*/
    @Input
    @Optional
    @Option(option = "configuration", description = "The name of the configuration to report")
    public abstract Property<String> getConfigurationName();

    /**
     * Shows all configurations, including legacy and deprecated configurations.
     *
     * @return property holding the flag to show all configurations
     */
    @Input
    @Optional

    }

    /**
     * Should this include non-buildable components in the report?
     */
    @Console
    public boolean isShowNonBuildable() {
        return showNonBuildable;
    }

    @Option(option = "non-buildable", description = "Show non-buildable components.")
    public void setShowNonBuildable(boolean showNonBuildable) {
        this.showNonBuildable = showNonBuildable;
    }

    /**

    private boolean showHidden;
    private Format format = Format.FULL;

    @Option(option = "showHidden", description = "Show hidden model elements.")
    public void setShowHidden(boolean showHidden) {
        this.showHidden = showHidden;
    }

    @Console
    public boolean isShowHidden() {
        return showHidden;
    }

    @Option(option = "format", description = "Output format (full, short)")

    public StringsJavadocOptionFileOption(String option, List<String> value, String joinBy) {
        super(option, value, joinBy);
    }

    @Override
    public void writeCollectionValue(JavadocOptionFileWriterContext writerContext) throws IOException {
        writerContext.writeValuesOption(option, value, joinBy);
    }

    @Override
    public StringsJavadocOptionFileOption duplicate() {

            return [new TestOption(), new TestFlag()]
        }
    }

    private class TestOption extends StringBuildOption<Bean> {
        TestOption() {
            super("some.option", CommandLineOptionConfiguration.create("some-option", "an option"))
        }

        @Override
        void applyTo(String value, Bean settings, Origin origin) {
            settings.prop = value
        }
    }

                String optionName = optionDescriptor.getName();
                org.gradle.cli.CommandLineOption option = parser.option(optionName);
                option.hasDescription(optionDescriptor.getDescription());
                option.hasArgument(optionDescriptor.getArgumentType());
            }
            taskOptions.addMutualExclusions(parser);

            ParsedCommandLine parsed;

                for (BuildOption<? super T> option : getAllOptions()) {
                    option.applyFromCommandLine(args, target);
                }
                return target;
            }

            @Override
            public void configure(CommandLineParser parser) {
                for (BuildOption<? super T> option : getAllOptions()) {
                    option.configure(parser);
                }
            }

		node := fuzz.Struct[*model.Proxy](fg)
		selectionOpts := model.PolicyMatcherForProxy(node)
		policies := push.AuthzPolicies.ListAuthorizationPolicies(selectionOpts)
		option := fuzz.Struct[Option](fg)
		b := New(bundle, push, policies, option)
		if b == nil {
			fg.T().Skip()
			return // To help linter
		}
		b.BuildHTTP()
	})
}

func FuzzBuildTCP(f *testing.F) {
	fuzz.Fuzz(f, func(fg fuzz.Helper) {

@Requires(value = IntegTestPreconditions.NotParallelOrConfigCacheExecutor, reason = "--parallel or configuration-cache options unavailable")
class TaskOptionsSpec extends AbstractIntegrationSpec {

    def defineTaskWithProfileOption() {
        return """
                abstract class MyTask extends DefaultTask {
                    @Option(option="profile", description="foobar")
                    @Optional
                    @Input

			return nil, err
		}
	}

	return params, nil
}

// Name unique name for an option.
type Name string

func (n Name) String() string {
	return string(n)
}

// Instance of a bootstrap option.
type Instance interface {
	Name() Name

	// apply this option to the given template parameter map.
	apply(map[string]any) error
}

var _ Instance = &instance{}

type (