pulumiTypes.go

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

package v1

import (
	"context"
	"reflect"

	corev1 "github.com/pulumi/pulumi-kubernetes/sdk/v3/go/kubernetes/core/v1"
	metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v3/go/kubernetes/meta/v1"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

// Overhead structure represents the resource overhead associated with running a pod.
type Overhead struct {
	// PodFixed represents the fixed resource overhead associated with running a pod.
	PodFixed map[string]string `pulumi:"podFixed"`
}

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

	ToOverheadOutput() OverheadOutput
	ToOverheadOutputWithContext(context.Context) OverheadOutput
}

// Overhead structure represents the resource overhead associated with running a pod.
type OverheadArgs struct {
	// PodFixed represents the fixed resource overhead associated with running a pod.
	PodFixed pulumi.StringMapInput `pulumi:"podFixed"`
}

func (OverheadArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Overhead)(nil)).Elem()
}

func (i OverheadArgs) ToOverheadOutput() OverheadOutput {
	return i.ToOverheadOutputWithContext(context.Background())
}

func (i OverheadArgs) ToOverheadOutputWithContext(ctx context.Context) OverheadOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OverheadOutput)
}

func (i OverheadArgs) ToOverheadPtrOutput() OverheadPtrOutput {
	return i.ToOverheadPtrOutputWithContext(context.Background())
}

func (i OverheadArgs) ToOverheadPtrOutputWithContext(ctx context.Context) OverheadPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OverheadOutput).ToOverheadPtrOutputWithContext(ctx)
}

// OverheadPtrInput is an input type that accepts OverheadArgs, OverheadPtr and OverheadPtrOutput values.
// You can construct a concrete instance of `OverheadPtrInput` via:
//
//          OverheadArgs{...}
//
//  or:
//
//          nil
type OverheadPtrInput interface {
	pulumi.Input

	ToOverheadPtrOutput() OverheadPtrOutput
	ToOverheadPtrOutputWithContext(context.Context) OverheadPtrOutput
}

type overheadPtrType OverheadArgs

func OverheadPtr(v *OverheadArgs) OverheadPtrInput {
	return (*overheadPtrType)(v)
}

func (*overheadPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**Overhead)(nil)).Elem()
}

func (i *overheadPtrType) ToOverheadPtrOutput() OverheadPtrOutput {
	return i.ToOverheadPtrOutputWithContext(context.Background())
}

func (i *overheadPtrType) ToOverheadPtrOutputWithContext(ctx context.Context) OverheadPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OverheadPtrOutput)
}

// Overhead structure represents the resource overhead associated with running a pod.
type OverheadOutput struct{ *pulumi.OutputState }

func (OverheadOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Overhead)(nil)).Elem()
}

func (o OverheadOutput) ToOverheadOutput() OverheadOutput {
	return o
}

func (o OverheadOutput) ToOverheadOutputWithContext(ctx context.Context) OverheadOutput {
	return o
}

func (o OverheadOutput) ToOverheadPtrOutput() OverheadPtrOutput {
	return o.ToOverheadPtrOutputWithContext(context.Background())
}

func (o OverheadOutput) ToOverheadPtrOutputWithContext(ctx context.Context) OverheadPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v Overhead) *Overhead {
		return &v
	}).(OverheadPtrOutput)
}

// PodFixed represents the fixed resource overhead associated with running a pod.
func (o OverheadOutput) PodFixed() pulumi.StringMapOutput {
	return o.ApplyT(func(v Overhead) map[string]string { return v.PodFixed }).(pulumi.StringMapOutput)
}

type OverheadPtrOutput struct{ *pulumi.OutputState }

func (OverheadPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**Overhead)(nil)).Elem()
}

func (o OverheadPtrOutput) ToOverheadPtrOutput() OverheadPtrOutput {
	return o
}

func (o OverheadPtrOutput) ToOverheadPtrOutputWithContext(ctx context.Context) OverheadPtrOutput {
	return o
}

func (o OverheadPtrOutput) Elem() OverheadOutput {
	return o.ApplyT(func(v *Overhead) Overhead {
		if v != nil {
			return *v
		}
		var ret Overhead
		return ret
	}).(OverheadOutput)
}

// PodFixed represents the fixed resource overhead associated with running a pod.
func (o OverheadPtrOutput) PodFixed() pulumi.StringMapOutput {
	return o.ApplyT(func(v *Overhead) map[string]string {
		if v == nil {
			return nil
		}
		return v.PodFixed
	}).(pulumi.StringMapOutput)
}

// Overhead structure represents the resource overhead associated with running a pod.
type OverheadPatch struct {
	// PodFixed represents the fixed resource overhead associated with running a pod.
	PodFixed map[string]string `pulumi:"podFixed"`
}

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

	ToOverheadPatchOutput() OverheadPatchOutput
	ToOverheadPatchOutputWithContext(context.Context) OverheadPatchOutput
}

// Overhead structure represents the resource overhead associated with running a pod.
type OverheadPatchArgs struct {
	// PodFixed represents the fixed resource overhead associated with running a pod.
	PodFixed pulumi.StringMapInput `pulumi:"podFixed"`
}

