// If this value is empty, the default value (5min) will be used.
	PodMaxInUnschedulablePodsDuration time.Duration
}

// AddFlags adds flags for the deprecated options.
func (o *DeprecatedOptions) AddFlags(fs *pflag.FlagSet) {
	if o == nil {
		return
	}

	*endpointslicemirroringconfig.EndpointSliceMirroringControllerConfiguration
}

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

type NodeLifecycleControllerOptions struct {
	*nodelifecycleconfig.NodeLifecycleControllerConfiguration
}

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

	fs.DurationVar(&o.NodeStartupGracePeriod.Duration, "node-startup-grace-period", o.NodeStartupGracePeriod.Duration,

        createOptions,
        impersonationLevel;
    private long allocationSize;
    private byte securityFlags;
    private int namelen_index;

int flags0, desiredAccess;

    SmbComNTCreateAndX( String name, int flags,
                int access,
                int shareAccess,
                int extFileAttributes,
                int createOptions,
                ServerMessageBlock andx ) {
        super( andx );

type PersistentVolumeBinderControllerOptions struct {
	*persistentvolumeconfig.PersistentVolumeBinderControllerConfiguration
}

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

	options.DefaultOffPlugins = DefaultOffAdmissionPlugins()

	return &AdmissionOptions{
		GenericAdmission: options,
	}
}

// AddFlags adds flags related to admission for kube-apiserver to the specified FlagSet
func (a *AdmissionOptions) AddFlags(fs *pflag.FlagSet) {
	if a == nil {
		return
	}
	fs.StringSliceVar(&a.PluginNames, "admission-control", a.PluginNames, ""+
		"Admission is divided into two phases. "+

		),
		APIEnablement: genericoptions.NewAPIEnablementOptions(),

		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.

	"k8s.io/klog/v2"

	"k8s.io/kubernetes/cmd/kubeadm/app/cmd"
)

// Run creates and executes new kubeadm command
func Run() error {
	var allFlags flag.FlagSet
	klog.InitFlags(&allFlags)
	// only add the flags that are still supported for kubeadm
	allFlags.VisitAll(func(f *flag.Flag) {
		switch f.Name {
		case "v", "add_dir_header", "skip_headers":
			flag.CommandLine.Var(f.Value, f.Name, f.Usage)
		}

See the License for the specific language governing permissions and
limitations under the License.
*/

package options

import (
	"github.com/spf13/pflag"
)

func (f *KubeletFlags) addOSFlags(fs *pflag.FlagSet) {
	fs.BoolVar(&f.WindowsService, "windows-service", f.WindowsService, "Enable Windows Service Control Manager API integration")

func NewAPIEnablementOptions() *APIEnablementOptions {
	return &APIEnablementOptions{
		RuntimeConfig: make(cliflag.ConfigurationMap),
	}
}

// AddFlags adds flags for a specific APIServer to the specified FlagSet
func (s *APIEnablementOptions) AddFlags(fs *pflag.FlagSet) {
	if s == nil {
		return
	}
	fs.Var(&s.RuntimeConfig, "runtime-config", ""+
		"A set of key=value pairs that enable or disable built-in APIs. Supported options are:\n"+