pulumiTypes.go

// Code generated by pulumi-language-go DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package k0s

import (
	"context"
	"reflect"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"internal"
)

var _ = internal.GetEnvOrDefault

type ClusterFile struct {
	DirPerm *string `pulumi:"dirPerm"`
	Dst     *string `pulumi:"dst"`
	DstDir  *string `pulumi:"dstDir"`
	Group   *string `pulumi:"group"`
	Name    *string `pulumi:"name"`
	Perm    *string `pulumi:"perm"`
	Src     *string `pulumi:"src"`
	User    *string `pulumi:"user"`
}

// ClusterFileInput is an input type that accepts ClusterFileArgs and ClusterFileOutput values.
// You can construct a concrete instance of `ClusterFileInput` via:
//
//	ClusterFileArgs{...}
type ClusterFileInput interface {
	pulumi.Input

	ToClusterFileOutput() ClusterFileOutput
	ToClusterFileOutputWithContext(context.Context) ClusterFileOutput
}

type ClusterFileArgs struct {
	DirPerm pulumi.StringPtrInput `pulumi:"dirPerm"`
	Dst     pulumi.StringPtrInput `pulumi:"dst"`
	DstDir  pulumi.StringPtrInput `pulumi:"dstDir"`
	Group   pulumi.StringPtrInput `pulumi:"group"`
	Name    pulumi.StringPtrInput `pulumi:"name"`
	Perm    pulumi.StringPtrInput `pulumi:"perm"`
	Src     pulumi.StringPtrInput `pulumi:"src"`
	User    pulumi.StringPtrInput `pulumi:"user"`
}

func (ClusterFileArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterFile)(nil)).Elem()
}

func (i ClusterFileArgs) ToClusterFileOutput() ClusterFileOutput {
	return i.ToClusterFileOutputWithContext(context.Background())
}

func (i ClusterFileArgs) ToClusterFileOutputWithContext(ctx context.Context) ClusterFileOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterFileOutput)
}

// ClusterFileArrayInput is an input type that accepts ClusterFileArray and ClusterFileArrayOutput values.
// You can construct a concrete instance of `ClusterFileArrayInput` via:
//
//	ClusterFileArray{ ClusterFileArgs{...} }
type ClusterFileArrayInput interface {
	pulumi.Input

	ToClusterFileArrayOutput() ClusterFileArrayOutput
	ToClusterFileArrayOutputWithContext(context.Context) ClusterFileArrayOutput
}

type ClusterFileArray []ClusterFileInput

func (ClusterFileArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ClusterFile)(nil)).Elem()
}

func (i ClusterFileArray) ToClusterFileArrayOutput() ClusterFileArrayOutput {
	return i.ToClusterFileArrayOutputWithContext(context.Background())
}

func (i ClusterFileArray) ToClusterFileArrayOutputWithContext(ctx context.Context) ClusterFileArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterFileArrayOutput)
}

type ClusterFileOutput struct{ *pulumi.OutputState }

func (ClusterFileOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterFile)(nil)).Elem()
}

func (o ClusterFileOutput) ToClusterFileOutput() ClusterFileOutput {
	return o
}

func (o ClusterFileOutput) ToClusterFileOutputWithContext(ctx context.Context) ClusterFileOutput {
	return o
}

func (o ClusterFileOutput) DirPerm() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterFile) *string { return v.DirPerm }).(pulumi.StringPtrOutput)
}

func (o ClusterFileOutput) Dst() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterFile) *string { return v.Dst }).(pulumi.StringPtrOutput)
}

func (o ClusterFileOutput) DstDir() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterFile) *string { return v.DstDir }).(pulumi.StringPtrOutput)
}

func (o ClusterFileOutput) Group() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterFile) *string { return v.Group }).(pulumi.StringPtrOutput)
}

func (o ClusterFileOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterFile) *string { return v.Name }).(pulumi.StringPtrOutput)
}

func (o ClusterFileOutput) Perm() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterFile) *string { return v.Perm }).(pulumi.StringPtrOutput)
}

func (o ClusterFileOutput) Src() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterFile) *string { return v.Src }).(pulumi.StringPtrOutput)
}

func (o ClusterFileOutput) User() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterFile) *string { return v.User }).(pulumi.StringPtrOutput)
}

type ClusterFileArrayOutput struct{ *pulumi.OutputState }

func (ClusterFileArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ClusterFile)(nil)).Elem()
}

func (o ClusterFileArrayOutput) ToClusterFileArrayOutput() ClusterFileArrayOutput {
	return o
}

func (o ClusterFileArrayOutput) ToClusterFileArrayOutputWithContext(ctx context.Context) ClusterFileArrayOutput {
	return o
}

func (o ClusterFileArrayOutput) Index(i pulumi.IntInput) ClusterFileOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ClusterFile {
		return vs[0].([]ClusterFile)[vs[1].(int)]
	}).(ClusterFileOutput)
}

type ClusterHook struct {
	After  []string `pulumi:"after"`
	Before []string `pulumi:"before"`
}

// ClusterHookInput is an input type that accepts ClusterHookArgs and ClusterHookOutput values.
// You can construct a concrete instance of `ClusterHookInput` via:
//
//	ClusterHookArgs{...}
type ClusterHookInput interface {
	pulumi.Input

	ToClusterHookOutput() ClusterHookOutput
	ToClusterHookOutputWithContext(context.Context) ClusterHookOutput
}

type ClusterHookArgs struct {
	After  pulumi.StringArrayInput `pulumi:"after"`
	Before pulumi.StringArrayInput `pulumi:"before"`
}

func (ClusterHookArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterHook)(nil)).Elem()
}

func (i ClusterHookArgs) ToClusterHookOutput() ClusterHookOutput {
	return i.ToClusterHookOutputWithContext(context.Background())
}

func (i ClusterHookArgs) ToClusterHookOutputWithContext(ctx context.Context) ClusterHookOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterHookOutput)
}

func (i ClusterHookArgs) ToClusterHookPtrOutput() ClusterHookPtrOutput {
	return i.ToClusterHookPtrOutputWithContext(context.Background())
}

func (i ClusterHookArgs) ToClusterHookPtrOutputWithContext(ctx context.Context) ClusterHookPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterHookOutput).ToClusterHookPtrOutputWithContext(ctx)
}

// ClusterHookPtrInput is an input type that accepts ClusterHookArgs, ClusterHookPtr and ClusterHookPtrOutput values.
// You can construct a concrete instance of `ClusterHookPtrInput` via:
//
//	        ClusterHookArgs{...}
//
//	or:
//
//	        nil
type ClusterHookPtrInput interface {
	pulumi.Input

	ToClusterHookPtrOutput() ClusterHookPtrOutput
	ToClusterHookPtrOutputWithContext(context.Context) ClusterHookPtrOutput
}

type clusterHookPtrType ClusterHookArgs

func ClusterHookPtr(v *ClusterHookArgs) ClusterHookPtrInput {
	return (*clusterHookPtrType)(v)
}

func (*clusterHookPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterHook)(nil)).Elem()
}

func (i *clusterHookPtrType) ToClusterHookPtrOutput() ClusterHookPtrOutput {
	return i.ToClusterHookPtrOutputWithContext(context.Background())
}

func (i *clusterHookPtrType) ToClusterHookPtrOutputWithContext(ctx context.Context) ClusterHookPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterHookPtrOutput)
}

type ClusterHookOutput struct{ *pulumi.OutputState }

func (ClusterHookOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterHook)(nil)).Elem()
}

func (o ClusterHookOutput) ToClusterHookOutput() ClusterHookOutput {
	return o
}

func (o ClusterHookOutput) ToClusterHookOutputWithContext(ctx context.Context) ClusterHookOutput {
	return o
}

func (o ClusterHookOutput) ToClusterHookPtrOutput() ClusterHookPtrOutput {
	return o.ToClusterHookPtrOutputWithContext(context.Background())
}

func (o ClusterHookOutput) ToClusterHookPtrOutputWithContext(ctx context.Context) ClusterHookPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ClusterHook) *ClusterHook {
		return &v
	}).(ClusterHookPtrOutput)
}

func (o ClusterHookOutput) After() pulumi.StringArrayOutput {
	return o.ApplyT(func(v ClusterHook) []string { return v.After }).(pulumi.StringArrayOutput)
}

func (o ClusterHookOutput) Before() pulumi.StringArrayOutput {
	return o.ApplyT(func(v ClusterHook) []string { return v.Before }).(pulumi.StringArrayOutput)
}

type ClusterHookPtrOutput struct{ *pulumi.OutputState }

func (ClusterHookPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterHook)(nil)).Elem()
}

func (o ClusterHookPtrOutput) ToClusterHookPtrOutput() ClusterHookPtrOutput {
	return o
}

func (o ClusterHookPtrOutput) ToClusterHookPtrOutputWithContext(ctx context.Context) ClusterHookPtrOutput {
	return o
}

func (o ClusterHookPtrOutput) Elem() ClusterHookOutput {
	return o.ApplyT(func(v *ClusterHook) ClusterHook {
		if v != nil {
			return *v
		}
		var ret ClusterHook
		return ret
	}).(ClusterHookOutput)
}

func (o ClusterHookPtrOutput) After() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *ClusterHook) []string {
		if v == nil {
			return nil
		}
		return v.After
	}).(pulumi.StringArrayOutput)
}

func (o ClusterHookPtrOutput) Before() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *ClusterHook) []string {
		if v == nil {
			return nil
		}
		return v.Before
	}).(pulumi.StringArrayOutput)
}

type ClusterHooks struct {
	Apply  *ClusterHook `pulumi:"apply"`
	Backup *ClusterHook `pulumi:"backup"`
	Reset  *ClusterHook `pulumi:"reset"`
}

// ClusterHooksInput is an input type that accepts ClusterHooksArgs and ClusterHooksOutput values.
// You can construct a concrete instance of `ClusterHooksInput` via:
//
//	ClusterHooksArgs{...}
type ClusterHooksInput interface {
	pulumi.Input

	ToClusterHooksOutput() ClusterHooksOutput
	ToClusterHooksOutputWithContext(context.Context) ClusterHooksOutput
}

type ClusterHooksArgs struct {
	Apply  ClusterHookPtrInput `pulumi:"apply"`
	Backup ClusterHookPtrInput `pulumi:"backup"`
	Reset  ClusterHookPtrInput `pulumi:"reset"`
}

func (ClusterHooksArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterHooks)(nil)).Elem()
}

func (i ClusterHooksArgs) ToClusterHooksOutput() ClusterHooksOutput {
	return i.ToClusterHooksOutputWithContext(context.Background())
}

func (i ClusterHooksArgs) ToClusterHooksOutputWithContext(ctx context.Context) ClusterHooksOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterHooksOutput)
}

func (i ClusterHooksArgs) ToClusterHooksPtrOutput() ClusterHooksPtrOutput {
	return i.ToClusterHooksPtrOutputWithContext(context.Background())
}

func (i ClusterHooksArgs) ToClusterHooksPtrOutputWithContext(ctx context.Context) ClusterHooksPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterHooksOutput).ToClusterHooksPtrOutputWithContext(ctx)
}

// ClusterHooksPtrInput is an input type that accepts ClusterHooksArgs, ClusterHooksPtr and ClusterHooksPtrOutput values.
// You can construct a concrete instance of `ClusterHooksPtrInput` via:
//
//	        ClusterHooksArgs{...}
//
//	or:
//
//	        nil
type ClusterHooksPtrInput interface {
	pulumi.Input

	ToClusterHooksPtrOutput() ClusterHooksPtrOutput
	ToClusterHooksPtrOutputWithContext(context.Context) ClusterHooksPtrOutput
}

type clusterHooksPtrType ClusterHooksArgs

func ClusterHooksPtr(v *ClusterHooksArgs) ClusterHooksPtrInput {
	return (*clusterHooksPtrType)(v)
}

func (*clusterHooksPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterHooks)(nil)).Elem()
}

func (i *clusterHooksPtrType) ToClusterHooksPtrOutput() ClusterHooksPtrOutput {
	return i.ToClusterHooksPtrOutputWithContext(context.Background())
}

func (i *clusterHooksPtrType) ToClusterHooksPtrOutputWithContext(ctx context.Context) ClusterHooksPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterHooksPtrOutput)
}

type ClusterHooksOutput struct{ *pulumi.OutputState }

func (ClusterHooksOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterHooks)(nil)).Elem()
}

func (o ClusterHooksOutput) ToClusterHooksOutput() ClusterHooksOutput {
	return o
}

func (o ClusterHooksOutput) ToClusterHooksOutputWithContext(ctx context.Context) ClusterHooksOutput {
	return o
}

func (o ClusterHooksOutput) ToClusterHooksPtrOutput() ClusterHooksPtrOutput {
	return o.ToClusterHooksPtrOutputWithContext(context.Background())
}

func (o ClusterHooksOutput) ToClusterHooksPtrOutputWithContext(ctx context.Context) ClusterHooksPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ClusterHooks) *ClusterHooks {
		return &v
	}).(ClusterHooksPtrOutput)
}

func (o ClusterHooksOutput) Apply() ClusterHookPtrOutput {
	return o.ApplyT(func(v ClusterHooks) *ClusterHook { return v.Apply }).(ClusterHookPtrOutput)
}

func (o ClusterHooksOutput) Backup() ClusterHookPtrOutput {
	return o.ApplyT(func(v ClusterHooks) *ClusterHook { return v.Backup }).(ClusterHookPtrOutput)
}

func (o ClusterHooksOutput) Reset() ClusterHookPtrOutput {
	return o.ApplyT(func(v ClusterHooks) *ClusterHook { return v.Reset }).(ClusterHookPtrOutput)
}

type ClusterHooksPtrOutput struct{ *pulumi.OutputState }

func (ClusterHooksPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterHooks)(nil)).Elem()
}

func (o ClusterHooksPtrOutput) ToClusterHooksPtrOutput() ClusterHooksPtrOutput {
	return o
}

func (o ClusterHooksPtrOutput) ToClusterHooksPtrOutputWithContext(ctx context.Context) ClusterHooksPtrOutput {
	return o
}

func (o ClusterHooksPtrOutput) Elem() ClusterHooksOutput {
	return o.ApplyT(func(v *ClusterHooks) ClusterHooks {
		if v != nil {
			return *v
		}
		var ret ClusterHooks
		return ret
	}).(ClusterHooksOutput)
}

func (o ClusterHooksPtrOutput) Apply() ClusterHookPtrOutput {
	return o.ApplyT(func(v *ClusterHooks) *ClusterHook {
		if v == nil {
			return nil
		}
		return v.Apply
	}).(ClusterHookPtrOutput)
}

func (o ClusterHooksPtrOutput) Backup() ClusterHookPtrOutput {
	return o.ApplyT(func(v *ClusterHooks) *ClusterHook {
		if v == nil {
			return nil
		}
		return v.Backup
	}).(ClusterHookPtrOutput)
}

func (o ClusterHooksPtrOutput) Reset() ClusterHookPtrOutput {
	return o.ApplyT(func(v *ClusterHooks) *ClusterHook {
		if v == nil {
			return nil
		}
		return v.Reset
	}).(ClusterHookPtrOutput)
}

type ClusterHost struct {
	Environment      map[string]string `pulumi:"environment"`
	Files            []ClusterFile     `pulumi:"files"`
	Hooks            *ClusterHooks     `pulumi:"hooks"`
	Hostname         *string           `pulumi:"hostname"`
	InstallFlags     []string          `pulumi:"installFlags"`
	K0sBinaryPath    *string           `pulumi:"k0sBinaryPath"`
	Localhost        *ClusterLocalhost `pulumi:"localhost"`
	NoTaints         *bool             `pulumi:"noTaints"`
	Os               *string           `pulumi:"os"`
	PrivateAddress   *string           `pulumi:"privateAddress"`
	PrivateInterface *string           `pulumi:"privateInterface"`
	Role             string            `pulumi:"role"`
	Ssh              *ClusterSSH       `pulumi:"ssh"`
	UploadBinary     *bool             `pulumi:"uploadBinary"`
	WinRM            *ClusterWinRM     `pulumi:"winRM"`
}

// ClusterHostInput is an input type that accepts ClusterHostArgs and ClusterHostOutput values.
// You can construct a concrete instance of `ClusterHostInput` via:
//
//	ClusterHostArgs{...}
type ClusterHostInput interface {
	pulumi.Input

	ToClusterHostOutput() ClusterHostOutput
	ToClusterHostOutputWithContext(context.Context) ClusterHostOutput
}

type ClusterHostArgs struct {
	Environment      pulumi.StringMapInput    `pulumi:"environment"`
	Files            ClusterFileArrayInput    `pulumi:"files"`
	Hooks            ClusterHooksPtrInput     `pulumi:"hooks"`
	Hostname         pulumi.StringPtrInput    `pulumi:"hostname"`
	InstallFlags     pulumi.StringArrayInput  `pulumi:"installFlags"`
	K0sBinaryPath    pulumi.StringPtrInput    `pulumi:"k0sBinaryPath"`
	Localhost        ClusterLocalhostPtrInput `pulumi:"localhost"`
	NoTaints         pulumi.BoolPtrInput      `pulumi:"noTaints"`
	Os               pulumi.StringPtrInput    `pulumi:"os"`
	PrivateAddress   pulumi.StringPtrInput    `pulumi:"privateAddress"`
	PrivateInterface pulumi.StringPtrInput    `pulumi:"privateInterface"`
	Role             pulumi.StringInput       `pulumi:"role"`
	Ssh              ClusterSSHPtrInput       `pulumi:"ssh"`
	UploadBinary     pulumi.BoolPtrInput      `pulumi:"uploadBinary"`
	WinRM            ClusterWinRMPtrInput     `pulumi:"winRM"`
}

func (ClusterHostArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterHost)(nil)).Elem()
}

func (i ClusterHostArgs) ToClusterHostOutput() ClusterHostOutput {
	return i.ToClusterHostOutputWithContext(context.Background())
}

func (i ClusterHostArgs) ToClusterHostOutputWithContext(ctx context.Context) ClusterHostOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterHostOutput)
}

// ClusterHostArrayInput is an input type that accepts ClusterHostArray and ClusterHostArrayOutput values.
// You can construct a concrete instance of `ClusterHostArrayInput` via:
//
//	ClusterHostArray{ ClusterHostArgs{...} }
type ClusterHostArrayInput interface {
	pulumi.Input

	ToClusterHostArrayOutput() ClusterHostArrayOutput
	ToClusterHostArrayOutputWithContext(context.Context) ClusterHostArrayOutput
}

type ClusterHostArray []ClusterHostInput

func (ClusterHostArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ClusterHost)(nil)).Elem()
}

func (i ClusterHostArray) ToClusterHostArrayOutput() ClusterHostArrayOutput {
	return i.ToClusterHostArrayOutputWithContext(context.Background())
}

func (i ClusterHostArray) ToClusterHostArrayOutputWithContext(ctx context.Context) ClusterHostArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterHostArrayOutput)
}

type ClusterHostOutput struct{ *pulumi.OutputState }

func (ClusterHostOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterHost)(nil)).Elem()
}

func (o ClusterHostOutput) ToClusterHostOutput() ClusterHostOutput {
	return o
}

func (o ClusterHostOutput) ToClusterHostOutputWithContext(ctx context.Context) ClusterHostOutput {
	return o
}

func (o ClusterHostOutput) Environment() pulumi.StringMapOutput {
	return o.ApplyT(func(v ClusterHost) map[string]string { return v.Environment }).(pulumi.StringMapOutput)
}

func (o ClusterHostOutput) Files() ClusterFileArrayOutput {
	return o.ApplyT(func(v ClusterHost) []ClusterFile { return v.Files }).(ClusterFileArrayOutput)
}

func (o ClusterHostOutput) Hooks() ClusterHooksPtrOutput {
	return o.ApplyT(func(v ClusterHost) *ClusterHooks { return v.Hooks }).(ClusterHooksPtrOutput)
}

func (o ClusterHostOutput) Hostname() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterHost) *string { return v.Hostname }).(pulumi.StringPtrOutput)
}

func (o ClusterHostOutput) InstallFlags() pulumi.StringArrayOutput {
	return o.ApplyT(func(v ClusterHost) []string { return v.InstallFlags }).(pulumi.StringArrayOutput)
}

func (o ClusterHostOutput) K0sBinaryPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterHost) *string { return v.K0sBinaryPath }).(pulumi.StringPtrOutput)
}

func (o ClusterHostOutput) Localhost() ClusterLocalhostPtrOutput {
	return o.ApplyT(func(v ClusterHost) *ClusterLocalhost { return v.Localhost }).(ClusterLocalhostPtrOutput)
}

func (o ClusterHostOutput) NoTaints() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ClusterHost) *bool { return v.NoTaints }).(pulumi.BoolPtrOutput)
}

func (o ClusterHostOutput) Os() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterHost) *string { return v.Os }).(pulumi.StringPtrOutput)
}

func (o ClusterHostOutput) PrivateAddress() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterHost) *string { return v.PrivateAddress }).(pulumi.StringPtrOutput)
}

func (o ClusterHostOutput) PrivateInterface() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterHost) *string { return v.PrivateInterface }).(pulumi.StringPtrOutput)
}

func (o ClusterHostOutput) Role() pulumi.StringOutput {
	return o.ApplyT(func(v ClusterHost) string { return v.Role }).(pulumi.StringOutput)
}

func (o ClusterHostOutput) Ssh() ClusterSSHPtrOutput {
	return o.ApplyT(func(v ClusterHost) *ClusterSSH { return v.Ssh }).(ClusterSSHPtrOutput)
}

func (o ClusterHostOutput) UploadBinary() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ClusterHost) *bool { return v.UploadBinary }).(pulumi.BoolPtrOutput)
}

func (o ClusterHostOutput) WinRM() ClusterWinRMPtrOutput {
	return o.ApplyT(func(v ClusterHost) *ClusterWinRM { return v.WinRM }).(ClusterWinRMPtrOutput)
}

type ClusterHostArrayOutput struct{ *pulumi.OutputState }

func (ClusterHostArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ClusterHost)(nil)).Elem()
}

func (o ClusterHostArrayOutput) ToClusterHostArrayOutput() ClusterHostArrayOutput {
	return o
}

func (o ClusterHostArrayOutput) ToClusterHostArrayOutputWithContext(ctx context.Context) ClusterHostArrayOutput {
	return o
}

func (o ClusterHostArrayOutput) Index(i pulumi.IntInput) ClusterHostOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ClusterHost {
		return vs[0].([]ClusterHost)[vs[1].(int)]
	}).(ClusterHostOutput)
}

type ClusterK0s struct {
	Config         *K0s    `pulumi:"config"`
	DynamicConfig  *bool   `pulumi:"dynamicConfig"`
	Version        *string `pulumi:"version"`
	VersionChannel *string `pulumi:"versionChannel"`
}

// ClusterK0sInput is an input type that accepts ClusterK0sArgs and ClusterK0sOutput values.
// You can construct a concrete instance of `ClusterK0sInput` via:
//
//	ClusterK0sArgs{...}
type ClusterK0sInput interface {
	pulumi.Input

	ToClusterK0sOutput() ClusterK0sOutput
	ToClusterK0sOutputWithContext(context.Context) ClusterK0sOutput
}

type ClusterK0sArgs struct {
	Config         K0sPtrInput           `pulumi:"config"`
	DynamicConfig  pulumi.BoolPtrInput   `pulumi:"dynamicConfig"`
	Version        pulumi.StringPtrInput `pulumi:"version"`
	VersionChannel pulumi.StringPtrInput `pulumi:"versionChannel"`
}

func (ClusterK0sArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterK0s)(nil)).Elem()
}

func (i ClusterK0sArgs) ToClusterK0sOutput() ClusterK0sOutput {
	return i.ToClusterK0sOutputWithContext(context.Background())
}

func (i ClusterK0sArgs) ToClusterK0sOutputWithContext(ctx context.Context) ClusterK0sOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterK0sOutput)
}

func (i ClusterK0sArgs) ToClusterK0sPtrOutput() ClusterK0sPtrOutput {
	return i.ToClusterK0sPtrOutputWithContext(context.Background())
}

func (i ClusterK0sArgs) ToClusterK0sPtrOutputWithContext(ctx context.Context) ClusterK0sPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterK0sOutput).ToClusterK0sPtrOutputWithContext(ctx)
}

// ClusterK0sPtrInput is an input type that accepts ClusterK0sArgs, ClusterK0sPtr and ClusterK0sPtrOutput values.
// You can construct a concrete instance of `ClusterK0sPtrInput` via:
//
//	        ClusterK0sArgs{...}
//
//	or:
//
//	        nil
type ClusterK0sPtrInput interface {
	pulumi.Input

	ToClusterK0sPtrOutput() ClusterK0sPtrOutput
	ToClusterK0sPtrOutputWithContext(context.Context) ClusterK0sPtrOutput
}

type clusterK0sPtrType ClusterK0sArgs

func ClusterK0sPtr(v *ClusterK0sArgs) ClusterK0sPtrInput {
	return (*clusterK0sPtrType)(v)
}

func (*clusterK0sPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterK0s)(nil)).Elem()
}

func (i *clusterK0sPtrType) ToClusterK0sPtrOutput() ClusterK0sPtrOutput {
	return i.ToClusterK0sPtrOutputWithContext(context.Background())
}

func (i *clusterK0sPtrType) ToClusterK0sPtrOutputWithContext(ctx context.Context) ClusterK0sPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterK0sPtrOutput)
}

type ClusterK0sOutput struct{ *pulumi.OutputState }

func (ClusterK0sOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterK0s)(nil)).Elem()
}

func (o ClusterK0sOutput) ToClusterK0sOutput() ClusterK0sOutput {
	return o
}

func (o ClusterK0sOutput) ToClusterK0sOutputWithContext(ctx context.Context) ClusterK0sOutput {
	return o
}

func (o ClusterK0sOutput) ToClusterK0sPtrOutput() ClusterK0sPtrOutput {
	return o.ToClusterK0sPtrOutputWithContext(context.Background())
}

func (o ClusterK0sOutput) ToClusterK0sPtrOutputWithContext(ctx context.Context) ClusterK0sPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ClusterK0s) *ClusterK0s {
		return &v
	}).(ClusterK0sPtrOutput)
}

func (o ClusterK0sOutput) Config() K0sPtrOutput {
	return o.ApplyT(func(v ClusterK0s) *K0s { return v.Config }).(K0sPtrOutput)
}

func (o ClusterK0sOutput) DynamicConfig() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ClusterK0s) *bool { return v.DynamicConfig }).(pulumi.BoolPtrOutput)
}

func (o ClusterK0sOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterK0s) *string { return v.Version }).(pulumi.StringPtrOutput)
}

func (o ClusterK0sOutput) VersionChannel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterK0s) *string { return v.VersionChannel }).(pulumi.StringPtrOutput)
}

type ClusterK0sPtrOutput struct{ *pulumi.OutputState }

func (ClusterK0sPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterK0s)(nil)).Elem()
}

func (o ClusterK0sPtrOutput) ToClusterK0sPtrOutput() ClusterK0sPtrOutput {
	return o
}

func (o ClusterK0sPtrOutput) ToClusterK0sPtrOutputWithContext(ctx context.Context) ClusterK0sPtrOutput {
	return o
}

func (o ClusterK0sPtrOutput) Elem() ClusterK0sOutput {
	return o.ApplyT(func(v *ClusterK0s) ClusterK0s {
		if v != nil {
			return *v
		}
		var ret ClusterK0s
		return ret
	}).(ClusterK0sOutput)
}

func (o ClusterK0sPtrOutput) Config() K0sPtrOutput {
	return o.ApplyT(func(v *ClusterK0s) *K0s {
		if v == nil {
			return nil
		}
		return v.Config
	}).(K0sPtrOutput)
}

func (o ClusterK0sPtrOutput) DynamicConfig() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ClusterK0s) *bool {
		if v == nil {
			return nil
		}
		return v.DynamicConfig
	}).(pulumi.BoolPtrOutput)
}

func (o ClusterK0sPtrOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ClusterK0s) *string {
		if v == nil {
			return nil
		}
		return v.Version
	}).(pulumi.StringPtrOutput)
}

func (o ClusterK0sPtrOutput) VersionChannel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ClusterK0s) *string {
		if v == nil {
			return nil
		}
		return v.VersionChannel
	}).(pulumi.StringPtrOutput)
}

type ClusterLocalhost struct {
	Enabled *bool `pulumi:"enabled"`
}

// ClusterLocalhostInput is an input type that accepts ClusterLocalhostArgs and ClusterLocalhostOutput values.
// You can construct a concrete instance of `ClusterLocalhostInput` via:
//
//	ClusterLocalhostArgs{...}
type ClusterLocalhostInput interface {
	pulumi.Input

	ToClusterLocalhostOutput() ClusterLocalhostOutput
	ToClusterLocalhostOutputWithContext(context.Context) ClusterLocalhostOutput
}

type ClusterLocalhostArgs struct {
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
}

func (ClusterLocalhostArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterLocalhost)(nil)).Elem()
}

func (i ClusterLocalhostArgs) ToClusterLocalhostOutput() ClusterLocalhostOutput {
	return i.ToClusterLocalhostOutputWithContext(context.Background())
}

func (i ClusterLocalhostArgs) ToClusterLocalhostOutputWithContext(ctx context.Context) ClusterLocalhostOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterLocalhostOutput)
}

func (i ClusterLocalhostArgs) ToClusterLocalhostPtrOutput() ClusterLocalhostPtrOutput {
	return i.ToClusterLocalhostPtrOutputWithContext(context.Background())
}

func (i ClusterLocalhostArgs) ToClusterLocalhostPtrOutputWithContext(ctx context.Context) ClusterLocalhostPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterLocalhostOutput).ToClusterLocalhostPtrOutputWithContext(ctx)
}

// ClusterLocalhostPtrInput is an input type that accepts ClusterLocalhostArgs, ClusterLocalhostPtr and ClusterLocalhostPtrOutput values.
// You can construct a concrete instance of `ClusterLocalhostPtrInput` via:
//
//	        ClusterLocalhostArgs{...}
//
//	or:
//
//	        nil
type ClusterLocalhostPtrInput interface {
	pulumi.Input

	ToClusterLocalhostPtrOutput() ClusterLocalhostPtrOutput
	ToClusterLocalhostPtrOutputWithContext(context.Context) ClusterLocalhostPtrOutput
}

type clusterLocalhostPtrType ClusterLocalhostArgs

func ClusterLocalhostPtr(v *ClusterLocalhostArgs) ClusterLocalhostPtrInput {
	return (*clusterLocalhostPtrType)(v)
}

func (*clusterLocalhostPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterLocalhost)(nil)).Elem()
}

func (i *clusterLocalhostPtrType) ToClusterLocalhostPtrOutput() ClusterLocalhostPtrOutput {
	return i.ToClusterLocalhostPtrOutputWithContext(context.Background())
}

func (i *clusterLocalhostPtrType) ToClusterLocalhostPtrOutputWithContext(ctx context.Context) ClusterLocalhostPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterLocalhostPtrOutput)
}

type ClusterLocalhostOutput struct{ *pulumi.OutputState }

func (ClusterLocalhostOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterLocalhost)(nil)).Elem()
}

func (o ClusterLocalhostOutput) ToClusterLocalhostOutput() ClusterLocalhostOutput {
	return o
}

func (o ClusterLocalhostOutput) ToClusterLocalhostOutputWithContext(ctx context.Context) ClusterLocalhostOutput {
	return o
}

func (o ClusterLocalhostOutput) ToClusterLocalhostPtrOutput() ClusterLocalhostPtrOutput {
	return o.ToClusterLocalhostPtrOutputWithContext(context.Background())
}

func (o ClusterLocalhostOutput) ToClusterLocalhostPtrOutputWithContext(ctx context.Context) ClusterLocalhostPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ClusterLocalhost) *ClusterLocalhost {
		return &v
	}).(ClusterLocalhostPtrOutput)
}

func (o ClusterLocalhostOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ClusterLocalhost) *bool { return v.Enabled }).(pulumi.BoolPtrOutput)
}

type ClusterLocalhostPtrOutput struct{ *pulumi.OutputState }

func (ClusterLocalhostPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterLocalhost)(nil)).Elem()
}

func (o ClusterLocalhostPtrOutput) ToClusterLocalhostPtrOutput() ClusterLocalhostPtrOutput {
	return o
}

func (o ClusterLocalhostPtrOutput) ToClusterLocalhostPtrOutputWithContext(ctx context.Context) ClusterLocalhostPtrOutput {
	return o
}

func (o ClusterLocalhostPtrOutput) Elem() ClusterLocalhostOutput {
	return o.ApplyT(func(v *ClusterLocalhost) ClusterLocalhost {
		if v != nil {
			return *v
		}
		var ret ClusterLocalhost
		return ret
	}).(ClusterLocalhostOutput)
}

func (o ClusterLocalhostPtrOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ClusterLocalhost) *bool {
		if v == nil {
			return nil
		}
		return v.Enabled
	}).(pulumi.BoolPtrOutput)
}

type ClusterMetadata struct {
	Name string `pulumi:"name"`
}

// ClusterMetadataInput is an input type that accepts ClusterMetadataArgs and ClusterMetadataOutput values.
// You can construct a concrete instance of `ClusterMetadataInput` via:
//
//	ClusterMetadataArgs{...}
type ClusterMetadataInput interface {
	pulumi.Input

	ToClusterMetadataOutput() ClusterMetadataOutput
	ToClusterMetadataOutputWithContext(context.Context) ClusterMetadataOutput
}

