pulumi-gcp 8.11.0__py3-none-any.whl → 8.11.0a1732282007__py3-none-any.whl

pulumi_gcp/compute/url_map.py

@@ -34,7 +34,7 @@ class URLMapArgs:
                  tests: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapTestArgs']]]] = None):
         """
         The set of arguments for constructing a URLMap resource.
-        :param pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs'] default_custom_error_response_policy: defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendService or BackendBucket responds with an error.
+        :param pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs'] default_custom_error_response_policy: defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
                This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
                For example, consider a UrlMap with the following configuration:
                UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
@@ -107,7 +107,7 @@ class URLMapArgs:
     @pulumi.getter(name="defaultCustomErrorResponsePolicy")
     def default_custom_error_response_policy(self) -> Optional[pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs']]:
         """
-        defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendService or BackendBucket responds with an error.
+        defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
         This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
         For example, consider a UrlMap with the following configuration:
         UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
@@ -291,7 +291,7 @@ class _URLMapState:
         """
         Input properties used for looking up and filtering URLMap resources.
         :param pulumi.Input[str] creation_timestamp: Creation timestamp in RFC3339 text format.
-        :param pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs'] default_custom_error_response_policy: defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendService or BackendBucket responds with an error.
+        :param pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs'] default_custom_error_response_policy: defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
                This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
                For example, consider a UrlMap with the following configuration:
                UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
@@ -388,7 +388,7 @@ class _URLMapState:
     @pulumi.getter(name="defaultCustomErrorResponsePolicy")
     def default_custom_error_response_policy(self) -> Optional[pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs']]:
         """
-        defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendService or BackendBucket responds with an error.
+        defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
         This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
         For example, consider a UrlMap with the following configuration:
         UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
@@ -1291,7 +1291,7 @@ class URLMap(pulumi.CustomResource):
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
-        :param pulumi.Input[Union['URLMapDefaultCustomErrorResponsePolicyArgs', 'URLMapDefaultCustomErrorResponsePolicyArgsDict']] default_custom_error_response_policy: defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendService or BackendBucket responds with an error.
+        :param pulumi.Input[Union['URLMapDefaultCustomErrorResponsePolicyArgs', 'URLMapDefaultCustomErrorResponsePolicyArgsDict']] default_custom_error_response_policy: defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
                This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
                For example, consider a UrlMap with the following configuration:
                UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
@@ -2110,7 +2110,7 @@ class URLMap(pulumi.CustomResource):
         :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[str] creation_timestamp: Creation timestamp in RFC3339 text format.
-        :param pulumi.Input[Union['URLMapDefaultCustomErrorResponsePolicyArgs', 'URLMapDefaultCustomErrorResponsePolicyArgsDict']] default_custom_error_response_policy: defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendService or BackendBucket responds with an error.
+        :param pulumi.Input[Union['URLMapDefaultCustomErrorResponsePolicyArgs', 'URLMapDefaultCustomErrorResponsePolicyArgsDict']] default_custom_error_response_policy: defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
                This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
                For example, consider a UrlMap with the following configuration:
                UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
