pulumi-kubernetes 4.23.0a1746131759__py3-none-any.whl → 4.23.0a1746153578__py3-none-any.whl

pulumi_kubernetes/core/v1/_inputs.py

@@ -358,6 +358,8 @@ __all__ = [
     'NodeSpecArgsDict',
     'NodeStatusArgs',
     'NodeStatusArgsDict',
+    'NodeSwapStatusArgs',
+    'NodeSwapStatusArgsDict',
     'NodeSystemInfoArgs',
     'NodeSystemInfoArgsDict',
     'NodeArgs',
@@ -6258,6 +6260,10 @@ if not MYPY:
         """
         State holds details about the container's current condition.
         """
+        stop_signal: NotRequired[pulumi.Input[builtins.str]]
+        """
+        StopSignal reports the effective stop signal for this container
+        """
         user: NotRequired[pulumi.Input['ContainerUserArgsDict']]
         """
         User represents user identity information initially attached to the first process of the container
@@ -6284,6 +6290,7 @@ class ContainerStatusArgs:
                  resources: Optional[pulumi.Input['ResourceRequirementsArgs']] = None,
                  started: Optional[pulumi.Input[builtins.bool]] = None,
                  state: Optional[pulumi.Input['ContainerStateArgs']] = None,
+                 stop_signal: Optional[pulumi.Input[builtins.str]] = None,
                  user: Optional[pulumi.Input['ContainerUserArgs']] = None,
                  volume_mounts: Optional[pulumi.Input[Sequence[pulumi.Input['VolumeMountStatusArgs']]]] = None):
         """
@@ -6302,6 +6309,7 @@ class ContainerStatusArgs:
         :param pulumi.Input['ResourceRequirementsArgs'] resources: Resources represents the compute resource requests and limits that have been successfully enacted on the running container after it has been started or has been successfully resized.
         :param pulumi.Input[builtins.bool] started: Started indicates whether the container has finished its postStart lifecycle hook and passed its startup probe. Initialized as false, becomes true after startupProbe is considered successful. Resets to false when the container is restarted, or if kubelet loses state temporarily. In both cases, startup probes will run again. Is always true when no startupProbe is defined and container is running and has passed the postStart lifecycle hook. The null value must be treated the same as false.
         :param pulumi.Input['ContainerStateArgs'] state: State holds details about the container's current condition.
+        :param pulumi.Input[builtins.str] stop_signal: StopSignal reports the effective stop signal for this container
         :param pulumi.Input['ContainerUserArgs'] user: User represents user identity information initially attached to the first process of the container
         :param pulumi.Input[Sequence[pulumi.Input['VolumeMountStatusArgs']]] volume_mounts: Status of volume mounts.
         """
@@ -6324,6 +6332,8 @@ class ContainerStatusArgs:
             pulumi.set(__self__, "started", started)
         if state is not None:
             pulumi.set(__self__, "state", state)
+        if stop_signal is not None:
+            pulumi.set(__self__, "stop_signal", stop_signal)
         if user is not None:
             pulumi.set(__self__, "user", user)
         if volume_mounts is not None:
@@ -6475,6 +6485,18 @@ class ContainerStatusArgs:
     def state(self, value: Optional[pulumi.Input['ContainerStateArgs']]):
         pulumi.set(self, "state", value)
 
+    @property
+    @pulumi.getter(name="stopSignal")
+    def stop_signal(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        StopSignal reports the effective stop signal for this container
+        """
+        return pulumi.get(self, "stop_signal")
+
+    @stop_signal.setter
+    def stop_signal(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "stop_signal", value)
+
     @property
     @pulumi.getter
     def user(self) -> Optional[pulumi.Input['ContainerUserArgs']]:
@@ -7556,7 +7578,7 @@ class EmptyDirVolumeSourceArgs:
 if not MYPY:
     class EndpointAddressPatchArgsDict(TypedDict):
         """
-        EndpointAddress is a tuple that describes single IP address.
+        EndpointAddress is a tuple that describes single IP address. Deprecated: This API is deprecated in v1.33+.
         """
         hostname: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -7585,7 +7607,7 @@ class EndpointAddressPatchArgs:
                  node_name: Optional[pulumi.Input[builtins.str]] = None,
                  target_ref: Optional[pulumi.Input['ObjectReferencePatchArgs']] = None):
         """
-        EndpointAddress is a tuple that describes single IP address.
+        EndpointAddress is a tuple that describes single IP address. Deprecated: This API is deprecated in v1.33+.
         :param pulumi.Input[builtins.str] hostname: The Hostname of this endpoint
         :param pulumi.Input[builtins.str] ip: The IP of this endpoint. May not be loopback (127.0.0.0/8 or ::1), link-local (169.254.0.0/16 or fe80::/10), or link-local multicast (224.0.0.0/24 or ff02::/16).
         :param pulumi.Input[builtins.str] node_name: Optional: Node hosting this endpoint. This can be used to determine endpoints local to a node.
@@ -7652,7 +7674,7 @@ class EndpointAddressPatchArgs:
 if not MYPY:
     class EndpointAddressArgsDict(TypedDict):
         """
-        EndpointAddress is a tuple that describes single IP address.
+        EndpointAddress is a tuple that describes single IP address. Deprecated: This API is deprecated in v1.33+.
         """
         ip: pulumi.Input[builtins.str]
         """
@@ -7681,7 +7703,7 @@ class EndpointAddressArgs:
                  node_name: Optional[pulumi.Input[builtins.str]] = None,
                  target_ref: Optional[pulumi.Input['ObjectReferenceArgs']] = None):
         """
-        EndpointAddress is a tuple that describes single IP address.
+        EndpointAddress is a tuple that describes single IP address. Deprecated: This API is deprecated in v1.33+.
         :param pulumi.Input[builtins.str] ip: The IP of this endpoint. May not be loopback (127.0.0.0/8 or ::1), link-local (169.254.0.0/16 or fe80::/10), or link-local multicast (224.0.0.0/24 or ff02::/16).
         :param pulumi.Input[builtins.str] hostname: The Hostname of this endpoint
         :param pulumi.Input[builtins.str] node_name: Optional: Node hosting this endpoint. This can be used to determine endpoints local to a node.
@@ -7747,7 +7769,7 @@ class EndpointAddressArgs:
 if not MYPY:
     class EndpointPortPatchArgsDict(TypedDict):
         """
-        EndpointPort is a tuple that describes a single port.
+        EndpointPort is a tuple that describes a single port. Deprecated: This API is deprecated in v1.33+.
         """
         app_protocol: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -7785,7 +7807,7 @@ class EndpointPortPatchArgs:
                  port: Optional[pulumi.Input[builtins.int]] = None,
                  protocol: Optional[pulumi.Input[builtins.str]] = None):
         """
