fss := cliflag.NamedFlagSets{}
	s.Generic.AddFlags(&fss, allControllers, disabledByDefaultControllers, controllerAliases)
	s.KubeCloudShared.AddFlags(fss.FlagSet("generic"))
	s.ServiceController.AddFlags(fss.FlagSet(cpnames.ServiceLBController))

	s.SecureServing.AddFlags(fss.FlagSet("secure serving"))
	s.Authentication.AddFlags(fss.FlagSet("authentication"))
	s.Authorization.AddFlags(fss.FlagSet("authorization"))

	pdfArgs := &profileDiffArgs{}
	args := &RootArgs{}

	plc := profileListCmd(plArgs)
	pdc := profileDumpCmd(pdArgs)
	pdfc := profileDiffCmd(pdfArgs)

	addFlags(pc, args)
	addFlags(plc, args)
	addFlags(pdc, args)
	addFlags(pdfc, args)

	addProfileDumpFlags(pdc, pdArgs)
	addProfileListFlags(plc, plArgs)
	addProfileDiffFlags(pdfc, pdfArgs)

	pc.AddCommand(plc)
	pc.AddCommand(pdc)

	}
}

func (o *RecommendedOptions) AddFlags(fs *pflag.FlagSet) {
	o.Etcd.AddFlags(fs)
	o.SecureServing.AddFlags(fs)
	o.Authentication.AddFlags(fs)
	o.Authorization.AddFlags(fs)
	o.Audit.AddFlags(fs)
	o.Features.AddFlags(fs)
	o.CoreAPI.AddFlags(fs)
	o.Admission.AddFlags(fs)
	o.EgressSelector.AddFlags(fs)
	o.Traces.AddFlags(fs)
}

// ApplyTo adds RecommendedOptions to the server configuration.

	return &s
}

func (s *Options) AddFlags(fss *cliflag.NamedFlagSets) {
	// Add the generic flags.
	s.GenericServerRunOptions.AddUniversalFlags(fss.FlagSet("generic"))
	s.Etcd.AddFlags(fss.FlagSet("etcd"))
	s.SecureServing.AddFlags(fss.FlagSet("secure serving"))
	s.Audit.AddFlags(fss.FlagSet("auditing"))
	s.Features.AddFlags(fss.FlagSet("features"))
	s.Authentication.AddFlags(fss.FlagSet("authentication"))

	defaultBool = true

	defaultDuration = 24 * time.Hour
)

func TestInitializeIntFlag(t *testing.T) {
	cmd := &cobra.Command{}
	var testInt int
	flag.IntVar(&testInt, "testint", defaultInt, "test int flag")
	AddFlags(cmd)

	testName := "Initialize int Flag"
	if !flag.Parsed() {
		t.Errorf("%s: flag.Parsed() returns false, should be true", testName)
	}

	cmd.Flags().VisitAll(func(f *pflag.Flag) {
		if f.Name != "testint" {

}

// AddFlags receives a *cobra.Command reference and binds
// flags related to JSON/Yaml/Name/Template printing to it
func (f *PrintFlags) AddFlags(cmd *cobra.Command) {
	f.JSONYamlPrintFlags.AddFlags(cmd)
	f.NamePrintFlags.AddFlags(cmd)
	f.TemplatePrinterFlags.AddFlags(cmd)

	if f.OutputFormat != nil {

	mdcArgs := &manifestDiffArgs{}

	args := &RootArgs{}

	mgc := ManifestGenerateCmd(ctx, args, mgcArgs)
	mdc := manifestDiffCmd(mdcArgs)
	ic := InstallCmd(ctx)

	addFlags(mc, args)
	addFlags(mgc, args)
	addFlags(mdc, args)

	addManifestGenerateFlags(mgc, mgcArgs)
	addManifestDiffFlags(mdc, mdcArgs)

	mc.AddCommand(mgc)
	mc.AddCommand(mdc)
	mc.AddCommand(ic)

	return mc

	orArgs := &operatorRemoveArgs{}
	args := &RootArgs{}

	odc := operatorDumpCmd(args, odArgs)
	oic := operatorInitCmd(ctx, args, oiArgs)
	orc := operatorRemoveCmd(ctx, args, orArgs)

	addFlags(odc, args)
	addFlags(oic, args)
	addFlags(orc, args)

	addOperatorDumpFlags(odc, odArgs)
	addOperatorInitFlags(oic, oiArgs)
	addOperatorRemoveFlags(orc, orArgs)

	oc.AddCommand(odc)
	oc.AddCommand(oic)
	oc.AddCommand(orc)

type EphemeralVolumeControllerOptions struct {
	*ephemeralvolumeconfig.EphemeralVolumeControllerConfiguration
}

// AddFlags adds flags related to EphemeralVolumeController for controller manager to the specified FlagSet.
func (o *EphemeralVolumeControllerOptions) AddFlags(fs *pflag.FlagSet) {
	if o == nil {
		return
	}

		StdOut: out,
		StdErr: errOut,
	}

	return o
}

// AddFlags adds the apiextensions-apiserver flags to the flagset.
func (o CustomResourceDefinitionsServerOptions) AddFlags(fs *pflag.FlagSet) {
	o.ServerRunOptions.AddUniversalFlags(fs)
	o.RecommendedOptions.AddFlags(fs)
	o.APIEnablement.AddFlags(fs)
}

// Validate validates the apiextensions-apiserver options.