etcdOptions.SkipHealthEndpoints = true // avoid double wiring of health checks
	if err := etcdOptions.ApplyTo(&genericConfig); err != nil {
		return nil, err
	}

	// override MergedResourceConfig with apiextensions defaults and registry
	if err := commandOptions.APIEnablement.ApplyTo(
		&genericConfig,
		apiextensionsapiserver.DefaultAPIResourceConfigSource(),
		apiextensionsapiserver.Scheme); err != nil {

            if (rejectedComponent != null) {
                resolveResult.missing();
            }
        }
    }

    protected void applyTo(ResourceAwareResolveResult result) {
        resolveResult.applyTo(result);
    }

    public boolean canMakeFurtherAttempts() {
        return !searchedRemotely;
    }

        def result = toResult(args, overrides)

        def parameters = new BuildLayoutParameters()
        result.applyTo(parameters)

        assert result.gradleUserHomeDir == parameters.gradleUserHomeDir

        def startParameters = new StartParameterInternal()
        result.applyTo(startParameters)

        assert startParameters.gradleUserHomeDir == parameters.gradleUserHomeDir

    @Override
    public boolean shouldUseGradleMetatada() {
        return state == State.Redirect;
    }

    public <S> void applyTo(BuildableModuleComponentMetaDataResolveResult<S> target, Function<T, S> resultMapper) {
        if (state == State.Resolved) {
            target.resolved(resultMapper.apply(metaData));
        } else if (state == State.Failed) {
            target.failed(failure);
        } else if (state == State.Redirect) {

        }

        @Override
        public void applyTo(boolean value, ParallelismConfiguration settings, Origin origin) {
            settings.setParallelProjectExecutionEnabled(value);
        }
    }

}

// ApplyTo fills up PersistentVolumeBinderController config with options.
func (o *PersistentVolumeBinderControllerOptions) ApplyTo(cfg *persistentvolumeconfig.PersistentVolumeBinderControllerConfiguration) error {
	if o == nil {
		return nil
	}

		"A human friendly description of how this token is used.",
	)
}

// ApplyTo applies the values set internally in the BootstrapTokenOptions object to a InitConfiguration object at runtime
// If --token was specified in the CLI (as a string), it's parsed and validated before it's added to the BootstrapToken object.
func (bto *BootstrapTokenOptions) ApplyTo(cfg *kubeadmapiv1.InitConfiguration) error {
	if len(bto.TokenStr) > 0 {
		var err error

	}
	if len(groups) != 0 {
		errors = append(errors, fmt.Errorf("unknown api groups %s", strings.Join(groups, ",")))
	}

	return errors
}

// ApplyTo override MergedResourceConfig with defaults and registry
func (s *APIEnablementOptions) ApplyTo(c *server.Config, defaultResourceConfig *serverstore.ResourceConfig, registry resourceconfig.GroupVersionRegistry) error {
	if s == nil {
		return nil
	}

}

// ApplyTo fills up AttachDetachController config with options.
func (o *AttachDetachControllerOptions) ApplyTo(cfg *attachdetachconfig.AttachDetachControllerConfiguration) error {
	if o == nil {
		return nil
	}

        result.getFound(request).applyTo(pluginManager)

        then:
        1 * pluginManager.apply(impl)
        1 * pluginRegistry.lookup(DefaultPluginId.of("foo")) >> impl
    }

    def "can resolve qualified"() {
        when:
        def request = request("org.gradle.foo")
        def result = resolver.resolve(request)
        result.getFound(request).applyTo(pluginManager)

        then: