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

pulumi_gcp/spanner/outputs.py

@@ -24,12 +24,20 @@ __all__ = [
     'DatabaseIAMBindingCondition',
     'DatabaseIAMMemberCondition',
     'InstanceAutoscalingConfig',
+    'InstanceAutoscalingConfigAsymmetricAutoscalingOption',
+    'InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrides',
+    'InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimits',
+    'InstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelection',
     'InstanceAutoscalingConfigAutoscalingLimits',
     'InstanceAutoscalingConfigAutoscalingTargets',
     'InstanceConfigReplica',
     'InstanceIAMBindingCondition',
     'InstanceIAMMemberCondition',
     'GetInstanceAutoscalingConfigResult',
+    'GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionResult',
+    'GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrideResult',
+    'GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrideAutoscalingLimitResult',
+    'GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelectionResult',
     'GetInstanceAutoscalingConfigAutoscalingLimitResult',
     'GetInstanceAutoscalingConfigAutoscalingTargetResult',
 ]
@@ -130,6 +138,8 @@ class DatabaseEncryptionConfig(dict):
         suggest = None
         if key == "kmsKeyName":
             suggest = "kms_key_name"
+        elif key == "kmsKeyNames":
+            suggest = "kms_key_names"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in DatabaseEncryptionConfig. Access the value via the '{suggest}' property getter instead.")
@@ -143,22 +153,37 @@ class DatabaseEncryptionConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 kms_key_name: str):
+                 kms_key_name: Optional[str] = None,
+                 kms_key_names: Optional[Sequence[str]] = None):
         """
         :param 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 Sequence[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) -> str:
+    def kms_key_name(self) -> Optional[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.
         """
         return pulumi.get(self, "kms_key_name")
 
+    @property
+    @pulumi.getter(name="kmsKeyNames")
+    def kms_key_names(self) -> Optional[Sequence[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")
+
 
 @pulumi.output_type
 class DatabaseIAMBindingCondition(dict):
@@ -239,7 +264,9 @@ class InstanceAutoscalingConfig(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "autoscalingLimits":
+        if key == "asymmetricAutoscalingOptions":
+            suggest = "asymmetric_autoscaling_options"
+        elif key == "autoscalingLimits":
             suggest = "autoscaling_limits"
         elif key == "autoscalingTargets":
             suggest = "autoscaling_targets"
@@ -256,9 +283,12 @@ class InstanceAutoscalingConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 asymmetric_autoscaling_options: Optional[Sequence['outputs.InstanceAutoscalingConfigAsymmetricAutoscalingOption']] = None,
                  autoscaling_limits: Optional['outputs.InstanceAutoscalingConfigAutoscalingLimits'] = None,
                  autoscaling_targets: Optional['outputs.InstanceAutoscalingConfigAutoscalingTargets'] = None):
         """
+        :param Sequence['InstanceAutoscalingConfigAsymmetricAutoscalingOptionArgs'] asymmetric_autoscaling_options: Asymmetric autoscaling options for specific replicas.
+               Structure is documented below.
         :param '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
@@ -270,11 +300,22 @@ class InstanceAutoscalingConfig(dict):
                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[Sequence['outputs.InstanceAutoscalingConfigAsymmetricAutoscalingOption']]:
+        """
+        Asymmetric autoscaling options for specific replicas.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "asymmetric_autoscaling_options")
+
     @property
     @pulumi.getter(name="autoscalingLimits")
     def autoscaling_limits(self) -> Optional['outputs.InstanceAutoscalingConfigAutoscalingLimits']:
@@ -300,6 +341,159 @@ class InstanceAutoscalingConfig(dict):
         return pulumi.get(self, "autoscaling_targets")
 
 
+@pulumi.output_type
+class InstanceAutoscalingConfigAsymmetricAutoscalingOption(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "replicaSelection":
+            suggest = "replica_selection"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstanceAutoscalingConfigAsymmetricAutoscalingOption. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceAutoscalingConfigAsymmetricAutoscalingOption.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceAutoscalingConfigAsymmetricAutoscalingOption.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 overrides: 'outputs.InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrides',
+                 replica_selection: 'outputs.InstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelection'):
+        """
+        :param 'InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesArgs' overrides: A nested object resource
+               Structure is documented below.
+        :param '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) -> 'outputs.InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrides':
+        """
+        A nested object resource
+        Structure is documented below.
+        """
+        return pulumi.get(self, "overrides")
+
+    @property
+    @pulumi.getter(name="replicaSelection")
+    def replica_selection(self) -> 'outputs.InstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelection':
+        """
+        A nested object resource
+        Structure is documented below.
+        """
+        return pulumi.get(self, "replica_selection")
+
+
+@pulumi.output_type
+class InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrides(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "autoscalingLimits":
+            suggest = "autoscaling_limits"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrides. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrides.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrides.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 autoscaling_limits: 'outputs.InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimits'):
+        """
+        :param '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) -> 'outputs.InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimits':
+        """
+        A nested object resource
+        Structure is documented below.
+        """
+        return pulumi.get(self, "autoscaling_limits")
+
+
+@pulumi.output_type
+class InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimits(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "maxNodes":
+            suggest = "max_nodes"
+        elif key == "minNodes":
+            suggest = "min_nodes"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimits. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimits.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceAutoscalingConfigAsymmetricAutoscalingOptionOverridesAutoscalingLimits.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 max_nodes: int,
+                 min_nodes: int):
+        """
+        :param int max_nodes: The maximum number of nodes for this specific replica.
+        :param 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) -> int:
+        """
+        The maximum number of nodes for this specific replica.
+        """
+        return pulumi.get(self, "max_nodes")
+
+    @property
+    @pulumi.getter(name="minNodes")
+    def min_nodes(self) -> int:
+        """
+        The minimum number of nodes for this specific replica.
+        """
+        return pulumi.get(self, "min_nodes")
+
+
+@pulumi.output_type
+class InstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelection(dict):
+    def __init__(__self__, *,
+                 location: str):
+        """
+        :param str location: The location of the replica to apply asymmetric autoscaling options.
+        """
+        pulumi.set(__self__, "location", location)
+
+    @property
+    @pulumi.getter
+    def location(self) -> str:
+        """
+        The location of the replica to apply asymmetric autoscaling options.
+        """
+        return pulumi.get(self, "location")
+
+
 @pulumi.output_type
 class InstanceAutoscalingConfigAutoscalingLimits(dict):
     @staticmethod
@@ -331,13 +525,11 @@ class InstanceAutoscalingConfigAutoscalingLimits(dict):
                  min_nodes: Optional[int] = None,
                  min_processing_units: Optional[int] = None):
         """
-        :param 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 int max_nodes: The maximum number of nodes for this specific replica.
         :param 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 int min_nodes: Specifies number of nodes allocated to the instance. If set, this number
-               should be greater than or equal to 1.
+        :param int min_nodes: The minimum number of nodes for this specific replica.
         :param int min_processing_units: Specifies minimum number of processing units allocated to the instance.
                If set, this number should be multiples of 1000.
         """
@@ -354,8 +546,7 @@ class InstanceAutoscalingConfigAutoscalingLimits(dict):
     @pulumi.getter(name="maxNodes")
     def max_nodes(self) -> Optional[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")
 
@@ -373,8 +564,7 @@ class InstanceAutoscalingConfigAutoscalingLimits(dict):
     @pulumi.getter(name="minNodes")
     def min_nodes(self) -> Optional[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")
 
@@ -575,9 +765,11 @@ class InstanceIAMMemberCondition(dict):
 @pulumi.output_type
 class GetInstanceAutoscalingConfigResult(dict):
     def __init__(__self__, *,
+                 asymmetric_autoscaling_options: Sequence['outputs.GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionResult'],
                  autoscaling_limits: Sequence['outputs.GetInstanceAutoscalingConfigAutoscalingLimitResult'],
                  autoscaling_targets: Sequence['outputs.GetInstanceAutoscalingConfigAutoscalingTargetResult']):
         """
+        :param Sequence['GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionArgs'] asymmetric_autoscaling_options: Asymmetric autoscaling options for specific replicas.
         :param Sequence['GetInstanceAutoscalingConfigAutoscalingLimitArgs'] 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
@@ -587,9 +779,18 @@ class GetInstanceAutoscalingConfigResult(dict):
         :param Sequence['GetInstanceAutoscalingConfigAutoscalingTargetArgs'] autoscaling_targets: Defines scale in controls to reduce the risk of response latency
                and outages due to abrupt scale-in events
         """
+        pulumi.set(__self__, "asymmetric_autoscaling_options", asymmetric_autoscaling_options)
         pulumi.set(__self__, "autoscaling_limits", autoscaling_limits)
         pulumi.set(__self__, "autoscaling_targets", autoscaling_targets)
 
+    @property
+    @pulumi.getter(name="asymmetricAutoscalingOptions")
+    def asymmetric_autoscaling_options(self) -> Sequence['outputs.GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionResult']:
+        """
+        Asymmetric autoscaling options for specific replicas.
+        """
+        return pulumi.get(self, "asymmetric_autoscaling_options")
+
     @property
     @pulumi.getter(name="autoscalingLimits")
     def autoscaling_limits(self) -> Sequence['outputs.GetInstanceAutoscalingConfigAutoscalingLimitResult']:
@@ -613,6 +814,100 @@ class GetInstanceAutoscalingConfigResult(dict):
         return pulumi.get(self, "autoscaling_targets")
 
 
+@pulumi.output_type
+class GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionResult(dict):
+    def __init__(__self__, *,
+                 overrides: Sequence['outputs.GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrideResult'],
+                 replica_selections: Sequence['outputs.GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelectionResult']):
+        """
+        :param Sequence['GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrideArgs'] overrides: A nested object resource
+        :param Sequence['GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelectionArgs'] replica_selections: A nested object resource
+        """
+        pulumi.set(__self__, "overrides", overrides)
+        pulumi.set(__self__, "replica_selections", replica_selections)
+
+    @property
+    @pulumi.getter
+    def overrides(self) -> Sequence['outputs.GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrideResult']:
+        """
+        A nested object resource
+        """
+        return pulumi.get(self, "overrides")
+
+    @property
+    @pulumi.getter(name="replicaSelections")
+    def replica_selections(self) -> Sequence['outputs.GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelectionResult']:
+        """
+        A nested object resource
+        """
+        return pulumi.get(self, "replica_selections")
+
+
+@pulumi.output_type
+class GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrideResult(dict):
+    def __init__(__self__, *,
+                 autoscaling_limits: Sequence['outputs.GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrideAutoscalingLimitResult']):
+        """
+        :param Sequence['GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrideAutoscalingLimitArgs'] autoscaling_limits: A nested object resource
+        """
+        pulumi.set(__self__, "autoscaling_limits", autoscaling_limits)
+
+    @property
+    @pulumi.getter(name="autoscalingLimits")
+    def autoscaling_limits(self) -> Sequence['outputs.GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrideAutoscalingLimitResult']:
+        """
+        A nested object resource
+        """
+        return pulumi.get(self, "autoscaling_limits")
+
+
+@pulumi.output_type
+class GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionOverrideAutoscalingLimitResult(dict):
+    def __init__(__self__, *,
+                 max_nodes: int,
+                 min_nodes: int):
+        """
+        :param int max_nodes: The maximum number of nodes for this specific replica.
+        :param 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) -> int:
+        """
+        The maximum number of nodes for this specific replica.
+        """
+        return pulumi.get(self, "max_nodes")
+
+    @property
+    @pulumi.getter(name="minNodes")
+    def min_nodes(self) -> int:
+        """
+        The minimum number of nodes for this specific replica.
+        """
+        return pulumi.get(self, "min_nodes")
+
+
+@pulumi.output_type
+class GetInstanceAutoscalingConfigAsymmetricAutoscalingOptionReplicaSelectionResult(dict):
+    def __init__(__self__, *,
+                 location: str):
+        """
+        :param str location: The location of the replica to apply asymmetric autoscaling options.
+        """
+        pulumi.set(__self__, "location", location)
+
+    @property
+    @pulumi.getter
+    def location(self) -> str:
+        """
+        The location of the replica to apply asymmetric autoscaling options.
+        """
+        return pulumi.get(self, "location")
+
+
 @pulumi.output_type
 class GetInstanceAutoscalingConfigAutoscalingLimitResult(dict):
     def __init__(__self__, *,

pulumi_gcp/sql/_inputs.py

@@ -284,7 +284,8 @@ if not MYPY:
         dump_file_path: NotRequired[pulumi.Input[str]]
         """
         Path to a SQL file in GCS from which replica
-        instances are created. Format is `gs://bucket/filename`.
+        instances are created. Format is `gs://bucket/filename`. Note, if the master
+        instance is a source representation instance this field must be present.
         """
         failover_target: NotRequired[pulumi.Input[bool]]
         """
@@ -343,7 +344,8 @@ class DatabaseInstanceReplicaConfigurationArgs:
         :param pulumi.Input[int] connect_retry_interval: The number of seconds
                between connect retries. MySQL's default is 60 seconds.
         :param pulumi.Input[str] dump_file_path: Path to a SQL file in GCS from which replica
-               instances are created. Format is `gs://bucket/filename`.
+               instances are created. Format is `gs://bucket/filename`. Note, if the master
+               instance is a source representation instance this field must be present.
         :param pulumi.Input[bool] failover_target: Specifies if the replica is the failover target.
                If the field is set to true the replica will be designated as a failover replica.
                If the master instance fails, the replica instance will be promoted as
@@ -437,7 +439,8 @@ class DatabaseInstanceReplicaConfigurationArgs:
     def dump_file_path(self) -> Optional[pulumi.Input[str]]:
         """
         Path to a SQL file in GCS from which replica
-        instances are created. Format is `gs://bucket/filename`.
+        instances are created. Format is `gs://bucket/filename`. Note, if the master
+        instance is a source representation instance this field must be present.
         """
         return pulumi.get(self, "dump_file_path")
 
@@ -1837,11 +1840,11 @@ if not MYPY:
         """
         server_ca_mode: NotRequired[pulumi.Input[str]]
         """
-        Specify how the server certificate's Certificate Authority is hosted. Supported value is `GOOGLE_MANAGED_INTERNAL_CA`.
+        Specify how the server certificate's Certificate Authority is hosted. Supported values are `GOOGLE_MANAGED_INTERNAL_CA` and `GOOGLE_MANAGED_CAS_CA`.
         """
         ssl_mode: NotRequired[pulumi.Input[str]]
         """
-        Specify how SSL connection should be enforced in DB connections.
+        Specify how SSL connection should be enforced in DB connections. Supported values are `ALLOW_UNENCRYPTED_AND_ENCRYPTED`, `ENCRYPTED_ONLY`, and `TRUSTED_CLIENT_CERTIFICATE_REQUIRED` (not supported for SQL Server). See [API reference doc](https://cloud.google.com/sql/docs/postgres/admin-api/rest/v1/instances#ipconfiguration) for details.
         """
 elif False:
     DatabaseInstanceSettingsIpConfigurationArgsDict: TypeAlias = Mapping[str, Any]
@@ -1869,8 +1872,8 @@ class DatabaseInstanceSettingsIpConfigurationArgs:
                At least `ipv4_enabled` must be enabled or a `private_network` must be configured.
                This setting can be updated, but it cannot be removed after it is set.
         :param pulumi.Input[Sequence[pulumi.Input['DatabaseInstanceSettingsIpConfigurationPscConfigArgs']]] psc_configs: PSC settings for a Cloud SQL instance.
-        :param pulumi.Input[str] server_ca_mode: Specify how the server certificate's Certificate Authority is hosted. Supported value is `GOOGLE_MANAGED_INTERNAL_CA`.
-        :param pulumi.Input[str] ssl_mode: Specify how SSL connection should be enforced in DB connections.
+        :param pulumi.Input[str] server_ca_mode: Specify how the server certificate's Certificate Authority is hosted. Supported values are `GOOGLE_MANAGED_INTERNAL_CA` and `GOOGLE_MANAGED_CAS_CA`.
+        :param pulumi.Input[str] ssl_mode: Specify how SSL connection should be enforced in DB connections. Supported values are `ALLOW_UNENCRYPTED_AND_ENCRYPTED`, `ENCRYPTED_ONLY`, and `TRUSTED_CLIENT_CERTIFICATE_REQUIRED` (not supported for SQL Server). See [API reference doc](https://cloud.google.com/sql/docs/postgres/admin-api/rest/v1/instances#ipconfiguration) for details.
         """
         if allocated_ip_range is not None:
             pulumi.set(__self__, "allocated_ip_range", allocated_ip_range)
@@ -1968,7 +1971,7 @@ class DatabaseInstanceSettingsIpConfigurationArgs:
     @pulumi.getter(name="serverCaMode")
     def server_ca_mode(self) -> Optional[pulumi.Input[str]]:
         """
-        Specify how the server certificate's Certificate Authority is hosted. Supported value is `GOOGLE_MANAGED_INTERNAL_CA`.
+        Specify how the server certificate's Certificate Authority is hosted. Supported values are `GOOGLE_MANAGED_INTERNAL_CA` and `GOOGLE_MANAGED_CAS_CA`.
         """
         return pulumi.get(self, "server_ca_mode")
 
@@ -1980,7 +1983,7 @@ class DatabaseInstanceSettingsIpConfigurationArgs:
     @pulumi.getter(name="sslMode")
     def ssl_mode(self) -> Optional[pulumi.Input[str]]:
         """
-        Specify how SSL connection should be enforced in DB connections.
+        Specify how SSL connection should be enforced in DB connections. Supported values are `ALLOW_UNENCRYPTED_AND_ENCRYPTED`, `ENCRYPTED_ONLY`, and `TRUSTED_CLIENT_CERTIFICATE_REQUIRED` (not supported for SQL Server). See [API reference doc](https://cloud.google.com/sql/docs/postgres/admin-api/rest/v1/instances#ipconfiguration) for details.
         """
         return pulumi.get(self, "ssl_mode")
 

pulumi_gcp/sql/outputs.py

@@ -304,7 +304,8 @@ class DatabaseInstanceReplicaConfiguration(dict):
         :param int connect_retry_interval: The number of seconds
                between connect retries. MySQL's default is 60 seconds.
         :param str dump_file_path: Path to a SQL file in GCS from which replica
-               instances are created. Format is `gs://bucket/filename`.
+               instances are created. Format is `gs://bucket/filename`. Note, if the master
+               instance is a source representation instance this field must be present.
         :param bool failover_target: Specifies if the replica is the failover target.
                If the field is set to true the replica will be designated as a failover replica.
                If the master instance fails, the replica instance will be promoted as
@@ -382,7 +383,8 @@ class DatabaseInstanceReplicaConfiguration(dict):
     def dump_file_path(self) -> Optional[str]:
         """
         Path to a SQL file in GCS from which replica
-        instances are created. Format is `gs://bucket/filename`.
+        instances are created. Format is `gs://bucket/filename`. Note, if the master
+        instance is a source representation instance this field must be present.
         """
         return pulumi.get(self, "dump_file_path")
 
@@ -1492,8 +1494,8 @@ class DatabaseInstanceSettingsIpConfiguration(dict):
                At least `ipv4_enabled` must be enabled or a `private_network` must be configured.
                This setting can be updated, but it cannot be removed after it is set.
         :param Sequence['DatabaseInstanceSettingsIpConfigurationPscConfigArgs'] psc_configs: PSC settings for a Cloud SQL instance.
-        :param str server_ca_mode: Specify how the server certificate's Certificate Authority is hosted. Supported value is `GOOGLE_MANAGED_INTERNAL_CA`.
-        :param str ssl_mode: Specify how SSL connection should be enforced in DB connections.
+        :param str server_ca_mode: Specify how the server certificate's Certificate Authority is hosted. Supported values are `GOOGLE_MANAGED_INTERNAL_CA` and `GOOGLE_MANAGED_CAS_CA`.
+        :param str ssl_mode: Specify how SSL connection should be enforced in DB connections. Supported values are `ALLOW_UNENCRYPTED_AND_ENCRYPTED`, `ENCRYPTED_ONLY`, and `TRUSTED_CLIENT_CERTIFICATE_REQUIRED` (not supported for SQL Server). See [API reference doc](https://cloud.google.com/sql/docs/postgres/admin-api/rest/v1/instances#ipconfiguration) for details.
         """
         if allocated_ip_range is not None:
             pulumi.set(__self__, "allocated_ip_range", allocated_ip_range)
@@ -1567,7 +1569,7 @@ class DatabaseInstanceSettingsIpConfiguration(dict):
     @pulumi.getter(name="serverCaMode")
     def server_ca_mode(self) -> Optional[str]:
         """
-        Specify how the server certificate's Certificate Authority is hosted. Supported value is `GOOGLE_MANAGED_INTERNAL_CA`.
+        Specify how the server certificate's Certificate Authority is hosted. Supported values are `GOOGLE_MANAGED_INTERNAL_CA` and `GOOGLE_MANAGED_CAS_CA`.
         """
         return pulumi.get(self, "server_ca_mode")
 
@@ -1575,7 +1577,7 @@ class DatabaseInstanceSettingsIpConfiguration(dict):
     @pulumi.getter(name="sslMode")
     def ssl_mode(self) -> Optional[str]:
         """
-        Specify how SSL connection should be enforced in DB connections.
+        Specify how SSL connection should be enforced in DB connections. Supported values are `ALLOW_UNENCRYPTED_AND_ENCRYPTED`, `ENCRYPTED_ONLY`, and `TRUSTED_CLIENT_CERTIFICATE_REQUIRED` (not supported for SQL Server). See [API reference doc](https://cloud.google.com/sql/docs/postgres/admin-api/rest/v1/instances#ipconfiguration) for details.
         """
         return pulumi.get(self, "ssl_mode")