@Override
    ImmutableAttributes getAttributes();

    ImmutableList<? extends ComponentArtifactMetadata> getArtifacts();

    @Override
    ImmutableCapabilities getCapabilities();

    boolean isExternalVariant();

    /**
     * Is this variant eligible for caching?
     *
     * Only variants from a project component are eligible for caching.
     *

                variant.getFiles(), variant.getCapabilities(), variantToDependencies.get(variant.getName()), variant.isExternalVariant()));
        }
        ImmutableList<AbstractRealisedModuleComponentResolveMetadata.ImmutableRealisedVariantImpl> realisedVariants = builder.build();

    MutableComponentVariant addVariant(String variantName, ImmutableAttributes attributes);

    AttributeContainer getAttributes();

    void setAttributes(AttributeContainer attributes);

    boolean isExternalVariant();

    void setExternalVariant(boolean externalVariant);

    boolean isComponentMetadataRuleCachingEnabled();

    void setComponentMetadataRuleCachingEnabled(boolean componentMetadataRuleCachingEnabled);

            getHierarchy(),
            getArtifacts(),
            getExcludes(),
            getAttributes(),
            getCapabilities(),
            dependencies,
            addedByRule,
            isExternalVariant()
        );
    }

    public boolean isAddedByRule() {
        return addedByRule;
    }

    @Nullable
    ImmutableAttributesFactory getAttributesFactory();

    VariantMetadataRules getVariantMetadataRules();

    VariantDerivationStrategy getVariantDerivationStrategy();

    boolean isExternalVariant();

    /*
     * When set to false component metadata rules are not cached.
     * Currently, we disable it just for local maven/ivy repository.
     *
     * Default value is true.
     */

    List<? extends DependencyMetadata> getDependencies();

    List<? extends ExcludeMetadata> getExcludes();

    ImmutableCapabilities getCapabilities();

    boolean isTransitive();

    boolean isExternalVariant();

    /**
     * Returns true if this variant is deprecated and consuming it in a dependency graph should emit a warning. False otherwise.
     */
    default boolean isDeprecated() {
        return false;

     */
    ComponentArtifactMetadata artifact(IvyArtifactName artifact);

    ImmutableCapabilities getCapabilities();

    boolean isExternalVariant();

        this.variantDerivationStrategy = metadata.getVariantDerivationStrategy();
        this.variantMetadataRules = new VariantMetadataRules(attributesFactory, moduleVersionId);
        this.externalVariant = metadata.isExternalVariant();
        this.isComponentMetadataRuleCachingEnabled = metadata.isComponentMetadataRuleCachingEnabled();
    }

    public boolean isVisible() {
        return visible;
    }

    @Override
    public boolean isCanBeConsumed() {
        return true;
    }

    @Override
    public boolean isExternalVariant() {
        return externalVariant;
    }

    public void setDependencies(List<ModuleDependencyMetadata> dependencies) {
        synchronized (lock) {

    public boolean isVisible() {
        return true;
    }

    @Override
    public boolean isCanBeConsumed() {
        return true;
    }

    @Override
    public boolean isExternalVariant() {
        return externalVariant;
    }