type ClusterMetadataArgs struct {
	Name pulumi.StringInput `pulumi:"name"`
}

func (ClusterMetadataArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterMetadata)(nil)).Elem()
}

func (i ClusterMetadataArgs) ToClusterMetadataOutput() ClusterMetadataOutput {
	return i.ToClusterMetadataOutputWithContext(context.Background())
}

func (i ClusterMetadataArgs) ToClusterMetadataOutputWithContext(ctx context.Context) ClusterMetadataOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterMetadataOutput)
}

func (i ClusterMetadataArgs) ToClusterMetadataPtrOutput() ClusterMetadataPtrOutput {
	return i.ToClusterMetadataPtrOutputWithContext(context.Background())
}

func (i ClusterMetadataArgs) ToClusterMetadataPtrOutputWithContext(ctx context.Context) ClusterMetadataPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterMetadataOutput).ToClusterMetadataPtrOutputWithContext(ctx)
}

// ClusterMetadataPtrInput is an input type that accepts ClusterMetadataArgs, ClusterMetadataPtr and ClusterMetadataPtrOutput values.
// You can construct a concrete instance of `ClusterMetadataPtrInput` via:
//
//	        ClusterMetadataArgs{...}
//
//	or:
//
//	        nil
type ClusterMetadataPtrInput interface {
	pulumi.Input

	ToClusterMetadataPtrOutput() ClusterMetadataPtrOutput
	ToClusterMetadataPtrOutputWithContext(context.Context) ClusterMetadataPtrOutput
}

type clusterMetadataPtrType ClusterMetadataArgs

func ClusterMetadataPtr(v *ClusterMetadataArgs) ClusterMetadataPtrInput {
	return (*clusterMetadataPtrType)(v)
}

func (*clusterMetadataPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterMetadata)(nil)).Elem()
}

func (i *clusterMetadataPtrType) ToClusterMetadataPtrOutput() ClusterMetadataPtrOutput {
	return i.ToClusterMetadataPtrOutputWithContext(context.Background())
}

func (i *clusterMetadataPtrType) ToClusterMetadataPtrOutputWithContext(ctx context.Context) ClusterMetadataPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterMetadataPtrOutput)
}

type ClusterMetadataOutput struct{ *pulumi.OutputState }

func (ClusterMetadataOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterMetadata)(nil)).Elem()
}

func (o ClusterMetadataOutput) ToClusterMetadataOutput() ClusterMetadataOutput {
	return o
}

func (o ClusterMetadataOutput) ToClusterMetadataOutputWithContext(ctx context.Context) ClusterMetadataOutput {
	return o
}

func (o ClusterMetadataOutput) ToClusterMetadataPtrOutput() ClusterMetadataPtrOutput {
	return o.ToClusterMetadataPtrOutputWithContext(context.Background())
}

func (o ClusterMetadataOutput) ToClusterMetadataPtrOutputWithContext(ctx context.Context) ClusterMetadataPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ClusterMetadata) *ClusterMetadata {
		return &v
	}).(ClusterMetadataPtrOutput)
}

func (o ClusterMetadataOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v ClusterMetadata) string { return v.Name }).(pulumi.StringOutput)
}

type ClusterMetadataPtrOutput struct{ *pulumi.OutputState }

func (ClusterMetadataPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterMetadata)(nil)).Elem()
}

func (o ClusterMetadataPtrOutput) ToClusterMetadataPtrOutput() ClusterMetadataPtrOutput {
	return o
}

func (o ClusterMetadataPtrOutput) ToClusterMetadataPtrOutputWithContext(ctx context.Context) ClusterMetadataPtrOutput {
	return o
}

func (o ClusterMetadataPtrOutput) Elem() ClusterMetadataOutput {
	return o.ApplyT(func(v *ClusterMetadata) ClusterMetadata {
		if v != nil {
			return *v
		}
		var ret ClusterMetadata
		return ret
	}).(ClusterMetadataOutput)
}

func (o ClusterMetadataPtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ClusterMetadata) *string {
		if v == nil {
			return nil
		}
		return &v.Name
	}).(pulumi.StringPtrOutput)
}

type ClusterSSH struct {
	Address string      `pulumi:"address"`
	Bastion *ClusterSSH `pulumi:"bastion"`
	HostKey *string     `pulumi:"hostKey"`
	Key     *string     `pulumi:"key"`
	Port    *int        `pulumi:"port"`
	User    *string     `pulumi:"user"`
}

// ClusterSSHInput is an input type that accepts ClusterSSHArgs and ClusterSSHOutput values.
// You can construct a concrete instance of `ClusterSSHInput` via:
//
//	ClusterSSHArgs{...}
type ClusterSSHInput interface {
	pulumi.Input

	ToClusterSSHOutput() ClusterSSHOutput
	ToClusterSSHOutputWithContext(context.Context) ClusterSSHOutput
}

type ClusterSSHArgs struct {
	Address pulumi.StringInput    `pulumi:"address"`
	Bastion ClusterSSHPtrInput    `pulumi:"bastion"`
	HostKey pulumi.StringPtrInput `pulumi:"hostKey"`
	Key     pulumi.StringPtrInput `pulumi:"key"`
	Port    pulumi.IntPtrInput    `pulumi:"port"`
	User    pulumi.StringPtrInput `pulumi:"user"`
}

func (ClusterSSHArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterSSH)(nil)).Elem()
}

func (i ClusterSSHArgs) ToClusterSSHOutput() ClusterSSHOutput {
	return i.ToClusterSSHOutputWithContext(context.Background())
}

func (i ClusterSSHArgs) ToClusterSSHOutputWithContext(ctx context.Context) ClusterSSHOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterSSHOutput)
}

func (i ClusterSSHArgs) ToClusterSSHPtrOutput() ClusterSSHPtrOutput {
	return i.ToClusterSSHPtrOutputWithContext(context.Background())
}

func (i ClusterSSHArgs) ToClusterSSHPtrOutputWithContext(ctx context.Context) ClusterSSHPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterSSHOutput).ToClusterSSHPtrOutputWithContext(ctx)
}

// ClusterSSHPtrInput is an input type that accepts ClusterSSHArgs, ClusterSSHPtr and ClusterSSHPtrOutput values.
// You can construct a concrete instance of `ClusterSSHPtrInput` via:
//
//	        ClusterSSHArgs{...}
//
//	or:
//
//	        nil
type ClusterSSHPtrInput interface {
	pulumi.Input

	ToClusterSSHPtrOutput() ClusterSSHPtrOutput
	ToClusterSSHPtrOutputWithContext(context.Context) ClusterSSHPtrOutput
}

type clusterSSHPtrType ClusterSSHArgs

func ClusterSSHPtr(v *ClusterSSHArgs) ClusterSSHPtrInput {
	return (*clusterSSHPtrType)(v)
}

func (*clusterSSHPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterSSH)(nil)).Elem()
}

func (i *clusterSSHPtrType) ToClusterSSHPtrOutput() ClusterSSHPtrOutput {
	return i.ToClusterSSHPtrOutputWithContext(context.Background())
}

func (i *clusterSSHPtrType) ToClusterSSHPtrOutputWithContext(ctx context.Context) ClusterSSHPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterSSHPtrOutput)
}

type ClusterSSHOutput struct{ *pulumi.OutputState }

func (ClusterSSHOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterSSH)(nil)).Elem()
}

func (o ClusterSSHOutput) ToClusterSSHOutput() ClusterSSHOutput {
	return o
}

func (o ClusterSSHOutput) ToClusterSSHOutputWithContext(ctx context.Context) ClusterSSHOutput {
	return o
}

func (o ClusterSSHOutput) ToClusterSSHPtrOutput() ClusterSSHPtrOutput {
	return o.ToClusterSSHPtrOutputWithContext(context.Background())
}

func (o ClusterSSHOutput) ToClusterSSHPtrOutputWithContext(ctx context.Context) ClusterSSHPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ClusterSSH) *ClusterSSH {
		return &v
	}).(ClusterSSHPtrOutput)
}

func (o ClusterSSHOutput) Address() pulumi.StringOutput {
	return o.ApplyT(func(v ClusterSSH) string { return v.Address }).(pulumi.StringOutput)
}

func (o ClusterSSHOutput) Bastion() ClusterSSHPtrOutput {
	return o.ApplyT(func(v ClusterSSH) *ClusterSSH { return v.Bastion }).(ClusterSSHPtrOutput)
}

func (o ClusterSSHOutput) HostKey() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterSSH) *string { return v.HostKey }).(pulumi.StringPtrOutput)
}

func (o ClusterSSHOutput) Key() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterSSH) *string { return v.Key }).(pulumi.StringPtrOutput)
}

func (o ClusterSSHOutput) Port() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ClusterSSH) *int { return v.Port }).(pulumi.IntPtrOutput)
}

func (o ClusterSSHOutput) User() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterSSH) *string { return v.User }).(pulumi.StringPtrOutput)
}

type ClusterSSHPtrOutput struct{ *pulumi.OutputState }

func (ClusterSSHPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterSSH)(nil)).Elem()
}

func (o ClusterSSHPtrOutput) ToClusterSSHPtrOutput() ClusterSSHPtrOutput {
	return o
}

func (o ClusterSSHPtrOutput) ToClusterSSHPtrOutputWithContext(ctx context.Context) ClusterSSHPtrOutput {
	return o
}

func (o ClusterSSHPtrOutput) Elem() ClusterSSHOutput {
	return o.ApplyT(func(v *ClusterSSH) ClusterSSH {
		if v != nil {
			return *v
		}
		var ret ClusterSSH
		return ret
	}).(ClusterSSHOutput)
}

func (o ClusterSSHPtrOutput) Address() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ClusterSSH) *string {
		if v == nil {
			return nil
		}
		return &v.Address
	}).(pulumi.StringPtrOutput)
}

func (o ClusterSSHPtrOutput) Bastion() ClusterSSHPtrOutput {
	return o.ApplyT(func(v *ClusterSSH) *ClusterSSH {
		if v == nil {
			return nil
		}
		return v.Bastion
	}).(ClusterSSHPtrOutput)
}

func (o ClusterSSHPtrOutput) HostKey() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ClusterSSH) *string {
		if v == nil {
			return nil
		}
		return v.HostKey
	}).(pulumi.StringPtrOutput)
}

func (o ClusterSSHPtrOutput) Key() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ClusterSSH) *string {
		if v == nil {
			return nil
		}
		return v.Key
	}).(pulumi.StringPtrOutput)
}

func (o ClusterSSHPtrOutput) Port() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ClusterSSH) *int {
		if v == nil {
			return nil
		}
		return v.Port
	}).(pulumi.IntPtrOutput)
}

func (o ClusterSSHPtrOutput) User() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ClusterSSH) *string {
		if v == nil {
			return nil
		}
		return v.User
	}).(pulumi.StringPtrOutput)
}

type ClusterSpec struct {
	Hosts []ClusterHost `pulumi:"hosts"`
	K0s   *ClusterK0s   `pulumi:"k0s"`
}

// ClusterSpecInput is an input type that accepts ClusterSpecArgs and ClusterSpecOutput values.
// You can construct a concrete instance of `ClusterSpecInput` via:
//
//	ClusterSpecArgs{...}
type ClusterSpecInput interface {
	pulumi.Input

	ToClusterSpecOutput() ClusterSpecOutput
	ToClusterSpecOutputWithContext(context.Context) ClusterSpecOutput
}

type ClusterSpecArgs struct {
	Hosts ClusterHostArrayInput `pulumi:"hosts"`
	K0s   ClusterK0sPtrInput    `pulumi:"k0s"`
}

func (ClusterSpecArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterSpec)(nil)).Elem()
}

func (i ClusterSpecArgs) ToClusterSpecOutput() ClusterSpecOutput {
	return i.ToClusterSpecOutputWithContext(context.Background())
}

func (i ClusterSpecArgs) ToClusterSpecOutputWithContext(ctx context.Context) ClusterSpecOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterSpecOutput)
}

func (i ClusterSpecArgs) ToClusterSpecPtrOutput() ClusterSpecPtrOutput {
	return i.ToClusterSpecPtrOutputWithContext(context.Background())
}

func (i ClusterSpecArgs) ToClusterSpecPtrOutputWithContext(ctx context.Context) ClusterSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterSpecOutput).ToClusterSpecPtrOutputWithContext(ctx)
}

// ClusterSpecPtrInput is an input type that accepts ClusterSpecArgs, ClusterSpecPtr and ClusterSpecPtrOutput values.
// You can construct a concrete instance of `ClusterSpecPtrInput` via:
//
//	        ClusterSpecArgs{...}
//
//	or:
//
//	        nil
type ClusterSpecPtrInput interface {
	pulumi.Input

	ToClusterSpecPtrOutput() ClusterSpecPtrOutput
	ToClusterSpecPtrOutputWithContext(context.Context) ClusterSpecPtrOutput
}

type clusterSpecPtrType ClusterSpecArgs

func ClusterSpecPtr(v *ClusterSpecArgs) ClusterSpecPtrInput {
	return (*clusterSpecPtrType)(v)
}

func (*clusterSpecPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterSpec)(nil)).Elem()
}

func (i *clusterSpecPtrType) ToClusterSpecPtrOutput() ClusterSpecPtrOutput {
	return i.ToClusterSpecPtrOutputWithContext(context.Background())
}

func (i *clusterSpecPtrType) ToClusterSpecPtrOutputWithContext(ctx context.Context) ClusterSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterSpecPtrOutput)
}

type ClusterSpecOutput struct{ *pulumi.OutputState }

func (ClusterSpecOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterSpec)(nil)).Elem()
}

func (o ClusterSpecOutput) ToClusterSpecOutput() ClusterSpecOutput {
	return o
}

func (o ClusterSpecOutput) ToClusterSpecOutputWithContext(ctx context.Context) ClusterSpecOutput {
	return o
}

func (o ClusterSpecOutput) ToClusterSpecPtrOutput() ClusterSpecPtrOutput {
	return o.ToClusterSpecPtrOutputWithContext(context.Background())
}

func (o ClusterSpecOutput) ToClusterSpecPtrOutputWithContext(ctx context.Context) ClusterSpecPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ClusterSpec) *ClusterSpec {
		return &v
	}).(ClusterSpecPtrOutput)
}

func (o ClusterSpecOutput) Hosts() ClusterHostArrayOutput {
	return o.ApplyT(func(v ClusterSpec) []ClusterHost { return v.Hosts }).(ClusterHostArrayOutput)
}

func (o ClusterSpecOutput) K0s() ClusterK0sPtrOutput {
	return o.ApplyT(func(v ClusterSpec) *ClusterK0s { return v.K0s }).(ClusterK0sPtrOutput)
}

type ClusterSpecPtrOutput struct{ *pulumi.OutputState }

func (ClusterSpecPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterSpec)(nil)).Elem()
}

func (o ClusterSpecPtrOutput) ToClusterSpecPtrOutput() ClusterSpecPtrOutput {
	return o
}

func (o ClusterSpecPtrOutput) ToClusterSpecPtrOutputWithContext(ctx context.Context) ClusterSpecPtrOutput {
	return o
}

func (o ClusterSpecPtrOutput) Elem() ClusterSpecOutput {
	return o.ApplyT(func(v *ClusterSpec) ClusterSpec {
		if v != nil {
			return *v
		}
		var ret ClusterSpec
		return ret
	}).(ClusterSpecOutput)
}

func (o ClusterSpecPtrOutput) Hosts() ClusterHostArrayOutput {
	return o.ApplyT(func(v *ClusterSpec) []ClusterHost {
		if v == nil {
			return nil
		}
		return v.Hosts
	}).(ClusterHostArrayOutput)
}

func (o ClusterSpecPtrOutput) K0s() ClusterK0sPtrOutput {
	return o.ApplyT(func(v *ClusterSpec) *ClusterK0s {
		if v == nil {
			return nil
		}
		return v.K0s
	}).(ClusterK0sPtrOutput)
}

type ClusterWinRM struct {
	Address       string      `pulumi:"address"`
	Bastion       *ClusterSSH `pulumi:"bastion"`
	CaCert        *string     `pulumi:"caCert"`
	Cert          *string     `pulumi:"cert"`
	Insecure      *bool       `pulumi:"insecure"`
	Key           *string     `pulumi:"key"`
	Password      *string     `pulumi:"password"`
	Port          *int        `pulumi:"port"`
	TlsServerName *string     `pulumi:"tlsServerName"`
	UseHTTPS      *bool       `pulumi:"useHTTPS"`
	UseNTLM       *bool       `pulumi:"useNTLM"`
	User          *string     `pulumi:"user"`
}

// ClusterWinRMInput is an input type that accepts ClusterWinRMArgs and ClusterWinRMOutput values.
// You can construct a concrete instance of `ClusterWinRMInput` via:
//
//	ClusterWinRMArgs{...}
type ClusterWinRMInput interface {
	pulumi.Input

	ToClusterWinRMOutput() ClusterWinRMOutput
	ToClusterWinRMOutputWithContext(context.Context) ClusterWinRMOutput
}

type ClusterWinRMArgs struct {
	Address       pulumi.StringInput    `pulumi:"address"`
	Bastion       ClusterSSHPtrInput    `pulumi:"bastion"`
	CaCert        pulumi.StringPtrInput `pulumi:"caCert"`
	Cert          pulumi.StringPtrInput `pulumi:"cert"`
	Insecure      pulumi.BoolPtrInput   `pulumi:"insecure"`
	Key           pulumi.StringPtrInput `pulumi:"key"`
	Password      pulumi.StringPtrInput `pulumi:"password"`
	Port          pulumi.IntPtrInput    `pulumi:"port"`
	TlsServerName pulumi.StringPtrInput `pulumi:"tlsServerName"`
	UseHTTPS      pulumi.BoolPtrInput   `pulumi:"useHTTPS"`
	UseNTLM       pulumi.BoolPtrInput   `pulumi:"useNTLM"`
	User          pulumi.StringPtrInput `pulumi:"user"`
}

func (ClusterWinRMArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterWinRM)(nil)).Elem()
}

func (i ClusterWinRMArgs) ToClusterWinRMOutput() ClusterWinRMOutput {
	return i.ToClusterWinRMOutputWithContext(context.Background())
}

func (i ClusterWinRMArgs) ToClusterWinRMOutputWithContext(ctx context.Context) ClusterWinRMOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterWinRMOutput)
}

func (i ClusterWinRMArgs) ToClusterWinRMPtrOutput() ClusterWinRMPtrOutput {
	return i.ToClusterWinRMPtrOutputWithContext(context.Background())
}

func (i ClusterWinRMArgs) ToClusterWinRMPtrOutputWithContext(ctx context.Context) ClusterWinRMPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterWinRMOutput).ToClusterWinRMPtrOutputWithContext(ctx)
}

// ClusterWinRMPtrInput is an input type that accepts ClusterWinRMArgs, ClusterWinRMPtr and ClusterWinRMPtrOutput values.
// You can construct a concrete instance of `ClusterWinRMPtrInput` via:
//
//	        ClusterWinRMArgs{...}
//
//	or:
//
//	        nil
type ClusterWinRMPtrInput interface {
	pulumi.Input

	ToClusterWinRMPtrOutput() ClusterWinRMPtrOutput
	ToClusterWinRMPtrOutputWithContext(context.Context) ClusterWinRMPtrOutput
}

type clusterWinRMPtrType ClusterWinRMArgs

func ClusterWinRMPtr(v *ClusterWinRMArgs) ClusterWinRMPtrInput {
	return (*clusterWinRMPtrType)(v)
}

func (*clusterWinRMPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterWinRM)(nil)).Elem()
}

func (i *clusterWinRMPtrType) ToClusterWinRMPtrOutput() ClusterWinRMPtrOutput {
	return i.ToClusterWinRMPtrOutputWithContext(context.Background())
}

func (i *clusterWinRMPtrType) ToClusterWinRMPtrOutputWithContext(ctx context.Context) ClusterWinRMPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ClusterWinRMPtrOutput)
}

type ClusterWinRMOutput struct{ *pulumi.OutputState }

func (ClusterWinRMOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ClusterWinRM)(nil)).Elem()
}

func (o ClusterWinRMOutput) ToClusterWinRMOutput() ClusterWinRMOutput {
	return o
}

func (o ClusterWinRMOutput) ToClusterWinRMOutputWithContext(ctx context.Context) ClusterWinRMOutput {
	return o
}

func (o ClusterWinRMOutput) ToClusterWinRMPtrOutput() ClusterWinRMPtrOutput {
	return o.ToClusterWinRMPtrOutputWithContext(context.Background())
}

func (o ClusterWinRMOutput) ToClusterWinRMPtrOutputWithContext(ctx context.Context) ClusterWinRMPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ClusterWinRM) *ClusterWinRM {
		return &v
	}).(ClusterWinRMPtrOutput)
}

func (o ClusterWinRMOutput) Address() pulumi.StringOutput {
	return o.ApplyT(func(v ClusterWinRM) string { return v.Address }).(pulumi.StringOutput)
}

func (o ClusterWinRMOutput) Bastion() ClusterSSHPtrOutput {
	return o.ApplyT(func(v ClusterWinRM) *ClusterSSH { return v.Bastion }).(ClusterSSHPtrOutput)
}

func (o ClusterWinRMOutput) CaCert() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterWinRM) *string { return v.CaCert }).(pulumi.StringPtrOutput)
}

func (o ClusterWinRMOutput) Cert() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterWinRM) *string { return v.Cert }).(pulumi.StringPtrOutput)
}

func (o ClusterWinRMOutput) Insecure() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ClusterWinRM) *bool { return v.Insecure }).(pulumi.BoolPtrOutput)
}

func (o ClusterWinRMOutput) Key() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterWinRM) *string { return v.Key }).(pulumi.StringPtrOutput)
}

func (o ClusterWinRMOutput) Password() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterWinRM) *string { return v.Password }).(pulumi.StringPtrOutput)
}

func (o ClusterWinRMOutput) Port() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ClusterWinRM) *int { return v.Port }).(pulumi.IntPtrOutput)
}

func (o ClusterWinRMOutput) TlsServerName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterWinRM) *string { return v.TlsServerName }).(pulumi.StringPtrOutput)
}

func (o ClusterWinRMOutput) UseHTTPS() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ClusterWinRM) *bool { return v.UseHTTPS }).(pulumi.BoolPtrOutput)
}

func (o ClusterWinRMOutput) UseNTLM() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ClusterWinRM) *bool { return v.UseNTLM }).(pulumi.BoolPtrOutput)
}

func (o ClusterWinRMOutput) User() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ClusterWinRM) *string { return v.User }).(pulumi.StringPtrOutput)
}

type ClusterWinRMPtrOutput struct{ *pulumi.OutputState }

func (ClusterWinRMPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ClusterWinRM)(nil)).Elem()
}

func (o ClusterWinRMPtrOutput) ToClusterWinRMPtrOutput() ClusterWinRMPtrOutput {
	return o
}

func (o ClusterWinRMPtrOutput) ToClusterWinRMPtrOutputWithContext(ctx context.Context) ClusterWinRMPtrOutput {
	return o
}

func (o ClusterWinRMPtrOutput) Elem() ClusterWinRMOutput {
	return o.ApplyT(func(v *ClusterWinRM) ClusterWinRM {
		if v != nil {
			return *v
		}
		var ret ClusterWinRM
		return ret
	}).(ClusterWinRMOutput)
}

func (o ClusterWinRMPtrOutput) Address() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ClusterWinRM) *string {
		if v == nil {
			return nil
		}
		return &v.Address
	}).(pulumi.StringPtrOutput)
}

func (o ClusterWinRMPtrOutput) Bastion() ClusterSSHPtrOutput {
	return o.ApplyT(func(v *ClusterWinRM) *ClusterSSH {
		if v == nil {
			return nil
		}
		return v.Bastion
	}).(ClusterSSHPtrOutput)
}

func (o ClusterWinRMPtrOutput) CaCert() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ClusterWinRM) *string {
		if v == nil {
			return nil
		}
		return v.CaCert
	}).(pulumi.StringPtrOutput)
}

func (o ClusterWinRMPtrOutput) Cert() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ClusterWinRM) *string {
		if v == nil {
			return nil
		}
		return v.Cert
	}).(pulumi.StringPtrOutput)
}

func (o ClusterWinRMPtrOutput) Insecure() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ClusterWinRM) *bool {
		if v == nil {
			return nil
		}
		return v.Insecure
	}).(pulumi.BoolPtrOutput)
}

func (o ClusterWinRMPtrOutput) Key() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ClusterWinRM) *string {
		if v == nil {
			return nil
		}
		return v.Key
	}).(pulumi.StringPtrOutput)
}

func (o ClusterWinRMPtrOutput) Password() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ClusterWinRM) *string {
		if v == nil {
			return nil
		}
		return v.Password
	}).(pulumi.StringPtrOutput)
}

func (o ClusterWinRMPtrOutput) Port() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ClusterWinRM) *int {
		if v == nil {
			return nil
		}
		return v.Port
	}).(pulumi.IntPtrOutput)
}

func (o ClusterWinRMPtrOutput) TlsServerName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ClusterWinRM) *string {
		if v == nil {
			return nil
		}
		return v.TlsServerName
	}).(pulumi.StringPtrOutput)
}

func (o ClusterWinRMPtrOutput) UseHTTPS() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ClusterWinRM) *bool {
		if v == nil {
			return nil
		}
		return v.UseHTTPS
	}).(pulumi.BoolPtrOutput)
}

func (o ClusterWinRMPtrOutput) UseNTLM() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ClusterWinRM) *bool {
		if v == nil {
			return nil
		}
		return v.UseNTLM
	}).(pulumi.BoolPtrOutput)
}

func (o ClusterWinRMPtrOutput) User() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ClusterWinRM) *string {
		if v == nil {
			return nil
		}
		return v.User
	}).(pulumi.StringPtrOutput)
}

type K0s struct {
	ApiVersion *string      `pulumi:"apiVersion"`
	Kind       *string      `pulumi:"kind"`
	Metadata   *K0sMetadata `pulumi:"metadata"`
	Spec       *K0sSpec     `pulumi:"spec"`
}

// K0sInput is an input type that accepts K0sArgs and K0sOutput values.
// You can construct a concrete instance of `K0sInput` via:
//
//	K0sArgs{...}
type K0sInput interface {
	pulumi.Input

	ToK0sOutput() K0sOutput
	ToK0sOutputWithContext(context.Context) K0sOutput
}

type K0sArgs struct {
	ApiVersion pulumi.StringPtrInput `pulumi:"apiVersion"`
	Kind       pulumi.StringPtrInput `pulumi:"kind"`
	Metadata   K0sMetadataPtrInput   `pulumi:"metadata"`
	Spec       K0sSpecPtrInput       `pulumi:"spec"`
}

func (K0sArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0s)(nil)).Elem()
}

func (i K0sArgs) ToK0sOutput() K0sOutput {
	return i.ToK0sOutputWithContext(context.Background())
}

func (i K0sArgs) ToK0sOutputWithContext(ctx context.Context) K0sOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sOutput)
}

func (i K0sArgs) ToK0sPtrOutput() K0sPtrOutput {
	return i.ToK0sPtrOutputWithContext(context.Background())
}

func (i K0sArgs) ToK0sPtrOutputWithContext(ctx context.Context) K0sPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sOutput).ToK0sPtrOutputWithContext(ctx)
}

// K0sPtrInput is an input type that accepts K0sArgs, K0sPtr and K0sPtrOutput values.
// You can construct a concrete instance of `K0sPtrInput` via:
//
//	        K0sArgs{...}
//
//	or:
//
//	        nil
type K0sPtrInput interface {
	pulumi.Input

	ToK0sPtrOutput() K0sPtrOutput
	ToK0sPtrOutputWithContext(context.Context) K0sPtrOutput
}

type k0sPtrType K0sArgs

func K0sPtr(v *K0sArgs) K0sPtrInput {
	return (*k0sPtrType)(v)
}

func (*k0sPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0s)(nil)).Elem()
}

func (i *k0sPtrType) ToK0sPtrOutput() K0sPtrOutput {
	return i.ToK0sPtrOutputWithContext(context.Background())
}

func (i *k0sPtrType) ToK0sPtrOutputWithContext(ctx context.Context) K0sPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sPtrOutput)
}

type K0sOutput struct{ *pulumi.OutputState }

func (K0sOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0s)(nil)).Elem()
}

func (o K0sOutput) ToK0sOutput() K0sOutput {
	return o
}

func (o K0sOutput) ToK0sOutputWithContext(ctx context.Context) K0sOutput {
	return o
}

func (o K0sOutput) ToK0sPtrOutput() K0sPtrOutput {
	return o.ToK0sPtrOutputWithContext(context.Background())
}

func (o K0sOutput) ToK0sPtrOutputWithContext(ctx context.Context) K0sPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0s) *K0s {
		return &v
	}).(K0sPtrOutput)
}

func (o K0sOutput) ApiVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0s) *string { return v.ApiVersion }).(pulumi.StringPtrOutput)
}

func (o K0sOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0s) *string { return v.Kind }).(pulumi.StringPtrOutput)
}

func (o K0sOutput) Metadata() K0sMetadataPtrOutput {
	return o.ApplyT(func(v K0s) *K0sMetadata { return v.Metadata }).(K0sMetadataPtrOutput)
}

func (o K0sOutput) Spec() K0sSpecPtrOutput {
	return o.ApplyT(func(v K0s) *K0sSpec { return v.Spec }).(K0sSpecPtrOutput)
}

type K0sPtrOutput struct{ *pulumi.OutputState }

func (K0sPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0s)(nil)).Elem()
}

func (o K0sPtrOutput) ToK0sPtrOutput() K0sPtrOutput {
	return o
}

func (o K0sPtrOutput) ToK0sPtrOutputWithContext(ctx context.Context) K0sPtrOutput {
	return o
}

func (o K0sPtrOutput) Elem() K0sOutput {
	return o.ApplyT(func(v *K0s) K0s {
		if v != nil {
			return *v
		}
		var ret K0s
		return ret
	}).(K0sOutput)
}

func (o K0sPtrOutput) ApiVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0s) *string {
		if v == nil {
			return nil
		}
		return v.ApiVersion
	}).(pulumi.StringPtrOutput)
}

func (o K0sPtrOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0s) *string {
		if v == nil {
			return nil
		}
		return v.Kind
	}).(pulumi.StringPtrOutput)
}

func (o K0sPtrOutput) Metadata() K0sMetadataPtrOutput {
	return o.ApplyT(func(v *K0s) *K0sMetadata {
		if v == nil {
			return nil
		}
		return v.Metadata
	}).(K0sMetadataPtrOutput)
}

func (o K0sPtrOutput) Spec() K0sSpecPtrOutput {
	return o.ApplyT(func(v *K0s) *K0sSpec {
		if v == nil {
			return nil
		}
		return v.Spec
	}).(K0sSpecPtrOutput)
}

type K0sAPI struct {
	Address         *string           `pulumi:"address"`
	ExternalAddress *string           `pulumi:"externalAddress"`
	ExtraArgs       map[string]string `pulumi:"extraArgs"`
	K0sApiPort      *int              `pulumi:"k0sApiPort"`
	Port            *int              `pulumi:"port"`
	Sans            []string          `pulumi:"sans"`
}

// K0sAPIInput is an input type that accepts K0sAPIArgs and K0sAPIOutput values.
// You can construct a concrete instance of `K0sAPIInput` via:
//
//	K0sAPIArgs{...}
type K0sAPIInput interface {
	pulumi.Input

	ToK0sAPIOutput() K0sAPIOutput
	ToK0sAPIOutputWithContext(context.Context) K0sAPIOutput
}

type K0sAPIArgs struct {
	Address         pulumi.StringPtrInput   `pulumi:"address"`
	ExternalAddress pulumi.StringPtrInput   `pulumi:"externalAddress"`
	ExtraArgs       pulumi.StringMapInput   `pulumi:"extraArgs"`
	K0sApiPort      pulumi.IntPtrInput      `pulumi:"k0sApiPort"`
	Port            pulumi.IntPtrInput      `pulumi:"port"`
	Sans            pulumi.StringArrayInput `pulumi:"sans"`
}

func (K0sAPIArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sAPI)(nil)).Elem()
}

func (i K0sAPIArgs) ToK0sAPIOutput() K0sAPIOutput {
	return i.ToK0sAPIOutputWithContext(context.Background())
}

func (i K0sAPIArgs) ToK0sAPIOutputWithContext(ctx context.Context) K0sAPIOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sAPIOutput)
}

func (i K0sAPIArgs) ToK0sAPIPtrOutput() K0sAPIPtrOutput {
	return i.ToK0sAPIPtrOutputWithContext(context.Background())
}

func (i K0sAPIArgs) ToK0sAPIPtrOutputWithContext(ctx context.Context) K0sAPIPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sAPIOutput).ToK0sAPIPtrOutputWithContext(ctx)
}

// K0sAPIPtrInput is an input type that accepts K0sAPIArgs, K0sAPIPtr and K0sAPIPtrOutput values.
// You can construct a concrete instance of `K0sAPIPtrInput` via:
//
//	        K0sAPIArgs{...}
//
//	or:
//
//	        nil
type K0sAPIPtrInput interface {
	pulumi.Input

	ToK0sAPIPtrOutput() K0sAPIPtrOutput
	ToK0sAPIPtrOutputWithContext(context.Context) K0sAPIPtrOutput
}

type k0sAPIPtrType K0sAPIArgs

