"istio.io/istio/tools/docker-builder/builder"
)

// Option is a functional option for remote operations.
type Option func(*options) error

type options struct {
	args       map[string]string
	ignoreRuns bool
	baseDir    string
}

// WithArgs sets the input args to the dockerfile
func WithArgs(a map[string]string) Option {
	return func(o *options) error {
		o.args = a
		return nil
	}
}

	Compact Option = compact
)

// TODO: option to preserve a normal form, if applicable?

type options struct {
	noLower bool
	simple  bool

	// TODO: segmenter, max ignorable, alternative versions, etc.

	ignoreFinalSigma bool
}

func getOpts(o ...Option) (res options) {
	for _, f := range o {
		res = f(res)
	}
	return
}

func noLower(o options) options {
	o.noLower = true

     */
    @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) {