-        EndpointPort is a tuple that describes a single port.
+        EndpointPort is a tuple that describes a single port. Deprecated: This API is deprecated in v1.33+.
         :param pulumi.Input[builtins.str] app_protocol: The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either:
                
                * Un-prefixed protocol names - reserved for IANA standard service names (as per RFC-6335 and https://www.iana.org/assignments/service-names).
@@ -7870,7 +7892,7 @@ class EndpointPortPatchArgs:
 if not MYPY:
     class EndpointPortArgsDict(TypedDict):
         """
-        EndpointPort is a tuple that describes a single port.
+        EndpointPort is a tuple that describes a single port. Deprecated: This API is deprecated in v1.33+.
         """
         port: pulumi.Input[builtins.int]
         """
@@ -7908,7 +7930,7 @@ class EndpointPortArgs:
                  name: Optional[pulumi.Input[builtins.str]] = None,
                  protocol: Optional[pulumi.Input[builtins.str]] = None):
         """
-        EndpointPort is a tuple that describes a single port.
+        EndpointPort is a tuple that describes a single port. Deprecated: This API is deprecated in v1.33+.
         :param pulumi.Input[builtins.int] port: The port number of the endpoint.
         :param pulumi.Input[builtins.str] app_protocol: The application protocol for this port. This is used as a hint for implementations to offer richer behavior for protocols that they understand. This field follows standard Kubernetes label syntax. Valid values are either:
                
@@ -8003,6 +8025,8 @@ if not MYPY:
 
         	a: [ 10.10.1.1:8675, 10.10.2.2:8675 ],
         	b: [ 10.10.1.1:309, 10.10.2.2:309 ]
+
+        Deprecated: This API is deprecated in v1.33+.
         """
         addresses: NotRequired[pulumi.Input[Sequence[pulumi.Input['EndpointAddressPatchArgsDict']]]]
         """
@@ -8037,6 +8061,8 @@ class EndpointSubsetPatchArgs:
 
         	a: [ 10.10.1.1:8675, 10.10.2.2:8675 ],
         	b: [ 10.10.1.1:309, 10.10.2.2:309 ]
+
+        Deprecated: This API is deprecated in v1.33+.
         :param pulumi.Input[Sequence[pulumi.Input['EndpointAddressPatchArgs']]] addresses: IP addresses which offer the related ports that are marked as ready. These endpoints should be considered safe for load balancers and clients to utilize.
         :param pulumi.Input[Sequence[pulumi.Input['EndpointAddressPatchArgs']]] not_ready_addresses: IP addresses which offer the related ports but are not currently marked as ready because they have not yet finished starting, have recently failed a readiness check, or have recently failed a liveness check.
         :param pulumi.Input[Sequence[pulumi.Input['EndpointPortPatchArgs']]] ports: Port numbers available on the related IP addresses.
@@ -8099,6 +8125,8 @@ if not MYPY:
 
         	a: [ 10.10.1.1:8675, 10.10.2.2:8675 ],
         	b: [ 10.10.1.1:309, 10.10.2.2:309 ]
+
+        Deprecated: This API is deprecated in v1.33+.
         """
         addresses: NotRequired[pulumi.Input[Sequence[pulumi.Input['EndpointAddressArgsDict']]]]
         """
@@ -8133,6 +8161,8 @@ class EndpointSubsetArgs:
 
         	a: [ 10.10.1.1:8675, 10.10.2.2:8675 ],
         	b: [ 10.10.1.1:309, 10.10.2.2:309 ]
+
+        Deprecated: This API is deprecated in v1.33+.
         :param pulumi.Input[Sequence[pulumi.Input['EndpointAddressArgs']]] addresses: IP addresses which offer the related ports that are marked as ready. These endpoints should be considered safe for load balancers and clients to utilize.
         :param pulumi.Input[Sequence[pulumi.Input['EndpointAddressArgs']]] not_ready_addresses: IP addresses which offer the related ports but are not currently marked as ready because they have not yet finished starting, have recently failed a readiness check, or have recently failed a liveness check.
         :param pulumi.Input[Sequence[pulumi.Input['EndpointPortArgs']]] ports: Port numbers available on the related IP addresses.
@@ -8197,6 +8227,10 @@ if not MYPY:
         	     Ports: [{"name": "a", "port": 93}, {"name": "b", "port": 76}]
         	   },
         	]
+
+        Endpoints is a legacy API and does not contain information about all Service features. Use discoveryv1.EndpointSlice for complete information about Service endpoints.
+
+        Deprecated: This API is deprecated in v1.33+. Use discoveryv1.EndpointSlice.
         """
         api_version: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -8238,6 +8272,10 @@ class EndpointsArgs:
         	     Ports: [{"name": "a", "port": 93}, {"name": "b", "port": 76}]
         	   },
         	]
+
+        Endpoints is a legacy API and does not contain information about all Service features. Use discoveryv1.EndpointSlice for complete information about Service endpoints.
+
+        Deprecated: This API is deprecated in v1.33+. Use discoveryv1.EndpointSlice.
         :param pulumi.Input[builtins.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[builtins.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's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
@@ -8304,7 +8342,7 @@ class EndpointsArgs:
 if not MYPY:
     class EnvFromSourcePatchArgsDict(TypedDict):
         """
-        EnvFromSource represents the source of a set of ConfigMaps
+        EnvFromSource represents the source of a set of ConfigMaps or Secrets
         """
         config_map_ref: NotRequired[pulumi.Input['ConfigMapEnvSourcePatchArgsDict']]
         """
@@ -8312,7 +8350,7 @@ if not MYPY:
         """
         prefix: NotRequired[pulumi.Input[builtins.str]]
         """
-        An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.
+        Optional text to prepend to the name of each environment variable. Must be a C_IDENTIFIER.
         """
         secret_ref: NotRequired[pulumi.Input['SecretEnvSourcePatchArgsDict']]
         """
@@ -8328,9 +8366,9 @@ class EnvFromSourcePatchArgs:
                  prefix: Optional[pulumi.Input[builtins.str]] = None,
                  secret_ref: Optional[pulumi.Input['SecretEnvSourcePatchArgs']] = None):
         """
-        EnvFromSource represents the source of a set of ConfigMaps
+        EnvFromSource represents the source of a set of ConfigMaps or Secrets
         :param pulumi.Input['ConfigMapEnvSourcePatchArgs'] config_map_ref: The ConfigMap to select from
-        :param pulumi.Input[builtins.str] prefix: An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.
+        :param pulumi.Input[builtins.str] prefix: Optional text to prepend to the name of each environment variable. Must be a C_IDENTIFIER.
         :param pulumi.Input['SecretEnvSourcePatchArgs'] secret_ref: The Secret to select from
         """
         if config_map_ref is not None:
@@ -8356,7 +8394,7 @@ class EnvFromSourcePatchArgs:
     @pulumi.getter
     def prefix(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.
+        Optional text to prepend to the name of each environment variable. Must be a C_IDENTIFIER.
         """
         return pulumi.get(self, "prefix")
 
@@ -8380,7 +8418,7 @@ class EnvFromSourcePatchArgs:
 if not MYPY:
     class EnvFromSourceArgsDict(TypedDict):
         """
-        EnvFromSource represents the source of a set of ConfigMaps
+        EnvFromSource represents the source of a set of ConfigMaps or Secrets
         """
         config_map_ref: NotRequired[pulumi.Input['ConfigMapEnvSourceArgsDict']]
         """
@@ -8388,7 +8426,7 @@ if not MYPY:
         """
         prefix: NotRequired[pulumi.Input[builtins.str]]
         """
-        An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.
+        Optional text to prepend to the name of each environment variable. Must be a C_IDENTIFIER.
         """
         secret_ref: NotRequired[pulumi.Input['SecretEnvSourceArgsDict']]
         """
@@ -8404,9 +8442,9 @@ class EnvFromSourceArgs:
                  prefix: Optional[pulumi.Input[builtins.str]] = None,
                  secret_ref: Optional[pulumi.Input['SecretEnvSourceArgs']] = None):
         """
-        EnvFromSource represents the source of a set of ConfigMaps
+        EnvFromSource represents the source of a set of ConfigMaps or Secrets
         :param pulumi.Input['ConfigMapEnvSourceArgs'] config_map_ref: The ConfigMap to select from
-        :param pulumi.Input[builtins.str] prefix: An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.
+        :param pulumi.Input[builtins.str] prefix: Optional text to prepend to the name of each environment variable. Must be a C_IDENTIFIER.
         :param pulumi.Input['SecretEnvSourceArgs'] secret_ref: The Secret to select from
         """
         if config_map_ref is not None:
@@ -8432,7 +8470,7 @@ class EnvFromSourceArgs:
     @pulumi.getter
     def prefix(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        An optional identifier to prepend to each key in the ConfigMap. Must be a C_IDENTIFIER.
+        Optional text to prepend to the name of each environment variable. Must be a C_IDENTIFIER.
         """
         return pulumi.get(self, "prefix")
 
@@ -14315,6 +14353,10 @@ if not MYPY:
         """
         PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks
         """
+        stop_signal: NotRequired[pulumi.Input[builtins.str]]
+        """
+        StopSignal defines which signal will be sent to a container when it is being stopped. If not specified, the default is defined by the container runtime in use. StopSignal can only be set for Pods with a non-empty .spec.os.name
+        """
 elif False:
     LifecyclePatchArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -14322,16 +14364,20 @@ elif False:
 class LifecyclePatchArgs:
     def __init__(__self__, *,
                  post_start: Optional[pulumi.Input['LifecycleHandlerPatchArgs']] = None,
-                 pre_stop: Optional[pulumi.Input['LifecycleHandlerPatchArgs']] = None):
+                 pre_stop: Optional[pulumi.Input['LifecycleHandlerPatchArgs']] = None,
+                 stop_signal: Optional[pulumi.Input[builtins.str]] = None):
         """
         Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.
         :param pulumi.Input['LifecycleHandlerPatchArgs'] post_start: PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks
         :param pulumi.Input['LifecycleHandlerPatchArgs'] pre_stop: PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks
+        :param pulumi.Input[builtins.str] stop_signal: StopSignal defines which signal will be sent to a container when it is being stopped. If not specified, the default is defined by the container runtime in use. StopSignal can only be set for Pods with a non-empty .spec.os.name
         """
         if post_start is not None:
             pulumi.set(__self__, "post_start", post_start)
         if pre_stop is not None:
             pulumi.set(__self__, "pre_stop", pre_stop)
+        if stop_signal is not None:
+            pulumi.set(__self__, "stop_signal", stop_signal)
 
     @property
     @pulumi.getter(name="postStart")
@@ -14357,6 +14403,18 @@ class LifecyclePatchArgs:
     def pre_stop(self, value: Optional[pulumi.Input['LifecycleHandlerPatchArgs']]):
         pulumi.set(self, "pre_stop", value)
 
+    @property
+    @pulumi.getter(name="stopSignal")
+    def stop_signal(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        StopSignal defines which signal will be sent to a container when it is being stopped. If not specified, the default is defined by the container runtime in use. StopSignal can only be set for Pods with a non-empty .spec.os.name
+        """
+        return pulumi.get(self, "stop_signal")
+
+    @stop_signal.setter
+    def stop_signal(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "stop_signal", value)
+
 
 if not MYPY:
     class LifecycleArgsDict(TypedDict):
@@ -14371,6 +14429,10 @@ if not MYPY:
         """
         PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks
         """
+        stop_signal: NotRequired[pulumi.Input[builtins.str]]
+        """
+        StopSignal defines which signal will be sent to a container when it is being stopped. If not specified, the default is defined by the container runtime in use. StopSignal can only be set for Pods with a non-empty .spec.os.name
+        """
 elif False:
     LifecycleArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -14378,16 +14440,20 @@ elif False:
 class LifecycleArgs:
     def __init__(__self__, *,
                  post_start: Optional[pulumi.Input['LifecycleHandlerArgs']] = None,
-                 pre_stop: Optional[pulumi.Input['LifecycleHandlerArgs']] = None):
+                 pre_stop: Optional[pulumi.Input['LifecycleHandlerArgs']] = None,
+                 stop_signal: Optional[pulumi.Input[builtins.str]] = None):
         """
         Lifecycle describes actions that the management system should take in response to container lifecycle events. For the PostStart and PreStop lifecycle handlers, management of the container blocks until the action is complete, unless the container process fails, in which case the handler is aborted.
         :param pulumi.Input['LifecycleHandlerArgs'] post_start: PostStart is called immediately after a container is created. If the handler fails, the container is terminated and restarted according to its restart policy. Other management of the container blocks until the hook completes. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks
         :param pulumi.Input['LifecycleHandlerArgs'] pre_stop: PreStop is called immediately before a container is terminated due to an API request or management event such as liveness/startup probe failure, preemption, resource contention, etc. The handler is not called if the container crashes or exits. The Pod's termination grace period countdown begins before the PreStop hook is executed. Regardless of the outcome of the handler, the container will eventually terminate within the Pod's termination grace period (unless delayed by finalizers). Other management of the container blocks until the hook completes or until the termination grace period is reached. More info: https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks
+        :param pulumi.Input[builtins.str] stop_signal: StopSignal defines which signal will be sent to a container when it is being stopped. If not specified, the default is defined by the container runtime in use. StopSignal can only be set for Pods with a non-empty .spec.os.name
         """
         if post_start is not None:
             pulumi.set(__self__, "post_start", post_start)
         if pre_stop is not None:
             pulumi.set(__self__, "pre_stop", pre_stop)
+        if stop_signal is not None:
+            pulumi.set(__self__, "stop_signal", stop_signal)
 
     @property
     @pulumi.getter(name="postStart")
@@ -14413,6 +14479,18 @@ class LifecycleArgs:
     def pre_stop(self, value: Optional[pulumi.Input['LifecycleHandlerArgs']]):
         pulumi.set(self, "pre_stop", value)
 
+    @property
+    @pulumi.getter(name="stopSignal")
+    def stop_signal(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        StopSignal defines which signal will be sent to a container when it is being stopped. If not specified, the default is defined by the container runtime in use. StopSignal can only be set for Pods with a non-empty .spec.os.name
+        """
+        return pulumi.get(self, "stop_signal")
+
+    @stop_signal.setter
+    def stop_signal(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "stop_signal", value)
+
 
 if not MYPY:
     class LimitRangeItemPatchArgsDict(TypedDict):
@@ -17487,6 +17565,42 @@ class NodeStatusArgs:
         pulumi.set(self, "volumes_in_use", value)
 
 
+if not MYPY:
+    class NodeSwapStatusArgsDict(TypedDict):
+        """
+        NodeSwapStatus represents swap memory information.
+        """
+        capacity: NotRequired[pulumi.Input[builtins.int]]
+        """
+        Total amount of swap memory in bytes.
+        """
+elif False:
+    NodeSwapStatusArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NodeSwapStatusArgs:
+    def __init__(__self__, *,
+                 capacity: Optional[pulumi.Input[builtins.int]] = None):
+        """
+        NodeSwapStatus represents swap memory information.
+        :param pulumi.Input[builtins.int] capacity: Total amount of swap memory in bytes.
+        """
+        if capacity is not None:
+            pulumi.set(__self__, "capacity", capacity)
+
+    @property
+    @pulumi.getter
+    def capacity(self) -> Optional[pulumi.Input[builtins.int]]:
+        """
+        Total amount of swap memory in bytes.
+        """
+        return pulumi.get(self, "capacity")
+
+    @capacity.setter
+    def capacity(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "capacity", value)
+
+
 if not MYPY:
     class NodeSystemInfoArgsDict(TypedDict):
         """
@@ -17532,6 +17646,10 @@ if not MYPY:
         """
         SystemUUID reported by the node. For unique machine identification MachineID is preferred. This field is specific to Red Hat hosts https://access.redhat.com/documentation/en-us/red_hat_subscription_management/1/html/rhsm/uuid
         """
+        swap: NotRequired[pulumi.Input['NodeSwapStatusArgsDict']]
+        """
+        Swap Info reported by the node.
+        """
 elif False:
     NodeSystemInfoArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -17547,7 +17665,8 @@ class NodeSystemInfoArgs:
                  machine_id: pulumi.Input[builtins.str],
                  operating_system: pulumi.Input[builtins.str],
                  os_image: pulumi.Input[builtins.str],
-                 system_uuid: pulumi.Input[builtins.str]):
+                 system_uuid: pulumi.Input[builtins.str],
+                 swap: Optional[pulumi.Input['NodeSwapStatusArgs']] = None):
         """
         NodeSystemInfo is a set of ids/uuids to uniquely identify the node.
         :param pulumi.Input[builtins.str] architecture: The Architecture reported by the node
@@ -17560,6 +17679,7 @@ class NodeSystemInfoArgs:
         :param pulumi.Input[builtins.str] operating_system: The Operating System reported by the node
         :param pulumi.Input[builtins.str] os_image: OS Image reported by the node from /etc/os-release (e.g. Debian GNU/Linux 7 (wheezy)).
         :param pulumi.Input[builtins.str] system_uuid: SystemUUID reported by the node. For unique machine identification MachineID is preferred. This field is specific to Red Hat hosts https://access.redhat.com/documentation/en-us/red_hat_subscription_management/1/html/rhsm/uuid
+        :param pulumi.Input['NodeSwapStatusArgs'] swap: Swap Info reported by the node.
         """
         pulumi.set(__self__, "architecture", architecture)
         pulumi.set(__self__, "boot_id", boot_id)
@@ -17571,6 +17691,8 @@ class NodeSystemInfoArgs:
         pulumi.set(__self__, "operating_system", operating_system)
         pulumi.set(__self__, "os_image", os_image)
         pulumi.set(__self__, "system_uuid", system_uuid)