func (OverheadPatchArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*OverheadPatch)(nil)).Elem()
}

func (i OverheadPatchArgs) ToOverheadPatchOutput() OverheadPatchOutput {
	return i.ToOverheadPatchOutputWithContext(context.Background())
}

func (i OverheadPatchArgs) ToOverheadPatchOutputWithContext(ctx context.Context) OverheadPatchOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OverheadPatchOutput)
}

func (i OverheadPatchArgs) ToOverheadPatchPtrOutput() OverheadPatchPtrOutput {
	return i.ToOverheadPatchPtrOutputWithContext(context.Background())
}

func (i OverheadPatchArgs) ToOverheadPatchPtrOutputWithContext(ctx context.Context) OverheadPatchPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OverheadPatchOutput).ToOverheadPatchPtrOutputWithContext(ctx)
}

// OverheadPatchPtrInput is an input type that accepts OverheadPatchArgs, OverheadPatchPtr and OverheadPatchPtrOutput values.
// You can construct a concrete instance of `OverheadPatchPtrInput` via:
//
//          OverheadPatchArgs{...}
//
//  or:
//
//          nil
type OverheadPatchPtrInput interface {
	pulumi.Input

	ToOverheadPatchPtrOutput() OverheadPatchPtrOutput
	ToOverheadPatchPtrOutputWithContext(context.Context) OverheadPatchPtrOutput
}

type overheadPatchPtrType OverheadPatchArgs

func OverheadPatchPtr(v *OverheadPatchArgs) OverheadPatchPtrInput {
	return (*overheadPatchPtrType)(v)
}

func (*overheadPatchPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**OverheadPatch)(nil)).Elem()
}

func (i *overheadPatchPtrType) ToOverheadPatchPtrOutput() OverheadPatchPtrOutput {
	return i.ToOverheadPatchPtrOutputWithContext(context.Background())
}

func (i *overheadPatchPtrType) ToOverheadPatchPtrOutputWithContext(ctx context.Context) OverheadPatchPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(OverheadPatchPtrOutput)
}

// Overhead structure represents the resource overhead associated with running a pod.
type OverheadPatchOutput struct{ *pulumi.OutputState }

func (OverheadPatchOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*OverheadPatch)(nil)).Elem()
}

func (o OverheadPatchOutput) ToOverheadPatchOutput() OverheadPatchOutput {
	return o
}

func (o OverheadPatchOutput) ToOverheadPatchOutputWithContext(ctx context.Context) OverheadPatchOutput {
	return o
}

func (o OverheadPatchOutput) ToOverheadPatchPtrOutput() OverheadPatchPtrOutput {
	return o.ToOverheadPatchPtrOutputWithContext(context.Background())
}

func (o OverheadPatchOutput) ToOverheadPatchPtrOutputWithContext(ctx context.Context) OverheadPatchPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v OverheadPatch) *OverheadPatch {
		return &v
	}).(OverheadPatchPtrOutput)
}

// PodFixed represents the fixed resource overhead associated with running a pod.
func (o OverheadPatchOutput) PodFixed() pulumi.StringMapOutput {
	return o.ApplyT(func(v OverheadPatch) map[string]string { return v.PodFixed }).(pulumi.StringMapOutput)
}

type OverheadPatchPtrOutput struct{ *pulumi.OutputState }

func (OverheadPatchPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**OverheadPatch)(nil)).Elem()
}

func (o OverheadPatchPtrOutput) ToOverheadPatchPtrOutput() OverheadPatchPtrOutput {
	return o
}

func (o OverheadPatchPtrOutput) ToOverheadPatchPtrOutputWithContext(ctx context.Context) OverheadPatchPtrOutput {
	return o
}

func (o OverheadPatchPtrOutput) Elem() OverheadPatchOutput {
	return o.ApplyT(func(v *OverheadPatch) OverheadPatch {
		if v != nil {
			return *v
		}
		var ret OverheadPatch
		return ret
	}).(OverheadPatchOutput)
}

// PodFixed represents the fixed resource overhead associated with running a pod.
func (o OverheadPatchPtrOutput) PodFixed() pulumi.StringMapOutput {
	return o.ApplyT(func(v *OverheadPatch) map[string]string {
		if v == nil {
			return nil
		}
		return v.PodFixed
	}).(pulumi.StringMapOutput)
}

// RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod.  For more details, see https://kubernetes.io/docs/concepts/containers/runtime-class/
type RuntimeClassType struct {
	// APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	ApiVersion *string `pulumi:"apiVersion"`
	// Handler specifies the underlying runtime and configuration that the CRI implementation will use to handle pods of this class. The possible values are specific to the node & CRI configuration.  It is assumed that all handlers are available on every node, and handlers of the same name are equivalent on every node. For example, a handler called "runc" might specify that the runc OCI runtime (using native Linux containers) will be used to run the containers in a pod. The Handler must be lowercase, conform to the DNS Label (RFC 1123) requirements, and is immutable.
	Handler string `pulumi:"handler"`
	// Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	Kind *string `pulumi:"kind"`
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	Metadata *metav1.ObjectMeta `pulumi:"metadata"`
	// Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. For more details, see
	//  https://kubernetes.io/docs/concepts/scheduling-eviction/pod-overhead/
	Overhead *Overhead `pulumi:"overhead"`
	// Scheduling holds the scheduling constraints to ensure that pods running with this RuntimeClass are scheduled to nodes that support it. If scheduling is nil, this RuntimeClass is assumed to be supported by all nodes.
	Scheduling *Scheduling `pulumi:"scheduling"`
}

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

	ToRuntimeClassTypeOutput() RuntimeClassTypeOutput
	ToRuntimeClassTypeOutputWithContext(context.Context) RuntimeClassTypeOutput
}

// RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod.  For more details, see https://kubernetes.io/docs/concepts/containers/runtime-class/
type RuntimeClassTypeArgs struct {
	// APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	ApiVersion pulumi.StringPtrInput `pulumi:"apiVersion"`
	// Handler specifies the underlying runtime and configuration that the CRI implementation will use to handle pods of this class. The possible values are specific to the node & CRI configuration.  It is assumed that all handlers are available on every node, and handlers of the same name are equivalent on every node. For example, a handler called "runc" might specify that the runc OCI runtime (using native Linux containers) will be used to run the containers in a pod. The Handler must be lowercase, conform to the DNS Label (RFC 1123) requirements, and is immutable.
	Handler pulumi.StringInput `pulumi:"handler"`
	// Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	Kind pulumi.StringPtrInput `pulumi:"kind"`
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	Metadata metav1.ObjectMetaPtrInput `pulumi:"metadata"`
	// Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. For more details, see
	//  https://kubernetes.io/docs/concepts/scheduling-eviction/pod-overhead/
	Overhead OverheadPtrInput `pulumi:"overhead"`
	// Scheduling holds the scheduling constraints to ensure that pods running with this RuntimeClass are scheduled to nodes that support it. If scheduling is nil, this RuntimeClass is assumed to be supported by all nodes.
	Scheduling SchedulingPtrInput `pulumi:"scheduling"`
}

func (RuntimeClassTypeArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RuntimeClassType)(nil)).Elem()
}

func (i RuntimeClassTypeArgs) ToRuntimeClassTypeOutput() RuntimeClassTypeOutput {
	return i.ToRuntimeClassTypeOutputWithContext(context.Background())
}

func (i RuntimeClassTypeArgs) ToRuntimeClassTypeOutputWithContext(ctx context.Context) RuntimeClassTypeOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassTypeOutput)
}

// RuntimeClassTypeArrayInput is an input type that accepts RuntimeClassTypeArray and RuntimeClassTypeArrayOutput values.
// You can construct a concrete instance of `RuntimeClassTypeArrayInput` via:
//
//          RuntimeClassTypeArray{ RuntimeClassTypeArgs{...} }
type RuntimeClassTypeArrayInput interface {
	pulumi.Input

	ToRuntimeClassTypeArrayOutput() RuntimeClassTypeArrayOutput
	ToRuntimeClassTypeArrayOutputWithContext(context.Context) RuntimeClassTypeArrayOutput
}

type RuntimeClassTypeArray []RuntimeClassTypeInput

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

func (i RuntimeClassTypeArray) ToRuntimeClassTypeArrayOutput() RuntimeClassTypeArrayOutput {
	return i.ToRuntimeClassTypeArrayOutputWithContext(context.Background())
}

func (i RuntimeClassTypeArray) ToRuntimeClassTypeArrayOutputWithContext(ctx context.Context) RuntimeClassTypeArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassTypeArrayOutput)
}

// RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod.  For more details, see https://kubernetes.io/docs/concepts/containers/runtime-class/
type RuntimeClassTypeOutput struct{ *pulumi.OutputState }

func (RuntimeClassTypeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RuntimeClassType)(nil)).Elem()
}

func (o RuntimeClassTypeOutput) ToRuntimeClassTypeOutput() RuntimeClassTypeOutput {
	return o
}

func (o RuntimeClassTypeOutput) ToRuntimeClassTypeOutputWithContext(ctx context.Context) RuntimeClassTypeOutput {
	return o
}

// APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
func (o RuntimeClassTypeOutput) ApiVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RuntimeClassType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput)
}

// Handler specifies the underlying runtime and configuration that the CRI implementation will use to handle pods of this class. The possible values are specific to the node & CRI configuration.  It is assumed that all handlers are available on every node, and handlers of the same name are equivalent on every node. For example, a handler called "runc" might specify that the runc OCI runtime (using native Linux containers) will be used to run the containers in a pod. The Handler must be lowercase, conform to the DNS Label (RFC 1123) requirements, and is immutable.
func (o RuntimeClassTypeOutput) Handler() pulumi.StringOutput {
	return o.ApplyT(func(v RuntimeClassType) string { return v.Handler }).(pulumi.StringOutput)
}

// Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
func (o RuntimeClassTypeOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RuntimeClassType) *string { return v.Kind }).(pulumi.StringPtrOutput)
}

// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
func (o RuntimeClassTypeOutput) Metadata() metav1.ObjectMetaPtrOutput {
	return o.ApplyT(func(v RuntimeClassType) *metav1.ObjectMeta { return v.Metadata }).(metav1.ObjectMetaPtrOutput)
}

// Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. For more details, see
//  https://kubernetes.io/docs/concepts/scheduling-eviction/pod-overhead/
func (o RuntimeClassTypeOutput) Overhead() OverheadPtrOutput {
	return o.ApplyT(func(v RuntimeClassType) *Overhead { return v.Overhead }).(OverheadPtrOutput)
}

// Scheduling holds the scheduling constraints to ensure that pods running with this RuntimeClass are scheduled to nodes that support it. If scheduling is nil, this RuntimeClass is assumed to be supported by all nodes.
func (o RuntimeClassTypeOutput) Scheduling() SchedulingPtrOutput {
	return o.ApplyT(func(v RuntimeClassType) *Scheduling { return v.Scheduling }).(SchedulingPtrOutput)
}

type RuntimeClassTypeArrayOutput struct{ *pulumi.OutputState }

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

func (o RuntimeClassTypeArrayOutput) ToRuntimeClassTypeArrayOutput() RuntimeClassTypeArrayOutput {
	return o
}

func (o RuntimeClassTypeArrayOutput) ToRuntimeClassTypeArrayOutputWithContext(ctx context.Context) RuntimeClassTypeArrayOutput {
	return o
}

func (o RuntimeClassTypeArrayOutput) Index(i pulumi.IntInput) RuntimeClassTypeOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) RuntimeClassType {
		return vs[0].([]RuntimeClassType)[vs[1].(int)]
	}).(RuntimeClassTypeOutput)
}

// RuntimeClassList is a list of RuntimeClass objects.
type RuntimeClassListType struct {
	// APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	ApiVersion *string `pulumi:"apiVersion"`
	// Items is a list of schema objects.
	Items []RuntimeClassType `pulumi:"items"`
	// Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	Kind *string `pulumi:"kind"`
	// Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	Metadata *metav1.ListMeta `pulumi:"metadata"`
}

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

	ToRuntimeClassListTypeOutput() RuntimeClassListTypeOutput
	ToRuntimeClassListTypeOutputWithContext(context.Context) RuntimeClassListTypeOutput
}

// RuntimeClassList is a list of RuntimeClass objects.
type RuntimeClassListTypeArgs struct {
	// APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	ApiVersion pulumi.StringPtrInput `pulumi:"apiVersion"`
	// Items is a list of schema objects.
	Items RuntimeClassTypeArrayInput `pulumi:"items"`
	// Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	Kind pulumi.StringPtrInput `pulumi:"kind"`
	// Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	Metadata metav1.ListMetaPtrInput `pulumi:"metadata"`
}

func (RuntimeClassListTypeArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RuntimeClassListType)(nil)).Elem()
}

func (i RuntimeClassListTypeArgs) ToRuntimeClassListTypeOutput() RuntimeClassListTypeOutput {
	return i.ToRuntimeClassListTypeOutputWithContext(context.Background())
}

func (i RuntimeClassListTypeArgs) ToRuntimeClassListTypeOutputWithContext(ctx context.Context) RuntimeClassListTypeOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassListTypeOutput)
}

// RuntimeClassList is a list of RuntimeClass objects.
type RuntimeClassListTypeOutput struct{ *pulumi.OutputState }

func (RuntimeClassListTypeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RuntimeClassListType)(nil)).Elem()
}

func (o RuntimeClassListTypeOutput) ToRuntimeClassListTypeOutput() RuntimeClassListTypeOutput {
	return o
}

func (o RuntimeClassListTypeOutput) ToRuntimeClassListTypeOutputWithContext(ctx context.Context) RuntimeClassListTypeOutput {
	return o
}

// APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
func (o RuntimeClassListTypeOutput) ApiVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RuntimeClassListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput)
}

// Items is a list of schema objects.
func (o RuntimeClassListTypeOutput) Items() RuntimeClassTypeArrayOutput {
	return o.ApplyT(func(v RuntimeClassListType) []RuntimeClassType { return v.Items }).(RuntimeClassTypeArrayOutput)
}

// Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
func (o RuntimeClassListTypeOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RuntimeClassListType) *string { return v.Kind }).(pulumi.StringPtrOutput)
}

// Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
func (o RuntimeClassListTypeOutput) Metadata() metav1.ListMetaPtrOutput {
	return o.ApplyT(func(v RuntimeClassListType) *metav1.ListMeta { return v.Metadata }).(metav1.ListMetaPtrOutput)
}

// RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod.  For more details, see https://kubernetes.io/docs/concepts/containers/runtime-class/
type RuntimeClassPatchType struct {
	// APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	ApiVersion *string `pulumi:"apiVersion"`
	// Handler specifies the underlying runtime and configuration that the CRI implementation will use to handle pods of this class. The possible values are specific to the node & CRI configuration.  It is assumed that all handlers are available on every node, and handlers of the same name are equivalent on every node. For example, a handler called "runc" might specify that the runc OCI runtime (using native Linux containers) will be used to run the containers in a pod. The Handler must be lowercase, conform to the DNS Label (RFC 1123) requirements, and is immutable.
	Handler *string `pulumi:"handler"`
	// Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	Kind *string `pulumi:"kind"`
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	Metadata *metav1.ObjectMetaPatch `pulumi:"metadata"`
	// Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. For more details, see
	//  https://kubernetes.io/docs/concepts/scheduling-eviction/pod-overhead/
	Overhead *OverheadPatch `pulumi:"overhead"`
	// Scheduling holds the scheduling constraints to ensure that pods running with this RuntimeClass are scheduled to nodes that support it. If scheduling is nil, this RuntimeClass is assumed to be supported by all nodes.
	Scheduling *SchedulingPatch `pulumi:"scheduling"`
}

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

	ToRuntimeClassPatchTypeOutput() RuntimeClassPatchTypeOutput
	ToRuntimeClassPatchTypeOutputWithContext(context.Context) RuntimeClassPatchTypeOutput
}

// RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod.  For more details, see https://kubernetes.io/docs/concepts/containers/runtime-class/
type RuntimeClassPatchTypeArgs struct {
	// APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
	ApiVersion pulumi.StringPtrInput `pulumi:"apiVersion"`
	// Handler specifies the underlying runtime and configuration that the CRI implementation will use to handle pods of this class. The possible values are specific to the node & CRI configuration.  It is assumed that all handlers are available on every node, and handlers of the same name are equivalent on every node. For example, a handler called "runc" might specify that the runc OCI runtime (using native Linux containers) will be used to run the containers in a pod. The Handler must be lowercase, conform to the DNS Label (RFC 1123) requirements, and is immutable.
	Handler pulumi.StringPtrInput `pulumi:"handler"`
	// Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	Kind pulumi.StringPtrInput `pulumi:"kind"`
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	Metadata metav1.ObjectMetaPatchPtrInput `pulumi:"metadata"`
	// Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. For more details, see
	//  https://kubernetes.io/docs/concepts/scheduling-eviction/pod-overhead/
	Overhead OverheadPatchPtrInput `pulumi:"overhead"`
	// Scheduling holds the scheduling constraints to ensure that pods running with this RuntimeClass are scheduled to nodes that support it. If scheduling is nil, this RuntimeClass is assumed to be supported by all nodes.
	Scheduling SchedulingPatchPtrInput `pulumi:"scheduling"`
}

func (RuntimeClassPatchTypeArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*RuntimeClassPatchType)(nil)).Elem()
}

func (i RuntimeClassPatchTypeArgs) ToRuntimeClassPatchTypeOutput() RuntimeClassPatchTypeOutput {
	return i.ToRuntimeClassPatchTypeOutputWithContext(context.Background())
}

func (i RuntimeClassPatchTypeArgs) ToRuntimeClassPatchTypeOutputWithContext(ctx context.Context) RuntimeClassPatchTypeOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RuntimeClassPatchTypeOutput)
}

// RuntimeClass defines a class of container runtime supported in the cluster. The RuntimeClass is used to determine which container runtime is used to run all containers in a pod. RuntimeClasses are manually defined by a user or cluster provisioner, and referenced in the PodSpec. The Kubelet is responsible for resolving the RuntimeClassName reference before running the pod.  For more details, see https://kubernetes.io/docs/concepts/containers/runtime-class/
type RuntimeClassPatchTypeOutput struct{ *pulumi.OutputState }

func (RuntimeClassPatchTypeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RuntimeClassPatchType)(nil)).Elem()
}

func (o RuntimeClassPatchTypeOutput) ToRuntimeClassPatchTypeOutput() RuntimeClassPatchTypeOutput {
	return o
}

func (o RuntimeClassPatchTypeOutput) ToRuntimeClassPatchTypeOutputWithContext(ctx context.Context) RuntimeClassPatchTypeOutput {
	return o
}

// APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
func (o RuntimeClassPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RuntimeClassPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput)
}

// Handler specifies the underlying runtime and configuration that the CRI implementation will use to handle pods of this class. The possible values are specific to the node & CRI configuration.  It is assumed that all handlers are available on every node, and handlers of the same name are equivalent on every node. For example, a handler called "runc" might specify that the runc OCI runtime (using native Linux containers) will be used to run the containers in a pod. The Handler must be lowercase, conform to the DNS Label (RFC 1123) requirements, and is immutable.
func (o RuntimeClassPatchTypeOutput) Handler() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RuntimeClassPatchType) *string { return v.Handler }).(pulumi.StringPtrOutput)
}

// Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
func (o RuntimeClassPatchTypeOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v RuntimeClassPatchType) *string { return v.Kind }).(pulumi.StringPtrOutput)
}

// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
func (o RuntimeClassPatchTypeOutput) Metadata() metav1.ObjectMetaPatchPtrOutput {
	return o.ApplyT(func(v RuntimeClassPatchType) *metav1.ObjectMetaPatch { return v.Metadata }).(metav1.ObjectMetaPatchPtrOutput)
}

// Overhead represents the resource overhead associated with running a pod for a given RuntimeClass. For more details, see
//  https://kubernetes.io/docs/concepts/scheduling-eviction/pod-overhead/
func (o RuntimeClassPatchTypeOutput) Overhead() OverheadPatchPtrOutput {
	return o.ApplyT(func(v RuntimeClassPatchType) *OverheadPatch { return v.Overhead }).(OverheadPatchPtrOutput)
}

// Scheduling holds the scheduling constraints to ensure that pods running with this RuntimeClass are scheduled to nodes that support it. If scheduling is nil, this RuntimeClass is assumed to be supported by all nodes.
func (o RuntimeClassPatchTypeOutput) Scheduling() SchedulingPatchPtrOutput {
	return o.ApplyT(func(v RuntimeClassPatchType) *SchedulingPatch { return v.Scheduling }).(SchedulingPatchPtrOutput)
}

// Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass.
type Scheduling struct {
	// nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission.
	NodeSelector map[string]string `pulumi:"nodeSelector"`
	// tolerations are appended (excluding duplicates) to pods running with this RuntimeClass during admission, effectively unioning the set of nodes tolerated by the pod and the RuntimeClass.
	Tolerations []corev1.Toleration `pulumi:"tolerations"`
}

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

	ToSchedulingOutput() SchedulingOutput
	ToSchedulingOutputWithContext(context.Context) SchedulingOutput
}

// Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass.
type SchedulingArgs struct {
	// nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission.
	NodeSelector pulumi.StringMapInput `pulumi:"nodeSelector"`
	// tolerations are appended (excluding duplicates) to pods running with this RuntimeClass during admission, effectively unioning the set of nodes tolerated by the pod and the RuntimeClass.
	Tolerations corev1.TolerationArrayInput `pulumi:"tolerations"`
}

func (SchedulingArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*Scheduling)(nil)).Elem()
}

func (i SchedulingArgs) ToSchedulingOutput() SchedulingOutput {
	return i.ToSchedulingOutputWithContext(context.Background())
}

func (i SchedulingArgs) ToSchedulingOutputWithContext(ctx context.Context) SchedulingOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SchedulingOutput)
}

func (i SchedulingArgs) ToSchedulingPtrOutput() SchedulingPtrOutput {
	return i.ToSchedulingPtrOutputWithContext(context.Background())
}

func (i SchedulingArgs) ToSchedulingPtrOutputWithContext(ctx context.Context) SchedulingPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SchedulingOutput).ToSchedulingPtrOutputWithContext(ctx)
}

// SchedulingPtrInput is an input type that accepts SchedulingArgs, SchedulingPtr and SchedulingPtrOutput values.
// You can construct a concrete instance of `SchedulingPtrInput` via:
//
//          SchedulingArgs{...}
//
//  or:
//
//          nil
type SchedulingPtrInput interface {
	pulumi.Input

	ToSchedulingPtrOutput() SchedulingPtrOutput
	ToSchedulingPtrOutputWithContext(context.Context) SchedulingPtrOutput
}

type schedulingPtrType SchedulingArgs

func SchedulingPtr(v *SchedulingArgs) SchedulingPtrInput {
	return (*schedulingPtrType)(v)
}

func (*schedulingPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**Scheduling)(nil)).Elem()
}

func (i *schedulingPtrType) ToSchedulingPtrOutput() SchedulingPtrOutput {
	return i.ToSchedulingPtrOutputWithContext(context.Background())
}

func (i *schedulingPtrType) ToSchedulingPtrOutputWithContext(ctx context.Context) SchedulingPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SchedulingPtrOutput)
}

// Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass.
type SchedulingOutput struct{ *pulumi.OutputState }

func (SchedulingOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*Scheduling)(nil)).Elem()
}

func (o SchedulingOutput) ToSchedulingOutput() SchedulingOutput {
	return o
}

func (o SchedulingOutput) ToSchedulingOutputWithContext(ctx context.Context) SchedulingOutput {
	return o
}

func (o SchedulingOutput) ToSchedulingPtrOutput() SchedulingPtrOutput {
	return o.ToSchedulingPtrOutputWithContext(context.Background())
}

func (o SchedulingOutput) ToSchedulingPtrOutputWithContext(ctx context.Context) SchedulingPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v Scheduling) *Scheduling {
		return &v
	}).(SchedulingPtrOutput)
}

// nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission.
func (o SchedulingOutput) NodeSelector() pulumi.StringMapOutput {
	return o.ApplyT(func(v Scheduling) map[string]string { return v.NodeSelector }).(pulumi.StringMapOutput)
}

// tolerations are appended (excluding duplicates) to pods running with this RuntimeClass during admission, effectively unioning the set of nodes tolerated by the pod and the RuntimeClass.
func (o SchedulingOutput) Tolerations() corev1.TolerationArrayOutput {
	return o.ApplyT(func(v Scheduling) []corev1.Toleration { return v.Tolerations }).(corev1.TolerationArrayOutput)
}

