pulumi-gcp 8.36.0a1751060819__py3-none-any.whl → 8.37.0a1751903932__py3-none-any.whl

pulumi_gcp/container/outputs.py

@@ -128,6 +128,7 @@ __all__ = [
     'ClusterEnterpriseConfig',
     'ClusterFleet',
     'ClusterGatewayApiConfig',
+    'ClusterGkeAutoUpgradeConfig',
     'ClusterIdentityServiceConfig',
     'ClusterIpAllocationPolicy',
     'ClusterIpAllocationPolicyAdditionalPodRangesConfig',
@@ -337,6 +338,7 @@ __all__ = [
     'GetClusterEnterpriseConfigResult',
     'GetClusterFleetResult',
     'GetClusterGatewayApiConfigResult',
+    'GetClusterGkeAutoUpgradeConfigResult',
     'GetClusterIdentityServiceConfigResult',
     'GetClusterIpAllocationPolicyResult',
     'GetClusterIpAllocationPolicyAdditionalPodRangesConfigResult',
@@ -5365,13 +5367,35 @@ class ClusterClusterTelemetry(dict):
 
 @pulumi.output_type
 class ClusterConfidentialNodes(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "confidentialInstanceType":
+            suggest = "confidential_instance_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterConfidentialNodes. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterConfidentialNodes.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterConfidentialNodes.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 enabled: builtins.bool):
+                 enabled: builtins.bool,
+                 confidential_instance_type: Optional[builtins.str] = None):
         """
         :param builtins.bool enabled: Enable Confidential GKE Nodes for this cluster, to
                enforce encryption of data in-use.
+        :param builtins.str confidential_instance_type: Defines the type of technology used
+               by the confidential node.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if confidential_instance_type is not None:
+            pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
 
     @property
     @pulumi.getter
@@ -5382,6 +5406,15 @@ class ClusterConfidentialNodes(dict):
         """
         return pulumi.get(self, "enabled")
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> Optional[builtins.str]:
+        """
+        Defines the type of technology used
+        by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
 
 @pulumi.output_type
 class ClusterControlPlaneEndpointsConfig(dict):
@@ -5860,6 +5893,45 @@ class ClusterGatewayApiConfig(dict):
         return pulumi.get(self, "channel")
 
 
+@pulumi.output_type
+class ClusterGkeAutoUpgradeConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "patchMode":
+            suggest = "patch_mode"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterGkeAutoUpgradeConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterGkeAutoUpgradeConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterGkeAutoUpgradeConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 patch_mode: builtins.str):
+        """
+        :param builtins.str patch_mode: The selected patch mode.
+               Accepted values are:
+               * ACCELERATED: Upgrades to the latest available patch version in a given minor and release channel.
+        """
+        pulumi.set(__self__, "patch_mode", patch_mode)
+
+    @property
+    @pulumi.getter(name="patchMode")
+    def patch_mode(self) -> builtins.str:
+        """
+        The selected patch mode.
+        Accepted values are:
+        * ACCELERATED: Upgrades to the latest available patch version in a given minor and release channel.
+        """
+        return pulumi.get(self, "patch_mode")
+
+
 @pulumi.output_type
 class ClusterIdentityServiceConfig(dict):
     def __init__(__self__, *,
@@ -7829,13 +7901,35 @@ class ClusterNodeConfigAdvancedMachineFeatures(dict):
 
 @pulumi.output_type
 class ClusterNodeConfigConfidentialNodes(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "confidentialInstanceType":
+            suggest = "confidential_instance_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeConfigConfidentialNodes. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeConfigConfidentialNodes.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeConfigConfidentialNodes.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 enabled: builtins.bool):
+                 enabled: builtins.bool,
+                 confidential_instance_type: Optional[builtins.str] = None):
         """
         :param builtins.bool enabled: Enable Confidential GKE Nodes for this cluster, to
                enforce encryption of data in-use.
+        :param builtins.str confidential_instance_type: Defines the type of technology used
+               by the confidential node.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if confidential_instance_type is not None:
+            pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
 
     @property
     @pulumi.getter
@@ -7846,6 +7940,15 @@ class ClusterNodeConfigConfidentialNodes(dict):
         """
         return pulumi.get(self, "enabled")
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> Optional[builtins.str]:
+        """
+        Defines the type of technology used
+        by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
 
 @pulumi.output_type
 class ClusterNodeConfigContainerdConfig(dict):
@@ -11184,13 +11287,35 @@ class ClusterNodePoolNodeConfigAdvancedMachineFeatures(dict):
 
 @pulumi.output_type
 class ClusterNodePoolNodeConfigConfidentialNodes(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "confidentialInstanceType":
+            suggest = "confidential_instance_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodePoolNodeConfigConfidentialNodes. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodePoolNodeConfigConfidentialNodes.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodePoolNodeConfigConfidentialNodes.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 enabled: builtins.bool):
+                 enabled: builtins.bool,
+                 confidential_instance_type: Optional[builtins.str] = None):
         """
         :param builtins.bool enabled: Enable Confidential GKE Nodes for this cluster, to
                enforce encryption of data in-use.
+        :param builtins.str confidential_instance_type: Defines the type of technology used
+               by the confidential node.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if confidential_instance_type is not None:
+            pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
 
     @property
     @pulumi.getter
@@ -11201,6 +11326,15 @@ class ClusterNodePoolNodeConfigConfidentialNodes(dict):
         """
         return pulumi.get(self, "enabled")
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> Optional[builtins.str]:
+        """
+        Defines the type of technology used
+        by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
 
 @pulumi.output_type
 class ClusterNodePoolNodeConfigContainerdConfig(dict):
@@ -14351,10 +14485,7 @@ class NodePoolNodeConfig(dict):
         :param builtins.str node_group: Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on sole tenant nodes.
         :param Sequence[builtins.str] oauth_scopes: The set of Google API scopes to be made available on all of the node VMs.
         :param builtins.bool preemptible: Whether the nodes are created as preemptible VM instances.
-        :param 'NodePoolNodeConfigReservationAffinityArgs' reservation_affinity: The configuration of the desired reservation which instances could take capacity from.
-               Structure is documented below.
-               
-               <a name="nested_autoscaling"></a>The `autoscaling` block supports (either total or per zone limits are required):
+        :param 'NodePoolNodeConfigReservationAffinityArgs' reservation_affinity: The reservation affinity configuration for the node pool.
         :param Mapping[str, builtins.str] resource_labels: The GCE resource labels (a map of key/value pairs) to be applied to the node pool.
         :param Mapping[str, builtins.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.
         :param 'NodePoolNodeConfigSandboxConfigArgs' sandbox_config: Sandbox configuration for this node.
@@ -14712,10 +14843,7 @@ class NodePoolNodeConfig(dict):
     @pulumi.getter(name="reservationAffinity")
     def reservation_affinity(self) -> Optional['outputs.NodePoolNodeConfigReservationAffinity']:
         """
-        The configuration of the desired reservation which instances could take capacity from.
-        Structure is documented below.
-
-        <a name="nested_autoscaling"></a>The `autoscaling` block supports (either total or per zone limits are required):
+        The reservation affinity configuration for the node pool.
         """
         return pulumi.get(self, "reservation_affinity")
 
@@ -14889,12 +15017,33 @@ class NodePoolNodeConfigAdvancedMachineFeatures(dict):
 
 @pulumi.output_type
 class NodePoolNodeConfigConfidentialNodes(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "confidentialInstanceType":
+            suggest = "confidential_instance_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodePoolNodeConfigConfidentialNodes. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodePoolNodeConfigConfidentialNodes.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodePoolNodeConfigConfidentialNodes.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 enabled: builtins.bool):
+                 enabled: builtins.bool,
+                 confidential_instance_type: Optional[builtins.str] = None):
         """
         :param builtins.bool enabled: Whether Confidential Nodes feature is enabled for all nodes in this pool.
+        :param builtins.str confidential_instance_type: Defines the type of technology used by the confidential node.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if confidential_instance_type is not None:
+            pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
 
     @property
     @pulumi.getter
@@ -14904,6 +15053,14 @@ class NodePoolNodeConfigConfidentialNodes(dict):
         """
         return pulumi.get(self, "enabled")
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> Optional[builtins.str]:
+        """
+        Defines the type of technology used by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
 
 @pulumi.output_type
 class NodePoolNodeConfigContainerdConfig(dict):
@@ -17375,12 +17532,23 @@ class GetClusterClusterTelemetryResult(dict):
 @pulumi.output_type
 class GetClusterConfidentialNodeResult(dict):
     def __init__(__self__, *,
+                 confidential_instance_type: builtins.str,
                  enabled: builtins.bool):
         """
+        :param builtins.str confidential_instance_type: Defines the type of technology used by the confidential node.
         :param builtins.bool enabled: Whether Confidential Nodes feature is enabled for all nodes in this cluster.
         """
+        pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
         pulumi.set(__self__, "enabled", enabled)
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> builtins.str:
+        """
+        Defines the type of technology used by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
     @property
     @pulumi.getter
     def enabled(self) -> builtins.bool:
@@ -17711,6 +17879,26 @@ class GetClusterGatewayApiConfigResult(dict):
         return pulumi.get(self, "channel")
 
 
+@pulumi.output_type
+class GetClusterGkeAutoUpgradeConfigResult(dict):
+    def __init__(__self__, *,
+                 patch_mode: builtins.str):
+        """
+        :param builtins.str patch_mode: The selected auto-upgrade patch type. Accepted values are:
+               * ACCELERATED: Upgrades to the latest available patch version in a given minor and release channel.
+        """
+        pulumi.set(__self__, "patch_mode", patch_mode)
+
+    @property
+    @pulumi.getter(name="patchMode")
+    def patch_mode(self) -> builtins.str:
+        """
+        The selected auto-upgrade patch type. Accepted values are:
+        * ACCELERATED: Upgrades to the latest available patch version in a given minor and release channel.
+        """
+        return pulumi.get(self, "patch_mode")
+
+
 @pulumi.output_type
 class GetClusterIdentityServiceConfigResult(dict):
     def __init__(__self__, *,
@@ -18867,12 +19055,23 @@ class GetClusterNodeConfigAdvancedMachineFeatureResult(dict):
 @pulumi.output_type
 class GetClusterNodeConfigConfidentialNodeResult(dict):
     def __init__(__self__, *,
+                 confidential_instance_type: builtins.str,
                  enabled: builtins.bool):
         """
+        :param builtins.str confidential_instance_type: Defines the type of technology used by the confidential node.
         :param builtins.bool enabled: Whether Confidential Nodes feature is enabled for all nodes in this pool.
         """
+        pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
         pulumi.set(__self__, "enabled", enabled)
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> builtins.str:
+        """
+        Defines the type of technology used by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
     @property
     @pulumi.getter
     def enabled(self) -> builtins.bool:
@@ -21015,12 +21214,23 @@ class GetClusterNodePoolNodeConfigAdvancedMachineFeatureResult(dict):
 @pulumi.output_type
 class GetClusterNodePoolNodeConfigConfidentialNodeResult(dict):
     def __init__(__self__, *,
+                 confidential_instance_type: builtins.str,
                  enabled: builtins.bool):
         """
+        :param builtins.str confidential_instance_type: Defines the type of technology used by the confidential node.
         :param builtins.bool enabled: Whether Confidential Nodes feature is enabled for all nodes in this pool.
         """
+        pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
         pulumi.set(__self__, "enabled", enabled)
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> builtins.str:
+        """
+        Defines the type of technology used by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
     @property
     @pulumi.getter
     def enabled(self) -> builtins.bool:

pulumi_gcp/diagflow/__init__.py

@@ -11,6 +11,7 @@ from .cx_agent import *
 from .cx_entity_type import *
 from .cx_environment import *
 from .cx_flow import *
+from .cx_generative_settings import *
 from .cx_intent import *
 from .cx_page import *
 from .cx_security_settings import *