+        if swap is not None:
+            pulumi.set(__self__, "swap", swap)
 
     @property
     @pulumi.getter
@@ -17692,6 +17814,18 @@ class NodeSystemInfoArgs:
     def system_uuid(self, value: pulumi.Input[builtins.str]):
         pulumi.set(self, "system_uuid", value)
 
+    @property
+    @pulumi.getter
+    def swap(self) -> Optional[pulumi.Input['NodeSwapStatusArgs']]:
+        """
+        Swap Info reported by the node.
+        """
+        return pulumi.get(self, "swap")
+
+    @swap.setter
+    def swap(self, value: Optional[pulumi.Input['NodeSwapStatusArgs']]):
+        pulumi.set(self, "swap", value)
+
 
 if not MYPY:
     class NodeArgsDict(TypedDict):
@@ -21678,11 +21812,11 @@ if not MYPY:
         """
         match_label_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
         """
-        MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
+        MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set.
         """
         mismatch_label_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
         """
-        MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
+        MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
         """
         namespace_selector: NotRequired[pulumi.Input['_meta.v1.LabelSelectorPatchArgsDict']]
         """
@@ -21711,8 +21845,8 @@ class PodAffinityTermPatchArgs:
         """
         Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running
         :param pulumi.Input['_meta.v1.LabelSelectorPatchArgs'] label_selector: A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm matches with no Pods.
-        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] match_label_keys: MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
-        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] mismatch_label_keys: MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
+        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] match_label_keys: MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set.
+        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] mismatch_label_keys: MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
         :param pulumi.Input['_meta.v1.LabelSelectorPatchArgs'] namespace_selector: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces.
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] namespaces: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace".
         :param pulumi.Input[builtins.str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
@@ -21746,7 +21880,7 @@ class PodAffinityTermPatchArgs:
     @pulumi.getter(name="matchLabelKeys")
     def match_label_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
         """
-        MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
+        MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set.
         """
         return pulumi.get(self, "match_label_keys")
 
@@ -21758,7 +21892,7 @@ class PodAffinityTermPatchArgs:
     @pulumi.getter(name="mismatchLabelKeys")
     def mismatch_label_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
         """
-        MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
+        MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
         """
         return pulumi.get(self, "mismatch_label_keys")
 
@@ -21818,11 +21952,11 @@ if not MYPY:
         """
         match_label_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
         """
-        MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
+        MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set.
         """
         mismatch_label_keys: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
         """
-        MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
+        MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
         """
         namespace_selector: NotRequired[pulumi.Input['_meta.v1.LabelSelectorArgsDict']]
         """
@@ -21848,8 +21982,8 @@ class PodAffinityTermArgs:
         Defines a set of pods (namely those matching the labelSelector relative to the given namespace(s)) that this pod should be co-located (affinity) or not co-located (anti-affinity) with, where co-located is defined as running on a node whose value of the label with key <topologyKey> matches that of any node on which a pod of the set of pods is running
         :param pulumi.Input[builtins.str] topology_key: This pod should be co-located (affinity) or not co-located (anti-affinity) with the pods matching the labelSelector in the specified namespaces, where co-located is defined as running on a node whose value of the label with key topologyKey matches that of any node on which any of the selected pods is running. Empty topologyKey is not allowed.
         :param pulumi.Input['_meta.v1.LabelSelectorArgs'] label_selector: A label query over a set of resources, in this case pods. If it's null, this PodAffinityTerm matches with no Pods.
-        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] match_label_keys: MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
-        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] mismatch_label_keys: MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
+        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] match_label_keys: MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set.
+        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] mismatch_label_keys: MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
         :param pulumi.Input['_meta.v1.LabelSelectorArgs'] namespace_selector: A label query over the set of namespaces that the term applies to. The term is applied to the union of the namespaces selected by this field and the ones listed in the namespaces field. null selector and null or empty namespaces list means "this pod's namespace". An empty selector ({}) matches all namespaces.
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] namespaces: namespaces specifies a static list of namespace names that the term applies to. The term is applied to the union of the namespaces listed in this field and the ones selected by namespaceSelector. null or empty namespaces list and null namespaceSelector means "this pod's namespace".
         """
@@ -21893,7 +22027,7 @@ class PodAffinityTermArgs:
     @pulumi.getter(name="matchLabelKeys")
     def match_label_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
         """
-        MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
+        MatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key in (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both matchLabelKeys and labelSelector. Also, matchLabelKeys cannot be set when labelSelector isn't set.
         """
         return pulumi.get(self, "match_label_keys")
 
@@ -21905,7 +22039,7 @@ class PodAffinityTermArgs:
     @pulumi.getter(name="mismatchLabelKeys")
     def mismatch_label_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
         """
-        MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set. This is a beta field and requires enabling MatchLabelKeysInPodAffinity feature gate (enabled by default).
+        MismatchLabelKeys is a set of pod label keys to select which pods will be taken into consideration. The keys are used to lookup values from the incoming pod labels, those key-value labels are merged with `labelSelector` as `key notin (value)` to select the group of existing pods which pods will be taken into consideration for the incoming pod's pod (anti) affinity. Keys that don't exist in the incoming pod labels will be ignored. The default value is empty. The same key is forbidden to exist in both mismatchLabelKeys and labelSelector. Also, mismatchLabelKeys cannot be set when labelSelector isn't set.
         """
         return pulumi.get(self, "mismatch_label_keys")
 
@@ -22131,6 +22265,10 @@ if not MYPY:
         """
         Human-readable message indicating details about last transition.
         """
+        observed_generation: NotRequired[pulumi.Input[builtins.int]]
+        """
+        If set, this represents the .metadata.generation that the pod condition was set based upon. This is an alpha field. Enable PodObservedGenerationTracking to be able to use this field.
+        """
         reason: NotRequired[pulumi.Input[builtins.str]]
         """
         Unique, one-word, CamelCase reason for the condition's last transition.
@@ -22146,6 +22284,7 @@ class PodConditionArgs:
                  last_probe_time: Optional[pulumi.Input[builtins.str]] = None,
                  last_transition_time: Optional[pulumi.Input[builtins.str]] = None,
                  message: Optional[pulumi.Input[builtins.str]] = None,
+                 observed_generation: Optional[pulumi.Input[builtins.int]] = None,
                  reason: Optional[pulumi.Input[builtins.str]] = None):
         """
         PodCondition contains details for the current condition of this pod.
@@ -22154,6 +22293,7 @@ class PodConditionArgs:
         :param pulumi.Input[builtins.str] last_probe_time: Last time we probed the condition.
         :param pulumi.Input[builtins.str] last_transition_time: Last time the condition transitioned from one status to another.
         :param pulumi.Input[builtins.str] message: Human-readable message indicating details about last transition.
+        :param pulumi.Input[builtins.int] observed_generation: If set, this represents the .metadata.generation that the pod condition was set based upon. This is an alpha field. Enable PodObservedGenerationTracking to be able to use this field.
         :param pulumi.Input[builtins.str] reason: Unique, one-word, CamelCase reason for the condition's last transition.
         """
         pulumi.set(__self__, "status", status)
@@ -22164,6 +22304,8 @@ class PodConditionArgs:
             pulumi.set(__self__, "last_transition_time", last_transition_time)
         if message is not None:
             pulumi.set(__self__, "message", message)
+        if observed_generation is not None:
+            pulumi.set(__self__, "observed_generation", observed_generation)
         if reason is not None:
             pulumi.set(__self__, "reason", reason)
 
@@ -22227,6 +22369,18 @@ class PodConditionArgs:
     def message(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "message", value)
 
+    @property
+    @pulumi.getter(name="observedGeneration")
+    def observed_generation(self) -> Optional[pulumi.Input[builtins.int]]:
+        """
+        If set, this represents the .metadata.generation that the pod condition was set based upon. This is an alpha field. Enable PodObservedGenerationTracking to be able to use this field.
+        """
+        return pulumi.get(self, "observed_generation")
+
+    @observed_generation.setter
+    def observed_generation(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "observed_generation", value)
+
     @property
     @pulumi.getter
     def reason(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -23757,7 +23911,7 @@ if not MYPY:
         """
         init_containers: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerPatchArgsDict']]]]
         """
-        List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/
+        List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/
         """
         node_name: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -23932,7 +24086,7 @@ class PodSpecPatchArgs:
         :param pulumi.Input[builtins.bool] host_users: Use the host's user namespace. Optional: Default to true. If set to true or not present, the pod will be run in the host user namespace, useful for when the pod needs a feature only available to the host user namespace, such as loading a kernel module with CAP_SYS_MODULE. When set to false, a new userns is created for the pod. Setting false is useful for mitigating container breakout vulnerabilities even allowing users to run their containers as root without actually having root privileges on the host. This field is alpha-level and is only honored by servers that enable the UserNamespacesSupport feature.
         :param pulumi.Input[builtins.str] hostname: Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.
         :param pulumi.Input[Sequence[pulumi.Input['LocalObjectReferencePatchArgs']]] image_pull_secrets: ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images used by this PodSpec. If specified, these secrets will be passed to individual puller implementations for them to use. More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod
-        :param pulumi.Input[Sequence[pulumi.Input['ContainerPatchArgs']]] init_containers: List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/
+        :param pulumi.Input[Sequence[pulumi.Input['ContainerPatchArgs']]] init_containers: List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/
         :param pulumi.Input[builtins.str] node_name: NodeName indicates in which node this pod is scheduled. If empty, this pod is a candidate for scheduling by the scheduler defined in schedulerName. Once this field is set, the kubelet for this node becomes responsible for the lifecycle of this pod. This field should not be used to express a desire for the pod to be scheduled on a specific node. https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#nodename
         :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] node_selector: NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
         :param pulumi.Input['PodOSPatchArgs'] os: Specifies the OS of the containers in the pod. Some pod and container fields are restricted if this is set.
@@ -24237,7 +24391,7 @@ class PodSpecPatchArgs:
     @pulumi.getter(name="initContainers")
     def init_containers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerPatchArgs']]]]:
         """
-        List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/
+        List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/
         """
         return pulumi.get(self, "init_containers")
 
@@ -24615,7 +24769,7 @@ if not MYPY:
         """
         init_containers: NotRequired[pulumi.Input[Sequence[pulumi.Input['ContainerArgsDict']]]]
         """
-        List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/
+        List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/
         """
         node_name: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -24790,7 +24944,7 @@ class PodSpecArgs:
         :param pulumi.Input[builtins.bool] host_users: Use the host's user namespace. Optional: Default to true. If set to true or not present, the pod will be run in the host user namespace, useful for when the pod needs a feature only available to the host user namespace, such as loading a kernel module with CAP_SYS_MODULE. When set to false, a new userns is created for the pod. Setting false is useful for mitigating container breakout vulnerabilities even allowing users to run their containers as root without actually having root privileges on the host. This field is alpha-level and is only honored by servers that enable the UserNamespacesSupport feature.
         :param pulumi.Input[builtins.str] hostname: Specifies the hostname of the Pod If not specified, the pod's hostname will be set to a system-defined value.
         :param pulumi.Input[Sequence[pulumi.Input['LocalObjectReferenceArgs']]] image_pull_secrets: ImagePullSecrets is an optional list of references to secrets in the same namespace to use for pulling any of the images used by this PodSpec. If specified, these secrets will be passed to individual puller implementations for them to use. More info: https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod
-        :param pulumi.Input[Sequence[pulumi.Input['ContainerArgs']]] init_containers: List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/
+        :param pulumi.Input[Sequence[pulumi.Input['ContainerArgs']]] init_containers: List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/
         :param pulumi.Input[builtins.str] node_name: NodeName indicates in which node this pod is scheduled. If empty, this pod is a candidate for scheduling by the scheduler defined in schedulerName. Once this field is set, the kubelet for this node becomes responsible for the lifecycle of this pod. This field should not be used to express a desire for the pod to be scheduled on a specific node. https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#nodename
         :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] node_selector: NodeSelector is a selector which must be true for the pod to fit on a node. Selector which must match a node's labels for the pod to be scheduled on that node. More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
         :param pulumi.Input['PodOSArgs'] os: Specifies the OS of the containers in the pod. Some pod and container fields are restricted if this is set.
@@ -25094,7 +25248,7 @@ class PodSpecArgs:
     @pulumi.getter(name="initContainers")
     def init_containers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerArgs']]]]:
         """
-        List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/
+        List of initialization containers belonging to the pod. Init containers are executed in order prior to containers being started. If any init container fails, the pod is considered to have failed and is handled according to its restartPolicy. The name for an init container or normal container must be unique among all containers. Init containers may not have Lifecycle actions, Readiness probes, Liveness probes, or Startup probes. The resourceRequirements of an init container are taken into account during scheduling by finding the highest request/limit for each resource type, and then using the max of that value or the sum of the normal containers. Limits are applied to init containers in a similar fashion. Init containers cannot currently be added or removed. Cannot be updated. More info: https://kubernetes.io/docs/concepts/workloads/pods/init-containers/
         """
         return pulumi.get(self, "init_containers")
 
@@ -25442,6 +25596,10 @@ if not MYPY:
         """
         nominatedNodeName is set only when this pod preempts other pods on the node, but it cannot be scheduled right away as preemption victims receive their graceful termination periods. This field does not guarantee that the pod will be scheduled on this node. Scheduler may decide to place the pod elsewhere if other nodes become available sooner. Scheduler may also decide to give the resources on this node to a higher priority pod that is created after preemption. As a result, this field may be different than PodSpec.nodeName when the pod is scheduled.
         """
+        observed_generation: NotRequired[pulumi.Input[builtins.int]]
+        """
+        If set, this represents the .metadata.generation that the pod status was set based upon. This is an alpha field. Enable PodObservedGenerationTracking to be able to use this field.
+        """
         phase: NotRequired[pulumi.Input[builtins.str]]
         """
         The phase of a Pod is a simple, high-level summary of where the Pod is in its lifecycle. The conditions array, the reason and message fields, and the individual container status arrays contain more detail about the pod's status. There are five possible phase values:
@@ -25468,7 +25626,7 @@ if not MYPY:
         """
         resize: NotRequired[pulumi.Input[builtins.str]]
         """
-        Status of resources resize desired for pod's containers. It is empty if no resources resize is pending. Any changes to container resources will automatically set this to "Proposed"
+        Status of resources resize desired for pod's containers. It is empty if no resources resize is pending. Any changes to container resources will automatically set this to "Proposed" Deprecated: Resize status is moved to two pod conditions PodResizePending and PodResizeInProgress. PodResizePending will track states where the spec has been resized, but the Kubelet has not yet allocated the resources. PodResizeInProgress will track in-progress resizes, and should be present whenever allocated resources != acknowledged resources.
         """
         resource_claim_statuses: NotRequired[pulumi.Input[Sequence[pulumi.Input['PodResourceClaimStatusArgsDict']]]]
         """
@@ -25492,6 +25650,7 @@ class PodStatusArgs:
                  init_container_statuses: Optional[pulumi.Input[Sequence[pulumi.Input['ContainerStatusArgs']]]] = None,
                  message: Optional[pulumi.Input[builtins.str]] = None,
                  nominated_node_name: Optional[pulumi.Input[builtins.str]] = None,
+                 observed_generation: Optional[pulumi.Input[builtins.int]] = None,
                  phase: Optional[pulumi.Input[builtins.str]] = None,
                  pod_ip: Optional[pulumi.Input[builtins.str]] = None,
                  pod_ips: Optional[pulumi.Input[Sequence[pulumi.Input['PodIPArgs']]]] = None,
@@ -25510,6 +25669,7 @@ class PodStatusArgs:
         :param pulumi.Input[Sequence[pulumi.Input['ContainerStatusArgs']]] init_container_statuses: Statuses of init containers in this pod. The most recent successful non-restartable init container will have ready = true, the most recently started container will have startTime set. Each init container in the pod should have at most one status in this list, and all statuses should be for containers in the pod. However this is not enforced. If a status for a non-existent container is present in the list, or the list has duplicate names, the behavior of various Kubernetes components is not defined and those statuses might be ignored. More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#pod-and-container-status
         :param pulumi.Input[builtins.str] message: A human readable message indicating details about why the pod is in this condition.
         :param pulumi.Input[builtins.str] nominated_node_name: nominatedNodeName is set only when this pod preempts other pods on the node, but it cannot be scheduled right away as preemption victims receive their graceful termination periods. This field does not guarantee that the pod will be scheduled on this node. Scheduler may decide to place the pod elsewhere if other nodes become available sooner. Scheduler may also decide to give the resources on this node to a higher priority pod that is created after preemption. As a result, this field may be different than PodSpec.nodeName when the pod is scheduled.
+        :param pulumi.Input[builtins.int] observed_generation: If set, this represents the .metadata.generation that the pod status was set based upon. This is an alpha field. Enable PodObservedGenerationTracking to be able to use this field.
         :param pulumi.Input[builtins.str] phase: The phase of a Pod is a simple, high-level summary of where the Pod is in its lifecycle. The conditions array, the reason and message fields, and the individual container status arrays contain more detail about the pod's status. There are five possible phase values:
                
                Pending: The pod has been accepted by the Kubernetes system, but one or more of the container images has not been created. This includes time before being scheduled as well as time spent downloading images over the network, which could take a while. Running: The pod has been bound to a node, and all of the containers have been created. At least one container is still running, or is in the process of starting or restarting. Succeeded: All containers in the pod have terminated in success, and will not be restarted. Failed: All containers in the pod have terminated, and at least one container has terminated in failure. The container either exited with non-zero status or was terminated by the system. Unknown: For some reason the state of the pod could not be obtained, typically due to an error in communicating with the host of the pod.
@@ -25519,7 +25679,7 @@ class PodStatusArgs:
         :param pulumi.Input[Sequence[pulumi.Input['PodIPArgs']]] pod_ips: podIPs holds the IP addresses allocated to the pod. If this field is specified, the 0th entry must match the podIP field. Pods may be allocated at most 1 value for each of IPv4 and IPv6. This list is empty if no IPs have been allocated yet.
         :param pulumi.Input[builtins.str] qos_class: The Quality of Service (QOS) classification assigned to the pod based on resource requirements See PodQOSClass type for available QOS classes More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-qos/#quality-of-service-classes
         :param pulumi.Input[builtins.str] reason: A brief CamelCase message indicating details about why the pod is in this state. e.g. 'Evicted'
-        :param pulumi.Input[builtins.str] resize: Status of resources resize desired for pod's containers. It is empty if no resources resize is pending. Any changes to container resources will automatically set this to "Proposed"
+        :param pulumi.Input[builtins.str] resize: Status of resources resize desired for pod's containers. It is empty if no resources resize is pending. Any changes to container resources will automatically set this to "Proposed" Deprecated: Resize status is moved to two pod conditions PodResizePending and PodResizeInProgress. PodResizePending will track states where the spec has been resized, but the Kubelet has not yet allocated the resources. PodResizeInProgress will track in-progress resizes, and should be present whenever allocated resources != acknowledged resources.
         :param pulumi.Input[Sequence[pulumi.Input['PodResourceClaimStatusArgs']]] resource_claim_statuses: Status of resource claims.
         :param pulumi.Input[builtins.str] start_time: RFC 3339 date and time at which the object was acknowledged by the Kubelet. This is before the Kubelet pulled the container image(s) for the pod.
         """
@@ -25539,6 +25699,8 @@ class PodStatusArgs:
             pulumi.set(__self__, "message", message)
         if nominated_node_name is not None:
             pulumi.set(__self__, "nominated_node_name", nominated_node_name)
+        if observed_generation is not None:
+            pulumi.set(__self__, "observed_generation", observed_generation)
         if phase is not None:
             pulumi.set(__self__, "phase", phase)
         if pod_ip is not None:
@@ -25652,6 +25814,18 @@ class PodStatusArgs:
     def nominated_node_name(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "nominated_node_name", value)
 
+    @property
+    @pulumi.getter(name="observedGeneration")
+    def observed_generation(self) -> Optional[pulumi.Input[builtins.int]]:
+        """
+        If set, this represents the .metadata.generation that the pod status was set based upon. This is an alpha field. Enable PodObservedGenerationTracking to be able to use this field.
+        """
+        return pulumi.get(self, "observed_generation")
+
+    @observed_generation.setter
+    def observed_generation(self, value: Optional[pulumi.Input[builtins.int]]):
+        pulumi.set(self, "observed_generation", value)
+
     @property
     @pulumi.getter
     def phase(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -25720,7 +25894,7 @@ class PodStatusArgs:
     @pulumi.getter
     def resize(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        Status of resources resize desired for pod's containers. It is empty if no resources resize is pending. Any changes to container resources will automatically set this to "Proposed"
+        Status of resources resize desired for pod's containers. It is empty if no resources resize is pending. Any changes to container resources will automatically set this to "Proposed" Deprecated: Resize status is moved to two pod conditions PodResizePending and PodResizeInProgress. PodResizePending will track states where the spec has been resized, but the Kubelet has not yet allocated the resources. PodResizeInProgress will track in-progress resizes, and should be present whenever allocated resources != acknowledged resources.
         """
         return pulumi.get(self, "resize")
 
@@ -32946,7 +33120,7 @@ if not MYPY:
         """
         traffic_distribution: NotRequired[pulumi.Input[builtins.str]]
         """
-        TrafficDistribution offers a way to express preferences for how traffic is distributed to Service endpoints. Implementations can use this field as a hint, but are not required to guarantee strict adherence. If the field is not set, the implementation will apply its default routing strategy. If set to "PreferClose", implementations should prioritize endpoints that are topologically close (e.g., same zone). This is a beta field and requires enabling ServiceTrafficDistribution feature.
+        TrafficDistribution offers a way to express preferences for how traffic is distributed to Service endpoints. Implementations can use this field as a hint, but are not required to guarantee strict adherence. If the field is not set, the implementation will apply its default routing strategy. If set to "PreferClose", implementations should prioritize endpoints that are in the same zone.
         """
         type: NotRequired[pulumi.Input[Union[builtins.str, 'ServiceSpecType']]]
         """
@@ -33006,7 +33180,7 @@ class ServiceSpecPatchArgs:
         :param pulumi.Input[builtins.str] session_affinity: Supports "ClientIP" and "None". Used to maintain session affinity. Enable client IP based session affinity. Must be ClientIP or None. Defaults to None. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies
         :param pulumi.Input['SessionAffinityConfigPatchArgs'] session_affinity_config: sessionAffinityConfig contains the configurations of session affinity.
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] topology_keys: topologyKeys is a preference-order list of topology keys which implementations of services should use to preferentially sort endpoints when accessing this Service, it can not be used at the same time as externalTrafficPolicy=Local. Topology keys must be valid label keys and at most 16 keys may be specified. Endpoints are chosen based on the first topology key with available backends. If this field is specified and all entries have no backends that match the topology of the client, the service has no backends for that client and connections should fail. The special value "*" may be used to mean "any topology". This catch-all value, if used, only makes sense as the last value in the list. If this is not specified or empty, no topology constraints will be applied.
-        :param pulumi.Input[builtins.str] traffic_distribution: TrafficDistribution offers a way to express preferences for how traffic is distributed to Service endpoints. Implementations can use this field as a hint, but are not required to guarantee strict adherence. If the field is not set, the implementation will apply its default routing strategy. If set to "PreferClose", implementations should prioritize endpoints that are topologically close (e.g., same zone). This is a beta field and requires enabling ServiceTrafficDistribution feature.
+        :param pulumi.Input[builtins.str] traffic_distribution: TrafficDistribution offers a way to express preferences for how traffic is distributed to Service endpoints. Implementations can use this field as a hint, but are not required to guarantee strict adherence. If the field is not set, the implementation will apply its default routing strategy. If set to "PreferClose", implementations should prioritize endpoints that are in the same zone.
         :param pulumi.Input[Union[builtins.str, 'ServiceSpecType']] type: type determines how the Service is exposed. Defaults to ClusterIP. Valid options are ExternalName, ClusterIP, NodePort, and LoadBalancer. "ClusterIP" allocates a cluster-internal IP address for load-balancing to endpoints. Endpoints are determined by the selector or if that is not specified, by manual construction of an Endpoints object or EndpointSlice objects. If clusterIP is "None", no virtual IP is allocated and the endpoints are published as a set of endpoints rather than a virtual IP. "NodePort" builds on ClusterIP and allocates a port on every node which routes to the same endpoints as the clusterIP. "LoadBalancer" builds on NodePort and creates an external load-balancer (if supported in the current cloud) which routes to the same endpoints as the clusterIP. "ExternalName" aliases this service to the specified externalName. Several other fields do not apply to ExternalName services. More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types
         """
         if allocate_load_balancer_node_ports is not None:
@@ -33302,7 +33476,7 @@ class ServiceSpecPatchArgs:
     @pulumi.getter(name="trafficDistribution")
     def traffic_distribution(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        TrafficDistribution offers a way to express preferences for how traffic is distributed to Service endpoints. Implementations can use this field as a hint, but are not required to guarantee strict adherence. If the field is not set, the implementation will apply its default routing strategy. If set to "PreferClose", implementations should prioritize endpoints that are topologically close (e.g., same zone). This is a beta field and requires enabling ServiceTrafficDistribution feature.
+        TrafficDistribution offers a way to express preferences for how traffic is distributed to Service endpoints. Implementations can use this field as a hint, but are not required to guarantee strict adherence. If the field is not set, the implementation will apply its default routing strategy. If set to "PreferClose", implementations should prioritize endpoints that are in the same zone.
         """
         return pulumi.get(self, "traffic_distribution")
 
