gw.Labels = map[string]string{label.IoIstioRev.Name: revision}
		}
		return &gw, nil
	}
	waypointGenerateCmd := &cobra.Command{
		Use:   "generate",
		Short: "Generate a waypoint configuration",
		Long:  "Generate a waypoint configuration as YAML",
		Example: `  # Generate a waypoint as yaml
  istioctl waypoint generate --namespace default`,
		RunE: func(cmd *cobra.Command, args []string) error {

    private val builder: KaSymbolByFirBuilder,
    override val token: KaLifetimeToken
) : KaBuiltinTypes() {

    override val int: KaType by cachedBuiltin(builtinTypes.intType)
    override val long: KaType by cachedBuiltin(builtinTypes.longType)
    override val short: KaType by cachedBuiltin(builtinTypes.shortType)
    override val byte: KaType by cachedBuiltin(builtinTypes.byteType)

    private final ModuleVersionIdentifier id;
    private final ComponentMetaDataResolver resolver;
    private final List<NodeState> nodes = new LinkedList<>();
    private final Long resultId;
    private final ModuleResolveState module;
    private final List<ComponentSelectionDescriptorInternal> selectionCauses = new ArrayList<>();
    private final DefaultImmutableCapability implicitCapability;

import java.util.HashMap;
import java.util.Map;

public class DefaultResolvedConfigurationBuilder implements ResolvedConfigurationBuilder {
    private final Map<Long, Dependency> modulesMap = new HashMap<>();
    private final TransientConfigurationResultsBuilder builder;

    public DefaultResolvedConfigurationBuilder(TransientConfigurationResultsBuilder builder) {

class RootNode extends NodeState implements RootGraphNode {
    private final ResolveOptimizations resolveOptimizations;
    private final List<? extends DependencyMetadata> syntheticDependencies;

    RootNode(long resultId, ComponentState moduleRevision, ResolveState resolveState, List<? extends DependencyMetadata> syntheticDependencies, VariantGraphResolveState root) {
        super(resultId, moduleRevision, resolveState, root, false);

// On some systems the limit is 256, which is very easy to run into,
// even in simple programs like gofmt when they parallelize walking
// a file tree.
//
// After a long discussion on go.dev/issue/46279, we decided the
// best approach was for Go to raise the limit unconditionally for itself,
// and then leave old software to set the limit back as needed.

            val substitutor = buildSubstitutor {
                substitution(getSymbolByName(mainFile, "A"), builtinTypes.int)
                substitution(getSymbolByName(mainFile, "B"), builtinTypes.long)
                substitution(
                    getSymbolByName(mainFile, "C"),
                    buildClassType(StandardClassIds.List) {
                        argument(builtinTypes.string)
                    }

                // build session is cancelled, we can't guarantee that all worker daemons are in a safe state, so the cancellation
                // handler will stop any long-lived worker daemons.  If a worker is not used during this session (i.e. this method
                // is never called) the cancellation handler will not stop daemons on a cancellation (as there is no danger of

        Daemon daemon = daemonServices.get(Daemon.class);
        daemon.start();

        try {
            DaemonContext daemonContext = daemonServices.get(DaemonContext.class);
            Long pid = daemonContext.getPid();
            daemonStarted(pid, daemon.getUid(), daemon.getAddress(), daemonLog);
            DaemonExpirationStrategy expirationStrategy = daemonServices.get(MasterExpirationStrategy.class);

            throw new IllegalStateException("Expected to find a selector with a failure but none was found");
        }
        return selectedComponent.getMetadataResolveFailure();
    }

    @Override
    public Long getSelected() {
        return getSelectedComponent().getResultId();
    }

    @Override
    public boolean isTargetVirtualPlatform() {
        ComponentState selectedComponent = getSelectedComponent();