text:
ClaimStatusOutput) ToResourceClaimStatusOutputWithContext(ctx context.Context) ResourceClaimStatusOutput {
	return o
}

func (o ResourceClaimStatusOutput) ToResourceClaimStatusPtrOutput() ResourceClaimStatusPtrOutput {
	return o.ToResourceClaimStatusPtrOutputWithContext(context.Background())
}

func (o ResourceClaimStatusOutput) ToResourceClaimStatusPtrOutputWithContext(ctx context.Context) ResourceClaimStatusPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResourceClaimStatus) *ResourceClaimStatus {
		return &v
	}).(ResourceClaimStatusPtrOutput)
}

// Allocation is set by the resource driver once a resource or set of resources has been allocated successfully. If this is not specified, the resources have not been allocated yet.
func (o ResourceClaimStatusOutput) Allocation() AllocationResultPtrOutput {
	return o.ApplyT(func(v ResourceClaimStatus) *AllocationResult { return v.Allocation }).(AllocationResultPtrOutput)
}

// DeallocationRequested indicates that a ResourceClaim is to be deallocated.
//
// The driver then must deallocate this claim and reset the field together with clearing the Allocation field.
//
// While DeallocationRequested is set, no new consumers may be added to ReservedFor.
func (o ResourceClaimStatusOutput) DeallocationRequested() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ResourceClaimStatus) *bool { return v.DeallocationRequested }).(pulumi.BoolPtrOutput)
}

// DriverName is a copy of the driver name from the ResourceClass at the time when allocation started.
func (o ResourceClaimStatusOutput) DriverName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClaimStatus) *string { return v.DriverName }).(pulumi.StringPtrOutput)
}

// ReservedFor indicates which entities are currently allowed to use the claim. A Pod which references a ResourceClaim which is not reserved for that Pod will not be started.
//
// There can be at most 32 such reservations. This may get increased in the future, but not reduced.
func (o ResourceClaimStatusOutput) ReservedFor() ResourceClaimConsumerReferenceArrayOutput {
	return o.ApplyT(func(v ResourceClaimStatus) []ResourceClaimConsumerReference { return v.ReservedFor }).(ResourceClaimConsumerReferenceArrayOutput)
}

type ResourceClaimStatusPtrOutput struct{ *pulumi.OutputState }

func (ResourceClaimStatusPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceClaimStatus)(nil)).Elem()
}

func (o ResourceClaimStatusPtrOutput) ToResourceClaimStatusPtrOutput() ResourceClaimStatusPtrOutput {
	return o
}

func (o ResourceClaimStatusPtrOutput) ToResourceClaimStatusPtrOutputWithContext(ctx context.Context) ResourceClaimStatusPtrOutput {
	return o
}

func (o ResourceClaimStatusPtrOutput) Elem() ResourceClaimStatusOutput {
	return o.ApplyT(func(v *ResourceClaimStatus) ResourceClaimStatus {
		if v != nil {
			return *v
		}
		var ret ResourceClaimStatus
		return ret
	}).(ResourceClaimStatusOutput)
}

// Allocation is set by the resource driver once a resource or set of resources has been allocated successfully. If this is not specified, the resources have not been allocated yet.
func (o ResourceClaimStatusPtrOutput) Allocation() AllocationResultPtrOutput {
	return o.ApplyT(func(v *ResourceClaimStatus) *AllocationResult {
		if v == nil {
			return nil
		}
		return v.Allocation
	}).(AllocationResultPtrOutput)
}

// DeallocationRequested indicates that a ResourceClaim is to be deallocated.
//
// The driver then must deallocate this claim and reset the field together with clearing the Allocation field.
//
// While DeallocationRequested is set, no new consumers may be added to ReservedFor.
func (o ResourceClaimStatusPtrOutput) DeallocationRequested() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ResourceClaimStatus) *bool {
		if v == nil {
			return nil
		}
		return v.DeallocationRequested
	}).(pulumi.BoolPtrOutput)
}

// DriverName is a copy of the driver name from the ResourceClass at the time when allocation started.
func (o ResourceClaimStatusPtrOutput) DriverName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceClaimStatus) *string {
		if v == nil {
			return nil
		}
		return v.DriverName
	}).(pulumi.StringPtrOutput)
}

// ReservedFor indicates which entities are currently allowed to use the claim. A Pod which references a ResourceClaim which is not reserved for that Pod will not be started.
//
// There can be at most 32 such reservations. This may get increased in the future, but not reduced.
func (o ResourceClaimStatusPtrOutput) ReservedFor() ResourceClaimConsumerReferenceArrayOutput {
	return o.ApplyT(func(v *ResourceClaimStatus) []ResourceClaimConsumerReference {
		if v == nil {
			return nil
		}
		return v.ReservedFor
	}).(ResourceClaimConsumerReferenceArrayOutput)
}

// ResourceClaimStatus tracks whether the resource has been allocated and what the resulting attributes are.
type ResourceClaimStatusPatch struct {
	// Allocation is set by the resource driver once a resource or set of resources has been allocated successfully. If this is not specified, the resources have not been allocated yet.
	Allocation *AllocationResultPatch `pulumi:"allocation"`
	// DeallocationRequested indicates that a ResourceClaim is to be deallocated.
	//
	// The driver then must deallocate this claim and reset the field together with clearing the Allocation field.
	//
	// While DeallocationRequested is set, no new consumers may be added to ReservedFor.
	DeallocationRequested *bool `pulumi:"deallocationRequested"`
	// DriverName is a copy of the driver name from the ResourceClass at the time when allocation started.
	DriverName *string `pulumi:"driverName"`
	// ReservedFor indicates which entities are currently allowed to use the claim. A Pod which references a ResourceClaim which is not reserved for that Pod will not be started.
	//
	// There can be at most 32 such reservations. This may get increased in the future, but not reduced.
	ReservedFor []ResourceClaimConsumerReferencePatch `pulumi:"reservedFor"`
}

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

	ToResourceClaimStatusPatchOutput() ResourceClaimStatusPatchOutput
	ToResourceClaimStatusPatchOutputWithContext(context.Context) ResourceClaimStatusPatchOutput
}

// ResourceClaimStatus tracks whether the resource has been allocated and what the resulting attributes are.
type ResourceClaimStatusPatchArgs struct {
	// Allocation is set by the resource driver once a resource or set of resources has been allocated successfully. If this is not specified, the resources have not been allocated yet.
	Allocation AllocationResultPatchPtrInput `pulumi:"allocation"`
	// DeallocationRequested indicates that a ResourceClaim is to be deallocated.
	//
	// The driver then must deallocate this claim and reset the field together with clearing the Allocation field.
	//
	// While DeallocationRequested is set, no new consumers may be added to ReservedFor.
	DeallocationRequested pulumi.BoolPtrInput `pulumi:"deallocationRequested"`
	// DriverName is a copy of the driver name from the ResourceClass at the time when allocation started.
	DriverName pulumi.StringPtrInput `pulumi:"driverName"`
	// ReservedFor indicates which entities are currently allowed to use the claim. A Pod which references a ResourceClaim which is not reserved for that Pod will not be started.
	//
	// There can be at most 32 such reservations. This may get increased in the future, but not reduced.
	ReservedFor ResourceClaimConsumerReferencePatchArrayInput `pulumi:"reservedFor"`
}

func (ResourceClaimStatusPatchArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClaimStatusPatch)(nil)).Elem()
}

func (i ResourceClaimStatusPatchArgs) ToResourceClaimStatusPatchOutput() ResourceClaimStatusPatchOutput {
	return i.ToResourceClaimStatusPatchOutputWithContext(context.Background())
}

func (i ResourceClaimStatusPatchArgs) ToResourceClaimStatusPatchOutputWithContext(ctx context.Context) ResourceClaimStatusPatchOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimStatusPatchOutput)
}

func (i ResourceClaimStatusPatchArgs) ToResourceClaimStatusPatchPtrOutput() ResourceClaimStatusPatchPtrOutput {
	return i.ToResourceClaimStatusPatchPtrOutputWithContext(context.Background())
}

func (i ResourceClaimStatusPatchArgs) ToResourceClaimStatusPatchPtrOutputWithContext(ctx context.Context) ResourceClaimStatusPatchPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimStatusPatchOutput).ToResourceClaimStatusPatchPtrOutputWithContext(ctx)
}

// ResourceClaimStatusPatchPtrInput is an input type that accepts ResourceClaimStatusPatchArgs, ResourceClaimStatusPatchPtr and ResourceClaimStatusPatchPtrOutput values.
// You can construct a concrete instance of `ResourceClaimStatusPatchPtrInput` via:
//
//	        ResourceClaimStatusPatchArgs{...}
//
//	or:
//
//	        nil
type ResourceClaimStatusPatchPtrInput interface {
	pulumi.Input

	ToResourceClaimStatusPatchPtrOutput() ResourceClaimStatusPatchPtrOutput
	ToResourceClaimStatusPatchPtrOutputWithContext(context.Context) ResourceClaimStatusPatchPtrOutput
}

type resourceClaimStatusPatchPtrType ResourceClaimStatusPatchArgs

func ResourceClaimStatusPatchPtr(v *ResourceClaimStatusPatchArgs) ResourceClaimStatusPatchPtrInput {
	return (*resourceClaimStatusPatchPtrType)(v)
}

func (*resourceClaimStatusPatchPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceClaimStatusPatch)(nil)).Elem()
}

func (i *resourceClaimStatusPatchPtrType) ToResourceClaimStatusPatchPtrOutput() ResourceClaimStatusPatchPtrOutput {
	return i.ToResourceClaimStatusPatchPtrOutputWithContext(context.Background())
}

func (i *resourceClaimStatusPatchPtrType) ToResourceClaimStatusPatchPtrOutputWithContext(ctx context.Context) ResourceClaimStatusPatchPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimStatusPatchPtrOutput)
}

// ResourceClaimStatus tracks whether the resource has been allocated and what the resulting attributes are.
type ResourceClaimStatusPatchOutput struct{ *pulumi.OutputState }

func (ResourceClaimStatusPatchOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClaimStatusPatch)(nil)).Elem()
}

func (o ResourceClaimStatusPatchOutput) ToResourceClaimStatusPatchOutput() ResourceClaimStatusPatchOutput {
	return o
}

func (o ResourceClaimStatusPatchOutput) ToResourceClaimStatusPatchOutputWithContext(ctx context.Context) ResourceClaimStatusPatchOutput {
	return o
}

func (o ResourceClaimStatusPatchOutput) ToResourceClaimStatusPatchPtrOutput() ResourceClaimStatusPatchPtrOutput {
	return o.ToResourceClaimStatusPatchPtrOutputWithContext(context.Background())
}

func (o ResourceClaimStatusPatchOutput) ToResourceClaimStatusPatchPtrOutputWithContext(ctx context.Context) ResourceClaimStatusPatchPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResourceClaimStatusPatch) *ResourceClaimStatusPatch {
		return &v
	}).(ResourceClaimStatusPatchPtrOutput)
}

// Allocation is set by the resource driver once a resource or set of resources has been allocated successfully. If this is not specified, the resources have not been allocated yet.
func (o ResourceClaimStatusPatchOutput) Allocation() AllocationResultPatchPtrOutput {
	return o.ApplyT(func(v ResourceClaimStatusPatch) *AllocationResultPatch { return v.Allocation }).(AllocationResultPatchPtrOutput)
}

// DeallocationRequested indicates that a ResourceClaim is to be deallocated.
//
// The driver then must deallocate this claim and reset the field together with clearing the Allocation field.
//
// While DeallocationRequested is set, no new consumers may be added to ReservedFor.
func (o ResourceClaimStatusPatchOutput) DeallocationRequested() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ResourceClaimStatusPatch) *bool { return v.DeallocationRequested }).(pulumi.BoolPtrOutput)
}

// DriverName is a copy of the driver name from the ResourceClass at the time when allocation started.
func (o ResourceClaimStatusPatchOutput) DriverName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClaimStatusPatch) *string { return v.DriverName }).(pulumi.StringPtrOutput)
}

// ReservedFor indicates which entities are currently allowed to use the claim. A Pod which references a ResourceClaim which is not reserved for that Pod will not be started.
//
// There can be at most 32 such reservations. This may get increased in the future, but not reduced.
func (o ResourceClaimStatusPatchOutput) ReservedFor() ResourceClaimConsumerReferencePatchArrayOutput {
	return o.ApplyT(func(v ResourceClaimStatusPatch) []ResourceClaimConsumerReferencePatch { return v.ReservedFor }).(ResourceClaimConsumerReferencePatchArrayOutput)
}

type ResourceClaimStatusPatchPtrOutput struct{ *pulumi.OutputState }

func (ResourceClaimStatusPatchPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceClaimStatusPatch)(nil)).Elem()
}

func (o ResourceClaimStatusPatchPtrOutput) ToResourceClaimStatusPatchPtrOutput() ResourceClaimStatusPatchPtrOutput {
	return o
}

func (o ResourceClaimStatusPatchPtrOutput) ToResourceClaimStatusPatchPtrOutputWithContext(ctx context.Context) ResourceClaimStatusPatchPtrOutput {
	return o
}

func (o ResourceClaimStatusPatchPtrOutput) Elem() ResourceClaimStatusPatchOutput {
	return o.ApplyT(func(v *ResourceClaimStatusPatch) ResourceClaimStatusPatch {
		if v != nil {
			return *v
		}
		var ret ResourceClaimStatusPatch
		return ret
	}).(ResourceClaimStatusPatchOutput)
}

// Allocation is set by the resource driver once a resource or set of resources has been allocated successfully. If this is not specified, the resources have not been allocated yet.
func (o ResourceClaimStatusPatchPtrOutput) Allocation() AllocationResultPatchPtrOutput {
	return o.ApplyT(func(v *ResourceClaimStatusPatch) *AllocationResultPatch {
		if v == nil {
			return nil
		}
		return v.Allocation
	}).(AllocationResultPatchPtrOutput)
}

// DeallocationRequested indicates that a ResourceClaim is to be deallocated.
//
// The driver then must deallocate this claim and reset the field together with clearing the Allocation field.
//
// While DeallocationRequested is set, no new consumers may be added to ReservedFor.
func (o ResourceClaimStatusPatchPtrOutput) DeallocationRequested() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ResourceClaimStatusPatch) *bool {
		if v == nil {
			return nil
		}
		return v.DeallocationRequested
	}).(pulumi.BoolPtrOutput)
}

// DriverName is a copy of the driver name from the ResourceClass at the time when allocation started.
func (o ResourceClaimStatusPatchPtrOutput) DriverName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceClaimStatusPatch) *string {
		if v == nil {
			return nil
		}
		return v.DriverName
	}).(pulumi.StringPtrOutput)
}

// ReservedFor indicates which entities are currently allowed to use the claim. A Pod which references a ResourceClaim which is not reserved for that Pod will not be started.
//
// There can be at most 32 such reservations. This may get increased in the future, but not reduced.
func (o ResourceClaimStatusPatchPtrOutput) ReservedFor() ResourceClaimConsumerReferencePatchArrayOutput {
	return o.ApplyT(func(v *ResourceClaimStatusPatch) []ResourceClaimConsumerReferencePatch {
		if v == nil {
			return nil
		}
		return v.ReservedFor
	}).(ResourceClaimConsumerReferencePatchArrayOutput)
}

// ResourceClaimTemplate is used to produce ResourceClaim objects.
type ResourceClaimTemplateType 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"`
	// 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 object metadata
	Metadata *metav1.ObjectMeta `pulumi:"metadata"`
	// Describes the ResourceClaim that is to be generated.
	//
	// This field is immutable. A ResourceClaim will get created by the control plane for a Pod when needed and then not get updated anymore.
	Spec ResourceClaimTemplateSpec `pulumi:"spec"`
}

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

	ToResourceClaimTemplateTypeOutput() ResourceClaimTemplateTypeOutput
	ToResourceClaimTemplateTypeOutputWithContext(context.Context) ResourceClaimTemplateTypeOutput
}

// ResourceClaimTemplate is used to produce ResourceClaim objects.
type ResourceClaimTemplateTypeArgs 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"`
	// 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 object metadata
	Metadata metav1.ObjectMetaPtrInput `pulumi:"metadata"`
	// Describes the ResourceClaim that is to be generated.
	//
	// This field is immutable. A ResourceClaim will get created by the control plane for a Pod when needed and then not get updated anymore.
	Spec ResourceClaimTemplateSpecInput `pulumi:"spec"`
}

func (ResourceClaimTemplateTypeArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClaimTemplateType)(nil)).Elem()
}

func (i ResourceClaimTemplateTypeArgs) ToResourceClaimTemplateTypeOutput() ResourceClaimTemplateTypeOutput {
	return i.ToResourceClaimTemplateTypeOutputWithContext(context.Background())
}

func (i ResourceClaimTemplateTypeArgs) ToResourceClaimTemplateTypeOutputWithContext(ctx context.Context) ResourceClaimTemplateTypeOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateTypeOutput)
}

// ResourceClaimTemplateTypeArrayInput is an input type that accepts ResourceClaimTemplateTypeArray and ResourceClaimTemplateTypeArrayOutput values.
// You can construct a concrete instance of `ResourceClaimTemplateTypeArrayInput` via:
//
//	ResourceClaimTemplateTypeArray{ ResourceClaimTemplateTypeArgs{...} }
type ResourceClaimTemplateTypeArrayInput interface {
	pulumi.Input

	ToResourceClaimTemplateTypeArrayOutput() ResourceClaimTemplateTypeArrayOutput
	ToResourceClaimTemplateTypeArrayOutputWithContext(context.Context) ResourceClaimTemplateTypeArrayOutput
}

type ResourceClaimTemplateTypeArray []ResourceClaimTemplateTypeInput

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

func (i ResourceClaimTemplateTypeArray) ToResourceClaimTemplateTypeArrayOutput() ResourceClaimTemplateTypeArrayOutput {
	return i.ToResourceClaimTemplateTypeArrayOutputWithContext(context.Background())
}

func (i ResourceClaimTemplateTypeArray) ToResourceClaimTemplateTypeArrayOutputWithContext(ctx context.Context) ResourceClaimTemplateTypeArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateTypeArrayOutput)
}

// ResourceClaimTemplate is used to produce ResourceClaim objects.
type ResourceClaimTemplateTypeOutput struct{ *pulumi.OutputState }

func (ResourceClaimTemplateTypeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClaimTemplateType)(nil)).Elem()
}

func (o ResourceClaimTemplateTypeOutput) ToResourceClaimTemplateTypeOutput() ResourceClaimTemplateTypeOutput {
	return o
}

func (o ResourceClaimTemplateTypeOutput) ToResourceClaimTemplateTypeOutputWithContext(ctx context.Context) ResourceClaimTemplateTypeOutput {
	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 ResourceClaimTemplateTypeOutput) ApiVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClaimTemplateType) *string { return v.ApiVersion }).(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 ResourceClaimTemplateTypeOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClaimTemplateType) *string { return v.Kind }).(pulumi.StringPtrOutput)
}

// Standard object metadata
func (o ResourceClaimTemplateTypeOutput) Metadata() metav1.ObjectMetaPtrOutput {
	return o.ApplyT(func(v ResourceClaimTemplateType) *metav1.ObjectMeta { return v.Metadata }).(metav1.ObjectMetaPtrOutput)
}

// Describes the ResourceClaim that is to be generated.
//
// This field is immutable. A ResourceClaim will get created by the control plane for a Pod when needed and then not get updated anymore.
func (o ResourceClaimTemplateTypeOutput) Spec() ResourceClaimTemplateSpecOutput {
	return o.ApplyT(func(v ResourceClaimTemplateType) ResourceClaimTemplateSpec { return v.Spec }).(ResourceClaimTemplateSpecOutput)
}

type ResourceClaimTemplateTypeArrayOutput struct{ *pulumi.OutputState }

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

func (o ResourceClaimTemplateTypeArrayOutput) ToResourceClaimTemplateTypeArrayOutput() ResourceClaimTemplateTypeArrayOutput {
	return o
}

func (o ResourceClaimTemplateTypeArrayOutput) ToResourceClaimTemplateTypeArrayOutputWithContext(ctx context.Context) ResourceClaimTemplateTypeArrayOutput {
	return o
}

func (o ResourceClaimTemplateTypeArrayOutput) Index(i pulumi.IntInput) ResourceClaimTemplateTypeOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClaimTemplateType {
		return vs[0].([]ResourceClaimTemplateType)[vs[1].(int)]
	}).(ResourceClaimTemplateTypeOutput)
}

// ResourceClaimTemplateList is a collection of claim templates.
type ResourceClaimTemplateListType 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 the list of resource claim templates.
	Items []ResourceClaimTemplateType `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
	Metadata *metav1.ListMeta `pulumi:"metadata"`
}

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

	ToResourceClaimTemplateListTypeOutput() ResourceClaimTemplateListTypeOutput
	ToResourceClaimTemplateListTypeOutputWithContext(context.Context) ResourceClaimTemplateListTypeOutput
}

// ResourceClaimTemplateList is a collection of claim templates.
type ResourceClaimTemplateListTypeArgs 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 the list of resource claim templates.
	Items ResourceClaimTemplateTypeArrayInput `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
	Metadata metav1.ListMetaPtrInput `pulumi:"metadata"`
}

func (ResourceClaimTemplateListTypeArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClaimTemplateListType)(nil)).Elem()
}

func (i ResourceClaimTemplateListTypeArgs) ToResourceClaimTemplateListTypeOutput() ResourceClaimTemplateListTypeOutput {
	return i.ToResourceClaimTemplateListTypeOutputWithContext(context.Background())
}

func (i ResourceClaimTemplateListTypeArgs) ToResourceClaimTemplateListTypeOutputWithContext(ctx context.Context) ResourceClaimTemplateListTypeOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateListTypeOutput)
}

// ResourceClaimTemplateList is a collection of claim templates.
type ResourceClaimTemplateListTypeOutput struct{ *pulumi.OutputState }

func (ResourceClaimTemplateListTypeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClaimTemplateListType)(nil)).Elem()
}

func (o ResourceClaimTemplateListTypeOutput) ToResourceClaimTemplateListTypeOutput() ResourceClaimTemplateListTypeOutput {
	return o
}

func (o ResourceClaimTemplateListTypeOutput) ToResourceClaimTemplateListTypeOutputWithContext(ctx context.Context) ResourceClaimTemplateListTypeOutput {
	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 ResourceClaimTemplateListTypeOutput) ApiVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClaimTemplateListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput)
}

// Items is the list of resource claim templates.
func (o ResourceClaimTemplateListTypeOutput) Items() ResourceClaimTemplateTypeArrayOutput {
	return o.ApplyT(func(v ResourceClaimTemplateListType) []ResourceClaimTemplateType { return v.Items }).(ResourceClaimTemplateTypeArrayOutput)
}

// 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 ResourceClaimTemplateListTypeOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClaimTemplateListType) *string { return v.Kind }).(pulumi.StringPtrOutput)
}

// Standard list metadata
func (o ResourceClaimTemplateListTypeOutput) Metadata() metav1.ListMetaPtrOutput {
	return o.ApplyT(func(v ResourceClaimTemplateListType) *metav1.ListMeta { return v.Metadata }).(metav1.ListMetaPtrOutput)
}

// ResourceClaimTemplate is used to produce ResourceClaim objects.
type ResourceClaimTemplatePatchType 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"`
	// 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 object metadata
	Metadata *metav1.ObjectMetaPatch `pulumi:"metadata"`
	// Describes the ResourceClaim that is to be generated.
	//
	// This field is immutable. A ResourceClaim will get created by the control plane for a Pod when needed and then not get updated anymore.
	Spec *ResourceClaimTemplateSpecPatch `pulumi:"spec"`
}

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

	ToResourceClaimTemplatePatchTypeOutput() ResourceClaimTemplatePatchTypeOutput
	ToResourceClaimTemplatePatchTypeOutputWithContext(context.Context) ResourceClaimTemplatePatchTypeOutput
}

// ResourceClaimTemplate is used to produce ResourceClaim objects.
type ResourceClaimTemplatePatchTypeArgs 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"`
	// 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 object metadata
	Metadata metav1.ObjectMetaPatchPtrInput `pulumi:"metadata"`
	// Describes the ResourceClaim that is to be generated.
	//
	// This field is immutable. A ResourceClaim will get created by the control plane for a Pod when needed and then not get updated anymore.
	Spec ResourceClaimTemplateSpecPatchPtrInput `pulumi:"spec"`
}

func (ResourceClaimTemplatePatchTypeArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClaimTemplatePatchType)(nil)).Elem()
}

func (i ResourceClaimTemplatePatchTypeArgs) ToResourceClaimTemplatePatchTypeOutput() ResourceClaimTemplatePatchTypeOutput {
	return i.ToResourceClaimTemplatePatchTypeOutputWithContext(context.Background())
}

func (i ResourceClaimTemplatePatchTypeArgs) ToResourceClaimTemplatePatchTypeOutputWithContext(ctx context.Context) ResourceClaimTemplatePatchTypeOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplatePatchTypeOutput)
}

// ResourceClaimTemplate is used to produce ResourceClaim objects.
type ResourceClaimTemplatePatchTypeOutput struct{ *pulumi.OutputState }

func (ResourceClaimTemplatePatchTypeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClaimTemplatePatchType)(nil)).Elem()
}

func (o ResourceClaimTemplatePatchTypeOutput) ToResourceClaimTemplatePatchTypeOutput() ResourceClaimTemplatePatchTypeOutput {
	return o
}

func (o ResourceClaimTemplatePatchTypeOutput) ToResourceClaimTemplatePatchTypeOutputWithContext(ctx context.Context) ResourceClaimTemplatePatchTypeOutput {
	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 ResourceClaimTemplatePatchTypeOutput) ApiVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClaimTemplatePatchType) *string { return v.ApiVersion }).(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 ResourceClaimTemplatePatchTypeOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClaimTemplatePatchType) *string { return v.Kind }).(pulumi.StringPtrOutput)
}

// Standard object metadata
func (o ResourceClaimTemplatePatchTypeOutput) Metadata() metav1.ObjectMetaPatchPtrOutput {
	return o.ApplyT(func(v ResourceClaimTemplatePatchType) *metav1.ObjectMetaPatch { return v.Metadata }).(metav1.ObjectMetaPatchPtrOutput)
}

// Describes the ResourceClaim that is to be generated.
//
// This field is immutable. A ResourceClaim will get created by the control plane for a Pod when needed and then not get updated anymore.
func (o ResourceClaimTemplatePatchTypeOutput) Spec() ResourceClaimTemplateSpecPatchPtrOutput {
	return o.ApplyT(func(v ResourceClaimTemplatePatchType) *ResourceClaimTemplateSpecPatch { return v.Spec }).(ResourceClaimTemplateSpecPatchPtrOutput)
}

// ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim.
type ResourceClaimTemplateSpec struct {
	// ObjectMeta may contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.
	Metadata *metav1.ObjectMeta `pulumi:"metadata"`
	// Spec for the ResourceClaim. The entire content is copied unchanged into the ResourceClaim that gets created from this template. The same fields as in a ResourceClaim are also valid here.
	Spec ResourceClaimSpec `pulumi:"spec"`
}

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

	ToResourceClaimTemplateSpecOutput() ResourceClaimTemplateSpecOutput
	ToResourceClaimTemplateSpecOutputWithContext(context.Context) ResourceClaimTemplateSpecOutput
}

// ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim.
type ResourceClaimTemplateSpecArgs struct {
	// ObjectMeta may contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.
	Metadata metav1.ObjectMetaPtrInput `pulumi:"metadata"`
	// Spec for the ResourceClaim. The entire content is copied unchanged into the ResourceClaim that gets created from this template. The same fields as in a ResourceClaim are also valid here.
	Spec ResourceClaimSpecInput `pulumi:"spec"`
}

func (ResourceClaimTemplateSpecArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClaimTemplateSpec)(nil)).Elem()
}

func (i ResourceClaimTemplateSpecArgs) ToResourceClaimTemplateSpecOutput() ResourceClaimTemplateSpecOutput {
	return i.ToResourceClaimTemplateSpecOutputWithContext(context.Background())
}

func (i ResourceClaimTemplateSpecArgs) ToResourceClaimTemplateSpecOutputWithContext(ctx context.Context) ResourceClaimTemplateSpecOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateSpecOutput)
}

// ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim.
type ResourceClaimTemplateSpecOutput struct{ *pulumi.OutputState }

func (ResourceClaimTemplateSpecOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClaimTemplateSpec)(nil)).Elem()
}

func (o ResourceClaimTemplateSpecOutput) ToResourceClaimTemplateSpecOutput() ResourceClaimTemplateSpecOutput {
	return o
}

func (o ResourceClaimTemplateSpecOutput) ToResourceClaimTemplateSpecOutputWithContext(ctx context.Context) ResourceClaimTemplateSpecOutput {
	return o
}

// ObjectMeta may contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.
func (o ResourceClaimTemplateSpecOutput) Metadata() metav1.ObjectMetaPtrOutput {
	return o.ApplyT(func(v ResourceClaimTemplateSpec) *metav1.ObjectMeta { return v.Metadata }).(metav1.ObjectMetaPtrOutput)
}

// Spec for the ResourceClaim. The entire content is copied unchanged into the ResourceClaim that gets created from this template. The same fields as in a ResourceClaim are also valid here.
func (o ResourceClaimTemplateSpecOutput) Spec() ResourceClaimSpecOutput {
	return o.ApplyT(func(v ResourceClaimTemplateSpec) ResourceClaimSpec { return v.Spec }).(ResourceClaimSpecOutput)
}

// ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim.
type ResourceClaimTemplateSpecPatch struct {
	// ObjectMeta may contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.
	Metadata *metav1.ObjectMetaPatch `pulumi:"metadata"`
	// Spec for the ResourceClaim. The entire content is copied unchanged into the ResourceClaim that gets created from this template. The same fields as in a ResourceClaim are also valid here.
	Spec *ResourceClaimSpecPatch `pulumi:"spec"`
}

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

	ToResourceClaimTemplateSpecPatchOutput() ResourceClaimTemplateSpecPatchOutput
	ToResourceClaimTemplateSpecPatchOutputWithContext(context.Context) ResourceClaimTemplateSpecPatchOutput
}

// ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim.
type ResourceClaimTemplateSpecPatchArgs struct {
	// ObjectMeta may contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.
	Metadata metav1.ObjectMetaPatchPtrInput `pulumi:"metadata"`
	// Spec for the ResourceClaim. The entire content is copied unchanged into the ResourceClaim that gets created from this template. The same fields as in a ResourceClaim are also valid here.
	Spec ResourceClaimSpecPatchPtrInput `pulumi:"spec"`
}

func (ResourceClaimTemplateSpecPatchArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClaimTemplateSpecPatch)(nil)).Elem()
}

func (i ResourceClaimTemplateSpecPatchArgs) ToResourceClaimTemplateSpecPatchOutput() ResourceClaimTemplateSpecPatchOutput {
	return i.ToResourceClaimTemplateSpecPatchOutputWithContext(context.Background())
}

func (i ResourceClaimTemplateSpecPatchArgs) ToResourceClaimTemplateSpecPatchOutputWithContext(ctx context.Context) ResourceClaimTemplateSpecPatchOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateSpecPatchOutput)
}

func (i ResourceClaimTemplateSpecPatchArgs) ToResourceClaimTemplateSpecPatchPtrOutput() ResourceClaimTemplateSpecPatchPtrOutput {
	return i.ToResourceClaimTemplateSpecPatchPtrOutputWithContext(context.Background())
}

func (i ResourceClaimTemplateSpecPatchArgs) ToResourceClaimTemplateSpecPatchPtrOutputWithContext(ctx context.Context) ResourceClaimTemplateSpecPatchPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateSpecPatchOutput).ToResourceClaimTemplateSpecPatchPtrOutputWithContext(ctx)
}

// ResourceClaimTemplateSpecPatchPtrInput is an input type that accepts ResourceClaimTemplateSpecPatchArgs, ResourceClaimTemplateSpecPatchPtr and ResourceClaimTemplateSpecPatchPtrOutput values.
// You can construct a concrete instance of `ResourceClaimTemplateSpecPatchPtrInput` via:
//
//	        ResourceClaimTemplateSpecPatchArgs{...}
//
//	or:
//
//	        nil
type ResourceClaimTemplateSpecPatchPtrInput interface {
	pulumi.Input

	ToResourceClaimTemplateSpecPatchPtrOutput() ResourceClaimTemplateSpecPatchPtrOutput
	ToResourceClaimTemplateSpecPatchPtrOutputWithContext(context.Context) ResourceClaimTemplateSpecPatchPtrOutput
}

type resourceClaimTemplateSpecPatchPtrType ResourceClaimTemplateSpecPatchArgs

func ResourceClaimTemplateSpecPatchPtr(v *ResourceClaimTemplateSpecPatchArgs) ResourceClaimTemplateSpecPatchPtrInput {
	return (*resourceClaimTemplateSpecPatchPtrType)(v)
}

func (*resourceClaimTemplateSpecPatchPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceClaimTemplateSpecPatch)(nil)).Elem()
}

func (i *resourceClaimTemplateSpecPatchPtrType) ToResourceClaimTemplateSpecPatchPtrOutput() ResourceClaimTemplateSpecPatchPtrOutput {
	return i.ToResourceClaimTemplateSpecPatchPtrOutputWithContext(context.Background())
}

func (i *resourceClaimTemplateSpecPatchPtrType) ToResourceClaimTemplateSpecPatchPtrOutputWithContext(ctx context.Context) ResourceClaimTemplateSpecPatchPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClaimTemplateSpecPatchPtrOutput)
}

// ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim.
type ResourceClaimTemplateSpecPatchOutput struct{ *pulumi.OutputState }

func (ResourceClaimTemplateSpecPatchOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClaimTemplateSpecPatch)(nil)).Elem()
}

func (o ResourceClaimTemplateSpecPatchOutput) ToResourceClaimTemplateSpecPatchOutput() ResourceClaimTemplateSpecPatchOutput {
	return o
}

func (o ResourceClaimTemplateSpecPatchOutput) ToResourceClaimTemplateSpecPatchOutputWithContext(ctx context.Context) ResourceClaimTemplateSpecPatchOutput {
	return o
}

func (o ResourceClaimTemplateSpecPatchOutput) ToResourceClaimTemplateSpecPatchPtrOutput() ResourceClaimTemplateSpecPatchPtrOutput {
	return o.ToResourceClaimTemplateSpecPatchPtrOutputWithContext(context.Background())
}

func (o ResourceClaimTemplateSpecPatchOutput) ToResourceClaimTemplateSpecPatchPtrOutputWithContext(ctx context.Context) ResourceClaimTemplateSpecPatchPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResourceClaimTemplateSpecPatch) *ResourceClaimTemplateSpecPatch {
		return &v
	}).(ResourceClaimTemplateSpecPatchPtrOutput)
}

// ObjectMeta may contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.
func (o ResourceClaimTemplateSpecPatchOutput) Metadata() metav1.ObjectMetaPatchPtrOutput {
	return o.ApplyT(func(v ResourceClaimTemplateSpecPatch) *metav1.ObjectMetaPatch { return v.Metadata }).(metav1.ObjectMetaPatchPtrOutput)
}

// Spec for the ResourceClaim. The entire content is copied unchanged into the ResourceClaim that gets created from this template. The same fields as in a ResourceClaim are also valid here.
func (o ResourceClaimTemplateSpecPatchOutput) Spec() ResourceClaimSpecPatchPtrOutput {
	return o.ApplyT(func(v ResourceClaimTemplateSpecPatch) *ResourceClaimSpecPatch { return v.Spec }).(ResourceClaimSpecPatchPtrOutput)
}

type ResourceClaimTemplateSpecPatchPtrOutput struct{ *pulumi.OutputState }

func (ResourceClaimTemplateSpecPatchPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceClaimTemplateSpecPatch)(nil)).Elem()
}

func (o ResourceClaimTemplateSpecPatchPtrOutput) ToResourceClaimTemplateSpecPatchPtrOutput() ResourceClaimTemplateSpecPatchPtrOutput {
	return o
}

func (o ResourceClaimTemplateSpecPatchPtrOutput) ToResourceClaimTemplateSpecPatchPtrOutputWithContext(ctx context.Context) ResourceClaimTemplateSpecPatchPtrOutput {
	return o
}

func (o ResourceClaimTemplateSpecPatchPtrOutput) Elem() ResourceClaimTemplateSpecPatchOutput {
	return o.ApplyT(func(v *ResourceClaimTemplateSpecPatch) ResourceClaimTemplateSpecPatch {
		if v != nil {
			return *v
		}
		var ret ResourceClaimTemplateSpecPatch
		return ret
	}).(ResourceClaimTemplateSpecPatchOutput)
}

// ObjectMeta may contain labels and annotations that will be copied into the PVC when creating it. No other fields are allowed and will be rejected during validation.
func (o ResourceClaimTemplateSpecPatchPtrOutput) Metadata() metav1.ObjectMetaPatchPtrOutput {
	return o.ApplyT(func(v *ResourceClaimTemplateSpecPatch) *metav1.ObjectMetaPatch {
		if v == nil {
			return nil
		}
		return v.Metadata
	}).(metav1.ObjectMetaPatchPtrOutput)
}

// Spec for the ResourceClaim. The entire content is copied unchanged into the ResourceClaim that gets created from this template. The same fields as in a ResourceClaim are also valid here.
func (o ResourceClaimTemplateSpecPatchPtrOutput) Spec() ResourceClaimSpecPatchPtrOutput {
	return o.ApplyT(func(v *ResourceClaimTemplateSpecPatch) *ResourceClaimSpecPatch {
		if v == nil {
			return nil
		}
		return v.Spec
	}).(ResourceClaimSpecPatchPtrOutput)
}

// ResourceClass is used by administrators to influence how resources are allocated.
//
// This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
type ResourceClassType 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"`
	// DriverName defines the name of the dynamic resource driver that is used for allocation of a ResourceClaim that uses this class.
	//
	// Resource drivers have a unique name in forward domain order (acme.example.com).
	DriverName string `pulumi:"driverName"`
	// 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 object metadata
	Metadata *metav1.ObjectMeta `pulumi:"metadata"`
	// ParametersRef references an arbitrary separate object that may hold parameters that will be used by the driver when allocating a resource that uses this class. A dynamic resource driver can distinguish between parameters stored here and and those stored in ResourceClaimSpec.
	ParametersRef *ResourceClassParametersReference `pulumi:"parametersRef"`
	// Only nodes matching the selector will be considered by the scheduler when trying to find a Node that fits a Pod when that Pod uses a ResourceClaim that has not been allocated yet.
	//
	// Setting this field is optional. If null, all nodes are candidates.
	SuitableNodes *corev1.NodeSelector `pulumi:"suitableNodes"`
}

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

	ToResourceClassTypeOutput() ResourceClassTypeOutput
	ToResourceClassTypeOutputWithContext(context.Context) ResourceClassTypeOutput
}

// ResourceClass is used by administrators to influence how resources are allocated.
//
// This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
type ResourceClassTypeArgs 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"`
	// DriverName defines the name of the dynamic resource driver that is used for allocation of a ResourceClaim that uses this class.
	//
	// Resource drivers have a unique name in forward domain order (acme.example.com).
	DriverName pulumi.StringInput `pulumi:"driverName"`
	// 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 object metadata
	Metadata metav1.ObjectMetaPtrInput `pulumi:"metadata"`
	// ParametersRef references an arbitrary separate object that may hold parameters that will be used by the driver when allocating a resource that uses this class. A dynamic resource driver can distinguish between parameters stored here and and those stored in ResourceClaimSpec.
	ParametersRef ResourceClassParametersReferencePtrInput `pulumi:"parametersRef"`
	// Only nodes matching the selector will be considered by the scheduler when trying to find a Node that fits a Pod when that Pod uses a ResourceClaim that has not been allocated yet.
	//
	// Setting this field is optional. If null, all nodes are candidates.
	SuitableNodes corev1.NodeSelectorPtrInput `pulumi:"suitableNodes"`
}

func (ResourceClassTypeArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClassType)(nil)).Elem()
}

func (i ResourceClassTypeArgs) ToResourceClassTypeOutput() ResourceClassTypeOutput {
	return i.ToResourceClassTypeOutputWithContext(context.Background())
}

func (i ResourceClassTypeArgs) ToResourceClassTypeOutputWithContext(ctx context.Context) ResourceClassTypeOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClassTypeOutput)
}

// ResourceClassTypeArrayInput is an input type that accepts ResourceClassTypeArray and ResourceClassTypeArrayOutput values.
// You can construct a concrete instance of `ResourceClassTypeArrayInput` via:
//
//	ResourceClassTypeArray{ ResourceClassTypeArgs{...} }
type ResourceClassTypeArrayInput interface {
	pulumi.Input

	ToResourceClassTypeArrayOutput() ResourceClassTypeArrayOutput
	ToResourceClassTypeArrayOutputWithContext(context.Context) ResourceClassTypeArrayOutput
}

type ResourceClassTypeArray []ResourceClassTypeInput

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

func (i ResourceClassTypeArray) ToResourceClassTypeArrayOutput() ResourceClassTypeArrayOutput {
	return i.ToResourceClassTypeArrayOutputWithContext(context.Background())
}

func (i ResourceClassTypeArray) ToResourceClassTypeArrayOutputWithContext(ctx context.Context) ResourceClassTypeArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClassTypeArrayOutput)
}

// ResourceClass is used by administrators to influence how resources are allocated.
//
// This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
type ResourceClassTypeOutput struct{ *pulumi.OutputState }

func (ResourceClassTypeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClassType)(nil)).Elem()
}

func (o ResourceClassTypeOutput) ToResourceClassTypeOutput() ResourceClassTypeOutput {
	return o
}

func (o ResourceClassTypeOutput) ToResourceClassTypeOutputWithContext(ctx context.Context) ResourceClassTypeOutput {
	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 ResourceClassTypeOutput) ApiVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClassType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput)
}

// DriverName defines the name of the dynamic resource driver that is used for allocation of a ResourceClaim that uses this class.
//
// Resource drivers have a unique name in forward domain order (acme.example.com).
func (o ResourceClassTypeOutput) DriverName() pulumi.StringOutput {
	return o.ApplyT(func(v ResourceClassType) string { return v.DriverName }).(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 ResourceClassTypeOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClassType) *string { return v.Kind }).(pulumi.StringPtrOutput)
}

// Standard object metadata
func (o ResourceClassTypeOutput) Metadata() metav1.ObjectMetaPtrOutput {
	return o.ApplyT(func(v ResourceClassType) *metav1.ObjectMeta { return v.Metadata }).(metav1.ObjectMetaPtrOutput)
}

// ParametersRef references an arbitrary separate object that may hold parameters that will be used by the driver when allocating a resource that uses this class. A dynamic resource driver can distinguish between parameters stored here and and those stored in ResourceClaimSpec.
func (o ResourceClassTypeOutput) ParametersRef() ResourceClassParametersReferencePtrOutput {
	return o.ApplyT(func(v ResourceClassType) *ResourceClassParametersReference { return v.ParametersRef }).(ResourceClassParametersReferencePtrOutput)
}

// Only nodes matching the selector will be considered by the scheduler when trying to find a Node that fits a Pod when that Pod uses a ResourceClaim that has not been allocated yet.
//
// Setting this field is optional. If null, all nodes are candidates.
func (o ResourceClassTypeOutput) SuitableNodes() corev1.NodeSelectorPtrOutput {
	return o.ApplyT(func(v ResourceClassType) *corev1.NodeSelector { return v.SuitableNodes }).(corev1.NodeSelectorPtrOutput)
}

type ResourceClassTypeArrayOutput struct{ *pulumi.OutputState }

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

func (o ResourceClassTypeArrayOutput) ToResourceClassTypeArrayOutput() ResourceClassTypeArrayOutput {
	return o
}

func (o ResourceClassTypeArrayOutput) ToResourceClassTypeArrayOutputWithContext(ctx context.Context) ResourceClassTypeArrayOutput {
	return o
}

func (o ResourceClassTypeArrayOutput) Index(i pulumi.IntInput) ResourceClassTypeOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceClassType {
		return vs[0].([]ResourceClassType)[vs[1].(int)]
	}).(ResourceClassTypeOutput)
}

// ResourceClassList is a collection of classes.
type ResourceClassListType 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 the list of resource classes.
	Items []ResourceClassType `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
	Metadata *metav1.ListMeta `pulumi:"metadata"`
}

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

	ToResourceClassListTypeOutput() ResourceClassListTypeOutput
	ToResourceClassListTypeOutputWithContext(context.Context) ResourceClassListTypeOutput
}

// ResourceClassList is a collection of classes.
type ResourceClassListTypeArgs 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 the list of resource classes.
	Items ResourceClassTypeArrayInput `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
	Metadata metav1.ListMetaPtrInput `pulumi:"metadata"`
}

func (ResourceClassListTypeArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClassListType)(nil)).Elem()
}

func (i ResourceClassListTypeArgs) ToResourceClassListTypeOutput() ResourceClassListTypeOutput {
	return i.ToResourceClassListTypeOutputWithContext(context.Background())
}

func (i ResourceClassListTypeArgs) ToResourceClassListTypeOutputWithContext(ctx context.Context) ResourceClassListTypeOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClassListTypeOutput)
}

// ResourceClassList is a collection of classes.
type ResourceClassListTypeOutput struct{ *pulumi.OutputState }

func (ResourceClassListTypeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClassListType)(nil)).Elem()
}

func (o ResourceClassListTypeOutput) ToResourceClassListTypeOutput() ResourceClassListTypeOutput {
	return o
}

func (o ResourceClassListTypeOutput) ToResourceClassListTypeOutputWithContext(ctx context.Context) ResourceClassListTypeOutput {
	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 ResourceClassListTypeOutput) ApiVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClassListType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput)
}

// Items is the list of resource classes.
func (o ResourceClassListTypeOutput) Items() ResourceClassTypeArrayOutput {
	return o.ApplyT(func(v ResourceClassListType) []ResourceClassType { return v.Items }).(ResourceClassTypeArrayOutput)
}

// 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 ResourceClassListTypeOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClassListType) *string { return v.Kind }).(pulumi.StringPtrOutput)
}

// Standard list metadata
func (o ResourceClassListTypeOutput) Metadata() metav1.ListMetaPtrOutput {
	return o.ApplyT(func(v ResourceClassListType) *metav1.ListMeta { return v.Metadata }).(metav1.ListMetaPtrOutput)
}

// ResourceClassParametersReference contains enough information to let you locate the parameters for a ResourceClass.
type ResourceClassParametersReference struct {
	// APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources.
	ApiGroup *string `pulumi:"apiGroup"`
	// Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
	Kind string `pulumi:"kind"`
	// Name is the name of resource being referenced.
	Name string `pulumi:"name"`
	// Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
	Namespace *string `pulumi:"namespace"`
}

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

	ToResourceClassParametersReferenceOutput() ResourceClassParametersReferenceOutput
	ToResourceClassParametersReferenceOutputWithContext(context.Context) ResourceClassParametersReferenceOutput
}

// ResourceClassParametersReference contains enough information to let you locate the parameters for a ResourceClass.
type ResourceClassParametersReferenceArgs struct {
	// APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources.
	ApiGroup pulumi.StringPtrInput `pulumi:"apiGroup"`
	// Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
	Kind pulumi.StringInput `pulumi:"kind"`
	// Name is the name of resource being referenced.
	Name pulumi.StringInput `pulumi:"name"`
	// Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
	Namespace pulumi.StringPtrInput `pulumi:"namespace"`
}

func (ResourceClassParametersReferenceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClassParametersReference)(nil)).Elem()
}

func (i ResourceClassParametersReferenceArgs) ToResourceClassParametersReferenceOutput() ResourceClassParametersReferenceOutput {
	return i.ToResourceClassParametersReferenceOutputWithContext(context.Background())
}

func (i ResourceClassParametersReferenceArgs) ToResourceClassParametersReferenceOutputWithContext(ctx context.Context) ResourceClassParametersReferenceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClassParametersReferenceOutput)
}

func (i ResourceClassParametersReferenceArgs) ToResourceClassParametersReferencePtrOutput() ResourceClassParametersReferencePtrOutput {
	return i.ToResourceClassParametersReferencePtrOutputWithContext(context.Background())
}

func (i ResourceClassParametersReferenceArgs) ToResourceClassParametersReferencePtrOutputWithContext(ctx context.Context) ResourceClassParametersReferencePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClassParametersReferenceOutput).ToResourceClassParametersReferencePtrOutputWithContext(ctx)
}

// ResourceClassParametersReferencePtrInput is an input type that accepts ResourceClassParametersReferenceArgs, ResourceClassParametersReferencePtr and ResourceClassParametersReferencePtrOutput values.
// You can construct a concrete instance of `ResourceClassParametersReferencePtrInput` via:
//
//	        ResourceClassParametersReferenceArgs{...}
//
//	or:
//
//	        nil
type ResourceClassParametersReferencePtrInput interface {
	pulumi.Input

	ToResourceClassParametersReferencePtrOutput() ResourceClassParametersReferencePtrOutput
	ToResourceClassParametersReferencePtrOutputWithContext(context.Context) ResourceClassParametersReferencePtrOutput
}

type resourceClassParametersReferencePtrType ResourceClassParametersReferenceArgs

func ResourceClassParametersReferencePtr(v *ResourceClassParametersReferenceArgs) ResourceClassParametersReferencePtrInput {
	return (*resourceClassParametersReferencePtrType)(v)
}

func (*resourceClassParametersReferencePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceClassParametersReference)(nil)).Elem()
}

func (i *resourceClassParametersReferencePtrType) ToResourceClassParametersReferencePtrOutput() ResourceClassParametersReferencePtrOutput {
	return i.ToResourceClassParametersReferencePtrOutputWithContext(context.Background())
}

func (i *resourceClassParametersReferencePtrType) ToResourceClassParametersReferencePtrOutputWithContext(ctx context.Context) ResourceClassParametersReferencePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClassParametersReferencePtrOutput)
}

// ResourceClassParametersReference contains enough information to let you locate the parameters for a ResourceClass.
type ResourceClassParametersReferenceOutput struct{ *pulumi.OutputState }

func (ResourceClassParametersReferenceOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClassParametersReference)(nil)).Elem()
}

func (o ResourceClassParametersReferenceOutput) ToResourceClassParametersReferenceOutput() ResourceClassParametersReferenceOutput {
	return o
}

func (o ResourceClassParametersReferenceOutput) ToResourceClassParametersReferenceOutputWithContext(ctx context.Context) ResourceClassParametersReferenceOutput {
	return o
}

func (o ResourceClassParametersReferenceOutput) ToResourceClassParametersReferencePtrOutput() ResourceClassParametersReferencePtrOutput {
	return o.ToResourceClassParametersReferencePtrOutputWithContext(context.Background())
}

func (o ResourceClassParametersReferenceOutput) ToResourceClassParametersReferencePtrOutputWithContext(ctx context.Context) ResourceClassParametersReferencePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResourceClassParametersReference) *ResourceClassParametersReference {
		return &v
	}).(ResourceClassParametersReferencePtrOutput)
}

// APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources.
func (o ResourceClassParametersReferenceOutput) ApiGroup() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClassParametersReference) *string { return v.ApiGroup }).(pulumi.StringPtrOutput)
}

// Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
func (o ResourceClassParametersReferenceOutput) Kind() pulumi.StringOutput {
	return o.ApplyT(func(v ResourceClassParametersReference) string { return v.Kind }).(pulumi.StringOutput)
}

// Name is the name of resource being referenced.
func (o ResourceClassParametersReferenceOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v ResourceClassParametersReference) string { return v.Name }).(pulumi.StringOutput)
}

// Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
func (o ResourceClassParametersReferenceOutput) Namespace() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClassParametersReference) *string { return v.Namespace }).(pulumi.StringPtrOutput)
}

type ResourceClassParametersReferencePtrOutput struct{ *pulumi.OutputState }

func (ResourceClassParametersReferencePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceClassParametersReference)(nil)).Elem()
}

func (o ResourceClassParametersReferencePtrOutput) ToResourceClassParametersReferencePtrOutput() ResourceClassParametersReferencePtrOutput {
	return o
}

func (o ResourceClassParametersReferencePtrOutput) ToResourceClassParametersReferencePtrOutputWithContext(ctx context.Context) ResourceClassParametersReferencePtrOutput {
	return o
}

func (o ResourceClassParametersReferencePtrOutput) Elem() ResourceClassParametersReferenceOutput {
	return o.ApplyT(func(v *ResourceClassParametersReference) ResourceClassParametersReference {
		if v != nil {
			return *v
		}
		var ret ResourceClassParametersReference
		return ret
	}).(ResourceClassParametersReferenceOutput)
}

// APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources.
func (o ResourceClassParametersReferencePtrOutput) ApiGroup() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceClassParametersReference) *string {
		if v == nil {
			return nil
		}
		return v.ApiGroup
	}).(pulumi.StringPtrOutput)
}

// Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
func (o ResourceClassParametersReferencePtrOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceClassParametersReference) *string {
		if v == nil {
			return nil
		}
		return &v.Kind
	}).(pulumi.StringPtrOutput)
}

// Name is the name of resource being referenced.
func (o ResourceClassParametersReferencePtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceClassParametersReference) *string {
		if v == nil {
			return nil
		}
		return &v.Name
	}).(pulumi.StringPtrOutput)
}

// Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
func (o ResourceClassParametersReferencePtrOutput) Namespace() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceClassParametersReference) *string {
		if v == nil {
			return nil
		}
		return v.Namespace
	}).(pulumi.StringPtrOutput)
}

// ResourceClassParametersReference contains enough information to let you locate the parameters for a ResourceClass.
type ResourceClassParametersReferencePatch struct {
	// APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources.
	ApiGroup *string `pulumi:"apiGroup"`
	// Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
	Kind *string `pulumi:"kind"`
	// Name is the name of resource being referenced.
	Name *string `pulumi:"name"`
	// Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
	Namespace *string `pulumi:"namespace"`
}

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

	ToResourceClassParametersReferencePatchOutput() ResourceClassParametersReferencePatchOutput
	ToResourceClassParametersReferencePatchOutputWithContext(context.Context) ResourceClassParametersReferencePatchOutput
}

// ResourceClassParametersReference contains enough information to let you locate the parameters for a ResourceClass.
type ResourceClassParametersReferencePatchArgs struct {
	// APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources.
	ApiGroup pulumi.StringPtrInput `pulumi:"apiGroup"`
	// Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
	Kind pulumi.StringPtrInput `pulumi:"kind"`
	// Name is the name of resource being referenced.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
	Namespace pulumi.StringPtrInput `pulumi:"namespace"`
}

func (ResourceClassParametersReferencePatchArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClassParametersReferencePatch)(nil)).Elem()
}

func (i ResourceClassParametersReferencePatchArgs) ToResourceClassParametersReferencePatchOutput() ResourceClassParametersReferencePatchOutput {
	return i.ToResourceClassParametersReferencePatchOutputWithContext(context.Background())
}

func (i ResourceClassParametersReferencePatchArgs) ToResourceClassParametersReferencePatchOutputWithContext(ctx context.Context) ResourceClassParametersReferencePatchOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClassParametersReferencePatchOutput)
}

func (i ResourceClassParametersReferencePatchArgs) ToResourceClassParametersReferencePatchPtrOutput() ResourceClassParametersReferencePatchPtrOutput {
	return i.ToResourceClassParametersReferencePatchPtrOutputWithContext(context.Background())
}

func (i ResourceClassParametersReferencePatchArgs) ToResourceClassParametersReferencePatchPtrOutputWithContext(ctx context.Context) ResourceClassParametersReferencePatchPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClassParametersReferencePatchOutput).ToResourceClassParametersReferencePatchPtrOutputWithContext(ctx)
}

// ResourceClassParametersReferencePatchPtrInput is an input type that accepts ResourceClassParametersReferencePatchArgs, ResourceClassParametersReferencePatchPtr and ResourceClassParametersReferencePatchPtrOutput values.
// You can construct a concrete instance of `ResourceClassParametersReferencePatchPtrInput` via:
//
//	        ResourceClassParametersReferencePatchArgs{...}
//
//	or:
//
//	        nil
type ResourceClassParametersReferencePatchPtrInput interface {
	pulumi.Input

	ToResourceClassParametersReferencePatchPtrOutput() ResourceClassParametersReferencePatchPtrOutput
	ToResourceClassParametersReferencePatchPtrOutputWithContext(context.Context) ResourceClassParametersReferencePatchPtrOutput
}

type resourceClassParametersReferencePatchPtrType ResourceClassParametersReferencePatchArgs

func ResourceClassParametersReferencePatchPtr(v *ResourceClassParametersReferencePatchArgs) ResourceClassParametersReferencePatchPtrInput {
	return (*resourceClassParametersReferencePatchPtrType)(v)
}

func (*resourceClassParametersReferencePatchPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceClassParametersReferencePatch)(nil)).Elem()
}

func (i *resourceClassParametersReferencePatchPtrType) ToResourceClassParametersReferencePatchPtrOutput() ResourceClassParametersReferencePatchPtrOutput {
	return i.ToResourceClassParametersReferencePatchPtrOutputWithContext(context.Background())
}

func (i *resourceClassParametersReferencePatchPtrType) ToResourceClassParametersReferencePatchPtrOutputWithContext(ctx context.Context) ResourceClassParametersReferencePatchPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClassParametersReferencePatchPtrOutput)
}

// ResourceClassParametersReference contains enough information to let you locate the parameters for a ResourceClass.
type ResourceClassParametersReferencePatchOutput struct{ *pulumi.OutputState }

func (ResourceClassParametersReferencePatchOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClassParametersReferencePatch)(nil)).Elem()
}

func (o ResourceClassParametersReferencePatchOutput) ToResourceClassParametersReferencePatchOutput() ResourceClassParametersReferencePatchOutput {
	return o
}

func (o ResourceClassParametersReferencePatchOutput) ToResourceClassParametersReferencePatchOutputWithContext(ctx context.Context) ResourceClassParametersReferencePatchOutput {
	return o
}

func (o ResourceClassParametersReferencePatchOutput) ToResourceClassParametersReferencePatchPtrOutput() ResourceClassParametersReferencePatchPtrOutput {
	return o.ToResourceClassParametersReferencePatchPtrOutputWithContext(context.Background())
}

func (o ResourceClassParametersReferencePatchOutput) ToResourceClassParametersReferencePatchPtrOutputWithContext(ctx context.Context) ResourceClassParametersReferencePatchPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResourceClassParametersReferencePatch) *ResourceClassParametersReferencePatch {
		return &v
	}).(ResourceClassParametersReferencePatchPtrOutput)
}

// APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources.
func (o ResourceClassParametersReferencePatchOutput) ApiGroup() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClassParametersReferencePatch) *string { return v.ApiGroup }).(pulumi.StringPtrOutput)
}

// Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
func (o ResourceClassParametersReferencePatchOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClassParametersReferencePatch) *string { return v.Kind }).(pulumi.StringPtrOutput)
}

// Name is the name of resource being referenced.
func (o ResourceClassParametersReferencePatchOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClassParametersReferencePatch) *string { return v.Name }).(pulumi.StringPtrOutput)
}

// Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
func (o ResourceClassParametersReferencePatchOutput) Namespace() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClassParametersReferencePatch) *string { return v.Namespace }).(pulumi.StringPtrOutput)
}

type ResourceClassParametersReferencePatchPtrOutput struct{ *pulumi.OutputState }

func (ResourceClassParametersReferencePatchPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceClassParametersReferencePatch)(nil)).Elem()
}

func (o ResourceClassParametersReferencePatchPtrOutput) ToResourceClassParametersReferencePatchPtrOutput() ResourceClassParametersReferencePatchPtrOutput {
	return o
}

func (o ResourceClassParametersReferencePatchPtrOutput) ToResourceClassParametersReferencePatchPtrOutputWithContext(ctx context.Context) ResourceClassParametersReferencePatchPtrOutput {
	return o
}

func (o ResourceClassParametersReferencePatchPtrOutput) Elem() ResourceClassParametersReferencePatchOutput {
	return o.ApplyT(func(v *ResourceClassParametersReferencePatch) ResourceClassParametersReferencePatch {
		if v != nil {
			return *v
		}
		var ret ResourceClassParametersReferencePatch
		return ret
	}).(ResourceClassParametersReferencePatchOutput)
}

// APIGroup is the group for the resource being referenced. It is empty for the core API. This matches the group in the APIVersion that is used when creating the resources.
func (o ResourceClassParametersReferencePatchPtrOutput) ApiGroup() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceClassParametersReferencePatch) *string {
		if v == nil {
			return nil
		}
		return v.ApiGroup
	}).(pulumi.StringPtrOutput)
}

// Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
func (o ResourceClassParametersReferencePatchPtrOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceClassParametersReferencePatch) *string {
		if v == nil {
			return nil
		}
		return v.Kind
	}).(pulumi.StringPtrOutput)
}

// Name is the name of resource being referenced.
func (o ResourceClassParametersReferencePatchPtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceClassParametersReferencePatch) *string {
		if v == nil {
			return nil
		}
		return v.Name
	}).(pulumi.StringPtrOutput)
}

// Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
func (o ResourceClassParametersReferencePatchPtrOutput) Namespace() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceClassParametersReferencePatch) *string {
		if v == nil {
			return nil
		}
		return v.Namespace
	}).(pulumi.StringPtrOutput)
}

// ResourceClass is used by administrators to influence how resources are allocated.
//
// This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
type ResourceClassPatchType 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"`
	// DriverName defines the name of the dynamic resource driver that is used for allocation of a ResourceClaim that uses this class.
	//
	// Resource drivers have a unique name in forward domain order (acme.example.com).
	DriverName *string `pulumi:"driverName"`
	// 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 object metadata
	Metadata *metav1.ObjectMetaPatch `pulumi:"metadata"`
	// ParametersRef references an arbitrary separate object that may hold parameters that will be used by the driver when allocating a resource that uses this class. A dynamic resource driver can distinguish between parameters stored here and and those stored in ResourceClaimSpec.
	ParametersRef *ResourceClassParametersReferencePatch `pulumi:"parametersRef"`
	// Only nodes matching the selector will be considered by the scheduler when trying to find a Node that fits a Pod when that Pod uses a ResourceClaim that has not been allocated yet.
	//
	// Setting this field is optional. If null, all nodes are candidates.
	SuitableNodes *corev1.NodeSelectorPatch `pulumi:"suitableNodes"`
}

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

	ToResourceClassPatchTypeOutput() ResourceClassPatchTypeOutput
	ToResourceClassPatchTypeOutputWithContext(context.Context) ResourceClassPatchTypeOutput
}

// ResourceClass is used by administrators to influence how resources are allocated.
//
// This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
type ResourceClassPatchTypeArgs 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"`
	// DriverName defines the name of the dynamic resource driver that is used for allocation of a ResourceClaim that uses this class.
	//
	// Resource drivers have a unique name in forward domain order (acme.example.com).
	DriverName pulumi.StringPtrInput `pulumi:"driverName"`
	// 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 object metadata
	Metadata metav1.ObjectMetaPatchPtrInput `pulumi:"metadata"`
	// ParametersRef references an arbitrary separate object that may hold parameters that will be used by the driver when allocating a resource that uses this class. A dynamic resource driver can distinguish between parameters stored here and and those stored in ResourceClaimSpec.
	ParametersRef ResourceClassParametersReferencePatchPtrInput `pulumi:"parametersRef"`
	// Only nodes matching the selector will be considered by the scheduler when trying to find a Node that fits a Pod when that Pod uses a ResourceClaim that has not been allocated yet.
	//
	// Setting this field is optional. If null, all nodes are candidates.
	SuitableNodes corev1.NodeSelectorPatchPtrInput `pulumi:"suitableNodes"`
}

func (ResourceClassPatchTypeArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClassPatchType)(nil)).Elem()
}

func (i ResourceClassPatchTypeArgs) ToResourceClassPatchTypeOutput() ResourceClassPatchTypeOutput {
	return i.ToResourceClassPatchTypeOutputWithContext(context.Background())
}

func (i ResourceClassPatchTypeArgs) ToResourceClassPatchTypeOutputWithContext(ctx context.Context) ResourceClassPatchTypeOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceClassPatchTypeOutput)
}

// ResourceClass is used by administrators to influence how resources are allocated.
//
// This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
type ResourceClassPatchTypeOutput struct{ *pulumi.OutputState }

func (ResourceClassPatchTypeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceClassPatchType)(nil)).Elem()
}

func (o ResourceClassPatchTypeOutput) ToResourceClassPatchTypeOutput() ResourceClassPatchTypeOutput {
	return o
}

func (o ResourceClassPatchTypeOutput) ToResourceClassPatchTypeOutputWithContext(ctx context.Context) ResourceClassPatchTypeOutput {
	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 ResourceClassPatchTypeOutput) ApiVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClassPatchType) *string { return v.ApiVersion }).(pulumi.StringPtrOutput)
}

// DriverName defines the name of the dynamic resource driver that is used for allocation of a ResourceClaim that uses this class.
//
// Resource drivers have a unique name in forward domain order (acme.example.com).
func (o ResourceClassPatchTypeOutput) DriverName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClassPatchType) *string { return v.DriverName }).(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 ResourceClassPatchTypeOutput) Kind() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceClassPatchType) *string { return v.Kind }).(pulumi.StringPtrOutput)
}

// Standard object metadata
func (o ResourceClassPatchTypeOutput) Metadata() metav1.ObjectMetaPatchPtrOutput {
	return o.ApplyT(func(v ResourceClassPatchType) *metav1.ObjectMetaPatch { return v.Metadata }).(metav1.ObjectMetaPatchPtrOutput)
}

// ParametersRef references an arbitrary separate object that may hold parameters that will be used by the driver when allocating a resource that uses this class. A dynamic resource driver can distinguish between parameters stored here and and those stored in ResourceClaimSpec.
func (o ResourceClassPatchTypeOutput) ParametersRef() ResourceClassParametersReferencePatchPtrOutput {
	return o.ApplyT(func(v ResourceClassPatchType) *ResourceClassParametersReferencePatch { return v.ParametersRef }).(ResourceClassParametersReferencePatchPtrOutput)
}

// Only nodes matching the selector will be considered by the scheduler when trying to find a Node that fits a Pod when that Pod uses a ResourceClaim that has not been allocated yet.
//
// Setting this field is optional. If null, all nodes are candidates.
func (o ResourceClassPatchTypeOutput) SuitableNodes() corev1.NodeSelectorPatchPtrOutput {
	return o.ApplyT(func(v ResourceClassPatchType) *corev1.NodeSelectorPatch { return v.SuitableNodes }).(corev1.NodeSelectorPatchPtrOutput)
}

// ResourceHandle holds opaque resource data for processing by a specific kubelet plugin.
type ResourceHandle struct {
	// Data contains the opaque data associated with this ResourceHandle. It is set by the controller component of the resource driver whose name matches the DriverName set in the ResourceClaimStatus this ResourceHandle is embedded in. It is set at allocation time and is intended for processing by the kubelet plugin whose name matches the DriverName set in this ResourceHandle.
	//
	// The maximum size of this field is 16KiB. This may get increased in the future, but not reduced.
	Data *string `pulumi:"data"`
	// DriverName specifies the name of the resource driver whose kubelet plugin should be invoked to process this ResourceHandle's data once it lands on a node. This may differ from the DriverName set in ResourceClaimStatus this ResourceHandle is embedded in.
	DriverName *string `pulumi:"driverName"`
}

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

	ToResourceHandleOutput() ResourceHandleOutput
	ToResourceHandleOutputWithContext(context.Context) ResourceHandleOutput
}

// ResourceHandle holds opaque resource data for processing by a specific kubelet plugin.
type ResourceHandleArgs struct {
	// Data contains the opaque data associated with this ResourceHandle. It is set by the controller component of the resource driver whose name matches the DriverName set in the ResourceClaimStatus this ResourceHandle is embedded in. It is set at allocation time and is intended for processing by the kubelet plugin whose name matches the DriverName set in this ResourceHandle.
	//
	// The maximum size of this field is 16KiB. This may get increased in the future, but not reduced.
	Data pulumi.StringPtrInput `pulumi:"data"`
	// DriverName specifies the name of the resource driver whose kubelet plugin should be invoked to process this ResourceHandle's data once it lands on a node. This may differ from the DriverName set in ResourceClaimStatus this ResourceHandle is embedded in.
	DriverName pulumi.StringPtrInput `pulumi:"driverName"`
}

func (ResourceHandleArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceHandle)(nil)).Elem()
}

func (i ResourceHandleArgs) ToResourceHandleOutput() ResourceHandleOutput {
	return i.ToResourceHandleOutputWithContext(context.Background())
}

func (i ResourceHandleArgs) ToResourceHandleOutputWithContext(ctx context.Context) ResourceHandleOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceHandleOutput)
}

// ResourceHandleArrayInput is an input type that accepts ResourceHandleArray and ResourceHandleArrayOutput values.
// You can construct a concrete instance of `ResourceHandleArrayInput` via:
//
//	ResourceHandleArray{ ResourceHandleArgs{...} }
type ResourceHandleArrayInput interface {
	pulumi.Input

	ToResourceHandleArrayOutput() ResourceHandleArrayOutput
	ToResourceHandleArrayOutputWithContext(context.Context) ResourceHandleArrayOutput
}

type ResourceHandleArray []ResourceHandleInput

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

func (i ResourceHandleArray) ToResourceHandleArrayOutput() ResourceHandleArrayOutput {
	return i.ToResourceHandleArrayOutputWithContext(context.Background())
}

func (i ResourceHandleArray) ToResourceHandleArrayOutputWithContext(ctx context.Context) ResourceHandleArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceHandleArrayOutput)
}

// ResourceHandle holds opaque resource data for processing by a specific kubelet plugin.
type ResourceHandleOutput struct{ *pulumi.OutputState }

func (ResourceHandleOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceHandle)(nil)).Elem()
}

func (o ResourceHandleOutput) ToResourceHandleOutput() ResourceHandleOutput {
	return o
}

func (o ResourceHandleOutput) ToResourceHandleOutputWithContext(ctx context.Context) ResourceHandleOutput {
	return o
}

// Data contains the opaque data associated with this ResourceHandle. It is set by the controller component of the resource driver whose name matches the DriverName set in the ResourceClaimStatus this ResourceHandle is embedded in. It is set at allocation time and is intended for processing by the kubelet plugin whose name matches the DriverName set in this ResourceHandle.
//
// The maximum size of this field is 16KiB. This may get increased in the future, but not reduced.
func (o ResourceHandleOutput) Data() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceHandle) *string { return v.Data }).(pulumi.StringPtrOutput)
}

// DriverName specifies the name of the resource driver whose kubelet plugin should be invoked to process this ResourceHandle's data once it lands on a node. This may differ from the DriverName set in ResourceClaimStatus this ResourceHandle is embedded in.
func (o ResourceHandleOutput) DriverName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceHandle) *string { return v.DriverName }).(pulumi.StringPtrOutput)
}

type ResourceHandleArrayOutput struct{ *pulumi.OutputState }

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

func (o ResourceHandleArrayOutput) ToResourceHandleArrayOutput() ResourceHandleArrayOutput {
	return o
}

func (o ResourceHandleArrayOutput) ToResourceHandleArrayOutputWithContext(ctx context.Context) ResourceHandleArrayOutput {
	return o
}

func (o ResourceHandleArrayOutput) Index(i pulumi.IntInput) ResourceHandleOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceHandle {
		return vs[0].([]ResourceHandle)[vs[1].(int)]
	}).(ResourceHandleOutput)
}

// ResourceHandle holds opaque resource data for processing by a specific kubelet plugin.
type ResourceHandlePatch struct {
	// Data contains the opaque data associated with this ResourceHandle. It is set by the controller component of the resource driver whose name matches the DriverName set in the ResourceClaimStatus this ResourceHandle is embedded in. It is set at allocation time and is intended for processing by the kubelet plugin whose name matches the DriverName set in this ResourceHandle.
	//
	// The maximum size of this field is 16KiB. This may get increased in the future, but not reduced.
	Data *string `pulumi:"data"`
	// DriverName specifies the name of the resource driver whose kubelet plugin should be invoked to process this ResourceHandle's data once it lands on a node. This may differ from the DriverName set in ResourceClaimStatus this ResourceHandle is embedded in.
	DriverName *string `pulumi:"driverName"`
}

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

	ToResourceHandlePatchOutput() ResourceHandlePatchOutput
	ToResourceHandlePatchOutputWithContext(context.Context) ResourceHandlePatchOutput
}

// ResourceHandle holds opaque resource data for processing by a specific kubelet plugin.
type ResourceHandlePatchArgs struct {
	// Data contains the opaque data associated with this ResourceHandle. It is set by the controller component of the resource driver whose name matches the DriverName set in the ResourceClaimStatus this ResourceHandle is embedded in. It is set at allocation time and is intended for processing by the kubelet plugin whose name matches the DriverName set in this ResourceHandle.
	//
	// The maximum size of this field is 16KiB. This may get increased in the future, but not reduced.
	Data pulumi.StringPtrInput `pulumi:"data"`
	// DriverName specifies the name of the resource driver whose kubelet plugin should be invoked to process this ResourceHandle's data once it lands on a node. This may differ from the DriverName set in ResourceClaimStatus this ResourceHandle is embedded in.
	DriverName pulumi.StringPtrInput `pulumi:"driverName"`
}

func (ResourceHandlePatchArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceHandlePatch)(nil)).Elem()
}

func (i ResourceHandlePatchArgs) ToResourceHandlePatchOutput() ResourceHandlePatchOutput {
	return i.ToResourceHandlePatchOutputWithContext(context.Background())
}

func (i ResourceHandlePatchArgs) ToResourceHandlePatchOutputWithContext(ctx context.Context) ResourceHandlePatchOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceHandlePatchOutput)
}

// ResourceHandlePatchArrayInput is an input type that accepts ResourceHandlePatchArray and ResourceHandlePatchArrayOutput values.
// You can construct a concrete instance of `ResourceHandlePatchArrayInput` via:
//
//	ResourceHandlePatchArray{ ResourceHandlePatchArgs{...} }
type ResourceHandlePatchArrayInput interface {
	pulumi.Input

	ToResourceHandlePatchArrayOutput() ResourceHandlePatchArrayOutput
	ToResourceHandlePatchArrayOutputWithContext(context.Context) ResourceHandlePatchArrayOutput
}

type ResourceHandlePatchArray []ResourceHandlePatchInput

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

func (i ResourceHandlePatchArray) ToResourceHandlePatchArrayOutput() ResourceHandlePatchArrayOutput {
	return i.ToResourceHandlePatchArrayOutputWithContext(context.Background())
}

func (i ResourceHandlePatchArray) ToResourceHandlePatchArrayOutputWithContext(ctx context.Context) ResourceHandlePatchArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceHandlePatchArrayOutput)
}

// ResourceHandle holds opaque resource data for processing by a specific kubelet plugin.
type ResourceHandlePatchOutput struct{ *pulumi.OutputState }

func (ResourceHandlePatchOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceHandlePatch)(nil)).Elem()
}

func (o ResourceHandlePatchOutput) ToResourceHandlePatchOutput() ResourceHandlePatchOutput {
	return o
}

func (o ResourceHandlePatchOutput) ToResourceHandlePatchOutputWithContext(ctx context.Context) ResourceHandlePatchOutput {
	return o
}

// Data contains the opaque data associated with this ResourceHandle. It is set by the controller component of the resource driver whose name matches the DriverName set in the ResourceClaimStatus this ResourceHandle is embedded in. It is set at allocation time and is intended for processing by the kubelet plugin whose name matches the DriverName set in this ResourceHandle.
//
// The maximum size of this field is 16KiB. This may get increased in the future, but not reduced.
func (o ResourceHandlePatchOutput) Data() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceHandlePatch) *string { return v.Data }).(pulumi.StringPtrOutput)
}

