pulumi-kubernetes 4.19.0a1733937243__py3-none-any.whl → 4.19.0a1733970382__py3-none-any.whl

pulumi_kubernetes/resource/v1alpha3/_inputs.py

@@ -17,6 +17,8 @@ from ... import core as _core
 from ... import meta as _meta
 
 __all__ = [
+    'AllocatedDeviceStatusArgs',
+    'AllocatedDeviceStatusArgsDict',
     'AllocationResultArgs',
     'AllocationResultArgsDict',
     'BasicDevicePatchArgs',
@@ -69,6 +71,8 @@ __all__ = [
     'DeviceSelectorArgsDict',
     'DeviceArgs',
     'DeviceArgsDict',
+    'NetworkDeviceDataArgs',
+    'NetworkDeviceDataArgsDict',
     'OpaqueDeviceConfigurationPatchArgs',
     'OpaqueDeviceConfigurationPatchArgsDict',
     'OpaqueDeviceConfigurationArgs',
@@ -107,10 +111,163 @@ __all__ = [
     'ResourceSliceSpecPatchArgsDict',
     'ResourceSliceSpecArgs',
     'ResourceSliceSpecArgsDict',
+    'ResourceSliceArgs',
+    'ResourceSliceArgsDict',
 ]
 
 MYPY = False
 
+if not MYPY:
+    class AllocatedDeviceStatusArgsDict(TypedDict):
+        """
+        AllocatedDeviceStatus contains the status of an allocated device, if the driver chooses to report it. This may include driver-specific information.
+        """
+        device: pulumi.Input[str]
+        """
+        Device references one device instance via its name in the driver's resource pool. It must be a DNS label.
+        """
+        driver: pulumi.Input[str]
+        """
+        Driver specifies the name of the DRA driver whose kubelet plugin should be invoked to process the allocation once the claim is needed on a node.
+
+        Must be a DNS subdomain and should end with a DNS domain owned by the vendor of the driver.
+        """
+        pool: pulumi.Input[str]
+        """
+        This name together with the driver name and the device name field identify which device was allocated (`<driver name>/<pool name>/<device name>`).
+
+        Must not be longer than 253 characters and may contain one or more DNS sub-domains separated by slashes.
+        """
+        conditions: NotRequired[pulumi.Input[Sequence[pulumi.Input['_meta.v1.ConditionArgsDict']]]]
+        """
+        Conditions contains the latest observation of the device's state. If the device has been configured according to the class and claim config references, the `Ready` condition should be True.
+        """
+        data: NotRequired[Any]
+        """
+        Data contains arbitrary driver-specific data.
+
+        The length of the raw data must be smaller or equal to 10 Ki.
+        """
+        network_data: NotRequired[pulumi.Input['NetworkDeviceDataArgsDict']]
+        """
+        NetworkData contains network-related information specific to the device.
+        """
+elif False:
+    AllocatedDeviceStatusArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AllocatedDeviceStatusArgs:
+    def __init__(__self__, *,
+                 device: pulumi.Input[str],
+                 driver: pulumi.Input[str],
+                 pool: pulumi.Input[str],
+                 conditions: Optional[pulumi.Input[Sequence[pulumi.Input['_meta.v1.ConditionArgs']]]] = None,
+                 data: Optional[Any] = None,
+                 network_data: Optional[pulumi.Input['NetworkDeviceDataArgs']] = None):
+        """
+        AllocatedDeviceStatus contains the status of an allocated device, if the driver chooses to report it. This may include driver-specific information.
+        :param pulumi.Input[str] device: Device references one device instance via its name in the driver's resource pool. It must be a DNS label.
+        :param pulumi.Input[str] driver: Driver specifies the name of the DRA driver whose kubelet plugin should be invoked to process the allocation once the claim is needed on a node.
+               
+               Must be a DNS subdomain and should end with a DNS domain owned by the vendor of the driver.
+        :param pulumi.Input[str] pool: This name together with the driver name and the device name field identify which device was allocated (`<driver name>/<pool name>/<device name>`).
+               
+               Must not be longer than 253 characters and may contain one or more DNS sub-domains separated by slashes.
+        :param pulumi.Input[Sequence[pulumi.Input['_meta.v1.ConditionArgs']]] conditions: Conditions contains the latest observation of the device's state. If the device has been configured according to the class and claim config references, the `Ready` condition should be True.
+        :param Any data: Data contains arbitrary driver-specific data.
+               
+               The length of the raw data must be smaller or equal to 10 Ki.
+        :param pulumi.Input['NetworkDeviceDataArgs'] network_data: NetworkData contains network-related information specific to the device.
+        """
+        pulumi.set(__self__, "device", device)
+        pulumi.set(__self__, "driver", driver)
+        pulumi.set(__self__, "pool", pool)
+        if conditions is not None:
+            pulumi.set(__self__, "conditions", conditions)
+        if data is not None:
+            pulumi.set(__self__, "data", data)
+        if network_data is not None:
+            pulumi.set(__self__, "network_data", network_data)
+
+    @property
+    @pulumi.getter
+    def device(self) -> pulumi.Input[str]:
+        """
+        Device references one device instance via its name in the driver's resource pool. It must be a DNS label.
+        """
+        return pulumi.get(self, "device")
+
+    @device.setter
+    def device(self, value: pulumi.Input[str]):
+        pulumi.set(self, "device", value)
+
+    @property
+    @pulumi.getter
+    def driver(self) -> pulumi.Input[str]:
+        """
+        Driver specifies the name of the DRA driver whose kubelet plugin should be invoked to process the allocation once the claim is needed on a node.
+
+        Must be a DNS subdomain and should end with a DNS domain owned by the vendor of the driver.
+        """
+        return pulumi.get(self, "driver")
+
+    @driver.setter
+    def driver(self, value: pulumi.Input[str]):
+        pulumi.set(self, "driver", value)
+
+    @property
+    @pulumi.getter
+    def pool(self) -> pulumi.Input[str]:
+        """
+        This name together with the driver name and the device name field identify which device was allocated (`<driver name>/<pool name>/<device name>`).
+
+        Must not be longer than 253 characters and may contain one or more DNS sub-domains separated by slashes.
+        """
+        return pulumi.get(self, "pool")
+
+    @pool.setter
+    def pool(self, value: pulumi.Input[str]):
+        pulumi.set(self, "pool", value)
+
+    @property
+    @pulumi.getter
+    def conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['_meta.v1.ConditionArgs']]]]:
+        """
+        Conditions contains the latest observation of the device's state. If the device has been configured according to the class and claim config references, the `Ready` condition should be True.
+        """
+        return pulumi.get(self, "conditions")
+
+    @conditions.setter
+    def conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['_meta.v1.ConditionArgs']]]]):
+        pulumi.set(self, "conditions", value)
+
+    @property
+    @pulumi.getter
+    def data(self) -> Optional[Any]:
+        """
+        Data contains arbitrary driver-specific data.
+
+        The length of the raw data must be smaller or equal to 10 Ki.
+        """
+        return pulumi.get(self, "data")
+
+    @data.setter
+    def data(self, value: Optional[Any]):
+        pulumi.set(self, "data", value)
+
+    @property
+    @pulumi.getter(name="networkData")
+    def network_data(self) -> Optional[pulumi.Input['NetworkDeviceDataArgs']]:
+        """
+        NetworkData contains network-related information specific to the device.
+        """
+        return pulumi.get(self, "network_data")
+
+    @network_data.setter
+    def network_data(self, value: Optional[pulumi.Input['NetworkDeviceDataArgs']]):
+        pulumi.set(self, "network_data", value)
+
+
 if not MYPY:
     class AllocationResultArgsDict(TypedDict):
         """
@@ -369,6 +526,8 @@ if not MYPY:
         For ease of use, the cel.bind() function is enabled, and can be used to simplify expressions that access multiple attributes with the same domain. For example:
 
             cel.bind(dra, device.attributes["dra.example.com"], dra.someBool && dra.anotherBool)
+
+        The length of the expression must be smaller or equal to 10 Ki. The cost of evaluating it is also limited based on the estimated number of logical steps.
         """
 elif False:
     CELDeviceSelectorPatchArgsDict: TypeAlias = Mapping[str, Any]