@@ -33414,7 +33588,7 @@ if not MYPY:
         """
         traffic_distribution: NotRequired[pulumi.Input[builtins.str]]
         """
-        TrafficDistribution offers a way to express preferences for how traffic is distributed to Service endpoints. Implementations can use this field as a hint, but are not required to guarantee strict adherence. If the field is not set, the implementation will apply its default routing strategy. If set to "PreferClose", implementations should prioritize endpoints that are topologically close (e.g., same zone). This is a beta field and requires enabling ServiceTrafficDistribution feature.
+        TrafficDistribution offers a way to express preferences for how traffic is distributed to Service endpoints. Implementations can use this field as a hint, but are not required to guarantee strict adherence. If the field is not set, the implementation will apply its default routing strategy. If set to "PreferClose", implementations should prioritize endpoints that are in the same zone.
         """
         type: NotRequired[pulumi.Input[Union[builtins.str, 'ServiceSpecType']]]
         """
@@ -33474,7 +33648,7 @@ class ServiceSpecArgs:
         :param pulumi.Input[builtins.str] session_affinity: Supports "ClientIP" and "None". Used to maintain session affinity. Enable client IP based session affinity. Must be ClientIP or None. Defaults to None. More info: https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies
         :param pulumi.Input['SessionAffinityConfigArgs'] session_affinity_config: sessionAffinityConfig contains the configurations of session affinity.
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] topology_keys: topologyKeys is a preference-order list of topology keys which implementations of services should use to preferentially sort endpoints when accessing this Service, it can not be used at the same time as externalTrafficPolicy=Local. Topology keys must be valid label keys and at most 16 keys may be specified. Endpoints are chosen based on the first topology key with available backends. If this field is specified and all entries have no backends that match the topology of the client, the service has no backends for that client and connections should fail. The special value "*" may be used to mean "any topology". This catch-all value, if used, only makes sense as the last value in the list. If this is not specified or empty, no topology constraints will be applied.
-        :param pulumi.Input[builtins.str] traffic_distribution: TrafficDistribution offers a way to express preferences for how traffic is distributed to Service endpoints. Implementations can use this field as a hint, but are not required to guarantee strict adherence. If the field is not set, the implementation will apply its default routing strategy. If set to "PreferClose", implementations should prioritize endpoints that are topologically close (e.g., same zone). This is a beta field and requires enabling ServiceTrafficDistribution feature.
+        :param pulumi.Input[builtins.str] traffic_distribution: TrafficDistribution offers a way to express preferences for how traffic is distributed to Service endpoints. Implementations can use this field as a hint, but are not required to guarantee strict adherence. If the field is not set, the implementation will apply its default routing strategy. If set to "PreferClose", implementations should prioritize endpoints that are in the same zone.
         :param pulumi.Input[Union[builtins.str, 'ServiceSpecType']] type: type determines how the Service is exposed. Defaults to ClusterIP. Valid options are ExternalName, ClusterIP, NodePort, and LoadBalancer. "ClusterIP" allocates a cluster-internal IP address for load-balancing to endpoints. Endpoints are determined by the selector or if that is not specified, by manual construction of an Endpoints object or EndpointSlice objects. If clusterIP is "None", no virtual IP is allocated and the endpoints are published as a set of endpoints rather than a virtual IP. "NodePort" builds on ClusterIP and allocates a port on every node which routes to the same endpoints as the clusterIP. "LoadBalancer" builds on NodePort and creates an external load-balancer (if supported in the current cloud) which routes to the same endpoints as the clusterIP. "ExternalName" aliases this service to the specified externalName. Several other fields do not apply to ExternalName services. More info: https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types
         """
         if allocate_load_balancer_node_ports is not None:
@@ -33770,7 +33944,7 @@ class ServiceSpecArgs:
     @pulumi.getter(name="trafficDistribution")
     def traffic_distribution(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        TrafficDistribution offers a way to express preferences for how traffic is distributed to Service endpoints. Implementations can use this field as a hint, but are not required to guarantee strict adherence. If the field is not set, the implementation will apply its default routing strategy. If set to "PreferClose", implementations should prioritize endpoints that are topologically close (e.g., same zone). This is a beta field and requires enabling ServiceTrafficDistribution feature.
+        TrafficDistribution offers a way to express preferences for how traffic is distributed to Service endpoints. Implementations can use this field as a hint, but are not required to guarantee strict adherence. If the field is not set, the implementation will apply its default routing strategy. If set to "PreferClose", implementations should prioritize endpoints that are in the same zone.
         """
         return pulumi.get(self, "traffic_distribution")
 
@@ -35458,13 +35632,13 @@ if not MYPY:
         """
         NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.
 
-        If this value is nil, the behavior is equivalent to the Honor policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
+        If this value is nil, the behavior is equivalent to the Honor policy.
         """
         node_taints_policy: NotRequired[pulumi.Input[builtins.str]]
         """
         NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included.
 
-        If this value is nil, the behavior is equivalent to the Ignore policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
+        If this value is nil, the behavior is equivalent to the Ignore policy.
         """
         topology_key: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -35503,10 +35677,10 @@ class TopologySpreadConstraintPatchArgs:
                For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | |  P P  |  P P  |  P P  | The number of domains is less than 5(MinDomains), so "global minimum" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.
         :param pulumi.Input[builtins.str] node_affinity_policy: NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.
                
-               If this value is nil, the behavior is equivalent to the Honor policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
+               If this value is nil, the behavior is equivalent to the Honor policy.
         :param pulumi.Input[builtins.str] node_taints_policy: NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included.
                
-               If this value is nil, the behavior is equivalent to the Ignore policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
+               If this value is nil, the behavior is equivalent to the Ignore policy.
         :param pulumi.Input[builtins.str] topology_key: TopologyKey is the key of node labels. Nodes that have a label with this key and identical values are considered to be in the same topology. We consider each <key, value> as a "bucket", and try to put balanced number of pods into each bucket. We define a domain as a particular instance of a topology. Also, we define an eligible domain as a domain whose nodes meet the requirements of nodeAffinityPolicy and nodeTaintsPolicy. e.g. If TopologyKey is "kubernetes.io/hostname", each Node is a domain of that topology. And, if TopologyKey is "topology.kubernetes.io/zone", each zone is a domain of that topology. It's a required field.
         :param pulumi.Input[builtins.str] when_unsatisfiable: WhenUnsatisfiable indicates how to deal with a pod if it doesn't satisfy the spread constraint. - DoNotSchedule (default) tells the scheduler not to schedule it. - ScheduleAnyway tells the scheduler to schedule the pod in any location,
                  but giving higher precedence to topologies that would help reduce the
@@ -35588,7 +35762,7 @@ class TopologySpreadConstraintPatchArgs:
         """
         NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.
 
-        If this value is nil, the behavior is equivalent to the Honor policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
+        If this value is nil, the behavior is equivalent to the Honor policy.
         """
         return pulumi.get(self, "node_affinity_policy")
 