func K0sAPIPtr(v *K0sAPIArgs) K0sAPIPtrInput {
	return (*k0sAPIPtrType)(v)
}

func (*k0sAPIPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sAPI)(nil)).Elem()
}

func (i *k0sAPIPtrType) ToK0sAPIPtrOutput() K0sAPIPtrOutput {
	return i.ToK0sAPIPtrOutputWithContext(context.Background())
}

func (i *k0sAPIPtrType) ToK0sAPIPtrOutputWithContext(ctx context.Context) K0sAPIPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sAPIPtrOutput)
}

type K0sAPIOutput struct{ *pulumi.OutputState }

func (K0sAPIOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sAPI)(nil)).Elem()
}

func (o K0sAPIOutput) ToK0sAPIOutput() K0sAPIOutput {
	return o
}

func (o K0sAPIOutput) ToK0sAPIOutputWithContext(ctx context.Context) K0sAPIOutput {
	return o
}

func (o K0sAPIOutput) ToK0sAPIPtrOutput() K0sAPIPtrOutput {
	return o.ToK0sAPIPtrOutputWithContext(context.Background())
}

func (o K0sAPIOutput) ToK0sAPIPtrOutputWithContext(ctx context.Context) K0sAPIPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sAPI) *K0sAPI {
		return &v
	}).(K0sAPIPtrOutput)
}

func (o K0sAPIOutput) Address() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sAPI) *string { return v.Address }).(pulumi.StringPtrOutput)
}

func (o K0sAPIOutput) ExternalAddress() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sAPI) *string { return v.ExternalAddress }).(pulumi.StringPtrOutput)
}

func (o K0sAPIOutput) ExtraArgs() pulumi.StringMapOutput {
	return o.ApplyT(func(v K0sAPI) map[string]string { return v.ExtraArgs }).(pulumi.StringMapOutput)
}

func (o K0sAPIOutput) K0sApiPort() pulumi.IntPtrOutput {
	return o.ApplyT(func(v K0sAPI) *int { return v.K0sApiPort }).(pulumi.IntPtrOutput)
}

func (o K0sAPIOutput) Port() pulumi.IntPtrOutput {
	return o.ApplyT(func(v K0sAPI) *int { return v.Port }).(pulumi.IntPtrOutput)
}

func (o K0sAPIOutput) Sans() pulumi.StringArrayOutput {
	return o.ApplyT(func(v K0sAPI) []string { return v.Sans }).(pulumi.StringArrayOutput)
}

type K0sAPIPtrOutput struct{ *pulumi.OutputState }

func (K0sAPIPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sAPI)(nil)).Elem()
}

func (o K0sAPIPtrOutput) ToK0sAPIPtrOutput() K0sAPIPtrOutput {
	return o
}

func (o K0sAPIPtrOutput) ToK0sAPIPtrOutputWithContext(ctx context.Context) K0sAPIPtrOutput {
	return o
}

func (o K0sAPIPtrOutput) Elem() K0sAPIOutput {
	return o.ApplyT(func(v *K0sAPI) K0sAPI {
		if v != nil {
			return *v
		}
		var ret K0sAPI
		return ret
	}).(K0sAPIOutput)
}

func (o K0sAPIPtrOutput) Address() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sAPI) *string {
		if v == nil {
			return nil
		}
		return v.Address
	}).(pulumi.StringPtrOutput)
}

func (o K0sAPIPtrOutput) ExternalAddress() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sAPI) *string {
		if v == nil {
			return nil
		}
		return v.ExternalAddress
	}).(pulumi.StringPtrOutput)
}

func (o K0sAPIPtrOutput) ExtraArgs() pulumi.StringMapOutput {
	return o.ApplyT(func(v *K0sAPI) map[string]string {
		if v == nil {
			return nil
		}
		return v.ExtraArgs
	}).(pulumi.StringMapOutput)
}

func (o K0sAPIPtrOutput) K0sApiPort() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *K0sAPI) *int {
		if v == nil {
			return nil
		}
		return v.K0sApiPort
	}).(pulumi.IntPtrOutput)
}

func (o K0sAPIPtrOutput) Port() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *K0sAPI) *int {
		if v == nil {
			return nil
		}
		return v.Port
	}).(pulumi.IntPtrOutput)
}

func (o K0sAPIPtrOutput) Sans() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *K0sAPI) []string {
		if v == nil {
			return nil
		}
		return v.Sans
	}).(pulumi.StringArrayOutput)
}

type K0sCalico struct {
	EnvVars               map[string]string `pulumi:"envVars"`
	FlexVolumeDriverPath  *string           `pulumi:"flexVolumeDriverPath"`
	IpAutodetectionMethod *string           `pulumi:"ipAutodetectionMethod"`
	Mode                  *string           `pulumi:"mode"`
	Mtu                   *int              `pulumi:"mtu"`
	Overlay               *string           `pulumi:"overlay"`
	VxlanPort             *int              `pulumi:"vxlanPort"`
	VxlanVNI              *int              `pulumi:"vxlanVNI"`
	Wireguard             *bool             `pulumi:"wireguard"`
}

// K0sCalicoInput is an input type that accepts K0sCalicoArgs and K0sCalicoOutput values.
// You can construct a concrete instance of `K0sCalicoInput` via:
//
//	K0sCalicoArgs{...}
type K0sCalicoInput interface {
	pulumi.Input

	ToK0sCalicoOutput() K0sCalicoOutput
	ToK0sCalicoOutputWithContext(context.Context) K0sCalicoOutput
}

type K0sCalicoArgs struct {
	EnvVars               pulumi.StringMapInput `pulumi:"envVars"`
	FlexVolumeDriverPath  pulumi.StringPtrInput `pulumi:"flexVolumeDriverPath"`
	IpAutodetectionMethod pulumi.StringPtrInput `pulumi:"ipAutodetectionMethod"`
	Mode                  pulumi.StringPtrInput `pulumi:"mode"`
	Mtu                   pulumi.IntPtrInput    `pulumi:"mtu"`
	Overlay               pulumi.StringPtrInput `pulumi:"overlay"`
	VxlanPort             pulumi.IntPtrInput    `pulumi:"vxlanPort"`
	VxlanVNI              pulumi.IntPtrInput    `pulumi:"vxlanVNI"`
	Wireguard             pulumi.BoolPtrInput   `pulumi:"wireguard"`
}

func (K0sCalicoArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sCalico)(nil)).Elem()
}

func (i K0sCalicoArgs) ToK0sCalicoOutput() K0sCalicoOutput {
	return i.ToK0sCalicoOutputWithContext(context.Background())
}

func (i K0sCalicoArgs) ToK0sCalicoOutputWithContext(ctx context.Context) K0sCalicoOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sCalicoOutput)
}

func (i K0sCalicoArgs) ToK0sCalicoPtrOutput() K0sCalicoPtrOutput {
	return i.ToK0sCalicoPtrOutputWithContext(context.Background())
}

func (i K0sCalicoArgs) ToK0sCalicoPtrOutputWithContext(ctx context.Context) K0sCalicoPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sCalicoOutput).ToK0sCalicoPtrOutputWithContext(ctx)
}

// K0sCalicoPtrInput is an input type that accepts K0sCalicoArgs, K0sCalicoPtr and K0sCalicoPtrOutput values.
// You can construct a concrete instance of `K0sCalicoPtrInput` via:
//
//	        K0sCalicoArgs{...}
//
//	or:
//
//	        nil
type K0sCalicoPtrInput interface {
	pulumi.Input

	ToK0sCalicoPtrOutput() K0sCalicoPtrOutput
	ToK0sCalicoPtrOutputWithContext(context.Context) K0sCalicoPtrOutput
}

type k0sCalicoPtrType K0sCalicoArgs

func K0sCalicoPtr(v *K0sCalicoArgs) K0sCalicoPtrInput {
	return (*k0sCalicoPtrType)(v)
}

func (*k0sCalicoPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sCalico)(nil)).Elem()
}

func (i *k0sCalicoPtrType) ToK0sCalicoPtrOutput() K0sCalicoPtrOutput {
	return i.ToK0sCalicoPtrOutputWithContext(context.Background())
}

func (i *k0sCalicoPtrType) ToK0sCalicoPtrOutputWithContext(ctx context.Context) K0sCalicoPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sCalicoPtrOutput)
}

type K0sCalicoOutput struct{ *pulumi.OutputState }

func (K0sCalicoOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sCalico)(nil)).Elem()
}

func (o K0sCalicoOutput) ToK0sCalicoOutput() K0sCalicoOutput {
	return o
}

func (o K0sCalicoOutput) ToK0sCalicoOutputWithContext(ctx context.Context) K0sCalicoOutput {
	return o
}

func (o K0sCalicoOutput) ToK0sCalicoPtrOutput() K0sCalicoPtrOutput {
	return o.ToK0sCalicoPtrOutputWithContext(context.Background())
}

func (o K0sCalicoOutput) ToK0sCalicoPtrOutputWithContext(ctx context.Context) K0sCalicoPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sCalico) *K0sCalico {
		return &v
	}).(K0sCalicoPtrOutput)
}

func (o K0sCalicoOutput) EnvVars() pulumi.StringMapOutput {
	return o.ApplyT(func(v K0sCalico) map[string]string { return v.EnvVars }).(pulumi.StringMapOutput)
}

func (o K0sCalicoOutput) FlexVolumeDriverPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sCalico) *string { return v.FlexVolumeDriverPath }).(pulumi.StringPtrOutput)
}

func (o K0sCalicoOutput) IpAutodetectionMethod() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sCalico) *string { return v.IpAutodetectionMethod }).(pulumi.StringPtrOutput)
}

func (o K0sCalicoOutput) Mode() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sCalico) *string { return v.Mode }).(pulumi.StringPtrOutput)
}

func (o K0sCalicoOutput) Mtu() pulumi.IntPtrOutput {
	return o.ApplyT(func(v K0sCalico) *int { return v.Mtu }).(pulumi.IntPtrOutput)
}

func (o K0sCalicoOutput) Overlay() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sCalico) *string { return v.Overlay }).(pulumi.StringPtrOutput)
}

func (o K0sCalicoOutput) VxlanPort() pulumi.IntPtrOutput {
	return o.ApplyT(func(v K0sCalico) *int { return v.VxlanPort }).(pulumi.IntPtrOutput)
}

func (o K0sCalicoOutput) VxlanVNI() pulumi.IntPtrOutput {
	return o.ApplyT(func(v K0sCalico) *int { return v.VxlanVNI }).(pulumi.IntPtrOutput)
}

func (o K0sCalicoOutput) Wireguard() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v K0sCalico) *bool { return v.Wireguard }).(pulumi.BoolPtrOutput)
}

type K0sCalicoPtrOutput struct{ *pulumi.OutputState }

func (K0sCalicoPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sCalico)(nil)).Elem()
}

func (o K0sCalicoPtrOutput) ToK0sCalicoPtrOutput() K0sCalicoPtrOutput {
	return o
}

func (o K0sCalicoPtrOutput) ToK0sCalicoPtrOutputWithContext(ctx context.Context) K0sCalicoPtrOutput {
	return o
}

func (o K0sCalicoPtrOutput) Elem() K0sCalicoOutput {
	return o.ApplyT(func(v *K0sCalico) K0sCalico {
		if v != nil {
			return *v
		}
		var ret K0sCalico
		return ret
	}).(K0sCalicoOutput)
}

func (o K0sCalicoPtrOutput) EnvVars() pulumi.StringMapOutput {
	return o.ApplyT(func(v *K0sCalico) map[string]string {
		if v == nil {
			return nil
		}
		return v.EnvVars
	}).(pulumi.StringMapOutput)
}

func (o K0sCalicoPtrOutput) FlexVolumeDriverPath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sCalico) *string {
		if v == nil {
			return nil
		}
		return v.FlexVolumeDriverPath
	}).(pulumi.StringPtrOutput)
}

func (o K0sCalicoPtrOutput) IpAutodetectionMethod() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sCalico) *string {
		if v == nil {
			return nil
		}
		return v.IpAutodetectionMethod
	}).(pulumi.StringPtrOutput)
}

func (o K0sCalicoPtrOutput) Mode() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sCalico) *string {
		if v == nil {
			return nil
		}
		return v.Mode
	}).(pulumi.StringPtrOutput)
}

func (o K0sCalicoPtrOutput) Mtu() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *K0sCalico) *int {
		if v == nil {
			return nil
		}
		return v.Mtu
	}).(pulumi.IntPtrOutput)
}

func (o K0sCalicoPtrOutput) Overlay() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sCalico) *string {
		if v == nil {
			return nil
		}
		return v.Overlay
	}).(pulumi.StringPtrOutput)
}

func (o K0sCalicoPtrOutput) VxlanPort() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *K0sCalico) *int {
		if v == nil {
			return nil
		}
		return v.VxlanPort
	}).(pulumi.IntPtrOutput)
}

func (o K0sCalicoPtrOutput) VxlanVNI() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *K0sCalico) *int {
		if v == nil {
			return nil
		}
		return v.VxlanVNI
	}).(pulumi.IntPtrOutput)
}

func (o K0sCalicoPtrOutput) Wireguard() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *K0sCalico) *bool {
		if v == nil {
			return nil
		}
		return v.Wireguard
	}).(pulumi.BoolPtrOutput)
}

type K0sCalicoImage struct {
	Cni             *K0sImage `pulumi:"cni"`
	Flexvolume      *K0sImage `pulumi:"flexvolume"`
	Kubecontrollers *K0sImage `pulumi:"kubecontrollers"`
	Node            *K0sImage `pulumi:"node"`
}

// K0sCalicoImageInput is an input type that accepts K0sCalicoImageArgs and K0sCalicoImageOutput values.
// You can construct a concrete instance of `K0sCalicoImageInput` via:
//
//	K0sCalicoImageArgs{...}
type K0sCalicoImageInput interface {
	pulumi.Input

	ToK0sCalicoImageOutput() K0sCalicoImageOutput
	ToK0sCalicoImageOutputWithContext(context.Context) K0sCalicoImageOutput
}

type K0sCalicoImageArgs struct {
	Cni             K0sImagePtrInput `pulumi:"cni"`
	Flexvolume      K0sImagePtrInput `pulumi:"flexvolume"`
	Kubecontrollers K0sImagePtrInput `pulumi:"kubecontrollers"`
	Node            K0sImagePtrInput `pulumi:"node"`
}

func (K0sCalicoImageArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sCalicoImage)(nil)).Elem()
}

func (i K0sCalicoImageArgs) ToK0sCalicoImageOutput() K0sCalicoImageOutput {
	return i.ToK0sCalicoImageOutputWithContext(context.Background())
}

func (i K0sCalicoImageArgs) ToK0sCalicoImageOutputWithContext(ctx context.Context) K0sCalicoImageOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sCalicoImageOutput)
}

func (i K0sCalicoImageArgs) ToK0sCalicoImagePtrOutput() K0sCalicoImagePtrOutput {
	return i.ToK0sCalicoImagePtrOutputWithContext(context.Background())
}

func (i K0sCalicoImageArgs) ToK0sCalicoImagePtrOutputWithContext(ctx context.Context) K0sCalicoImagePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sCalicoImageOutput).ToK0sCalicoImagePtrOutputWithContext(ctx)
}

// K0sCalicoImagePtrInput is an input type that accepts K0sCalicoImageArgs, K0sCalicoImagePtr and K0sCalicoImagePtrOutput values.
// You can construct a concrete instance of `K0sCalicoImagePtrInput` via:
//
//	        K0sCalicoImageArgs{...}
//
//	or:
//
//	        nil
type K0sCalicoImagePtrInput interface {
	pulumi.Input

	ToK0sCalicoImagePtrOutput() K0sCalicoImagePtrOutput
	ToK0sCalicoImagePtrOutputWithContext(context.Context) K0sCalicoImagePtrOutput
}

type k0sCalicoImagePtrType K0sCalicoImageArgs

func K0sCalicoImagePtr(v *K0sCalicoImageArgs) K0sCalicoImagePtrInput {
	return (*k0sCalicoImagePtrType)(v)
}

func (*k0sCalicoImagePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sCalicoImage)(nil)).Elem()
}

func (i *k0sCalicoImagePtrType) ToK0sCalicoImagePtrOutput() K0sCalicoImagePtrOutput {
	return i.ToK0sCalicoImagePtrOutputWithContext(context.Background())
}

func (i *k0sCalicoImagePtrType) ToK0sCalicoImagePtrOutputWithContext(ctx context.Context) K0sCalicoImagePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sCalicoImagePtrOutput)
}

type K0sCalicoImageOutput struct{ *pulumi.OutputState }

func (K0sCalicoImageOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sCalicoImage)(nil)).Elem()
}

func (o K0sCalicoImageOutput) ToK0sCalicoImageOutput() K0sCalicoImageOutput {
	return o
}

func (o K0sCalicoImageOutput) ToK0sCalicoImageOutputWithContext(ctx context.Context) K0sCalicoImageOutput {
	return o
}

func (o K0sCalicoImageOutput) ToK0sCalicoImagePtrOutput() K0sCalicoImagePtrOutput {
	return o.ToK0sCalicoImagePtrOutputWithContext(context.Background())
}

func (o K0sCalicoImageOutput) ToK0sCalicoImagePtrOutputWithContext(ctx context.Context) K0sCalicoImagePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sCalicoImage) *K0sCalicoImage {
		return &v
	}).(K0sCalicoImagePtrOutput)
}

func (o K0sCalicoImageOutput) Cni() K0sImagePtrOutput {
	return o.ApplyT(func(v K0sCalicoImage) *K0sImage { return v.Cni }).(K0sImagePtrOutput)
}

func (o K0sCalicoImageOutput) Flexvolume() K0sImagePtrOutput {
	return o.ApplyT(func(v K0sCalicoImage) *K0sImage { return v.Flexvolume }).(K0sImagePtrOutput)
}

func (o K0sCalicoImageOutput) Kubecontrollers() K0sImagePtrOutput {
	return o.ApplyT(func(v K0sCalicoImage) *K0sImage { return v.Kubecontrollers }).(K0sImagePtrOutput)
}

func (o K0sCalicoImageOutput) Node() K0sImagePtrOutput {
	return o.ApplyT(func(v K0sCalicoImage) *K0sImage { return v.Node }).(K0sImagePtrOutput)
}

type K0sCalicoImagePtrOutput struct{ *pulumi.OutputState }

func (K0sCalicoImagePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sCalicoImage)(nil)).Elem()
}

func (o K0sCalicoImagePtrOutput) ToK0sCalicoImagePtrOutput() K0sCalicoImagePtrOutput {
	return o
}

func (o K0sCalicoImagePtrOutput) ToK0sCalicoImagePtrOutputWithContext(ctx context.Context) K0sCalicoImagePtrOutput {
	return o
}

func (o K0sCalicoImagePtrOutput) Elem() K0sCalicoImageOutput {
	return o.ApplyT(func(v *K0sCalicoImage) K0sCalicoImage {
		if v != nil {
			return *v
		}
		var ret K0sCalicoImage
		return ret
	}).(K0sCalicoImageOutput)
}

func (o K0sCalicoImagePtrOutput) Cni() K0sImagePtrOutput {
	return o.ApplyT(func(v *K0sCalicoImage) *K0sImage {
		if v == nil {
			return nil
		}
		return v.Cni
	}).(K0sImagePtrOutput)
}

func (o K0sCalicoImagePtrOutput) Flexvolume() K0sImagePtrOutput {
	return o.ApplyT(func(v *K0sCalicoImage) *K0sImage {
		if v == nil {
			return nil
		}
		return v.Flexvolume
	}).(K0sImagePtrOutput)
}

func (o K0sCalicoImagePtrOutput) Kubecontrollers() K0sImagePtrOutput {
	return o.ApplyT(func(v *K0sCalicoImage) *K0sImage {
		if v == nil {
			return nil
		}
		return v.Kubecontrollers
	}).(K0sImagePtrOutput)
}

func (o K0sCalicoImagePtrOutput) Node() K0sImagePtrOutput {
	return o.ApplyT(func(v *K0sCalicoImage) *K0sImage {
		if v == nil {
			return nil
		}
		return v.Node
	}).(K0sImagePtrOutput)
}

type K0sControllerManager struct {
	ExtraArgs map[string]string `pulumi:"extraArgs"`
}

// K0sControllerManagerInput is an input type that accepts K0sControllerManagerArgs and K0sControllerManagerOutput values.
// You can construct a concrete instance of `K0sControllerManagerInput` via:
//
//	K0sControllerManagerArgs{...}
type K0sControllerManagerInput interface {
	pulumi.Input

	ToK0sControllerManagerOutput() K0sControllerManagerOutput
	ToK0sControllerManagerOutputWithContext(context.Context) K0sControllerManagerOutput
}

type K0sControllerManagerArgs struct {
	ExtraArgs pulumi.StringMapInput `pulumi:"extraArgs"`
}

func (K0sControllerManagerArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sControllerManager)(nil)).Elem()
}

func (i K0sControllerManagerArgs) ToK0sControllerManagerOutput() K0sControllerManagerOutput {
	return i.ToK0sControllerManagerOutputWithContext(context.Background())
}

func (i K0sControllerManagerArgs) ToK0sControllerManagerOutputWithContext(ctx context.Context) K0sControllerManagerOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sControllerManagerOutput)
}

func (i K0sControllerManagerArgs) ToK0sControllerManagerPtrOutput() K0sControllerManagerPtrOutput {
	return i.ToK0sControllerManagerPtrOutputWithContext(context.Background())
}

func (i K0sControllerManagerArgs) ToK0sControllerManagerPtrOutputWithContext(ctx context.Context) K0sControllerManagerPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sControllerManagerOutput).ToK0sControllerManagerPtrOutputWithContext(ctx)
}

// K0sControllerManagerPtrInput is an input type that accepts K0sControllerManagerArgs, K0sControllerManagerPtr and K0sControllerManagerPtrOutput values.
// You can construct a concrete instance of `K0sControllerManagerPtrInput` via:
//
//	        K0sControllerManagerArgs{...}
//
//	or:
//
//	        nil
type K0sControllerManagerPtrInput interface {
	pulumi.Input

	ToK0sControllerManagerPtrOutput() K0sControllerManagerPtrOutput
	ToK0sControllerManagerPtrOutputWithContext(context.Context) K0sControllerManagerPtrOutput
}

type k0sControllerManagerPtrType K0sControllerManagerArgs

func K0sControllerManagerPtr(v *K0sControllerManagerArgs) K0sControllerManagerPtrInput {
	return (*k0sControllerManagerPtrType)(v)
}

func (*k0sControllerManagerPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sControllerManager)(nil)).Elem()
}

func (i *k0sControllerManagerPtrType) ToK0sControllerManagerPtrOutput() K0sControllerManagerPtrOutput {
	return i.ToK0sControllerManagerPtrOutputWithContext(context.Background())
}

func (i *k0sControllerManagerPtrType) ToK0sControllerManagerPtrOutputWithContext(ctx context.Context) K0sControllerManagerPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sControllerManagerPtrOutput)
}

type K0sControllerManagerOutput struct{ *pulumi.OutputState }

func (K0sControllerManagerOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sControllerManager)(nil)).Elem()
}

func (o K0sControllerManagerOutput) ToK0sControllerManagerOutput() K0sControllerManagerOutput {
	return o
}

func (o K0sControllerManagerOutput) ToK0sControllerManagerOutputWithContext(ctx context.Context) K0sControllerManagerOutput {
	return o
}

func (o K0sControllerManagerOutput) ToK0sControllerManagerPtrOutput() K0sControllerManagerPtrOutput {
	return o.ToK0sControllerManagerPtrOutputWithContext(context.Background())
}

func (o K0sControllerManagerOutput) ToK0sControllerManagerPtrOutputWithContext(ctx context.Context) K0sControllerManagerPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sControllerManager) *K0sControllerManager {
		return &v
	}).(K0sControllerManagerPtrOutput)
}

func (o K0sControllerManagerOutput) ExtraArgs() pulumi.StringMapOutput {
	return o.ApplyT(func(v K0sControllerManager) map[string]string { return v.ExtraArgs }).(pulumi.StringMapOutput)
}

type K0sControllerManagerPtrOutput struct{ *pulumi.OutputState }

func (K0sControllerManagerPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sControllerManager)(nil)).Elem()
}

func (o K0sControllerManagerPtrOutput) ToK0sControllerManagerPtrOutput() K0sControllerManagerPtrOutput {
	return o
}

func (o K0sControllerManagerPtrOutput) ToK0sControllerManagerPtrOutputWithContext(ctx context.Context) K0sControllerManagerPtrOutput {
	return o
}

func (o K0sControllerManagerPtrOutput) Elem() K0sControllerManagerOutput {
	return o.ApplyT(func(v *K0sControllerManager) K0sControllerManager {
		if v != nil {
			return *v
		}
		var ret K0sControllerManager
		return ret
	}).(K0sControllerManagerOutput)
}

func (o K0sControllerManagerPtrOutput) ExtraArgs() pulumi.StringMapOutput {
	return o.ApplyT(func(v *K0sControllerManager) map[string]string {
		if v == nil {
			return nil
		}
		return v.ExtraArgs
	}).(pulumi.StringMapOutput)
}

type K0sDualStack struct {
	IPv6podCIDR     *string `pulumi:"IPv6podCIDR"`
	IPv6serviceCIDR *string `pulumi:"IPv6serviceCIDR"`
	Enabled         *bool   `pulumi:"enabled"`
}

// K0sDualStackInput is an input type that accepts K0sDualStackArgs and K0sDualStackOutput values.
// You can construct a concrete instance of `K0sDualStackInput` via:
//
//	K0sDualStackArgs{...}
type K0sDualStackInput interface {
	pulumi.Input

	ToK0sDualStackOutput() K0sDualStackOutput
	ToK0sDualStackOutputWithContext(context.Context) K0sDualStackOutput
}

type K0sDualStackArgs struct {
	IPv6podCIDR     pulumi.StringPtrInput `pulumi:"IPv6podCIDR"`
	IPv6serviceCIDR pulumi.StringPtrInput `pulumi:"IPv6serviceCIDR"`
	Enabled         pulumi.BoolPtrInput   `pulumi:"enabled"`
}

func (K0sDualStackArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sDualStack)(nil)).Elem()
}

func (i K0sDualStackArgs) ToK0sDualStackOutput() K0sDualStackOutput {
	return i.ToK0sDualStackOutputWithContext(context.Background())
}

func (i K0sDualStackArgs) ToK0sDualStackOutputWithContext(ctx context.Context) K0sDualStackOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sDualStackOutput)
}

func (i K0sDualStackArgs) ToK0sDualStackPtrOutput() K0sDualStackPtrOutput {
	return i.ToK0sDualStackPtrOutputWithContext(context.Background())
}

func (i K0sDualStackArgs) ToK0sDualStackPtrOutputWithContext(ctx context.Context) K0sDualStackPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sDualStackOutput).ToK0sDualStackPtrOutputWithContext(ctx)
}

// K0sDualStackPtrInput is an input type that accepts K0sDualStackArgs, K0sDualStackPtr and K0sDualStackPtrOutput values.
// You can construct a concrete instance of `K0sDualStackPtrInput` via:
//
//	        K0sDualStackArgs{...}
//
//	or:
//
//	        nil
type K0sDualStackPtrInput interface {
	pulumi.Input

	ToK0sDualStackPtrOutput() K0sDualStackPtrOutput
	ToK0sDualStackPtrOutputWithContext(context.Context) K0sDualStackPtrOutput
}

type k0sDualStackPtrType K0sDualStackArgs

func K0sDualStackPtr(v *K0sDualStackArgs) K0sDualStackPtrInput {
	return (*k0sDualStackPtrType)(v)
}

func (*k0sDualStackPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sDualStack)(nil)).Elem()
}

func (i *k0sDualStackPtrType) ToK0sDualStackPtrOutput() K0sDualStackPtrOutput {
	return i.ToK0sDualStackPtrOutputWithContext(context.Background())
}

func (i *k0sDualStackPtrType) ToK0sDualStackPtrOutputWithContext(ctx context.Context) K0sDualStackPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sDualStackPtrOutput)
}

type K0sDualStackOutput struct{ *pulumi.OutputState }

func (K0sDualStackOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sDualStack)(nil)).Elem()
}

func (o K0sDualStackOutput) ToK0sDualStackOutput() K0sDualStackOutput {
	return o
}

func (o K0sDualStackOutput) ToK0sDualStackOutputWithContext(ctx context.Context) K0sDualStackOutput {
	return o
}

func (o K0sDualStackOutput) ToK0sDualStackPtrOutput() K0sDualStackPtrOutput {
	return o.ToK0sDualStackPtrOutputWithContext(context.Background())
}

func (o K0sDualStackOutput) ToK0sDualStackPtrOutputWithContext(ctx context.Context) K0sDualStackPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sDualStack) *K0sDualStack {
		return &v
	}).(K0sDualStackPtrOutput)
}

func (o K0sDualStackOutput) IPv6podCIDR() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sDualStack) *string { return v.IPv6podCIDR }).(pulumi.StringPtrOutput)
}

func (o K0sDualStackOutput) IPv6serviceCIDR() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sDualStack) *string { return v.IPv6serviceCIDR }).(pulumi.StringPtrOutput)
}

func (o K0sDualStackOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v K0sDualStack) *bool { return v.Enabled }).(pulumi.BoolPtrOutput)
}

type K0sDualStackPtrOutput struct{ *pulumi.OutputState }

func (K0sDualStackPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sDualStack)(nil)).Elem()
}

func (o K0sDualStackPtrOutput) ToK0sDualStackPtrOutput() K0sDualStackPtrOutput {
	return o
}

func (o K0sDualStackPtrOutput) ToK0sDualStackPtrOutputWithContext(ctx context.Context) K0sDualStackPtrOutput {
	return o
}

func (o K0sDualStackPtrOutput) Elem() K0sDualStackOutput {
	return o.ApplyT(func(v *K0sDualStack) K0sDualStack {
		if v != nil {
			return *v
		}
		var ret K0sDualStack
		return ret
	}).(K0sDualStackOutput)
}

func (o K0sDualStackPtrOutput) IPv6podCIDR() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sDualStack) *string {
		if v == nil {
			return nil
		}
		return v.IPv6podCIDR
	}).(pulumi.StringPtrOutput)
}

func (o K0sDualStackPtrOutput) IPv6serviceCIDR() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sDualStack) *string {
		if v == nil {
			return nil
		}
		return v.IPv6serviceCIDR
	}).(pulumi.StringPtrOutput)
}

func (o K0sDualStackPtrOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *K0sDualStack) *bool {
		if v == nil {
			return nil
		}
		return v.Enabled
	}).(pulumi.BoolPtrOutput)
}

type K0sEnvoyProxy struct {
	ApiServerBindPort          *int    `pulumi:"apiServerBindPort"`
	Image                      *string `pulumi:"image"`
	ImagePullPolicy            *string `pulumi:"imagePullPolicy"`
	KonnectivityServerBindPort *int    `pulumi:"konnectivityServerBindPort"`
}

// K0sEnvoyProxyInput is an input type that accepts K0sEnvoyProxyArgs and K0sEnvoyProxyOutput values.
// You can construct a concrete instance of `K0sEnvoyProxyInput` via:
//
//	K0sEnvoyProxyArgs{...}
type K0sEnvoyProxyInput interface {
	pulumi.Input

	ToK0sEnvoyProxyOutput() K0sEnvoyProxyOutput
	ToK0sEnvoyProxyOutputWithContext(context.Context) K0sEnvoyProxyOutput
}

type K0sEnvoyProxyArgs struct {
	ApiServerBindPort          pulumi.IntPtrInput    `pulumi:"apiServerBindPort"`
	Image                      pulumi.StringPtrInput `pulumi:"image"`
	ImagePullPolicy            pulumi.StringPtrInput `pulumi:"imagePullPolicy"`
	KonnectivityServerBindPort pulumi.IntPtrInput    `pulumi:"konnectivityServerBindPort"`
}

func (K0sEnvoyProxyArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sEnvoyProxy)(nil)).Elem()
}

func (i K0sEnvoyProxyArgs) ToK0sEnvoyProxyOutput() K0sEnvoyProxyOutput {
	return i.ToK0sEnvoyProxyOutputWithContext(context.Background())
}

func (i K0sEnvoyProxyArgs) ToK0sEnvoyProxyOutputWithContext(ctx context.Context) K0sEnvoyProxyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sEnvoyProxyOutput)
}

func (i K0sEnvoyProxyArgs) ToK0sEnvoyProxyPtrOutput() K0sEnvoyProxyPtrOutput {
	return i.ToK0sEnvoyProxyPtrOutputWithContext(context.Background())
}

func (i K0sEnvoyProxyArgs) ToK0sEnvoyProxyPtrOutputWithContext(ctx context.Context) K0sEnvoyProxyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sEnvoyProxyOutput).ToK0sEnvoyProxyPtrOutputWithContext(ctx)
}

// K0sEnvoyProxyPtrInput is an input type that accepts K0sEnvoyProxyArgs, K0sEnvoyProxyPtr and K0sEnvoyProxyPtrOutput values.
// You can construct a concrete instance of `K0sEnvoyProxyPtrInput` via:
//
//	        K0sEnvoyProxyArgs{...}
//
//	or:
//
//	        nil
type K0sEnvoyProxyPtrInput interface {
	pulumi.Input

	ToK0sEnvoyProxyPtrOutput() K0sEnvoyProxyPtrOutput
	ToK0sEnvoyProxyPtrOutputWithContext(context.Context) K0sEnvoyProxyPtrOutput
}

type k0sEnvoyProxyPtrType K0sEnvoyProxyArgs

func K0sEnvoyProxyPtr(v *K0sEnvoyProxyArgs) K0sEnvoyProxyPtrInput {
	return (*k0sEnvoyProxyPtrType)(v)
}

func (*k0sEnvoyProxyPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sEnvoyProxy)(nil)).Elem()
}

func (i *k0sEnvoyProxyPtrType) ToK0sEnvoyProxyPtrOutput() K0sEnvoyProxyPtrOutput {
	return i.ToK0sEnvoyProxyPtrOutputWithContext(context.Background())
}

func (i *k0sEnvoyProxyPtrType) ToK0sEnvoyProxyPtrOutputWithContext(ctx context.Context) K0sEnvoyProxyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sEnvoyProxyPtrOutput)
}

type K0sEnvoyProxyOutput struct{ *pulumi.OutputState }

func (K0sEnvoyProxyOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sEnvoyProxy)(nil)).Elem()
}

func (o K0sEnvoyProxyOutput) ToK0sEnvoyProxyOutput() K0sEnvoyProxyOutput {
	return o
}

func (o K0sEnvoyProxyOutput) ToK0sEnvoyProxyOutputWithContext(ctx context.Context) K0sEnvoyProxyOutput {
	return o
}

func (o K0sEnvoyProxyOutput) ToK0sEnvoyProxyPtrOutput() K0sEnvoyProxyPtrOutput {
	return o.ToK0sEnvoyProxyPtrOutputWithContext(context.Background())
}

func (o K0sEnvoyProxyOutput) ToK0sEnvoyProxyPtrOutputWithContext(ctx context.Context) K0sEnvoyProxyPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sEnvoyProxy) *K0sEnvoyProxy {
		return &v
	}).(K0sEnvoyProxyPtrOutput)
}

func (o K0sEnvoyProxyOutput) ApiServerBindPort() pulumi.IntPtrOutput {
	return o.ApplyT(func(v K0sEnvoyProxy) *int { return v.ApiServerBindPort }).(pulumi.IntPtrOutput)
}

func (o K0sEnvoyProxyOutput) Image() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sEnvoyProxy) *string { return v.Image }).(pulumi.StringPtrOutput)
}

func (o K0sEnvoyProxyOutput) ImagePullPolicy() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sEnvoyProxy) *string { return v.ImagePullPolicy }).(pulumi.StringPtrOutput)
}

func (o K0sEnvoyProxyOutput) KonnectivityServerBindPort() pulumi.IntPtrOutput {
	return o.ApplyT(func(v K0sEnvoyProxy) *int { return v.KonnectivityServerBindPort }).(pulumi.IntPtrOutput)
}

type K0sEnvoyProxyPtrOutput struct{ *pulumi.OutputState }

func (K0sEnvoyProxyPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sEnvoyProxy)(nil)).Elem()
}

func (o K0sEnvoyProxyPtrOutput) ToK0sEnvoyProxyPtrOutput() K0sEnvoyProxyPtrOutput {
	return o
}

func (o K0sEnvoyProxyPtrOutput) ToK0sEnvoyProxyPtrOutputWithContext(ctx context.Context) K0sEnvoyProxyPtrOutput {
	return o
}

func (o K0sEnvoyProxyPtrOutput) Elem() K0sEnvoyProxyOutput {
	return o.ApplyT(func(v *K0sEnvoyProxy) K0sEnvoyProxy {
		if v != nil {
			return *v
		}
		var ret K0sEnvoyProxy
		return ret
	}).(K0sEnvoyProxyOutput)
}

func (o K0sEnvoyProxyPtrOutput) ApiServerBindPort() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *K0sEnvoyProxy) *int {
		if v == nil {
			return nil
		}
		return v.ApiServerBindPort
	}).(pulumi.IntPtrOutput)
}

func (o K0sEnvoyProxyPtrOutput) Image() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sEnvoyProxy) *string {
		if v == nil {
			return nil
		}
		return v.Image
	}).(pulumi.StringPtrOutput)
}

func (o K0sEnvoyProxyPtrOutput) ImagePullPolicy() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sEnvoyProxy) *string {
		if v == nil {
			return nil
		}
		return v.ImagePullPolicy
	}).(pulumi.StringPtrOutput)
}

func (o K0sEnvoyProxyPtrOutput) KonnectivityServerBindPort() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *K0sEnvoyProxy) *int {
		if v == nil {
			return nil
		}
		return v.KonnectivityServerBindPort
	}).(pulumi.IntPtrOutput)
}

type K0sEtcd struct {
	ExternalCluster *K0sEtcdExternalCluster `pulumi:"externalCluster"`
	ExtraArgs       map[string]string       `pulumi:"extraArgs"`
	PeerAddress     *string                 `pulumi:"peerAddress"`
}

// K0sEtcdInput is an input type that accepts K0sEtcdArgs and K0sEtcdOutput values.
// You can construct a concrete instance of `K0sEtcdInput` via:
//
//	K0sEtcdArgs{...}
type K0sEtcdInput interface {
	pulumi.Input

	ToK0sEtcdOutput() K0sEtcdOutput
	ToK0sEtcdOutputWithContext(context.Context) K0sEtcdOutput
}

type K0sEtcdArgs struct {
	ExternalCluster K0sEtcdExternalClusterPtrInput `pulumi:"externalCluster"`
	ExtraArgs       pulumi.StringMapInput          `pulumi:"extraArgs"`
	PeerAddress     pulumi.StringPtrInput          `pulumi:"peerAddress"`
}

func (K0sEtcdArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sEtcd)(nil)).Elem()
}

func (i K0sEtcdArgs) ToK0sEtcdOutput() K0sEtcdOutput {
	return i.ToK0sEtcdOutputWithContext(context.Background())
}

func (i K0sEtcdArgs) ToK0sEtcdOutputWithContext(ctx context.Context) K0sEtcdOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sEtcdOutput)
}

func (i K0sEtcdArgs) ToK0sEtcdPtrOutput() K0sEtcdPtrOutput {
	return i.ToK0sEtcdPtrOutputWithContext(context.Background())
}

func (i K0sEtcdArgs) ToK0sEtcdPtrOutputWithContext(ctx context.Context) K0sEtcdPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sEtcdOutput).ToK0sEtcdPtrOutputWithContext(ctx)
}

// K0sEtcdPtrInput is an input type that accepts K0sEtcdArgs, K0sEtcdPtr and K0sEtcdPtrOutput values.
// You can construct a concrete instance of `K0sEtcdPtrInput` via:
//
//	        K0sEtcdArgs{...}
//
//	or:
//
//	        nil
type K0sEtcdPtrInput interface {
	pulumi.Input

	ToK0sEtcdPtrOutput() K0sEtcdPtrOutput
	ToK0sEtcdPtrOutputWithContext(context.Context) K0sEtcdPtrOutput
}

type k0sEtcdPtrType K0sEtcdArgs

func K0sEtcdPtr(v *K0sEtcdArgs) K0sEtcdPtrInput {
	return (*k0sEtcdPtrType)(v)
}

func (*k0sEtcdPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sEtcd)(nil)).Elem()
}

func (i *k0sEtcdPtrType) ToK0sEtcdPtrOutput() K0sEtcdPtrOutput {
	return i.ToK0sEtcdPtrOutputWithContext(context.Background())
}

func (i *k0sEtcdPtrType) ToK0sEtcdPtrOutputWithContext(ctx context.Context) K0sEtcdPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sEtcdPtrOutput)
}

type K0sEtcdOutput struct{ *pulumi.OutputState }

func (K0sEtcdOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sEtcd)(nil)).Elem()
}

func (o K0sEtcdOutput) ToK0sEtcdOutput() K0sEtcdOutput {
	return o
}

func (o K0sEtcdOutput) ToK0sEtcdOutputWithContext(ctx context.Context) K0sEtcdOutput {
	return o
}

func (o K0sEtcdOutput) ToK0sEtcdPtrOutput() K0sEtcdPtrOutput {
	return o.ToK0sEtcdPtrOutputWithContext(context.Background())
}

func (o K0sEtcdOutput) ToK0sEtcdPtrOutputWithContext(ctx context.Context) K0sEtcdPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sEtcd) *K0sEtcd {
		return &v
	}).(K0sEtcdPtrOutput)
}

func (o K0sEtcdOutput) ExternalCluster() K0sEtcdExternalClusterPtrOutput {
	return o.ApplyT(func(v K0sEtcd) *K0sEtcdExternalCluster { return v.ExternalCluster }).(K0sEtcdExternalClusterPtrOutput)
}

func (o K0sEtcdOutput) ExtraArgs() pulumi.StringMapOutput {
	return o.ApplyT(func(v K0sEtcd) map[string]string { return v.ExtraArgs }).(pulumi.StringMapOutput)
}

func (o K0sEtcdOutput) PeerAddress() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sEtcd) *string { return v.PeerAddress }).(pulumi.StringPtrOutput)
}

type K0sEtcdPtrOutput struct{ *pulumi.OutputState }

func (K0sEtcdPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sEtcd)(nil)).Elem()
}

func (o K0sEtcdPtrOutput) ToK0sEtcdPtrOutput() K0sEtcdPtrOutput {
	return o
}

func (o K0sEtcdPtrOutput) ToK0sEtcdPtrOutputWithContext(ctx context.Context) K0sEtcdPtrOutput {
	return o
}

func (o K0sEtcdPtrOutput) Elem() K0sEtcdOutput {
	return o.ApplyT(func(v *K0sEtcd) K0sEtcd {
		if v != nil {
			return *v
		}
		var ret K0sEtcd
		return ret
	}).(K0sEtcdOutput)
}

func (o K0sEtcdPtrOutput) ExternalCluster() K0sEtcdExternalClusterPtrOutput {
	return o.ApplyT(func(v *K0sEtcd) *K0sEtcdExternalCluster {
		if v == nil {
			return nil
		}
		return v.ExternalCluster
	}).(K0sEtcdExternalClusterPtrOutput)
}

func (o K0sEtcdPtrOutput) ExtraArgs() pulumi.StringMapOutput {
	return o.ApplyT(func(v *K0sEtcd) map[string]string {
		if v == nil {
			return nil
		}
		return v.ExtraArgs
	}).(pulumi.StringMapOutput)
}

func (o K0sEtcdPtrOutput) PeerAddress() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sEtcd) *string {
		if v == nil {
			return nil
		}
		return v.PeerAddress
	}).(pulumi.StringPtrOutput)
}

type K0sEtcdExternalCluster struct {
	Ca         *string  `pulumi:"ca"`
	ClientCert *string  `pulumi:"clientCert"`
	ClientKey  *string  `pulumi:"clientKey"`
	Endpoints  []string `pulumi:"endpoints"`
	EtcdPrefix *string  `pulumi:"etcdPrefix"`
}

// K0sEtcdExternalClusterInput is an input type that accepts K0sEtcdExternalClusterArgs and K0sEtcdExternalClusterOutput values.
// You can construct a concrete instance of `K0sEtcdExternalClusterInput` via:
//
//	K0sEtcdExternalClusterArgs{...}
type K0sEtcdExternalClusterInput interface {
	pulumi.Input

	ToK0sEtcdExternalClusterOutput() K0sEtcdExternalClusterOutput
	ToK0sEtcdExternalClusterOutputWithContext(context.Context) K0sEtcdExternalClusterOutput
}

type K0sEtcdExternalClusterArgs struct {
	Ca         pulumi.StringPtrInput   `pulumi:"ca"`
	ClientCert pulumi.StringPtrInput   `pulumi:"clientCert"`
	ClientKey  pulumi.StringPtrInput   `pulumi:"clientKey"`
	Endpoints  pulumi.StringArrayInput `pulumi:"endpoints"`
	EtcdPrefix pulumi.StringPtrInput   `pulumi:"etcdPrefix"`
}

func (K0sEtcdExternalClusterArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sEtcdExternalCluster)(nil)).Elem()
}

func (i K0sEtcdExternalClusterArgs) ToK0sEtcdExternalClusterOutput() K0sEtcdExternalClusterOutput {
	return i.ToK0sEtcdExternalClusterOutputWithContext(context.Background())
}

func (i K0sEtcdExternalClusterArgs) ToK0sEtcdExternalClusterOutputWithContext(ctx context.Context) K0sEtcdExternalClusterOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sEtcdExternalClusterOutput)
}

func (i K0sEtcdExternalClusterArgs) ToK0sEtcdExternalClusterPtrOutput() K0sEtcdExternalClusterPtrOutput {
	return i.ToK0sEtcdExternalClusterPtrOutputWithContext(context.Background())
}

func (i K0sEtcdExternalClusterArgs) ToK0sEtcdExternalClusterPtrOutputWithContext(ctx context.Context) K0sEtcdExternalClusterPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sEtcdExternalClusterOutput).ToK0sEtcdExternalClusterPtrOutputWithContext(ctx)
}

// K0sEtcdExternalClusterPtrInput is an input type that accepts K0sEtcdExternalClusterArgs, K0sEtcdExternalClusterPtr and K0sEtcdExternalClusterPtrOutput values.
// You can construct a concrete instance of `K0sEtcdExternalClusterPtrInput` via:
//
//	        K0sEtcdExternalClusterArgs{...}
//
//	or:
//
//	        nil
type K0sEtcdExternalClusterPtrInput interface {
	pulumi.Input

	ToK0sEtcdExternalClusterPtrOutput() K0sEtcdExternalClusterPtrOutput
	ToK0sEtcdExternalClusterPtrOutputWithContext(context.Context) K0sEtcdExternalClusterPtrOutput
}

type k0sEtcdExternalClusterPtrType K0sEtcdExternalClusterArgs

func K0sEtcdExternalClusterPtr(v *K0sEtcdExternalClusterArgs) K0sEtcdExternalClusterPtrInput {
	return (*k0sEtcdExternalClusterPtrType)(v)
}

func (*k0sEtcdExternalClusterPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sEtcdExternalCluster)(nil)).Elem()
}

func (i *k0sEtcdExternalClusterPtrType) ToK0sEtcdExternalClusterPtrOutput() K0sEtcdExternalClusterPtrOutput {
	return i.ToK0sEtcdExternalClusterPtrOutputWithContext(context.Background())
}

func (i *k0sEtcdExternalClusterPtrType) ToK0sEtcdExternalClusterPtrOutputWithContext(ctx context.Context) K0sEtcdExternalClusterPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sEtcdExternalClusterPtrOutput)
}

type K0sEtcdExternalClusterOutput struct{ *pulumi.OutputState }

func (K0sEtcdExternalClusterOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sEtcdExternalCluster)(nil)).Elem()
}

func (o K0sEtcdExternalClusterOutput) ToK0sEtcdExternalClusterOutput() K0sEtcdExternalClusterOutput {
	return o
}

func (o K0sEtcdExternalClusterOutput) ToK0sEtcdExternalClusterOutputWithContext(ctx context.Context) K0sEtcdExternalClusterOutput {
	return o
}

func (o K0sEtcdExternalClusterOutput) ToK0sEtcdExternalClusterPtrOutput() K0sEtcdExternalClusterPtrOutput {
	return o.ToK0sEtcdExternalClusterPtrOutputWithContext(context.Background())
}

func (o K0sEtcdExternalClusterOutput) ToK0sEtcdExternalClusterPtrOutputWithContext(ctx context.Context) K0sEtcdExternalClusterPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sEtcdExternalCluster) *K0sEtcdExternalCluster {
		return &v
	}).(K0sEtcdExternalClusterPtrOutput)
}

func (o K0sEtcdExternalClusterOutput) Ca() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sEtcdExternalCluster) *string { return v.Ca }).(pulumi.StringPtrOutput)
}

func (o K0sEtcdExternalClusterOutput) ClientCert() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sEtcdExternalCluster) *string { return v.ClientCert }).(pulumi.StringPtrOutput)
}

func (o K0sEtcdExternalClusterOutput) ClientKey() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sEtcdExternalCluster) *string { return v.ClientKey }).(pulumi.StringPtrOutput)
}

func (o K0sEtcdExternalClusterOutput) Endpoints() pulumi.StringArrayOutput {
	return o.ApplyT(func(v K0sEtcdExternalCluster) []string { return v.Endpoints }).(pulumi.StringArrayOutput)
}

func (o K0sEtcdExternalClusterOutput) EtcdPrefix() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sEtcdExternalCluster) *string { return v.EtcdPrefix }).(pulumi.StringPtrOutput)
}

type K0sEtcdExternalClusterPtrOutput struct{ *pulumi.OutputState }

func (K0sEtcdExternalClusterPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sEtcdExternalCluster)(nil)).Elem()
}

func (o K0sEtcdExternalClusterPtrOutput) ToK0sEtcdExternalClusterPtrOutput() K0sEtcdExternalClusterPtrOutput {
	return o
}

func (o K0sEtcdExternalClusterPtrOutput) ToK0sEtcdExternalClusterPtrOutputWithContext(ctx context.Context) K0sEtcdExternalClusterPtrOutput {
	return o
}

func (o K0sEtcdExternalClusterPtrOutput) Elem() K0sEtcdExternalClusterOutput {
	return o.ApplyT(func(v *K0sEtcdExternalCluster) K0sEtcdExternalCluster {
		if v != nil {
			return *v
		}
		var ret K0sEtcdExternalCluster
		return ret
	}).(K0sEtcdExternalClusterOutput)
}

func (o K0sEtcdExternalClusterPtrOutput) Ca() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sEtcdExternalCluster) *string {
		if v == nil {
			return nil
		}
		return v.Ca
	}).(pulumi.StringPtrOutput)
}

func (o K0sEtcdExternalClusterPtrOutput) ClientCert() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sEtcdExternalCluster) *string {
		if v == nil {
			return nil
		}
		return v.ClientCert
	}).(pulumi.StringPtrOutput)
}

func (o K0sEtcdExternalClusterPtrOutput) ClientKey() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sEtcdExternalCluster) *string {
		if v == nil {
			return nil
		}
		return v.ClientKey
	}).(pulumi.StringPtrOutput)
}

func (o K0sEtcdExternalClusterPtrOutput) Endpoints() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *K0sEtcdExternalCluster) []string {
		if v == nil {
			return nil
		}
		return v.Endpoints
	}).(pulumi.StringArrayOutput)
}

func (o K0sEtcdExternalClusterPtrOutput) EtcdPrefix() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sEtcdExternalCluster) *string {
		if v == nil {
			return nil
		}
		return v.EtcdPrefix
	}).(pulumi.StringPtrOutput)
}

type K0sFeatureGate struct {
	Components []string `pulumi:"components"`
	Enabled    *bool    `pulumi:"enabled"`
	Name       string   `pulumi:"name"`
}

// K0sFeatureGateInput is an input type that accepts K0sFeatureGateArgs and K0sFeatureGateOutput values.
// You can construct a concrete instance of `K0sFeatureGateInput` via:
//
//	K0sFeatureGateArgs{...}
type K0sFeatureGateInput interface {
	pulumi.Input

	ToK0sFeatureGateOutput() K0sFeatureGateOutput
	ToK0sFeatureGateOutputWithContext(context.Context) K0sFeatureGateOutput
}

type K0sFeatureGateArgs struct {
	Components pulumi.StringArrayInput `pulumi:"components"`
	Enabled    pulumi.BoolPtrInput     `pulumi:"enabled"`
	Name       pulumi.StringInput      `pulumi:"name"`
}

func (K0sFeatureGateArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sFeatureGate)(nil)).Elem()
}

func (i K0sFeatureGateArgs) ToK0sFeatureGateOutput() K0sFeatureGateOutput {
	return i.ToK0sFeatureGateOutputWithContext(context.Background())
}

func (i K0sFeatureGateArgs) ToK0sFeatureGateOutputWithContext(ctx context.Context) K0sFeatureGateOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sFeatureGateOutput)
}

// K0sFeatureGateArrayInput is an input type that accepts K0sFeatureGateArray and K0sFeatureGateArrayOutput values.
// You can construct a concrete instance of `K0sFeatureGateArrayInput` via:
//
//	K0sFeatureGateArray{ K0sFeatureGateArgs{...} }
type K0sFeatureGateArrayInput interface {
	pulumi.Input

	ToK0sFeatureGateArrayOutput() K0sFeatureGateArrayOutput
	ToK0sFeatureGateArrayOutputWithContext(context.Context) K0sFeatureGateArrayOutput
}

type K0sFeatureGateArray []K0sFeatureGateInput

func (K0sFeatureGateArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]K0sFeatureGate)(nil)).Elem()
}

func (i K0sFeatureGateArray) ToK0sFeatureGateArrayOutput() K0sFeatureGateArrayOutput {
	return i.ToK0sFeatureGateArrayOutputWithContext(context.Background())
}

func (i K0sFeatureGateArray) ToK0sFeatureGateArrayOutputWithContext(ctx context.Context) K0sFeatureGateArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sFeatureGateArrayOutput)
}

type K0sFeatureGateOutput struct{ *pulumi.OutputState }

func (K0sFeatureGateOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sFeatureGate)(nil)).Elem()
}

func (o K0sFeatureGateOutput) ToK0sFeatureGateOutput() K0sFeatureGateOutput {
	return o
}

func (o K0sFeatureGateOutput) ToK0sFeatureGateOutputWithContext(ctx context.Context) K0sFeatureGateOutput {
	return o
}

func (o K0sFeatureGateOutput) Components() pulumi.StringArrayOutput {
	return o.ApplyT(func(v K0sFeatureGate) []string { return v.Components }).(pulumi.StringArrayOutput)
}

func (o K0sFeatureGateOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v K0sFeatureGate) *bool { return v.Enabled }).(pulumi.BoolPtrOutput)
}

func (o K0sFeatureGateOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v K0sFeatureGate) string { return v.Name }).(pulumi.StringOutput)
}

type K0sFeatureGateArrayOutput struct{ *pulumi.OutputState }

func (K0sFeatureGateArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]K0sFeatureGate)(nil)).Elem()
}

func (o K0sFeatureGateArrayOutput) ToK0sFeatureGateArrayOutput() K0sFeatureGateArrayOutput {
	return o
}

func (o K0sFeatureGateArrayOutput) ToK0sFeatureGateArrayOutputWithContext(ctx context.Context) K0sFeatureGateArrayOutput {
	return o
}

func (o K0sFeatureGateArrayOutput) Index(i pulumi.IntInput) K0sFeatureGateOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) K0sFeatureGate {
		return vs[0].([]K0sFeatureGate)[vs[1].(int)]
	}).(K0sFeatureGateOutput)
}

type K0sImage struct {
	Image   *string `pulumi:"image"`
	Version *string `pulumi:"version"`
}

// K0sImageInput is an input type that accepts K0sImageArgs and K0sImageOutput values.
// You can construct a concrete instance of `K0sImageInput` via:
//
//	K0sImageArgs{...}
type K0sImageInput interface {
	pulumi.Input

	ToK0sImageOutput() K0sImageOutput
	ToK0sImageOutputWithContext(context.Context) K0sImageOutput
}

type K0sImageArgs struct {
	Image   pulumi.StringPtrInput `pulumi:"image"`
	Version pulumi.StringPtrInput `pulumi:"version"`
}

func (K0sImageArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sImage)(nil)).Elem()
}

func (i K0sImageArgs) ToK0sImageOutput() K0sImageOutput {
	return i.ToK0sImageOutputWithContext(context.Background())
}

func (i K0sImageArgs) ToK0sImageOutputWithContext(ctx context.Context) K0sImageOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sImageOutput)
}

func (i K0sImageArgs) ToK0sImagePtrOutput() K0sImagePtrOutput {
	return i.ToK0sImagePtrOutputWithContext(context.Background())
}

func (i K0sImageArgs) ToK0sImagePtrOutputWithContext(ctx context.Context) K0sImagePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sImageOutput).ToK0sImagePtrOutputWithContext(ctx)
}

// K0sImagePtrInput is an input type that accepts K0sImageArgs, K0sImagePtr and K0sImagePtrOutput values.
// You can construct a concrete instance of `K0sImagePtrInput` via:
//
//	        K0sImageArgs{...}
//
//	or:
//
//	        nil
type K0sImagePtrInput interface {
	pulumi.Input

	ToK0sImagePtrOutput() K0sImagePtrOutput
	ToK0sImagePtrOutputWithContext(context.Context) K0sImagePtrOutput
}

type k0sImagePtrType K0sImageArgs

func K0sImagePtr(v *K0sImageArgs) K0sImagePtrInput {
	return (*k0sImagePtrType)(v)
}

func (*k0sImagePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sImage)(nil)).Elem()
}

func (i *k0sImagePtrType) ToK0sImagePtrOutput() K0sImagePtrOutput {
	return i.ToK0sImagePtrOutputWithContext(context.Background())
}

func (i *k0sImagePtrType) ToK0sImagePtrOutputWithContext(ctx context.Context) K0sImagePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sImagePtrOutput)
}

type K0sImageOutput struct{ *pulumi.OutputState }

func (K0sImageOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sImage)(nil)).Elem()
}

func (o K0sImageOutput) ToK0sImageOutput() K0sImageOutput {
	return o
}

func (o K0sImageOutput) ToK0sImageOutputWithContext(ctx context.Context) K0sImageOutput {
	return o
}

func (o K0sImageOutput) ToK0sImagePtrOutput() K0sImagePtrOutput {
	return o.ToK0sImagePtrOutputWithContext(context.Background())
}

func (o K0sImageOutput) ToK0sImagePtrOutputWithContext(ctx context.Context) K0sImagePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sImage) *K0sImage {
		return &v
	}).(K0sImagePtrOutput)
}

func (o K0sImageOutput) Image() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sImage) *string { return v.Image }).(pulumi.StringPtrOutput)
}

func (o K0sImageOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sImage) *string { return v.Version }).(pulumi.StringPtrOutput)
}

type K0sImagePtrOutput struct{ *pulumi.OutputState }

func (K0sImagePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sImage)(nil)).Elem()
}

func (o K0sImagePtrOutput) ToK0sImagePtrOutput() K0sImagePtrOutput {
	return o
}

func (o K0sImagePtrOutput) ToK0sImagePtrOutputWithContext(ctx context.Context) K0sImagePtrOutput {
	return o
}

func (o K0sImagePtrOutput) Elem() K0sImageOutput {
	return o.ApplyT(func(v *K0sImage) K0sImage {
		if v != nil {
			return *v
		}
		var ret K0sImage
		return ret
	}).(K0sImageOutput)
}

func (o K0sImagePtrOutput) Image() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sImage) *string {
		if v == nil {
			return nil
		}
		return v.Image
	}).(pulumi.StringPtrOutput)
}

func (o K0sImagePtrOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sImage) *string {
		if v == nil {
			return nil
		}
		return v.Version
	}).(pulumi.StringPtrOutput)
}

type K0sImages struct {
	Calico              *K0sCalicoImage     `pulumi:"calico"`
	Coredns             *K0sImage           `pulumi:"coredns"`
	Default_pull_policy *string             `pulumi:"default_pull_policy"`
	Konnectivity        *K0sImage           `pulumi:"konnectivity"`
	Kubeproxy           *K0sImage           `pulumi:"kubeproxy"`
	Kuberouter          *K0sKubeRouterImage `pulumi:"kuberouter"`
	Metricsserver       *K0sImage           `pulumi:"metricsserver"`
	Pause               *K0sImage           `pulumi:"pause"`
	Repository          *string             `pulumi:"repository"`
}

// K0sImagesInput is an input type that accepts K0sImagesArgs and K0sImagesOutput values.
// You can construct a concrete instance of `K0sImagesInput` via:
//
//	K0sImagesArgs{...}
type K0sImagesInput interface {
	pulumi.Input

	ToK0sImagesOutput() K0sImagesOutput
	ToK0sImagesOutputWithContext(context.Context) K0sImagesOutput
}

type K0sImagesArgs struct {
	Calico              K0sCalicoImagePtrInput     `pulumi:"calico"`
	Coredns             K0sImagePtrInput           `pulumi:"coredns"`
	Default_pull_policy pulumi.StringPtrInput      `pulumi:"default_pull_policy"`
	Konnectivity        K0sImagePtrInput           `pulumi:"konnectivity"`
	Kubeproxy           K0sImagePtrInput           `pulumi:"kubeproxy"`
	Kuberouter          K0sKubeRouterImagePtrInput `pulumi:"kuberouter"`
	Metricsserver       K0sImagePtrInput           `pulumi:"metricsserver"`
	Pause               K0sImagePtrInput           `pulumi:"pause"`
	Repository          pulumi.StringPtrInput      `pulumi:"repository"`
}

func (K0sImagesArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sImages)(nil)).Elem()
}

func (i K0sImagesArgs) ToK0sImagesOutput() K0sImagesOutput {
	return i.ToK0sImagesOutputWithContext(context.Background())
}

func (i K0sImagesArgs) ToK0sImagesOutputWithContext(ctx context.Context) K0sImagesOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sImagesOutput)
}

func (i K0sImagesArgs) ToK0sImagesPtrOutput() K0sImagesPtrOutput {
	return i.ToK0sImagesPtrOutputWithContext(context.Background())
}

func (i K0sImagesArgs) ToK0sImagesPtrOutputWithContext(ctx context.Context) K0sImagesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sImagesOutput).ToK0sImagesPtrOutputWithContext(ctx)
}

// K0sImagesPtrInput is an input type that accepts K0sImagesArgs, K0sImagesPtr and K0sImagesPtrOutput values.
// You can construct a concrete instance of `K0sImagesPtrInput` via:
//
//	        K0sImagesArgs{...}
//
//	or:
//
//	        nil
type K0sImagesPtrInput interface {
	pulumi.Input

	ToK0sImagesPtrOutput() K0sImagesPtrOutput
	ToK0sImagesPtrOutputWithContext(context.Context) K0sImagesPtrOutput
}

type k0sImagesPtrType K0sImagesArgs

func K0sImagesPtr(v *K0sImagesArgs) K0sImagesPtrInput {
	return (*k0sImagesPtrType)(v)
}

func (*k0sImagesPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sImages)(nil)).Elem()
}

func (i *k0sImagesPtrType) ToK0sImagesPtrOutput() K0sImagesPtrOutput {
	return i.ToK0sImagesPtrOutputWithContext(context.Background())
}

func (i *k0sImagesPtrType) ToK0sImagesPtrOutputWithContext(ctx context.Context) K0sImagesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sImagesPtrOutput)
}

type K0sImagesOutput struct{ *pulumi.OutputState }

func (K0sImagesOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sImages)(nil)).Elem()
}

func (o K0sImagesOutput) ToK0sImagesOutput() K0sImagesOutput {
	return o
}

func (o K0sImagesOutput) ToK0sImagesOutputWithContext(ctx context.Context) K0sImagesOutput {
	return o
}

func (o K0sImagesOutput) ToK0sImagesPtrOutput() K0sImagesPtrOutput {
	return o.ToK0sImagesPtrOutputWithContext(context.Background())
}

func (o K0sImagesOutput) ToK0sImagesPtrOutputWithContext(ctx context.Context) K0sImagesPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sImages) *K0sImages {
		return &v
	}).(K0sImagesPtrOutput)
}

func (o K0sImagesOutput) Calico() K0sCalicoImagePtrOutput {
	return o.ApplyT(func(v K0sImages) *K0sCalicoImage { return v.Calico }).(K0sCalicoImagePtrOutput)
}

func (o K0sImagesOutput) Coredns() K0sImagePtrOutput {
	return o.ApplyT(func(v K0sImages) *K0sImage { return v.Coredns }).(K0sImagePtrOutput)
}

func (o K0sImagesOutput) Default_pull_policy() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sImages) *string { return v.Default_pull_policy }).(pulumi.StringPtrOutput)
}

func (o K0sImagesOutput) Konnectivity() K0sImagePtrOutput {
	return o.ApplyT(func(v K0sImages) *K0sImage { return v.Konnectivity }).(K0sImagePtrOutput)
}

func (o K0sImagesOutput) Kubeproxy() K0sImagePtrOutput {
	return o.ApplyT(func(v K0sImages) *K0sImage { return v.Kubeproxy }).(K0sImagePtrOutput)
}

func (o K0sImagesOutput) Kuberouter() K0sKubeRouterImagePtrOutput {
	return o.ApplyT(func(v K0sImages) *K0sKubeRouterImage { return v.Kuberouter }).(K0sKubeRouterImagePtrOutput)
}

func (o K0sImagesOutput) Metricsserver() K0sImagePtrOutput {
	return o.ApplyT(func(v K0sImages) *K0sImage { return v.Metricsserver }).(K0sImagePtrOutput)
}

func (o K0sImagesOutput) Pause() K0sImagePtrOutput {
	return o.ApplyT(func(v K0sImages) *K0sImage { return v.Pause }).(K0sImagePtrOutput)
}

func (o K0sImagesOutput) Repository() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sImages) *string { return v.Repository }).(pulumi.StringPtrOutput)
}

type K0sImagesPtrOutput struct{ *pulumi.OutputState }

func (K0sImagesPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sImages)(nil)).Elem()
}

func (o K0sImagesPtrOutput) ToK0sImagesPtrOutput() K0sImagesPtrOutput {
	return o
}

func (o K0sImagesPtrOutput) ToK0sImagesPtrOutputWithContext(ctx context.Context) K0sImagesPtrOutput {
	return o
}

func (o K0sImagesPtrOutput) Elem() K0sImagesOutput {
	return o.ApplyT(func(v *K0sImages) K0sImages {
		if v != nil {
			return *v
		}
		var ret K0sImages
		return ret
	}).(K0sImagesOutput)
}

func (o K0sImagesPtrOutput) Calico() K0sCalicoImagePtrOutput {
	return o.ApplyT(func(v *K0sImages) *K0sCalicoImage {
		if v == nil {
			return nil
		}
		return v.Calico
	}).(K0sCalicoImagePtrOutput)
}

func (o K0sImagesPtrOutput) Coredns() K0sImagePtrOutput {
	return o.ApplyT(func(v *K0sImages) *K0sImage {
		if v == nil {
			return nil
		}
		return v.Coredns
	}).(K0sImagePtrOutput)
}

func (o K0sImagesPtrOutput) Default_pull_policy() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sImages) *string {
		if v == nil {
			return nil
		}
		return v.Default_pull_policy
	}).(pulumi.StringPtrOutput)
}

func (o K0sImagesPtrOutput) Konnectivity() K0sImagePtrOutput {
	return o.ApplyT(func(v *K0sImages) *K0sImage {
		if v == nil {
			return nil
		}
		return v.Konnectivity
	}).(K0sImagePtrOutput)
}

func (o K0sImagesPtrOutput) Kubeproxy() K0sImagePtrOutput {
	return o.ApplyT(func(v *K0sImages) *K0sImage {
		if v == nil {
			return nil
		}
		return v.Kubeproxy
	}).(K0sImagePtrOutput)
}

func (o K0sImagesPtrOutput) Kuberouter() K0sKubeRouterImagePtrOutput {
	return o.ApplyT(func(v *K0sImages) *K0sKubeRouterImage {
		if v == nil {
			return nil
		}
		return v.Kuberouter
	}).(K0sKubeRouterImagePtrOutput)
}

func (o K0sImagesPtrOutput) Metricsserver() K0sImagePtrOutput {
	return o.ApplyT(func(v *K0sImages) *K0sImage {
		if v == nil {
			return nil
		}
		return v.Metricsserver
	}).(K0sImagePtrOutput)
}

func (o K0sImagesPtrOutput) Pause() K0sImagePtrOutput {
	return o.ApplyT(func(v *K0sImages) *K0sImage {
		if v == nil {
			return nil
		}
		return v.Pause
	}).(K0sImagePtrOutput)
}

func (o K0sImagesPtrOutput) Repository() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sImages) *string {
		if v == nil {
			return nil
		}
		return v.Repository
	}).(pulumi.StringPtrOutput)
}

type K0sInstallConfig struct {
	Users *K0sInstallConfigUser `pulumi:"users"`
}

// K0sInstallConfigInput is an input type that accepts K0sInstallConfigArgs and K0sInstallConfigOutput values.
// You can construct a concrete instance of `K0sInstallConfigInput` via:
//
//	K0sInstallConfigArgs{...}
type K0sInstallConfigInput interface {
	pulumi.Input

	ToK0sInstallConfigOutput() K0sInstallConfigOutput
	ToK0sInstallConfigOutputWithContext(context.Context) K0sInstallConfigOutput
}

type K0sInstallConfigArgs struct {
	Users K0sInstallConfigUserPtrInput `pulumi:"users"`
}

func (K0sInstallConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sInstallConfig)(nil)).Elem()
}

func (i K0sInstallConfigArgs) ToK0sInstallConfigOutput() K0sInstallConfigOutput {
	return i.ToK0sInstallConfigOutputWithContext(context.Background())
}

func (i K0sInstallConfigArgs) ToK0sInstallConfigOutputWithContext(ctx context.Context) K0sInstallConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sInstallConfigOutput)
}

func (i K0sInstallConfigArgs) ToK0sInstallConfigPtrOutput() K0sInstallConfigPtrOutput {
	return i.ToK0sInstallConfigPtrOutputWithContext(context.Background())
}

func (i K0sInstallConfigArgs) ToK0sInstallConfigPtrOutputWithContext(ctx context.Context) K0sInstallConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sInstallConfigOutput).ToK0sInstallConfigPtrOutputWithContext(ctx)
}

// K0sInstallConfigPtrInput is an input type that accepts K0sInstallConfigArgs, K0sInstallConfigPtr and K0sInstallConfigPtrOutput values.
// You can construct a concrete instance of `K0sInstallConfigPtrInput` via:
//
//	        K0sInstallConfigArgs{...}
//
//	or:
//
//	        nil
type K0sInstallConfigPtrInput interface {
	pulumi.Input

	ToK0sInstallConfigPtrOutput() K0sInstallConfigPtrOutput
	ToK0sInstallConfigPtrOutputWithContext(context.Context) K0sInstallConfigPtrOutput
}

type k0sInstallConfigPtrType K0sInstallConfigArgs

func K0sInstallConfigPtr(v *K0sInstallConfigArgs) K0sInstallConfigPtrInput {
	return (*k0sInstallConfigPtrType)(v)
}

func (*k0sInstallConfigPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sInstallConfig)(nil)).Elem()
}

func (i *k0sInstallConfigPtrType) ToK0sInstallConfigPtrOutput() K0sInstallConfigPtrOutput {
	return i.ToK0sInstallConfigPtrOutputWithContext(context.Background())
}

func (i *k0sInstallConfigPtrType) ToK0sInstallConfigPtrOutputWithContext(ctx context.Context) K0sInstallConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sInstallConfigPtrOutput)
}

type K0sInstallConfigOutput struct{ *pulumi.OutputState }

func (K0sInstallConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sInstallConfig)(nil)).Elem()
}

func (o K0sInstallConfigOutput) ToK0sInstallConfigOutput() K0sInstallConfigOutput {
	return o
}

func (o K0sInstallConfigOutput) ToK0sInstallConfigOutputWithContext(ctx context.Context) K0sInstallConfigOutput {
	return o
}

func (o K0sInstallConfigOutput) ToK0sInstallConfigPtrOutput() K0sInstallConfigPtrOutput {
	return o.ToK0sInstallConfigPtrOutputWithContext(context.Background())
}

func (o K0sInstallConfigOutput) ToK0sInstallConfigPtrOutputWithContext(ctx context.Context) K0sInstallConfigPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sInstallConfig) *K0sInstallConfig {
		return &v
	}).(K0sInstallConfigPtrOutput)
}

func (o K0sInstallConfigOutput) Users() K0sInstallConfigUserPtrOutput {
	return o.ApplyT(func(v K0sInstallConfig) *K0sInstallConfigUser { return v.Users }).(K0sInstallConfigUserPtrOutput)
}

type K0sInstallConfigPtrOutput struct{ *pulumi.OutputState }

func (K0sInstallConfigPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sInstallConfig)(nil)).Elem()
}

func (o K0sInstallConfigPtrOutput) ToK0sInstallConfigPtrOutput() K0sInstallConfigPtrOutput {
	return o
}

func (o K0sInstallConfigPtrOutput) ToK0sInstallConfigPtrOutputWithContext(ctx context.Context) K0sInstallConfigPtrOutput {
	return o
}

func (o K0sInstallConfigPtrOutput) Elem() K0sInstallConfigOutput {
	return o.ApplyT(func(v *K0sInstallConfig) K0sInstallConfig {
		if v != nil {
			return *v
		}
		var ret K0sInstallConfig
		return ret
	}).(K0sInstallConfigOutput)
}

func (o K0sInstallConfigPtrOutput) Users() K0sInstallConfigUserPtrOutput {
	return o.ApplyT(func(v *K0sInstallConfig) *K0sInstallConfigUser {
		if v == nil {
			return nil
		}
		return v.Users
	}).(K0sInstallConfigUserPtrOutput)
}

type K0sInstallConfigUser struct {
	EtcdUser          *string `pulumi:"etcdUser"`
	KineUser          *string `pulumi:"kineUser"`
	KonnectivityUser  *string `pulumi:"konnectivityUser"`
	KubeAPIserverUser *string `pulumi:"kubeAPIserverUser"`
	KubeSchedulerUser *string `pulumi:"kubeSchedulerUser"`
}

// K0sInstallConfigUserInput is an input type that accepts K0sInstallConfigUserArgs and K0sInstallConfigUserOutput values.
// You can construct a concrete instance of `K0sInstallConfigUserInput` via:
//
//	K0sInstallConfigUserArgs{...}
type K0sInstallConfigUserInput interface {
	pulumi.Input

	ToK0sInstallConfigUserOutput() K0sInstallConfigUserOutput
	ToK0sInstallConfigUserOutputWithContext(context.Context) K0sInstallConfigUserOutput
}

type K0sInstallConfigUserArgs struct {
	EtcdUser          pulumi.StringPtrInput `pulumi:"etcdUser"`
	KineUser          pulumi.StringPtrInput `pulumi:"kineUser"`
	KonnectivityUser  pulumi.StringPtrInput `pulumi:"konnectivityUser"`
	KubeAPIserverUser pulumi.StringPtrInput `pulumi:"kubeAPIserverUser"`
	KubeSchedulerUser pulumi.StringPtrInput `pulumi:"kubeSchedulerUser"`
}

func (K0sInstallConfigUserArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sInstallConfigUser)(nil)).Elem()
}

func (i K0sInstallConfigUserArgs) ToK0sInstallConfigUserOutput() K0sInstallConfigUserOutput {
	return i.ToK0sInstallConfigUserOutputWithContext(context.Background())
}

func (i K0sInstallConfigUserArgs) ToK0sInstallConfigUserOutputWithContext(ctx context.Context) K0sInstallConfigUserOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sInstallConfigUserOutput)
}

func (i K0sInstallConfigUserArgs) ToK0sInstallConfigUserPtrOutput() K0sInstallConfigUserPtrOutput {
	return i.ToK0sInstallConfigUserPtrOutputWithContext(context.Background())
}

func (i K0sInstallConfigUserArgs) ToK0sInstallConfigUserPtrOutputWithContext(ctx context.Context) K0sInstallConfigUserPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sInstallConfigUserOutput).ToK0sInstallConfigUserPtrOutputWithContext(ctx)
}

// K0sInstallConfigUserPtrInput is an input type that accepts K0sInstallConfigUserArgs, K0sInstallConfigUserPtr and K0sInstallConfigUserPtrOutput values.
// You can construct a concrete instance of `K0sInstallConfigUserPtrInput` via:
//
//	        K0sInstallConfigUserArgs{...}
//
//	or:
//
//	        nil
type K0sInstallConfigUserPtrInput interface {
	pulumi.Input

	ToK0sInstallConfigUserPtrOutput() K0sInstallConfigUserPtrOutput
	ToK0sInstallConfigUserPtrOutputWithContext(context.Context) K0sInstallConfigUserPtrOutput
}

type k0sInstallConfigUserPtrType K0sInstallConfigUserArgs

func K0sInstallConfigUserPtr(v *K0sInstallConfigUserArgs) K0sInstallConfigUserPtrInput {
	return (*k0sInstallConfigUserPtrType)(v)
}

func (*k0sInstallConfigUserPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sInstallConfigUser)(nil)).Elem()
}

func (i *k0sInstallConfigUserPtrType) ToK0sInstallConfigUserPtrOutput() K0sInstallConfigUserPtrOutput {
	return i.ToK0sInstallConfigUserPtrOutputWithContext(context.Background())
}

func (i *k0sInstallConfigUserPtrType) ToK0sInstallConfigUserPtrOutputWithContext(ctx context.Context) K0sInstallConfigUserPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sInstallConfigUserPtrOutput)
}

type K0sInstallConfigUserOutput struct{ *pulumi.OutputState }

func (K0sInstallConfigUserOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sInstallConfigUser)(nil)).Elem()
}

func (o K0sInstallConfigUserOutput) ToK0sInstallConfigUserOutput() K0sInstallConfigUserOutput {
	return o
}

func (o K0sInstallConfigUserOutput) ToK0sInstallConfigUserOutputWithContext(ctx context.Context) K0sInstallConfigUserOutput {
	return o
}

func (o K0sInstallConfigUserOutput) ToK0sInstallConfigUserPtrOutput() K0sInstallConfigUserPtrOutput {
	return o.ToK0sInstallConfigUserPtrOutputWithContext(context.Background())
}

func (o K0sInstallConfigUserOutput) ToK0sInstallConfigUserPtrOutputWithContext(ctx context.Context) K0sInstallConfigUserPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sInstallConfigUser) *K0sInstallConfigUser {
		return &v
	}).(K0sInstallConfigUserPtrOutput)
}

func (o K0sInstallConfigUserOutput) EtcdUser() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sInstallConfigUser) *string { return v.EtcdUser }).(pulumi.StringPtrOutput)
}

func (o K0sInstallConfigUserOutput) KineUser() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sInstallConfigUser) *string { return v.KineUser }).(pulumi.StringPtrOutput)
}

func (o K0sInstallConfigUserOutput) KonnectivityUser() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sInstallConfigUser) *string { return v.KonnectivityUser }).(pulumi.StringPtrOutput)
}

func (o K0sInstallConfigUserOutput) KubeAPIserverUser() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sInstallConfigUser) *string { return v.KubeAPIserverUser }).(pulumi.StringPtrOutput)
}

func (o K0sInstallConfigUserOutput) KubeSchedulerUser() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sInstallConfigUser) *string { return v.KubeSchedulerUser }).(pulumi.StringPtrOutput)
}

type K0sInstallConfigUserPtrOutput struct{ *pulumi.OutputState }

func (K0sInstallConfigUserPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sInstallConfigUser)(nil)).Elem()
}

func (o K0sInstallConfigUserPtrOutput) ToK0sInstallConfigUserPtrOutput() K0sInstallConfigUserPtrOutput {
	return o
}

func (o K0sInstallConfigUserPtrOutput) ToK0sInstallConfigUserPtrOutputWithContext(ctx context.Context) K0sInstallConfigUserPtrOutput {
	return o
}

func (o K0sInstallConfigUserPtrOutput) Elem() K0sInstallConfigUserOutput {
	return o.ApplyT(func(v *K0sInstallConfigUser) K0sInstallConfigUser {
		if v != nil {
			return *v
		}
		var ret K0sInstallConfigUser
		return ret
	}).(K0sInstallConfigUserOutput)
}

func (o K0sInstallConfigUserPtrOutput) EtcdUser() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sInstallConfigUser) *string {
		if v == nil {
			return nil
		}
		return v.EtcdUser
	}).(pulumi.StringPtrOutput)
}

func (o K0sInstallConfigUserPtrOutput) KineUser() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sInstallConfigUser) *string {
		if v == nil {
			return nil
		}
		return v.KineUser
	}).(pulumi.StringPtrOutput)
}

func (o K0sInstallConfigUserPtrOutput) KonnectivityUser() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sInstallConfigUser) *string {
		if v == nil {
			return nil
		}
		return v.KonnectivityUser
	}).(pulumi.StringPtrOutput)
}

func (o K0sInstallConfigUserPtrOutput) KubeAPIserverUser() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sInstallConfigUser) *string {
		if v == nil {
			return nil
		}
		return v.KubeAPIserverUser
	}).(pulumi.StringPtrOutput)
}

func (o K0sInstallConfigUserPtrOutput) KubeSchedulerUser() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sInstallConfigUser) *string {
		if v == nil {
			return nil
		}
		return v.KubeSchedulerUser
	}).(pulumi.StringPtrOutput)
}

type K0sKine struct {
	DataSource string `pulumi:"dataSource"`
}

// K0sKineInput is an input type that accepts K0sKineArgs and K0sKineOutput values.
// You can construct a concrete instance of `K0sKineInput` via:
//
//	K0sKineArgs{...}
type K0sKineInput interface {
	pulumi.Input

	ToK0sKineOutput() K0sKineOutput
	ToK0sKineOutputWithContext(context.Context) K0sKineOutput
}

type K0sKineArgs struct {
	DataSource pulumi.StringInput `pulumi:"dataSource"`
}

func (K0sKineArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sKine)(nil)).Elem()
}

func (i K0sKineArgs) ToK0sKineOutput() K0sKineOutput {
	return i.ToK0sKineOutputWithContext(context.Background())
}

func (i K0sKineArgs) ToK0sKineOutputWithContext(ctx context.Context) K0sKineOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKineOutput)
}

func (i K0sKineArgs) ToK0sKinePtrOutput() K0sKinePtrOutput {
	return i.ToK0sKinePtrOutputWithContext(context.Background())
}

func (i K0sKineArgs) ToK0sKinePtrOutputWithContext(ctx context.Context) K0sKinePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKineOutput).ToK0sKinePtrOutputWithContext(ctx)
}

// K0sKinePtrInput is an input type that accepts K0sKineArgs, K0sKinePtr and K0sKinePtrOutput values.
// You can construct a concrete instance of `K0sKinePtrInput` via:
//
//	        K0sKineArgs{...}
//
//	or:
//
//	        nil
type K0sKinePtrInput interface {
	pulumi.Input

	ToK0sKinePtrOutput() K0sKinePtrOutput
	ToK0sKinePtrOutputWithContext(context.Context) K0sKinePtrOutput
}

type k0sKinePtrType K0sKineArgs

func K0sKinePtr(v *K0sKineArgs) K0sKinePtrInput {
	return (*k0sKinePtrType)(v)
}

func (*k0sKinePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sKine)(nil)).Elem()
}

func (i *k0sKinePtrType) ToK0sKinePtrOutput() K0sKinePtrOutput {
	return i.ToK0sKinePtrOutputWithContext(context.Background())
}

func (i *k0sKinePtrType) ToK0sKinePtrOutputWithContext(ctx context.Context) K0sKinePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKinePtrOutput)
}

type K0sKineOutput struct{ *pulumi.OutputState }

func (K0sKineOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sKine)(nil)).Elem()
}

func (o K0sKineOutput) ToK0sKineOutput() K0sKineOutput {
	return o
}

func (o K0sKineOutput) ToK0sKineOutputWithContext(ctx context.Context) K0sKineOutput {
	return o
}

func (o K0sKineOutput) ToK0sKinePtrOutput() K0sKinePtrOutput {
	return o.ToK0sKinePtrOutputWithContext(context.Background())
}

func (o K0sKineOutput) ToK0sKinePtrOutputWithContext(ctx context.Context) K0sKinePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sKine) *K0sKine {
		return &v
	}).(K0sKinePtrOutput)
}

func (o K0sKineOutput) DataSource() pulumi.StringOutput {
	return o.ApplyT(func(v K0sKine) string { return v.DataSource }).(pulumi.StringOutput)
}

type K0sKinePtrOutput struct{ *pulumi.OutputState }

func (K0sKinePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sKine)(nil)).Elem()
}

func (o K0sKinePtrOutput) ToK0sKinePtrOutput() K0sKinePtrOutput {
	return o
}

func (o K0sKinePtrOutput) ToK0sKinePtrOutputWithContext(ctx context.Context) K0sKinePtrOutput {
	return o
}

func (o K0sKinePtrOutput) Elem() K0sKineOutput {
	return o.ApplyT(func(v *K0sKine) K0sKine {
		if v != nil {
			return *v
		}
		var ret K0sKine
		return ret
	}).(K0sKineOutput)
}

func (o K0sKinePtrOutput) DataSource() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sKine) *string {
		if v == nil {
			return nil
		}
		return &v.DataSource
	}).(pulumi.StringPtrOutput)
}

type K0sKonnectivity struct {
	AdminPort *int `pulumi:"adminPort"`
	AgentPort *int `pulumi:"agentPort"`
}

// K0sKonnectivityInput is an input type that accepts K0sKonnectivityArgs and K0sKonnectivityOutput values.
// You can construct a concrete instance of `K0sKonnectivityInput` via:
//
//	K0sKonnectivityArgs{...}
type K0sKonnectivityInput interface {
	pulumi.Input

	ToK0sKonnectivityOutput() K0sKonnectivityOutput
	ToK0sKonnectivityOutputWithContext(context.Context) K0sKonnectivityOutput
}

type K0sKonnectivityArgs struct {
	AdminPort pulumi.IntPtrInput `pulumi:"adminPort"`
	AgentPort pulumi.IntPtrInput `pulumi:"agentPort"`
}

func (K0sKonnectivityArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sKonnectivity)(nil)).Elem()
}

func (i K0sKonnectivityArgs) ToK0sKonnectivityOutput() K0sKonnectivityOutput {
	return i.ToK0sKonnectivityOutputWithContext(context.Background())
}

func (i K0sKonnectivityArgs) ToK0sKonnectivityOutputWithContext(ctx context.Context) K0sKonnectivityOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKonnectivityOutput)
}

func (i K0sKonnectivityArgs) ToK0sKonnectivityPtrOutput() K0sKonnectivityPtrOutput {
	return i.ToK0sKonnectivityPtrOutputWithContext(context.Background())
}

func (i K0sKonnectivityArgs) ToK0sKonnectivityPtrOutputWithContext(ctx context.Context) K0sKonnectivityPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKonnectivityOutput).ToK0sKonnectivityPtrOutputWithContext(ctx)
}

// K0sKonnectivityPtrInput is an input type that accepts K0sKonnectivityArgs, K0sKonnectivityPtr and K0sKonnectivityPtrOutput values.
// You can construct a concrete instance of `K0sKonnectivityPtrInput` via:
//
//	        K0sKonnectivityArgs{...}
//
//	or:
//
//	        nil
type K0sKonnectivityPtrInput interface {
	pulumi.Input

	ToK0sKonnectivityPtrOutput() K0sKonnectivityPtrOutput
	ToK0sKonnectivityPtrOutputWithContext(context.Context) K0sKonnectivityPtrOutput
}

type k0sKonnectivityPtrType K0sKonnectivityArgs

func K0sKonnectivityPtr(v *K0sKonnectivityArgs) K0sKonnectivityPtrInput {
	return (*k0sKonnectivityPtrType)(v)
}

func (*k0sKonnectivityPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sKonnectivity)(nil)).Elem()
}

func (i *k0sKonnectivityPtrType) ToK0sKonnectivityPtrOutput() K0sKonnectivityPtrOutput {
	return i.ToK0sKonnectivityPtrOutputWithContext(context.Background())
}

func (i *k0sKonnectivityPtrType) ToK0sKonnectivityPtrOutputWithContext(ctx context.Context) K0sKonnectivityPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKonnectivityPtrOutput)
}

type K0sKonnectivityOutput struct{ *pulumi.OutputState }

func (K0sKonnectivityOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sKonnectivity)(nil)).Elem()
}

func (o K0sKonnectivityOutput) ToK0sKonnectivityOutput() K0sKonnectivityOutput {
	return o
}

func (o K0sKonnectivityOutput) ToK0sKonnectivityOutputWithContext(ctx context.Context) K0sKonnectivityOutput {
	return o
}

func (o K0sKonnectivityOutput) ToK0sKonnectivityPtrOutput() K0sKonnectivityPtrOutput {
	return o.ToK0sKonnectivityPtrOutputWithContext(context.Background())
}

func (o K0sKonnectivityOutput) ToK0sKonnectivityPtrOutputWithContext(ctx context.Context) K0sKonnectivityPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sKonnectivity) *K0sKonnectivity {
		return &v
	}).(K0sKonnectivityPtrOutput)
}

func (o K0sKonnectivityOutput) AdminPort() pulumi.IntPtrOutput {
	return o.ApplyT(func(v K0sKonnectivity) *int { return v.AdminPort }).(pulumi.IntPtrOutput)
}

func (o K0sKonnectivityOutput) AgentPort() pulumi.IntPtrOutput {
	return o.ApplyT(func(v K0sKonnectivity) *int { return v.AgentPort }).(pulumi.IntPtrOutput)
}

type K0sKonnectivityPtrOutput struct{ *pulumi.OutputState }

func (K0sKonnectivityPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sKonnectivity)(nil)).Elem()
}

func (o K0sKonnectivityPtrOutput) ToK0sKonnectivityPtrOutput() K0sKonnectivityPtrOutput {
	return o
}

func (o K0sKonnectivityPtrOutput) ToK0sKonnectivityPtrOutputWithContext(ctx context.Context) K0sKonnectivityPtrOutput {
	return o
}

func (o K0sKonnectivityPtrOutput) Elem() K0sKonnectivityOutput {
	return o.ApplyT(func(v *K0sKonnectivity) K0sKonnectivity {
		if v != nil {
			return *v
		}
		var ret K0sKonnectivity
		return ret
	}).(K0sKonnectivityOutput)
}

func (o K0sKonnectivityPtrOutput) AdminPort() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *K0sKonnectivity) *int {
		if v == nil {
			return nil
		}
		return v.AdminPort
	}).(pulumi.IntPtrOutput)
}

func (o K0sKonnectivityPtrOutput) AgentPort() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *K0sKonnectivity) *int {
		if v == nil {
			return nil
		}
		return v.AgentPort
	}).(pulumi.IntPtrOutput)
}

type K0sKubeProxy struct {
	Disabled          *bool                 `pulumi:"disabled"`
	Iptables          *K0sKubeProxyIPTables `pulumi:"iptables"`
	Ipvs              *K0sKubeProxyIPVS     `pulumi:"ipvs"`
	Mode              *string               `pulumi:"mode"`
	NodePortAddresses *string               `pulumi:"nodePortAddresses"`
}

// K0sKubeProxyInput is an input type that accepts K0sKubeProxyArgs and K0sKubeProxyOutput values.
// You can construct a concrete instance of `K0sKubeProxyInput` via:
//
//	K0sKubeProxyArgs{...}
type K0sKubeProxyInput interface {
	pulumi.Input

	ToK0sKubeProxyOutput() K0sKubeProxyOutput
	ToK0sKubeProxyOutputWithContext(context.Context) K0sKubeProxyOutput
}

type K0sKubeProxyArgs struct {
	Disabled          pulumi.BoolPtrInput          `pulumi:"disabled"`
	Iptables          K0sKubeProxyIPTablesPtrInput `pulumi:"iptables"`
	Ipvs              K0sKubeProxyIPVSPtrInput     `pulumi:"ipvs"`
	Mode              pulumi.StringPtrInput        `pulumi:"mode"`
	NodePortAddresses pulumi.StringPtrInput        `pulumi:"nodePortAddresses"`
}

func (K0sKubeProxyArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sKubeProxy)(nil)).Elem()
}

func (i K0sKubeProxyArgs) ToK0sKubeProxyOutput() K0sKubeProxyOutput {
	return i.ToK0sKubeProxyOutputWithContext(context.Background())
}

func (i K0sKubeProxyArgs) ToK0sKubeProxyOutputWithContext(ctx context.Context) K0sKubeProxyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKubeProxyOutput)
}

func (i K0sKubeProxyArgs) ToK0sKubeProxyPtrOutput() K0sKubeProxyPtrOutput {
	return i.ToK0sKubeProxyPtrOutputWithContext(context.Background())
}

func (i K0sKubeProxyArgs) ToK0sKubeProxyPtrOutputWithContext(ctx context.Context) K0sKubeProxyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKubeProxyOutput).ToK0sKubeProxyPtrOutputWithContext(ctx)
}

// K0sKubeProxyPtrInput is an input type that accepts K0sKubeProxyArgs, K0sKubeProxyPtr and K0sKubeProxyPtrOutput values.
// You can construct a concrete instance of `K0sKubeProxyPtrInput` via:
//
//	        K0sKubeProxyArgs{...}
//
//	or:
//
//	        nil
type K0sKubeProxyPtrInput interface {
	pulumi.Input

	ToK0sKubeProxyPtrOutput() K0sKubeProxyPtrOutput
	ToK0sKubeProxyPtrOutputWithContext(context.Context) K0sKubeProxyPtrOutput
}

type k0sKubeProxyPtrType K0sKubeProxyArgs

func K0sKubeProxyPtr(v *K0sKubeProxyArgs) K0sKubeProxyPtrInput {
	return (*k0sKubeProxyPtrType)(v)
}

func (*k0sKubeProxyPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sKubeProxy)(nil)).Elem()
}

func (i *k0sKubeProxyPtrType) ToK0sKubeProxyPtrOutput() K0sKubeProxyPtrOutput {
	return i.ToK0sKubeProxyPtrOutputWithContext(context.Background())
}

func (i *k0sKubeProxyPtrType) ToK0sKubeProxyPtrOutputWithContext(ctx context.Context) K0sKubeProxyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKubeProxyPtrOutput)
}

type K0sKubeProxyOutput struct{ *pulumi.OutputState }

func (K0sKubeProxyOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sKubeProxy)(nil)).Elem()
}

func (o K0sKubeProxyOutput) ToK0sKubeProxyOutput() K0sKubeProxyOutput {
	return o
}

func (o K0sKubeProxyOutput) ToK0sKubeProxyOutputWithContext(ctx context.Context) K0sKubeProxyOutput {
	return o
}

func (o K0sKubeProxyOutput) ToK0sKubeProxyPtrOutput() K0sKubeProxyPtrOutput {
	return o.ToK0sKubeProxyPtrOutputWithContext(context.Background())
}

func (o K0sKubeProxyOutput) ToK0sKubeProxyPtrOutputWithContext(ctx context.Context) K0sKubeProxyPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sKubeProxy) *K0sKubeProxy {
		return &v
	}).(K0sKubeProxyPtrOutput)
}

func (o K0sKubeProxyOutput) Disabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v K0sKubeProxy) *bool { return v.Disabled }).(pulumi.BoolPtrOutput)
}

func (o K0sKubeProxyOutput) Iptables() K0sKubeProxyIPTablesPtrOutput {
	return o.ApplyT(func(v K0sKubeProxy) *K0sKubeProxyIPTables { return v.Iptables }).(K0sKubeProxyIPTablesPtrOutput)
}

func (o K0sKubeProxyOutput) Ipvs() K0sKubeProxyIPVSPtrOutput {
	return o.ApplyT(func(v K0sKubeProxy) *K0sKubeProxyIPVS { return v.Ipvs }).(K0sKubeProxyIPVSPtrOutput)
}

func (o K0sKubeProxyOutput) Mode() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sKubeProxy) *string { return v.Mode }).(pulumi.StringPtrOutput)
}

func (o K0sKubeProxyOutput) NodePortAddresses() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sKubeProxy) *string { return v.NodePortAddresses }).(pulumi.StringPtrOutput)
}

type K0sKubeProxyPtrOutput struct{ *pulumi.OutputState }

func (K0sKubeProxyPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sKubeProxy)(nil)).Elem()
}

func (o K0sKubeProxyPtrOutput) ToK0sKubeProxyPtrOutput() K0sKubeProxyPtrOutput {
	return o
}

func (o K0sKubeProxyPtrOutput) ToK0sKubeProxyPtrOutputWithContext(ctx context.Context) K0sKubeProxyPtrOutput {
	return o
}

func (o K0sKubeProxyPtrOutput) Elem() K0sKubeProxyOutput {
	return o.ApplyT(func(v *K0sKubeProxy) K0sKubeProxy {
		if v != nil {
			return *v
		}
		var ret K0sKubeProxy
		return ret
	}).(K0sKubeProxyOutput)
}

func (o K0sKubeProxyPtrOutput) Disabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxy) *bool {
		if v == nil {
			return nil
		}
		return v.Disabled
	}).(pulumi.BoolPtrOutput)
}

func (o K0sKubeProxyPtrOutput) Iptables() K0sKubeProxyIPTablesPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxy) *K0sKubeProxyIPTables {
		if v == nil {
			return nil
		}
		return v.Iptables
	}).(K0sKubeProxyIPTablesPtrOutput)
}

func (o K0sKubeProxyPtrOutput) Ipvs() K0sKubeProxyIPVSPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxy) *K0sKubeProxyIPVS {
		if v == nil {
			return nil
		}
		return v.Ipvs
	}).(K0sKubeProxyIPVSPtrOutput)
}

func (o K0sKubeProxyPtrOutput) Mode() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxy) *string {
		if v == nil {
			return nil
		}
		return v.Mode
	}).(pulumi.StringPtrOutput)
}

func (o K0sKubeProxyPtrOutput) NodePortAddresses() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxy) *string {
		if v == nil {
			return nil
		}
		return v.NodePortAddresses
	}).(pulumi.StringPtrOutput)
}

type K0sKubeProxyIPTables struct {
	MasqueradeAll *bool   `pulumi:"masqueradeAll"`
	MasqueradeBit *int    `pulumi:"masqueradeBit"`
	MinSyncPeriod *string `pulumi:"minSyncPeriod"`
	SyncPeriod    *string `pulumi:"syncPeriod"`
}

// K0sKubeProxyIPTablesInput is an input type that accepts K0sKubeProxyIPTablesArgs and K0sKubeProxyIPTablesOutput values.
// You can construct a concrete instance of `K0sKubeProxyIPTablesInput` via:
//
//	K0sKubeProxyIPTablesArgs{...}
type K0sKubeProxyIPTablesInput interface {
	pulumi.Input

	ToK0sKubeProxyIPTablesOutput() K0sKubeProxyIPTablesOutput
	ToK0sKubeProxyIPTablesOutputWithContext(context.Context) K0sKubeProxyIPTablesOutput
}

type K0sKubeProxyIPTablesArgs struct {
	MasqueradeAll pulumi.BoolPtrInput   `pulumi:"masqueradeAll"`
	MasqueradeBit pulumi.IntPtrInput    `pulumi:"masqueradeBit"`
	MinSyncPeriod pulumi.StringPtrInput `pulumi:"minSyncPeriod"`
	SyncPeriod    pulumi.StringPtrInput `pulumi:"syncPeriod"`
}

func (K0sKubeProxyIPTablesArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sKubeProxyIPTables)(nil)).Elem()
}