@@ -406,6 +565,8 @@ class CELDeviceSelectorPatchArgs:
                For ease of use, the cel.bind() function is enabled, and can be used to simplify expressions that access multiple attributes with the same domain. For example:
                
                    cel.bind(dra, device.attributes["dra.example.com"], dra.someBool && dra.anotherBool)
+               
+               The length of the expression must be smaller or equal to 10 Ki. The cost of evaluating it is also limited based on the estimated number of logical steps.
         """
         if expression is not None:
             pulumi.set(__self__, "expression", expression)
@@ -441,6 +602,8 @@ class CELDeviceSelectorPatchArgs:
         For ease of use, the cel.bind() function is enabled, and can be used to simplify expressions that access multiple attributes with the same domain. For example:
 
             cel.bind(dra, device.attributes["dra.example.com"], dra.someBool && dra.anotherBool)
+
+        The length of the expression must be smaller or equal to 10 Ki. The cost of evaluating it is also limited based on the estimated number of logical steps.
         """
         return pulumi.get(self, "expression")
 
@@ -483,6 +646,8 @@ if not MYPY:
         For ease of use, the cel.bind() function is enabled, and can be used to simplify expressions that access multiple attributes with the same domain. For example:
 
             cel.bind(dra, device.attributes["dra.example.com"], dra.someBool && dra.anotherBool)
