defaultConfig.transitive
        defaultConfig.visible
        defaultConfig.artifacts.name.name == ["api.jar", "runtime.jar"]
        defaultConfig.excludes.empty

        and:
        def copy = immutable.asMutable()
        copy != metadata
        copy.id == id
        copy.sources == new MutableModuleSources()
        copy.statusScheme == ExternalComponentResolveMetadata.DEFAULT_STATUS_SCHEME
        copy.branch == null

        }
        return null;
    }

    @Nullable
    @Override
    public <T> ModelView<? extends T> asMutable(ModelType<T> type, MutableModelNode node, ModelRuleDescriptor ruleDescriptor) {
        for (ModelProjection projection : projections) {
            ModelView<? extends T> view = projection.asMutable(type, node, ruleDescriptor);
            if (view != null) {
                return view;
            }
        }

 */
public interface MavenModuleResolveMetadata extends ModuleComponentResolveMetadata {
    /**
     * {@inheritDoc}
     */
    @Override
    MutableMavenModuleResolveMetadata asMutable();

    @Nonnull String getPackaging();
    boolean isRelocated();
    boolean isPomPackaging();
    boolean isKnownJarPackaging();
    @Nullable
    String getSnapshotTimestamp();

public interface ModelAdapter {

    @Nullable
    <T> ModelView<? extends T> asImmutable(ModelType<T> type, MutableModelNode node, @Nullable ModelRuleDescriptor ruleDescriptor);

    @Nullable
    <T> ModelView<? extends T> asMutable(ModelType<T> type, MutableModelNode node, ModelRuleDescriptor ruleDescriptor);

    Optional<String> getValueDescription(MutableModelNode mutableModelNode);

        return null;
    }

    @Nullable
    @Override
    public <T> ModelView<? extends T> asMutable(ModelType<T> type, MutableModelNode node, ModelRuleDescriptor ruleDescriptor) {
        return null;
    }

    @Override
    public <T> boolean canBeViewedAs(ModelType<T> type) {
        return false;
    }

        def node = createNode(publicType, implType, componentId);
        return node.asMutable(ModelType.of(publicType), new SimpleModelRuleDescriptor(componentId.getName())).getInstance()
    }

                    propertyNode.ensureUsable();

                    ModelView<? extends T> modelView;
                    if (writable) {
                        modelView = propertyNode.asMutable(propertyType, ruleDescriptor);
                        if (state.isClosed()) {
                            modelView.close();
                        }
                    } else {

        assert mapNode != null;
        return mapNode;
    }

    public static <T> ModelMap<T> toView(MutableModelNode mapNode, ModelType<T> elementModelType) {
        mapNode.ensureUsable();
        return mapNode.asMutable(
                ModelTypes.modelMap(elementModelType),
                RuleContext.get()
        ).getInstance();
    }

 */
public interface IvyModuleResolveMetadata extends ModuleComponentResolveMetadata {
    /**
     * {@inheritDoc}
     */
    @Override
    MutableIvyModuleResolveMetadata asMutable();

    /**
     * Returns the branch attribute for the module.
     *
     * @return the branch attribute for the module
     */
    @Nullable
    String getBranch();

    /**

        return targetType.isAssignableFrom(type)
            || (ModelType.UNTYPED.equals(targetType) && isPrimitiveType(type));
    }

    @Override
    public <T> ModelView<? extends T> asMutable(ModelType<T> type, MutableModelNode modelNode, ModelRuleDescriptor ruleDescriptor) {
        if (canBeViewedAs(type)) {
            return Cast.uncheckedCast(toView(modelNode, ruleDescriptor, true));
        } else {