// DriverName specifies the name of the resource driver whose kubelet plugin should be invoked to process this ResourceHandle's data once it lands on a node. This may differ from the DriverName set in ResourceClaimStatus this ResourceHandle is embedded in.
func (o ResourceHandlePatchOutput) DriverName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceHandlePatch) *string { return v.DriverName }).(pulumi.StringPtrOutput)
}

type ResourceHandlePatchArrayOutput struct{ *pulumi.OutputState }

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

func (o ResourceHandlePatchArrayOutput) ToResourceHandlePatchArrayOutput() ResourceHandlePatchArrayOutput {
	return o
}

func (o ResourceHandlePatchArrayOutput) ToResourceHandlePatchArrayOutputWithContext(ctx context.Context) ResourceHandlePatchArrayOutput {
	return o
}

func (o ResourceHandlePatchArrayOutput) Index(i pulumi.IntInput) ResourceHandlePatchOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceHandlePatch {
		return vs[0].([]ResourceHandlePatch)[vs[1].(int)]
	}).(ResourceHandlePatchOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*AllocationResultInput)(nil)).Elem(), AllocationResultArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AllocationResultPtrInput)(nil)).Elem(), AllocationResultArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AllocationResultPatchInput)(nil)).Elem(), AllocationResultPatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AllocationResultPatchPtrInput)(nil)).Elem(), AllocationResultPatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PodSchedulingContextTypeInput)(nil)).Elem(), PodSchedulingContextTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PodSchedulingContextTypeArrayInput)(nil)).Elem(), PodSchedulingContextTypeArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*PodSchedulingContextListTypeInput)(nil)).Elem(), PodSchedulingContextListTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PodSchedulingContextPatchTypeInput)(nil)).Elem(), PodSchedulingContextPatchTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PodSchedulingContextSpecInput)(nil)).Elem(), PodSchedulingContextSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PodSchedulingContextSpecPatchInput)(nil)).Elem(), PodSchedulingContextSpecPatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PodSchedulingContextSpecPatchPtrInput)(nil)).Elem(), PodSchedulingContextSpecPatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PodSchedulingContextStatusInput)(nil)).Elem(), PodSchedulingContextStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PodSchedulingContextStatusPtrInput)(nil)).Elem(), PodSchedulingContextStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PodSchedulingContextStatusPatchInput)(nil)).Elem(), PodSchedulingContextStatusPatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PodSchedulingContextStatusPatchPtrInput)(nil)).Elem(), PodSchedulingContextStatusPatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimTypeInput)(nil)).Elem(), ResourceClaimTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimTypeArrayInput)(nil)).Elem(), ResourceClaimTypeArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimConsumerReferenceInput)(nil)).Elem(), ResourceClaimConsumerReferenceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimConsumerReferenceArrayInput)(nil)).Elem(), ResourceClaimConsumerReferenceArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimConsumerReferencePatchInput)(nil)).Elem(), ResourceClaimConsumerReferencePatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimConsumerReferencePatchArrayInput)(nil)).Elem(), ResourceClaimConsumerReferencePatchArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimListTypeInput)(nil)).Elem(), ResourceClaimListTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimParametersReferenceInput)(nil)).Elem(), ResourceClaimParametersReferenceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimParametersReferencePtrInput)(nil)).Elem(), ResourceClaimParametersReferenceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimParametersReferencePatchInput)(nil)).Elem(), ResourceClaimParametersReferencePatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimParametersReferencePatchPtrInput)(nil)).Elem(), ResourceClaimParametersReferencePatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimPatchTypeInput)(nil)).Elem(), ResourceClaimPatchTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimSchedulingStatusInput)(nil)).Elem(), ResourceClaimSchedulingStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimSchedulingStatusArrayInput)(nil)).Elem(), ResourceClaimSchedulingStatusArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimSchedulingStatusPatchInput)(nil)).Elem(), ResourceClaimSchedulingStatusPatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimSchedulingStatusPatchArrayInput)(nil)).Elem(), ResourceClaimSchedulingStatusPatchArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimSpecInput)(nil)).Elem(), ResourceClaimSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimSpecPatchInput)(nil)).Elem(), ResourceClaimSpecPatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimSpecPatchPtrInput)(nil)).Elem(), ResourceClaimSpecPatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimStatusInput)(nil)).Elem(), ResourceClaimStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimStatusPtrInput)(nil)).Elem(), ResourceClaimStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimStatusPatchInput)(nil)).Elem(), ResourceClaimStatusPatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimStatusPatchPtrInput)(nil)).Elem(), ResourceClaimStatusPatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimTemplateTypeInput)(nil)).Elem(), ResourceClaimTemplateTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimTemplateTypeArrayInput)(nil)).Elem(), ResourceClaimTemplateTypeArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimTemplateListTypeInput)(nil)).Elem(), ResourceClaimTemplateListTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimTemplatePatchTypeInput)(nil)).Elem(), ResourceClaimTemplatePatchTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimTemplateSpecInput)(nil)).Elem(), ResourceClaimTemplateSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimTemplateSpecPatchInput)(nil)).Elem(), ResourceClaimTemplateSpecPatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClaimTemplateSpecPatchPtrInput)(nil)).Elem(), ResourceClaimTemplateSpecPatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClassTypeInput)(nil)).Elem(), ResourceClassTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClassTypeArrayInput)(nil)).Elem(), ResourceClassTypeArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClassListTypeInput)(nil)).Elem(), ResourceClassListTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClassParametersReferenceInput)(nil)).Elem(), ResourceClassParametersReferenceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClassParametersReferencePtrInput)(nil)).Elem(), ResourceClassParametersReferenceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClassParametersReferencePatchInput)(nil)).Elem(), ResourceClassParametersReferencePatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClassParametersReferencePatchPtrInput)(nil)).Elem(), ResourceClassParametersReferencePatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceClassPatchTypeInput)(nil)).Elem(), ResourceClassPatchTypeArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceHandleInput)(nil)).Elem(), ResourceHandleArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceHandleArrayInput)(nil)).Elem(), ResourceHandleArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceHandlePatchInput)(nil)).Elem(), ResourceHandlePatchArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceHandlePatchArrayInput)(nil)).Elem(), ResourceHandlePatchArray{})
	pulumi.RegisterOutputType(AllocationResultOutput{})
	pulumi.RegisterOutputType(AllocationResultPtrOutput{})
	pulumi.RegisterOutputType(AllocationResultPatchOutput{})
	pulumi.RegisterOutputType(AllocationResultPatchPtrOutput{})
	pulumi.RegisterOutputType(PodSchedulingContextTypeOutput{})
	pulumi.RegisterOutputType(PodSchedulingContextTypeArrayOutput{})
	pulumi.RegisterOutputType(PodSchedulingContextListTypeOutput{})
	pulumi.RegisterOutputType(PodSchedulingContextPatchTypeOutput{})
	pulumi.RegisterOutputType(PodSchedulingContextSpecOutput{})
	pulumi.RegisterOutputType(PodSchedulingContextSpecPatchOutput{})
	pulumi.RegisterOutputType(PodSchedulingContextSpecPatchPtrOutput{})
	pulumi.RegisterOutputType(PodSchedulingContextStatusOutput{})
	pulumi.RegisterOutputType(PodSchedulingContextStatusPtrOutput{})
	pulumi.RegisterOutputType(PodSchedulingContextStatusPatchOutput{})
	pulumi.RegisterOutputType(PodSchedulingContextStatusPatchPtrOutput{})
	pulumi.RegisterOutputType(ResourceClaimTypeOutput{})
	pulumi.RegisterOutputType(ResourceClaimTypeArrayOutput{})
	pulumi.RegisterOutputType(ResourceClaimConsumerReferenceOutput{})
	pulumi.RegisterOutputType(ResourceClaimConsumerReferenceArrayOutput{})
	pulumi.RegisterOutputType(ResourceClaimConsumerReferencePatchOutput{})
	pulumi.RegisterOutputType(ResourceClaimConsumerReferencePatchArrayOutput{})
	pulumi.RegisterOutputType(ResourceClaimListTypeOutput{})
	pulumi.RegisterOutputType(ResourceClaimParametersReferenceOutput{})
	pulumi.RegisterOutputType(ResourceClaimParametersReferencePtrOutput{})
	pulumi.RegisterOutputType(ResourceClaimParametersReferencePatchOutput{})
	pulumi.RegisterOutputType(ResourceClaimParametersReferencePatchPtrOutput{})
	pulumi.RegisterOutputType(ResourceClaimPatchTypeOutput{})
	pulumi.RegisterOutputType(ResourceClaimSchedulingStatusOutput{})
	pulumi.RegisterOutputType(ResourceClaimSchedulingStatusArrayOutput{})
	pulumi.RegisterOutputType(ResourceClaimSchedulingStatusPatchOutput{})
	pulumi.RegisterOutputType(ResourceClaimSchedulingStatusPatchArrayOutput{})
	pulumi.RegisterOutputType(ResourceClaimSpecOutput{})
	pulumi.RegisterOutputType(ResourceClaimSpecPatchOutput{})
	pulumi.RegisterOutputType(ResourceClaimSpecPatchPtrOutput{})
	pulumi.RegisterOutputType(ResourceClaimStatusOutput{})
	pulumi.RegisterOutputType(ResourceClaimStatusPtrOutput{})
	pulumi.RegisterOutputType(ResourceClaimStatusPatchOutput{})
	pulumi.RegisterOutputType(ResourceClaimStatusPatchPtrOutput{})
	pulumi.RegisterOutputType(ResourceClaimTemplateTypeOutput{})
	pulumi.RegisterOutputType(ResourceClaimTemplateTypeArrayOutput{})
	pulumi.RegisterOutputType(ResourceClaimTemplateListTypeOutput{})
	pulumi.RegisterOutputType(ResourceClaimTemplatePatchTypeOutput{})
	pulumi.RegisterOutputType(ResourceClaimTemplateSpecOutput{})
	pulumi.RegisterOutputType(ResourceClaimTemplateSpecPatchOutput{})
	pulumi.RegisterOutputType(ResourceClaimTemplateSpecPatchPtrOutput{})
	pulumi.RegisterOutputType(ResourceClassTypeOutput{})
	pulumi.RegisterOutputType(ResourceClassTypeArrayOutput{})
	pulumi.RegisterOutputType(ResourceClassListTypeOutput{})
	pulumi.RegisterOutputType(ResourceClassParametersReferenceOutput{})
	pulumi.RegisterOutputType(ResourceClassParametersReferencePtrOutput{})
	pulumi.RegisterOutputType(ResourceClassParametersReferencePatchOutput{})
	pulumi.RegisterOutputType(ResourceClassParametersReferencePatchPtrOutput{})
	pulumi.RegisterOutputType(ResourceClassPatchTypeOutput{})
	pulumi.RegisterOutputType(ResourceHandleOutput{})
	pulumi.RegisterOutputType(ResourceHandleArrayOutput{})
	pulumi.RegisterOutputType(ResourceHandlePatchOutput{})
	pulumi.RegisterOutputType(ResourceHandlePatchArrayOutput{})
}

license_type: permissive

branch_name: refs/heads/master

extension: go