* be migrated to {@link ExternalComponentGraphResolveState}</p>
 */
public interface ExternalComponentGraphResolveMetadata extends ComponentGraphResolveMetadata {

    /**
     * Returns the set of variants of this component to use for variant aware resolution of the dependency graph nodes.
     * May be empty, in which case selection falls back to an ecosystem-specific selection strategy.
     */

    interface LocalComponentGraphSelectionCandidates extends GraphSelectionCandidates {

        /**
         * Get all variants that can be selected for this component. This includes both:
         * <ul>
         *     <li>Variant with attributes: those which can be selected through attribute matching</li>
         *     <li>Variant without attributes: those which can be selected by configuration name</li>
         * </ul>
         */

        failure.assertThatCause(containsNormalizedString("The only attribute distinguishing these variants is 'org.gradle.testsuite.target.name'. Add this attribute to the consumer's configuration to resolve the ambiguity:"))
    }

    def "reports of multiple targets can be aggregated if variant information is specified"() {

        return selectLegacyConfigurations(variantSelector, consumerAttributes, targetComponentState, consumerSchema);
    }

    /**
     * Select target graph variants in an ecosystem-dependent manner.
     *
     * This method is called when the target component does not have variants to select from.
     */
    protected abstract GraphVariantSelectionResult selectLegacyConfigurations(
        GraphVariantSelector variantSelector,

        }
    }

    interface VariantVisitor {
        // This configuration as a variant. May not always be present
        void visitOwnVariant(DisplayName displayName, ImmutableAttributes attributes, Collection<? extends PublishArtifact> artifacts);

        // A child variant. May not always be present

    }

    def "each configuration contains a single variant containing the status attribute and the artifacts of the configuration"() {
        when:
        def runtime = metadata.getConfiguration("runtime")

        then:
        runtime.variants.size() == 1
        def firstVariant = runtime.variants.first()
        assertHasOnlyStatusAttribute(firstVariant.attributes)

     */
    @Nullable
    String getRepositoryId();

    /**
     * Returns all the variants of this component available for selection. Does not include variants that cannot be consumed, which means this
     * may not include all the variants returned by {@link #getVariants()}.
     *
     * <p>
     * Note: for performance reasons,

	// lots of varint sizes.
	//
	// Add 1 because we might also write a traceAllocFreeTypesBatch byte.
	var flushed bool
	w, flushed = w.ensure(1 + maxBytes)
	if flushed {
		// Annotate the batch as containing types.
		w.byte(byte(traceAllocFreeTypesBatch))
	}

	// Emit type.
	w.varint(uint64(node.id))
	w.varint(uint64(uintptr(unsafe.Pointer(typ))))
	w.varint(uint64(typ.Size()))

        result.selectionReason == ComponentSelectionReasons.requested()
        result.moduleVersion == newId('org', 'foo', '2.0')
        for (def variants : [result.selectedVariants, result.availableVariants]) {
            variants.size() == 2
            variants[0] == v1Result
            variants[1] == v2Result
        }
        result.repositoryId == 'repoName'
    }

    private byte[] serialize(ResolvedGraphComponent component) {

      f = @identity} : (tensor<!tf_type.variant<tensor<f32>>>) -> tensor<!tf_type.variant<tensor<f32>>>
  %2 = "tf.OptionalGetValue"(%1) : (tensor<!tf_type.variant<tensor<f32>>>) -> tensor<f32>
  %3 = "tf.OptionalNone"() : () -> tensor<!tf_type.variant<tensor<f32>>>
  return %2, %3 : tensor<f32>, tensor<!tf_type.variant<tensor<f32>>>
}

func.func private @identity(%arg0: tensor<!tf_type.variant<tensor<f32>>>) -> tensor<!tf_type.variant<tensor<f32>>> {