+
+        The length of the expression must be smaller or equal to 10 Ki. The cost of evaluating it is also limited based on the estimated number of logical steps.
         """
 elif False:
     CELDeviceSelectorArgsDict: TypeAlias = Mapping[str, Any]
@@ -520,6 +685,8 @@ class CELDeviceSelectorArgs:
                For ease of use, the cel.bind() function is enabled, and can be used to simplify expressions that access multiple attributes with the same domain. For example:
                
                    cel.bind(dra, device.attributes["dra.example.com"], dra.someBool && dra.anotherBool)
+               
+               The length of the expression must be smaller or equal to 10 Ki. The cost of evaluating it is also limited based on the estimated number of logical steps.
         """
         pulumi.set(__self__, "expression", expression)
 
@@ -554,6 +721,8 @@ class CELDeviceSelectorArgs:
         For ease of use, the cel.bind() function is enabled, and can be used to simplify expressions that access multiple attributes with the same domain. For example:
 
             cel.bind(dra, device.attributes["dra.example.com"], dra.someBool && dra.anotherBool)
+
+        The length of the expression must be smaller or equal to 10 Ki. The cost of evaluating it is also limited based on the estimated number of logical steps.
         """
         return pulumi.get(self, "expression")
 
@@ -1647,6 +1816,12 @@ if not MYPY:
         """
         Request is the name of the request in the claim which caused this device to be allocated. Multiple devices may have been allocated per request.
         """
+        admin_access: NotRequired[pulumi.Input[bool]]
+        """
+        AdminAccess indicates that this device was allocated for administrative access. See the corresponding request field for a definition of mode.
+
+        This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
+        """
 elif False:
     DeviceRequestAllocationResultArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -1656,7 +1831,8 @@ class DeviceRequestAllocationResultArgs:
                  device: pulumi.Input[str],
                  driver: pulumi.Input[str],
                  pool: pulumi.Input[str],
-                 request: pulumi.Input[str]):
+                 request: pulumi.Input[str],
+                 admin_access: Optional[pulumi.Input[bool]] = None):
         """
         DeviceRequestAllocationResult contains the allocation result for one request.
         :param pulumi.Input[str] device: Device references one device instance via its name in the driver's resource pool. It must be a DNS label.
@@ -1667,11 +1843,16 @@ class DeviceRequestAllocationResultArgs:
                
                Must not be longer than 253 characters and may contain one or more DNS sub-domains separated by slashes.
         :param pulumi.Input[str] request: Request is the name of the request in the claim which caused this device to be allocated. Multiple devices may have been allocated per request.