@@ -2193,7 +2193,7 @@ class URLMap(pulumi.CustomResource):
     @pulumi.getter(name="defaultCustomErrorResponsePolicy")
     def default_custom_error_response_policy(self) -> pulumi.Output[Optional['outputs.URLMapDefaultCustomErrorResponsePolicy']]:
         """
-        defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendService or BackendBucket responds with an error.
+        defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
         This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
         For example, consider a UrlMap with the following configuration:
         UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors

pulumi_gcp/config/__init__.pyi

@@ -159,8 +159,6 @@ dialogflowCustomEndpoint: Optional[str]
 
 dialogflowCxCustomEndpoint: Optional[str]
 
-disableGlobalProjectWarning: bool
-
 disableGooglePartnerName: Optional[bool]
 
 discoveryEngineCustomEndpoint: Optional[str]
@@ -197,8 +195,6 @@ firebaserulesCustomEndpoint: Optional[str]
 
 firestoreCustomEndpoint: Optional[str]
 
-geminiCustomEndpoint: Optional[str]
-
 gkeBackupCustomEndpoint: Optional[str]
 
 gkeHub2CustomEndpoint: Optional[str]

pulumi_gcp/config/vars.py

@@ -309,10 +309,6 @@ class _ExportableConfig(types.ModuleType):
     def dialogflow_cx_custom_endpoint(self) -> Optional[str]:
         return __config__.get('dialogflowCxCustomEndpoint')
 
-    @property
-    def disable_global_project_warning(self) -> bool:
-        return __config__.get_bool('disableGlobalProjectWarning') or (_utilities.get_env_bool('PULUMI_GCP_DISABLE_GLOBAL_PROJECT_WARNING') or False)
-
     @property
     def disable_google_partner_name(self) -> Optional[bool]:
         return __config__.get_bool('disableGooglePartnerName')
@@ -385,10 +381,6 @@ class _ExportableConfig(types.ModuleType):
     def firestore_custom_endpoint(self) -> Optional[str]:
         return __config__.get('firestoreCustomEndpoint')
 
-    @property
-    def gemini_custom_endpoint(self) -> Optional[str]:
-        return __config__.get('geminiCustomEndpoint')
-
     @property
     def gke_backup_custom_endpoint(self) -> Optional[str]:
         return __config__.get('gkeBackupCustomEndpoint')

pulumi_gcp/container/_inputs.py

@@ -229,8 +229,6 @@ __all__ = [
     'ClusterDnsConfigArgsDict',
     'ClusterEnableK8sBetaApisArgs',
     'ClusterEnableK8sBetaApisArgsDict',
-    'ClusterEnterpriseConfigArgs',
-    'ClusterEnterpriseConfigArgsDict',
     'ClusterFleetArgs',
     'ClusterFleetArgsDict',
     'ClusterGatewayApiConfigArgs',
@@ -335,8 +333,6 @@ __all__ = [
     'ClusterNodePoolArgsDict',
     'ClusterNodePoolAutoConfigArgs',
     'ClusterNodePoolAutoConfigArgsDict',
-    'ClusterNodePoolAutoConfigLinuxNodeConfigArgs',
-    'ClusterNodePoolAutoConfigLinuxNodeConfigArgsDict',
     'ClusterNodePoolAutoConfigNetworkTagsArgs',
     'ClusterNodePoolAutoConfigNetworkTagsArgsDict',
     'ClusterNodePoolAutoConfigNodeKubeletConfigArgs',
@@ -5774,7 +5770,7 @@ if not MYPY:
         """
         disk_type: NotRequired[pulumi.Input[str]]
         """
-        Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd', 'pd-balanced', or 'hyperdisk-balanced'). Defaults to `hyperdisk-balanced` if `hyperdisk-balanced` is supported and `pd-balanced` is not supported for the machine type; otherwise defaults to `pd-balanced`.
+        Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced'). Defaults to `pd-standard`
         """
         image_type: NotRequired[pulumi.Input[str]]
         """
@@ -5827,7 +5823,7 @@ class ClusterClusterAutoscalingAutoProvisioningDefaultsArgs:
         """
         :param pulumi.Input[str] boot_disk_kms_key: The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: https://cloud.google.com/compute/docs/disks/customer-managed-encryption
         :param pulumi.Input[int] disk_size: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB. Defaults to `100`