func (i K0sKubeProxyIPTablesArgs) ToK0sKubeProxyIPTablesOutput() K0sKubeProxyIPTablesOutput {
	return i.ToK0sKubeProxyIPTablesOutputWithContext(context.Background())
}

func (i K0sKubeProxyIPTablesArgs) ToK0sKubeProxyIPTablesOutputWithContext(ctx context.Context) K0sKubeProxyIPTablesOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKubeProxyIPTablesOutput)
}

func (i K0sKubeProxyIPTablesArgs) ToK0sKubeProxyIPTablesPtrOutput() K0sKubeProxyIPTablesPtrOutput {
	return i.ToK0sKubeProxyIPTablesPtrOutputWithContext(context.Background())
}

func (i K0sKubeProxyIPTablesArgs) ToK0sKubeProxyIPTablesPtrOutputWithContext(ctx context.Context) K0sKubeProxyIPTablesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKubeProxyIPTablesOutput).ToK0sKubeProxyIPTablesPtrOutputWithContext(ctx)
}

// K0sKubeProxyIPTablesPtrInput is an input type that accepts K0sKubeProxyIPTablesArgs, K0sKubeProxyIPTablesPtr and K0sKubeProxyIPTablesPtrOutput values.
// You can construct a concrete instance of `K0sKubeProxyIPTablesPtrInput` via:
//
//	        K0sKubeProxyIPTablesArgs{...}
//
//	or:
//
//	        nil
type K0sKubeProxyIPTablesPtrInput interface {
	pulumi.Input

	ToK0sKubeProxyIPTablesPtrOutput() K0sKubeProxyIPTablesPtrOutput
	ToK0sKubeProxyIPTablesPtrOutputWithContext(context.Context) K0sKubeProxyIPTablesPtrOutput
}

type k0sKubeProxyIPTablesPtrType K0sKubeProxyIPTablesArgs

func K0sKubeProxyIPTablesPtr(v *K0sKubeProxyIPTablesArgs) K0sKubeProxyIPTablesPtrInput {
	return (*k0sKubeProxyIPTablesPtrType)(v)
}

func (*k0sKubeProxyIPTablesPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sKubeProxyIPTables)(nil)).Elem()
}

func (i *k0sKubeProxyIPTablesPtrType) ToK0sKubeProxyIPTablesPtrOutput() K0sKubeProxyIPTablesPtrOutput {
	return i.ToK0sKubeProxyIPTablesPtrOutputWithContext(context.Background())
}

func (i *k0sKubeProxyIPTablesPtrType) ToK0sKubeProxyIPTablesPtrOutputWithContext(ctx context.Context) K0sKubeProxyIPTablesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKubeProxyIPTablesPtrOutput)
}

type K0sKubeProxyIPTablesOutput struct{ *pulumi.OutputState }

func (K0sKubeProxyIPTablesOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sKubeProxyIPTables)(nil)).Elem()
}

func (o K0sKubeProxyIPTablesOutput) ToK0sKubeProxyIPTablesOutput() K0sKubeProxyIPTablesOutput {
	return o
}

func (o K0sKubeProxyIPTablesOutput) ToK0sKubeProxyIPTablesOutputWithContext(ctx context.Context) K0sKubeProxyIPTablesOutput {
	return o
}

func (o K0sKubeProxyIPTablesOutput) ToK0sKubeProxyIPTablesPtrOutput() K0sKubeProxyIPTablesPtrOutput {
	return o.ToK0sKubeProxyIPTablesPtrOutputWithContext(context.Background())
}

func (o K0sKubeProxyIPTablesOutput) ToK0sKubeProxyIPTablesPtrOutputWithContext(ctx context.Context) K0sKubeProxyIPTablesPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sKubeProxyIPTables) *K0sKubeProxyIPTables {
		return &v
	}).(K0sKubeProxyIPTablesPtrOutput)
}

func (o K0sKubeProxyIPTablesOutput) MasqueradeAll() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v K0sKubeProxyIPTables) *bool { return v.MasqueradeAll }).(pulumi.BoolPtrOutput)
}

func (o K0sKubeProxyIPTablesOutput) MasqueradeBit() pulumi.IntPtrOutput {
	return o.ApplyT(func(v K0sKubeProxyIPTables) *int { return v.MasqueradeBit }).(pulumi.IntPtrOutput)
}

func (o K0sKubeProxyIPTablesOutput) MinSyncPeriod() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sKubeProxyIPTables) *string { return v.MinSyncPeriod }).(pulumi.StringPtrOutput)
}

func (o K0sKubeProxyIPTablesOutput) SyncPeriod() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sKubeProxyIPTables) *string { return v.SyncPeriod }).(pulumi.StringPtrOutput)
}

type K0sKubeProxyIPTablesPtrOutput struct{ *pulumi.OutputState }

func (K0sKubeProxyIPTablesPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sKubeProxyIPTables)(nil)).Elem()
}

func (o K0sKubeProxyIPTablesPtrOutput) ToK0sKubeProxyIPTablesPtrOutput() K0sKubeProxyIPTablesPtrOutput {
	return o
}

func (o K0sKubeProxyIPTablesPtrOutput) ToK0sKubeProxyIPTablesPtrOutputWithContext(ctx context.Context) K0sKubeProxyIPTablesPtrOutput {
	return o
}

func (o K0sKubeProxyIPTablesPtrOutput) Elem() K0sKubeProxyIPTablesOutput {
	return o.ApplyT(func(v *K0sKubeProxyIPTables) K0sKubeProxyIPTables {
		if v != nil {
			return *v
		}
		var ret K0sKubeProxyIPTables
		return ret
	}).(K0sKubeProxyIPTablesOutput)
}

func (o K0sKubeProxyIPTablesPtrOutput) MasqueradeAll() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxyIPTables) *bool {
		if v == nil {
			return nil
		}
		return v.MasqueradeAll
	}).(pulumi.BoolPtrOutput)
}

func (o K0sKubeProxyIPTablesPtrOutput) MasqueradeBit() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxyIPTables) *int {
		if v == nil {
			return nil
		}
		return v.MasqueradeBit
	}).(pulumi.IntPtrOutput)
}

func (o K0sKubeProxyIPTablesPtrOutput) MinSyncPeriod() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxyIPTables) *string {
		if v == nil {
			return nil
		}
		return v.MinSyncPeriod
	}).(pulumi.StringPtrOutput)
}

func (o K0sKubeProxyIPTablesPtrOutput) SyncPeriod() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxyIPTables) *string {
		if v == nil {
			return nil
		}
		return v.SyncPeriod
	}).(pulumi.StringPtrOutput)
}

type K0sKubeProxyIPVS struct {
	ExcludeCIDRs  *string `pulumi:"excludeCIDRs"`
	MinSyncPeriod *string `pulumi:"minSyncPeriod"`
	Scheduler     *string `pulumi:"scheduler"`
	StrictARP     *bool   `pulumi:"strictARP"`
	SyncPeriod    *string `pulumi:"syncPeriod"`
	TcpFinTimeout *string `pulumi:"tcpFinTimeout"`
	TcpTimeout    *string `pulumi:"tcpTimeout"`
	UdpTimeout    *string `pulumi:"udpTimeout"`
}

// K0sKubeProxyIPVSInput is an input type that accepts K0sKubeProxyIPVSArgs and K0sKubeProxyIPVSOutput values.
// You can construct a concrete instance of `K0sKubeProxyIPVSInput` via:
//
//	K0sKubeProxyIPVSArgs{...}
type K0sKubeProxyIPVSInput interface {
	pulumi.Input

	ToK0sKubeProxyIPVSOutput() K0sKubeProxyIPVSOutput
	ToK0sKubeProxyIPVSOutputWithContext(context.Context) K0sKubeProxyIPVSOutput
}

type K0sKubeProxyIPVSArgs struct {
	ExcludeCIDRs  pulumi.StringPtrInput `pulumi:"excludeCIDRs"`
	MinSyncPeriod pulumi.StringPtrInput `pulumi:"minSyncPeriod"`
	Scheduler     pulumi.StringPtrInput `pulumi:"scheduler"`
	StrictARP     pulumi.BoolPtrInput   `pulumi:"strictARP"`
	SyncPeriod    pulumi.StringPtrInput `pulumi:"syncPeriod"`
	TcpFinTimeout pulumi.StringPtrInput `pulumi:"tcpFinTimeout"`
	TcpTimeout    pulumi.StringPtrInput `pulumi:"tcpTimeout"`
	UdpTimeout    pulumi.StringPtrInput `pulumi:"udpTimeout"`
}

func (K0sKubeProxyIPVSArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sKubeProxyIPVS)(nil)).Elem()
}

func (i K0sKubeProxyIPVSArgs) ToK0sKubeProxyIPVSOutput() K0sKubeProxyIPVSOutput {
	return i.ToK0sKubeProxyIPVSOutputWithContext(context.Background())
}

func (i K0sKubeProxyIPVSArgs) ToK0sKubeProxyIPVSOutputWithContext(ctx context.Context) K0sKubeProxyIPVSOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKubeProxyIPVSOutput)
}

func (i K0sKubeProxyIPVSArgs) ToK0sKubeProxyIPVSPtrOutput() K0sKubeProxyIPVSPtrOutput {
	return i.ToK0sKubeProxyIPVSPtrOutputWithContext(context.Background())
}

func (i K0sKubeProxyIPVSArgs) ToK0sKubeProxyIPVSPtrOutputWithContext(ctx context.Context) K0sKubeProxyIPVSPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKubeProxyIPVSOutput).ToK0sKubeProxyIPVSPtrOutputWithContext(ctx)
}

// K0sKubeProxyIPVSPtrInput is an input type that accepts K0sKubeProxyIPVSArgs, K0sKubeProxyIPVSPtr and K0sKubeProxyIPVSPtrOutput values.
// You can construct a concrete instance of `K0sKubeProxyIPVSPtrInput` via:
//
//	        K0sKubeProxyIPVSArgs{...}
//
//	or:
//
//	        nil
type K0sKubeProxyIPVSPtrInput interface {
	pulumi.Input

	ToK0sKubeProxyIPVSPtrOutput() K0sKubeProxyIPVSPtrOutput
	ToK0sKubeProxyIPVSPtrOutputWithContext(context.Context) K0sKubeProxyIPVSPtrOutput
}

type k0sKubeProxyIPVSPtrType K0sKubeProxyIPVSArgs

func K0sKubeProxyIPVSPtr(v *K0sKubeProxyIPVSArgs) K0sKubeProxyIPVSPtrInput {
	return (*k0sKubeProxyIPVSPtrType)(v)
}

func (*k0sKubeProxyIPVSPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sKubeProxyIPVS)(nil)).Elem()
}

func (i *k0sKubeProxyIPVSPtrType) ToK0sKubeProxyIPVSPtrOutput() K0sKubeProxyIPVSPtrOutput {
	return i.ToK0sKubeProxyIPVSPtrOutputWithContext(context.Background())
}

func (i *k0sKubeProxyIPVSPtrType) ToK0sKubeProxyIPVSPtrOutputWithContext(ctx context.Context) K0sKubeProxyIPVSPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKubeProxyIPVSPtrOutput)
}

type K0sKubeProxyIPVSOutput struct{ *pulumi.OutputState }

func (K0sKubeProxyIPVSOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sKubeProxyIPVS)(nil)).Elem()
}

func (o K0sKubeProxyIPVSOutput) ToK0sKubeProxyIPVSOutput() K0sKubeProxyIPVSOutput {
	return o
}

func (o K0sKubeProxyIPVSOutput) ToK0sKubeProxyIPVSOutputWithContext(ctx context.Context) K0sKubeProxyIPVSOutput {
	return o
}

func (o K0sKubeProxyIPVSOutput) ToK0sKubeProxyIPVSPtrOutput() K0sKubeProxyIPVSPtrOutput {
	return o.ToK0sKubeProxyIPVSPtrOutputWithContext(context.Background())
}

func (o K0sKubeProxyIPVSOutput) ToK0sKubeProxyIPVSPtrOutputWithContext(ctx context.Context) K0sKubeProxyIPVSPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sKubeProxyIPVS) *K0sKubeProxyIPVS {
		return &v
	}).(K0sKubeProxyIPVSPtrOutput)
}

func (o K0sKubeProxyIPVSOutput) ExcludeCIDRs() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sKubeProxyIPVS) *string { return v.ExcludeCIDRs }).(pulumi.StringPtrOutput)
}

func (o K0sKubeProxyIPVSOutput) MinSyncPeriod() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sKubeProxyIPVS) *string { return v.MinSyncPeriod }).(pulumi.StringPtrOutput)
}

func (o K0sKubeProxyIPVSOutput) Scheduler() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sKubeProxyIPVS) *string { return v.Scheduler }).(pulumi.StringPtrOutput)
}

func (o K0sKubeProxyIPVSOutput) StrictARP() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v K0sKubeProxyIPVS) *bool { return v.StrictARP }).(pulumi.BoolPtrOutput)
}

func (o K0sKubeProxyIPVSOutput) SyncPeriod() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sKubeProxyIPVS) *string { return v.SyncPeriod }).(pulumi.StringPtrOutput)
}

func (o K0sKubeProxyIPVSOutput) TcpFinTimeout() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sKubeProxyIPVS) *string { return v.TcpFinTimeout }).(pulumi.StringPtrOutput)
}

func (o K0sKubeProxyIPVSOutput) TcpTimeout() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sKubeProxyIPVS) *string { return v.TcpTimeout }).(pulumi.StringPtrOutput)
}

func (o K0sKubeProxyIPVSOutput) UdpTimeout() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sKubeProxyIPVS) *string { return v.UdpTimeout }).(pulumi.StringPtrOutput)
}

type K0sKubeProxyIPVSPtrOutput struct{ *pulumi.OutputState }

func (K0sKubeProxyIPVSPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sKubeProxyIPVS)(nil)).Elem()
}

func (o K0sKubeProxyIPVSPtrOutput) ToK0sKubeProxyIPVSPtrOutput() K0sKubeProxyIPVSPtrOutput {
	return o
}

func (o K0sKubeProxyIPVSPtrOutput) ToK0sKubeProxyIPVSPtrOutputWithContext(ctx context.Context) K0sKubeProxyIPVSPtrOutput {
	return o
}

func (o K0sKubeProxyIPVSPtrOutput) Elem() K0sKubeProxyIPVSOutput {
	return o.ApplyT(func(v *K0sKubeProxyIPVS) K0sKubeProxyIPVS {
		if v != nil {
			return *v
		}
		var ret K0sKubeProxyIPVS
		return ret
	}).(K0sKubeProxyIPVSOutput)
}

func (o K0sKubeProxyIPVSPtrOutput) ExcludeCIDRs() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxyIPVS) *string {
		if v == nil {
			return nil
		}
		return v.ExcludeCIDRs
	}).(pulumi.StringPtrOutput)
}

func (o K0sKubeProxyIPVSPtrOutput) MinSyncPeriod() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxyIPVS) *string {
		if v == nil {
			return nil
		}
		return v.MinSyncPeriod
	}).(pulumi.StringPtrOutput)
}

func (o K0sKubeProxyIPVSPtrOutput) Scheduler() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxyIPVS) *string {
		if v == nil {
			return nil
		}
		return v.Scheduler
	}).(pulumi.StringPtrOutput)
}

func (o K0sKubeProxyIPVSPtrOutput) StrictARP() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxyIPVS) *bool {
		if v == nil {
			return nil
		}
		return v.StrictARP
	}).(pulumi.BoolPtrOutput)
}

func (o K0sKubeProxyIPVSPtrOutput) SyncPeriod() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxyIPVS) *string {
		if v == nil {
			return nil
		}
		return v.SyncPeriod
	}).(pulumi.StringPtrOutput)
}

func (o K0sKubeProxyIPVSPtrOutput) TcpFinTimeout() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxyIPVS) *string {
		if v == nil {
			return nil
		}
		return v.TcpFinTimeout
	}).(pulumi.StringPtrOutput)
}

func (o K0sKubeProxyIPVSPtrOutput) TcpTimeout() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxyIPVS) *string {
		if v == nil {
			return nil
		}
		return v.TcpTimeout
	}).(pulumi.StringPtrOutput)
}

func (o K0sKubeProxyIPVSPtrOutput) UdpTimeout() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sKubeProxyIPVS) *string {
		if v == nil {
			return nil
		}
		return v.UdpTimeout
	}).(pulumi.StringPtrOutput)
}

type K0sKubeRouter struct {
	AutoMTU     *bool             `pulumi:"autoMTU"`
	ExtraArgs   map[string]string `pulumi:"extraArgs"`
	Hairpin     *string           `pulumi:"hairpin"`
	IpMasq      *bool             `pulumi:"ipMasq"`
	MetricsPort *int              `pulumi:"metricsPort"`
	Mtu         *int              `pulumi:"mtu"`
}

// K0sKubeRouterInput is an input type that accepts K0sKubeRouterArgs and K0sKubeRouterOutput values.
// You can construct a concrete instance of `K0sKubeRouterInput` via:
//
//	K0sKubeRouterArgs{...}
type K0sKubeRouterInput interface {
	pulumi.Input

	ToK0sKubeRouterOutput() K0sKubeRouterOutput
	ToK0sKubeRouterOutputWithContext(context.Context) K0sKubeRouterOutput
}

type K0sKubeRouterArgs struct {
	AutoMTU     pulumi.BoolPtrInput   `pulumi:"autoMTU"`
	ExtraArgs   pulumi.StringMapInput `pulumi:"extraArgs"`
	Hairpin     pulumi.StringPtrInput `pulumi:"hairpin"`
	IpMasq      pulumi.BoolPtrInput   `pulumi:"ipMasq"`
	MetricsPort pulumi.IntPtrInput    `pulumi:"metricsPort"`
	Mtu         pulumi.IntPtrInput    `pulumi:"mtu"`
}

func (K0sKubeRouterArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sKubeRouter)(nil)).Elem()
}

func (i K0sKubeRouterArgs) ToK0sKubeRouterOutput() K0sKubeRouterOutput {
	return i.ToK0sKubeRouterOutputWithContext(context.Background())
}

func (i K0sKubeRouterArgs) ToK0sKubeRouterOutputWithContext(ctx context.Context) K0sKubeRouterOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKubeRouterOutput)
}

func (i K0sKubeRouterArgs) ToK0sKubeRouterPtrOutput() K0sKubeRouterPtrOutput {
	return i.ToK0sKubeRouterPtrOutputWithContext(context.Background())
}

func (i K0sKubeRouterArgs) ToK0sKubeRouterPtrOutputWithContext(ctx context.Context) K0sKubeRouterPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKubeRouterOutput).ToK0sKubeRouterPtrOutputWithContext(ctx)
}

// K0sKubeRouterPtrInput is an input type that accepts K0sKubeRouterArgs, K0sKubeRouterPtr and K0sKubeRouterPtrOutput values.
// You can construct a concrete instance of `K0sKubeRouterPtrInput` via:
//
//	        K0sKubeRouterArgs{...}
//
//	or:
//
//	        nil
type K0sKubeRouterPtrInput interface {
	pulumi.Input

	ToK0sKubeRouterPtrOutput() K0sKubeRouterPtrOutput
	ToK0sKubeRouterPtrOutputWithContext(context.Context) K0sKubeRouterPtrOutput
}

type k0sKubeRouterPtrType K0sKubeRouterArgs

func K0sKubeRouterPtr(v *K0sKubeRouterArgs) K0sKubeRouterPtrInput {
	return (*k0sKubeRouterPtrType)(v)
}

func (*k0sKubeRouterPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sKubeRouter)(nil)).Elem()
}

func (i *k0sKubeRouterPtrType) ToK0sKubeRouterPtrOutput() K0sKubeRouterPtrOutput {
	return i.ToK0sKubeRouterPtrOutputWithContext(context.Background())
}

func (i *k0sKubeRouterPtrType) ToK0sKubeRouterPtrOutputWithContext(ctx context.Context) K0sKubeRouterPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKubeRouterPtrOutput)
}

type K0sKubeRouterOutput struct{ *pulumi.OutputState }

func (K0sKubeRouterOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sKubeRouter)(nil)).Elem()
}

func (o K0sKubeRouterOutput) ToK0sKubeRouterOutput() K0sKubeRouterOutput {
	return o
}

func (o K0sKubeRouterOutput) ToK0sKubeRouterOutputWithContext(ctx context.Context) K0sKubeRouterOutput {
	return o
}

func (o K0sKubeRouterOutput) ToK0sKubeRouterPtrOutput() K0sKubeRouterPtrOutput {
	return o.ToK0sKubeRouterPtrOutputWithContext(context.Background())
}

func (o K0sKubeRouterOutput) ToK0sKubeRouterPtrOutputWithContext(ctx context.Context) K0sKubeRouterPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sKubeRouter) *K0sKubeRouter {
		return &v
	}).(K0sKubeRouterPtrOutput)
}

func (o K0sKubeRouterOutput) AutoMTU() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v K0sKubeRouter) *bool { return v.AutoMTU }).(pulumi.BoolPtrOutput)
}

func (o K0sKubeRouterOutput) ExtraArgs() pulumi.StringMapOutput {
	return o.ApplyT(func(v K0sKubeRouter) map[string]string { return v.ExtraArgs }).(pulumi.StringMapOutput)
}

func (o K0sKubeRouterOutput) Hairpin() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sKubeRouter) *string { return v.Hairpin }).(pulumi.StringPtrOutput)
}

func (o K0sKubeRouterOutput) IpMasq() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v K0sKubeRouter) *bool { return v.IpMasq }).(pulumi.BoolPtrOutput)
}

func (o K0sKubeRouterOutput) MetricsPort() pulumi.IntPtrOutput {
	return o.ApplyT(func(v K0sKubeRouter) *int { return v.MetricsPort }).(pulumi.IntPtrOutput)
}

func (o K0sKubeRouterOutput) Mtu() pulumi.IntPtrOutput {
	return o.ApplyT(func(v K0sKubeRouter) *int { return v.Mtu }).(pulumi.IntPtrOutput)
}

type K0sKubeRouterPtrOutput struct{ *pulumi.OutputState }

func (K0sKubeRouterPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sKubeRouter)(nil)).Elem()
}

func (o K0sKubeRouterPtrOutput) ToK0sKubeRouterPtrOutput() K0sKubeRouterPtrOutput {
	return o
}

func (o K0sKubeRouterPtrOutput) ToK0sKubeRouterPtrOutputWithContext(ctx context.Context) K0sKubeRouterPtrOutput {
	return o
}

func (o K0sKubeRouterPtrOutput) Elem() K0sKubeRouterOutput {
	return o.ApplyT(func(v *K0sKubeRouter) K0sKubeRouter {
		if v != nil {
			return *v
		}
		var ret K0sKubeRouter
		return ret
	}).(K0sKubeRouterOutput)
}

func (o K0sKubeRouterPtrOutput) AutoMTU() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *K0sKubeRouter) *bool {
		if v == nil {
			return nil
		}
		return v.AutoMTU
	}).(pulumi.BoolPtrOutput)
}

func (o K0sKubeRouterPtrOutput) ExtraArgs() pulumi.StringMapOutput {
	return o.ApplyT(func(v *K0sKubeRouter) map[string]string {
		if v == nil {
			return nil
		}
		return v.ExtraArgs
	}).(pulumi.StringMapOutput)
}

func (o K0sKubeRouterPtrOutput) Hairpin() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sKubeRouter) *string {
		if v == nil {
			return nil
		}
		return v.Hairpin
	}).(pulumi.StringPtrOutput)
}

func (o K0sKubeRouterPtrOutput) IpMasq() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *K0sKubeRouter) *bool {
		if v == nil {
			return nil
		}
		return v.IpMasq
	}).(pulumi.BoolPtrOutput)
}

func (o K0sKubeRouterPtrOutput) MetricsPort() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *K0sKubeRouter) *int {
		if v == nil {
			return nil
		}
		return v.MetricsPort
	}).(pulumi.IntPtrOutput)
}

func (o K0sKubeRouterPtrOutput) Mtu() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *K0sKubeRouter) *int {
		if v == nil {
			return nil
		}
		return v.Mtu
	}).(pulumi.IntPtrOutput)
}

type K0sKubeRouterImage struct {
	Cni          *K0sImage `pulumi:"cni"`
	CniInstaller *K0sImage `pulumi:"cniInstaller"`
}

// K0sKubeRouterImageInput is an input type that accepts K0sKubeRouterImageArgs and K0sKubeRouterImageOutput values.
// You can construct a concrete instance of `K0sKubeRouterImageInput` via:
//
//	K0sKubeRouterImageArgs{...}
type K0sKubeRouterImageInput interface {
	pulumi.Input

	ToK0sKubeRouterImageOutput() K0sKubeRouterImageOutput
	ToK0sKubeRouterImageOutputWithContext(context.Context) K0sKubeRouterImageOutput
}

type K0sKubeRouterImageArgs struct {
	Cni          K0sImagePtrInput `pulumi:"cni"`
	CniInstaller K0sImagePtrInput `pulumi:"cniInstaller"`
}

func (K0sKubeRouterImageArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sKubeRouterImage)(nil)).Elem()
}

func (i K0sKubeRouterImageArgs) ToK0sKubeRouterImageOutput() K0sKubeRouterImageOutput {
	return i.ToK0sKubeRouterImageOutputWithContext(context.Background())
}

func (i K0sKubeRouterImageArgs) ToK0sKubeRouterImageOutputWithContext(ctx context.Context) K0sKubeRouterImageOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKubeRouterImageOutput)
}

func (i K0sKubeRouterImageArgs) ToK0sKubeRouterImagePtrOutput() K0sKubeRouterImagePtrOutput {
	return i.ToK0sKubeRouterImagePtrOutputWithContext(context.Background())
}

func (i K0sKubeRouterImageArgs) ToK0sKubeRouterImagePtrOutputWithContext(ctx context.Context) K0sKubeRouterImagePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKubeRouterImageOutput).ToK0sKubeRouterImagePtrOutputWithContext(ctx)
}

// K0sKubeRouterImagePtrInput is an input type that accepts K0sKubeRouterImageArgs, K0sKubeRouterImagePtr and K0sKubeRouterImagePtrOutput values.
// You can construct a concrete instance of `K0sKubeRouterImagePtrInput` via:
//
//	        K0sKubeRouterImageArgs{...}
//
//	or:
//
//	        nil
type K0sKubeRouterImagePtrInput interface {
	pulumi.Input

	ToK0sKubeRouterImagePtrOutput() K0sKubeRouterImagePtrOutput
	ToK0sKubeRouterImagePtrOutputWithContext(context.Context) K0sKubeRouterImagePtrOutput
}

type k0sKubeRouterImagePtrType K0sKubeRouterImageArgs

func K0sKubeRouterImagePtr(v *K0sKubeRouterImageArgs) K0sKubeRouterImagePtrInput {
	return (*k0sKubeRouterImagePtrType)(v)
}

func (*k0sKubeRouterImagePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sKubeRouterImage)(nil)).Elem()
}

func (i *k0sKubeRouterImagePtrType) ToK0sKubeRouterImagePtrOutput() K0sKubeRouterImagePtrOutput {
	return i.ToK0sKubeRouterImagePtrOutputWithContext(context.Background())
}

func (i *k0sKubeRouterImagePtrType) ToK0sKubeRouterImagePtrOutputWithContext(ctx context.Context) K0sKubeRouterImagePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sKubeRouterImagePtrOutput)
}

type K0sKubeRouterImageOutput struct{ *pulumi.OutputState }

func (K0sKubeRouterImageOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sKubeRouterImage)(nil)).Elem()
}

func (o K0sKubeRouterImageOutput) ToK0sKubeRouterImageOutput() K0sKubeRouterImageOutput {
	return o
}

func (o K0sKubeRouterImageOutput) ToK0sKubeRouterImageOutputWithContext(ctx context.Context) K0sKubeRouterImageOutput {
	return o
}

func (o K0sKubeRouterImageOutput) ToK0sKubeRouterImagePtrOutput() K0sKubeRouterImagePtrOutput {
	return o.ToK0sKubeRouterImagePtrOutputWithContext(context.Background())
}

func (o K0sKubeRouterImageOutput) ToK0sKubeRouterImagePtrOutputWithContext(ctx context.Context) K0sKubeRouterImagePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sKubeRouterImage) *K0sKubeRouterImage {
		return &v
	}).(K0sKubeRouterImagePtrOutput)
}

func (o K0sKubeRouterImageOutput) Cni() K0sImagePtrOutput {
	return o.ApplyT(func(v K0sKubeRouterImage) *K0sImage { return v.Cni }).(K0sImagePtrOutput)
}

func (o K0sKubeRouterImageOutput) CniInstaller() K0sImagePtrOutput {
	return o.ApplyT(func(v K0sKubeRouterImage) *K0sImage { return v.CniInstaller }).(K0sImagePtrOutput)
}

type K0sKubeRouterImagePtrOutput struct{ *pulumi.OutputState }

func (K0sKubeRouterImagePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sKubeRouterImage)(nil)).Elem()
}

func (o K0sKubeRouterImagePtrOutput) ToK0sKubeRouterImagePtrOutput() K0sKubeRouterImagePtrOutput {
	return o
}

func (o K0sKubeRouterImagePtrOutput) ToK0sKubeRouterImagePtrOutputWithContext(ctx context.Context) K0sKubeRouterImagePtrOutput {
	return o
}

func (o K0sKubeRouterImagePtrOutput) Elem() K0sKubeRouterImageOutput {
	return o.ApplyT(func(v *K0sKubeRouterImage) K0sKubeRouterImage {
		if v != nil {
			return *v
		}
		var ret K0sKubeRouterImage
		return ret
	}).(K0sKubeRouterImageOutput)
}

func (o K0sKubeRouterImagePtrOutput) Cni() K0sImagePtrOutput {
	return o.ApplyT(func(v *K0sKubeRouterImage) *K0sImage {
		if v == nil {
			return nil
		}
		return v.Cni
	}).(K0sImagePtrOutput)
}

func (o K0sKubeRouterImagePtrOutput) CniInstaller() K0sImagePtrOutput {
	return o.ApplyT(func(v *K0sKubeRouterImage) *K0sImage {
		if v == nil {
			return nil
		}
		return v.CniInstaller
	}).(K0sImagePtrOutput)
}

type K0sMetadata struct {
	Name string `pulumi:"name"`
}

// K0sMetadataInput is an input type that accepts K0sMetadataArgs and K0sMetadataOutput values.
// You can construct a concrete instance of `K0sMetadataInput` via:
//
//	K0sMetadataArgs{...}
type K0sMetadataInput interface {
	pulumi.Input

	ToK0sMetadataOutput() K0sMetadataOutput
	ToK0sMetadataOutputWithContext(context.Context) K0sMetadataOutput
}

type K0sMetadataArgs struct {
	Name pulumi.StringInput `pulumi:"name"`
}

func (K0sMetadataArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sMetadata)(nil)).Elem()
}

func (i K0sMetadataArgs) ToK0sMetadataOutput() K0sMetadataOutput {
	return i.ToK0sMetadataOutputWithContext(context.Background())
}

func (i K0sMetadataArgs) ToK0sMetadataOutputWithContext(ctx context.Context) K0sMetadataOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sMetadataOutput)
}

func (i K0sMetadataArgs) ToK0sMetadataPtrOutput() K0sMetadataPtrOutput {
	return i.ToK0sMetadataPtrOutputWithContext(context.Background())
}

func (i K0sMetadataArgs) ToK0sMetadataPtrOutputWithContext(ctx context.Context) K0sMetadataPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sMetadataOutput).ToK0sMetadataPtrOutputWithContext(ctx)
}

// K0sMetadataPtrInput is an input type that accepts K0sMetadataArgs, K0sMetadataPtr and K0sMetadataPtrOutput values.
// You can construct a concrete instance of `K0sMetadataPtrInput` via:
//
//	        K0sMetadataArgs{...}
//
//	or:
//
//	        nil
type K0sMetadataPtrInput interface {
	pulumi.Input

	ToK0sMetadataPtrOutput() K0sMetadataPtrOutput
	ToK0sMetadataPtrOutputWithContext(context.Context) K0sMetadataPtrOutput
}

type k0sMetadataPtrType K0sMetadataArgs

func K0sMetadataPtr(v *K0sMetadataArgs) K0sMetadataPtrInput {
	return (*k0sMetadataPtrType)(v)
}

func (*k0sMetadataPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sMetadata)(nil)).Elem()
}

func (i *k0sMetadataPtrType) ToK0sMetadataPtrOutput() K0sMetadataPtrOutput {
	return i.ToK0sMetadataPtrOutputWithContext(context.Background())
}

func (i *k0sMetadataPtrType) ToK0sMetadataPtrOutputWithContext(ctx context.Context) K0sMetadataPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sMetadataPtrOutput)
}

type K0sMetadataOutput struct{ *pulumi.OutputState }

func (K0sMetadataOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sMetadata)(nil)).Elem()
}

func (o K0sMetadataOutput) ToK0sMetadataOutput() K0sMetadataOutput {
	return o
}

func (o K0sMetadataOutput) ToK0sMetadataOutputWithContext(ctx context.Context) K0sMetadataOutput {
	return o
}

func (o K0sMetadataOutput) ToK0sMetadataPtrOutput() K0sMetadataPtrOutput {
	return o.ToK0sMetadataPtrOutputWithContext(context.Background())
}

func (o K0sMetadataOutput) ToK0sMetadataPtrOutputWithContext(ctx context.Context) K0sMetadataPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sMetadata) *K0sMetadata {
		return &v
	}).(K0sMetadataPtrOutput)
}