+        :param pulumi.Input[bool] admin_access: AdminAccess indicates that this device was allocated for administrative access. See the corresponding request field for a definition of mode.
+               
+               This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
         """
         pulumi.set(__self__, "device", device)
         pulumi.set(__self__, "driver", driver)
         pulumi.set(__self__, "pool", pool)
         pulumi.set(__self__, "request", request)
+        if admin_access is not None:
+            pulumi.set(__self__, "admin_access", admin_access)
 
     @property
     @pulumi.getter
@@ -1725,6 +1906,20 @@ class DeviceRequestAllocationResultArgs:
     def request(self, value: pulumi.Input[str]):
         pulumi.set(self, "request", value)
 
+    @property
+    @pulumi.getter(name="adminAccess")
+    def admin_access(self) -> Optional[pulumi.Input[bool]]:
+        """
+        AdminAccess indicates that this device was allocated for administrative access. See the corresponding request field for a definition of mode.
+
+        This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
+        """
+        return pulumi.get(self, "admin_access")
+
+    @admin_access.setter
+    def admin_access(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "admin_access", value)
+
 
 if not MYPY:
     class DeviceRequestPatchArgsDict(TypedDict):
@@ -1736,6 +1931,8 @@ if not MYPY:
         admin_access: NotRequired[pulumi.Input[bool]]
         """
         AdminAccess indicates that this is a claim for administrative access to the device(s). Claims with AdminAccess are expected to be used for monitoring or other management services for a device.  They ignore all ordinary claims to the device with respect to access modes and any resource allocations.
+
+        This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
         """
         allocation_mode: NotRequired[pulumi.Input[str]]
         """
@@ -1792,6 +1989,8 @@ class DeviceRequestPatchArgs:
 
         A DeviceClassName is currently required. Clients must check that it is indeed set. It's absence indicates that something changed in a way that is not supported by the client yet, in which case it must refuse to handle the request.
         :param pulumi.Input[bool] admin_access: AdminAccess indicates that this is a claim for administrative access to the device(s). Claims with AdminAccess are expected to be used for monitoring or other management services for a device.  They ignore all ordinary claims to the device with respect to access modes and any resource allocations.
+               
+               This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
         :param pulumi.Input[str] allocation_mode: AllocationMode and its related fields define how devices are allocated to satisfy this request. Supported values are:
                
                - ExactCount: This request is for a specific number of devices.
@@ -1834,6 +2033,8 @@ class DeviceRequestPatchArgs:
     def admin_access(self) -> Optional[pulumi.Input[bool]]:
         """
         AdminAccess indicates that this is a claim for administrative access to the device(s). Claims with AdminAccess are expected to be used for monitoring or other management services for a device.  They ignore all ordinary claims to the device with respect to access modes and any resource allocations.
+
+        This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
         """
         return pulumi.get(self, "admin_access")
 
@@ -1944,6 +2145,8 @@ if not MYPY:
         admin_access: NotRequired[pulumi.Input[bool]]
         """
         AdminAccess indicates that this is a claim for administrative access to the device(s). Claims with AdminAccess are expected to be used for monitoring or other management services for a device.  They ignore all ordinary claims to the device with respect to access modes and any resource allocations.
+
+        This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
         """
         allocation_mode: NotRequired[pulumi.Input[str]]
         """
@@ -1994,6 +2197,8 @@ class DeviceRequestArgs:
                
                Must be a DNS label.
         :param pulumi.Input[bool] admin_access: AdminAccess indicates that this is a claim for administrative access to the device(s). Claims with AdminAccess are expected to be used for monitoring or other management services for a device.  They ignore all ordinary claims to the device with respect to access modes and any resource allocations.
+               
+               This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
         :param pulumi.Input[str] allocation_mode: AllocationMode and its related fields define how devices are allocated to satisfy this request. Supported values are:
                
                - ExactCount: This request is for a specific number of devices.
@@ -2056,6 +2261,8 @@ class DeviceRequestArgs:
     def admin_access(self) -> Optional[pulumi.Input[bool]]:
         """
         AdminAccess indicates that this is a claim for administrative access to the device(s). Claims with AdminAccess are expected to be used for monitoring or other management services for a device.  They ignore all ordinary claims to the device with respect to access modes and any resource allocations.