type SchedulingPtrOutput struct{ *pulumi.OutputState }

func (SchedulingPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**Scheduling)(nil)).Elem()
}

func (o SchedulingPtrOutput) ToSchedulingPtrOutput() SchedulingPtrOutput {
	return o
}

func (o SchedulingPtrOutput) ToSchedulingPtrOutputWithContext(ctx context.Context) SchedulingPtrOutput {
	return o
}

func (o SchedulingPtrOutput) Elem() SchedulingOutput {
	return o.ApplyT(func(v *Scheduling) Scheduling {
		if v != nil {
			return *v
		}
		var ret Scheduling
		return ret
	}).(SchedulingOutput)
}

// nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission.
func (o SchedulingPtrOutput) NodeSelector() pulumi.StringMapOutput {
	return o.ApplyT(func(v *Scheduling) map[string]string {
		if v == nil {
			return nil
		}
		return v.NodeSelector
	}).(pulumi.StringMapOutput)
}

// tolerations are appended (excluding duplicates) to pods running with this RuntimeClass during admission, effectively unioning the set of nodes tolerated by the pod and the RuntimeClass.
func (o SchedulingPtrOutput) Tolerations() corev1.TolerationArrayOutput {
	return o.ApplyT(func(v *Scheduling) []corev1.Toleration {
		if v == nil {
			return nil
		}
		return v.Tolerations
	}).(corev1.TolerationArrayOutput)
}

// Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass.
type SchedulingPatch struct {
	// nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission.
	NodeSelector map[string]string `pulumi:"nodeSelector"`
	// tolerations are appended (excluding duplicates) to pods running with this RuntimeClass during admission, effectively unioning the set of nodes tolerated by the pod and the RuntimeClass.
	Tolerations []corev1.TolerationPatch `pulumi:"tolerations"`
}

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

	ToSchedulingPatchOutput() SchedulingPatchOutput
	ToSchedulingPatchOutputWithContext(context.Context) SchedulingPatchOutput
}

// Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass.
type SchedulingPatchArgs struct {
	// nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission.
	NodeSelector pulumi.StringMapInput `pulumi:"nodeSelector"`
	// tolerations are appended (excluding duplicates) to pods running with this RuntimeClass during admission, effectively unioning the set of nodes tolerated by the pod and the RuntimeClass.
	Tolerations corev1.TolerationPatchArrayInput `pulumi:"tolerations"`
}

func (SchedulingPatchArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*SchedulingPatch)(nil)).Elem()
}

func (i SchedulingPatchArgs) ToSchedulingPatchOutput() SchedulingPatchOutput {
	return i.ToSchedulingPatchOutputWithContext(context.Background())
}

func (i SchedulingPatchArgs) ToSchedulingPatchOutputWithContext(ctx context.Context) SchedulingPatchOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SchedulingPatchOutput)
}

func (i SchedulingPatchArgs) ToSchedulingPatchPtrOutput() SchedulingPatchPtrOutput {
	return i.ToSchedulingPatchPtrOutputWithContext(context.Background())
}

func (i SchedulingPatchArgs) ToSchedulingPatchPtrOutputWithContext(ctx context.Context) SchedulingPatchPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SchedulingPatchOutput).ToSchedulingPatchPtrOutputWithContext(ctx)
}

// SchedulingPatchPtrInput is an input type that accepts SchedulingPatchArgs, SchedulingPatchPtr and SchedulingPatchPtrOutput values.
// You can construct a concrete instance of `SchedulingPatchPtrInput` via:
//
//          SchedulingPatchArgs{...}
//
//  or:
//
//          nil
type SchedulingPatchPtrInput interface {
	pulumi.Input

	ToSchedulingPatchPtrOutput() SchedulingPatchPtrOutput
	ToSchedulingPatchPtrOutputWithContext(context.Context) SchedulingPatchPtrOutput
}

type schedulingPatchPtrType SchedulingPatchArgs

func SchedulingPatchPtr(v *SchedulingPatchArgs) SchedulingPatchPtrInput {
	return (*schedulingPatchPtrType)(v)
}

func (*schedulingPatchPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**SchedulingPatch)(nil)).Elem()
}

func (i *schedulingPatchPtrType) ToSchedulingPatchPtrOutput() SchedulingPatchPtrOutput {
	return i.ToSchedulingPatchPtrOutputWithContext(context.Background())
}

func (i *schedulingPatchPtrType) ToSchedulingPatchPtrOutputWithContext(ctx context.Context) SchedulingPatchPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(SchedulingPatchPtrOutput)
}

// Scheduling specifies the scheduling constraints for nodes supporting a RuntimeClass.
type SchedulingPatchOutput struct{ *pulumi.OutputState }

func (SchedulingPatchOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SchedulingPatch)(nil)).Elem()
}

func (o SchedulingPatchOutput) ToSchedulingPatchOutput() SchedulingPatchOutput {
	return o
}

func (o SchedulingPatchOutput) ToSchedulingPatchOutputWithContext(ctx context.Context) SchedulingPatchOutput {
	return o
}

func (o SchedulingPatchOutput) ToSchedulingPatchPtrOutput() SchedulingPatchPtrOutput {
	return o.ToSchedulingPatchPtrOutputWithContext(context.Background())
}

func (o SchedulingPatchOutput) ToSchedulingPatchPtrOutputWithContext(ctx context.Context) SchedulingPatchPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v SchedulingPatch) *SchedulingPatch {
		return &v
	}).(SchedulingPatchPtrOutput)
}

// nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission.
func (o SchedulingPatchOutput) NodeSelector() pulumi.StringMapOutput {
	return o.ApplyT(func(v SchedulingPatch) map[string]string { return v.NodeSelector }).(pulumi.StringMapOutput)
}

// tolerations are appended (excluding duplicates) to pods running with this RuntimeClass during admission, effectively unioning the set of nodes tolerated by the pod and the RuntimeClass.
func (o SchedulingPatchOutput) Tolerations() corev1.TolerationPatchArrayOutput {
	return o.ApplyT(func(v SchedulingPatch) []corev1.TolerationPatch { return v.Tolerations }).(corev1.TolerationPatchArrayOutput)
}

type SchedulingPatchPtrOutput struct{ *pulumi.OutputState }

func (SchedulingPatchPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**SchedulingPatch)(nil)).Elem()
}

func (o SchedulingPatchPtrOutput) ToSchedulingPatchPtrOutput() SchedulingPatchPtrOutput {
	return o
}

func (o SchedulingPatchPtrOutput) ToSchedulingPatchPtrOutputWithContext(ctx context.Context) SchedulingPatchPtrOutput {
	return o
}

func (o SchedulingPatchPtrOutput) Elem() SchedulingPatchOutput {
	return o.ApplyT(func(v *SchedulingPatch) SchedulingPatch {
		if v != nil {
			return *v
		}
		var ret SchedulingPatch
		return ret
	}).(SchedulingPatchOutput)
}

// nodeSelector lists labels that must be present on nodes that support this RuntimeClass. Pods using this RuntimeClass can only be scheduled to a node matched by this selector. The RuntimeClass nodeSelector is merged with a pod's existing nodeSelector. Any conflicts will cause the pod to be rejected in admission.
func (o SchedulingPatchPtrOutput) NodeSelector() pulumi.StringMapOutput {
	return o.ApplyT(func(v *SchedulingPatch) map[string]string {
		if v == nil {
			return nil
		}
		return v.NodeSelector
	}).(pulumi.StringMapOutput)
}

// tolerations are appended (excluding duplicates) to pods running with this RuntimeClass during admission, effectively unioning the set of nodes tolerated by the pod and the RuntimeClass.
func (o SchedulingPatchPtrOutput) Tolerations() corev1.TolerationPatchArrayOutput {
	return o.ApplyT(func(v *SchedulingPatch) []corev1.TolerationPatch {
		if v == nil {
			return nil
		}
		return v.Tolerations
	}).(corev1.TolerationPatchArrayOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*OverheadInput)(nil)).Elem(), OverheadArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*OverheadPtrInput)(nil)).Elem(), OverheadArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*OverheadPatchInput)(nil)).Elem(), OverheadPatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*OverheadPatchPtrInput)(nil)).Elem(), OverheadPatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RuntimeClassTypeInput)(nil)).Elem(), RuntimeClassTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RuntimeClassTypeArrayInput)(nil)).Elem(), RuntimeClassTypeArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*RuntimeClassListTypeInput)(nil)).Elem(), RuntimeClassListTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*RuntimeClassPatchTypeInput)(nil)).Elem(), RuntimeClassPatchTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SchedulingInput)(nil)).Elem(), SchedulingArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SchedulingPtrInput)(nil)).Elem(), SchedulingArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SchedulingPatchInput)(nil)).Elem(), SchedulingPatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*SchedulingPatchPtrInput)(nil)).Elem(), SchedulingPatchArgs{})
	pulumi.RegisterOutputType(OverheadOutput{})
	pulumi.RegisterOutputType(OverheadPtrOutput{})
	pulumi.RegisterOutputType(OverheadPatchOutput{})
	pulumi.RegisterOutputType(OverheadPatchPtrOutput{})
	pulumi.RegisterOutputType(RuntimeClassTypeOutput{})
	pulumi.RegisterOutputType(RuntimeClassTypeArrayOutput{})
	pulumi.RegisterOutputType(RuntimeClassListTypeOutput{})
	pulumi.RegisterOutputType(RuntimeClassPatchTypeOutput{})
	pulumi.RegisterOutputType(SchedulingOutput{})
	pulumi.RegisterOutputType(SchedulingPtrOutput{})
	pulumi.RegisterOutputType(SchedulingPatchOutput{})
	pulumi.RegisterOutputType(SchedulingPatchPtrOutput{})
}