pulumi-kubernetes 4.10.0a1710288589__py3-none-any.whl → 4.20.0__py3-none-any.whl

pulumi_kubernetes/resource/v1alpha2/_inputs.py

@@ -4,36 +4,143 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from ... import _utilities
 from ... import core as _core
 from ... import meta as _meta
 
 __all__ = [
     'AllocationResultArgs',
+    'AllocationResultArgsDict',
+    'DriverAllocationResultArgs',
+    'DriverAllocationResultArgsDict',
+    'DriverRequestsPatchArgs',
+    'DriverRequestsPatchArgsDict',
+    'DriverRequestsArgs',
+    'DriverRequestsArgsDict',
+    'NamedResourcesAllocationResultArgs',
+    'NamedResourcesAllocationResultArgsDict',
+    'NamedResourcesAttributePatchArgs',
+    'NamedResourcesAttributePatchArgsDict',
+    'NamedResourcesAttributeArgs',
+    'NamedResourcesAttributeArgsDict',
+    'NamedResourcesFilterPatchArgs',
+    'NamedResourcesFilterPatchArgsDict',
+    'NamedResourcesFilterArgs',
+    'NamedResourcesFilterArgsDict',
+    'NamedResourcesInstancePatchArgs',
+    'NamedResourcesInstancePatchArgsDict',
+    'NamedResourcesInstanceArgs',
+    'NamedResourcesInstanceArgsDict',
+    'NamedResourcesIntSlicePatchArgs',
+    'NamedResourcesIntSlicePatchArgsDict',
+    'NamedResourcesIntSliceArgs',
+    'NamedResourcesIntSliceArgsDict',
+    'NamedResourcesRequestPatchArgs',
+    'NamedResourcesRequestPatchArgsDict',
+    'NamedResourcesRequestArgs',
+    'NamedResourcesRequestArgsDict',
+    'NamedResourcesResourcesPatchArgs',
+    'NamedResourcesResourcesPatchArgsDict',
+    'NamedResourcesResourcesArgs',
+    'NamedResourcesResourcesArgsDict',
+    'NamedResourcesStringSlicePatchArgs',
+    'NamedResourcesStringSlicePatchArgsDict',
+    'NamedResourcesStringSliceArgs',
+    'NamedResourcesStringSliceArgsDict',
     'PodSchedulingContextSpecPatchArgs',
+    'PodSchedulingContextSpecPatchArgsDict',
     'PodSchedulingContextSpecArgs',
+    'PodSchedulingContextSpecArgsDict',
     'PodSchedulingContextStatusArgs',
+    'PodSchedulingContextStatusArgsDict',
     'PodSchedulingContextArgs',
+    'PodSchedulingContextArgsDict',
     'ResourceClaimConsumerReferenceArgs',
+    'ResourceClaimConsumerReferenceArgsDict',
     'ResourceClaimParametersReferencePatchArgs',
+    'ResourceClaimParametersReferencePatchArgsDict',
     'ResourceClaimParametersReferenceArgs',
+    'ResourceClaimParametersReferenceArgsDict',
+    'ResourceClaimParametersArgs',
+    'ResourceClaimParametersArgsDict',
     'ResourceClaimSchedulingStatusArgs',
+    'ResourceClaimSchedulingStatusArgsDict',
     'ResourceClaimSpecPatchArgs',
+    'ResourceClaimSpecPatchArgsDict',
     'ResourceClaimSpecArgs',
+    'ResourceClaimSpecArgsDict',
     'ResourceClaimStatusArgs',
+    'ResourceClaimStatusArgsDict',
     'ResourceClaimTemplateSpecPatchArgs',
+    'ResourceClaimTemplateSpecPatchArgsDict',
     'ResourceClaimTemplateSpecArgs',
+    'ResourceClaimTemplateSpecArgsDict',
     'ResourceClaimTemplateArgs',
+    'ResourceClaimTemplateArgsDict',
     'ResourceClaimArgs',
+    'ResourceClaimArgsDict',
     'ResourceClassParametersReferencePatchArgs',
+    'ResourceClassParametersReferencePatchArgsDict',
     'ResourceClassParametersReferenceArgs',
+    'ResourceClassParametersReferenceArgsDict',
+    'ResourceClassParametersArgs',
+    'ResourceClassParametersArgsDict',
     'ResourceClassArgs',
+    'ResourceClassArgsDict',
+    'ResourceFilterPatchArgs',
+    'ResourceFilterPatchArgsDict',
+    'ResourceFilterArgs',
+    'ResourceFilterArgsDict',
     'ResourceHandleArgs',
+    'ResourceHandleArgsDict',
+    'ResourceRequestPatchArgs',
+    'ResourceRequestPatchArgsDict',
+    'ResourceRequestArgs',
+    'ResourceRequestArgsDict',
+    'ResourceSliceArgs',
+    'ResourceSliceArgsDict',
+    'StructuredResourceHandleArgs',
+    'StructuredResourceHandleArgsDict',
+    'VendorParametersPatchArgs',
+    'VendorParametersPatchArgsDict',
+    'VendorParametersArgs',
+    'VendorParametersArgsDict',
 ]
 
+MYPY = False
+
+if not MYPY:
+    class AllocationResultArgsDict(TypedDict):
+        """
+        AllocationResult contains attributes of an allocated resource.
+        """
+        available_on_nodes: NotRequired[pulumi.Input['_core.v1.NodeSelectorArgsDict']]
+        """
+        This field will get set by the resource driver after it has allocated the resource to inform the scheduler where it can schedule Pods using the ResourceClaim.
+
+        Setting this field is optional. If null, the resource is available everywhere.
+        """
+        resource_handles: NotRequired[pulumi.Input[Sequence[pulumi.Input['ResourceHandleArgsDict']]]]
+        """
+        ResourceHandles contain the state associated with an allocation that should be maintained throughout the lifetime of a claim. Each ResourceHandle contains data that should be passed to a specific kubelet plugin once it lands on a node. This data is returned by the driver after a successful allocation and is opaque to Kubernetes. Driver documentation may explain to users how to interpret this data if needed.
+
+        Setting this field is optional. It has a maximum size of 32 entries. If null (or empty), it is assumed this allocation will be processed by a single kubelet plugin with no ResourceHandle data attached. The name of the kubelet plugin invoked will match the DriverName set in the ResourceClaimStatus this AllocationResult is embedded in.
+        """
+        shareable: NotRequired[pulumi.Input[bool]]
+        """
+        Shareable determines whether the resource supports more than one consumer at a time.
+        """
+elif False:
+    AllocationResultArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AllocationResultArgs:
     def __init__(__self__, *,
@@ -98,232 +205,241 @@ class AllocationResultArgs:
         pulumi.set(self, "shareable", value)
 
 
+if not MYPY:
+    class DriverAllocationResultArgsDict(TypedDict):
+        """
+        DriverAllocationResult contains vendor parameters and the allocation result for one request.
+        """
+        named_resources: NotRequired[pulumi.Input['NamedResourcesAllocationResultArgsDict']]
+        """
+        NamedResources describes the allocation result when using the named resources model.
+        """
+        vendor_request_parameters: NotRequired[Any]
+        """
+        VendorRequestParameters are the per-request configuration parameters from the time that the claim was allocated.
+        """
+elif False:
+    DriverAllocationResultArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
-class PodSchedulingContextSpecPatchArgs:
+class DriverAllocationResultArgs:
     def __init__(__self__, *,
-                 potential_nodes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-                 selected_node: Optional[pulumi.Input[str]] = None):
+                 named_resources: Optional[pulumi.Input['NamedResourcesAllocationResultArgs']] = None,
+                 vendor_request_parameters: Optional[Any] = None):
         """
-        PodSchedulingContextSpec describes where resources for the Pod are needed.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] potential_nodes: PotentialNodes lists nodes where the Pod might be able to run.
-               
-               The size of this field is limited to 128. This is large enough for many clusters. Larger clusters may need more attempts to find a node that suits all pending resources. This may get increased in the future, but not reduced.
-        :param pulumi.Input[str] selected_node: SelectedNode is the node for which allocation of ResourceClaims that are referenced by the Pod and that use "WaitForFirstConsumer" allocation is to be attempted.
+        DriverAllocationResult contains vendor parameters and the allocation result for one request.
+        :param pulumi.Input['NamedResourcesAllocationResultArgs'] named_resources: NamedResources describes the allocation result when using the named resources model.
+        :param Any vendor_request_parameters: VendorRequestParameters are the per-request configuration parameters from the time that the claim was allocated.
         """
-        if potential_nodes is not None:
-            pulumi.set(__self__, "potential_nodes", potential_nodes)
-        if selected_node is not None:
-            pulumi.set(__self__, "selected_node", selected_node)
+        if named_resources is not None:
+            pulumi.set(__self__, "named_resources", named_resources)
+        if vendor_request_parameters is not None:
+            pulumi.set(__self__, "vendor_request_parameters", vendor_request_parameters)
 
     @property
-    @pulumi.getter(name="potentialNodes")
-    def potential_nodes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+    @pulumi.getter(name="namedResources")
+    def named_resources(self) -> Optional[pulumi.Input['NamedResourcesAllocationResultArgs']]:
         """
-        PotentialNodes lists nodes where the Pod might be able to run.
-
-        The size of this field is limited to 128. This is large enough for many clusters. Larger clusters may need more attempts to find a node that suits all pending resources. This may get increased in the future, but not reduced.
+        NamedResources describes the allocation result when using the named resources model.
         """
-        return pulumi.get(self, "potential_nodes")
+        return pulumi.get(self, "named_resources")
 
-    @potential_nodes.setter
-    def potential_nodes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
-        pulumi.set(self, "potential_nodes", value)
+    @named_resources.setter
+    def named_resources(self, value: Optional[pulumi.Input['NamedResourcesAllocationResultArgs']]):
+        pulumi.set(self, "named_resources", value)
 
     @property
-    @pulumi.getter(name="selectedNode")
-    def selected_node(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="vendorRequestParameters")
+    def vendor_request_parameters(self) -> Optional[Any]:
         """
-        SelectedNode is the node for which allocation of ResourceClaims that are referenced by the Pod and that use "WaitForFirstConsumer" allocation is to be attempted.
+        VendorRequestParameters are the per-request configuration parameters from the time that the claim was allocated.
         """
-        return pulumi.get(self, "selected_node")
+        return pulumi.get(self, "vendor_request_parameters")
+
+    @vendor_request_parameters.setter
+    def vendor_request_parameters(self, value: Optional[Any]):
+        pulumi.set(self, "vendor_request_parameters", value)
 
-    @selected_node.setter
-    def selected_node(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "selected_node", value)
 
+if not MYPY:
+    class DriverRequestsPatchArgsDict(TypedDict):
+        """
+        DriverRequests describes all resources that are needed from one particular driver.
+        """
+        driver_name: NotRequired[pulumi.Input[str]]
+        """
+        DriverName is the name used by the DRA driver kubelet plugin.
+        """
+        requests: NotRequired[pulumi.Input[Sequence[pulumi.Input['ResourceRequestPatchArgsDict']]]]
+        """
+        Requests describes all resources that are needed from the driver.
+        """
+        vendor_parameters: NotRequired[Any]
+        """
+        VendorParameters are arbitrary setup parameters for all requests of the claim. They are ignored while allocating the claim.
+        """
+elif False:
+    DriverRequestsPatchArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class PodSchedulingContextSpecArgs:
+class DriverRequestsPatchArgs:
     def __init__(__self__, *,
-                 potential_nodes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-                 selected_node: Optional[pulumi.Input[str]] = None):
+                 driver_name: Optional[pulumi.Input[str]] = None,
+                 requests: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceRequestPatchArgs']]]] = None,
+                 vendor_parameters: Optional[Any] = None):
         """
-        PodSchedulingContextSpec describes where resources for the Pod are needed.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] potential_nodes: PotentialNodes lists nodes where the Pod might be able to run.
-               
-               The size of this field is limited to 128. This is large enough for many clusters. Larger clusters may need more attempts to find a node that suits all pending resources. This may get increased in the future, but not reduced.
-        :param pulumi.Input[str] selected_node: SelectedNode is the node for which allocation of ResourceClaims that are referenced by the Pod and that use "WaitForFirstConsumer" allocation is to be attempted.
+        DriverRequests describes all resources that are needed from one particular driver.
+        :param pulumi.Input[str] driver_name: DriverName is the name used by the DRA driver kubelet plugin.
+        :param pulumi.Input[Sequence[pulumi.Input['ResourceRequestPatchArgs']]] requests: Requests describes all resources that are needed from the driver.
+        :param Any vendor_parameters: VendorParameters are arbitrary setup parameters for all requests of the claim. They are ignored while allocating the claim.
         """
-        if potential_nodes is not None:
-            pulumi.set(__self__, "potential_nodes", potential_nodes)
-        if selected_node is not None:
-            pulumi.set(__self__, "selected_node", selected_node)
+        if driver_name is not None:
+            pulumi.set(__self__, "driver_name", driver_name)
+        if requests is not None:
+            pulumi.set(__self__, "requests", requests)
+        if vendor_parameters is not None:
+            pulumi.set(__self__, "vendor_parameters", vendor_parameters)
 
     @property
-    @pulumi.getter(name="potentialNodes")
-    def potential_nodes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+    @pulumi.getter(name="driverName")
+    def driver_name(self) -> Optional[pulumi.Input[str]]:
         """
-        PotentialNodes lists nodes where the Pod might be able to run.
+        DriverName is the name used by the DRA driver kubelet plugin.
+        """
+        return pulumi.get(self, "driver_name")
 
-        The size of this field is limited to 128. This is large enough for many clusters. Larger clusters may need more attempts to find a node that suits all pending resources. This may get increased in the future, but not reduced.
+    @driver_name.setter
+    def driver_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "driver_name", value)
+
+    @property
+    @pulumi.getter
+    def requests(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceRequestPatchArgs']]]]:
         """
-        return pulumi.get(self, "potential_nodes")
+        Requests describes all resources that are needed from the driver.
+        """
+        return pulumi.get(self, "requests")
 
-    @potential_nodes.setter
-    def potential_nodes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
-        pulumi.set(self, "potential_nodes", value)
+    @requests.setter
+    def requests(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceRequestPatchArgs']]]]):
+        pulumi.set(self, "requests", value)
 
     @property
-    @pulumi.getter(name="selectedNode")
-    def selected_node(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="vendorParameters")
+    def vendor_parameters(self) -> Optional[Any]:
         """
-        SelectedNode is the node for which allocation of ResourceClaims that are referenced by the Pod and that use "WaitForFirstConsumer" allocation is to be attempted.
+        VendorParameters are arbitrary setup parameters for all requests of the claim. They are ignored while allocating the claim.
         """
-        return pulumi.get(self, "selected_node")
+        return pulumi.get(self, "vendor_parameters")
 
-    @selected_node.setter
-    def selected_node(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "selected_node", value)
+    @vendor_parameters.setter
+    def vendor_parameters(self, value: Optional[Any]):
+        pulumi.set(self, "vendor_parameters", value)
 
 
-@pulumi.input_type
-class PodSchedulingContextStatusArgs:
-    def __init__(__self__, *,
-                 resource_claims: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceClaimSchedulingStatusArgs']]]] = None):
+if not MYPY:
+    class DriverRequestsArgsDict(TypedDict):
         """
-        PodSchedulingContextStatus describes where resources for the Pod can be allocated.
-        :param pulumi.Input[Sequence[pulumi.Input['ResourceClaimSchedulingStatusArgs']]] resource_claims: ResourceClaims describes resource availability for each pod.spec.resourceClaim entry where the corresponding ResourceClaim uses "WaitForFirstConsumer" allocation mode.
+        DriverRequests describes all resources that are needed from one particular driver.
         """
-        if resource_claims is not None:
-            pulumi.set(__self__, "resource_claims", resource_claims)
-
-    @property
-    @pulumi.getter(name="resourceClaims")
-    def resource_claims(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceClaimSchedulingStatusArgs']]]]:
+        driver_name: NotRequired[pulumi.Input[str]]
         """
-        ResourceClaims describes resource availability for each pod.spec.resourceClaim entry where the corresponding ResourceClaim uses "WaitForFirstConsumer" allocation mode.
+        DriverName is the name used by the DRA driver kubelet plugin.
         """
-        return pulumi.get(self, "resource_claims")
-
-    @resource_claims.setter
-    def resource_claims(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceClaimSchedulingStatusArgs']]]]):
-        pulumi.set(self, "resource_claims", value)
-
+        requests: NotRequired[pulumi.Input[Sequence[pulumi.Input['ResourceRequestArgsDict']]]]
+        """
+        Requests describes all resources that are needed from the driver.
+        """
+        vendor_parameters: NotRequired[Any]
+        """
+        VendorParameters are arbitrary setup parameters for all requests of the claim. They are ignored while allocating the claim.
+        """
+elif False:
+    DriverRequestsArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class PodSchedulingContextArgs:
+class DriverRequestsArgs:
     def __init__(__self__, *,
-                 spec: pulumi.Input['PodSchedulingContextSpecArgs'],
-                 api_version: Optional[pulumi.Input[str]] = None,
-                 kind: Optional[pulumi.Input[str]] = None,
-                 metadata: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']] = None,
-                 status: Optional[pulumi.Input['PodSchedulingContextStatusArgs']] = None):
+                 driver_name: Optional[pulumi.Input[str]] = None,
+                 requests: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceRequestArgs']]]] = None,
+                 vendor_parameters: Optional[Any] = None):
         """
-        PodSchedulingContext objects hold information that is needed to schedule a Pod with ResourceClaims that use "WaitForFirstConsumer" allocation mode.
-
-        This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
-        :param pulumi.Input['PodSchedulingContextSpecArgs'] spec: Spec describes where resources for the Pod are needed.
-        :param pulumi.Input[str] api_version: 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
-        :param pulumi.Input[str] kind: 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
-        :param pulumi.Input['_meta.v1.ObjectMetaArgs'] metadata: Standard object metadata
-        :param pulumi.Input['PodSchedulingContextStatusArgs'] status: Status describes where resources for the Pod can be allocated.
+        DriverRequests describes all resources that are needed from one particular driver.
+        :param pulumi.Input[str] driver_name: DriverName is the name used by the DRA driver kubelet plugin.
+        :param pulumi.Input[Sequence[pulumi.Input['ResourceRequestArgs']]] requests: Requests describes all resources that are needed from the driver.
+        :param Any vendor_parameters: VendorParameters are arbitrary setup parameters for all requests of the claim. They are ignored while allocating the claim.
         """
-        pulumi.set(__self__, "spec", spec)
-        if api_version is not None:
-            pulumi.set(__self__, "api_version", 'resource.k8s.io/v1alpha2')
-        if kind is not None:
-            pulumi.set(__self__, "kind", 'PodSchedulingContext')
-        if metadata is not None:
-            pulumi.set(__self__, "metadata", metadata)
-        if status is not None:
-            pulumi.set(__self__, "status", status)
+        if driver_name is not None:
+            pulumi.set(__self__, "driver_name", driver_name)
+        if requests is not None:
+            pulumi.set(__self__, "requests", requests)
+        if vendor_parameters is not None:
+            pulumi.set(__self__, "vendor_parameters", vendor_parameters)
 
     @property
-    @pulumi.getter
-    def spec(self) -> pulumi.Input['PodSchedulingContextSpecArgs']:
+    @pulumi.getter(name="driverName")
+    def driver_name(self) -> Optional[pulumi.Input[str]]:
         """
-        Spec describes where resources for the Pod are needed.
+        DriverName is the name used by the DRA driver kubelet plugin.
         """
-        return pulumi.get(self, "spec")
+        return pulumi.get(self, "driver_name")
 
-    @spec.setter
-    def spec(self, value: pulumi.Input['PodSchedulingContextSpecArgs']):
-        pulumi.set(self, "spec", value)
+    @driver_name.setter
+    def driver_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "driver_name", value)
 
     @property
-    @pulumi.getter(name="apiVersion")
-    def api_version(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter
+    def requests(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceRequestArgs']]]]:
         """
-        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
+        Requests describes all resources that are needed from the driver.
         """
-        return pulumi.get(self, "api_version")
+        return pulumi.get(self, "requests")
 
-    @api_version.setter
-    def api_version(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "api_version", value)
+    @requests.setter
+    def requests(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceRequestArgs']]]]):
+        pulumi.set(self, "requests", value)
 
     @property
-    @pulumi.getter
-    def kind(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="vendorParameters")
+    def vendor_parameters(self) -> Optional[Any]:
         """
-        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
+        VendorParameters are arbitrary setup parameters for all requests of the claim. They are ignored while allocating the claim.
         """
-        return pulumi.get(self, "kind")
+        return pulumi.get(self, "vendor_parameters")
 
-    @kind.setter
-    def kind(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "kind", value)
+    @vendor_parameters.setter
+    def vendor_parameters(self, value: Optional[Any]):
+        pulumi.set(self, "vendor_parameters", value)
 
-    @property
-    @pulumi.getter
-    def metadata(self) -> Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]:
+
+if not MYPY:
+    class NamedResourcesAllocationResultArgsDict(TypedDict):
         """
-        Standard object metadata
+        NamedResourcesAllocationResult is used in AllocationResultModel.
         """
-        return pulumi.get(self, "metadata")
-
-    @metadata.setter
-    def metadata(self, value: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]):
-        pulumi.set(self, "metadata", value)
-
-    @property
-    @pulumi.getter
-    def status(self) -> Optional[pulumi.Input['PodSchedulingContextStatusArgs']]:
+        name: pulumi.Input[str]
         """
-        Status describes where resources for the Pod can be allocated.
+        Name is the name of the selected resource instance.
         """
-        return pulumi.get(self, "status")
-
-    @status.setter
-    def status(self, value: Optional[pulumi.Input['PodSchedulingContextStatusArgs']]):
-        pulumi.set(self, "status", value)
-
+elif False:
+    NamedResourcesAllocationResultArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class ResourceClaimConsumerReferenceArgs:
+class NamedResourcesAllocationResultArgs:
     def __init__(__self__, *,
-                 name: pulumi.Input[str],
-                 resource: pulumi.Input[str],
-                 uid: pulumi.Input[str],
-                 api_group: Optional[pulumi.Input[str]] = None):
+                 name: pulumi.Input[str]):
         """
-        ResourceClaimConsumerReference contains enough information to let you locate the consumer of a ResourceClaim. The user must be a resource in the same namespace as the ResourceClaim.
-        :param pulumi.Input[str] name: Name is the name of resource being referenced.
-        :param pulumi.Input[str] resource: Resource is the type of resource being referenced, for example "pods".
-        :param pulumi.Input[str] uid: UID identifies exactly one incarnation of the resource.
-        :param pulumi.Input[str] api_group: 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.
+        NamedResourcesAllocationResult is used in AllocationResultModel.
+        :param pulumi.Input[str] name: Name is the name of the selected resource instance.
         """
         pulumi.set(__self__, "name", name)
-        pulumi.set(__self__, "resource", resource)
-        pulumi.set(__self__, "uid", uid)
-        if api_group is not None:
-            pulumi.set(__self__, "api_group", api_group)
 
     @property
     @pulumi.getter
     def name(self) -> pulumi.Input[str]:
         """
-        Name is the name of resource being referenced.
+        Name is the name of the selected resource instance.
         """
         return pulumi.get(self, "name")
 
@@ -331,516 +447,2470 @@ class ResourceClaimConsumerReferenceArgs:
     def name(self, value: pulumi.Input[str]):
         pulumi.set(self, "name", value)
 
+
+if not MYPY:
+    class NamedResourcesAttributePatchArgsDict(TypedDict):
+        """
+        NamedResourcesAttribute is a combination of an attribute name and its value.
+        """
+        bool: NotRequired[pulumi.Input[bool]]
+        """
+        BoolValue is a true/false value.
+        """
+        int: NotRequired[pulumi.Input[int]]
+        """
+        IntValue is a 64-bit integer.
+        """
+        int_slice: NotRequired[pulumi.Input['NamedResourcesIntSlicePatchArgsDict']]
+        """
+        IntSliceValue is an array of 64-bit integers.
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Name is unique identifier among all resource instances managed by the driver on the node. It must be a DNS subdomain.
+        """
+        quantity: NotRequired[pulumi.Input[str]]
+        """
+        QuantityValue is a quantity.
+        """
+        string: NotRequired[pulumi.Input[str]]
+        """
+        StringValue is a string.
+        """
+        string_slice: NotRequired[pulumi.Input['NamedResourcesStringSlicePatchArgsDict']]
+        """
+        StringSliceValue is an array of strings.
+        """
+        version: NotRequired[pulumi.Input[str]]
+        """
+        VersionValue is a semantic version according to semver.org spec 2.0.0.
+        """
+elif False:
+    NamedResourcesAttributePatchArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NamedResourcesAttributePatchArgs:
+    def __init__(__self__, *,
+                 bool: Optional[pulumi.Input[bool]] = None,
+                 int: Optional[pulumi.Input[int]] = None,
+                 int_slice: Optional[pulumi.Input['NamedResourcesIntSlicePatchArgs']] = None,
+                 name: Optional[pulumi.Input[str]] = None,
+                 quantity: Optional[pulumi.Input[str]] = None,
+                 string: Optional[pulumi.Input[str]] = None,
+                 string_slice: Optional[pulumi.Input['NamedResourcesStringSlicePatchArgs']] = None,
+                 version: Optional[pulumi.Input[str]] = None):
+        """
+        NamedResourcesAttribute is a combination of an attribute name and its value.
+        :param pulumi.Input[bool] bool: BoolValue is a true/false value.
+        :param pulumi.Input[int] int: IntValue is a 64-bit integer.
+        :param pulumi.Input['NamedResourcesIntSlicePatchArgs'] int_slice: IntSliceValue is an array of 64-bit integers.
+        :param pulumi.Input[str] name: Name is unique identifier among all resource instances managed by the driver on the node. It must be a DNS subdomain.
+        :param pulumi.Input[str] quantity: QuantityValue is a quantity.
+        :param pulumi.Input[str] string: StringValue is a string.
+        :param pulumi.Input['NamedResourcesStringSlicePatchArgs'] string_slice: StringSliceValue is an array of strings.
+        :param pulumi.Input[str] version: VersionValue is a semantic version according to semver.org spec 2.0.0.
+        """
+        if bool is not None:
+            pulumi.set(__self__, "bool", bool)
+        if int is not None:
+            pulumi.set(__self__, "int", int)
+        if int_slice is not None:
+            pulumi.set(__self__, "int_slice", int_slice)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if quantity is not None:
+            pulumi.set(__self__, "quantity", quantity)
+        if string is not None:
+            pulumi.set(__self__, "string", string)
+        if string_slice is not None:
+            pulumi.set(__self__, "string_slice", string_slice)
+        if version is not None:
+            pulumi.set(__self__, "version", version)
+
     @property
     @pulumi.getter
-    def resource(self) -> pulumi.Input[str]:
+    def bool(self) -> Optional[pulumi.Input[bool]]:
         """
-        Resource is the type of resource being referenced, for example "pods".
+        BoolValue is a true/false value.
         """
-        return pulumi.get(self, "resource")
+        return pulumi.get(self, "bool")
 
-    @resource.setter
-    def resource(self, value: pulumi.Input[str]):
-        pulumi.set(self, "resource", value)
+    @bool.setter
+    def bool(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "bool", value)
 
     @property
     @pulumi.getter
-    def uid(self) -> pulumi.Input[str]:
+    def int(self) -> Optional[pulumi.Input[int]]:
         """
-        UID identifies exactly one incarnation of the resource.
+        IntValue is a 64-bit integer.
         """
-        return pulumi.get(self, "uid")
+        return pulumi.get(self, "int")
 
-    @uid.setter
-    def uid(self, value: pulumi.Input[str]):
-        pulumi.set(self, "uid", value)
+    @int.setter
+    def int(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "int", value)
 
     @property
-    @pulumi.getter(name="apiGroup")
-    def api_group(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="intSlice")
+    def int_slice(self) -> Optional[pulumi.Input['NamedResourcesIntSlicePatchArgs']]:
         """
-        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.
+        IntSliceValue is an array of 64-bit integers.
         """
-        return pulumi.get(self, "api_group")
-
-    @api_group.setter
-    def api_group(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "api_group", value)
+        return pulumi.get(self, "int_slice")
 
+    @int_slice.setter
+    def int_slice(self, value: Optional[pulumi.Input['NamedResourcesIntSlicePatchArgs']]):
+        pulumi.set(self, "int_slice", value)
 
-@pulumi.input_type
-class ResourceClaimParametersReferencePatchArgs:
-    def __init__(__self__, *,
-                 api_group: Optional[pulumi.Input[str]] = None,
-                 kind: Optional[pulumi.Input[str]] = None,
-                 name: Optional[pulumi.Input[str]] = None):
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
         """
-        ResourceClaimParametersReference contains enough information to let you locate the parameters for a ResourceClaim. The object must be in the same namespace as the ResourceClaim.
-        :param pulumi.Input[str] api_group: 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.
-        :param pulumi.Input[str] kind: Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata, for example "ConfigMap".
-        :param pulumi.Input[str] name: Name is the name of resource being referenced.
+        Name is unique identifier among all resource instances managed by the driver on the node. It must be a DNS subdomain.
         """
-        if api_group is not None:
-            pulumi.set(__self__, "api_group", api_group)
-        if kind is not None:
-            pulumi.set(__self__, "kind", kind)
-        if name is not None:
-            pulumi.set(__self__, "name", name)
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
 
     @property
-    @pulumi.getter(name="apiGroup")
-    def api_group(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter
+    def quantity(self) -> Optional[pulumi.Input[str]]:
         """
-        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.
+        QuantityValue is a quantity.
         """
-        return pulumi.get(self, "api_group")
+        return pulumi.get(self, "quantity")
 
-    @api_group.setter
-    def api_group(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "api_group", value)
+    @quantity.setter
+    def quantity(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "quantity", value)
 
     @property
     @pulumi.getter
-    def kind(self) -> Optional[pulumi.Input[str]]:
+    def string(self) -> Optional[pulumi.Input[str]]:
         """
-        Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata, for example "ConfigMap".
+        StringValue is a string.
         """
-        return pulumi.get(self, "kind")
+        return pulumi.get(self, "string")
 
-    @kind.setter
-    def kind(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "kind", value)
+    @string.setter
+    def string(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "string", value)
+
+    @property
+    @pulumi.getter(name="stringSlice")
+    def string_slice(self) -> Optional[pulumi.Input['NamedResourcesStringSlicePatchArgs']]:
+        """
+        StringSliceValue is an array of strings.
+        """
+        return pulumi.get(self, "string_slice")
+
+    @string_slice.setter
+    def string_slice(self, value: Optional[pulumi.Input['NamedResourcesStringSlicePatchArgs']]):
+        pulumi.set(self, "string_slice", value)
 
     @property
     @pulumi.getter
-    def name(self) -> Optional[pulumi.Input[str]]:
+    def version(self) -> Optional[pulumi.Input[str]]:
         """
-        Name is the name of resource being referenced.
+        VersionValue is a semantic version according to semver.org spec 2.0.0.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "version")
+
+    @version.setter
+    def version(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "version", value)
 
-    @name.setter
-    def name(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "name", value)
 
+if not MYPY:
+    class NamedResourcesAttributeArgsDict(TypedDict):
+        """
+        NamedResourcesAttribute is a combination of an attribute name and its value.
+        """
+        name: pulumi.Input[str]
+        """
+        Name is unique identifier among all resource instances managed by the driver on the node. It must be a DNS subdomain.
+        """
+        bool: NotRequired[pulumi.Input[bool]]
+        """
+        BoolValue is a true/false value.
+        """
+        int: NotRequired[pulumi.Input[int]]
+        """
+        IntValue is a 64-bit integer.
+        """
+        int_slice: NotRequired[pulumi.Input['NamedResourcesIntSliceArgsDict']]
+        """
+        IntSliceValue is an array of 64-bit integers.
+        """
+        quantity: NotRequired[pulumi.Input[str]]
+        """
+        QuantityValue is a quantity.
+        """
+        string: NotRequired[pulumi.Input[str]]
+        """
+        StringValue is a string.
+        """
+        string_slice: NotRequired[pulumi.Input['NamedResourcesStringSliceArgsDict']]
+        """
+        StringSliceValue is an array of strings.
+        """
+        version: NotRequired[pulumi.Input[str]]
+        """
+        VersionValue is a semantic version according to semver.org spec 2.0.0.
+        """
+elif False:
+    NamedResourcesAttributeArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class ResourceClaimParametersReferenceArgs:
+class NamedResourcesAttributeArgs:
     def __init__(__self__, *,
-                 kind: pulumi.Input[str],
                  name: pulumi.Input[str],
-                 api_group: Optional[pulumi.Input[str]] = None):
-        """
-        ResourceClaimParametersReference contains enough information to let you locate the parameters for a ResourceClaim. The object must be in the same namespace as the ResourceClaim.
-        :param pulumi.Input[str] kind: Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata, for example "ConfigMap".
-        :param pulumi.Input[str] name: Name is the name of resource being referenced.
-        :param pulumi.Input[str] api_group: 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.
+                 bool: Optional[pulumi.Input[bool]] = None,
+                 int: Optional[pulumi.Input[int]] = None,
+                 int_slice: Optional[pulumi.Input['NamedResourcesIntSliceArgs']] = None,
+                 quantity: Optional[pulumi.Input[str]] = None,
+                 string: Optional[pulumi.Input[str]] = None,
+                 string_slice: Optional[pulumi.Input['NamedResourcesStringSliceArgs']] = None,
+                 version: Optional[pulumi.Input[str]] = None):
+        """
+        NamedResourcesAttribute is a combination of an attribute name and its value.
+        :param pulumi.Input[str] name: Name is unique identifier among all resource instances managed by the driver on the node. It must be a DNS subdomain.
+        :param pulumi.Input[bool] bool: BoolValue is a true/false value.
+        :param pulumi.Input[int] int: IntValue is a 64-bit integer.
+        :param pulumi.Input['NamedResourcesIntSliceArgs'] int_slice: IntSliceValue is an array of 64-bit integers.
+        :param pulumi.Input[str] quantity: QuantityValue is a quantity.
+        :param pulumi.Input[str] string: StringValue is a string.
+        :param pulumi.Input['NamedResourcesStringSliceArgs'] string_slice: StringSliceValue is an array of strings.
+        :param pulumi.Input[str] version: VersionValue is a semantic version according to semver.org spec 2.0.0.
         """
-        pulumi.set(__self__, "kind", kind)
         pulumi.set(__self__, "name", name)
-        if api_group is not None:
-            pulumi.set(__self__, "api_group", api_group)
+        if bool is not None:
+            pulumi.set(__self__, "bool", bool)
+        if int is not None:
+            pulumi.set(__self__, "int", int)
+        if int_slice is not None:
+            pulumi.set(__self__, "int_slice", int_slice)
+        if quantity is not None:
+            pulumi.set(__self__, "quantity", quantity)
+        if string is not None:
+            pulumi.set(__self__, "string", string)
+        if string_slice is not None:
+            pulumi.set(__self__, "string_slice", string_slice)
+        if version is not None:
+            pulumi.set(__self__, "version", version)
 
     @property
     @pulumi.getter
-    def kind(self) -> pulumi.Input[str]:
+    def name(self) -> pulumi.Input[str]:
         """
-        Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata, for example "ConfigMap".
+        Name is unique identifier among all resource instances managed by the driver on the node. It must be a DNS subdomain.
         """
-        return pulumi.get(self, "kind")
+        return pulumi.get(self, "name")
 
-    @kind.setter
-    def kind(self, value: pulumi.Input[str]):
-        pulumi.set(self, "kind", value)
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
 
     @property
     @pulumi.getter
-    def name(self) -> pulumi.Input[str]:
+    def bool(self) -> Optional[pulumi.Input[bool]]:
         """
-        Name is the name of resource being referenced.
+        BoolValue is a true/false value.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "bool")
 
-    @name.setter
-    def name(self, value: pulumi.Input[str]):
-        pulumi.set(self, "name", value)
+    @bool.setter
+    def bool(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "bool", value)
 
     @property
-    @pulumi.getter(name="apiGroup")
-    def api_group(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter
+    def int(self) -> Optional[pulumi.Input[int]]:
         """
-        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.
+        IntValue is a 64-bit integer.
         """
-        return pulumi.get(self, "api_group")
+        return pulumi.get(self, "int")
 
-    @api_group.setter
-    def api_group(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "api_group", value)
+    @int.setter
+    def int(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "int", value)
+
+    @property
+    @pulumi.getter(name="intSlice")
+    def int_slice(self) -> Optional[pulumi.Input['NamedResourcesIntSliceArgs']]:
+        """
+        IntSliceValue is an array of 64-bit integers.
+        """
+        return pulumi.get(self, "int_slice")
 
+    @int_slice.setter
+    def int_slice(self, value: Optional[pulumi.Input['NamedResourcesIntSliceArgs']]):
+        pulumi.set(self, "int_slice", value)
 
-@pulumi.input_type
-class ResourceClaimSchedulingStatusArgs:
-    def __init__(__self__, *,
-                 name: Optional[pulumi.Input[str]] = None,
-                 unsuitable_nodes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+    @property
+    @pulumi.getter
+    def quantity(self) -> Optional[pulumi.Input[str]]:
         """
-        ResourceClaimSchedulingStatus contains information about one particular ResourceClaim with "WaitForFirstConsumer" allocation mode.
-        :param pulumi.Input[str] name: Name matches the pod.spec.resourceClaims[*].Name field.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] unsuitable_nodes: UnsuitableNodes lists nodes that the ResourceClaim cannot be allocated for.
-               
-               The size of this field is limited to 128, the same as for PodSchedulingSpec.PotentialNodes. This may get increased in the future, but not reduced.
+        QuantityValue is a quantity.
         """
-        if name is not None:
-            pulumi.set(__self__, "name", name)
-        if unsuitable_nodes is not None:
-            pulumi.set(__self__, "unsuitable_nodes", unsuitable_nodes)
+        return pulumi.get(self, "quantity")
+
+    @quantity.setter
+    def quantity(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "quantity", value)
 
     @property
     @pulumi.getter
-    def name(self) -> Optional[pulumi.Input[str]]:
+    def string(self) -> Optional[pulumi.Input[str]]:
         """
-        Name matches the pod.spec.resourceClaims[*].Name field.
+        StringValue is a string.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "string")
 
-    @name.setter
-    def name(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "name", value)
+    @string.setter
+    def string(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "string", value)
 
     @property
-    @pulumi.getter(name="unsuitableNodes")
-    def unsuitable_nodes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+    @pulumi.getter(name="stringSlice")
+    def string_slice(self) -> Optional[pulumi.Input['NamedResourcesStringSliceArgs']]:
         """
-        UnsuitableNodes lists nodes that the ResourceClaim cannot be allocated for.
+        StringSliceValue is an array of strings.
+        """
+        return pulumi.get(self, "string_slice")
 
-        The size of this field is limited to 128, the same as for PodSchedulingSpec.PotentialNodes. This may get increased in the future, but not reduced.
+    @string_slice.setter
+    def string_slice(self, value: Optional[pulumi.Input['NamedResourcesStringSliceArgs']]):
+        pulumi.set(self, "string_slice", value)
+
+    @property
+    @pulumi.getter
+    def version(self) -> Optional[pulumi.Input[str]]:
         """
-        return pulumi.get(self, "unsuitable_nodes")
+        VersionValue is a semantic version according to semver.org spec 2.0.0.
+        """
+        return pulumi.get(self, "version")
 
-    @unsuitable_nodes.setter
-    def unsuitable_nodes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
-        pulumi.set(self, "unsuitable_nodes", value)
+    @version.setter
+    def version(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "version", value)
+
+
+if not MYPY:
+    class NamedResourcesFilterPatchArgsDict(TypedDict):
+        """
+        NamedResourcesFilter is used in ResourceFilterModel.
+        """
+        selector: NotRequired[pulumi.Input[str]]
+        """
+        Selector is a CEL expression which must evaluate to true if a resource instance is suitable. The language is as defined in https://kubernetes.io/docs/reference/using-api/cel/
+
+        In addition, for each type NamedResourcesin AttributeValue there is a map that resolves to the corresponding value of the instance under evaluation. For example:
 
+           attributes.quantity["a"].isGreaterThan(quantity("0")) &&
+           attributes.stringslice["b"].isSorted()
+        """
+elif False:
+    NamedResourcesFilterPatchArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class ResourceClaimSpecPatchArgs:
+class NamedResourcesFilterPatchArgs:
     def __init__(__self__, *,
-                 allocation_mode: Optional[pulumi.Input[str]] = None,
-                 parameters_ref: Optional[pulumi.Input['ResourceClaimParametersReferencePatchArgs']] = None,
-                 resource_class_name: Optional[pulumi.Input[str]] = None):
+                 selector: Optional[pulumi.Input[str]] = None):
         """
-        ResourceClaimSpec defines how a resource is to be allocated.
-        :param pulumi.Input[str] allocation_mode: Allocation can start immediately or when a Pod wants to use the resource. "WaitForFirstConsumer" is the default.
-        :param pulumi.Input['ResourceClaimParametersReferencePatchArgs'] parameters_ref: ParametersRef references a separate object with arbitrary parameters that will be used by the driver when allocating a resource for the claim.
+        NamedResourcesFilter is used in ResourceFilterModel.
+        :param pulumi.Input[str] selector: Selector is a CEL expression which must evaluate to true if a resource instance is suitable. The language is as defined in https://kubernetes.io/docs/reference/using-api/cel/
                
-               The object must be in the same namespace as the ResourceClaim.
-        :param pulumi.Input[str] resource_class_name: ResourceClassName references the driver and additional parameters via the name of a ResourceClass that was created as part of the driver deployment.
+               In addition, for each type NamedResourcesin AttributeValue there is a map that resolves to the corresponding value of the instance under evaluation. For example:
+               
+                  attributes.quantity["a"].isGreaterThan(quantity("0")) &&
+                  attributes.stringslice["b"].isSorted()
         """
-        if allocation_mode is not None:
-            pulumi.set(__self__, "allocation_mode", allocation_mode)
-        if parameters_ref is not None:
-            pulumi.set(__self__, "parameters_ref", parameters_ref)
-        if resource_class_name is not None:
-            pulumi.set(__self__, "resource_class_name", resource_class_name)
+        if selector is not None:
+            pulumi.set(__self__, "selector", selector)
 
     @property
-    @pulumi.getter(name="allocationMode")
-    def allocation_mode(self) -> Optional[pulumi.Input[str]]:
-        """
-        Allocation can start immediately or when a Pod wants to use the resource. "WaitForFirstConsumer" is the default.
+    @pulumi.getter
+    def selector(self) -> Optional[pulumi.Input[str]]:
         """
-        return pulumi.get(self, "allocation_mode")
+        Selector is a CEL expression which must evaluate to true if a resource instance is suitable. The language is as defined in https://kubernetes.io/docs/reference/using-api/cel/
 
-    @allocation_mode.setter
-    def allocation_mode(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "allocation_mode", value)
+        In addition, for each type NamedResourcesin AttributeValue there is a map that resolves to the corresponding value of the instance under evaluation. For example:
 
-    @property
-    @pulumi.getter(name="parametersRef")
-    def parameters_ref(self) -> Optional[pulumi.Input['ResourceClaimParametersReferencePatchArgs']]:
+           attributes.quantity["a"].isGreaterThan(quantity("0")) &&
+           attributes.stringslice["b"].isSorted()
         """
-        ParametersRef references a separate object with arbitrary parameters that will be used by the driver when allocating a resource for the claim.
+        return pulumi.get(self, "selector")
 
-        The object must be in the same namespace as the ResourceClaim.
-        """
-        return pulumi.get(self, "parameters_ref")
+    @selector.setter
+    def selector(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "selector", value)
 
-    @parameters_ref.setter
-    def parameters_ref(self, value: Optional[pulumi.Input['ResourceClaimParametersReferencePatchArgs']]):
-        pulumi.set(self, "parameters_ref", value)
 
-    @property
-    @pulumi.getter(name="resourceClassName")
-    def resource_class_name(self) -> Optional[pulumi.Input[str]]:
+if not MYPY:
+    class NamedResourcesFilterArgsDict(TypedDict):
         """
-        ResourceClassName references the driver and additional parameters via the name of a ResourceClass that was created as part of the driver deployment.
+        NamedResourcesFilter is used in ResourceFilterModel.
         """
-        return pulumi.get(self, "resource_class_name")
+        selector: pulumi.Input[str]
+        """
+        Selector is a CEL expression which must evaluate to true if a resource instance is suitable. The language is as defined in https://kubernetes.io/docs/reference/using-api/cel/
 
-    @resource_class_name.setter
-    def resource_class_name(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "resource_class_name", value)
+        In addition, for each type NamedResourcesin AttributeValue there is a map that resolves to the corresponding value of the instance under evaluation. For example:
 
+           attributes.quantity["a"].isGreaterThan(quantity("0")) &&
+           attributes.stringslice["b"].isSorted()
+        """
+elif False:
+    NamedResourcesFilterArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class ResourceClaimSpecArgs:
+class NamedResourcesFilterArgs:
     def __init__(__self__, *,
-                 resource_class_name: pulumi.Input[str],
-                 allocation_mode: Optional[pulumi.Input[str]] = None,
-                 parameters_ref: Optional[pulumi.Input['ResourceClaimParametersReferenceArgs']] = None):
+                 selector: pulumi.Input[str]):
         """
-        ResourceClaimSpec defines how a resource is to be allocated.
-        :param pulumi.Input[str] resource_class_name: ResourceClassName references the driver and additional parameters via the name of a ResourceClass that was created as part of the driver deployment.
-        :param pulumi.Input[str] allocation_mode: Allocation can start immediately or when a Pod wants to use the resource. "WaitForFirstConsumer" is the default.
-        :param pulumi.Input['ResourceClaimParametersReferenceArgs'] parameters_ref: ParametersRef references a separate object with arbitrary parameters that will be used by the driver when allocating a resource for the claim.
+        NamedResourcesFilter is used in ResourceFilterModel.
+        :param pulumi.Input[str] selector: Selector is a CEL expression which must evaluate to true if a resource instance is suitable. The language is as defined in https://kubernetes.io/docs/reference/using-api/cel/
                
-               The object must be in the same namespace as the ResourceClaim.
+               In addition, for each type NamedResourcesin AttributeValue there is a map that resolves to the corresponding value of the instance under evaluation. For example:
+               
+                  attributes.quantity["a"].isGreaterThan(quantity("0")) &&
+                  attributes.stringslice["b"].isSorted()
         """
-        pulumi.set(__self__, "resource_class_name", resource_class_name)
-        if allocation_mode is not None:
-            pulumi.set(__self__, "allocation_mode", allocation_mode)
-        if parameters_ref is not None:
-            pulumi.set(__self__, "parameters_ref", parameters_ref)
+        pulumi.set(__self__, "selector", selector)
 
     @property
-    @pulumi.getter(name="resourceClassName")
-    def resource_class_name(self) -> pulumi.Input[str]:
+    @pulumi.getter
+    def selector(self) -> pulumi.Input[str]:
         """
-        ResourceClassName references the driver and additional parameters via the name of a ResourceClass that was created as part of the driver deployment.
+        Selector is a CEL expression which must evaluate to true if a resource instance is suitable. The language is as defined in https://kubernetes.io/docs/reference/using-api/cel/
+
+        In addition, for each type NamedResourcesin AttributeValue there is a map that resolves to the corresponding value of the instance under evaluation. For example:
+
+           attributes.quantity["a"].isGreaterThan(quantity("0")) &&
+           attributes.stringslice["b"].isSorted()
         """
-        return pulumi.get(self, "resource_class_name")
+        return pulumi.get(self, "selector")
 
-    @resource_class_name.setter
-    def resource_class_name(self, value: pulumi.Input[str]):
-        pulumi.set(self, "resource_class_name", value)
+    @selector.setter
+    def selector(self, value: pulumi.Input[str]):
+        pulumi.set(self, "selector", value)
 
-    @property
-    @pulumi.getter(name="allocationMode")
-    def allocation_mode(self) -> Optional[pulumi.Input[str]]:
+
+if not MYPY:
+    class NamedResourcesInstancePatchArgsDict(TypedDict):
         """
-        Allocation can start immediately or when a Pod wants to use the resource. "WaitForFirstConsumer" is the default.
+        NamedResourcesInstance represents one individual hardware instance that can be selected based on its attributes.
         """
-        return pulumi.get(self, "allocation_mode")
+        attributes: NotRequired[pulumi.Input[Sequence[pulumi.Input['NamedResourcesAttributePatchArgsDict']]]]
+        """
+        Attributes defines the attributes of this resource instance. The name of each attribute must be unique.
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Name is unique identifier among all resource instances managed by the driver on the node. It must be a DNS subdomain.
+        """
+elif False:
+    NamedResourcesInstancePatchArgsDict: TypeAlias = Mapping[str, Any]
 
-    @allocation_mode.setter
-    def allocation_mode(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "allocation_mode", value)
+@pulumi.input_type
+class NamedResourcesInstancePatchArgs:
+    def __init__(__self__, *,
+                 attributes: Optional[pulumi.Input[Sequence[pulumi.Input['NamedResourcesAttributePatchArgs']]]] = None,
+                 name: Optional[pulumi.Input[str]] = None):
+        """
+        NamedResourcesInstance represents one individual hardware instance that can be selected based on its attributes.
+        :param pulumi.Input[Sequence[pulumi.Input['NamedResourcesAttributePatchArgs']]] attributes: Attributes defines the attributes of this resource instance. The name of each attribute must be unique.
+        :param pulumi.Input[str] name: Name is unique identifier among all resource instances managed by the driver on the node. It must be a DNS subdomain.
+        """
+        if attributes is not None:
+            pulumi.set(__self__, "attributes", attributes)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
 
     @property
-    @pulumi.getter(name="parametersRef")
-    def parameters_ref(self) -> Optional[pulumi.Input['ResourceClaimParametersReferenceArgs']]:
+    @pulumi.getter
+    def attributes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NamedResourcesAttributePatchArgs']]]]:
         """
-        ParametersRef references a separate object with arbitrary parameters that will be used by the driver when allocating a resource for the claim.
-
-        The object must be in the same namespace as the ResourceClaim.
+        Attributes defines the attributes of this resource instance. The name of each attribute must be unique.
         """
-        return pulumi.get(self, "parameters_ref")
+        return pulumi.get(self, "attributes")
 
-    @parameters_ref.setter
-    def parameters_ref(self, value: Optional[pulumi.Input['ResourceClaimParametersReferenceArgs']]):
-        pulumi.set(self, "parameters_ref", value)
+    @attributes.setter
+    def attributes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NamedResourcesAttributePatchArgs']]]]):
+        pulumi.set(self, "attributes", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Name is unique identifier among all resource instances managed by the driver on the node. It must be a DNS subdomain.
+        """
+        return pulumi.get(self, "name")
 
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+
+if not MYPY:
+    class NamedResourcesInstanceArgsDict(TypedDict):
+        """
+        NamedResourcesInstance represents one individual hardware instance that can be selected based on its attributes.
+        """
+        name: pulumi.Input[str]
+        """
+        Name is unique identifier among all resource instances managed by the driver on the node. It must be a DNS subdomain.
+        """
+        attributes: NotRequired[pulumi.Input[Sequence[pulumi.Input['NamedResourcesAttributeArgsDict']]]]
+        """
+        Attributes defines the attributes of this resource instance. The name of each attribute must be unique.
+        """
+elif False:
+    NamedResourcesInstanceArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class ResourceClaimStatusArgs:
+class NamedResourcesInstanceArgs:
     def __init__(__self__, *,
-                 allocation: Optional[pulumi.Input['AllocationResultArgs']] = None,
-                 deallocation_requested: Optional[pulumi.Input[bool]] = None,
-                 driver_name: Optional[pulumi.Input[str]] = None,
-                 reserved_for: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceClaimConsumerReferenceArgs']]]] = None):
+                 name: pulumi.Input[str],
+                 attributes: Optional[pulumi.Input[Sequence[pulumi.Input['NamedResourcesAttributeArgs']]]] = None):
         """
-        ResourceClaimStatus tracks whether the resource has been allocated and what the resulting attributes are.
-        :param pulumi.Input['AllocationResultArgs'] allocation: 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.
-        :param pulumi.Input[bool] deallocation_requested: 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.
-        :param pulumi.Input[str] driver_name: DriverName is a copy of the driver name from the ResourceClass at the time when allocation started.
-        :param pulumi.Input[Sequence[pulumi.Input['ResourceClaimConsumerReferenceArgs']]] reserved_for: 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.
+        NamedResourcesInstance represents one individual hardware instance that can be selected based on its attributes.
+        :param pulumi.Input[str] name: Name is unique identifier among all resource instances managed by the driver on the node. It must be a DNS subdomain.
+        :param pulumi.Input[Sequence[pulumi.Input['NamedResourcesAttributeArgs']]] attributes: Attributes defines the attributes of this resource instance. The name of each attribute must be unique.
         """
-        if allocation is not None:
-            pulumi.set(__self__, "allocation", allocation)
-        if deallocation_requested is not None:
-            pulumi.set(__self__, "deallocation_requested", deallocation_requested)
-        if driver_name is not None:
-            pulumi.set(__self__, "driver_name", driver_name)
-        if reserved_for is not None:
-            pulumi.set(__self__, "reserved_for", reserved_for)
+        pulumi.set(__self__, "name", name)
+        if attributes is not None:
+            pulumi.set(__self__, "attributes", attributes)
 
     @property
     @pulumi.getter
-    def allocation(self) -> Optional[pulumi.Input['AllocationResultArgs']]:
+    def name(self) -> pulumi.Input[str]:
         """
-        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.
+        Name is unique identifier among all resource instances managed by the driver on the node. It must be a DNS subdomain.
         """
-        return pulumi.get(self, "allocation")
+        return pulumi.get(self, "name")
 
-    @allocation.setter
-    def allocation(self, value: Optional[pulumi.Input['AllocationResultArgs']]):
-        pulumi.set(self, "allocation", value)
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
 
     @property
-    @pulumi.getter(name="deallocationRequested")
-    def deallocation_requested(self) -> Optional[pulumi.Input[bool]]:
+    @pulumi.getter
+    def attributes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NamedResourcesAttributeArgs']]]]:
         """
-        DeallocationRequested indicates that a ResourceClaim is to be deallocated.
+        Attributes defines the attributes of this resource instance. The name of each attribute must be unique.
+        """
+        return pulumi.get(self, "attributes")
 
-        The driver then must deallocate this claim and reset the field together with clearing the Allocation field.
+    @attributes.setter
+    def attributes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NamedResourcesAttributeArgs']]]]):
+        pulumi.set(self, "attributes", value)
 
-        While DeallocationRequested is set, no new consumers may be added to ReservedFor.
+
+if not MYPY:
+    class NamedResourcesIntSlicePatchArgsDict(TypedDict):
         """
-        return pulumi.get(self, "deallocation_requested")
+        NamedResourcesIntSlice contains a slice of 64-bit integers.
+        """
+        ints: NotRequired[pulumi.Input[Sequence[pulumi.Input[int]]]]
+        """
+        Ints is the slice of 64-bit integers.
+        """
+elif False:
+    NamedResourcesIntSlicePatchArgsDict: TypeAlias = Mapping[str, Any]
 
-    @deallocation_requested.setter
-    def deallocation_requested(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "deallocation_requested", value)
+@pulumi.input_type
+class NamedResourcesIntSlicePatchArgs:
+    def __init__(__self__, *,
+                 ints: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None):
+        """
+        NamedResourcesIntSlice contains a slice of 64-bit integers.
+        :param pulumi.Input[Sequence[pulumi.Input[int]]] ints: Ints is the slice of 64-bit integers.
+        """
+        if ints is not None:
+            pulumi.set(__self__, "ints", ints)
 
     @property
-    @pulumi.getter(name="driverName")
-    def driver_name(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter
+    def ints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
         """
-        DriverName is a copy of the driver name from the ResourceClass at the time when allocation started.
+        Ints is the slice of 64-bit integers.
         """
-        return pulumi.get(self, "driver_name")
+        return pulumi.get(self, "ints")
 
-    @driver_name.setter
-    def driver_name(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "driver_name", value)
+    @ints.setter
+    def ints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
+        pulumi.set(self, "ints", value)
+
+
+if not MYPY:
+    class NamedResourcesIntSliceArgsDict(TypedDict):
+        """
+        NamedResourcesIntSlice contains a slice of 64-bit integers.
+        """
+        ints: pulumi.Input[Sequence[pulumi.Input[int]]]
+        """
+        Ints is the slice of 64-bit integers.
+        """
+elif False:
+    NamedResourcesIntSliceArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NamedResourcesIntSliceArgs:
+    def __init__(__self__, *,
+                 ints: pulumi.Input[Sequence[pulumi.Input[int]]]):
+        """
+        NamedResourcesIntSlice contains a slice of 64-bit integers.
+        :param pulumi.Input[Sequence[pulumi.Input[int]]] ints: Ints is the slice of 64-bit integers.
+        """
+        pulumi.set(__self__, "ints", ints)
 
     @property
-    @pulumi.getter(name="reservedFor")
-    def reserved_for(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceClaimConsumerReferenceArgs']]]]:
+    @pulumi.getter
+    def ints(self) -> pulumi.Input[Sequence[pulumi.Input[int]]]:
         """
-        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.
+        Ints is the slice of 64-bit integers.
+        """
+        return pulumi.get(self, "ints")
 
-        There can be at most 32 such reservations. This may get increased in the future, but not reduced.
+    @ints.setter
+    def ints(self, value: pulumi.Input[Sequence[pulumi.Input[int]]]):
+        pulumi.set(self, "ints", value)
+
+
+if not MYPY:
+    class NamedResourcesRequestPatchArgsDict(TypedDict):
         """
-        return pulumi.get(self, "reserved_for")
+        NamedResourcesRequest is used in ResourceRequestModel.
+        """
+        selector: NotRequired[pulumi.Input[str]]
+        """
+        Selector is a CEL expression which must evaluate to true if a resource instance is suitable. The language is as defined in https://kubernetes.io/docs/reference/using-api/cel/
 
-    @reserved_for.setter
-    def reserved_for(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceClaimConsumerReferenceArgs']]]]):
-        pulumi.set(self, "reserved_for", value)
+        In addition, for each type NamedResourcesin AttributeValue there is a map that resolves to the corresponding value of the instance under evaluation. For example:
 
+           attributes.quantity["a"].isGreaterThan(quantity("0")) &&
+           attributes.stringslice["b"].isSorted()
+        """
+elif False:
+    NamedResourcesRequestPatchArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class ResourceClaimTemplateSpecPatchArgs:
+class NamedResourcesRequestPatchArgs:
     def __init__(__self__, *,
-                 metadata: Optional[pulumi.Input['_meta.v1.ObjectMetaPatchArgs']] = None,
-                 spec: Optional[pulumi.Input['ResourceClaimSpecPatchArgs']] = None):
+                 selector: Optional[pulumi.Input[str]] = None):
         """
-        ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim.
-        :param pulumi.Input['_meta.v1.ObjectMetaPatchArgs'] metadata: 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.
-        :param pulumi.Input['ResourceClaimSpecPatchArgs'] spec: 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.
+        NamedResourcesRequest is used in ResourceRequestModel.
+        :param pulumi.Input[str] selector: Selector is a CEL expression which must evaluate to true if a resource instance is suitable. The language is as defined in https://kubernetes.io/docs/reference/using-api/cel/
+               
+               In addition, for each type NamedResourcesin AttributeValue there is a map that resolves to the corresponding value of the instance under evaluation. For example:
+               
+                  attributes.quantity["a"].isGreaterThan(quantity("0")) &&
+                  attributes.stringslice["b"].isSorted()
         """
-        if metadata is not None:
-            pulumi.set(__self__, "metadata", metadata)
-        if spec is not None:
-            pulumi.set(__self__, "spec", spec)
+        if selector is not None:
+            pulumi.set(__self__, "selector", selector)
 
     @property
     @pulumi.getter
-    def metadata(self) -> Optional[pulumi.Input['_meta.v1.ObjectMetaPatchArgs']]:
+    def selector(self) -> Optional[pulumi.Input[str]]:
         """
-        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.
+        Selector is a CEL expression which must evaluate to true if a resource instance is suitable. The language is as defined in https://kubernetes.io/docs/reference/using-api/cel/
+
+        In addition, for each type NamedResourcesin AttributeValue there is a map that resolves to the corresponding value of the instance under evaluation. For example:
+
+           attributes.quantity["a"].isGreaterThan(quantity("0")) &&
+           attributes.stringslice["b"].isSorted()
         """
-        return pulumi.get(self, "metadata")
+        return pulumi.get(self, "selector")
 
-    @metadata.setter
-    def metadata(self, value: Optional[pulumi.Input['_meta.v1.ObjectMetaPatchArgs']]):
-        pulumi.set(self, "metadata", value)
+    @selector.setter
+    def selector(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "selector", value)
+
+
+if not MYPY:
+    class NamedResourcesRequestArgsDict(TypedDict):
+        """
+        NamedResourcesRequest is used in ResourceRequestModel.
+        """
+        selector: pulumi.Input[str]
+        """
+        Selector is a CEL expression which must evaluate to true if a resource instance is suitable. The language is as defined in https://kubernetes.io/docs/reference/using-api/cel/
+
+        In addition, for each type NamedResourcesin AttributeValue there is a map that resolves to the corresponding value of the instance under evaluation. For example:
+
+           attributes.quantity["a"].isGreaterThan(quantity("0")) &&
+           attributes.stringslice["b"].isSorted()
+        """
+elif False:
+    NamedResourcesRequestArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NamedResourcesRequestArgs:
+    def __init__(__self__, *,
+                 selector: pulumi.Input[str]):
+        """
+        NamedResourcesRequest is used in ResourceRequestModel.
+        :param pulumi.Input[str] selector: Selector is a CEL expression which must evaluate to true if a resource instance is suitable. The language is as defined in https://kubernetes.io/docs/reference/using-api/cel/
+               
+               In addition, for each type NamedResourcesin AttributeValue there is a map that resolves to the corresponding value of the instance under evaluation. For example:
+               
+                  attributes.quantity["a"].isGreaterThan(quantity("0")) &&
+                  attributes.stringslice["b"].isSorted()
+        """
+        pulumi.set(__self__, "selector", selector)
 
     @property
     @pulumi.getter
-    def spec(self) -> Optional[pulumi.Input['ResourceClaimSpecPatchArgs']]:
+    def selector(self) -> pulumi.Input[str]:
         """
-        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.
+        Selector is a CEL expression which must evaluate to true if a resource instance is suitable. The language is as defined in https://kubernetes.io/docs/reference/using-api/cel/
+
+        In addition, for each type NamedResourcesin AttributeValue there is a map that resolves to the corresponding value of the instance under evaluation. For example:
+
+           attributes.quantity["a"].isGreaterThan(quantity("0")) &&
+           attributes.stringslice["b"].isSorted()
         """
-        return pulumi.get(self, "spec")
+        return pulumi.get(self, "selector")
 
-    @spec.setter
-    def spec(self, value: Optional[pulumi.Input['ResourceClaimSpecPatchArgs']]):
-        pulumi.set(self, "spec", value)
+    @selector.setter
+    def selector(self, value: pulumi.Input[str]):
+        pulumi.set(self, "selector", value)
 
 
+if not MYPY:
+    class NamedResourcesResourcesPatchArgsDict(TypedDict):
+        """
+        NamedResourcesResources is used in ResourceModel.
+        """
+        instances: NotRequired[pulumi.Input[Sequence[pulumi.Input['NamedResourcesInstancePatchArgsDict']]]]
+        """
+        The list of all individual resources instances currently available.
+        """
+elif False:
+    NamedResourcesResourcesPatchArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
-class ResourceClaimTemplateSpecArgs:
+class NamedResourcesResourcesPatchArgs:
     def __init__(__self__, *,
-                 spec: pulumi.Input['ResourceClaimSpecArgs'],
-                 metadata: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']] = None):
+                 instances: Optional[pulumi.Input[Sequence[pulumi.Input['NamedResourcesInstancePatchArgs']]]] = None):
         """
-        ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim.
-        :param pulumi.Input['ResourceClaimSpecArgs'] spec: 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.
-        :param pulumi.Input['_meta.v1.ObjectMetaArgs'] metadata: 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.
+        NamedResourcesResources is used in ResourceModel.
+        :param pulumi.Input[Sequence[pulumi.Input['NamedResourcesInstancePatchArgs']]] instances: The list of all individual resources instances currently available.
         """
-        pulumi.set(__self__, "spec", spec)
-        if metadata is not None:
-            pulumi.set(__self__, "metadata", metadata)
+        if instances is not None:
+            pulumi.set(__self__, "instances", instances)
 
     @property
     @pulumi.getter
-    def spec(self) -> pulumi.Input['ResourceClaimSpecArgs']:
+    def instances(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NamedResourcesInstancePatchArgs']]]]:
         """
-        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.
+        The list of all individual resources instances currently available.
         """
-        return pulumi.get(self, "spec")
+        return pulumi.get(self, "instances")
 
-    @spec.setter
-    def spec(self, value: pulumi.Input['ResourceClaimSpecArgs']):
-        pulumi.set(self, "spec", value)
+    @instances.setter
+    def instances(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NamedResourcesInstancePatchArgs']]]]):
+        pulumi.set(self, "instances", value)
+
+
+if not MYPY:
+    class NamedResourcesResourcesArgsDict(TypedDict):
+        """
+        NamedResourcesResources is used in ResourceModel.
+        """
+        instances: pulumi.Input[Sequence[pulumi.Input['NamedResourcesInstanceArgsDict']]]
+        """
+        The list of all individual resources instances currently available.
+        """
+elif False:
+    NamedResourcesResourcesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NamedResourcesResourcesArgs:
+    def __init__(__self__, *,
+                 instances: pulumi.Input[Sequence[pulumi.Input['NamedResourcesInstanceArgs']]]):
+        """
+        NamedResourcesResources is used in ResourceModel.
+        :param pulumi.Input[Sequence[pulumi.Input['NamedResourcesInstanceArgs']]] instances: The list of all individual resources instances currently available.
+        """
+        pulumi.set(__self__, "instances", instances)
 
     @property
     @pulumi.getter
-    def metadata(self) -> Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]:
+    def instances(self) -> pulumi.Input[Sequence[pulumi.Input['NamedResourcesInstanceArgs']]]:
+        """
+        The list of all individual resources instances currently available.
+        """
+        return pulumi.get(self, "instances")
+
+    @instances.setter
+    def instances(self, value: pulumi.Input[Sequence[pulumi.Input['NamedResourcesInstanceArgs']]]):
+        pulumi.set(self, "instances", value)
+
+
+if not MYPY:
+    class NamedResourcesStringSlicePatchArgsDict(TypedDict):
+        """
+        NamedResourcesStringSlice contains a slice of strings.
+        """
+        strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Strings is the slice of strings.
+        """
+elif False:
+    NamedResourcesStringSlicePatchArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NamedResourcesStringSlicePatchArgs:
+    def __init__(__self__, *,
+                 strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        NamedResourcesStringSlice contains a slice of strings.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] strings: Strings is the slice of strings.
+        """
+        if strings is not None:
+            pulumi.set(__self__, "strings", strings)
+
+    @property
+    @pulumi.getter
+    def strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Strings is the slice of strings.
+        """
+        return pulumi.get(self, "strings")
+
+    @strings.setter
+    def strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "strings", value)
+
+
+if not MYPY:
+    class NamedResourcesStringSliceArgsDict(TypedDict):
+        """
+        NamedResourcesStringSlice contains a slice of strings.
+        """
+        strings: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        Strings is the slice of strings.
+        """
+elif False:
+    NamedResourcesStringSliceArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NamedResourcesStringSliceArgs:
+    def __init__(__self__, *,
+                 strings: pulumi.Input[Sequence[pulumi.Input[str]]]):
+        """
+        NamedResourcesStringSlice contains a slice of strings.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] strings: Strings is the slice of strings.
+        """
+        pulumi.set(__self__, "strings", strings)
+
+    @property
+    @pulumi.getter
+    def strings(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
+        """
+        Strings is the slice of strings.
+        """
+        return pulumi.get(self, "strings")
+
+    @strings.setter
+    def strings(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
+        pulumi.set(self, "strings", value)
+
+
+if not MYPY:
+    class PodSchedulingContextSpecPatchArgsDict(TypedDict):
+        """
+        PodSchedulingContextSpec describes where resources for the Pod are needed.
+        """
+        potential_nodes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        PotentialNodes lists nodes where the Pod might be able to run.
+
+        The size of this field is limited to 128. This is large enough for many clusters. Larger clusters may need more attempts to find a node that suits all pending resources. This may get increased in the future, but not reduced.
+        """
+        selected_node: NotRequired[pulumi.Input[str]]
+        """
+        SelectedNode is the node for which allocation of ResourceClaims that are referenced by the Pod and that use "WaitForFirstConsumer" allocation is to be attempted.
+        """
+elif False:
+    PodSchedulingContextSpecPatchArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PodSchedulingContextSpecPatchArgs:
+    def __init__(__self__, *,
+                 potential_nodes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 selected_node: Optional[pulumi.Input[str]] = None):
+        """
+        PodSchedulingContextSpec describes where resources for the Pod are needed.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] potential_nodes: PotentialNodes lists nodes where the Pod might be able to run.
+               
+               The size of this field is limited to 128. This is large enough for many clusters. Larger clusters may need more attempts to find a node that suits all pending resources. This may get increased in the future, but not reduced.
+        :param pulumi.Input[str] selected_node: SelectedNode is the node for which allocation of ResourceClaims that are referenced by the Pod and that use "WaitForFirstConsumer" allocation is to be attempted.
+        """
+        if potential_nodes is not None:
+            pulumi.set(__self__, "potential_nodes", potential_nodes)
+        if selected_node is not None:
+            pulumi.set(__self__, "selected_node", selected_node)
+
+    @property
+    @pulumi.getter(name="potentialNodes")
+    def potential_nodes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        PotentialNodes lists nodes where the Pod might be able to run.
+
+        The size of this field is limited to 128. This is large enough for many clusters. Larger clusters may need more attempts to find a node that suits all pending resources. This may get increased in the future, but not reduced.
+        """
+        return pulumi.get(self, "potential_nodes")
+
+    @potential_nodes.setter
+    def potential_nodes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "potential_nodes", value)
+
+    @property
+    @pulumi.getter(name="selectedNode")
+    def selected_node(self) -> Optional[pulumi.Input[str]]:
+        """
+        SelectedNode is the node for which allocation of ResourceClaims that are referenced by the Pod and that use "WaitForFirstConsumer" allocation is to be attempted.
+        """
+        return pulumi.get(self, "selected_node")
+
+    @selected_node.setter
+    def selected_node(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "selected_node", value)
+
+
+if not MYPY:
+    class PodSchedulingContextSpecArgsDict(TypedDict):
+        """
+        PodSchedulingContextSpec describes where resources for the Pod are needed.
+        """
+        potential_nodes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        PotentialNodes lists nodes where the Pod might be able to run.
+
+        The size of this field is limited to 128. This is large enough for many clusters. Larger clusters may need more attempts to find a node that suits all pending resources. This may get increased in the future, but not reduced.
+        """
+        selected_node: NotRequired[pulumi.Input[str]]
+        """
+        SelectedNode is the node for which allocation of ResourceClaims that are referenced by the Pod and that use "WaitForFirstConsumer" allocation is to be attempted.
+        """
+elif False:
+    PodSchedulingContextSpecArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PodSchedulingContextSpecArgs:
+    def __init__(__self__, *,
+                 potential_nodes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 selected_node: Optional[pulumi.Input[str]] = None):
+        """
+        PodSchedulingContextSpec describes where resources for the Pod are needed.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] potential_nodes: PotentialNodes lists nodes where the Pod might be able to run.
+               
+               The size of this field is limited to 128. This is large enough for many clusters. Larger clusters may need more attempts to find a node that suits all pending resources. This may get increased in the future, but not reduced.
+        :param pulumi.Input[str] selected_node: SelectedNode is the node for which allocation of ResourceClaims that are referenced by the Pod and that use "WaitForFirstConsumer" allocation is to be attempted.
+        """
+        if potential_nodes is not None:
+            pulumi.set(__self__, "potential_nodes", potential_nodes)
+        if selected_node is not None:
+            pulumi.set(__self__, "selected_node", selected_node)
+
+    @property
+    @pulumi.getter(name="potentialNodes")
+    def potential_nodes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        PotentialNodes lists nodes where the Pod might be able to run.
+
+        The size of this field is limited to 128. This is large enough for many clusters. Larger clusters may need more attempts to find a node that suits all pending resources. This may get increased in the future, but not reduced.
+        """
+        return pulumi.get(self, "potential_nodes")
+
+    @potential_nodes.setter
+    def potential_nodes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "potential_nodes", value)
+
+    @property
+    @pulumi.getter(name="selectedNode")
+    def selected_node(self) -> Optional[pulumi.Input[str]]:
+        """
+        SelectedNode is the node for which allocation of ResourceClaims that are referenced by the Pod and that use "WaitForFirstConsumer" allocation is to be attempted.
+        """
+        return pulumi.get(self, "selected_node")
+
+    @selected_node.setter
+    def selected_node(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "selected_node", value)
+
+
+if not MYPY:
+    class PodSchedulingContextStatusArgsDict(TypedDict):
+        """
+        PodSchedulingContextStatus describes where resources for the Pod can be allocated.
+        """
+        resource_claims: NotRequired[pulumi.Input[Sequence[pulumi.Input['ResourceClaimSchedulingStatusArgsDict']]]]
+        """
+        ResourceClaims describes resource availability for each pod.spec.resourceClaim entry where the corresponding ResourceClaim uses "WaitForFirstConsumer" allocation mode.
+        """
+elif False:
+    PodSchedulingContextStatusArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PodSchedulingContextStatusArgs:
+    def __init__(__self__, *,
+                 resource_claims: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceClaimSchedulingStatusArgs']]]] = None):
+        """
+        PodSchedulingContextStatus describes where resources for the Pod can be allocated.
+        :param pulumi.Input[Sequence[pulumi.Input['ResourceClaimSchedulingStatusArgs']]] resource_claims: ResourceClaims describes resource availability for each pod.spec.resourceClaim entry where the corresponding ResourceClaim uses "WaitForFirstConsumer" allocation mode.
+        """
+        if resource_claims is not None:
+            pulumi.set(__self__, "resource_claims", resource_claims)
+
+    @property
+    @pulumi.getter(name="resourceClaims")
+    def resource_claims(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceClaimSchedulingStatusArgs']]]]:
+        """
+        ResourceClaims describes resource availability for each pod.spec.resourceClaim entry where the corresponding ResourceClaim uses "WaitForFirstConsumer" allocation mode.
+        """
+        return pulumi.get(self, "resource_claims")
+
+    @resource_claims.setter
+    def resource_claims(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceClaimSchedulingStatusArgs']]]]):
+        pulumi.set(self, "resource_claims", value)
+
+
+if not MYPY:
+    class PodSchedulingContextArgsDict(TypedDict):
+        """
+        PodSchedulingContext objects hold information that is needed to schedule a Pod with ResourceClaims that use "WaitForFirstConsumer" allocation mode.
+
+        This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
+        """
+        spec: pulumi.Input['PodSchedulingContextSpecArgsDict']
+        """
+        Spec describes where resources for the Pod are needed.
+        """
+        api_version: NotRequired[pulumi.Input[str]]
+        """
+        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
+        """
+        kind: NotRequired[pulumi.Input[str]]
+        """
+        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
+        """
+        metadata: NotRequired[pulumi.Input['_meta.v1.ObjectMetaArgsDict']]
+        """
+        Standard object metadata
+        """
+        status: NotRequired[pulumi.Input['PodSchedulingContextStatusArgsDict']]
+        """
+        Status describes where resources for the Pod can be allocated.
+        """
+elif False:
+    PodSchedulingContextArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class PodSchedulingContextArgs:
+    def __init__(__self__, *,
+                 spec: pulumi.Input['PodSchedulingContextSpecArgs'],
+                 api_version: Optional[pulumi.Input[str]] = None,
+                 kind: Optional[pulumi.Input[str]] = None,
+                 metadata: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']] = None,
+                 status: Optional[pulumi.Input['PodSchedulingContextStatusArgs']] = None):
+        """
+        PodSchedulingContext objects hold information that is needed to schedule a Pod with ResourceClaims that use "WaitForFirstConsumer" allocation mode.
+
+        This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
+        :param pulumi.Input['PodSchedulingContextSpecArgs'] spec: Spec describes where resources for the Pod are needed.
+        :param pulumi.Input[str] api_version: 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
+        :param pulumi.Input[str] kind: 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
+        :param pulumi.Input['_meta.v1.ObjectMetaArgs'] metadata: Standard object metadata
+        :param pulumi.Input['PodSchedulingContextStatusArgs'] status: Status describes where resources for the Pod can be allocated.
+        """
+        pulumi.set(__self__, "spec", spec)
+        if api_version is not None:
+            pulumi.set(__self__, "api_version", 'resource.k8s.io/v1alpha2')
+        if kind is not None:
+            pulumi.set(__self__, "kind", 'PodSchedulingContext')
+        if metadata is not None:
+            pulumi.set(__self__, "metadata", metadata)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter
+    def spec(self) -> pulumi.Input['PodSchedulingContextSpecArgs']:
+        """
+        Spec describes where resources for the Pod are needed.
+        """
+        return pulumi.get(self, "spec")
+
+    @spec.setter
+    def spec(self, value: pulumi.Input['PodSchedulingContextSpecArgs']):
+        pulumi.set(self, "spec", value)
+
+    @property
+    @pulumi.getter(name="apiVersion")
+    def api_version(self) -> Optional[pulumi.Input[str]]:
+        """
+        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
+        """
+        return pulumi.get(self, "api_version")
+
+    @api_version.setter
+    def api_version(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_version", value)
+
+    @property
+    @pulumi.getter
+    def kind(self) -> Optional[pulumi.Input[str]]:
+        """
+        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
+        """
+        return pulumi.get(self, "kind")
+
+    @kind.setter
+    def kind(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "kind", value)
+
+    @property
+    @pulumi.getter
+    def metadata(self) -> Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]:
+        """
+        Standard object metadata
+        """
+        return pulumi.get(self, "metadata")
+
+    @metadata.setter
+    def metadata(self, value: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]):
+        pulumi.set(self, "metadata", value)
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[pulumi.Input['PodSchedulingContextStatusArgs']]:
+        """
+        Status describes where resources for the Pod can be allocated.
+        """
+        return pulumi.get(self, "status")
+
+    @status.setter
+    def status(self, value: Optional[pulumi.Input['PodSchedulingContextStatusArgs']]):
+        pulumi.set(self, "status", value)
+
+
+if not MYPY:
+    class ResourceClaimConsumerReferenceArgsDict(TypedDict):
+        """
+        ResourceClaimConsumerReference contains enough information to let you locate the consumer of a ResourceClaim. The user must be a resource in the same namespace as the ResourceClaim.
+        """
+        name: pulumi.Input[str]
+        """
+        Name is the name of resource being referenced.
+        """
+        resource: pulumi.Input[str]
+        """
+        Resource is the type of resource being referenced, for example "pods".
+        """
+        uid: pulumi.Input[str]
+        """
+        UID identifies exactly one incarnation of the resource.
+        """
+        api_group: NotRequired[pulumi.Input[str]]
+        """
+        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.
+        """
+elif False:
+    ResourceClaimConsumerReferenceArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceClaimConsumerReferenceArgs:
+    def __init__(__self__, *,
+                 name: pulumi.Input[str],
+                 resource: pulumi.Input[str],
+                 uid: pulumi.Input[str],
+                 api_group: Optional[pulumi.Input[str]] = None):
+        """
+        ResourceClaimConsumerReference contains enough information to let you locate the consumer of a ResourceClaim. The user must be a resource in the same namespace as the ResourceClaim.
+        :param pulumi.Input[str] name: Name is the name of resource being referenced.
+        :param pulumi.Input[str] resource: Resource is the type of resource being referenced, for example "pods".
+        :param pulumi.Input[str] uid: UID identifies exactly one incarnation of the resource.
+        :param pulumi.Input[str] api_group: 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.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "resource", resource)
+        pulumi.set(__self__, "uid", uid)
+        if api_group is not None:
+            pulumi.set(__self__, "api_group", api_group)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[str]:
+        """
+        Name is the name of resource being referenced.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def resource(self) -> pulumi.Input[str]:
+        """
+        Resource is the type of resource being referenced, for example "pods".
+        """
+        return pulumi.get(self, "resource")
+
+    @resource.setter
+    def resource(self, value: pulumi.Input[str]):
+        pulumi.set(self, "resource", value)
+
+    @property
+    @pulumi.getter
+    def uid(self) -> pulumi.Input[str]:
+        """
+        UID identifies exactly one incarnation of the resource.
+        """
+        return pulumi.get(self, "uid")
+
+    @uid.setter
+    def uid(self, value: pulumi.Input[str]):
+        pulumi.set(self, "uid", value)
+
+    @property
+    @pulumi.getter(name="apiGroup")
+    def api_group(self) -> Optional[pulumi.Input[str]]:
+        """
+        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.
+        """
+        return pulumi.get(self, "api_group")
+
+    @api_group.setter
+    def api_group(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_group", value)
+
+
+if not MYPY:
+    class ResourceClaimParametersReferencePatchArgsDict(TypedDict):
+        """
+        ResourceClaimParametersReference contains enough information to let you locate the parameters for a ResourceClaim. The object must be in the same namespace as the ResourceClaim.
+        """
+        api_group: NotRequired[pulumi.Input[str]]
+        """
+        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.
+        """
+        kind: NotRequired[pulumi.Input[str]]
+        """
+        Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata, for example "ConfigMap".
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Name is the name of resource being referenced.
+        """
+elif False:
+    ResourceClaimParametersReferencePatchArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceClaimParametersReferencePatchArgs:
+    def __init__(__self__, *,
+                 api_group: Optional[pulumi.Input[str]] = None,
+                 kind: Optional[pulumi.Input[str]] = None,
+                 name: Optional[pulumi.Input[str]] = None):
+        """
+        ResourceClaimParametersReference contains enough information to let you locate the parameters for a ResourceClaim. The object must be in the same namespace as the ResourceClaim.
+        :param pulumi.Input[str] api_group: 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.
+        :param pulumi.Input[str] kind: Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata, for example "ConfigMap".
+        :param pulumi.Input[str] name: Name is the name of resource being referenced.
+        """
+        if api_group is not None:
+            pulumi.set(__self__, "api_group", api_group)
+        if kind is not None:
+            pulumi.set(__self__, "kind", kind)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter(name="apiGroup")
+    def api_group(self) -> Optional[pulumi.Input[str]]:
+        """
+        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.
+        """
+        return pulumi.get(self, "api_group")
+
+    @api_group.setter
+    def api_group(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_group", value)
+
+    @property
+    @pulumi.getter
+    def kind(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata, for example "ConfigMap".
+        """
+        return pulumi.get(self, "kind")
+
+    @kind.setter
+    def kind(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "kind", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Name is the name of resource being referenced.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+
+if not MYPY:
+    class ResourceClaimParametersReferenceArgsDict(TypedDict):
+        """
+        ResourceClaimParametersReference contains enough information to let you locate the parameters for a ResourceClaim. The object must be in the same namespace as the ResourceClaim.
+        """
+        kind: pulumi.Input[str]
+        """
+        Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata, for example "ConfigMap".
+        """
+        name: pulumi.Input[str]
+        """
+        Name is the name of resource being referenced.
+        """
+        api_group: NotRequired[pulumi.Input[str]]
+        """
+        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.
+        """
+elif False:
+    ResourceClaimParametersReferenceArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceClaimParametersReferenceArgs:
+    def __init__(__self__, *,
+                 kind: pulumi.Input[str],
+                 name: pulumi.Input[str],
+                 api_group: Optional[pulumi.Input[str]] = None):
+        """
+        ResourceClaimParametersReference contains enough information to let you locate the parameters for a ResourceClaim. The object must be in the same namespace as the ResourceClaim.
+        :param pulumi.Input[str] kind: Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata, for example "ConfigMap".
+        :param pulumi.Input[str] name: Name is the name of resource being referenced.
+        :param pulumi.Input[str] api_group: 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.
+        """
+        pulumi.set(__self__, "kind", kind)
+        pulumi.set(__self__, "name", name)
+        if api_group is not None:
+            pulumi.set(__self__, "api_group", api_group)
+
+    @property
+    @pulumi.getter
+    def kind(self) -> pulumi.Input[str]:
+        """
+        Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata, for example "ConfigMap".
+        """
+        return pulumi.get(self, "kind")
+
+    @kind.setter
+    def kind(self, value: pulumi.Input[str]):
+        pulumi.set(self, "kind", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[str]:
+        """
+        Name is the name of resource being referenced.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter(name="apiGroup")
+    def api_group(self) -> Optional[pulumi.Input[str]]:
+        """
+        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.
+        """
+        return pulumi.get(self, "api_group")
+
+    @api_group.setter
+    def api_group(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_group", value)
+
+
+if not MYPY:
+    class ResourceClaimParametersArgsDict(TypedDict):
+        """
+        ResourceClaimParameters defines resource requests for a ResourceClaim in an in-tree format understood by Kubernetes.
+        """
+        api_version: NotRequired[pulumi.Input[str]]
+        """
+        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
+        """
+        driver_requests: NotRequired[pulumi.Input[Sequence[pulumi.Input['DriverRequestsArgsDict']]]]
+        """
+        DriverRequests describes all resources that are needed for the allocated claim. A single claim may use resources coming from different drivers. For each driver, this array has at most one entry which then may have one or more per-driver requests.
+
+        May be empty, in which case the claim can always be allocated.
+        """
+        generated_from: NotRequired[pulumi.Input['ResourceClaimParametersReferenceArgsDict']]
+        """
+        If this object was created from some other resource, then this links back to that resource. This field is used to find the in-tree representation of the claim parameters when the parameter reference of the claim refers to some unknown type.
+        """
+        kind: NotRequired[pulumi.Input[str]]
+        """
+        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
+        """
+        metadata: NotRequired[pulumi.Input['_meta.v1.ObjectMetaArgsDict']]
+        """
+        Standard object metadata
+        """
+        shareable: NotRequired[pulumi.Input[bool]]
+        """
+        Shareable indicates whether the allocated claim is meant to be shareable by multiple consumers at the same time.
+        """
+elif False:
+    ResourceClaimParametersArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceClaimParametersArgs:
+    def __init__(__self__, *,
+                 api_version: Optional[pulumi.Input[str]] = None,
+                 driver_requests: Optional[pulumi.Input[Sequence[pulumi.Input['DriverRequestsArgs']]]] = None,
+                 generated_from: Optional[pulumi.Input['ResourceClaimParametersReferenceArgs']] = None,
+                 kind: Optional[pulumi.Input[str]] = None,
+                 metadata: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']] = None,
+                 shareable: Optional[pulumi.Input[bool]] = None):
+        """
+        ResourceClaimParameters defines resource requests for a ResourceClaim in an in-tree format understood by Kubernetes.
+        :param pulumi.Input[str] api_version: 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
+        :param pulumi.Input[Sequence[pulumi.Input['DriverRequestsArgs']]] driver_requests: DriverRequests describes all resources that are needed for the allocated claim. A single claim may use resources coming from different drivers. For each driver, this array has at most one entry which then may have one or more per-driver requests.
+               
+               May be empty, in which case the claim can always be allocated.
+        :param pulumi.Input['ResourceClaimParametersReferenceArgs'] generated_from: If this object was created from some other resource, then this links back to that resource. This field is used to find the in-tree representation of the claim parameters when the parameter reference of the claim refers to some unknown type.
+        :param pulumi.Input[str] kind: 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
+        :param pulumi.Input['_meta.v1.ObjectMetaArgs'] metadata: Standard object metadata
+        :param pulumi.Input[bool] shareable: Shareable indicates whether the allocated claim is meant to be shareable by multiple consumers at the same time.
+        """
+        if api_version is not None:
+            pulumi.set(__self__, "api_version", 'resource.k8s.io/v1alpha2')
+        if driver_requests is not None:
+            pulumi.set(__self__, "driver_requests", driver_requests)
+        if generated_from is not None:
+            pulumi.set(__self__, "generated_from", generated_from)
+        if kind is not None:
+            pulumi.set(__self__, "kind", 'ResourceClaimParameters')
+        if metadata is not None:
+            pulumi.set(__self__, "metadata", metadata)
+        if shareable is not None:
+            pulumi.set(__self__, "shareable", shareable)
+
+    @property
+    @pulumi.getter(name="apiVersion")
+    def api_version(self) -> Optional[pulumi.Input[str]]:
+        """
+        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
+        """
+        return pulumi.get(self, "api_version")
+
+    @api_version.setter
+    def api_version(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_version", value)
+
+    @property
+    @pulumi.getter(name="driverRequests")
+    def driver_requests(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DriverRequestsArgs']]]]:
+        """
+        DriverRequests describes all resources that are needed for the allocated claim. A single claim may use resources coming from different drivers. For each driver, this array has at most one entry which then may have one or more per-driver requests.
+
+        May be empty, in which case the claim can always be allocated.
+        """
+        return pulumi.get(self, "driver_requests")
+
+    @driver_requests.setter
+    def driver_requests(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DriverRequestsArgs']]]]):
+        pulumi.set(self, "driver_requests", value)
+
+    @property
+    @pulumi.getter(name="generatedFrom")
+    def generated_from(self) -> Optional[pulumi.Input['ResourceClaimParametersReferenceArgs']]:
+        """
+        If this object was created from some other resource, then this links back to that resource. This field is used to find the in-tree representation of the claim parameters when the parameter reference of the claim refers to some unknown type.
+        """
+        return pulumi.get(self, "generated_from")
+
+    @generated_from.setter
+    def generated_from(self, value: Optional[pulumi.Input['ResourceClaimParametersReferenceArgs']]):
+        pulumi.set(self, "generated_from", value)
+
+    @property
+    @pulumi.getter
+    def kind(self) -> Optional[pulumi.Input[str]]:
+        """
+        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
+        """
+        return pulumi.get(self, "kind")
+
+    @kind.setter
+    def kind(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "kind", value)
+
+    @property
+    @pulumi.getter
+    def metadata(self) -> Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]:
+        """
+        Standard object metadata
+        """
+        return pulumi.get(self, "metadata")
+
+    @metadata.setter
+    def metadata(self, value: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]):
+        pulumi.set(self, "metadata", value)
+
+    @property
+    @pulumi.getter
+    def shareable(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Shareable indicates whether the allocated claim is meant to be shareable by multiple consumers at the same time.
+        """
+        return pulumi.get(self, "shareable")
+
+    @shareable.setter
+    def shareable(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "shareable", value)
+
+
+if not MYPY:
+    class ResourceClaimSchedulingStatusArgsDict(TypedDict):
+        """
+        ResourceClaimSchedulingStatus contains information about one particular ResourceClaim with "WaitForFirstConsumer" allocation mode.
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Name matches the pod.spec.resourceClaims[*].Name field.
+        """
+        unsuitable_nodes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        UnsuitableNodes lists nodes that the ResourceClaim cannot be allocated for.
+
+        The size of this field is limited to 128, the same as for PodSchedulingSpec.PotentialNodes. This may get increased in the future, but not reduced.
+        """
+elif False:
+    ResourceClaimSchedulingStatusArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceClaimSchedulingStatusArgs:
+    def __init__(__self__, *,
+                 name: Optional[pulumi.Input[str]] = None,
+                 unsuitable_nodes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        ResourceClaimSchedulingStatus contains information about one particular ResourceClaim with "WaitForFirstConsumer" allocation mode.
+        :param pulumi.Input[str] name: Name matches the pod.spec.resourceClaims[*].Name field.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] unsuitable_nodes: UnsuitableNodes lists nodes that the ResourceClaim cannot be allocated for.
+               
+               The size of this field is limited to 128, the same as for PodSchedulingSpec.PotentialNodes. This may get increased in the future, but not reduced.
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if unsuitable_nodes is not None:
+            pulumi.set(__self__, "unsuitable_nodes", unsuitable_nodes)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Name matches the pod.spec.resourceClaims[*].Name field.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter(name="unsuitableNodes")
+    def unsuitable_nodes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        UnsuitableNodes lists nodes that the ResourceClaim cannot be allocated for.
+
+        The size of this field is limited to 128, the same as for PodSchedulingSpec.PotentialNodes. This may get increased in the future, but not reduced.
+        """
+        return pulumi.get(self, "unsuitable_nodes")
+
+    @unsuitable_nodes.setter
+    def unsuitable_nodes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "unsuitable_nodes", value)
+
+
+if not MYPY:
+    class ResourceClaimSpecPatchArgsDict(TypedDict):
+        """
+        ResourceClaimSpec defines how a resource is to be allocated.
+        """
+        allocation_mode: NotRequired[pulumi.Input[str]]
+        """
+        Allocation can start immediately or when a Pod wants to use the resource. "WaitForFirstConsumer" is the default.
+        """
+        parameters_ref: NotRequired[pulumi.Input['ResourceClaimParametersReferencePatchArgsDict']]
+        """
+        ParametersRef references a separate object with arbitrary parameters that will be used by the driver when allocating a resource for the claim.
+
+        The object must be in the same namespace as the ResourceClaim.
+        """
+        resource_class_name: NotRequired[pulumi.Input[str]]
+        """
+        ResourceClassName references the driver and additional parameters via the name of a ResourceClass that was created as part of the driver deployment.
+        """
+elif False:
+    ResourceClaimSpecPatchArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceClaimSpecPatchArgs:
+    def __init__(__self__, *,
+                 allocation_mode: Optional[pulumi.Input[str]] = None,
+                 parameters_ref: Optional[pulumi.Input['ResourceClaimParametersReferencePatchArgs']] = None,
+                 resource_class_name: Optional[pulumi.Input[str]] = None):
+        """
+        ResourceClaimSpec defines how a resource is to be allocated.
+        :param pulumi.Input[str] allocation_mode: Allocation can start immediately or when a Pod wants to use the resource. "WaitForFirstConsumer" is the default.
+        :param pulumi.Input['ResourceClaimParametersReferencePatchArgs'] parameters_ref: ParametersRef references a separate object with arbitrary parameters that will be used by the driver when allocating a resource for the claim.
+               
+               The object must be in the same namespace as the ResourceClaim.
+        :param pulumi.Input[str] resource_class_name: ResourceClassName references the driver and additional parameters via the name of a ResourceClass that was created as part of the driver deployment.
+        """
+        if allocation_mode is not None:
+            pulumi.set(__self__, "allocation_mode", allocation_mode)
+        if parameters_ref is not None:
+            pulumi.set(__self__, "parameters_ref", parameters_ref)
+        if resource_class_name is not None:
+            pulumi.set(__self__, "resource_class_name", resource_class_name)
+
+    @property
+    @pulumi.getter(name="allocationMode")
+    def allocation_mode(self) -> Optional[pulumi.Input[str]]:
+        """
+        Allocation can start immediately or when a Pod wants to use the resource. "WaitForFirstConsumer" is the default.
+        """
+        return pulumi.get(self, "allocation_mode")
+
+    @allocation_mode.setter
+    def allocation_mode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "allocation_mode", value)
+
+    @property
+    @pulumi.getter(name="parametersRef")
+    def parameters_ref(self) -> Optional[pulumi.Input['ResourceClaimParametersReferencePatchArgs']]:
+        """
+        ParametersRef references a separate object with arbitrary parameters that will be used by the driver when allocating a resource for the claim.
+
+        The object must be in the same namespace as the ResourceClaim.
+        """
+        return pulumi.get(self, "parameters_ref")
+
+    @parameters_ref.setter
+    def parameters_ref(self, value: Optional[pulumi.Input['ResourceClaimParametersReferencePatchArgs']]):
+        pulumi.set(self, "parameters_ref", value)
+
+    @property
+    @pulumi.getter(name="resourceClassName")
+    def resource_class_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        ResourceClassName references the driver and additional parameters via the name of a ResourceClass that was created as part of the driver deployment.
+        """
+        return pulumi.get(self, "resource_class_name")
+
+    @resource_class_name.setter
+    def resource_class_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "resource_class_name", value)
+
+
+if not MYPY:
+    class ResourceClaimSpecArgsDict(TypedDict):
+        """
+        ResourceClaimSpec defines how a resource is to be allocated.
+        """
+        resource_class_name: pulumi.Input[str]
+        """
+        ResourceClassName references the driver and additional parameters via the name of a ResourceClass that was created as part of the driver deployment.
+        """
+        allocation_mode: NotRequired[pulumi.Input[str]]
+        """
+        Allocation can start immediately or when a Pod wants to use the resource. "WaitForFirstConsumer" is the default.
+        """
+        parameters_ref: NotRequired[pulumi.Input['ResourceClaimParametersReferenceArgsDict']]
+        """
+        ParametersRef references a separate object with arbitrary parameters that will be used by the driver when allocating a resource for the claim.
+
+        The object must be in the same namespace as the ResourceClaim.
+        """
+elif False:
+    ResourceClaimSpecArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceClaimSpecArgs:
+    def __init__(__self__, *,
+                 resource_class_name: pulumi.Input[str],
+                 allocation_mode: Optional[pulumi.Input[str]] = None,
+                 parameters_ref: Optional[pulumi.Input['ResourceClaimParametersReferenceArgs']] = None):
+        """
+        ResourceClaimSpec defines how a resource is to be allocated.
+        :param pulumi.Input[str] resource_class_name: ResourceClassName references the driver and additional parameters via the name of a ResourceClass that was created as part of the driver deployment.
+        :param pulumi.Input[str] allocation_mode: Allocation can start immediately or when a Pod wants to use the resource. "WaitForFirstConsumer" is the default.
+        :param pulumi.Input['ResourceClaimParametersReferenceArgs'] parameters_ref: ParametersRef references a separate object with arbitrary parameters that will be used by the driver when allocating a resource for the claim.
+               
+               The object must be in the same namespace as the ResourceClaim.
+        """
+        pulumi.set(__self__, "resource_class_name", resource_class_name)
+        if allocation_mode is not None:
+            pulumi.set(__self__, "allocation_mode", allocation_mode)
+        if parameters_ref is not None:
+            pulumi.set(__self__, "parameters_ref", parameters_ref)
+
+    @property
+    @pulumi.getter(name="resourceClassName")
+    def resource_class_name(self) -> pulumi.Input[str]:
+        """
+        ResourceClassName references the driver and additional parameters via the name of a ResourceClass that was created as part of the driver deployment.
+        """
+        return pulumi.get(self, "resource_class_name")
+
+    @resource_class_name.setter
+    def resource_class_name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "resource_class_name", value)
+
+    @property
+    @pulumi.getter(name="allocationMode")
+    def allocation_mode(self) -> Optional[pulumi.Input[str]]:
+        """
+        Allocation can start immediately or when a Pod wants to use the resource. "WaitForFirstConsumer" is the default.
+        """
+        return pulumi.get(self, "allocation_mode")
+
+    @allocation_mode.setter
+    def allocation_mode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "allocation_mode", value)
+
+    @property
+    @pulumi.getter(name="parametersRef")
+    def parameters_ref(self) -> Optional[pulumi.Input['ResourceClaimParametersReferenceArgs']]:
+        """
+        ParametersRef references a separate object with arbitrary parameters that will be used by the driver when allocating a resource for the claim.
+
+        The object must be in the same namespace as the ResourceClaim.
+        """
+        return pulumi.get(self, "parameters_ref")
+
+    @parameters_ref.setter
+    def parameters_ref(self, value: Optional[pulumi.Input['ResourceClaimParametersReferenceArgs']]):
+        pulumi.set(self, "parameters_ref", value)
+
+
+if not MYPY:
+    class ResourceClaimStatusArgsDict(TypedDict):
+        """
+        ResourceClaimStatus tracks whether the resource has been allocated and what the resulting attributes are.
+        """
+        allocation: NotRequired[pulumi.Input['AllocationResultArgsDict']]
+        """
+        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.
+        """
+        deallocation_requested: NotRequired[pulumi.Input[bool]]
+        """
+        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.
+        """
+        driver_name: NotRequired[pulumi.Input[str]]
+        """
+        DriverName is a copy of the driver name from the ResourceClass at the time when allocation started.
+        """
+        reserved_for: NotRequired[pulumi.Input[Sequence[pulumi.Input['ResourceClaimConsumerReferenceArgsDict']]]]
+        """
+        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.
+        """
+elif False:
+    ResourceClaimStatusArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceClaimStatusArgs:
+    def __init__(__self__, *,
+                 allocation: Optional[pulumi.Input['AllocationResultArgs']] = None,
+                 deallocation_requested: Optional[pulumi.Input[bool]] = None,
+                 driver_name: Optional[pulumi.Input[str]] = None,
+                 reserved_for: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceClaimConsumerReferenceArgs']]]] = None):
+        """
+        ResourceClaimStatus tracks whether the resource has been allocated and what the resulting attributes are.
+        :param pulumi.Input['AllocationResultArgs'] allocation: 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.
+        :param pulumi.Input[bool] deallocation_requested: 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.
+        :param pulumi.Input[str] driver_name: DriverName is a copy of the driver name from the ResourceClass at the time when allocation started.
+        :param pulumi.Input[Sequence[pulumi.Input['ResourceClaimConsumerReferenceArgs']]] reserved_for: 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.
+        """
+        if allocation is not None:
+            pulumi.set(__self__, "allocation", allocation)
+        if deallocation_requested is not None:
+            pulumi.set(__self__, "deallocation_requested", deallocation_requested)
+        if driver_name is not None:
+            pulumi.set(__self__, "driver_name", driver_name)
+        if reserved_for is not None:
+            pulumi.set(__self__, "reserved_for", reserved_for)
+
+    @property
+    @pulumi.getter
+    def allocation(self) -> Optional[pulumi.Input['AllocationResultArgs']]:
+        """
+        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.
+        """
+        return pulumi.get(self, "allocation")
+
+    @allocation.setter
+    def allocation(self, value: Optional[pulumi.Input['AllocationResultArgs']]):
+        pulumi.set(self, "allocation", value)
+
+    @property
+    @pulumi.getter(name="deallocationRequested")
+    def deallocation_requested(self) -> Optional[pulumi.Input[bool]]:
+        """
+        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.
+        """
+        return pulumi.get(self, "deallocation_requested")
+
+    @deallocation_requested.setter
+    def deallocation_requested(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "deallocation_requested", value)
+
+    @property
+    @pulumi.getter(name="driverName")
+    def driver_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        DriverName is a copy of the driver name from the ResourceClass at the time when allocation started.
+        """
+        return pulumi.get(self, "driver_name")
+
+    @driver_name.setter
+    def driver_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "driver_name", value)
+
+    @property
+    @pulumi.getter(name="reservedFor")
+    def reserved_for(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceClaimConsumerReferenceArgs']]]]:
+        """
+        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.
+        """
+        return pulumi.get(self, "reserved_for")
+
+    @reserved_for.setter
+    def reserved_for(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceClaimConsumerReferenceArgs']]]]):
+        pulumi.set(self, "reserved_for", value)
+
+
+if not MYPY:
+    class ResourceClaimTemplateSpecPatchArgsDict(TypedDict):
+        """
+        ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim.
+        """
+        metadata: NotRequired[pulumi.Input['_meta.v1.ObjectMetaPatchArgsDict']]
+        """
+        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.
+        """
+        spec: NotRequired[pulumi.Input['ResourceClaimSpecPatchArgsDict']]
+        """
+        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.
+        """
+elif False:
+    ResourceClaimTemplateSpecPatchArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceClaimTemplateSpecPatchArgs:
+    def __init__(__self__, *,
+                 metadata: Optional[pulumi.Input['_meta.v1.ObjectMetaPatchArgs']] = None,
+                 spec: Optional[pulumi.Input['ResourceClaimSpecPatchArgs']] = None):
+        """
+        ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim.
+        :param pulumi.Input['_meta.v1.ObjectMetaPatchArgs'] metadata: 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.
+        :param pulumi.Input['ResourceClaimSpecPatchArgs'] spec: 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.
+        """
+        if metadata is not None:
+            pulumi.set(__self__, "metadata", metadata)
+        if spec is not None:
+            pulumi.set(__self__, "spec", spec)
+
+    @property
+    @pulumi.getter
+    def metadata(self) -> Optional[pulumi.Input['_meta.v1.ObjectMetaPatchArgs']]:
+        """
+        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.
+        """
+        return pulumi.get(self, "metadata")
+
+    @metadata.setter
+    def metadata(self, value: Optional[pulumi.Input['_meta.v1.ObjectMetaPatchArgs']]):
+        pulumi.set(self, "metadata", value)
+
+    @property
+    @pulumi.getter
+    def spec(self) -> Optional[pulumi.Input['ResourceClaimSpecPatchArgs']]:
+        """
+        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.
+        """
+        return pulumi.get(self, "spec")
+
+    @spec.setter
+    def spec(self, value: Optional[pulumi.Input['ResourceClaimSpecPatchArgs']]):
+        pulumi.set(self, "spec", value)
+
+
+if not MYPY:
+    class ResourceClaimTemplateSpecArgsDict(TypedDict):
+        """
+        ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim.
+        """
+        spec: pulumi.Input['ResourceClaimSpecArgsDict']
+        """
+        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.
+        """
+        metadata: NotRequired[pulumi.Input['_meta.v1.ObjectMetaArgsDict']]
+        """
+        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.
+        """
+elif False:
+    ResourceClaimTemplateSpecArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceClaimTemplateSpecArgs:
+    def __init__(__self__, *,
+                 spec: pulumi.Input['ResourceClaimSpecArgs'],
+                 metadata: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']] = None):
+        """
+        ResourceClaimTemplateSpec contains the metadata and fields for a ResourceClaim.
+        :param pulumi.Input['ResourceClaimSpecArgs'] spec: 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.
+        :param pulumi.Input['_meta.v1.ObjectMetaArgs'] metadata: 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.
+        """
+        pulumi.set(__self__, "spec", spec)
+        if metadata is not None:
+            pulumi.set(__self__, "metadata", metadata)
+
+    @property
+    @pulumi.getter
+    def spec(self) -> pulumi.Input['ResourceClaimSpecArgs']:
+        """
+        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.
+        """
+        return pulumi.get(self, "spec")
+
+    @spec.setter
+    def spec(self, value: pulumi.Input['ResourceClaimSpecArgs']):
+        pulumi.set(self, "spec", value)
+
+    @property
+    @pulumi.getter
+    def metadata(self) -> Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]:
+        """
+        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.
+        """
+        return pulumi.get(self, "metadata")
+
+    @metadata.setter
+    def metadata(self, value: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]):
+        pulumi.set(self, "metadata", value)
+
+
+if not MYPY:
+    class ResourceClaimTemplateArgsDict(TypedDict):
+        """
+        ResourceClaimTemplate is used to produce ResourceClaim objects.
+        """
+        spec: pulumi.Input['ResourceClaimTemplateSpecArgsDict']
+        """
+        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.
+        """
+        api_version: NotRequired[pulumi.Input[str]]
+        """
+        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
+        """
+        kind: NotRequired[pulumi.Input[str]]
+        """
+        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
+        """
+        metadata: NotRequired[pulumi.Input['_meta.v1.ObjectMetaArgsDict']]
+        """
+        Standard object metadata
+        """
+elif False:
+    ResourceClaimTemplateArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceClaimTemplateArgs:
+    def __init__(__self__, *,
+                 spec: pulumi.Input['ResourceClaimTemplateSpecArgs'],
+                 api_version: Optional[pulumi.Input[str]] = None,
+                 kind: Optional[pulumi.Input[str]] = None,
+                 metadata: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']] = None):
+        """
+        ResourceClaimTemplate is used to produce ResourceClaim objects.
+        :param pulumi.Input['ResourceClaimTemplateSpecArgs'] spec: 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.
+        :param pulumi.Input[str] api_version: 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
+        :param pulumi.Input[str] kind: 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
+        :param pulumi.Input['_meta.v1.ObjectMetaArgs'] metadata: Standard object metadata
+        """
+        pulumi.set(__self__, "spec", spec)
+        if api_version is not None:
+            pulumi.set(__self__, "api_version", 'resource.k8s.io/v1alpha2')
+        if kind is not None:
+            pulumi.set(__self__, "kind", 'ResourceClaimTemplate')
+        if metadata is not None:
+            pulumi.set(__self__, "metadata", metadata)
+
+    @property
+    @pulumi.getter
+    def spec(self) -> pulumi.Input['ResourceClaimTemplateSpecArgs']:
+        """
+        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.
+        """
+        return pulumi.get(self, "spec")
+
+    @spec.setter
+    def spec(self, value: pulumi.Input['ResourceClaimTemplateSpecArgs']):
+        pulumi.set(self, "spec", value)
+
+    @property
+    @pulumi.getter(name="apiVersion")
+    def api_version(self) -> Optional[pulumi.Input[str]]:
+        """
+        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
+        """
+        return pulumi.get(self, "api_version")
+
+    @api_version.setter
+    def api_version(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_version", value)
+
+    @property
+    @pulumi.getter
+    def kind(self) -> Optional[pulumi.Input[str]]:
+        """
+        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
+        """
+        return pulumi.get(self, "kind")
+
+    @kind.setter
+    def kind(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "kind", value)
+
+    @property
+    @pulumi.getter
+    def metadata(self) -> Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]:
+        """
+        Standard object metadata
+        """
+        return pulumi.get(self, "metadata")
+
+    @metadata.setter
+    def metadata(self, value: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]):
+        pulumi.set(self, "metadata", value)
+
+
+if not MYPY:
+    class ResourceClaimArgsDict(TypedDict):
+        """
+        ResourceClaim describes which resources are needed by a resource consumer. Its status tracks whether the resource has been allocated and what the resulting attributes are.
+
+        This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
+        """
+        spec: pulumi.Input['ResourceClaimSpecArgsDict']
+        """
+        Spec describes the desired attributes of a resource that then needs to be allocated. It can only be set once when creating the ResourceClaim.
+        """
+        api_version: NotRequired[pulumi.Input[str]]
+        """
+        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
+        """
+        kind: NotRequired[pulumi.Input[str]]
+        """
+        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
+        """
+        metadata: NotRequired[pulumi.Input['_meta.v1.ObjectMetaArgsDict']]
+        """
+        Standard object metadata
+        """
+        status: NotRequired[pulumi.Input['ResourceClaimStatusArgsDict']]
+        """
+        Status describes whether the resource is available and with which attributes.
+        """
+elif False:
+    ResourceClaimArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceClaimArgs:
+    def __init__(__self__, *,
+                 spec: pulumi.Input['ResourceClaimSpecArgs'],
+                 api_version: Optional[pulumi.Input[str]] = None,
+                 kind: Optional[pulumi.Input[str]] = None,
+                 metadata: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']] = None,
+                 status: Optional[pulumi.Input['ResourceClaimStatusArgs']] = None):
+        """
+        ResourceClaim describes which resources are needed by a resource consumer. Its status tracks whether the resource has been allocated and what the resulting attributes are.
+
+        This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
+        :param pulumi.Input['ResourceClaimSpecArgs'] spec: Spec describes the desired attributes of a resource that then needs to be allocated. It can only be set once when creating the ResourceClaim.
+        :param pulumi.Input[str] api_version: 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
+        :param pulumi.Input[str] kind: 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
+        :param pulumi.Input['_meta.v1.ObjectMetaArgs'] metadata: Standard object metadata
+        :param pulumi.Input['ResourceClaimStatusArgs'] status: Status describes whether the resource is available and with which attributes.
+        """
+        pulumi.set(__self__, "spec", spec)
+        if api_version is not None:
+            pulumi.set(__self__, "api_version", 'resource.k8s.io/v1alpha2')
+        if kind is not None:
+            pulumi.set(__self__, "kind", 'ResourceClaim')
+        if metadata is not None:
+            pulumi.set(__self__, "metadata", metadata)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter
+    def spec(self) -> pulumi.Input['ResourceClaimSpecArgs']:
+        """
+        Spec describes the desired attributes of a resource that then needs to be allocated. It can only be set once when creating the ResourceClaim.
+        """
+        return pulumi.get(self, "spec")
+
+    @spec.setter
+    def spec(self, value: pulumi.Input['ResourceClaimSpecArgs']):
+        pulumi.set(self, "spec", value)
+
+    @property
+    @pulumi.getter(name="apiVersion")
+    def api_version(self) -> Optional[pulumi.Input[str]]:
+        """
+        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
+        """
+        return pulumi.get(self, "api_version")
+
+    @api_version.setter
+    def api_version(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_version", value)
+
+    @property
+    @pulumi.getter
+    def kind(self) -> Optional[pulumi.Input[str]]:
+        """
+        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
+        """
+        return pulumi.get(self, "kind")
+
+    @kind.setter
+    def kind(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "kind", value)
+
+    @property
+    @pulumi.getter
+    def metadata(self) -> Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]:
+        """
+        Standard object metadata
+        """
+        return pulumi.get(self, "metadata")
+
+    @metadata.setter
+    def metadata(self, value: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]):
+        pulumi.set(self, "metadata", value)
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[pulumi.Input['ResourceClaimStatusArgs']]:
+        """
+        Status describes whether the resource is available and with which attributes.
+        """
+        return pulumi.get(self, "status")
+
+    @status.setter
+    def status(self, value: Optional[pulumi.Input['ResourceClaimStatusArgs']]):
+        pulumi.set(self, "status", value)
+
+
+if not MYPY:
+    class ResourceClassParametersReferencePatchArgsDict(TypedDict):
+        """
+        ResourceClassParametersReference contains enough information to let you locate the parameters for a ResourceClass.
+        """
+        api_group: NotRequired[pulumi.Input[str]]
+        """
+        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.
+        """
+        kind: NotRequired[pulumi.Input[str]]
+        """
+        Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Name is the name of resource being referenced.
+        """
+        namespace: NotRequired[pulumi.Input[str]]
+        """
+        Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
+        """
+elif False:
+    ResourceClassParametersReferencePatchArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceClassParametersReferencePatchArgs:
+    def __init__(__self__, *,
+                 api_group: Optional[pulumi.Input[str]] = None,
+                 kind: Optional[pulumi.Input[str]] = None,
+                 name: Optional[pulumi.Input[str]] = None,
+                 namespace: Optional[pulumi.Input[str]] = None):
+        """
+        ResourceClassParametersReference contains enough information to let you locate the parameters for a ResourceClass.
+        :param pulumi.Input[str] api_group: 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.
+        :param pulumi.Input[str] kind: Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
+        :param pulumi.Input[str] name: Name is the name of resource being referenced.
+        :param pulumi.Input[str] namespace: Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
+        """
+        if api_group is not None:
+            pulumi.set(__self__, "api_group", api_group)
+        if kind is not None:
+            pulumi.set(__self__, "kind", kind)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if namespace is not None:
+            pulumi.set(__self__, "namespace", namespace)
+
+    @property
+    @pulumi.getter(name="apiGroup")
+    def api_group(self) -> Optional[pulumi.Input[str]]:
+        """
+        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.
+        """
+        return pulumi.get(self, "api_group")
+
+    @api_group.setter
+    def api_group(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_group", value)
+
+    @property
+    @pulumi.getter
+    def kind(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
+        """
+        return pulumi.get(self, "kind")
+
+    @kind.setter
+    def kind(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "kind", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Name is the name of resource being referenced.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def namespace(self) -> Optional[pulumi.Input[str]]:
+        """
+        Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
+        """
+        return pulumi.get(self, "namespace")
+
+    @namespace.setter
+    def namespace(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "namespace", value)
+
+
+if not MYPY:
+    class ResourceClassParametersReferenceArgsDict(TypedDict):
+        """
+        ResourceClassParametersReference contains enough information to let you locate the parameters for a ResourceClass.
+        """
+        kind: pulumi.Input[str]
+        """
+        Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
+        """
+        name: pulumi.Input[str]
+        """
+        Name is the name of resource being referenced.
+        """
+        api_group: NotRequired[pulumi.Input[str]]
+        """
+        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.
+        """
+        namespace: NotRequired[pulumi.Input[str]]
+        """
+        Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
+        """
+elif False:
+    ResourceClassParametersReferenceArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceClassParametersReferenceArgs:
+    def __init__(__self__, *,
+                 kind: pulumi.Input[str],
+                 name: pulumi.Input[str],
+                 api_group: Optional[pulumi.Input[str]] = None,
+                 namespace: Optional[pulumi.Input[str]] = None):
+        """
+        ResourceClassParametersReference contains enough information to let you locate the parameters for a ResourceClass.
+        :param pulumi.Input[str] kind: Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
+        :param pulumi.Input[str] name: Name is the name of resource being referenced.
+        :param pulumi.Input[str] api_group: 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.
+        :param pulumi.Input[str] namespace: Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
+        """
+        pulumi.set(__self__, "kind", kind)
+        pulumi.set(__self__, "name", name)
+        if api_group is not None:
+            pulumi.set(__self__, "api_group", api_group)
+        if namespace is not None:
+            pulumi.set(__self__, "namespace", namespace)
+
+    @property
+    @pulumi.getter
+    def kind(self) -> pulumi.Input[str]:
+        """
+        Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
+        """
+        return pulumi.get(self, "kind")
+
+    @kind.setter
+    def kind(self, value: pulumi.Input[str]):
+        pulumi.set(self, "kind", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[str]:
+        """
+        Name is the name of resource being referenced.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter(name="apiGroup")
+    def api_group(self) -> Optional[pulumi.Input[str]]:
+        """
+        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.
+        """
+        return pulumi.get(self, "api_group")
+
+    @api_group.setter
+    def api_group(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_group", value)
+
+    @property
+    @pulumi.getter
+    def namespace(self) -> Optional[pulumi.Input[str]]:
+        """
+        Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
+        """
+        return pulumi.get(self, "namespace")
+
+    @namespace.setter
+    def namespace(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "namespace", value)
+
+
+if not MYPY:
+    class ResourceClassParametersArgsDict(TypedDict):
+        """
+        ResourceClassParameters defines resource requests for a ResourceClass in an in-tree format understood by Kubernetes.
+        """
+        api_version: NotRequired[pulumi.Input[str]]
+        """
+        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
+        """
+        filters: NotRequired[pulumi.Input[Sequence[pulumi.Input['ResourceFilterArgsDict']]]]
+        """
+        Filters describes additional contraints that must be met when using the class.
+        """
+        generated_from: NotRequired[pulumi.Input['ResourceClassParametersReferenceArgsDict']]
+        """
+        If this object was created from some other resource, then this links back to that resource. This field is used to find the in-tree representation of the class parameters when the parameter reference of the class refers to some unknown type.
+        """
+        kind: NotRequired[pulumi.Input[str]]
+        """
+        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
+        """
+        metadata: NotRequired[pulumi.Input['_meta.v1.ObjectMetaArgsDict']]
+        """
+        Standard object metadata
+        """
+        vendor_parameters: NotRequired[pulumi.Input[Sequence[pulumi.Input['VendorParametersArgsDict']]]]
         """
-        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.
+        VendorParameters are arbitrary setup parameters for all claims using this class. They are ignored while allocating the claim. There must not be more than one entry per driver.
         """
-        return pulumi.get(self, "metadata")
-
-    @metadata.setter
-    def metadata(self, value: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]):
-        pulumi.set(self, "metadata", value)
-
+elif False:
+    ResourceClassParametersArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class ResourceClaimTemplateArgs:
+class ResourceClassParametersArgs:
     def __init__(__self__, *,
-                 spec: pulumi.Input['ResourceClaimTemplateSpecArgs'],
                  api_version: Optional[pulumi.Input[str]] = None,
+                 filters: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceFilterArgs']]]] = None,
+                 generated_from: Optional[pulumi.Input['ResourceClassParametersReferenceArgs']] = None,
                  kind: Optional[pulumi.Input[str]] = None,
-                 metadata: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']] = None):
+                 metadata: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']] = None,
+                 vendor_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['VendorParametersArgs']]]] = None):
         """
-        ResourceClaimTemplate is used to produce ResourceClaim objects.
-        :param pulumi.Input['ResourceClaimTemplateSpecArgs'] spec: 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.
+        ResourceClassParameters defines resource requests for a ResourceClass in an in-tree format understood by Kubernetes.
         :param pulumi.Input[str] api_version: 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
+        :param pulumi.Input[Sequence[pulumi.Input['ResourceFilterArgs']]] filters: Filters describes additional contraints that must be met when using the class.
+        :param pulumi.Input['ResourceClassParametersReferenceArgs'] generated_from: If this object was created from some other resource, then this links back to that resource. This field is used to find the in-tree representation of the class parameters when the parameter reference of the class refers to some unknown type.
         :param pulumi.Input[str] kind: 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
         :param pulumi.Input['_meta.v1.ObjectMetaArgs'] metadata: Standard object metadata
+        :param pulumi.Input[Sequence[pulumi.Input['VendorParametersArgs']]] vendor_parameters: VendorParameters are arbitrary setup parameters for all claims using this class. They are ignored while allocating the claim. There must not be more than one entry per driver.
         """
-        pulumi.set(__self__, "spec", spec)
         if api_version is not None:
             pulumi.set(__self__, "api_version", 'resource.k8s.io/v1alpha2')
+        if filters is not None:
+            pulumi.set(__self__, "filters", filters)
+        if generated_from is not None:
+            pulumi.set(__self__, "generated_from", generated_from)
         if kind is not None:
-            pulumi.set(__self__, "kind", 'ResourceClaimTemplate')
+            pulumi.set(__self__, "kind", 'ResourceClassParameters')
         if metadata is not None:
             pulumi.set(__self__, "metadata", metadata)
-
-    @property
-    @pulumi.getter
-    def spec(self) -> pulumi.Input['ResourceClaimTemplateSpecArgs']:
-        """
-        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.
-        """
-        return pulumi.get(self, "spec")
-
-    @spec.setter
-    def spec(self, value: pulumi.Input['ResourceClaimTemplateSpecArgs']):
-        pulumi.set(self, "spec", value)
+        if vendor_parameters is not None:
+            pulumi.set(__self__, "vendor_parameters", vendor_parameters)
 
     @property
     @pulumi.getter(name="apiVersion")
@@ -854,6 +2924,30 @@ class ResourceClaimTemplateArgs:
     def api_version(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "api_version", value)
 
+    @property
+    @pulumi.getter
+    def filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceFilterArgs']]]]:
+        """
+        Filters describes additional contraints that must be met when using the class.
+        """
+        return pulumi.get(self, "filters")
+
+    @filters.setter
+    def filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceFilterArgs']]]]):
+        pulumi.set(self, "filters", value)
+
+    @property
+    @pulumi.getter(name="generatedFrom")
+    def generated_from(self) -> Optional[pulumi.Input['ResourceClassParametersReferenceArgs']]:
+        """
+        If this object was created from some other resource, then this links back to that resource. This field is used to find the in-tree representation of the class parameters when the parameter reference of the class refers to some unknown type.
+        """
+        return pulumi.get(self, "generated_from")
+
+    @generated_from.setter
+    def generated_from(self, value: Optional[pulumi.Input['ResourceClassParametersReferenceArgs']]):
+        pulumi.set(self, "generated_from", value)
+
     @property
     @pulumi.getter
     def kind(self) -> Optional[pulumi.Input[str]]:
@@ -878,46 +2972,114 @@ class ResourceClaimTemplateArgs:
     def metadata(self, value: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']]):
         pulumi.set(self, "metadata", value)
 
+    @property
+    @pulumi.getter(name="vendorParameters")
+    def vendor_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VendorParametersArgs']]]]:
+        """
+        VendorParameters are arbitrary setup parameters for all claims using this class. They are ignored while allocating the claim. There must not be more than one entry per driver.
+        """
+        return pulumi.get(self, "vendor_parameters")
+
+    @vendor_parameters.setter
+    def vendor_parameters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VendorParametersArgs']]]]):
+        pulumi.set(self, "vendor_parameters", value)
+
+
+if not MYPY:
+    class ResourceClassArgsDict(TypedDict):
+        """
+        ResourceClass is used by administrators to influence how resources are allocated.
+
+        This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
+        """
+        driver_name: pulumi.Input[str]
+        """
+        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).
+        """
+        api_version: NotRequired[pulumi.Input[str]]
+        """
+        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
+        """
+        kind: NotRequired[pulumi.Input[str]]
+        """
+        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
+        """
+        metadata: NotRequired[pulumi.Input['_meta.v1.ObjectMetaArgsDict']]
+        """
+        Standard object metadata
+        """
+        parameters_ref: NotRequired[pulumi.Input['ResourceClassParametersReferenceArgsDict']]
+        """
+        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.
+        """
+        structured_parameters: NotRequired[pulumi.Input[bool]]
+        """
+        If and only if allocation of claims using this class is handled via structured parameters, then StructuredParameters must be set to true.
+        """
+        suitable_nodes: NotRequired[pulumi.Input['_core.v1.NodeSelectorArgsDict']]
+        """
+        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.
+        """
+elif False:
+    ResourceClassArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class ResourceClaimArgs:
+class ResourceClassArgs:
     def __init__(__self__, *,
-                 spec: pulumi.Input['ResourceClaimSpecArgs'],
+                 driver_name: pulumi.Input[str],
                  api_version: Optional[pulumi.Input[str]] = None,
                  kind: Optional[pulumi.Input[str]] = None,
                  metadata: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']] = None,
-                 status: Optional[pulumi.Input['ResourceClaimStatusArgs']] = None):
+                 parameters_ref: Optional[pulumi.Input['ResourceClassParametersReferenceArgs']] = None,
+                 structured_parameters: Optional[pulumi.Input[bool]] = None,
+                 suitable_nodes: Optional[pulumi.Input['_core.v1.NodeSelectorArgs']] = None):
         """
-        ResourceClaim describes which resources are needed by a resource consumer. Its status tracks whether the resource has been allocated and what the resulting attributes are.
+        ResourceClass is used by administrators to influence how resources are allocated.
 
         This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
-        :param pulumi.Input['ResourceClaimSpecArgs'] spec: Spec describes the desired attributes of a resource that then needs to be allocated. It can only be set once when creating the ResourceClaim.
+        :param pulumi.Input[str] driver_name: 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).
         :param pulumi.Input[str] api_version: 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
         :param pulumi.Input[str] kind: 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
         :param pulumi.Input['_meta.v1.ObjectMetaArgs'] metadata: Standard object metadata
-        :param pulumi.Input['ResourceClaimStatusArgs'] status: Status describes whether the resource is available and with which attributes.
+        :param pulumi.Input['ResourceClassParametersReferenceArgs'] parameters_ref: 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.
+        :param pulumi.Input[bool] structured_parameters: If and only if allocation of claims using this class is handled via structured parameters, then StructuredParameters must be set to true.
+        :param pulumi.Input['_core.v1.NodeSelectorArgs'] suitable_nodes: 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.
         """
-        pulumi.set(__self__, "spec", spec)
+        pulumi.set(__self__, "driver_name", driver_name)
         if api_version is not None:
             pulumi.set(__self__, "api_version", 'resource.k8s.io/v1alpha2')
         if kind is not None:
-            pulumi.set(__self__, "kind", 'ResourceClaim')
+            pulumi.set(__self__, "kind", 'ResourceClass')
         if metadata is not None:
             pulumi.set(__self__, "metadata", metadata)
-        if status is not None:
-            pulumi.set(__self__, "status", status)
+        if parameters_ref is not None:
+            pulumi.set(__self__, "parameters_ref", parameters_ref)
+        if structured_parameters is not None:
+            pulumi.set(__self__, "structured_parameters", structured_parameters)
+        if suitable_nodes is not None:
+            pulumi.set(__self__, "suitable_nodes", suitable_nodes)
 
     @property
-    @pulumi.getter
-    def spec(self) -> pulumi.Input['ResourceClaimSpecArgs']:
+    @pulumi.getter(name="driverName")
+    def driver_name(self) -> pulumi.Input[str]:
         """
-        Spec describes the desired attributes of a resource that then needs to be allocated. It can only be set once when creating the ResourceClaim.
+        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).
         """
-        return pulumi.get(self, "spec")
+        return pulumi.get(self, "driver_name")
 
-    @spec.setter
-    def spec(self, value: pulumi.Input['ResourceClaimSpecArgs']):
-        pulumi.set(self, "spec", value)
+    @driver_name.setter
+    def driver_name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "driver_name", value)
 
     @property
     @pulumi.getter(name="apiVersion")
@@ -956,203 +3118,421 @@ class ResourceClaimArgs:
         pulumi.set(self, "metadata", value)
 
     @property
-    @pulumi.getter
-    def status(self) -> Optional[pulumi.Input['ResourceClaimStatusArgs']]:
+    @pulumi.getter(name="parametersRef")
+    def parameters_ref(self) -> Optional[pulumi.Input['ResourceClassParametersReferenceArgs']]:
         """
-        Status describes whether the resource is available and with which attributes.
+        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.
         """
-        return pulumi.get(self, "status")
+        return pulumi.get(self, "parameters_ref")
 
-    @status.setter
-    def status(self, value: Optional[pulumi.Input['ResourceClaimStatusArgs']]):
-        pulumi.set(self, "status", value)
+    @parameters_ref.setter
+    def parameters_ref(self, value: Optional[pulumi.Input['ResourceClassParametersReferenceArgs']]):
+        pulumi.set(self, "parameters_ref", value)
+
+    @property
+    @pulumi.getter(name="structuredParameters")
+    def structured_parameters(self) -> Optional[pulumi.Input[bool]]:
+        """
+        If and only if allocation of claims using this class is handled via structured parameters, then StructuredParameters must be set to true.
+        """
+        return pulumi.get(self, "structured_parameters")
+
+    @structured_parameters.setter
+    def structured_parameters(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "structured_parameters", value)
+
+    @property
+    @pulumi.getter(name="suitableNodes")
+    def suitable_nodes(self) -> Optional[pulumi.Input['_core.v1.NodeSelectorArgs']]:
+        """
+        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.
+        """
+        return pulumi.get(self, "suitable_nodes")
+
+    @suitable_nodes.setter
+    def suitable_nodes(self, value: Optional[pulumi.Input['_core.v1.NodeSelectorArgs']]):
+        pulumi.set(self, "suitable_nodes", value)
 
 
+if not MYPY:
+    class ResourceFilterPatchArgsDict(TypedDict):
+        """
+        ResourceFilter is a filter for resources from one particular driver.
+        """
+        driver_name: NotRequired[pulumi.Input[str]]
+        """
+        DriverName is the name used by the DRA driver kubelet plugin.
+        """
+        named_resources: NotRequired[pulumi.Input['NamedResourcesFilterPatchArgsDict']]
+        """
+        NamedResources describes a resource filter using the named resources model.
+        """
+elif False:
+    ResourceFilterPatchArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
-class ResourceClassParametersReferencePatchArgs:
+class ResourceFilterPatchArgs:
     def __init__(__self__, *,
-                 api_group: Optional[pulumi.Input[str]] = None,
-                 kind: Optional[pulumi.Input[str]] = None,
-                 name: Optional[pulumi.Input[str]] = None,
-                 namespace: Optional[pulumi.Input[str]] = None):
+                 driver_name: Optional[pulumi.Input[str]] = None,
+                 named_resources: Optional[pulumi.Input['NamedResourcesFilterPatchArgs']] = None):
         """
-        ResourceClassParametersReference contains enough information to let you locate the parameters for a ResourceClass.
-        :param pulumi.Input[str] api_group: 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.
-        :param pulumi.Input[str] kind: Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
-        :param pulumi.Input[str] name: Name is the name of resource being referenced.
-        :param pulumi.Input[str] namespace: Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
+        ResourceFilter is a filter for resources from one particular driver.
+        :param pulumi.Input[str] driver_name: DriverName is the name used by the DRA driver kubelet plugin.
+        :param pulumi.Input['NamedResourcesFilterPatchArgs'] named_resources: NamedResources describes a resource filter using the named resources model.
         """
-        if api_group is not None:
-            pulumi.set(__self__, "api_group", api_group)
-        if kind is not None:
-            pulumi.set(__self__, "kind", kind)
-        if name is not None:
-            pulumi.set(__self__, "name", name)
-        if namespace is not None:
-            pulumi.set(__self__, "namespace", namespace)
+        if driver_name is not None:
+            pulumi.set(__self__, "driver_name", driver_name)
+        if named_resources is not None:
+            pulumi.set(__self__, "named_resources", named_resources)
 
     @property
-    @pulumi.getter(name="apiGroup")
-    def api_group(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="driverName")
+    def driver_name(self) -> Optional[pulumi.Input[str]]:
         """
-        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.
+        DriverName is the name used by the DRA driver kubelet plugin.
+        """
+        return pulumi.get(self, "driver_name")
+
+    @driver_name.setter
+    def driver_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "driver_name", value)
+
+    @property
+    @pulumi.getter(name="namedResources")
+    def named_resources(self) -> Optional[pulumi.Input['NamedResourcesFilterPatchArgs']]:
+        """
+        NamedResources describes a resource filter using the named resources model.
+        """
+        return pulumi.get(self, "named_resources")
+
+    @named_resources.setter
+    def named_resources(self, value: Optional[pulumi.Input['NamedResourcesFilterPatchArgs']]):
+        pulumi.set(self, "named_resources", value)
+
+
+if not MYPY:
+    class ResourceFilterArgsDict(TypedDict):
+        """
+        ResourceFilter is a filter for resources from one particular driver.
+        """
+        driver_name: NotRequired[pulumi.Input[str]]
+        """
+        DriverName is the name used by the DRA driver kubelet plugin.
+        """
+        named_resources: NotRequired[pulumi.Input['NamedResourcesFilterArgsDict']]
+        """
+        NamedResources describes a resource filter using the named resources model.
+        """
+elif False:
+    ResourceFilterArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceFilterArgs:
+    def __init__(__self__, *,
+                 driver_name: Optional[pulumi.Input[str]] = None,
+                 named_resources: Optional[pulumi.Input['NamedResourcesFilterArgs']] = None):
+        """
+        ResourceFilter is a filter for resources from one particular driver.
+        :param pulumi.Input[str] driver_name: DriverName is the name used by the DRA driver kubelet plugin.
+        :param pulumi.Input['NamedResourcesFilterArgs'] named_resources: NamedResources describes a resource filter using the named resources model.
+        """
+        if driver_name is not None:
+            pulumi.set(__self__, "driver_name", driver_name)
+        if named_resources is not None:
+            pulumi.set(__self__, "named_resources", named_resources)
+
+    @property
+    @pulumi.getter(name="driverName")
+    def driver_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        DriverName is the name used by the DRA driver kubelet plugin.
+        """
+        return pulumi.get(self, "driver_name")
+
+    @driver_name.setter
+    def driver_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "driver_name", value)
+
+    @property
+    @pulumi.getter(name="namedResources")
+    def named_resources(self) -> Optional[pulumi.Input['NamedResourcesFilterArgs']]:
+        """
+        NamedResources describes a resource filter using the named resources model.
+        """
+        return pulumi.get(self, "named_resources")
+
+    @named_resources.setter
+    def named_resources(self, value: Optional[pulumi.Input['NamedResourcesFilterArgs']]):
+        pulumi.set(self, "named_resources", value)
+
+
+if not MYPY:
+    class ResourceHandleArgsDict(TypedDict):
+        """
+        ResourceHandle holds opaque resource data for processing by a specific kubelet plugin.
+        """
+        data: NotRequired[pulumi.Input[str]]
+        """
+        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.
+        """
+        driver_name: NotRequired[pulumi.Input[str]]
+        """
+        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.
+        """
+        structured_data: NotRequired[pulumi.Input['StructuredResourceHandleArgsDict']]
+        """
+        If StructuredData is set, then it needs to be used instead of Data.
+        """
+elif False:
+    ResourceHandleArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceHandleArgs:
+    def __init__(__self__, *,
+                 data: Optional[pulumi.Input[str]] = None,
+                 driver_name: Optional[pulumi.Input[str]] = None,
+                 structured_data: Optional[pulumi.Input['StructuredResourceHandleArgs']] = None):
+        """
+        ResourceHandle holds opaque resource data for processing by a specific kubelet plugin.
+        :param pulumi.Input[str] data: 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.
+        :param pulumi.Input[str] driver_name: 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.
+        :param pulumi.Input['StructuredResourceHandleArgs'] structured_data: If StructuredData is set, then it needs to be used instead of Data.
         """
-        return pulumi.get(self, "api_group")
-
-    @api_group.setter
-    def api_group(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "api_group", value)
+        if data is not None:
+            pulumi.set(__self__, "data", data)
+        if driver_name is not None:
+            pulumi.set(__self__, "driver_name", driver_name)
+        if structured_data is not None:
+            pulumi.set(__self__, "structured_data", structured_data)
 
     @property
     @pulumi.getter
-    def kind(self) -> Optional[pulumi.Input[str]]:
+    def data(self) -> Optional[pulumi.Input[str]]:
         """
-        Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
+        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.
         """
-        return pulumi.get(self, "kind")
+        return pulumi.get(self, "data")
 
-    @kind.setter
-    def kind(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "kind", value)
+    @data.setter
+    def data(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "data", value)
 
     @property
-    @pulumi.getter
-    def name(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="driverName")
+    def driver_name(self) -> Optional[pulumi.Input[str]]:
         """
-        Name is the name of resource being referenced.
+        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.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "driver_name")
 
-    @name.setter
-    def name(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "name", value)
+    @driver_name.setter
+    def driver_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "driver_name", value)
 
     @property
-    @pulumi.getter
-    def namespace(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="structuredData")
+    def structured_data(self) -> Optional[pulumi.Input['StructuredResourceHandleArgs']]:
         """
-        Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
+        If StructuredData is set, then it needs to be used instead of Data.
         """
-        return pulumi.get(self, "namespace")
+        return pulumi.get(self, "structured_data")
+
+    @structured_data.setter
+    def structured_data(self, value: Optional[pulumi.Input['StructuredResourceHandleArgs']]):
+        pulumi.set(self, "structured_data", value)
 
-    @namespace.setter
-    def namespace(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "namespace", value)
 
+if not MYPY:
+    class ResourceRequestPatchArgsDict(TypedDict):
+        """
+        ResourceRequest is a request for resources from one particular driver.
+        """
+        named_resources: NotRequired[pulumi.Input['NamedResourcesRequestPatchArgsDict']]
+        """
+        NamedResources describes a request for resources with the named resources model.
+        """
+        vendor_parameters: NotRequired[Any]
+        """
+        VendorParameters are arbitrary setup parameters for the requested resource. They are ignored while allocating a claim.
+        """
+elif False:
+    ResourceRequestPatchArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class ResourceClassParametersReferenceArgs:
+class ResourceRequestPatchArgs:
     def __init__(__self__, *,
-                 kind: pulumi.Input[str],
-                 name: pulumi.Input[str],
-                 api_group: Optional[pulumi.Input[str]] = None,
-                 namespace: Optional[pulumi.Input[str]] = None):
+                 named_resources: Optional[pulumi.Input['NamedResourcesRequestPatchArgs']] = None,
+                 vendor_parameters: Optional[Any] = None):
         """
-        ResourceClassParametersReference contains enough information to let you locate the parameters for a ResourceClass.
-        :param pulumi.Input[str] kind: Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
-        :param pulumi.Input[str] name: Name is the name of resource being referenced.
-        :param pulumi.Input[str] api_group: 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.
-        :param pulumi.Input[str] namespace: Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
+        ResourceRequest is a request for resources from one particular driver.
+        :param pulumi.Input['NamedResourcesRequestPatchArgs'] named_resources: NamedResources describes a request for resources with the named resources model.
+        :param Any vendor_parameters: VendorParameters are arbitrary setup parameters for the requested resource. They are ignored while allocating a claim.
         """
-        pulumi.set(__self__, "kind", kind)
-        pulumi.set(__self__, "name", name)
-        if api_group is not None:
-            pulumi.set(__self__, "api_group", api_group)
-        if namespace is not None:
-            pulumi.set(__self__, "namespace", namespace)
+        if named_resources is not None:
+            pulumi.set(__self__, "named_resources", named_resources)
+        if vendor_parameters is not None:
+            pulumi.set(__self__, "vendor_parameters", vendor_parameters)
 
     @property
-    @pulumi.getter
-    def kind(self) -> pulumi.Input[str]:
+    @pulumi.getter(name="namedResources")
+    def named_resources(self) -> Optional[pulumi.Input['NamedResourcesRequestPatchArgs']]:
         """
-        Kind is the type of resource being referenced. This is the same value as in the parameter object's metadata.
+        NamedResources describes a request for resources with the named resources model.
         """
-        return pulumi.get(self, "kind")
+        return pulumi.get(self, "named_resources")
 
-    @kind.setter
-    def kind(self, value: pulumi.Input[str]):
-        pulumi.set(self, "kind", value)
+    @named_resources.setter
+    def named_resources(self, value: Optional[pulumi.Input['NamedResourcesRequestPatchArgs']]):
+        pulumi.set(self, "named_resources", value)
 
     @property
-    @pulumi.getter
-    def name(self) -> pulumi.Input[str]:
+    @pulumi.getter(name="vendorParameters")
+    def vendor_parameters(self) -> Optional[Any]:
         """
-        Name is the name of resource being referenced.
+        VendorParameters are arbitrary setup parameters for the requested resource. They are ignored while allocating a claim.
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "vendor_parameters")
 
-    @name.setter
-    def name(self, value: pulumi.Input[str]):
-        pulumi.set(self, "name", value)
+    @vendor_parameters.setter
+    def vendor_parameters(self, value: Optional[Any]):
+        pulumi.set(self, "vendor_parameters", value)
+
+
+if not MYPY:
+    class ResourceRequestArgsDict(TypedDict):
+        """
+        ResourceRequest is a request for resources from one particular driver.
+        """
+        named_resources: NotRequired[pulumi.Input['NamedResourcesRequestArgsDict']]
+        """
+        NamedResources describes a request for resources with the named resources model.
+        """
+        vendor_parameters: NotRequired[Any]
+        """
+        VendorParameters are arbitrary setup parameters for the requested resource. They are ignored while allocating a claim.
+        """
+elif False:
+    ResourceRequestArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceRequestArgs:
+    def __init__(__self__, *,
+                 named_resources: Optional[pulumi.Input['NamedResourcesRequestArgs']] = None,
+                 vendor_parameters: Optional[Any] = None):
+        """
+        ResourceRequest is a request for resources from one particular driver.
+        :param pulumi.Input['NamedResourcesRequestArgs'] named_resources: NamedResources describes a request for resources with the named resources model.
+        :param Any vendor_parameters: VendorParameters are arbitrary setup parameters for the requested resource. They are ignored while allocating a claim.
+        """
+        if named_resources is not None:
+            pulumi.set(__self__, "named_resources", named_resources)
+        if vendor_parameters is not None:
+            pulumi.set(__self__, "vendor_parameters", vendor_parameters)
 
     @property
-    @pulumi.getter(name="apiGroup")
-    def api_group(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="namedResources")
+    def named_resources(self) -> Optional[pulumi.Input['NamedResourcesRequestArgs']]:
         """
-        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.
+        NamedResources describes a request for resources with the named resources model.
         """
-        return pulumi.get(self, "api_group")
+        return pulumi.get(self, "named_resources")
 
-    @api_group.setter
-    def api_group(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "api_group", value)
+    @named_resources.setter
+    def named_resources(self, value: Optional[pulumi.Input['NamedResourcesRequestArgs']]):
+        pulumi.set(self, "named_resources", value)
 
     @property
-    @pulumi.getter
-    def namespace(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="vendorParameters")
+    def vendor_parameters(self) -> Optional[Any]:
         """
-        Namespace that contains the referenced resource. Must be empty for cluster-scoped resources and non-empty for namespaced resources.
+        VendorParameters are arbitrary setup parameters for the requested resource. They are ignored while allocating a claim.
         """
-        return pulumi.get(self, "namespace")
+        return pulumi.get(self, "vendor_parameters")
 
-    @namespace.setter
-    def namespace(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "namespace", value)
+    @vendor_parameters.setter
+    def vendor_parameters(self, value: Optional[Any]):
+        pulumi.set(self, "vendor_parameters", value)
+
+
+if not MYPY:
+    class ResourceSliceArgsDict(TypedDict):
+        """
+        ResourceSlice provides information about available resources on individual nodes.
+        """
+        driver_name: pulumi.Input[str]
+        """
+        DriverName identifies the DRA driver providing the capacity information. A field selector can be used to list only ResourceSlice objects with a certain driver name.
+        """
+        api_version: NotRequired[pulumi.Input[str]]
+        """
+        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
+        """
+        kind: NotRequired[pulumi.Input[str]]
+        """
+        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
+        """
+        metadata: NotRequired[pulumi.Input['_meta.v1.ObjectMetaArgsDict']]
+        """
+        Standard object metadata
+        """
+        named_resources: NotRequired[pulumi.Input['NamedResourcesResourcesArgsDict']]
+        """
+        NamedResources describes available resources using the named resources model.
+        """
+        node_name: NotRequired[pulumi.Input[str]]
+        """
+        NodeName identifies the node which provides the resources if they are local to a node.
 
+        A field selector can be used to list only ResourceSlice objects with a certain node name.
+        """
+elif False:
+    ResourceSliceArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class ResourceClassArgs:
+class ResourceSliceArgs:
     def __init__(__self__, *,
                  driver_name: pulumi.Input[str],
                  api_version: Optional[pulumi.Input[str]] = None,
                  kind: Optional[pulumi.Input[str]] = None,
                  metadata: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']] = None,
-                 parameters_ref: Optional[pulumi.Input['ResourceClassParametersReferenceArgs']] = None,
-                 suitable_nodes: Optional[pulumi.Input['_core.v1.NodeSelectorArgs']] = None):
+                 named_resources: Optional[pulumi.Input['NamedResourcesResourcesArgs']] = None,
+                 node_name: Optional[pulumi.Input[str]] = None):
         """
-        ResourceClass is used by administrators to influence how resources are allocated.
-
-        This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
-        :param pulumi.Input[str] driver_name: 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).
+        ResourceSlice provides information about available resources on individual nodes.
+        :param pulumi.Input[str] driver_name: DriverName identifies the DRA driver providing the capacity information. A field selector can be used to list only ResourceSlice objects with a certain driver name.
         :param pulumi.Input[str] api_version: 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
         :param pulumi.Input[str] kind: 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
         :param pulumi.Input['_meta.v1.ObjectMetaArgs'] metadata: Standard object metadata
-        :param pulumi.Input['ResourceClassParametersReferenceArgs'] parameters_ref: 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.
-        :param pulumi.Input['_core.v1.NodeSelectorArgs'] suitable_nodes: 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.
+        :param pulumi.Input['NamedResourcesResourcesArgs'] named_resources: NamedResources describes available resources using the named resources model.
+        :param pulumi.Input[str] node_name: NodeName identifies the node which provides the resources if they are local to a node.
                
-               Setting this field is optional. If null, all nodes are candidates.
+               A field selector can be used to list only ResourceSlice objects with a certain node name.
         """
         pulumi.set(__self__, "driver_name", driver_name)
         if api_version is not None:
             pulumi.set(__self__, "api_version", 'resource.k8s.io/v1alpha2')
         if kind is not None:
-            pulumi.set(__self__, "kind", 'ResourceClass')
+            pulumi.set(__self__, "kind", 'ResourceSlice')
         if metadata is not None:
             pulumi.set(__self__, "metadata", metadata)
-        if parameters_ref is not None:
-            pulumi.set(__self__, "parameters_ref", parameters_ref)
-        if suitable_nodes is not None:
-            pulumi.set(__self__, "suitable_nodes", suitable_nodes)
+        if named_resources is not None:
+            pulumi.set(__self__, "named_resources", named_resources)
+        if node_name is not None:
+            pulumi.set(__self__, "node_name", node_name)
 
     @property
     @pulumi.getter(name="driverName")
     def driver_name(self) -> pulumi.Input[str]:
         """
-        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 identifies the DRA driver providing the capacity information. A field selector can be used to list only ResourceSlice objects with a certain driver name.
         """
         return pulumi.get(self, "driver_name")
 
@@ -1197,68 +3577,219 @@ class ResourceClassArgs:
         pulumi.set(self, "metadata", value)
 
     @property
-    @pulumi.getter(name="parametersRef")
-    def parameters_ref(self) -> Optional[pulumi.Input['ResourceClassParametersReferenceArgs']]:
+    @pulumi.getter(name="namedResources")
+    def named_resources(self) -> Optional[pulumi.Input['NamedResourcesResourcesArgs']]:
         """
-        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.
+        NamedResources describes available resources using the named resources model.
         """
-        return pulumi.get(self, "parameters_ref")
+        return pulumi.get(self, "named_resources")
 
-    @parameters_ref.setter
-    def parameters_ref(self, value: Optional[pulumi.Input['ResourceClassParametersReferenceArgs']]):
-        pulumi.set(self, "parameters_ref", value)
+    @named_resources.setter
+    def named_resources(self, value: Optional[pulumi.Input['NamedResourcesResourcesArgs']]):
+        pulumi.set(self, "named_resources", value)
 
     @property
-    @pulumi.getter(name="suitableNodes")
-    def suitable_nodes(self) -> Optional[pulumi.Input['_core.v1.NodeSelectorArgs']]:
+    @pulumi.getter(name="nodeName")
+    def node_name(self) -> Optional[pulumi.Input[str]]:
         """
-        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.
+        NodeName identifies the node which provides the resources if they are local to a node.
 
-        Setting this field is optional. If null, all nodes are candidates.
+        A field selector can be used to list only ResourceSlice objects with a certain node name.
         """
-        return pulumi.get(self, "suitable_nodes")
+        return pulumi.get(self, "node_name")
+
+    @node_name.setter
+    def node_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "node_name", value)
 
-    @suitable_nodes.setter
-    def suitable_nodes(self, value: Optional[pulumi.Input['_core.v1.NodeSelectorArgs']]):
-        pulumi.set(self, "suitable_nodes", value)
 
+if not MYPY:
+    class StructuredResourceHandleArgsDict(TypedDict):
+        """
+        StructuredResourceHandle is the in-tree representation of the allocation result.
+        """
+        results: pulumi.Input[Sequence[pulumi.Input['DriverAllocationResultArgsDict']]]
+        """
+        Results lists all allocated driver resources.
+        """
+        node_name: NotRequired[pulumi.Input[str]]
+        """
+        NodeName is the name of the node providing the necessary resources if the resources are local to a node.
+        """
+        vendor_claim_parameters: NotRequired[Any]
+        """
+        VendorClaimParameters are the per-claim configuration parameters from the resource claim parameters at the time that the claim was allocated.
+        """
+        vendor_class_parameters: NotRequired[Any]
+        """
+        VendorClassParameters are the per-claim configuration parameters from the resource class at the time that the claim was allocated.
+        """
+elif False:
+    StructuredResourceHandleArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class ResourceHandleArgs:
+class StructuredResourceHandleArgs:
     def __init__(__self__, *,
-                 data: Optional[pulumi.Input[str]] = None,
-                 driver_name: Optional[pulumi.Input[str]] = None):
+                 results: pulumi.Input[Sequence[pulumi.Input['DriverAllocationResultArgs']]],
+                 node_name: Optional[pulumi.Input[str]] = None,
+                 vendor_claim_parameters: Optional[Any] = None,
+                 vendor_class_parameters: Optional[Any] = None):
+        """
+        StructuredResourceHandle is the in-tree representation of the allocation result.
+        :param pulumi.Input[Sequence[pulumi.Input['DriverAllocationResultArgs']]] results: Results lists all allocated driver resources.
+        :param pulumi.Input[str] node_name: NodeName is the name of the node providing the necessary resources if the resources are local to a node.
+        :param Any vendor_claim_parameters: VendorClaimParameters are the per-claim configuration parameters from the resource claim parameters at the time that the claim was allocated.
+        :param Any vendor_class_parameters: VendorClassParameters are the per-claim configuration parameters from the resource class at the time that the claim was allocated.
+        """
+        pulumi.set(__self__, "results", results)
+        if node_name is not None:
+            pulumi.set(__self__, "node_name", node_name)
+        if vendor_claim_parameters is not None:
+            pulumi.set(__self__, "vendor_claim_parameters", vendor_claim_parameters)
+        if vendor_class_parameters is not None:
+            pulumi.set(__self__, "vendor_class_parameters", vendor_class_parameters)
+
+    @property
+    @pulumi.getter
+    def results(self) -> pulumi.Input[Sequence[pulumi.Input['DriverAllocationResultArgs']]]:
         """
-        ResourceHandle holds opaque resource data for processing by a specific kubelet plugin.
-        :param pulumi.Input[str] data: 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.
-        :param pulumi.Input[str] driver_name: 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.
+        Results lists all allocated driver resources.
+        """
+        return pulumi.get(self, "results")
+
+    @results.setter
+    def results(self, value: pulumi.Input[Sequence[pulumi.Input['DriverAllocationResultArgs']]]):
+        pulumi.set(self, "results", value)
+
+    @property
+    @pulumi.getter(name="nodeName")
+    def node_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        NodeName is the name of the node providing the necessary resources if the resources are local to a node.
+        """
+        return pulumi.get(self, "node_name")
+
+    @node_name.setter
+    def node_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "node_name", value)
+
+    @property
+    @pulumi.getter(name="vendorClaimParameters")
+    def vendor_claim_parameters(self) -> Optional[Any]:
+        """
+        VendorClaimParameters are the per-claim configuration parameters from the resource claim parameters at the time that the claim was allocated.
+        """
+        return pulumi.get(self, "vendor_claim_parameters")
+
+    @vendor_claim_parameters.setter
+    def vendor_claim_parameters(self, value: Optional[Any]):
+        pulumi.set(self, "vendor_claim_parameters", value)
+
+    @property
+    @pulumi.getter(name="vendorClassParameters")
+    def vendor_class_parameters(self) -> Optional[Any]:
+        """
+        VendorClassParameters are the per-claim configuration parameters from the resource class at the time that the claim was allocated.
+        """
+        return pulumi.get(self, "vendor_class_parameters")
+
+    @vendor_class_parameters.setter
+    def vendor_class_parameters(self, value: Optional[Any]):
+        pulumi.set(self, "vendor_class_parameters", value)
+
+
+if not MYPY:
+    class VendorParametersPatchArgsDict(TypedDict):
+        """
+        VendorParameters are opaque parameters for one particular driver.
+        """
+        driver_name: NotRequired[pulumi.Input[str]]
+        """
+        DriverName is the name used by the DRA driver kubelet plugin.
+        """
+        parameters: NotRequired[Any]
+        """
+        Parameters can be arbitrary setup parameters. They are ignored while allocating a claim.
+        """
+elif False:
+    VendorParametersPatchArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class VendorParametersPatchArgs:
+    def __init__(__self__, *,
+                 driver_name: Optional[pulumi.Input[str]] = None,
+                 parameters: Optional[Any] = None):
+        """
+        VendorParameters are opaque parameters for one particular driver.
+        :param pulumi.Input[str] driver_name: DriverName is the name used by the DRA driver kubelet plugin.
+        :param Any parameters: Parameters can be arbitrary setup parameters. They are ignored while allocating a claim.
         """
-        if data is not None:
-            pulumi.set(__self__, "data", data)
         if driver_name is not None:
             pulumi.set(__self__, "driver_name", driver_name)
+        if parameters is not None:
+            pulumi.set(__self__, "parameters", parameters)
+
+    @property
+    @pulumi.getter(name="driverName")
+    def driver_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        DriverName is the name used by the DRA driver kubelet plugin.
+        """
+        return pulumi.get(self, "driver_name")
+
+    @driver_name.setter
+    def driver_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "driver_name", value)
 
     @property
     @pulumi.getter
-    def data(self) -> Optional[pulumi.Input[str]]:
+    def parameters(self) -> Optional[Any]:
         """
-        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.
+        Parameters can be arbitrary setup parameters. They are ignored while allocating a claim.
+        """
+        return pulumi.get(self, "parameters")
 
-        The maximum size of this field is 16KiB. This may get increased in the future, but not reduced.
+    @parameters.setter
+    def parameters(self, value: Optional[Any]):
+        pulumi.set(self, "parameters", value)
+
+
+if not MYPY:
+    class VendorParametersArgsDict(TypedDict):
         """
-        return pulumi.get(self, "data")
+        VendorParameters are opaque parameters for one particular driver.
+        """
+        driver_name: NotRequired[pulumi.Input[str]]
+        """
+        DriverName is the name used by the DRA driver kubelet plugin.
+        """
+        parameters: NotRequired[Any]
+        """
+        Parameters can be arbitrary setup parameters. They are ignored while allocating a claim.
+        """
+elif False:
+    VendorParametersArgsDict: TypeAlias = Mapping[str, Any]
 
-    @data.setter
-    def data(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "data", value)
+@pulumi.input_type
+class VendorParametersArgs:
+    def __init__(__self__, *,
+                 driver_name: Optional[pulumi.Input[str]] = None,
+                 parameters: Optional[Any] = None):
+        """
+        VendorParameters are opaque parameters for one particular driver.
+        :param pulumi.Input[str] driver_name: DriverName is the name used by the DRA driver kubelet plugin.
+        :param Any parameters: Parameters can be arbitrary setup parameters. They are ignored while allocating a claim.
+        """
+        if driver_name is not None:
+            pulumi.set(__self__, "driver_name", driver_name)
+        if parameters is not None:
+            pulumi.set(__self__, "parameters", parameters)
 
     @property
     @pulumi.getter(name="driverName")
     def driver_name(self) -> Optional[pulumi.Input[str]]:
         """
-        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 is the name used by the DRA driver kubelet plugin.
         """
         return pulumi.get(self, "driver_name")
 
@@ -1266,4 +3797,16 @@ class ResourceHandleArgs:
     def driver_name(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "driver_name", value)
 
+    @property
+    @pulumi.getter
+    def parameters(self) -> Optional[Any]:
+        """
+        Parameters can be arbitrary setup parameters. They are ignored while allocating a claim.
+        """
+        return pulumi.get(self, "parameters")
+
+    @parameters.setter
+    def parameters(self, value: Optional[Any]):
+        pulumi.set(self, "parameters", value)
+