-        :param pulumi.Input[str] disk_type: Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd', 'pd-balanced', or 'hyperdisk-balanced'). Defaults to `hyperdisk-balanced` if `hyperdisk-balanced` is supported and `pd-balanced` is not supported for the machine type; otherwise defaults to `pd-balanced`.
+        :param pulumi.Input[str] disk_type: Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced'). Defaults to `pd-standard`
         :param pulumi.Input[str] image_type: The default image type used by NAP once a new node pool is being created. Please note that according to the [official documentation](https://cloud.google.com/kubernetes-engine/docs/how-to/node-auto-provisioning#default-image-type) the value must be one of the [COS_CONTAINERD, COS, UBUNTU_CONTAINERD, UBUNTU]. __NOTE__ : COS AND UBUNTU are deprecated as of `GKE 1.24`
         :param pulumi.Input['ClusterClusterAutoscalingAutoProvisioningDefaultsManagementArgs'] management: NodeManagement configuration for this NodePool. Structure is documented below.
         :param pulumi.Input[str] min_cpu_platform: Minimum CPU platform to be used for NAP created node pools. The instance may be scheduled on the
@@ -5889,7 +5885,7 @@ class ClusterClusterAutoscalingAutoProvisioningDefaultsArgs:
     @pulumi.getter(name="diskType")
     def disk_type(self) -> Optional[pulumi.Input[str]]:
         """
-        Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd', 'pd-balanced', or 'hyperdisk-balanced'). Defaults to `hyperdisk-balanced` if `hyperdisk-balanced` is supported and `pd-balanced` is not supported for the machine type; otherwise defaults to `pd-balanced`.
+        Type of the disk attached to each node (e.g. 'pd-standard', 'pd-ssd' or 'pd-balanced'). Defaults to `pd-standard`
         """
         return pulumi.get(self, "disk_type")
 
@@ -6873,58 +6869,6 @@ class ClusterEnableK8sBetaApisArgs:
         pulumi.set(self, "enabled_apis", value)
 
 
-if not MYPY:
-    class ClusterEnterpriseConfigArgsDict(TypedDict):
-        cluster_tier: NotRequired[pulumi.Input[str]]
-        """
-        The effective tier of the cluster.
-        """
-        desired_tier: NotRequired[pulumi.Input[str]]
-        """
-        Sets the tier of the cluster. Available options include `STANDARD` and `ENTERPRISE`.
-        """
-elif False:
-    ClusterEnterpriseConfigArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ClusterEnterpriseConfigArgs:
-    def __init__(__self__, *,
-                 cluster_tier: Optional[pulumi.Input[str]] = None,
-                 desired_tier: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input[str] cluster_tier: The effective tier of the cluster.
-        :param pulumi.Input[str] desired_tier: Sets the tier of the cluster. Available options include `STANDARD` and `ENTERPRISE`.
-        """
-        if cluster_tier is not None:
-            pulumi.set(__self__, "cluster_tier", cluster_tier)
-        if desired_tier is not None:
-            pulumi.set(__self__, "desired_tier", desired_tier)
-
-    @property
-    @pulumi.getter(name="clusterTier")
-    def cluster_tier(self) -> Optional[pulumi.Input[str]]:
-        """
-        The effective tier of the cluster.
-        """
-        return pulumi.get(self, "cluster_tier")
-
-    @cluster_tier.setter
-    def cluster_tier(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "cluster_tier", value)
-
-    @property
-    @pulumi.getter(name="desiredTier")
-    def desired_tier(self) -> Optional[pulumi.Input[str]]:
-        """
-        Sets the tier of the cluster. Available options include `STANDARD` and `ENTERPRISE`.
-        """
-        return pulumi.get(self, "desired_tier")
-
-    @desired_tier.setter
-    def desired_tier(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "desired_tier", value)
-
-
 if not MYPY:
     class ClusterFleetArgsDict(TypedDict):
         membership: NotRequired[pulumi.Input[str]]
@@ -8474,13 +8418,6 @@ if not MYPY:
         The amount of local SSD disks that will be
         attached to each cluster node. Defaults to 0.
         """
-        local_ssd_encryption_mode: NotRequired[pulumi.Input[str]]
-        """
-        Possible Local SSD encryption modes:
-        Accepted values are:
-        * `STANDARD_ENCRYPTION`: The given node will be encrypted using keys managed by Google infrastructure and the keys wll be deleted when the node is deleted.
-        * `EPHEMERAL_KEY_ENCRYPTION`: The given node will opt-in for using ephemeral key for encrypting Local SSDs. The Local SSDs will not be able to recover data in case of node crash.
-        """
         logging_variant: NotRequired[pulumi.Input[str]]
         """
         Parameter for specifying the type of logging agent used in a node pool. This will override any cluster-wide default value. Valid values include DEFAULT and MAX_THROUGHPUT. See [Increasing logging agent throughput](https://cloud.google.com/stackdriver/docs/solutions/gke/managing-logs#throughput) for more information.
@@ -8617,7 +8554,6 @@ class ClusterNodeConfigArgs:
                  linux_node_config: Optional[pulumi.Input['ClusterNodeConfigLinuxNodeConfigArgs']] = None,
                  local_nvme_ssd_block_config: Optional[pulumi.Input['ClusterNodeConfigLocalNvmeSsdBlockConfigArgs']] = None,
                  local_ssd_count: Optional[pulumi.Input[int]] = None,
-                 local_ssd_encryption_mode: Optional[pulumi.Input[str]] = None,
                  logging_variant: Optional[pulumi.Input[str]] = None,
                  machine_type: Optional[pulumi.Input[str]] = None,
                  metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -8689,10 +8625,6 @@ class ClusterNodeConfigArgs:
         :param pulumi.Input['ClusterNodeConfigLocalNvmeSsdBlockConfigArgs'] local_nvme_ssd_block_config: Parameters for the local NVMe SSDs. Structure is documented below.
         :param pulumi.Input[int] local_ssd_count: The amount of local SSD disks that will be
                attached to each cluster node. Defaults to 0.
-        :param pulumi.Input[str] local_ssd_encryption_mode: Possible Local SSD encryption modes:
-               Accepted values are:
-               * `STANDARD_ENCRYPTION`: The given node will be encrypted using keys managed by Google infrastructure and the keys wll be deleted when the node is deleted.
-               * `EPHEMERAL_KEY_ENCRYPTION`: The given node will opt-in for using ephemeral key for encrypting Local SSDs. The Local SSDs will not be able to recover data in case of node crash.
         :param pulumi.Input[str] logging_variant: Parameter for specifying the type of logging agent used in a node pool. This will override any cluster-wide default value. Valid values include DEFAULT and MAX_THROUGHPUT. See [Increasing logging agent throughput](https://cloud.google.com/stackdriver/docs/solutions/gke/managing-logs#throughput) for more information.
         :param pulumi.Input[str] machine_type: The name of a Google Compute Engine machine type.
                Defaults to `e2-medium`. To create a custom machine type, value should be set as specified
@@ -8785,8 +8717,6 @@ class ClusterNodeConfigArgs:
             pulumi.set(__self__, "local_nvme_ssd_block_config", local_nvme_ssd_block_config)
         if local_ssd_count is not None:
             pulumi.set(__self__, "local_ssd_count", local_ssd_count)
-        if local_ssd_encryption_mode is not None:
-            pulumi.set(__self__, "local_ssd_encryption_mode", local_ssd_encryption_mode)
         if logging_variant is not None:
             pulumi.set(__self__, "logging_variant", logging_variant)
         if machine_type is not None:
@@ -9109,21 +9039,6 @@ class ClusterNodeConfigArgs:
     def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "local_ssd_count", value)
 
-    @property
-    @pulumi.getter(name="localSsdEncryptionMode")
-    def local_ssd_encryption_mode(self) -> Optional[pulumi.Input[str]]:
-        """
-        Possible Local SSD encryption modes:
-        Accepted values are:
-        * `STANDARD_ENCRYPTION`: The given node will be encrypted using keys managed by Google infrastructure and the keys wll be deleted when the node is deleted.
-        * `EPHEMERAL_KEY_ENCRYPTION`: The given node will opt-in for using ephemeral key for encrypting Local SSDs. The Local SSDs will not be able to recover data in case of node crash.
-        """
-        return pulumi.get(self, "local_ssd_encryption_mode")
-
-    @local_ssd_encryption_mode.setter
-    def local_ssd_encryption_mode(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "local_ssd_encryption_mode", value)
-
     @property
     @pulumi.getter(name="loggingVariant")
     def logging_variant(self) -> Optional[pulumi.Input[str]]:
@@ -11283,10 +11198,6 @@ class ClusterNodePoolArgs:
 
 if not MYPY:
     class ClusterNodePoolAutoConfigArgsDict(TypedDict):
-        linux_node_config: NotRequired[pulumi.Input['ClusterNodePoolAutoConfigLinuxNodeConfigArgsDict']]
-        """
-        Linux system configuration for the cluster's automatically provisioned node pools. Only `cgroup_mode` field is supported in `node_pool_auto_config`. Structure is documented below.
-        """
         network_tags: NotRequired[pulumi.Input['ClusterNodePoolAutoConfigNetworkTagsArgsDict']]
         """
         The network tag config for the cluster's automatically provisioned node pools. Structure is documented below.
@@ -11306,19 +11217,15 @@ elif False:
 @pulumi.input_type
 class ClusterNodePoolAutoConfigArgs:
     def __init__(__self__, *,
-                 linux_node_config: Optional[pulumi.Input['ClusterNodePoolAutoConfigLinuxNodeConfigArgs']] = None,
                  network_tags: Optional[pulumi.Input['ClusterNodePoolAutoConfigNetworkTagsArgs']] = None,
                  node_kubelet_config: Optional[pulumi.Input['ClusterNodePoolAutoConfigNodeKubeletConfigArgs']] = None,
                  resource_manager_tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
         """
-        :param pulumi.Input['ClusterNodePoolAutoConfigLinuxNodeConfigArgs'] linux_node_config: Linux system configuration for the cluster's automatically provisioned node pools. Only `cgroup_mode` field is supported in `node_pool_auto_config`. Structure is documented below.
         :param pulumi.Input['ClusterNodePoolAutoConfigNetworkTagsArgs'] network_tags: The network tag config for the cluster's automatically provisioned node pools. Structure is documented below.
         :param pulumi.Input['ClusterNodePoolAutoConfigNodeKubeletConfigArgs'] node_kubelet_config: Kubelet configuration for Autopilot clusters. Currently, only `insecure_kubelet_readonly_port_enabled` is supported here.
                Structure is documented below.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] resource_manager_tags: A map of resource manager tag keys and values to be attached to the nodes for managing Compute Engine firewalls using Network Firewall Policies. Tags must be according to specifications found [here](https://cloud.google.com/vpc/docs/tags-firewalls-overview#specifications). A maximum of 5 tag key-value pairs can be specified. Existing tags will be replaced with new values. Tags must be in one of the following formats ([KEY]=[VALUE]) 1. `tagKeys/{tag_key_id}=tagValues/{tag_value_id}` 2. `{org_id}/{tag_key_name}={tag_value_name}` 3. `{project_id}/{tag_key_name}={tag_value_name}`.
         """
-        if linux_node_config is not None:
-            pulumi.set(__self__, "linux_node_config", linux_node_config)
         if network_tags is not None:
             pulumi.set(__self__, "network_tags", network_tags)
         if node_kubelet_config is not None:
@@ -11326,18 +11233,6 @@ class ClusterNodePoolAutoConfigArgs:
         if resource_manager_tags is not None:
             pulumi.set(__self__, "resource_manager_tags", resource_manager_tags)
 
-    @property
-    @pulumi.getter(name="linuxNodeConfig")
-    def linux_node_config(self) -> Optional[pulumi.Input['ClusterNodePoolAutoConfigLinuxNodeConfigArgs']]:
-        """
-        Linux system configuration for the cluster's automatically provisioned node pools. Only `cgroup_mode` field is supported in `node_pool_auto_config`. Structure is documented below.
-        """
-        return pulumi.get(self, "linux_node_config")
-
-    @linux_node_config.setter
-    def linux_node_config(self, value: Optional[pulumi.Input['ClusterNodePoolAutoConfigLinuxNodeConfigArgs']]):
-        pulumi.set(self, "linux_node_config", value)
-
     @property
     @pulumi.getter(name="networkTags")
     def network_tags(self) -> Optional[pulumi.Input['ClusterNodePoolAutoConfigNetworkTagsArgs']]:
@@ -11376,50 +11271,6 @@ class ClusterNodePoolAutoConfigArgs:
         pulumi.set(self, "resource_manager_tags", value)
 
 
-if not MYPY:
-    class ClusterNodePoolAutoConfigLinuxNodeConfigArgsDict(TypedDict):
-        cgroup_mode: NotRequired[pulumi.Input[str]]
-        """
-        Possible cgroup modes that can be used.
-        Accepted values are:
-        * `CGROUP_MODE_UNSPECIFIED`: CGROUP_MODE_UNSPECIFIED is when unspecified cgroup configuration is used. The default for the GKE node OS image will be used.
-        * `CGROUP_MODE_V1`: CGROUP_MODE_V1 specifies to use cgroupv1 for the cgroup configuration on the node image.
-        * `CGROUP_MODE_V2`: CGROUP_MODE_V2 specifies to use cgroupv2 for the cgroup configuration on the node image.
-        """
-elif False:
-    ClusterNodePoolAutoConfigLinuxNodeConfigArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class ClusterNodePoolAutoConfigLinuxNodeConfigArgs:
-    def __init__(__self__, *,
-                 cgroup_mode: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input[str] cgroup_mode: Possible cgroup modes that can be used.
-               Accepted values are:
-               * `CGROUP_MODE_UNSPECIFIED`: CGROUP_MODE_UNSPECIFIED is when unspecified cgroup configuration is used. The default for the GKE node OS image will be used.
-               * `CGROUP_MODE_V1`: CGROUP_MODE_V1 specifies to use cgroupv1 for the cgroup configuration on the node image.
-               * `CGROUP_MODE_V2`: CGROUP_MODE_V2 specifies to use cgroupv2 for the cgroup configuration on the node image.
-        """
-        if cgroup_mode is not None:
-            pulumi.set(__self__, "cgroup_mode", cgroup_mode)
-
-    @property
-    @pulumi.getter(name="cgroupMode")
-    def cgroup_mode(self) -> Optional[pulumi.Input[str]]:
-        """
-        Possible cgroup modes that can be used.
-        Accepted values are:
-        * `CGROUP_MODE_UNSPECIFIED`: CGROUP_MODE_UNSPECIFIED is when unspecified cgroup configuration is used. The default for the GKE node OS image will be used.
-        * `CGROUP_MODE_V1`: CGROUP_MODE_V1 specifies to use cgroupv1 for the cgroup configuration on the node image.
-        * `CGROUP_MODE_V2`: CGROUP_MODE_V2 specifies to use cgroupv2 for the cgroup configuration on the node image.
-        """
-        return pulumi.get(self, "cgroup_mode")
-
-    @cgroup_mode.setter
-    def cgroup_mode(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "cgroup_mode", value)
-
-
 if not MYPY:
     class ClusterNodePoolAutoConfigNetworkTagsArgsDict(TypedDict):
         tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
@@ -12464,13 +12315,6 @@ if not MYPY:
         The amount of local SSD disks that will be
         attached to each cluster node. Defaults to 0.
         """
-        local_ssd_encryption_mode: NotRequired[pulumi.Input[str]]
-        """
-        Possible Local SSD encryption modes:
-        Accepted values are:
-        * `STANDARD_ENCRYPTION`: The given node will be encrypted using keys managed by Google infrastructure and the keys wll be deleted when the node is deleted.
-        * `EPHEMERAL_KEY_ENCRYPTION`: The given node will opt-in for using ephemeral key for encrypting Local SSDs. The Local SSDs will not be able to recover data in case of node crash.
-        """
         logging_variant: NotRequired[pulumi.Input[str]]
         """
         Parameter for specifying the type of logging agent used in a node pool. This will override any cluster-wide default value. Valid values include DEFAULT and MAX_THROUGHPUT. See [Increasing logging agent throughput](https://cloud.google.com/stackdriver/docs/solutions/gke/managing-logs#throughput) for more information.
@@ -12607,7 +12451,6 @@ class ClusterNodePoolNodeConfigArgs:
                  linux_node_config: Optional[pulumi.Input['ClusterNodePoolNodeConfigLinuxNodeConfigArgs']] = None,
                  local_nvme_ssd_block_config: Optional[pulumi.Input['ClusterNodePoolNodeConfigLocalNvmeSsdBlockConfigArgs']] = None,
                  local_ssd_count: Optional[pulumi.Input[int]] = None,
-                 local_ssd_encryption_mode: Optional[pulumi.Input[str]] = None,
                  logging_variant: Optional[pulumi.Input[str]] = None,
                  machine_type: Optional[pulumi.Input[str]] = None,
                  metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -12679,10 +12522,6 @@ class ClusterNodePoolNodeConfigArgs:
         :param pulumi.Input['ClusterNodePoolNodeConfigLocalNvmeSsdBlockConfigArgs'] local_nvme_ssd_block_config: Parameters for the local NVMe SSDs. Structure is documented below.
         :param pulumi.Input[int] local_ssd_count: The amount of local SSD disks that will be
                attached to each cluster node. Defaults to 0.
-        :param pulumi.Input[str] local_ssd_encryption_mode: Possible Local SSD encryption modes:
-               Accepted values are:
-               * `STANDARD_ENCRYPTION`: The given node will be encrypted using keys managed by Google infrastructure and the keys wll be deleted when the node is deleted.
-               * `EPHEMERAL_KEY_ENCRYPTION`: The given node will opt-in for using ephemeral key for encrypting Local SSDs. The Local SSDs will not be able to recover data in case of node crash.
         :param pulumi.Input[str] logging_variant: Parameter for specifying the type of logging agent used in a node pool. This will override any cluster-wide default value. Valid values include DEFAULT and MAX_THROUGHPUT. See [Increasing logging agent throughput](https://cloud.google.com/stackdriver/docs/solutions/gke/managing-logs#throughput) for more information.
         :param pulumi.Input[str] machine_type: The name of a Google Compute Engine machine type.
                Defaults to `e2-medium`. To create a custom machine type, value should be set as specified
@@ -12775,8 +12614,6 @@ class ClusterNodePoolNodeConfigArgs:
             pulumi.set(__self__, "local_nvme_ssd_block_config", local_nvme_ssd_block_config)
         if local_ssd_count is not None:
             pulumi.set(__self__, "local_ssd_count", local_ssd_count)
-        if local_ssd_encryption_mode is not None:
-            pulumi.set(__self__, "local_ssd_encryption_mode", local_ssd_encryption_mode)
         if logging_variant is not None:
             pulumi.set(__self__, "logging_variant", logging_variant)
         if machine_type is not None:
@@ -13099,21 +12936,6 @@ class ClusterNodePoolNodeConfigArgs:
     def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "local_ssd_count", value)
 
-    @property
-    @pulumi.getter(name="localSsdEncryptionMode")
-    def local_ssd_encryption_mode(self) -> Optional[pulumi.Input[str]]:
-        """
-        Possible Local SSD encryption modes:
-        Accepted values are:
-        * `STANDARD_ENCRYPTION`: The given node will be encrypted using keys managed by Google infrastructure and the keys wll be deleted when the node is deleted.
-        * `EPHEMERAL_KEY_ENCRYPTION`: The given node will opt-in for using ephemeral key for encrypting Local SSDs. The Local SSDs will not be able to recover data in case of node crash.
-        """
-        return pulumi.get(self, "local_ssd_encryption_mode")
-
-    @local_ssd_encryption_mode.setter
-    def local_ssd_encryption_mode(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "local_ssd_encryption_mode", value)
-
     @property
     @pulumi.getter(name="loggingVariant")
     def logging_variant(self) -> Optional[pulumi.Input[str]]:
@@ -16974,10 +16796,6 @@ if not MYPY:
         """
         The number of local SSD disks to be attached to the node.
         """
-        local_ssd_encryption_mode: NotRequired[pulumi.Input[str]]
-        """
-        LocalSsdEncryptionMode specified the method used for encrypting the local SSDs attached to the node.
-        """
         logging_variant: NotRequired[pulumi.Input[str]]
         """
         Type of logging agent that is used as the default value for node pools in the cluster. Valid values include DEFAULT and MAX_THROUGHPUT.
@@ -17088,7 +16906,6 @@ class NodePoolNodeConfigArgs:
                  linux_node_config: Optional[pulumi.Input['NodePoolNodeConfigLinuxNodeConfigArgs']] = None,
                  local_nvme_ssd_block_config: Optional[pulumi.Input['NodePoolNodeConfigLocalNvmeSsdBlockConfigArgs']] = None,
                  local_ssd_count: Optional[pulumi.Input[int]] = None,
-                 local_ssd_encryption_mode: Optional[pulumi.Input[str]] = None,
                  logging_variant: Optional[pulumi.Input[str]] = None,
                  machine_type: Optional[pulumi.Input[str]] = None,
                  metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -17131,7 +16948,6 @@ class NodePoolNodeConfigArgs:
         :param pulumi.Input['NodePoolNodeConfigLinuxNodeConfigArgs'] linux_node_config: Parameters that can be configured on Linux nodes.
         :param pulumi.Input['NodePoolNodeConfigLocalNvmeSsdBlockConfigArgs'] local_nvme_ssd_block_config: Parameters for raw-block local NVMe SSDs.
         :param pulumi.Input[int] local_ssd_count: The number of local SSD disks to be attached to the node.
-        :param pulumi.Input[str] local_ssd_encryption_mode: LocalSsdEncryptionMode specified the method used for encrypting the local SSDs attached to the node.
         :param pulumi.Input[str] logging_variant: Type of logging agent that is used as the default value for node pools in the cluster. Valid values include DEFAULT and MAX_THROUGHPUT.
         :param pulumi.Input[str] machine_type: The name of a Google Compute Engine machine type.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: The metadata key/value pairs assigned to instances in the cluster.
@@ -17198,8 +17014,6 @@ class NodePoolNodeConfigArgs:
             pulumi.set(__self__, "local_nvme_ssd_block_config", local_nvme_ssd_block_config)
         if local_ssd_count is not None:
             pulumi.set(__self__, "local_ssd_count", local_ssd_count)
-        if local_ssd_encryption_mode is not None:
-            pulumi.set(__self__, "local_ssd_encryption_mode", local_ssd_encryption_mode)
         if logging_variant is not None:
             pulumi.set(__self__, "logging_variant", logging_variant)
         if machine_type is not None:
@@ -17493,18 +17307,6 @@ class NodePoolNodeConfigArgs:
     def local_ssd_count(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "local_ssd_count", value)
 
-    @property
-    @pulumi.getter(name="localSsdEncryptionMode")
-    def local_ssd_encryption_mode(self) -> Optional[pulumi.Input[str]]:
-        """
-        LocalSsdEncryptionMode specified the method used for encrypting the local SSDs attached to the node.
-        """
-        return pulumi.get(self, "local_ssd_encryption_mode")
-
-    @local_ssd_encryption_mode.setter
-    def local_ssd_encryption_mode(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "local_ssd_encryption_mode", value)
-
     @property
     @pulumi.getter(name="loggingVariant")
     def logging_variant(self) -> Optional[pulumi.Input[str]]: