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

pulumi_gcp/container/outputs.py

@@ -123,7 +123,6 @@ __all__ = [
     'ClusterDefaultSnatStatus',
     'ClusterDnsConfig',
     'ClusterEnableK8sBetaApis',
-    'ClusterEnterpriseConfig',
     'ClusterFleet',
     'ClusterGatewayApiConfig',
     'ClusterIdentityServiceConfig',
@@ -176,7 +175,6 @@ __all__ = [
     'ClusterNodeConfigWorkloadMetadataConfig',
     'ClusterNodePool',
     'ClusterNodePoolAutoConfig',
-    'ClusterNodePoolAutoConfigLinuxNodeConfig',
     'ClusterNodePoolAutoConfigNetworkTags',
     'ClusterNodePoolAutoConfigNodeKubeletConfig',
     'ClusterNodePoolAutoscaling',
@@ -325,7 +323,6 @@ __all__ = [
     'GetClusterDefaultSnatStatusResult',
     'GetClusterDnsConfigResult',
     'GetClusterEnableK8sBetaApiResult',
-    'GetClusterEnterpriseConfigResult',
     'GetClusterFleetResult',
     'GetClusterGatewayApiConfigResult',
     'GetClusterIdentityServiceConfigResult',
@@ -378,7 +375,6 @@ __all__ = [
     'GetClusterNodeConfigWorkloadMetadataConfigResult',
     'GetClusterNodePoolResult',
     'GetClusterNodePoolAutoConfigResult',
-    'GetClusterNodePoolAutoConfigLinuxNodeConfigResult',
     'GetClusterNodePoolAutoConfigNetworkTagResult',
     'GetClusterNodePoolAutoConfigNodeKubeletConfigResult',
     'GetClusterNodePoolAutoscalingResult',
@@ -4784,7 +4780,7 @@ class ClusterClusterAutoscalingAutoProvisioningDefaults(dict):
         """
         :param 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 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 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 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 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 'ClusterClusterAutoscalingAutoProvisioningDefaultsManagementArgs' management: NodeManagement configuration for this NodePool. Structure is documented below.
         :param str min_cpu_platform: Minimum CPU platform to be used for NAP created node pools. The instance may be scheduled on the
@@ -4838,7 +4834,7 @@ class ClusterClusterAutoscalingAutoProvisioningDefaults(dict):
     @pulumi.getter(name="diskType")
     def disk_type(self) -> Optional[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")
 
@@ -5658,56 +5654,6 @@ class ClusterEnableK8sBetaApis(dict):
         return pulumi.get(self, "enabled_apis")
 
 
-@pulumi.output_type
-class ClusterEnterpriseConfig(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "clusterTier":
-            suggest = "cluster_tier"
-        elif key == "desiredTier":
-            suggest = "desired_tier"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ClusterEnterpriseConfig. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        ClusterEnterpriseConfig.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        ClusterEnterpriseConfig.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 cluster_tier: Optional[str] = None,
-                 desired_tier: Optional[str] = None):
-        """
-        :param str cluster_tier: The effective tier of the cluster.
-        :param 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[str]:
-        """
-        The effective tier of the cluster.
-        """
-        return pulumi.get(self, "cluster_tier")
-
-    @property
-    @pulumi.getter(name="desiredTier")
-    def desired_tier(self) -> Optional[str]:
-        """
-        Sets the tier of the cluster. Available options include `STANDARD` and `ENTERPRISE`.
-        """
-        return pulumi.get(self, "desired_tier")
-
-
 @pulumi.output_type
 class ClusterFleet(dict):
     @staticmethod
@@ -6919,8 +6865,6 @@ class ClusterNodeConfig(dict):
             suggest = "local_nvme_ssd_block_config"
         elif key == "localSsdCount":
             suggest = "local_ssd_count"
-        elif key == "localSsdEncryptionMode":
-            suggest = "local_ssd_encryption_mode"
         elif key == "loggingVariant":
             suggest = "logging_variant"
         elif key == "machineType":
@@ -6985,7 +6929,6 @@ class ClusterNodeConfig(dict):
                  linux_node_config: Optional['outputs.ClusterNodeConfigLinuxNodeConfig'] = None,
                  local_nvme_ssd_block_config: Optional['outputs.ClusterNodeConfigLocalNvmeSsdBlockConfig'] = None,
                  local_ssd_count: Optional[int] = None,
-                 local_ssd_encryption_mode: Optional[str] = None,
                  logging_variant: Optional[str] = None,
                  machine_type: Optional[str] = None,
                  metadata: Optional[Mapping[str, str]] = None,
@@ -7057,10 +7000,6 @@ class ClusterNodeConfig(dict):
         :param 'ClusterNodeConfigLocalNvmeSsdBlockConfigArgs' local_nvme_ssd_block_config: Parameters for the local NVMe SSDs. Structure is documented below.
         :param int local_ssd_count: The amount of local SSD disks that will be
                attached to each cluster node. Defaults to 0.
-        :param 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 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 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
@@ -7153,8 +7092,6 @@ class ClusterNodeConfig(dict):
             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:
@@ -7393,17 +7330,6 @@ class ClusterNodeConfig(dict):
         """
         return pulumi.get(self, "local_ssd_count")
 
-    @property
-    @pulumi.getter(name="localSsdEncryptionMode")
-    def local_ssd_encryption_mode(self) -> Optional[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")
-
     @property
     @pulumi.getter(name="loggingVariant")
     def logging_variant(self) -> Optional[str]:
@@ -9128,9 +9054,7 @@ class ClusterNodePoolAutoConfig(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "linuxNodeConfig":
-            suggest = "linux_node_config"
-        elif key == "networkTags":
+        if key == "networkTags":
             suggest = "network_tags"
         elif key == "nodeKubeletConfig":
             suggest = "node_kubelet_config"
@@ -9149,19 +9073,15 @@ class ClusterNodePoolAutoConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 linux_node_config: Optional['outputs.ClusterNodePoolAutoConfigLinuxNodeConfig'] = None,
                  network_tags: Optional['outputs.ClusterNodePoolAutoConfigNetworkTags'] = None,
                  node_kubelet_config: Optional['outputs.ClusterNodePoolAutoConfigNodeKubeletConfig'] = None,
                  resource_manager_tags: Optional[Mapping[str, str]] = None):
         """
-        :param '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 'ClusterNodePoolAutoConfigNetworkTagsArgs' network_tags: The network tag config for the cluster's automatically provisioned node pools. Structure is documented below.
         :param 'ClusterNodePoolAutoConfigNodeKubeletConfigArgs' node_kubelet_config: Kubelet configuration for Autopilot clusters. Currently, only `insecure_kubelet_readonly_port_enabled` is supported here.
                Structure is documented below.
         :param Mapping[str, 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:
@@ -9169,14 +9089,6 @@ class ClusterNodePoolAutoConfig(dict):
         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['outputs.ClusterNodePoolAutoConfigLinuxNodeConfig']:
-        """
-        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")
-
     @property
     @pulumi.getter(name="networkTags")
     def network_tags(self) -> Optional['outputs.ClusterNodePoolAutoConfigNetworkTags']:
@@ -9203,50 +9115,6 @@ class ClusterNodePoolAutoConfig(dict):
         return pulumi.get(self, "resource_manager_tags")
 
 
-@pulumi.output_type
-class ClusterNodePoolAutoConfigLinuxNodeConfig(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "cgroupMode":
-            suggest = "cgroup_mode"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ClusterNodePoolAutoConfigLinuxNodeConfig. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        ClusterNodePoolAutoConfigLinuxNodeConfig.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        ClusterNodePoolAutoConfigLinuxNodeConfig.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 cgroup_mode: Optional[str] = None):
-        """
-        :param 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[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")
-
-
 @pulumi.output_type
 class ClusterNodePoolAutoConfigNetworkTags(dict):
     def __init__(__self__, *,
@@ -10079,8 +9947,6 @@ class ClusterNodePoolNodeConfig(dict):
             suggest = "local_nvme_ssd_block_config"
         elif key == "localSsdCount":
             suggest = "local_ssd_count"
-        elif key == "localSsdEncryptionMode":
-            suggest = "local_ssd_encryption_mode"
         elif key == "loggingVariant":
             suggest = "logging_variant"
         elif key == "machineType":
@@ -10145,7 +10011,6 @@ class ClusterNodePoolNodeConfig(dict):
                  linux_node_config: Optional['outputs.ClusterNodePoolNodeConfigLinuxNodeConfig'] = None,
                  local_nvme_ssd_block_config: Optional['outputs.ClusterNodePoolNodeConfigLocalNvmeSsdBlockConfig'] = None,
                  local_ssd_count: Optional[int] = None,
-                 local_ssd_encryption_mode: Optional[str] = None,
                  logging_variant: Optional[str] = None,
                  machine_type: Optional[str] = None,
                  metadata: Optional[Mapping[str, str]] = None,
@@ -10217,10 +10082,6 @@ class ClusterNodePoolNodeConfig(dict):
         :param 'ClusterNodePoolNodeConfigLocalNvmeSsdBlockConfigArgs' local_nvme_ssd_block_config: Parameters for the local NVMe SSDs. Structure is documented below.
         :param int local_ssd_count: The amount of local SSD disks that will be
                attached to each cluster node. Defaults to 0.
-        :param 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 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 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
@@ -10313,8 +10174,6 @@ class ClusterNodePoolNodeConfig(dict):
             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:
@@ -10553,17 +10412,6 @@ class ClusterNodePoolNodeConfig(dict):
         """
         return pulumi.get(self, "local_ssd_count")
 
-    @property
-    @pulumi.getter(name="localSsdEncryptionMode")
-    def local_ssd_encryption_mode(self) -> Optional[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")
-
     @property
     @pulumi.getter(name="loggingVariant")
     def logging_variant(self) -> Optional[str]:
@@ -13662,8 +13510,6 @@ class NodePoolNodeConfig(dict):
             suggest = "local_nvme_ssd_block_config"
         elif key == "localSsdCount":
             suggest = "local_ssd_count"
-        elif key == "localSsdEncryptionMode":
-            suggest = "local_ssd_encryption_mode"
         elif key == "loggingVariant":
             suggest = "logging_variant"
         elif key == "machineType":
@@ -13728,7 +13574,6 @@ class NodePoolNodeConfig(dict):
                  linux_node_config: Optional['outputs.NodePoolNodeConfigLinuxNodeConfig'] = None,
                  local_nvme_ssd_block_config: Optional['outputs.NodePoolNodeConfigLocalNvmeSsdBlockConfig'] = None,
                  local_ssd_count: Optional[int] = None,
-                 local_ssd_encryption_mode: Optional[str] = None,
                  logging_variant: Optional[str] = None,
                  machine_type: Optional[str] = None,
                  metadata: Optional[Mapping[str, str]] = None,
@@ -13771,7 +13616,6 @@ class NodePoolNodeConfig(dict):
         :param 'NodePoolNodeConfigLinuxNodeConfigArgs' linux_node_config: Parameters that can be configured on Linux nodes.
         :param 'NodePoolNodeConfigLocalNvmeSsdBlockConfigArgs' local_nvme_ssd_block_config: Parameters for raw-block local NVMe SSDs.
         :param int local_ssd_count: The number of local SSD disks to be attached to the node.
-        :param str local_ssd_encryption_mode: LocalSsdEncryptionMode specified the method used for encrypting the local SSDs attached to the node.
         :param 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 str machine_type: The name of a Google Compute Engine machine type.
         :param Mapping[str, str] metadata: The metadata key/value pairs assigned to instances in the cluster.
@@ -13838,8 +13682,6 @@ class NodePoolNodeConfig(dict):
             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:
@@ -14049,14 +13891,6 @@ class NodePoolNodeConfig(dict):
         """
         return pulumi.get(self, "local_ssd_count")
 
-    @property
-    @pulumi.getter(name="localSsdEncryptionMode")
-    def local_ssd_encryption_mode(self) -> Optional[str]:
-        """
-        LocalSsdEncryptionMode specified the method used for encrypting the local SSDs attached to the node.
-        """
-        return pulumi.get(self, "local_ssd_encryption_mode")
-
     @property
     @pulumi.getter(name="loggingVariant")
     def logging_variant(self) -> Optional[str]:
@@ -16823,35 +16657,6 @@ class GetClusterEnableK8sBetaApiResult(dict):
         return pulumi.get(self, "enabled_apis")
 
 
-@pulumi.output_type
-class GetClusterEnterpriseConfigResult(dict):
-    def __init__(__self__, *,
-                 cluster_tier: str,
-                 desired_tier: str):
-        """
-        :param str cluster_tier: Indicates the effective cluster tier. Available options include STANDARD and ENTERPRISE.
-        :param str desired_tier: Indicates the desired cluster tier. Available options include STANDARD and ENTERPRISE.
-        """
-        pulumi.set(__self__, "cluster_tier", cluster_tier)
-        pulumi.set(__self__, "desired_tier", desired_tier)
-
-    @property
-    @pulumi.getter(name="clusterTier")
-    def cluster_tier(self) -> str:
-        """
-        Indicates the effective cluster tier. Available options include STANDARD and ENTERPRISE.
-        """
-        return pulumi.get(self, "cluster_tier")
-
-    @property
-    @pulumi.getter(name="desiredTier")
-    def desired_tier(self) -> str:
-        """
-        Indicates the desired cluster tier. Available options include STANDARD and ENTERPRISE.
-        """
-        return pulumi.get(self, "desired_tier")
-
-
 @pulumi.output_type
 class GetClusterFleetResult(dict):
     def __init__(__self__, *,
@@ -17522,7 +17327,6 @@ class GetClusterNodeConfigResult(dict):
                  linux_node_configs: Sequence['outputs.GetClusterNodeConfigLinuxNodeConfigResult'],
                  local_nvme_ssd_block_configs: Sequence['outputs.GetClusterNodeConfigLocalNvmeSsdBlockConfigResult'],
                  local_ssd_count: int,
-                 local_ssd_encryption_mode: str,
                  logging_variant: str,
                  machine_type: str,
                  metadata: Mapping[str, str],
@@ -17565,7 +17369,6 @@ class GetClusterNodeConfigResult(dict):
         :param Sequence['GetClusterNodeConfigLinuxNodeConfigArgs'] linux_node_configs: Parameters that can be configured on Linux nodes.
         :param Sequence['GetClusterNodeConfigLocalNvmeSsdBlockConfigArgs'] local_nvme_ssd_block_configs: Parameters for raw-block local NVMe SSDs.
         :param int local_ssd_count: The number of local SSD disks to be attached to the node.
-        :param str local_ssd_encryption_mode: LocalSsdEncryptionMode specified the method used for encrypting the local SSDs attached to the node.
         :param 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 str machine_type: The name of a Google Compute Engine machine type.
         :param Mapping[str, str] metadata: The metadata key/value pairs assigned to instances in the cluster.
@@ -17608,7 +17411,6 @@ class GetClusterNodeConfigResult(dict):
         pulumi.set(__self__, "linux_node_configs", linux_node_configs)
         pulumi.set(__self__, "local_nvme_ssd_block_configs", local_nvme_ssd_block_configs)
         pulumi.set(__self__, "local_ssd_count", local_ssd_count)
-        pulumi.set(__self__, "local_ssd_encryption_mode", local_ssd_encryption_mode)
         pulumi.set(__self__, "logging_variant", logging_variant)
         pulumi.set(__self__, "machine_type", machine_type)
         pulumi.set(__self__, "metadata", metadata)
@@ -17798,14 +17600,6 @@ class GetClusterNodeConfigResult(dict):
         """
         return pulumi.get(self, "local_ssd_count")
 
-    @property
-    @pulumi.getter(name="localSsdEncryptionMode")
-    def local_ssd_encryption_mode(self) -> str:
-        """
-        LocalSsdEncryptionMode specified the method used for encrypting the local SSDs attached to the node.
-        """
-        return pulumi.get(self, "local_ssd_encryption_mode")
-
     @property
     @pulumi.getter(name="loggingVariant")
     def logging_variant(self) -> str:
@@ -18928,29 +18722,18 @@ class GetClusterNodePoolResult(dict):
 @pulumi.output_type
 class GetClusterNodePoolAutoConfigResult(dict):
     def __init__(__self__, *,
-                 linux_node_configs: Sequence['outputs.GetClusterNodePoolAutoConfigLinuxNodeConfigResult'],
                  network_tags: Sequence['outputs.GetClusterNodePoolAutoConfigNetworkTagResult'],
                  node_kubelet_configs: Sequence['outputs.GetClusterNodePoolAutoConfigNodeKubeletConfigResult'],
                  resource_manager_tags: Mapping[str, str]):
         """
-        :param Sequence['GetClusterNodePoolAutoConfigLinuxNodeConfigArgs'] linux_node_configs: Linux node configuration options.
         :param Sequence['GetClusterNodePoolAutoConfigNetworkTagArgs'] network_tags: Collection of Compute Engine network tags that can be applied to a node's underlying VM instance.
         :param Sequence['GetClusterNodePoolAutoConfigNodeKubeletConfigArgs'] node_kubelet_configs: Node kubelet configs.
         :param Mapping[str, str] resource_manager_tags: A map of resource manager tags. Resource manager tag keys and values have the same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id}, and values are in the format tagValues/456. The field is ignored (both PUT & PATCH) when empty.
         """
-        pulumi.set(__self__, "linux_node_configs", linux_node_configs)
         pulumi.set(__self__, "network_tags", network_tags)
         pulumi.set(__self__, "node_kubelet_configs", node_kubelet_configs)
         pulumi.set(__self__, "resource_manager_tags", resource_manager_tags)
 
-    @property
-    @pulumi.getter(name="linuxNodeConfigs")
-    def linux_node_configs(self) -> Sequence['outputs.GetClusterNodePoolAutoConfigLinuxNodeConfigResult']:
-        """
-        Linux node configuration options.
-        """
-        return pulumi.get(self, "linux_node_configs")
-
     @property
     @pulumi.getter(name="networkTags")
     def network_tags(self) -> Sequence['outputs.GetClusterNodePoolAutoConfigNetworkTagResult']:
@@ -18976,24 +18759,6 @@ class GetClusterNodePoolAutoConfigResult(dict):
         return pulumi.get(self, "resource_manager_tags")
 
 
-@pulumi.output_type
-class GetClusterNodePoolAutoConfigLinuxNodeConfigResult(dict):
-    def __init__(__self__, *,
-                 cgroup_mode: str):
-        """
-        :param str cgroup_mode: cgroupMode specifies the cgroup mode to be used on the node.
-        """
-        pulumi.set(__self__, "cgroup_mode", cgroup_mode)
-
-    @property
-    @pulumi.getter(name="cgroupMode")
-    def cgroup_mode(self) -> str:
-        """
-        cgroupMode specifies the cgroup mode to be used on the node.
-        """
-        return pulumi.get(self, "cgroup_mode")
-
-
 @pulumi.output_type
 class GetClusterNodePoolAutoConfigNetworkTagResult(dict):
     def __init__(__self__, *,
@@ -19520,7 +19285,6 @@ class GetClusterNodePoolNodeConfigResult(dict):
                  linux_node_configs: Sequence['outputs.GetClusterNodePoolNodeConfigLinuxNodeConfigResult'],
                  local_nvme_ssd_block_configs: Sequence['outputs.GetClusterNodePoolNodeConfigLocalNvmeSsdBlockConfigResult'],
                  local_ssd_count: int,
-                 local_ssd_encryption_mode: str,
                  logging_variant: str,
                  machine_type: str,
                  metadata: Mapping[str, str],
@@ -19563,7 +19327,6 @@ class GetClusterNodePoolNodeConfigResult(dict):
         :param Sequence['GetClusterNodePoolNodeConfigLinuxNodeConfigArgs'] linux_node_configs: Parameters that can be configured on Linux nodes.
         :param Sequence['GetClusterNodePoolNodeConfigLocalNvmeSsdBlockConfigArgs'] local_nvme_ssd_block_configs: Parameters for raw-block local NVMe SSDs.
         :param int local_ssd_count: The number of local SSD disks to be attached to the node.
-        :param str local_ssd_encryption_mode: LocalSsdEncryptionMode specified the method used for encrypting the local SSDs attached to the node.
         :param 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 str machine_type: The name of a Google Compute Engine machine type.
         :param Mapping[str, str] metadata: The metadata key/value pairs assigned to instances in the cluster.
@@ -19606,7 +19369,6 @@ class GetClusterNodePoolNodeConfigResult(dict):
         pulumi.set(__self__, "linux_node_configs", linux_node_configs)
         pulumi.set(__self__, "local_nvme_ssd_block_configs", local_nvme_ssd_block_configs)
         pulumi.set(__self__, "local_ssd_count", local_ssd_count)
-        pulumi.set(__self__, "local_ssd_encryption_mode", local_ssd_encryption_mode)
         pulumi.set(__self__, "logging_variant", logging_variant)
         pulumi.set(__self__, "machine_type", machine_type)
         pulumi.set(__self__, "metadata", metadata)
@@ -19796,14 +19558,6 @@ class GetClusterNodePoolNodeConfigResult(dict):
         """
         return pulumi.get(self, "local_ssd_count")
 
-    @property
-    @pulumi.getter(name="localSsdEncryptionMode")
-    def local_ssd_encryption_mode(self) -> str:
-        """
-        LocalSsdEncryptionMode specified the method used for encrypting the local SSDs attached to the node.
-        """
-        return pulumi.get(self, "local_ssd_encryption_mode")
-
     @property
     @pulumi.getter(name="loggingVariant")
     def logging_variant(self) -> str:

pulumi_gcp/containeranalysis/get_note_iam_policy.py

@@ -127,7 +127,7 @@ def get_note_iam_policy(note: Optional[str] = None,
         project=pulumi.get(__ret__, 'project'))
 def get_note_iam_policy_output(note: Optional[pulumi.Input[str]] = None,
                                project: Optional[pulumi.Input[Optional[str]]] = None,
-                               opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetNoteIamPolicyResult]:
+                               opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetNoteIamPolicyResult]:
     """
     Retrieves the current IAM policy data for note
 
@@ -149,7 +149,7 @@ def get_note_iam_policy_output(note: Optional[pulumi.Input[str]] = None,
     __args__ = dict()
     __args__['note'] = note
     __args__['project'] = project
-    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('gcp:containeranalysis/getNoteIamPolicy:getNoteIamPolicy', __args__, opts=opts, typ=GetNoteIamPolicyResult)
     return __ret__.apply(lambda __response__: GetNoteIamPolicyResult(
         etag=pulumi.get(__response__, 'etag'),

pulumi_gcp/datacatalog/get_entry_group_iam_policy.py

@@ -139,7 +139,7 @@ def get_entry_group_iam_policy(entry_group: Optional[str] = None,
 def get_entry_group_iam_policy_output(entry_group: Optional[pulumi.Input[str]] = None,
                                       project: Optional[pulumi.Input[Optional[str]]] = None,
                                       region: Optional[pulumi.Input[Optional[str]]] = None,
-                                      opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetEntryGroupIamPolicyResult]:
+                                      opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetEntryGroupIamPolicyResult]:
     """
     Retrieves the current IAM policy data for entrygroup
 
@@ -161,7 +161,7 @@ def get_entry_group_iam_policy_output(entry_group: Optional[pulumi.Input[str]] =
     __args__['entryGroup'] = entry_group
     __args__['project'] = project
     __args__['region'] = region
-    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('gcp:datacatalog/getEntryGroupIamPolicy:getEntryGroupIamPolicy', __args__, opts=opts, typ=GetEntryGroupIamPolicyResult)
     return __ret__.apply(lambda __response__: GetEntryGroupIamPolicyResult(
         entry_group=pulumi.get(__response__, 'entry_group'),

pulumi_gcp/datacatalog/get_policy_tag_iam_policy.py

@@ -111,7 +111,7 @@ def get_policy_tag_iam_policy(policy_tag: Optional[str] = None,
         policy_data=pulumi.get(__ret__, 'policy_data'),
         policy_tag=pulumi.get(__ret__, 'policy_tag'))
 def get_policy_tag_iam_policy_output(policy_tag: Optional[pulumi.Input[str]] = None,
-                                     opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetPolicyTagIamPolicyResult]:
+                                     opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetPolicyTagIamPolicyResult]:
     """
     Retrieves the current IAM policy data for policytag
 
@@ -129,7 +129,7 @@ def get_policy_tag_iam_policy_output(policy_tag: Optional[pulumi.Input[str]] = N
     """
     __args__ = dict()
     __args__['policyTag'] = policy_tag
-    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('gcp:datacatalog/getPolicyTagIamPolicy:getPolicyTagIamPolicy', __args__, opts=opts, typ=GetPolicyTagIamPolicyResult)
     return __ret__.apply(lambda __response__: GetPolicyTagIamPolicyResult(
         etag=pulumi.get(__response__, 'etag'),

pulumi_gcp/datacatalog/get_tag_template_iam_policy.py

@@ -139,7 +139,7 @@ def get_tag_template_iam_policy(project: Optional[str] = None,
 def get_tag_template_iam_policy_output(project: Optional[pulumi.Input[Optional[str]]] = None,
                                        region: Optional[pulumi.Input[Optional[str]]] = None,
                                        tag_template: Optional[pulumi.Input[str]] = None,
-                                       opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetTagTemplateIamPolicyResult]:
+                                       opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetTagTemplateIamPolicyResult]:
     """
     Retrieves the current IAM policy data for tagtemplate
 
@@ -161,7 +161,7 @@ def get_tag_template_iam_policy_output(project: Optional[pulumi.Input[Optional[s
     __args__['project'] = project
     __args__['region'] = region
     __args__['tagTemplate'] = tag_template
-    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('gcp:datacatalog/getTagTemplateIamPolicy:getTagTemplateIamPolicy', __args__, opts=opts, typ=GetTagTemplateIamPolicyResult)
     return __ret__.apply(lambda __response__: GetTagTemplateIamPolicyResult(
         etag=pulumi.get(__response__, 'etag'),

pulumi_gcp/datacatalog/get_taxonomy_iam_policy.py

@@ -139,7 +139,7 @@ def get_taxonomy_iam_policy(project: Optional[str] = None,
 def get_taxonomy_iam_policy_output(project: Optional[pulumi.Input[Optional[str]]] = None,
                                    region: Optional[pulumi.Input[Optional[str]]] = None,
                                    taxonomy: Optional[pulumi.Input[str]] = None,
-                                   opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetTaxonomyIamPolicyResult]:
+                                   opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetTaxonomyIamPolicyResult]:
     """
     Retrieves the current IAM policy data for taxonomy
 
@@ -161,7 +161,7 @@ def get_taxonomy_iam_policy_output(project: Optional[pulumi.Input[Optional[str]]
     __args__['project'] = project
     __args__['region'] = region
     __args__['taxonomy'] = taxonomy
-    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('gcp:datacatalog/getTaxonomyIamPolicy:getTaxonomyIamPolicy', __args__, opts=opts, typ=GetTaxonomyIamPolicyResult)
     return __ret__.apply(lambda __response__: GetTaxonomyIamPolicyResult(
         etag=pulumi.get(__response__, 'etag'),

pulumi_gcp/dataform/get_repository_iam_policy.py

@@ -132,7 +132,7 @@ def get_repository_iam_policy(project: Optional[str] = None,
 def get_repository_iam_policy_output(project: Optional[pulumi.Input[Optional[str]]] = None,
                                      region: Optional[pulumi.Input[Optional[str]]] = None,
                                      repository: Optional[pulumi.Input[str]] = None,
-                                     opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetRepositoryIamPolicyResult]:
+                                     opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetRepositoryIamPolicyResult]:
     """
     Use this data source to access information about an existing resource.
 
@@ -147,7 +147,7 @@ def get_repository_iam_policy_output(project: Optional[pulumi.Input[Optional[str
     __args__['project'] = project
     __args__['region'] = region
     __args__['repository'] = repository
-    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('gcp:dataform/getRepositoryIamPolicy:getRepositoryIamPolicy', __args__, opts=opts, typ=GetRepositoryIamPolicyResult)
     return __ret__.apply(lambda __response__: GetRepositoryIamPolicyResult(
         etag=pulumi.get(__response__, 'etag'),