func (o K0sMetadataOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v K0sMetadata) string { return v.Name }).(pulumi.StringOutput)
}

type K0sMetadataPtrOutput struct{ *pulumi.OutputState }

func (K0sMetadataPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sMetadata)(nil)).Elem()
}

func (o K0sMetadataPtrOutput) ToK0sMetadataPtrOutput() K0sMetadataPtrOutput {
	return o
}

func (o K0sMetadataPtrOutput) ToK0sMetadataPtrOutputWithContext(ctx context.Context) K0sMetadataPtrOutput {
	return o
}

func (o K0sMetadataPtrOutput) Elem() K0sMetadataOutput {
	return o.ApplyT(func(v *K0sMetadata) K0sMetadata {
		if v != nil {
			return *v
		}
		var ret K0sMetadata
		return ret
	}).(K0sMetadataOutput)
}

func (o K0sMetadataPtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sMetadata) *string {
		if v == nil {
			return nil
		}
		return &v.Name
	}).(pulumi.StringPtrOutput)
}

type K0sNetwork struct {
	Calico                 *K0sCalico                 `pulumi:"calico"`
	ClusterDomain          *string                    `pulumi:"clusterDomain"`
	DualStack              *K0sDualStack              `pulumi:"dualStack"`
	KubeProxy              *K0sKubeProxy              `pulumi:"kubeProxy"`
	Kuberouter             *K0sKubeRouter             `pulumi:"kuberouter"`
	NodeLocalLoadBalancing *K0sNodeLocalLoadBalancing `pulumi:"nodeLocalLoadBalancing"`
	PodCIDR                *string                    `pulumi:"podCIDR"`
	Provider               *string                    `pulumi:"provider"`
	ServiceCIDR            *string                    `pulumi:"serviceCIDR"`
}

// K0sNetworkInput is an input type that accepts K0sNetworkArgs and K0sNetworkOutput values.
// You can construct a concrete instance of `K0sNetworkInput` via:
//
//	K0sNetworkArgs{...}
type K0sNetworkInput interface {
	pulumi.Input

	ToK0sNetworkOutput() K0sNetworkOutput
	ToK0sNetworkOutputWithContext(context.Context) K0sNetworkOutput
}

type K0sNetworkArgs struct {
	Calico                 K0sCalicoPtrInput                 `pulumi:"calico"`
	ClusterDomain          pulumi.StringPtrInput             `pulumi:"clusterDomain"`
	DualStack              K0sDualStackPtrInput              `pulumi:"dualStack"`
	KubeProxy              K0sKubeProxyPtrInput              `pulumi:"kubeProxy"`
	Kuberouter             K0sKubeRouterPtrInput             `pulumi:"kuberouter"`
	NodeLocalLoadBalancing K0sNodeLocalLoadBalancingPtrInput `pulumi:"nodeLocalLoadBalancing"`
	PodCIDR                pulumi.StringPtrInput             `pulumi:"podCIDR"`
	Provider               pulumi.StringPtrInput             `pulumi:"provider"`
	ServiceCIDR            pulumi.StringPtrInput             `pulumi:"serviceCIDR"`
}

func (K0sNetworkArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sNetwork)(nil)).Elem()
}

func (i K0sNetworkArgs) ToK0sNetworkOutput() K0sNetworkOutput {
	return i.ToK0sNetworkOutputWithContext(context.Background())
}

func (i K0sNetworkArgs) ToK0sNetworkOutputWithContext(ctx context.Context) K0sNetworkOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sNetworkOutput)
}

func (i K0sNetworkArgs) ToK0sNetworkPtrOutput() K0sNetworkPtrOutput {
	return i.ToK0sNetworkPtrOutputWithContext(context.Background())
}

func (i K0sNetworkArgs) ToK0sNetworkPtrOutputWithContext(ctx context.Context) K0sNetworkPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sNetworkOutput).ToK0sNetworkPtrOutputWithContext(ctx)
}

// K0sNetworkPtrInput is an input type that accepts K0sNetworkArgs, K0sNetworkPtr and K0sNetworkPtrOutput values.
// You can construct a concrete instance of `K0sNetworkPtrInput` via:
//
//	        K0sNetworkArgs{...}
//
//	or:
//
//	        nil
type K0sNetworkPtrInput interface {
	pulumi.Input

	ToK0sNetworkPtrOutput() K0sNetworkPtrOutput
	ToK0sNetworkPtrOutputWithContext(context.Context) K0sNetworkPtrOutput
}

type k0sNetworkPtrType K0sNetworkArgs

func K0sNetworkPtr(v *K0sNetworkArgs) K0sNetworkPtrInput {
	return (*k0sNetworkPtrType)(v)
}

func (*k0sNetworkPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sNetwork)(nil)).Elem()
}

func (i *k0sNetworkPtrType) ToK0sNetworkPtrOutput() K0sNetworkPtrOutput {
	return i.ToK0sNetworkPtrOutputWithContext(context.Background())
}

func (i *k0sNetworkPtrType) ToK0sNetworkPtrOutputWithContext(ctx context.Context) K0sNetworkPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sNetworkPtrOutput)
}

type K0sNetworkOutput struct{ *pulumi.OutputState }

func (K0sNetworkOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sNetwork)(nil)).Elem()
}

func (o K0sNetworkOutput) ToK0sNetworkOutput() K0sNetworkOutput {
	return o
}

func (o K0sNetworkOutput) ToK0sNetworkOutputWithContext(ctx context.Context) K0sNetworkOutput {
	return o
}

func (o K0sNetworkOutput) ToK0sNetworkPtrOutput() K0sNetworkPtrOutput {
	return o.ToK0sNetworkPtrOutputWithContext(context.Background())
}

func (o K0sNetworkOutput) ToK0sNetworkPtrOutputWithContext(ctx context.Context) K0sNetworkPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sNetwork) *K0sNetwork {
		return &v
	}).(K0sNetworkPtrOutput)
}

func (o K0sNetworkOutput) Calico() K0sCalicoPtrOutput {
	return o.ApplyT(func(v K0sNetwork) *K0sCalico { return v.Calico }).(K0sCalicoPtrOutput)
}

func (o K0sNetworkOutput) ClusterDomain() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sNetwork) *string { return v.ClusterDomain }).(pulumi.StringPtrOutput)
}

func (o K0sNetworkOutput) DualStack() K0sDualStackPtrOutput {
	return o.ApplyT(func(v K0sNetwork) *K0sDualStack { return v.DualStack }).(K0sDualStackPtrOutput)
}

func (o K0sNetworkOutput) KubeProxy() K0sKubeProxyPtrOutput {
	return o.ApplyT(func(v K0sNetwork) *K0sKubeProxy { return v.KubeProxy }).(K0sKubeProxyPtrOutput)
}

func (o K0sNetworkOutput) Kuberouter() K0sKubeRouterPtrOutput {
	return o.ApplyT(func(v K0sNetwork) *K0sKubeRouter { return v.Kuberouter }).(K0sKubeRouterPtrOutput)
}

func (o K0sNetworkOutput) NodeLocalLoadBalancing() K0sNodeLocalLoadBalancingPtrOutput {
	return o.ApplyT(func(v K0sNetwork) *K0sNodeLocalLoadBalancing { return v.NodeLocalLoadBalancing }).(K0sNodeLocalLoadBalancingPtrOutput)
}

func (o K0sNetworkOutput) PodCIDR() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sNetwork) *string { return v.PodCIDR }).(pulumi.StringPtrOutput)
}

func (o K0sNetworkOutput) Provider() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sNetwork) *string { return v.Provider }).(pulumi.StringPtrOutput)
}

func (o K0sNetworkOutput) ServiceCIDR() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sNetwork) *string { return v.ServiceCIDR }).(pulumi.StringPtrOutput)
}

type K0sNetworkPtrOutput struct{ *pulumi.OutputState }

func (K0sNetworkPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sNetwork)(nil)).Elem()
}

func (o K0sNetworkPtrOutput) ToK0sNetworkPtrOutput() K0sNetworkPtrOutput {
	return o
}

func (o K0sNetworkPtrOutput) ToK0sNetworkPtrOutputWithContext(ctx context.Context) K0sNetworkPtrOutput {
	return o
}

func (o K0sNetworkPtrOutput) Elem() K0sNetworkOutput {
	return o.ApplyT(func(v *K0sNetwork) K0sNetwork {
		if v != nil {
			return *v
		}
		var ret K0sNetwork
		return ret
	}).(K0sNetworkOutput)
}

func (o K0sNetworkPtrOutput) Calico() K0sCalicoPtrOutput {
	return o.ApplyT(func(v *K0sNetwork) *K0sCalico {
		if v == nil {
			return nil
		}
		return v.Calico
	}).(K0sCalicoPtrOutput)
}

func (o K0sNetworkPtrOutput) ClusterDomain() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sNetwork) *string {
		if v == nil {
			return nil
		}
		return v.ClusterDomain
	}).(pulumi.StringPtrOutput)
}

func (o K0sNetworkPtrOutput) DualStack() K0sDualStackPtrOutput {
	return o.ApplyT(func(v *K0sNetwork) *K0sDualStack {
		if v == nil {
			return nil
		}
		return v.DualStack
	}).(K0sDualStackPtrOutput)
}

func (o K0sNetworkPtrOutput) KubeProxy() K0sKubeProxyPtrOutput {
	return o.ApplyT(func(v *K0sNetwork) *K0sKubeProxy {
		if v == nil {
			return nil
		}
		return v.KubeProxy
	}).(K0sKubeProxyPtrOutput)
}

func (o K0sNetworkPtrOutput) Kuberouter() K0sKubeRouterPtrOutput {
	return o.ApplyT(func(v *K0sNetwork) *K0sKubeRouter {
		if v == nil {
			return nil
		}
		return v.Kuberouter
	}).(K0sKubeRouterPtrOutput)
}

func (o K0sNetworkPtrOutput) NodeLocalLoadBalancing() K0sNodeLocalLoadBalancingPtrOutput {
	return o.ApplyT(func(v *K0sNetwork) *K0sNodeLocalLoadBalancing {
		if v == nil {
			return nil
		}
		return v.NodeLocalLoadBalancing
	}).(K0sNodeLocalLoadBalancingPtrOutput)
}

func (o K0sNetworkPtrOutput) PodCIDR() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sNetwork) *string {
		if v == nil {
			return nil
		}
		return v.PodCIDR
	}).(pulumi.StringPtrOutput)
}

func (o K0sNetworkPtrOutput) Provider() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sNetwork) *string {
		if v == nil {
			return nil
		}
		return v.Provider
	}).(pulumi.StringPtrOutput)
}

func (o K0sNetworkPtrOutput) ServiceCIDR() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sNetwork) *string {
		if v == nil {
			return nil
		}
		return v.ServiceCIDR
	}).(pulumi.StringPtrOutput)
}

type K0sNodeLocalLoadBalancing struct {
	Enabled    *bool          `pulumi:"enabled"`
	EnvoyProxy *K0sEnvoyProxy `pulumi:"envoyProxy"`
	Type       *string        `pulumi:"type"`
}

// K0sNodeLocalLoadBalancingInput is an input type that accepts K0sNodeLocalLoadBalancingArgs and K0sNodeLocalLoadBalancingOutput values.
// You can construct a concrete instance of `K0sNodeLocalLoadBalancingInput` via:
//
//	K0sNodeLocalLoadBalancingArgs{...}
type K0sNodeLocalLoadBalancingInput interface {
	pulumi.Input

	ToK0sNodeLocalLoadBalancingOutput() K0sNodeLocalLoadBalancingOutput
	ToK0sNodeLocalLoadBalancingOutputWithContext(context.Context) K0sNodeLocalLoadBalancingOutput
}

type K0sNodeLocalLoadBalancingArgs struct {
	Enabled    pulumi.BoolPtrInput   `pulumi:"enabled"`
	EnvoyProxy K0sEnvoyProxyPtrInput `pulumi:"envoyProxy"`
	Type       pulumi.StringPtrInput `pulumi:"type"`
}

func (K0sNodeLocalLoadBalancingArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sNodeLocalLoadBalancing)(nil)).Elem()
}

func (i K0sNodeLocalLoadBalancingArgs) ToK0sNodeLocalLoadBalancingOutput() K0sNodeLocalLoadBalancingOutput {
	return i.ToK0sNodeLocalLoadBalancingOutputWithContext(context.Background())
}

func (i K0sNodeLocalLoadBalancingArgs) ToK0sNodeLocalLoadBalancingOutputWithContext(ctx context.Context) K0sNodeLocalLoadBalancingOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sNodeLocalLoadBalancingOutput)
}

func (i K0sNodeLocalLoadBalancingArgs) ToK0sNodeLocalLoadBalancingPtrOutput() K0sNodeLocalLoadBalancingPtrOutput {
	return i.ToK0sNodeLocalLoadBalancingPtrOutputWithContext(context.Background())
}

func (i K0sNodeLocalLoadBalancingArgs) ToK0sNodeLocalLoadBalancingPtrOutputWithContext(ctx context.Context) K0sNodeLocalLoadBalancingPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sNodeLocalLoadBalancingOutput).ToK0sNodeLocalLoadBalancingPtrOutputWithContext(ctx)
}

// K0sNodeLocalLoadBalancingPtrInput is an input type that accepts K0sNodeLocalLoadBalancingArgs, K0sNodeLocalLoadBalancingPtr and K0sNodeLocalLoadBalancingPtrOutput values.
// You can construct a concrete instance of `K0sNodeLocalLoadBalancingPtrInput` via:
//
//	        K0sNodeLocalLoadBalancingArgs{...}
//
//	or:
//
//	        nil
type K0sNodeLocalLoadBalancingPtrInput interface {
	pulumi.Input

	ToK0sNodeLocalLoadBalancingPtrOutput() K0sNodeLocalLoadBalancingPtrOutput
	ToK0sNodeLocalLoadBalancingPtrOutputWithContext(context.Context) K0sNodeLocalLoadBalancingPtrOutput
}

type k0sNodeLocalLoadBalancingPtrType K0sNodeLocalLoadBalancingArgs

func K0sNodeLocalLoadBalancingPtr(v *K0sNodeLocalLoadBalancingArgs) K0sNodeLocalLoadBalancingPtrInput {
	return (*k0sNodeLocalLoadBalancingPtrType)(v)
}

func (*k0sNodeLocalLoadBalancingPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sNodeLocalLoadBalancing)(nil)).Elem()
}

func (i *k0sNodeLocalLoadBalancingPtrType) ToK0sNodeLocalLoadBalancingPtrOutput() K0sNodeLocalLoadBalancingPtrOutput {
	return i.ToK0sNodeLocalLoadBalancingPtrOutputWithContext(context.Background())
}

func (i *k0sNodeLocalLoadBalancingPtrType) ToK0sNodeLocalLoadBalancingPtrOutputWithContext(ctx context.Context) K0sNodeLocalLoadBalancingPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sNodeLocalLoadBalancingPtrOutput)
}

type K0sNodeLocalLoadBalancingOutput struct{ *pulumi.OutputState }

func (K0sNodeLocalLoadBalancingOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sNodeLocalLoadBalancing)(nil)).Elem()
}

func (o K0sNodeLocalLoadBalancingOutput) ToK0sNodeLocalLoadBalancingOutput() K0sNodeLocalLoadBalancingOutput {
	return o
}

func (o K0sNodeLocalLoadBalancingOutput) ToK0sNodeLocalLoadBalancingOutputWithContext(ctx context.Context) K0sNodeLocalLoadBalancingOutput {
	return o
}

func (o K0sNodeLocalLoadBalancingOutput) ToK0sNodeLocalLoadBalancingPtrOutput() K0sNodeLocalLoadBalancingPtrOutput {
	return o.ToK0sNodeLocalLoadBalancingPtrOutputWithContext(context.Background())
}

func (o K0sNodeLocalLoadBalancingOutput) ToK0sNodeLocalLoadBalancingPtrOutputWithContext(ctx context.Context) K0sNodeLocalLoadBalancingPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sNodeLocalLoadBalancing) *K0sNodeLocalLoadBalancing {
		return &v
	}).(K0sNodeLocalLoadBalancingPtrOutput)
}

func (o K0sNodeLocalLoadBalancingOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v K0sNodeLocalLoadBalancing) *bool { return v.Enabled }).(pulumi.BoolPtrOutput)
}

func (o K0sNodeLocalLoadBalancingOutput) EnvoyProxy() K0sEnvoyProxyPtrOutput {
	return o.ApplyT(func(v K0sNodeLocalLoadBalancing) *K0sEnvoyProxy { return v.EnvoyProxy }).(K0sEnvoyProxyPtrOutput)
}

func (o K0sNodeLocalLoadBalancingOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sNodeLocalLoadBalancing) *string { return v.Type }).(pulumi.StringPtrOutput)
}

type K0sNodeLocalLoadBalancingPtrOutput struct{ *pulumi.OutputState }

func (K0sNodeLocalLoadBalancingPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sNodeLocalLoadBalancing)(nil)).Elem()
}

func (o K0sNodeLocalLoadBalancingPtrOutput) ToK0sNodeLocalLoadBalancingPtrOutput() K0sNodeLocalLoadBalancingPtrOutput {
	return o
}

func (o K0sNodeLocalLoadBalancingPtrOutput) ToK0sNodeLocalLoadBalancingPtrOutputWithContext(ctx context.Context) K0sNodeLocalLoadBalancingPtrOutput {
	return o
}

func (o K0sNodeLocalLoadBalancingPtrOutput) Elem() K0sNodeLocalLoadBalancingOutput {
	return o.ApplyT(func(v *K0sNodeLocalLoadBalancing) K0sNodeLocalLoadBalancing {
		if v != nil {
			return *v
		}
		var ret K0sNodeLocalLoadBalancing
		return ret
	}).(K0sNodeLocalLoadBalancingOutput)
}

func (o K0sNodeLocalLoadBalancingPtrOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *K0sNodeLocalLoadBalancing) *bool {
		if v == nil {
			return nil
		}
		return v.Enabled
	}).(pulumi.BoolPtrOutput)
}

func (o K0sNodeLocalLoadBalancingPtrOutput) EnvoyProxy() K0sEnvoyProxyPtrOutput {
	return o.ApplyT(func(v *K0sNodeLocalLoadBalancing) *K0sEnvoyProxy {
		if v == nil {
			return nil
		}
		return v.EnvoyProxy
	}).(K0sEnvoyProxyPtrOutput)
}

func (o K0sNodeLocalLoadBalancingPtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sNodeLocalLoadBalancing) *string {
		if v == nil {
			return nil
		}
		return v.Type
	}).(pulumi.StringPtrOutput)
}

type K0sPodSecurityPolicy struct {
	DefaultPolicy *string `pulumi:"defaultPolicy"`
}

// K0sPodSecurityPolicyInput is an input type that accepts K0sPodSecurityPolicyArgs and K0sPodSecurityPolicyOutput values.
// You can construct a concrete instance of `K0sPodSecurityPolicyInput` via:
//
//	K0sPodSecurityPolicyArgs{...}
type K0sPodSecurityPolicyInput interface {
	pulumi.Input

	ToK0sPodSecurityPolicyOutput() K0sPodSecurityPolicyOutput
	ToK0sPodSecurityPolicyOutputWithContext(context.Context) K0sPodSecurityPolicyOutput
}

type K0sPodSecurityPolicyArgs struct {
	DefaultPolicy pulumi.StringPtrInput `pulumi:"defaultPolicy"`
}

func (K0sPodSecurityPolicyArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sPodSecurityPolicy)(nil)).Elem()
}

func (i K0sPodSecurityPolicyArgs) ToK0sPodSecurityPolicyOutput() K0sPodSecurityPolicyOutput {
	return i.ToK0sPodSecurityPolicyOutputWithContext(context.Background())
}

func (i K0sPodSecurityPolicyArgs) ToK0sPodSecurityPolicyOutputWithContext(ctx context.Context) K0sPodSecurityPolicyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sPodSecurityPolicyOutput)
}

func (i K0sPodSecurityPolicyArgs) ToK0sPodSecurityPolicyPtrOutput() K0sPodSecurityPolicyPtrOutput {
	return i.ToK0sPodSecurityPolicyPtrOutputWithContext(context.Background())
}

func (i K0sPodSecurityPolicyArgs) ToK0sPodSecurityPolicyPtrOutputWithContext(ctx context.Context) K0sPodSecurityPolicyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sPodSecurityPolicyOutput).ToK0sPodSecurityPolicyPtrOutputWithContext(ctx)
}

// K0sPodSecurityPolicyPtrInput is an input type that accepts K0sPodSecurityPolicyArgs, K0sPodSecurityPolicyPtr and K0sPodSecurityPolicyPtrOutput values.
// You can construct a concrete instance of `K0sPodSecurityPolicyPtrInput` via:
//
//	        K0sPodSecurityPolicyArgs{...}
//
//	or:
//
//	        nil
type K0sPodSecurityPolicyPtrInput interface {
	pulumi.Input

	ToK0sPodSecurityPolicyPtrOutput() K0sPodSecurityPolicyPtrOutput
	ToK0sPodSecurityPolicyPtrOutputWithContext(context.Context) K0sPodSecurityPolicyPtrOutput
}

type k0sPodSecurityPolicyPtrType K0sPodSecurityPolicyArgs

func K0sPodSecurityPolicyPtr(v *K0sPodSecurityPolicyArgs) K0sPodSecurityPolicyPtrInput {
	return (*k0sPodSecurityPolicyPtrType)(v)
}

func (*k0sPodSecurityPolicyPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sPodSecurityPolicy)(nil)).Elem()
}

func (i *k0sPodSecurityPolicyPtrType) ToK0sPodSecurityPolicyPtrOutput() K0sPodSecurityPolicyPtrOutput {
	return i.ToK0sPodSecurityPolicyPtrOutputWithContext(context.Background())
}

func (i *k0sPodSecurityPolicyPtrType) ToK0sPodSecurityPolicyPtrOutputWithContext(ctx context.Context) K0sPodSecurityPolicyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sPodSecurityPolicyPtrOutput)
}

type K0sPodSecurityPolicyOutput struct{ *pulumi.OutputState }

func (K0sPodSecurityPolicyOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sPodSecurityPolicy)(nil)).Elem()
}

func (o K0sPodSecurityPolicyOutput) ToK0sPodSecurityPolicyOutput() K0sPodSecurityPolicyOutput {
	return o
}

func (o K0sPodSecurityPolicyOutput) ToK0sPodSecurityPolicyOutputWithContext(ctx context.Context) K0sPodSecurityPolicyOutput {
	return o
}

func (o K0sPodSecurityPolicyOutput) ToK0sPodSecurityPolicyPtrOutput() K0sPodSecurityPolicyPtrOutput {
	return o.ToK0sPodSecurityPolicyPtrOutputWithContext(context.Background())
}

func (o K0sPodSecurityPolicyOutput) ToK0sPodSecurityPolicyPtrOutputWithContext(ctx context.Context) K0sPodSecurityPolicyPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sPodSecurityPolicy) *K0sPodSecurityPolicy {
		return &v
	}).(K0sPodSecurityPolicyPtrOutput)
}

func (o K0sPodSecurityPolicyOutput) DefaultPolicy() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sPodSecurityPolicy) *string { return v.DefaultPolicy }).(pulumi.StringPtrOutput)
}

type K0sPodSecurityPolicyPtrOutput struct{ *pulumi.OutputState }

func (K0sPodSecurityPolicyPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sPodSecurityPolicy)(nil)).Elem()
}

func (o K0sPodSecurityPolicyPtrOutput) ToK0sPodSecurityPolicyPtrOutput() K0sPodSecurityPolicyPtrOutput {
	return o
}

func (o K0sPodSecurityPolicyPtrOutput) ToK0sPodSecurityPolicyPtrOutputWithContext(ctx context.Context) K0sPodSecurityPolicyPtrOutput {
	return o
}

func (o K0sPodSecurityPolicyPtrOutput) Elem() K0sPodSecurityPolicyOutput {
	return o.ApplyT(func(v *K0sPodSecurityPolicy) K0sPodSecurityPolicy {
		if v != nil {
			return *v
		}
		var ret K0sPodSecurityPolicy
		return ret
	}).(K0sPodSecurityPolicyOutput)
}

func (o K0sPodSecurityPolicyPtrOutput) DefaultPolicy() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sPodSecurityPolicy) *string {
		if v == nil {
			return nil
		}
		return v.DefaultPolicy
	}).(pulumi.StringPtrOutput)
}

type K0sScheduler struct {
	ExtraArgs map[string]string `pulumi:"extraArgs"`
}

// K0sSchedulerInput is an input type that accepts K0sSchedulerArgs and K0sSchedulerOutput values.
// You can construct a concrete instance of `K0sSchedulerInput` via:
//
//	K0sSchedulerArgs{...}
type K0sSchedulerInput interface {
	pulumi.Input

	ToK0sSchedulerOutput() K0sSchedulerOutput
	ToK0sSchedulerOutputWithContext(context.Context) K0sSchedulerOutput
}

type K0sSchedulerArgs struct {
	ExtraArgs pulumi.StringMapInput `pulumi:"extraArgs"`
}

func (K0sSchedulerArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sScheduler)(nil)).Elem()
}

func (i K0sSchedulerArgs) ToK0sSchedulerOutput() K0sSchedulerOutput {
	return i.ToK0sSchedulerOutputWithContext(context.Background())
}

func (i K0sSchedulerArgs) ToK0sSchedulerOutputWithContext(ctx context.Context) K0sSchedulerOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sSchedulerOutput)
}

func (i K0sSchedulerArgs) ToK0sSchedulerPtrOutput() K0sSchedulerPtrOutput {
	return i.ToK0sSchedulerPtrOutputWithContext(context.Background())
}

func (i K0sSchedulerArgs) ToK0sSchedulerPtrOutputWithContext(ctx context.Context) K0sSchedulerPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sSchedulerOutput).ToK0sSchedulerPtrOutputWithContext(ctx)
}

// K0sSchedulerPtrInput is an input type that accepts K0sSchedulerArgs, K0sSchedulerPtr and K0sSchedulerPtrOutput values.
// You can construct a concrete instance of `K0sSchedulerPtrInput` via:
//
//	        K0sSchedulerArgs{...}
//
//	or:
//
//	        nil
type K0sSchedulerPtrInput interface {
	pulumi.Input

	ToK0sSchedulerPtrOutput() K0sSchedulerPtrOutput
	ToK0sSchedulerPtrOutputWithContext(context.Context) K0sSchedulerPtrOutput
}

type k0sSchedulerPtrType K0sSchedulerArgs

func K0sSchedulerPtr(v *K0sSchedulerArgs) K0sSchedulerPtrInput {
	return (*k0sSchedulerPtrType)(v)
}

func (*k0sSchedulerPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sScheduler)(nil)).Elem()
}

func (i *k0sSchedulerPtrType) ToK0sSchedulerPtrOutput() K0sSchedulerPtrOutput {
	return i.ToK0sSchedulerPtrOutputWithContext(context.Background())
}

func (i *k0sSchedulerPtrType) ToK0sSchedulerPtrOutputWithContext(ctx context.Context) K0sSchedulerPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sSchedulerPtrOutput)
}

type K0sSchedulerOutput struct{ *pulumi.OutputState }

func (K0sSchedulerOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sScheduler)(nil)).Elem()
}

func (o K0sSchedulerOutput) ToK0sSchedulerOutput() K0sSchedulerOutput {
	return o
}

func (o K0sSchedulerOutput) ToK0sSchedulerOutputWithContext(ctx context.Context) K0sSchedulerOutput {
	return o
}

func (o K0sSchedulerOutput) ToK0sSchedulerPtrOutput() K0sSchedulerPtrOutput {
	return o.ToK0sSchedulerPtrOutputWithContext(context.Background())
}

func (o K0sSchedulerOutput) ToK0sSchedulerPtrOutputWithContext(ctx context.Context) K0sSchedulerPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sScheduler) *K0sScheduler {
		return &v
	}).(K0sSchedulerPtrOutput)
}

func (o K0sSchedulerOutput) ExtraArgs() pulumi.StringMapOutput {
	return o.ApplyT(func(v K0sScheduler) map[string]string { return v.ExtraArgs }).(pulumi.StringMapOutput)
}

type K0sSchedulerPtrOutput struct{ *pulumi.OutputState }

func (K0sSchedulerPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sScheduler)(nil)).Elem()
}

func (o K0sSchedulerPtrOutput) ToK0sSchedulerPtrOutput() K0sSchedulerPtrOutput {
	return o
}

func (o K0sSchedulerPtrOutput) ToK0sSchedulerPtrOutputWithContext(ctx context.Context) K0sSchedulerPtrOutput {
	return o
}

func (o K0sSchedulerPtrOutput) Elem() K0sSchedulerOutput {
	return o.ApplyT(func(v *K0sScheduler) K0sScheduler {
		if v != nil {
			return *v
		}
		var ret K0sScheduler
		return ret
	}).(K0sSchedulerOutput)
}

func (o K0sSchedulerPtrOutput) ExtraArgs() pulumi.StringMapOutput {
	return o.ApplyT(func(v *K0sScheduler) map[string]string {
		if v == nil {
			return nil
		}
		return v.ExtraArgs
	}).(pulumi.StringMapOutput)
}

type K0sSpec struct {
	Api               *K0sAPI               `pulumi:"api"`
	ControllerManager *K0sControllerManager `pulumi:"controllerManager"`
	FeatureGates      []K0sFeatureGate      `pulumi:"featureGates"`
	Images            *K0sImages            `pulumi:"images"`
	InstallConfig     *K0sInstallConfig     `pulumi:"installConfig"`
	Konnectivity      *K0sKonnectivity      `pulumi:"konnectivity"`
	Network           *K0sNetwork           `pulumi:"network"`
	PodSecurityPolicy *K0sPodSecurityPolicy `pulumi:"podSecurityPolicy"`
	Scheduler         *K0sScheduler         `pulumi:"scheduler"`
	Storage           *K0sStorage           `pulumi:"storage"`
	Telemetry         *K0sTelemetry         `pulumi:"telemetry"`
	WorkerProfiles    []K0sWorkerProfile    `pulumi:"workerProfiles"`
}

// K0sSpecInput is an input type that accepts K0sSpecArgs and K0sSpecOutput values.
// You can construct a concrete instance of `K0sSpecInput` via:
//
//	K0sSpecArgs{...}
type K0sSpecInput interface {
	pulumi.Input

	ToK0sSpecOutput() K0sSpecOutput
	ToK0sSpecOutputWithContext(context.Context) K0sSpecOutput
}

type K0sSpecArgs struct {
	Api               K0sAPIPtrInput               `pulumi:"api"`
	ControllerManager K0sControllerManagerPtrInput `pulumi:"controllerManager"`
	FeatureGates      K0sFeatureGateArrayInput     `pulumi:"featureGates"`
	Images            K0sImagesPtrInput            `pulumi:"images"`
	InstallConfig     K0sInstallConfigPtrInput     `pulumi:"installConfig"`
	Konnectivity      K0sKonnectivityPtrInput      `pulumi:"konnectivity"`
	Network           K0sNetworkPtrInput           `pulumi:"network"`
	PodSecurityPolicy K0sPodSecurityPolicyPtrInput `pulumi:"podSecurityPolicy"`
	Scheduler         K0sSchedulerPtrInput         `pulumi:"scheduler"`
	Storage           K0sStoragePtrInput           `pulumi:"storage"`
	Telemetry         K0sTelemetryPtrInput         `pulumi:"telemetry"`
	WorkerProfiles    K0sWorkerProfileArrayInput   `pulumi:"workerProfiles"`
}

func (K0sSpecArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sSpec)(nil)).Elem()
}

func (i K0sSpecArgs) ToK0sSpecOutput() K0sSpecOutput {
	return i.ToK0sSpecOutputWithContext(context.Background())
}

func (i K0sSpecArgs) ToK0sSpecOutputWithContext(ctx context.Context) K0sSpecOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sSpecOutput)
}

func (i K0sSpecArgs) ToK0sSpecPtrOutput() K0sSpecPtrOutput {
	return i.ToK0sSpecPtrOutputWithContext(context.Background())
}

func (i K0sSpecArgs) ToK0sSpecPtrOutputWithContext(ctx context.Context) K0sSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sSpecOutput).ToK0sSpecPtrOutputWithContext(ctx)
}

// K0sSpecPtrInput is an input type that accepts K0sSpecArgs, K0sSpecPtr and K0sSpecPtrOutput values.
// You can construct a concrete instance of `K0sSpecPtrInput` via:
//
//	        K0sSpecArgs{...}
//
//	or:
//
//	        nil
type K0sSpecPtrInput interface {
	pulumi.Input

	ToK0sSpecPtrOutput() K0sSpecPtrOutput
	ToK0sSpecPtrOutputWithContext(context.Context) K0sSpecPtrOutput
}

type k0sSpecPtrType K0sSpecArgs

func K0sSpecPtr(v *K0sSpecArgs) K0sSpecPtrInput {
	return (*k0sSpecPtrType)(v)
}

func (*k0sSpecPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sSpec)(nil)).Elem()
}

func (i *k0sSpecPtrType) ToK0sSpecPtrOutput() K0sSpecPtrOutput {
	return i.ToK0sSpecPtrOutputWithContext(context.Background())
}

func (i *k0sSpecPtrType) ToK0sSpecPtrOutputWithContext(ctx context.Context) K0sSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sSpecPtrOutput)
}

type K0sSpecOutput struct{ *pulumi.OutputState }

func (K0sSpecOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sSpec)(nil)).Elem()
}

func (o K0sSpecOutput) ToK0sSpecOutput() K0sSpecOutput {
	return o
}

func (o K0sSpecOutput) ToK0sSpecOutputWithContext(ctx context.Context) K0sSpecOutput {
	return o
}

func (o K0sSpecOutput) ToK0sSpecPtrOutput() K0sSpecPtrOutput {
	return o.ToK0sSpecPtrOutputWithContext(context.Background())
}

func (o K0sSpecOutput) ToK0sSpecPtrOutputWithContext(ctx context.Context) K0sSpecPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sSpec) *K0sSpec {
		return &v
	}).(K0sSpecPtrOutput)
}

func (o K0sSpecOutput) Api() K0sAPIPtrOutput {
	return o.ApplyT(func(v K0sSpec) *K0sAPI { return v.Api }).(K0sAPIPtrOutput)
}

func (o K0sSpecOutput) ControllerManager() K0sControllerManagerPtrOutput {
	return o.ApplyT(func(v K0sSpec) *K0sControllerManager { return v.ControllerManager }).(K0sControllerManagerPtrOutput)
}

func (o K0sSpecOutput) FeatureGates() K0sFeatureGateArrayOutput {
	return o.ApplyT(func(v K0sSpec) []K0sFeatureGate { return v.FeatureGates }).(K0sFeatureGateArrayOutput)
}

func (o K0sSpecOutput) Images() K0sImagesPtrOutput {
	return o.ApplyT(func(v K0sSpec) *K0sImages { return v.Images }).(K0sImagesPtrOutput)
}

func (o K0sSpecOutput) InstallConfig() K0sInstallConfigPtrOutput {
	return o.ApplyT(func(v K0sSpec) *K0sInstallConfig { return v.InstallConfig }).(K0sInstallConfigPtrOutput)
}

func (o K0sSpecOutput) Konnectivity() K0sKonnectivityPtrOutput {
	return o.ApplyT(func(v K0sSpec) *K0sKonnectivity { return v.Konnectivity }).(K0sKonnectivityPtrOutput)
}

func (o K0sSpecOutput) Network() K0sNetworkPtrOutput {
	return o.ApplyT(func(v K0sSpec) *K0sNetwork { return v.Network }).(K0sNetworkPtrOutput)
}

func (o K0sSpecOutput) PodSecurityPolicy() K0sPodSecurityPolicyPtrOutput {
	return o.ApplyT(func(v K0sSpec) *K0sPodSecurityPolicy { return v.PodSecurityPolicy }).(K0sPodSecurityPolicyPtrOutput)
}

func (o K0sSpecOutput) Scheduler() K0sSchedulerPtrOutput {
	return o.ApplyT(func(v K0sSpec) *K0sScheduler { return v.Scheduler }).(K0sSchedulerPtrOutput)
}

func (o K0sSpecOutput) Storage() K0sStoragePtrOutput {
	return o.ApplyT(func(v K0sSpec) *K0sStorage { return v.Storage }).(K0sStoragePtrOutput)
}

func (o K0sSpecOutput) Telemetry() K0sTelemetryPtrOutput {
	return o.ApplyT(func(v K0sSpec) *K0sTelemetry { return v.Telemetry }).(K0sTelemetryPtrOutput)
}

func (o K0sSpecOutput) WorkerProfiles() K0sWorkerProfileArrayOutput {
	return o.ApplyT(func(v K0sSpec) []K0sWorkerProfile { return v.WorkerProfiles }).(K0sWorkerProfileArrayOutput)
}

type K0sSpecPtrOutput struct{ *pulumi.OutputState }

func (K0sSpecPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sSpec)(nil)).Elem()
}

func (o K0sSpecPtrOutput) ToK0sSpecPtrOutput() K0sSpecPtrOutput {
	return o
}

func (o K0sSpecPtrOutput) ToK0sSpecPtrOutputWithContext(ctx context.Context) K0sSpecPtrOutput {
	return o
}

func (o K0sSpecPtrOutput) Elem() K0sSpecOutput {
	return o.ApplyT(func(v *K0sSpec) K0sSpec {
		if v != nil {
			return *v
		}
		var ret K0sSpec
		return ret
	}).(K0sSpecOutput)
}

func (o K0sSpecPtrOutput) Api() K0sAPIPtrOutput {
	return o.ApplyT(func(v *K0sSpec) *K0sAPI {
		if v == nil {
			return nil
		}
		return v.Api
	}).(K0sAPIPtrOutput)
}

func (o K0sSpecPtrOutput) ControllerManager() K0sControllerManagerPtrOutput {
	return o.ApplyT(func(v *K0sSpec) *K0sControllerManager {
		if v == nil {
			return nil
		}
		return v.ControllerManager
	}).(K0sControllerManagerPtrOutput)
}

func (o K0sSpecPtrOutput) FeatureGates() K0sFeatureGateArrayOutput {
	return o.ApplyT(func(v *K0sSpec) []K0sFeatureGate {
		if v == nil {
			return nil
		}
		return v.FeatureGates
	}).(K0sFeatureGateArrayOutput)
}

func (o K0sSpecPtrOutput) Images() K0sImagesPtrOutput {
	return o.ApplyT(func(v *K0sSpec) *K0sImages {
		if v == nil {
			return nil
		}
		return v.Images
	}).(K0sImagesPtrOutput)
}

func (o K0sSpecPtrOutput) InstallConfig() K0sInstallConfigPtrOutput {
	return o.ApplyT(func(v *K0sSpec) *K0sInstallConfig {
		if v == nil {
			return nil
		}
		return v.InstallConfig
	}).(K0sInstallConfigPtrOutput)
}

func (o K0sSpecPtrOutput) Konnectivity() K0sKonnectivityPtrOutput {
	return o.ApplyT(func(v *K0sSpec) *K0sKonnectivity {
		if v == nil {
			return nil
		}
		return v.Konnectivity
	}).(K0sKonnectivityPtrOutput)
}

func (o K0sSpecPtrOutput) Network() K0sNetworkPtrOutput {
	return o.ApplyT(func(v *K0sSpec) *K0sNetwork {
		if v == nil {
			return nil
		}
		return v.Network
	}).(K0sNetworkPtrOutput)
}

func (o K0sSpecPtrOutput) PodSecurityPolicy() K0sPodSecurityPolicyPtrOutput {
	return o.ApplyT(func(v *K0sSpec) *K0sPodSecurityPolicy {
		if v == nil {
			return nil
		}
		return v.PodSecurityPolicy
	}).(K0sPodSecurityPolicyPtrOutput)
}

func (o K0sSpecPtrOutput) Scheduler() K0sSchedulerPtrOutput {
	return o.ApplyT(func(v *K0sSpec) *K0sScheduler {
		if v == nil {
			return nil
		}
		return v.Scheduler
	}).(K0sSchedulerPtrOutput)
}

func (o K0sSpecPtrOutput) Storage() K0sStoragePtrOutput {
	return o.ApplyT(func(v *K0sSpec) *K0sStorage {
		if v == nil {
			return nil
		}
		return v.Storage
	}).(K0sStoragePtrOutput)
}

func (o K0sSpecPtrOutput) Telemetry() K0sTelemetryPtrOutput {
	return o.ApplyT(func(v *K0sSpec) *K0sTelemetry {
		if v == nil {
			return nil
		}
		return v.Telemetry
	}).(K0sTelemetryPtrOutput)
}

func (o K0sSpecPtrOutput) WorkerProfiles() K0sWorkerProfileArrayOutput {
	return o.ApplyT(func(v *K0sSpec) []K0sWorkerProfile {
		if v == nil {
			return nil
		}
		return v.WorkerProfiles
	}).(K0sWorkerProfileArrayOutput)
}

type K0sStorage struct {
	Etcd *K0sEtcd `pulumi:"etcd"`
	Kine *K0sKine `pulumi:"kine"`
	Type *string  `pulumi:"type"`
}

// K0sStorageInput is an input type that accepts K0sStorageArgs and K0sStorageOutput values.
// You can construct a concrete instance of `K0sStorageInput` via:
//
//	K0sStorageArgs{...}
type K0sStorageInput interface {
	pulumi.Input

	ToK0sStorageOutput() K0sStorageOutput
	ToK0sStorageOutputWithContext(context.Context) K0sStorageOutput
}

type K0sStorageArgs struct {
	Etcd K0sEtcdPtrInput       `pulumi:"etcd"`
	Kine K0sKinePtrInput       `pulumi:"kine"`
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (K0sStorageArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sStorage)(nil)).Elem()
}

func (i K0sStorageArgs) ToK0sStorageOutput() K0sStorageOutput {
	return i.ToK0sStorageOutputWithContext(context.Background())
}

func (i K0sStorageArgs) ToK0sStorageOutputWithContext(ctx context.Context) K0sStorageOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sStorageOutput)
}

func (i K0sStorageArgs) ToK0sStoragePtrOutput() K0sStoragePtrOutput {
	return i.ToK0sStoragePtrOutputWithContext(context.Background())
}

func (i K0sStorageArgs) ToK0sStoragePtrOutputWithContext(ctx context.Context) K0sStoragePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sStorageOutput).ToK0sStoragePtrOutputWithContext(ctx)
}

// K0sStoragePtrInput is an input type that accepts K0sStorageArgs, K0sStoragePtr and K0sStoragePtrOutput values.
// You can construct a concrete instance of `K0sStoragePtrInput` via:
//
//	        K0sStorageArgs{...}
//
//	or:
//
//	        nil
type K0sStoragePtrInput interface {
	pulumi.Input

	ToK0sStoragePtrOutput() K0sStoragePtrOutput
	ToK0sStoragePtrOutputWithContext(context.Context) K0sStoragePtrOutput
}

type k0sStoragePtrType K0sStorageArgs

func K0sStoragePtr(v *K0sStorageArgs) K0sStoragePtrInput {
	return (*k0sStoragePtrType)(v)
}

func (*k0sStoragePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sStorage)(nil)).Elem()
}

func (i *k0sStoragePtrType) ToK0sStoragePtrOutput() K0sStoragePtrOutput {
	return i.ToK0sStoragePtrOutputWithContext(context.Background())
}

func (i *k0sStoragePtrType) ToK0sStoragePtrOutputWithContext(ctx context.Context) K0sStoragePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sStoragePtrOutput)
}

type K0sStorageOutput struct{ *pulumi.OutputState }

func (K0sStorageOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sStorage)(nil)).Elem()
}

func (o K0sStorageOutput) ToK0sStorageOutput() K0sStorageOutput {
	return o
}

func (o K0sStorageOutput) ToK0sStorageOutputWithContext(ctx context.Context) K0sStorageOutput {
	return o
}

func (o K0sStorageOutput) ToK0sStoragePtrOutput() K0sStoragePtrOutput {
	return o.ToK0sStoragePtrOutputWithContext(context.Background())
}

func (o K0sStorageOutput) ToK0sStoragePtrOutputWithContext(ctx context.Context) K0sStoragePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sStorage) *K0sStorage {
		return &v
	}).(K0sStoragePtrOutput)
}

func (o K0sStorageOutput) Etcd() K0sEtcdPtrOutput {
	return o.ApplyT(func(v K0sStorage) *K0sEtcd { return v.Etcd }).(K0sEtcdPtrOutput)
}

func (o K0sStorageOutput) Kine() K0sKinePtrOutput {
	return o.ApplyT(func(v K0sStorage) *K0sKine { return v.Kine }).(K0sKinePtrOutput)
}

func (o K0sStorageOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v K0sStorage) *string { return v.Type }).(pulumi.StringPtrOutput)
}

type K0sStoragePtrOutput struct{ *pulumi.OutputState }

func (K0sStoragePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sStorage)(nil)).Elem()
}

func (o K0sStoragePtrOutput) ToK0sStoragePtrOutput() K0sStoragePtrOutput {
	return o
}

func (o K0sStoragePtrOutput) ToK0sStoragePtrOutputWithContext(ctx context.Context) K0sStoragePtrOutput {
	return o
}

func (o K0sStoragePtrOutput) Elem() K0sStorageOutput {
	return o.ApplyT(func(v *K0sStorage) K0sStorage {
		if v != nil {
			return *v
		}
		var ret K0sStorage
		return ret
	}).(K0sStorageOutput)
}

func (o K0sStoragePtrOutput) Etcd() K0sEtcdPtrOutput {
	return o.ApplyT(func(v *K0sStorage) *K0sEtcd {
		if v == nil {
			return nil
		}
		return v.Etcd
	}).(K0sEtcdPtrOutput)
}

func (o K0sStoragePtrOutput) Kine() K0sKinePtrOutput {
	return o.ApplyT(func(v *K0sStorage) *K0sKine {
		if v == nil {
			return nil
		}
		return v.Kine
	}).(K0sKinePtrOutput)
}

func (o K0sStoragePtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *K0sStorage) *string {
		if v == nil {
			return nil
		}
		return v.Type
	}).(pulumi.StringPtrOutput)
}

type K0sTelemetry struct {
	Enabled *bool `pulumi:"enabled"`
}

// K0sTelemetryInput is an input type that accepts K0sTelemetryArgs and K0sTelemetryOutput values.
// You can construct a concrete instance of `K0sTelemetryInput` via:
//
//	K0sTelemetryArgs{...}
type K0sTelemetryInput interface {
	pulumi.Input

	ToK0sTelemetryOutput() K0sTelemetryOutput
	ToK0sTelemetryOutputWithContext(context.Context) K0sTelemetryOutput
}

type K0sTelemetryArgs struct {
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
}

func (K0sTelemetryArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sTelemetry)(nil)).Elem()
}

func (i K0sTelemetryArgs) ToK0sTelemetryOutput() K0sTelemetryOutput {
	return i.ToK0sTelemetryOutputWithContext(context.Background())
}

func (i K0sTelemetryArgs) ToK0sTelemetryOutputWithContext(ctx context.Context) K0sTelemetryOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sTelemetryOutput)
}

func (i K0sTelemetryArgs) ToK0sTelemetryPtrOutput() K0sTelemetryPtrOutput {
	return i.ToK0sTelemetryPtrOutputWithContext(context.Background())
}

func (i K0sTelemetryArgs) ToK0sTelemetryPtrOutputWithContext(ctx context.Context) K0sTelemetryPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sTelemetryOutput).ToK0sTelemetryPtrOutputWithContext(ctx)
}

// K0sTelemetryPtrInput is an input type that accepts K0sTelemetryArgs, K0sTelemetryPtr and K0sTelemetryPtrOutput values.
// You can construct a concrete instance of `K0sTelemetryPtrInput` via:
//
//	        K0sTelemetryArgs{...}
//
//	or:
//
//	        nil
type K0sTelemetryPtrInput interface {
	pulumi.Input

	ToK0sTelemetryPtrOutput() K0sTelemetryPtrOutput
	ToK0sTelemetryPtrOutputWithContext(context.Context) K0sTelemetryPtrOutput
}

type k0sTelemetryPtrType K0sTelemetryArgs

func K0sTelemetryPtr(v *K0sTelemetryArgs) K0sTelemetryPtrInput {
	return (*k0sTelemetryPtrType)(v)
}

func (*k0sTelemetryPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sTelemetry)(nil)).Elem()
}

func (i *k0sTelemetryPtrType) ToK0sTelemetryPtrOutput() K0sTelemetryPtrOutput {
	return i.ToK0sTelemetryPtrOutputWithContext(context.Background())
}

func (i *k0sTelemetryPtrType) ToK0sTelemetryPtrOutputWithContext(ctx context.Context) K0sTelemetryPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sTelemetryPtrOutput)
}

type K0sTelemetryOutput struct{ *pulumi.OutputState }

func (K0sTelemetryOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sTelemetry)(nil)).Elem()
}

func (o K0sTelemetryOutput) ToK0sTelemetryOutput() K0sTelemetryOutput {
	return o
}

func (o K0sTelemetryOutput) ToK0sTelemetryOutputWithContext(ctx context.Context) K0sTelemetryOutput {
	return o
}

func (o K0sTelemetryOutput) ToK0sTelemetryPtrOutput() K0sTelemetryPtrOutput {
	return o.ToK0sTelemetryPtrOutputWithContext(context.Background())
}

func (o K0sTelemetryOutput) ToK0sTelemetryPtrOutputWithContext(ctx context.Context) K0sTelemetryPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v K0sTelemetry) *K0sTelemetry {
		return &v
	}).(K0sTelemetryPtrOutput)
}

func (o K0sTelemetryOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v K0sTelemetry) *bool { return v.Enabled }).(pulumi.BoolPtrOutput)
}

type K0sTelemetryPtrOutput struct{ *pulumi.OutputState }

func (K0sTelemetryPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**K0sTelemetry)(nil)).Elem()
}

func (o K0sTelemetryPtrOutput) ToK0sTelemetryPtrOutput() K0sTelemetryPtrOutput {
	return o
}

func (o K0sTelemetryPtrOutput) ToK0sTelemetryPtrOutputWithContext(ctx context.Context) K0sTelemetryPtrOutput {
	return o
}

func (o K0sTelemetryPtrOutput) Elem() K0sTelemetryOutput {
	return o.ApplyT(func(v *K0sTelemetry) K0sTelemetry {
		if v != nil {
			return *v
		}
		var ret K0sTelemetry
		return ret
	}).(K0sTelemetryOutput)
}

func (o K0sTelemetryPtrOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *K0sTelemetry) *bool {
		if v == nil {
			return nil
		}
		return v.Enabled
	}).(pulumi.BoolPtrOutput)
}

type K0sWorkerProfile struct {
	Name   string                 `pulumi:"name"`
	Values map[string]interface{} `pulumi:"values"`
}

// K0sWorkerProfileInput is an input type that accepts K0sWorkerProfileArgs and K0sWorkerProfileOutput values.
// You can construct a concrete instance of `K0sWorkerProfileInput` via:
//
//	K0sWorkerProfileArgs{...}
type K0sWorkerProfileInput interface {
	pulumi.Input

	ToK0sWorkerProfileOutput() K0sWorkerProfileOutput
	ToK0sWorkerProfileOutputWithContext(context.Context) K0sWorkerProfileOutput
}

type K0sWorkerProfileArgs struct {
	Name   pulumi.StringInput `pulumi:"name"`
	Values pulumi.MapInput    `pulumi:"values"`
}

func (K0sWorkerProfileArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sWorkerProfile)(nil)).Elem()
}

func (i K0sWorkerProfileArgs) ToK0sWorkerProfileOutput() K0sWorkerProfileOutput {
	return i.ToK0sWorkerProfileOutputWithContext(context.Background())
}

func (i K0sWorkerProfileArgs) ToK0sWorkerProfileOutputWithContext(ctx context.Context) K0sWorkerProfileOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sWorkerProfileOutput)
}

// K0sWorkerProfileArrayInput is an input type that accepts K0sWorkerProfileArray and K0sWorkerProfileArrayOutput values.
// You can construct a concrete instance of `K0sWorkerProfileArrayInput` via:
//
//	K0sWorkerProfileArray{ K0sWorkerProfileArgs{...} }
type K0sWorkerProfileArrayInput interface {
	pulumi.Input

	ToK0sWorkerProfileArrayOutput() K0sWorkerProfileArrayOutput
	ToK0sWorkerProfileArrayOutputWithContext(context.Context) K0sWorkerProfileArrayOutput
}

type K0sWorkerProfileArray []K0sWorkerProfileInput

func (K0sWorkerProfileArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]K0sWorkerProfile)(nil)).Elem()
}

func (i K0sWorkerProfileArray) ToK0sWorkerProfileArrayOutput() K0sWorkerProfileArrayOutput {
	return i.ToK0sWorkerProfileArrayOutputWithContext(context.Background())
}

func (i K0sWorkerProfileArray) ToK0sWorkerProfileArrayOutputWithContext(ctx context.Context) K0sWorkerProfileArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(K0sWorkerProfileArrayOutput)
}

type K0sWorkerProfileOutput struct{ *pulumi.OutputState }

func (K0sWorkerProfileOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*K0sWorkerProfile)(nil)).Elem()
}

func (o K0sWorkerProfileOutput) ToK0sWorkerProfileOutput() K0sWorkerProfileOutput {
	return o
}

func (o K0sWorkerProfileOutput) ToK0sWorkerProfileOutputWithContext(ctx context.Context) K0sWorkerProfileOutput {
	return o
}

func (o K0sWorkerProfileOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v K0sWorkerProfile) string { return v.Name }).(pulumi.StringOutput)
}

func (o K0sWorkerProfileOutput) Values() pulumi.MapOutput {
	return o.ApplyT(func(v K0sWorkerProfile) map[string]interface{} { return v.Values }).(pulumi.MapOutput)
}

type K0sWorkerProfileArrayOutput struct{ *pulumi.OutputState }

func (K0sWorkerProfileArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]K0sWorkerProfile)(nil)).Elem()
}

func (o K0sWorkerProfileArrayOutput) ToK0sWorkerProfileArrayOutput() K0sWorkerProfileArrayOutput {
	return o
}

func (o K0sWorkerProfileArrayOutput) ToK0sWorkerProfileArrayOutputWithContext(ctx context.Context) K0sWorkerProfileArrayOutput {
	return o
}

func (o K0sWorkerProfileArrayOutput) Index(i pulumi.IntInput) K0sWorkerProfileOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) K0sWorkerProfile {
		return vs[0].([]K0sWorkerProfile)[vs[1].(int)]
	}).(K0sWorkerProfileOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterFileInput)(nil)).Elem(), ClusterFileArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterFileArrayInput)(nil)).Elem(), ClusterFileArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterHookInput)(nil)).Elem(), ClusterHookArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterHookPtrInput)(nil)).Elem(), ClusterHookArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterHooksInput)(nil)).Elem(), ClusterHooksArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterHooksPtrInput)(nil)).Elem(), ClusterHooksArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterHostInput)(nil)).Elem(), ClusterHostArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterHostArrayInput)(nil)).Elem(), ClusterHostArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterK0sInput)(nil)).Elem(), ClusterK0sArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterK0sPtrInput)(nil)).Elem(), ClusterK0sArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterLocalhostInput)(nil)).Elem(), ClusterLocalhostArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterLocalhostPtrInput)(nil)).Elem(), ClusterLocalhostArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterMetadataInput)(nil)).Elem(), ClusterMetadataArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterMetadataPtrInput)(nil)).Elem(), ClusterMetadataArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterSSHInput)(nil)).Elem(), ClusterSSHArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterSSHPtrInput)(nil)).Elem(), ClusterSSHArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterSpecInput)(nil)).Elem(), ClusterSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterSpecPtrInput)(nil)).Elem(), ClusterSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterWinRMInput)(nil)).Elem(), ClusterWinRMArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ClusterWinRMPtrInput)(nil)).Elem(), ClusterWinRMArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sInput)(nil)).Elem(), K0sArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sPtrInput)(nil)).Elem(), K0sArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sAPIInput)(nil)).Elem(), K0sAPIArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sAPIPtrInput)(nil)).Elem(), K0sAPIArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sCalicoInput)(nil)).Elem(), K0sCalicoArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sCalicoPtrInput)(nil)).Elem(), K0sCalicoArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sCalicoImageInput)(nil)).Elem(), K0sCalicoImageArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sCalicoImagePtrInput)(nil)).Elem(), K0sCalicoImageArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sControllerManagerInput)(nil)).Elem(), K0sControllerManagerArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sControllerManagerPtrInput)(nil)).Elem(), K0sControllerManagerArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sDualStackInput)(nil)).Elem(), K0sDualStackArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sDualStackPtrInput)(nil)).Elem(), K0sDualStackArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sEnvoyProxyInput)(nil)).Elem(), K0sEnvoyProxyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sEnvoyProxyPtrInput)(nil)).Elem(), K0sEnvoyProxyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sEtcdInput)(nil)).Elem(), K0sEtcdArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sEtcdPtrInput)(nil)).Elem(), K0sEtcdArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sEtcdExternalClusterInput)(nil)).Elem(), K0sEtcdExternalClusterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sEtcdExternalClusterPtrInput)(nil)).Elem(), K0sEtcdExternalClusterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sFeatureGateInput)(nil)).Elem(), K0sFeatureGateArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sFeatureGateArrayInput)(nil)).Elem(), K0sFeatureGateArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sImageInput)(nil)).Elem(), K0sImageArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sImagePtrInput)(nil)).Elem(), K0sImageArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sImagesInput)(nil)).Elem(), K0sImagesArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sImagesPtrInput)(nil)).Elem(), K0sImagesArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sInstallConfigInput)(nil)).Elem(), K0sInstallConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sInstallConfigPtrInput)(nil)).Elem(), K0sInstallConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sInstallConfigUserInput)(nil)).Elem(), K0sInstallConfigUserArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sInstallConfigUserPtrInput)(nil)).Elem(), K0sInstallConfigUserArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sKineInput)(nil)).Elem(), K0sKineArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sKinePtrInput)(nil)).Elem(), K0sKineArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sKonnectivityInput)(nil)).Elem(), K0sKonnectivityArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sKonnectivityPtrInput)(nil)).Elem(), K0sKonnectivityArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sKubeProxyInput)(nil)).Elem(), K0sKubeProxyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sKubeProxyPtrInput)(nil)).Elem(), K0sKubeProxyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sKubeProxyIPTablesInput)(nil)).Elem(), K0sKubeProxyIPTablesArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sKubeProxyIPTablesPtrInput)(nil)).Elem(), K0sKubeProxyIPTablesArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sKubeProxyIPVSInput)(nil)).Elem(), K0sKubeProxyIPVSArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sKubeProxyIPVSPtrInput)(nil)).Elem(), K0sKubeProxyIPVSArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sKubeRouterInput)(nil)).Elem(), K0sKubeRouterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sKubeRouterPtrInput)(nil)).Elem(), K0sKubeRouterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sKubeRouterImageInput)(nil)).Elem(), K0sKubeRouterImageArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sKubeRouterImagePtrInput)(nil)).Elem(), K0sKubeRouterImageArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sMetadataInput)(nil)).Elem(), K0sMetadataArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sMetadataPtrInput)(nil)).Elem(), K0sMetadataArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sNetworkInput)(nil)).Elem(), K0sNetworkArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sNetworkPtrInput)(nil)).Elem(), K0sNetworkArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sNodeLocalLoadBalancingInput)(nil)).Elem(), K0sNodeLocalLoadBalancingArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sNodeLocalLoadBalancingPtrInput)(nil)).Elem(), K0sNodeLocalLoadBalancingArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sPodSecurityPolicyInput)(nil)).Elem(), K0sPodSecurityPolicyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sPodSecurityPolicyPtrInput)(nil)).Elem(), K0sPodSecurityPolicyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sSchedulerInput)(nil)).Elem(), K0sSchedulerArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sSchedulerPtrInput)(nil)).Elem(), K0sSchedulerArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sSpecInput)(nil)).Elem(), K0sSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sSpecPtrInput)(nil)).Elem(), K0sSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sStorageInput)(nil)).Elem(), K0sStorageArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sStoragePtrInput)(nil)).Elem(), K0sStorageArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sTelemetryInput)(nil)).Elem(), K0sTelemetryArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sTelemetryPtrInput)(nil)).Elem(), K0sTelemetryArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sWorkerProfileInput)(nil)).Elem(), K0sWorkerProfileArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*K0sWorkerProfileArrayInput)(nil)).Elem(), K0sWorkerProfileArray{})
	pulumi.RegisterOutputType(ClusterFileOutput{})
	pulumi.RegisterOutputType(ClusterFileArrayOutput{})
	pulumi.RegisterOutputType(ClusterHookOutput{})
	pulumi.RegisterOutputType(ClusterHookPtrOutput{})
	pulumi.RegisterOutputType(ClusterHooksOutput{})
	pulumi.RegisterOutputType(ClusterHooksPtrOutput{})
	pulumi.RegisterOutputType(ClusterHostOutput{})
	pulumi.RegisterOutputType(ClusterHostArrayOutput{})
	pulumi.RegisterOutputType(ClusterK0sOutput{})
	pulumi.RegisterOutputType(ClusterK0sPtrOutput{})
	pulumi.RegisterOutputType(ClusterLocalhostOutput{})
	pulumi.RegisterOutputType(ClusterLocalhostPtrOutput{})
	pulumi.RegisterOutputType(ClusterMetadataOutput{})
	pulumi.RegisterOutputType(ClusterMetadataPtrOutput{})
	pulumi.RegisterOutputType(ClusterSSHOutput{})
	pulumi.RegisterOutputType(ClusterSSHPtrOutput{})
	pulumi.RegisterOutputType(ClusterSpecOutput{})
	pulumi.RegisterOutputType(ClusterSpecPtrOutput{})
	pulumi.RegisterOutputType(ClusterWinRMOutput{})
	pulumi.RegisterOutputType(ClusterWinRMPtrOutput{})
	pulumi.RegisterOutputType(K0sOutput{})
	pulumi.RegisterOutputType(K0sPtrOutput{})
	pulumi.RegisterOutputType(K0sAPIOutput{})
	pulumi.RegisterOutputType(K0sAPIPtrOutput{})
	pulumi.RegisterOutputType(K0sCalicoOutput{})
	pulumi.RegisterOutputType(K0sCalicoPtrOutput{})
	pulumi.RegisterOutputType(K0sCalicoImageOutput{})
	pulumi.RegisterOutputType(K0sCalicoImagePtrOutput{})
	pulumi.RegisterOutputType(K0sControllerManagerOutput{})
	pulumi.RegisterOutputType(K0sControllerManagerPtrOutput{})
	pulumi.RegisterOutputType(K0sDualStackOutput{})
	pulumi.RegisterOutputType(K0sDualStackPtrOutput{})
	pulumi.RegisterOutputType(K0sEnvoyProxyOutput{})
	pulumi.RegisterOutputType(K0sEnvoyProxyPtrOutput{})
	pulumi.RegisterOutputType(K0sEtcdOutput{})
	pulumi.RegisterOutputType(K0sEtcdPtrOutput{})
	pulumi.RegisterOutputType(K0sEtcdExternalClusterOutput{})
	pulumi.RegisterOutputType(K0sEtcdExternalClusterPtrOutput{})
	pulumi.RegisterOutputType(K0sFeatureGateOutput{})
	pulumi.RegisterOutputType(K0sFeatureGateArrayOutput{})
	pulumi.RegisterOutputType(K0sImageOutput{})
	pulumi.RegisterOutputType(K0sImagePtrOutput{})
	pulumi.RegisterOutputType(K0sImagesOutput{})
	pulumi.RegisterOutputType(K0sImagesPtrOutput{})
	pulumi.RegisterOutputType(K0sInstallConfigOutput{})
	pulumi.RegisterOutputType(K0sInstallConfigPtrOutput{})
	pulumi.RegisterOutputType(K0sInstallConfigUserOutput{})
	pulumi.RegisterOutputType(K0sInstallConfigUserPtrOutput{})
	pulumi.RegisterOutputType(K0sKineOutput{})
	pulumi.RegisterOutputType(K0sKinePtrOutput{})
	pulumi.RegisterOutputType(K0sKonnectivityOutput{})
	pulumi.RegisterOutputType(K0sKonnectivityPtrOutput{})
	pulumi.RegisterOutputType(K0sKubeProxyOutput{})
	pulumi.RegisterOutputType(K0sKubeProxyPtrOutput{})
	pulumi.RegisterOutputType(K0sKubeProxyIPTablesOutput{})
	pulumi.RegisterOutputType(K0sKubeProxyIPTablesPtrOutput{})
	pulumi.RegisterOutputType(K0sKubeProxyIPVSOutput{})
	pulumi.RegisterOutputType(K0sKubeProxyIPVSPtrOutput{})
	pulumi.RegisterOutputType(K0sKubeRouterOutput{})
	pulumi.RegisterOutputType(K0sKubeRouterPtrOutput{})
	pulumi.RegisterOutputType(K0sKubeRouterImageOutput{})
	pulumi.RegisterOutputType(K0sKubeRouterImagePtrOutput{})
	pulumi.RegisterOutputType(K0sMetadataOutput{})
	pulumi.RegisterOutputType(K0sMetadataPtrOutput{})
	pulumi.RegisterOutputType(K0sNetworkOutput{})
	pulumi.RegisterOutputType(K0sNetworkPtrOutput{})
	pulumi.RegisterOutputType(K0sNodeLocalLoadBalancingOutput{})
	pulumi.RegisterOutputType(K0sNodeLocalLoadBalancingPtrOutput{})
	pulumi.RegisterOutputType(K0sPodSecurityPolicyOutput{})
	pulumi.RegisterOutputType(K0sPodSecurityPolicyPtrOutput{})
	pulumi.RegisterOutputType(K0sSchedulerOutput{})
	pulumi.RegisterOutputType(K0sSchedulerPtrOutput{})
	pulumi.RegisterOutputType(K0sSpecOutput{})
	pulumi.RegisterOutputType(K0sSpecPtrOutput{})
	pulumi.RegisterOutputType(K0sStorageOutput{})
	pulumi.RegisterOutputType(K0sStoragePtrOutput{})
	pulumi.RegisterOutputType(K0sTelemetryOutput{})
	pulumi.RegisterOutputType(K0sTelemetryPtrOutput{})
	pulumi.RegisterOutputType(K0sWorkerProfileOutput{})
	pulumi.RegisterOutputType(K0sWorkerProfileArrayOutput{})
}