pulumi-gcp 8.7.0a1730183903__py3-none-any.whl → 8.8.0__py3-none-any.whl

pulumi_gcp/spanner/_inputs.py

@@ -31,6 +31,14 @@ __all__ = [
     'DatabaseIAMMemberConditionArgsDict',
     'InstanceAutoscalingConfigArgs',
     'InstanceAutoscalingConfigArgsDict',
+    'InstanceAutoscalingConfigAsymmetricAutoscalingOptionArgs',
+    'InstanceAutoscalingConfigAsymmetricAutoscalingOptionArgsDict',
+    'InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesArgs',
+    'InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesArgsDict',
+    'InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimitsArgs',
+    'InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimitsArgsDict',
+    'InstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelectionArgs',
+    'InstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelectionArgsDict',
     'InstanceAutoscalingConfigAutoscalingLimitsArgs',
     'InstanceAutoscalingConfigAutoscalingLimitsArgsDict',
     'InstanceAutoscalingConfigAutoscalingTargetsArgs',
@@ -168,27 +176,38 @@ class BackupScheduleSpecCronSpecArgs:
 
 if not MYPY:
     class DatabaseEncryptionConfigArgsDict(TypedDict):
-        kms_key_name: pulumi.Input[str]
+        kms_key_name: NotRequired[pulumi.Input[str]]
         """
         Fully qualified name of the KMS key to use to encrypt this database. This key must exist
         in the same location as the Spanner Database.
         """
+        kms_key_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Fully qualified name of the KMS keys to use to encrypt this database. The keys must exist
+        in the same locations as the Spanner Database.
+        """
 elif False:
     DatabaseEncryptionConfigArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class DatabaseEncryptionConfigArgs:
     def __init__(__self__, *,
-                 kms_key_name: pulumi.Input[str]):
+                 kms_key_name: Optional[pulumi.Input[str]] = None,
+                 kms_key_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
         """
         :param pulumi.Input[str] kms_key_name: Fully qualified name of the KMS key to use to encrypt this database. This key must exist
                in the same location as the Spanner Database.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] kms_key_names: Fully qualified name of the KMS keys to use to encrypt this database. The keys must exist
+               in the same locations as the Spanner Database.
         """
-        pulumi.set(__self__, "kms_key_name", kms_key_name)
+        if kms_key_name is not None:
+            pulumi.set(__self__, "kms_key_name", kms_key_name)
+        if kms_key_names is not None:
+            pulumi.set(__self__, "kms_key_names", kms_key_names)
 
     @property
     @pulumi.getter(name="kmsKeyName")
-    def kms_key_name(self) -> pulumi.Input[str]:
+    def kms_key_name(self) -> Optional[pulumi.Input[str]]:
         """
         Fully qualified name of the KMS key to use to encrypt this database. This key must exist
         in the same location as the Spanner Database.
@@ -196,9 +215,22 @@ class DatabaseEncryptionConfigArgs:
         return pulumi.get(self, "kms_key_name")
 
     @kms_key_name.setter
-    def kms_key_name(self, value: pulumi.Input[str]):
+    def kms_key_name(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "kms_key_name", value)
 
+    @property
+    @pulumi.getter(name="kmsKeyNames")
+    def kms_key_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Fully qualified name of the KMS keys to use to encrypt this database. The keys must exist
+        in the same locations as the Spanner Database.
+        """
+        return pulumi.get(self, "kms_key_names")
+
+    @kms_key_names.setter
+    def kms_key_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "kms_key_names", value)
+
 
 if not MYPY:
     class DatabaseIAMBindingConditionArgsDict(TypedDict):
@@ -328,6 +360,11 @@ class DatabaseIAMMemberConditionArgs:
 
 if not MYPY:
     class InstanceAutoscalingConfigArgsDict(TypedDict):
+        asymmetric_autoscaling_options: NotRequired[pulumi.Input[Sequence[pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionArgsDict']]]]
+        """
+        Asymmetric autoscaling options for specific replicas.
+        Structure is documented below.
+        """
         autoscaling_limits: NotRequired[pulumi.Input['InstanceAutoscalingConfigAutoscalingLimitsArgsDict']]
         """
         Defines scale in controls to reduce the risk of response latency
@@ -350,9 +387,12 @@ elif False:
 @pulumi.input_type
 class InstanceAutoscalingConfigArgs:
     def __init__(__self__, *,
+                 asymmetric_autoscaling_options: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionArgs']]]] = None,
                  autoscaling_limits: Optional[pulumi.Input['InstanceAutoscalingConfigAutoscalingLimitsArgs']] = None,
                  autoscaling_targets: Optional[pulumi.Input['InstanceAutoscalingConfigAutoscalingTargetsArgs']] = None):
         """
+        :param pulumi.Input[Sequence[pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionArgs']]] asymmetric_autoscaling_options: Asymmetric autoscaling options for specific replicas.
+               Structure is documented below.
         :param pulumi.Input['InstanceAutoscalingConfigAutoscalingLimitsArgs'] autoscaling_limits: Defines scale in controls to reduce the risk of response latency
                and outages due to abrupt scale-in events. Users can define the minimum and
                maximum compute capacity allocated to the instance, and the autoscaler will
@@ -364,11 +404,26 @@ class InstanceAutoscalingConfigArgs:
                and outages due to abrupt scale-in events
                Structure is documented below.
         """
+        if asymmetric_autoscaling_options is not None:
+            pulumi.set(__self__, "asymmetric_autoscaling_options", asymmetric_autoscaling_options)
         if autoscaling_limits is not None:
             pulumi.set(__self__, "autoscaling_limits", autoscaling_limits)
         if autoscaling_targets is not None:
             pulumi.set(__self__, "autoscaling_targets", autoscaling_targets)
 
+    @property
+    @pulumi.getter(name="asymmetricAutoscalingOptions")
+    def asymmetric_autoscaling_options(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionArgs']]]]:
+        """
+        Asymmetric autoscaling options for specific replicas.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "asymmetric_autoscaling_options")
+
+    @asymmetric_autoscaling_options.setter
+    def asymmetric_autoscaling_options(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionArgs']]]]):
+        pulumi.set(self, "asymmetric_autoscaling_options", value)
+
     @property
     @pulumi.getter(name="autoscalingLimits")
     def autoscaling_limits(self) -> Optional[pulumi.Input['InstanceAutoscalingConfigAutoscalingLimitsArgs']]:
@@ -402,12 +457,182 @@ class InstanceAutoscalingConfigArgs:
         pulumi.set(self, "autoscaling_targets", value)
 
 
+if not MYPY:
+    class InstanceAutoscalingConfigAsymmetricAutoscalingOptionArgsDict(TypedDict):
+        overrides: pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesArgsDict']
+        """
+        A nested object resource
+        Structure is documented below.
+        """
+        replica_selection: pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelectionArgsDict']
+        """
+        A nested object resource
+        Structure is documented below.
+        """
+elif False:
+    InstanceAutoscalingConfigAsymmetricAutoscalingOptionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstanceAutoscalingConfigAsymmetricAutoscalingOptionArgs:
+    def __init__(__self__, *,
+                 overrides: pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesArgs'],
+                 replica_selection: pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelectionArgs']):
+        """
+        :param pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesArgs'] overrides: A nested object resource
+               Structure is documented below.
+        :param pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelectionArgs'] replica_selection: A nested object resource
+               Structure is documented below.
+        """
+        pulumi.set(__self__, "overrides", overrides)
+        pulumi.set(__self__, "replica_selection", replica_selection)
+
+    @property
+    @pulumi.getter
+    def overrides(self) -> pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesArgs']:
+        """
+        A nested object resource
+        Structure is documented below.
+        """
+        return pulumi.get(self, "overrides")
+
+    @overrides.setter
+    def overrides(self, value: pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesArgs']):
+        pulumi.set(self, "overrides", value)
+
+    @property
+    @pulumi.getter(name="replicaSelection")
+    def replica_selection(self) -> pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelectionArgs']:
+        """
+        A nested object resource
+        Structure is documented below.
+        """
+        return pulumi.get(self, "replica_selection")
+
+    @replica_selection.setter
+    def replica_selection(self, value: pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelectionArgs']):
+        pulumi.set(self, "replica_selection", value)
+
+
+if not MYPY:
+    class InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesArgsDict(TypedDict):
+        autoscaling_limits: pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimitsArgsDict']
+        """
+        A nested object resource
+        Structure is documented below.
+        """
+elif False:
+    InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesArgs:
+    def __init__(__self__, *,
+                 autoscaling_limits: pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimitsArgs']):
+        """
+        :param pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimitsArgs'] autoscaling_limits: A nested object resource
+               Structure is documented below.
+        """
+        pulumi.set(__self__, "autoscaling_limits", autoscaling_limits)
+
+    @property
+    @pulumi.getter(name="autoscalingLimits")
+    def autoscaling_limits(self) -> pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimitsArgs']:
+        """
+        A nested object resource
+        Structure is documented below.
+        """
+        return pulumi.get(self, "autoscaling_limits")
+
+    @autoscaling_limits.setter
+    def autoscaling_limits(self, value: pulumi.Input['InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimitsArgs']):
+        pulumi.set(self, "autoscaling_limits", value)
+
+
+if not MYPY:
+    class InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimitsArgsDict(TypedDict):
+        max_nodes: pulumi.Input[int]
+        """
+        The maximum number of nodes for this specific replica.
+        """
+        min_nodes: pulumi.Input[int]
+        """
+        The minimum number of nodes for this specific replica.
+        """
+elif False:
+    InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimitsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimitsArgs:
+    def __init__(__self__, *,
+                 max_nodes: pulumi.Input[int],
+                 min_nodes: pulumi.Input[int]):
+        """
+        :param pulumi.Input[int] max_nodes: The maximum number of nodes for this specific replica.
+        :param pulumi.Input[int] min_nodes: The minimum number of nodes for this specific replica.
+        """
+        pulumi.set(__self__, "max_nodes", max_nodes)
+        pulumi.set(__self__, "min_nodes", min_nodes)
+
+    @property
+    @pulumi.getter(name="maxNodes")
+    def max_nodes(self) -> pulumi.Input[int]:
+        """
+        The maximum number of nodes for this specific replica.
+        """
+        return pulumi.get(self, "max_nodes")
+
+    @max_nodes.setter
+    def max_nodes(self, value: pulumi.Input[int]):
+        pulumi.set(self, "max_nodes", value)
+
+    @property
+    @pulumi.getter(name="minNodes")
+    def min_nodes(self) -> pulumi.Input[int]:
+        """
+        The minimum number of nodes for this specific replica.
+        """
+        return pulumi.get(self, "min_nodes")
+
+    @min_nodes.setter
+    def min_nodes(self, value: pulumi.Input[int]):
+        pulumi.set(self, "min_nodes", value)
+
+
+if not MYPY:
+    class InstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelectionArgsDict(TypedDict):
+        location: pulumi.Input[str]
+        """
+        The location of the replica to apply asymmetric autoscaling options.
+        """
+elif False:
+    InstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelectionArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelectionArgs:
+    def __init__(__self__, *,
+                 location: pulumi.Input[str]):
+        """
+        :param pulumi.Input[str] location: The location of the replica to apply asymmetric autoscaling options.
+        """
+        pulumi.set(__self__, "location", location)
+
+    @property
+    @pulumi.getter
+    def location(self) -> pulumi.Input[str]:
+        """
+        The location of the replica to apply asymmetric autoscaling options.
+        """
+        return pulumi.get(self, "location")
+
+    @location.setter
+    def location(self, value: pulumi.Input[str]):
+        pulumi.set(self, "location", value)
+
+
 if not MYPY:
     class InstanceAutoscalingConfigAutoscalingLimitsArgsDict(TypedDict):
         max_nodes: NotRequired[pulumi.Input[int]]
         """
-        Specifies maximum number of nodes allocated to the instance. If set, this number
-        should be greater than or equal to min_nodes.
+        The maximum number of nodes for this specific replica.
         """
         max_processing_units: NotRequired[pulumi.Input[int]]
         """
@@ -417,8 +642,7 @@ if not MYPY:
         """
         min_nodes: NotRequired[pulumi.Input[int]]
         """
-        Specifies number of nodes allocated to the instance. If set, this number
-        should be greater than or equal to 1.
+        The minimum number of nodes for this specific replica.
         """
         min_processing_units: NotRequired[pulumi.Input[int]]
         """
@@ -436,13 +660,11 @@ class InstanceAutoscalingConfigAutoscalingLimitsArgs:
                  min_nodes: Optional[pulumi.Input[int]] = None,
                  min_processing_units: Optional[pulumi.Input[int]] = None):
         """
-        :param pulumi.Input[int] max_nodes: Specifies maximum number of nodes allocated to the instance. If set, this number
-               should be greater than or equal to min_nodes.
+        :param pulumi.Input[int] max_nodes: The maximum number of nodes for this specific replica.
         :param pulumi.Input[int] max_processing_units: Specifies maximum number of processing units allocated to the instance.
                If set, this number should be multiples of 1000 and be greater than or equal to
                min_processing_units.
-        :param pulumi.Input[int] min_nodes: Specifies number of nodes allocated to the instance. If set, this number
-               should be greater than or equal to 1.
+        :param pulumi.Input[int] min_nodes: The minimum number of nodes for this specific replica.
         :param pulumi.Input[int] min_processing_units: Specifies minimum number of processing units allocated to the instance.
                If set, this number should be multiples of 1000.
         """
@@ -459,8 +681,7 @@ class InstanceAutoscalingConfigAutoscalingLimitsArgs:
     @pulumi.getter(name="maxNodes")
     def max_nodes(self) -> Optional[pulumi.Input[int]]:
         """
-        Specifies maximum number of nodes allocated to the instance. If set, this number
-        should be greater than or equal to min_nodes.
+        The maximum number of nodes for this specific replica.
         """
         return pulumi.get(self, "max_nodes")
 
@@ -486,8 +707,7 @@ class InstanceAutoscalingConfigAutoscalingLimitsArgs:
     @pulumi.getter(name="minNodes")
     def min_nodes(self) -> Optional[pulumi.Input[int]]:
         """
-        Specifies number of nodes allocated to the instance. If set, this number
-        should be greater than or equal to 1.
+        The minimum number of nodes for this specific replica.
         """
         return pulumi.get(self, "min_nodes")