@@ -35602,7 +35776,7 @@ class TopologySpreadConstraintPatchArgs:
         """
         NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included.
 
-        If this value is nil, the behavior is equivalent to the Ignore policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
+        If this value is nil, the behavior is equivalent to the Ignore policy.
         """
         return pulumi.get(self, "node_taints_policy")
 
@@ -35678,13 +35852,13 @@ if not MYPY:
         """
         NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.
 
-        If this value is nil, the behavior is equivalent to the Honor policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
+        If this value is nil, the behavior is equivalent to the Honor policy.
         """
         node_taints_policy: NotRequired[pulumi.Input[builtins.str]]
         """
         NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included.
 
-        If this value is nil, the behavior is equivalent to the Ignore policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
+        If this value is nil, the behavior is equivalent to the Ignore policy.
         """
 elif False:
     TopologySpreadConstraintArgsDict: TypeAlias = Mapping[str, Any]
@@ -35717,10 +35891,10 @@ class TopologySpreadConstraintArgs:
                For example, in a 3-zone cluster, MaxSkew is set to 2, MinDomains is set to 5 and pods with the same labelSelector spread as 2/2/2: | zone1 | zone2 | zone3 | |  P P  |  P P  |  P P  | The number of domains is less than 5(MinDomains), so "global minimum" is treated as 0. In this situation, new pod with the same labelSelector cannot be scheduled, because computed skew will be 3(3 - 0) if new Pod is scheduled to any of the three zones, it will violate MaxSkew.
         :param pulumi.Input[builtins.str] node_affinity_policy: NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.
                
-               If this value is nil, the behavior is equivalent to the Honor policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
+               If this value is nil, the behavior is equivalent to the Honor policy.
         :param pulumi.Input[builtins.str] node_taints_policy: NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included.
                
-               If this value is nil, the behavior is equivalent to the Ignore policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
+               If this value is nil, the behavior is equivalent to the Ignore policy.
         """
         pulumi.set(__self__, "max_skew", max_skew)
         pulumi.set(__self__, "topology_key", topology_key)
@@ -35821,7 +35995,7 @@ class TopologySpreadConstraintArgs:
         """
         NodeAffinityPolicy indicates how we will treat Pod's nodeAffinity/nodeSelector when calculating pod topology spread skew. Options are: - Honor: only nodes matching nodeAffinity/nodeSelector are included in the calculations. - Ignore: nodeAffinity/nodeSelector are ignored. All nodes are included in the calculations.
 
-        If this value is nil, the behavior is equivalent to the Honor policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
+        If this value is nil, the behavior is equivalent to the Honor policy.
         """
         return pulumi.get(self, "node_affinity_policy")
 
@@ -35835,7 +36009,7 @@ class TopologySpreadConstraintArgs:
         """
         NodeTaintsPolicy indicates how we will treat node taints when calculating pod topology spread skew. Options are: - Honor: nodes without taints, along with tainted nodes for which the incoming pod has a toleration, are included. - Ignore: node taints are ignored. All nodes are included.
 
-        If this value is nil, the behavior is equivalent to the Ignore policy. This is a beta-level feature default enabled by the NodeInclusionPolicyInPodTopologySpread feature flag.
+        If this value is nil, the behavior is equivalent to the Ignore policy.
         """
         return pulumi.get(self, "node_taints_policy")
 
@@ -36910,7 +37084,7 @@ if not MYPY:
 
         - Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. - Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. - IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails.
 
-        The volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro) and non-executable files (noexec). Sub path mounts for containers are not supported (spec.containers[*].volumeMounts.subpath). The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type.
+        The volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro) and non-executable files (noexec). Sub path mounts for containers are not supported (spec.containers[*].volumeMounts.subpath) before 1.33. The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type.
         """
         iscsi: NotRequired[pulumi.Input['ISCSIVolumeSourcePatchArgsDict']]
         """
@@ -37037,7 +37211,7 @@ class VolumePatchArgs:
                
                - Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. - Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. - IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails.
                
-               The volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro) and non-executable files (noexec). Sub path mounts for containers are not supported (spec.containers[*].volumeMounts.subpath). The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type.
+               The volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro) and non-executable files (noexec). Sub path mounts for containers are not supported (spec.containers[*].volumeMounts.subpath) before 1.33. The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type.
         :param pulumi.Input['ISCSIVolumeSourcePatchArgs'] iscsi: iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://examples.k8s.io/volumes/iscsi/README.md
         :param pulumi.Input[builtins.str] name: name of the volume. Must be a DNS_LABEL and unique within the pod. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
         :param pulumi.Input['NFSVolumeSourcePatchArgs'] nfs: nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs
@@ -37340,7 +37514,7 @@ class VolumePatchArgs:
 
         - Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. - Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. - IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails.
 
-        The volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro) and non-executable files (noexec). Sub path mounts for containers are not supported (spec.containers[*].volumeMounts.subpath). The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type.
+        The volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro) and non-executable files (noexec). Sub path mounts for containers are not supported (spec.containers[*].volumeMounts.subpath) before 1.33. The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type.
         """
         return pulumi.get(self, "image")
 
@@ -37981,7 +38155,7 @@ if not MYPY:
 
         - Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. - Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. - IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails.
 
-        The volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro) and non-executable files (noexec). Sub path mounts for containers are not supported (spec.containers[*].volumeMounts.subpath). The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type.
+        The volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro) and non-executable files (noexec). Sub path mounts for containers are not supported (spec.containers[*].volumeMounts.subpath) before 1.33. The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type.
         """
         iscsi: NotRequired[pulumi.Input['ISCSIVolumeSourceArgsDict']]
         """
@@ -38105,7 +38279,7 @@ class VolumeArgs:
                
                - Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. - Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. - IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails.
                
-               The volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro) and non-executable files (noexec). Sub path mounts for containers are not supported (spec.containers[*].volumeMounts.subpath). The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type.
+               The volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro) and non-executable files (noexec). Sub path mounts for containers are not supported (spec.containers[*].volumeMounts.subpath) before 1.33. The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type.
         :param pulumi.Input['ISCSIVolumeSourceArgs'] iscsi: iscsi represents an ISCSI Disk resource that is attached to a kubelet's host machine and then exposed to the pod. More info: https://examples.k8s.io/volumes/iscsi/README.md
         :param pulumi.Input['NFSVolumeSourceArgs'] nfs: nfs represents an NFS mount on the host that shares a pod's lifetime More info: https://kubernetes.io/docs/concepts/storage/volumes#nfs
         :param pulumi.Input['PersistentVolumeClaimVolumeSourceArgs'] persistent_volume_claim: persistentVolumeClaimVolumeSource represents a reference to a PersistentVolumeClaim in the same namespace. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims
@@ -38418,7 +38592,7 @@ class VolumeArgs:
 
         - Always: the kubelet always attempts to pull the reference. Container creation will fail If the pull fails. - Never: the kubelet never pulls the reference and only uses a local image or artifact. Container creation will fail if the reference isn't present. - IfNotPresent: the kubelet pulls if the reference isn't already present on disk. Container creation will fail if the reference isn't present and the pull fails.
 
-        The volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro) and non-executable files (noexec). Sub path mounts for containers are not supported (spec.containers[*].volumeMounts.subpath). The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type.
+        The volume gets re-resolved if the pod gets deleted and recreated, which means that new remote content will become available on pod recreation. A failure to resolve or pull the image during pod startup will block containers from starting and may add significant latency. Failures will be retried using normal volume backoff and will be reported on the pod reason and message. The types of objects that may be mounted by this volume are defined by the container runtime implementation on a host machine and at minimum must include all valid types supported by the container image field. The OCI object gets mounted in a single directory (spec.containers[*].volumeMounts.mountPath) by merging the manifest layers in the same way as for container images. The volume will be mounted read-only (ro) and non-executable files (noexec). Sub path mounts for containers are not supported (spec.containers[*].volumeMounts.subpath) before 1.33. The field spec.securityContext.fsGroupChangePolicy has no effect on this volume type.
         """
         return pulumi.get(self, "image")