+
+        This is an alpha field and requires enabling the DRAAdminAccess feature gate. Admin access is disabled if this field is unset or set to false, otherwise it is enabled.
         """
         return pulumi.get(self, "admin_access")
 
@@ -2239,6 +2446,94 @@ class DeviceArgs:
         pulumi.set(self, "basic", value)
 
 
+if not MYPY:
+    class NetworkDeviceDataArgsDict(TypedDict):
+        """
+        NetworkDeviceData provides network-related details for the allocated device. This information may be filled by drivers or other components to configure or identify the device within a network context.
+        """
+        hardware_address: NotRequired[pulumi.Input[str]]
+        """
+        HardwareAddress represents the hardware address (e.g. MAC Address) of the device's network interface.
+
+        Must not be longer than 128 characters.
+        """
+        interface_name: NotRequired[pulumi.Input[str]]
+        """
+        InterfaceName specifies the name of the network interface associated with the allocated device. This might be the name of a physical or virtual network interface being configured in the pod.
+
+        Must not be longer than 256 characters.
+        """
+        ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        IPs lists the network addresses assigned to the device's network interface. This can include both IPv4 and IPv6 addresses. The IPs are in the CIDR notation, which includes both the address and the associated subnet mask. e.g.: "192.0.2.5/24" for IPv4 and "2001:db8::5/64" for IPv6.
+        """
+elif False:
+    NetworkDeviceDataArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NetworkDeviceDataArgs:
+    def __init__(__self__, *,
+                 hardware_address: Optional[pulumi.Input[str]] = None,
+                 interface_name: Optional[pulumi.Input[str]] = None,
+                 ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        NetworkDeviceData provides network-related details for the allocated device. This information may be filled by drivers or other components to configure or identify the device within a network context.
+        :param pulumi.Input[str] hardware_address: HardwareAddress represents the hardware address (e.g. MAC Address) of the device's network interface.
+               
+               Must not be longer than 128 characters.
+        :param pulumi.Input[str] interface_name: InterfaceName specifies the name of the network interface associated with the allocated device. This might be the name of a physical or virtual network interface being configured in the pod.
+               
+               Must not be longer than 256 characters.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] ips: IPs lists the network addresses assigned to the device's network interface. This can include both IPv4 and IPv6 addresses. The IPs are in the CIDR notation, which includes both the address and the associated subnet mask. e.g.: "192.0.2.5/24" for IPv4 and "2001:db8::5/64" for IPv6.
+        """
+        if hardware_address is not None:
+            pulumi.set(__self__, "hardware_address", hardware_address)
+        if interface_name is not None:
+            pulumi.set(__self__, "interface_name", interface_name)
+        if ips is not None:
+            pulumi.set(__self__, "ips", ips)
+
+    @property
+    @pulumi.getter(name="hardwareAddress")
+    def hardware_address(self) -> Optional[pulumi.Input[str]]:
+        """
+        HardwareAddress represents the hardware address (e.g. MAC Address) of the device's network interface.
+
+        Must not be longer than 128 characters.
+        """
+        return pulumi.get(self, "hardware_address")
+
+    @hardware_address.setter
+    def hardware_address(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "hardware_address", value)
+
+    @property
+    @pulumi.getter(name="interfaceName")
+    def interface_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        InterfaceName specifies the name of the network interface associated with the allocated device. This might be the name of a physical or virtual network interface being configured in the pod.
+
+        Must not be longer than 256 characters.
+        """
+        return pulumi.get(self, "interface_name")
+
+    @interface_name.setter
+    def interface_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "interface_name", value)
+
+    @property
+    @pulumi.getter
+    def ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        IPs lists the network addresses assigned to the device's network interface. This can include both IPv4 and IPv6 addresses. The IPs are in the CIDR notation, which includes both the address and the associated subnet mask. e.g.: "192.0.2.5/24" for IPv4 and "2001:db8::5/64" for IPv6.
+        """
+        return pulumi.get(self, "ips")
+
+    @ips.setter
+    def ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "ips", value)
+
+
 if not MYPY:
     class OpaqueDeviceConfigurationPatchArgsDict(TypedDict):
         """
