this.outgoingConfiguration = outgoingConfiguration;
        }

        @Override
        public PublishArtifactSet getArtifacts() {
            return outgoingConfiguration.getArtifacts();
        }

        @Override
        public void artifact(Object notation) {
            throw new InvalidUserCodeException("Cannot add artifacts during filtering");
        }

        SelectedArtifactResults artifacts = artifactsResults.select(artifactVariantSelector, spec, false);
        return new DefaultSelectedArtifactSet(artifactSetResolver, graphResults, artifacts.getArtifacts(), resolutionHost);
    }

     */
    @Nullable
    VariantResolveMetadata.Identifier getIdentifier();

    @Override
    AttributeContainerInternal getAttributes();

    ResolvedArtifactSet getArtifacts();

    ImmutableCapabilities getCapabilities();

     * if any. Hence, the list returned by this method depends on which lifecycle step of the build was it invoked.
     * The head of returned list is result of {@link Project#getArtifacts()} method, so same applies here: the list can have
     * minimum of one element. The maximum number of elements is in turn dependent on build configuration and lifecycle

        boolean optional,
        @Nullable ConfigurationVariantMapping.DefaultDependencyMappingDetails dependencyMapping
    ) {
        super(name, ((AttributeContainerInternal)variant.getAttributes()).asImmutable(), variant.getArtifacts(), configuration);
        this.scopeMapping = ScopeMapping.of(mavenScope, optional);
        this.optional = optional;
        this.dependencyMapping = dependencyMapping;
    }

    @Override

        this.remoteRepositories = remoteRepositories;
    }

    public Artifact getOriginatingArtifact() {
        return originatingArtifact;
    }

    public List<Artifact> getArtifacts() {
        return artifacts;
    }

    public List<ArtifactRepository> getRemoteRepositories() {
        return remoteRepositories;
    }

     */
    @Nullable
    Identifier getIdentifier();

    DisplayName asDescribable();

    @Override
    ImmutableAttributes getAttributes();

    ImmutableList<? extends ComponentArtifactMetadata> getArtifacts();

    @Override
    ImmutableCapabilities getCapabilities();

    boolean isExternalVariant();

    /**
     * Is this variant eligible for caching?
     *

        return this;
    }

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

    @Override
    public ImmutableList<LocalComponentArtifactMetadata> getArtifacts() {
        return artifacts.get();
    }

     */
    @Nullable
    String getRevConstraint();

    /**
     * The requested artifacts for this dependency.
     */
    Set<DependencyArtifact> getArtifacts();

    /**
     * The exclude rules for this dependency.
     */
    Set<ExcludeRule> getExcludeRules();

     *
     * @since 7.5
     */
    @Incubating
    Optional<String> getDescription();

    /**
     * Returns the artifacts associated with this variant.
     */
    PublishArtifactSet getArtifacts();

    /**
     * Adds an artifact to this variant.
     *
     * <p>See {@link org.gradle.api.artifacts.dsl.ArtifactHandler} for details of the supported notations.
     */
    void artifact(Object notation);