@@ -2255,6 +2550,8 @@ if not MYPY:
         parameters: NotRequired[Any]
         """
         Parameters can contain arbitrary data. It is the responsibility of the driver developer to handle validation and versioning. Typically this includes self-identification and a version ("kind" + "apiVersion" for Kubernetes types), with conversion between different versions.
+
+        The length of the raw data must be smaller or equal to 10 Ki.
         """
 elif False:
     OpaqueDeviceConfigurationPatchArgsDict: TypeAlias = Mapping[str, Any]
@@ -2272,6 +2569,8 @@ class OpaqueDeviceConfigurationPatchArgs:
                
                Must be a DNS subdomain and should end with a DNS domain owned by the vendor of the driver.
         :param Any parameters: Parameters can contain arbitrary data. It is the responsibility of the driver developer to handle validation and versioning. Typically this includes self-identification and a version ("kind" + "apiVersion" for Kubernetes types), with conversion between different versions.
+               
+               The length of the raw data must be smaller or equal to 10 Ki.
         """
         if driver is not None:
             pulumi.set(__self__, "driver", driver)
@@ -2299,6 +2598,8 @@ class OpaqueDeviceConfigurationPatchArgs:
     def parameters(self) -> Optional[Any]:
         """
         Parameters can contain arbitrary data. It is the responsibility of the driver developer to handle validation and versioning. Typically this includes self-identification and a version ("kind" + "apiVersion" for Kubernetes types), with conversion between different versions.
+
+        The length of the raw data must be smaller or equal to 10 Ki.
         """
         return pulumi.get(self, "parameters")
 
@@ -2323,6 +2624,8 @@ if not MYPY:
         parameters: Any
         """
         Parameters can contain arbitrary data. It is the responsibility of the driver developer to handle validation and versioning. Typically this includes self-identification and a version ("kind" + "apiVersion" for Kubernetes types), with conversion between different versions.
+
+        The length of the raw data must be smaller or equal to 10 Ki.
         """
 elif False:
     OpaqueDeviceConfigurationArgsDict: TypeAlias = Mapping[str, Any]
@@ -2340,6 +2643,8 @@ class OpaqueDeviceConfigurationArgs:
                
                Must be a DNS subdomain and should end with a DNS domain owned by the vendor of the driver.
         :param Any parameters: Parameters can contain arbitrary data. It is the responsibility of the driver developer to handle validation and versioning. Typically this includes self-identification and a version ("kind" + "apiVersion" for Kubernetes types), with conversion between different versions.
+               
+               The length of the raw data must be smaller or equal to 10 Ki.
         """
         pulumi.set(__self__, "driver", driver)
         pulumi.set(__self__, "parameters", parameters)
@@ -2365,6 +2670,8 @@ class OpaqueDeviceConfigurationArgs:
     def parameters(self) -> Any:
         """
         Parameters can contain arbitrary data. It is the responsibility of the driver developer to handle validation and versioning. Typically this includes self-identification and a version ("kind" + "apiVersion" for Kubernetes types), with conversion between different versions.
+
+        The length of the raw data must be smaller or equal to 10 Ki.
         """
         return pulumi.get(self, "parameters")
 
@@ -2959,6 +3266,10 @@ if not MYPY:
 
         This is an alpha field and requires enabling the DRAControlPlaneController feature gate.
         """
+        devices: NotRequired[pulumi.Input[Sequence[pulumi.Input['AllocatedDeviceStatusArgsDict']]]]
+        """
+        Devices contains the status of each device allocated for this claim, as reported by the driver. This can include driver-specific information. Entries are owned by their respective drivers.
+        """
         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. A claim that is in use or might be in use because it has been reserved must not get deallocated.
@@ -2977,6 +3288,7 @@ class ResourceClaimStatusArgs:
     def __init__(__self__, *,
                  allocation: Optional[pulumi.Input['AllocationResultArgs']] = None,
                  deallocation_requested: Optional[pulumi.Input[bool]] = None,
+                 devices: Optional[pulumi.Input[Sequence[pulumi.Input['AllocatedDeviceStatusArgs']]]] = None,
                  reserved_for: Optional[pulumi.Input[Sequence[pulumi.Input['ResourceClaimConsumerReferenceArgs']]]] = None):
         """
         ResourceClaimStatus tracks whether the resource has been allocated and what the result of that was.
@@ -2986,6 +3298,7 @@ class ResourceClaimStatusArgs:
                This is only used if the claim needs to be deallocated by a DRA driver. That driver then must deallocate this claim and reset the field together with clearing the Allocation field.
                
                This is an alpha field and requires enabling the DRAControlPlaneController feature gate.
+        :param pulumi.Input[Sequence[pulumi.Input['AllocatedDeviceStatusArgs']]] devices: Devices contains the status of each device allocated for this claim, as reported by the driver. This can include driver-specific information. Entries are owned by their respective drivers.
         :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. A claim that is in use or might be in use because it has been reserved must not get deallocated.
                
                In a cluster with multiple scheduler instances, two pods might get scheduled concurrently by different schedulers. When they reference the same ResourceClaim which already has reached its maximum number of consumers, only one pod can be scheduled.
@@ -2998,6 +3311,8 @@ class ResourceClaimStatusArgs:
             pulumi.set(__self__, "allocation", allocation)
         if deallocation_requested is not None:
             pulumi.set(__self__, "deallocation_requested", deallocation_requested)
+        if devices is not None:
+            pulumi.set(__self__, "devices", devices)
         if reserved_for is not None:
             pulumi.set(__self__, "reserved_for", reserved_for)
 
@@ -3029,6 +3344,18 @@ class ResourceClaimStatusArgs:
     def deallocation_requested(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "deallocation_requested", value)
 
+    @property
+    @pulumi.getter
+    def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AllocatedDeviceStatusArgs']]]]:
+        """
+        Devices contains the status of each device allocated for this claim, as reported by the driver. This can include driver-specific information. Entries are owned by their respective drivers.
+        """
+        return pulumi.get(self, "devices")
+
+    @devices.setter
+    def devices(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AllocatedDeviceStatusArgs']]]]):
+        pulumi.set(self, "devices", value)
+
     @property
     @pulumi.getter(name="reservedFor")
     def reserved_for(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourceClaimConsumerReferenceArgs']]]]:
@@ -3055,7 +3382,7 @@ if not MYPY:
         """
         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.
+        ObjectMeta may contain labels and annotations that will be copied into the ResourceClaim when creating it. No other fields are allowed and will be rejected during validation.
         """
         spec: NotRequired[pulumi.Input['ResourceClaimSpecPatchArgsDict']]
         """
@@ -3071,7 +3398,7 @@ class ResourceClaimTemplateSpecPatchArgs:
                  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['_meta.v1.ObjectMetaPatchArgs'] metadata: ObjectMeta may contain labels and annotations that will be copied into the ResourceClaim 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:
@@ -3083,7 +3410,7 @@ class ResourceClaimTemplateSpecPatchArgs:
     @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.
+        ObjectMeta may contain labels and annotations that will be copied into the ResourceClaim when creating it. No other fields are allowed and will be rejected during validation.
         """
         return pulumi.get(self, "metadata")
 
@@ -3115,7 +3442,7 @@ if not MYPY:
         """
         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.
+        ObjectMeta may contain labels and annotations that will be copied into the ResourceClaim when creating it. No other fields are allowed and will be rejected during validation.
         """
 elif False:
     ResourceClaimTemplateSpecArgsDict: TypeAlias = Mapping[str, Any]
@@ -3128,7 +3455,7 @@ class ResourceClaimTemplateSpecArgs:
         """
         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.
+        :param pulumi.Input['_meta.v1.ObjectMetaArgs'] metadata: ObjectMeta may contain labels and annotations that will be copied into the ResourceClaim when creating it. No other fields are allowed and will be rejected during validation.
         """
         pulumi.set(__self__, "spec", spec)
         if metadata is not None:
@@ -3150,7 +3477,7 @@ class ResourceClaimTemplateSpecArgs:
     @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.
+        ObjectMeta may contain labels and annotations that will be copied into the ResourceClaim when creating it. No other fields are allowed and will be rejected during validation.
         """
         return pulumi.get(self, "metadata")
 
@@ -3922,3 +4249,124 @@ class ResourceSliceSpecArgs:
         pulumi.set(self, "node_selector", value)
 
 
+if not MYPY:
+    class ResourceSliceArgsDict(TypedDict):
+        """
+        ResourceSlice represents one or more resources in a pool of similar resources, managed by a common driver. A pool may span more than one ResourceSlice, and exactly how many ResourceSlices comprise a pool is determined by the driver.
+
+        At the moment, the only supported resources are devices with attributes and capacities. Each device in a given pool, regardless of how many ResourceSlices, must have a unique name. The ResourceSlice in which a device gets published may change over time. The unique identifier for a device is the tuple <driver name>, <pool name>, <device name>.
+
+        Whenever a driver needs to update a pool, it increments the pool.Spec.Pool.Generation number and updates all ResourceSlices with that new number and new resource definitions. A consumer must only use ResourceSlices with the highest generation number and ignore all others.
+
+        When allocating all resources in a pool matching certain criteria or when looking for the best solution among several different alternatives, a consumer should check the number of ResourceSlices in a pool (included in each ResourceSlice) to determine whether its view of a pool is complete and if not, should wait until the driver has completed updating the pool.
+
+        For resources that are not local to a node, the node name is not set. Instead, the driver may use a node selector to specify where the devices are available.
+
+        This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
+        """
+        spec: pulumi.Input['ResourceSliceSpecArgsDict']
+        """
+        Contains the information published by the driver.
+
+        Changing the spec automatically increments the metadata.generation number.
+        """
+        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:
+    ResourceSliceArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ResourceSliceArgs:
+    def __init__(__self__, *,
+                 spec: pulumi.Input['ResourceSliceSpecArgs'],
+                 api_version: Optional[pulumi.Input[str]] = None,
+                 kind: Optional[pulumi.Input[str]] = None,
+                 metadata: Optional[pulumi.Input['_meta.v1.ObjectMetaArgs']] = None):
+        """
+        ResourceSlice represents one or more resources in a pool of similar resources, managed by a common driver. A pool may span more than one ResourceSlice, and exactly how many ResourceSlices comprise a pool is determined by the driver.
+
+        At the moment, the only supported resources are devices with attributes and capacities. Each device in a given pool, regardless of how many ResourceSlices, must have a unique name. The ResourceSlice in which a device gets published may change over time. The unique identifier for a device is the tuple <driver name>, <pool name>, <device name>.
+
+        Whenever a driver needs to update a pool, it increments the pool.Spec.Pool.Generation number and updates all ResourceSlices with that new number and new resource definitions. A consumer must only use ResourceSlices with the highest generation number and ignore all others.
+
+        When allocating all resources in a pool matching certain criteria or when looking for the best solution among several different alternatives, a consumer should check the number of ResourceSlices in a pool (included in each ResourceSlice) to determine whether its view of a pool is complete and if not, should wait until the driver has completed updating the pool.
+
+        For resources that are not local to a node, the node name is not set. Instead, the driver may use a node selector to specify where the devices are available.
+
+        This is an alpha type and requires enabling the DynamicResourceAllocation feature gate.
+        :param pulumi.Input['ResourceSliceSpecArgs'] spec: Contains the information published by the driver.
+               
+               Changing the spec automatically increments the metadata.generation number.
+        :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/v1alpha3')
+        if kind is not None:
+            pulumi.set(__self__, "kind", 'ResourceSlice')
+        if metadata is not None:
+            pulumi.set(__self__, "metadata", metadata)
+
+    @property
+    @pulumi.getter
+    def spec(self) -> pulumi.Input['ResourceSliceSpecArgs']:
+        """
+        Contains the information published by the driver.
+
+        Changing the spec automatically increments the metadata.generation number.
+        """
+        return pulumi.get(self, "spec")
+
+    @spec.setter
+    def spec(self, value: pulumi.Input['ResourceSliceSpecArgs']):
+        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)
+
+