pulumi-gcp 8.29.0a1746115375__py3-none-any.whl → 8.30.0__py3-none-any.whl

pulumi_gcp/sql/outputs.py

@@ -18,6 +18,7 @@ from . import outputs
 
 __all__ = [
     'DatabaseInstanceClone',
+    'DatabaseInstanceDnsName',
     'DatabaseInstanceIpAddress',
     'DatabaseInstanceReplicaConfiguration',
     'DatabaseInstanceReplicationCluster',
@@ -28,6 +29,8 @@ __all__ = [
     'DatabaseInstanceSettingsAdvancedMachineFeatures',
     'DatabaseInstanceSettingsBackupConfiguration',
     'DatabaseInstanceSettingsBackupConfigurationBackupRetentionSettings',
+    'DatabaseInstanceSettingsConnectionPoolConfig',
+    'DatabaseInstanceSettingsConnectionPoolConfigFlag',
     'DatabaseInstanceSettingsDataCacheConfig',
     'DatabaseInstanceSettingsDatabaseFlag',
     'DatabaseInstanceSettingsDenyMaintenancePeriod',
@@ -45,6 +48,7 @@ __all__ = [
     'UserSqlServerUserDetail',
     'GetCaCertsCertResult',
     'GetDatabaseInstanceCloneResult',
+    'GetDatabaseInstanceDnsNameResult',
     'GetDatabaseInstanceIpAddressResult',
     'GetDatabaseInstanceReplicaConfigurationResult',
     'GetDatabaseInstanceReplicationClusterResult',
@@ -55,6 +59,8 @@ __all__ = [
     'GetDatabaseInstanceSettingAdvancedMachineFeatureResult',
     'GetDatabaseInstanceSettingBackupConfigurationResult',
     'GetDatabaseInstanceSettingBackupConfigurationBackupRetentionSettingResult',
+    'GetDatabaseInstanceSettingConnectionPoolConfigResult',
+    'GetDatabaseInstanceSettingConnectionPoolConfigFlagResult',
     'GetDatabaseInstanceSettingDataCacheConfigResult',
     'GetDatabaseInstanceSettingDatabaseFlagResult',
     'GetDatabaseInstanceSettingDenyMaintenancePeriodResult',
@@ -69,6 +75,7 @@ __all__ = [
     'GetDatabaseInstanceSettingSqlServerAuditConfigResult',
     'GetDatabaseInstancesInstanceResult',
     'GetDatabaseInstancesInstanceCloneResult',
+    'GetDatabaseInstancesInstanceDnsNameResult',
     'GetDatabaseInstancesInstanceIpAddressResult',
     'GetDatabaseInstancesInstanceReplicaConfigurationResult',
     'GetDatabaseInstancesInstanceReplicationClusterResult',
@@ -79,6 +86,8 @@ __all__ = [
     'GetDatabaseInstancesInstanceSettingAdvancedMachineFeatureResult',
     'GetDatabaseInstancesInstanceSettingBackupConfigurationResult',
     'GetDatabaseInstancesInstanceSettingBackupConfigurationBackupRetentionSettingResult',
+    'GetDatabaseInstancesInstanceSettingConnectionPoolConfigResult',
+    'GetDatabaseInstancesInstanceSettingConnectionPoolConfigFlagResult',
     'GetDatabaseInstancesInstanceSettingDataCacheConfigResult',
     'GetDatabaseInstancesInstanceSettingDatabaseFlagResult',
     'GetDatabaseInstancesInstanceSettingDenyMaintenancePeriodResult',
@@ -190,6 +199,74 @@ class DatabaseInstanceClone(dict):
         return pulumi.get(self, "preferred_zone")
 
 
+@pulumi.output_type
+class DatabaseInstanceDnsName(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "connectionType":
+            suggest = "connection_type"
+        elif key == "dnsScope":
+            suggest = "dns_scope"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DatabaseInstanceDnsName. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DatabaseInstanceDnsName.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DatabaseInstanceDnsName.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 connection_type: Optional[builtins.str] = None,
+                 dns_scope: Optional[builtins.str] = None,
+                 name: Optional[builtins.str] = None):
+        """
+        :param builtins.str connection_type: The connection type of the DNS name. Can be either `PUBLIC`, `PRIVATE_SERVICES_ACCESS`, or `PRIVATE_SERVICE_CONNECT`.
+        :param builtins.str dns_scope: The scope that the DNS name applies to.
+        :param builtins.str name: The name of the instance. If the name is left
+               blank, the provider will randomly generate one when the instance is first
+               created. This is done because after a name is used, it cannot be reused for
+               up to [one week](https://cloud.google.com/sql/docs/delete-instance).
+        """
+        if connection_type is not None:
+            pulumi.set(__self__, "connection_type", connection_type)
+        if dns_scope is not None:
+            pulumi.set(__self__, "dns_scope", dns_scope)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter(name="connectionType")
+    def connection_type(self) -> Optional[builtins.str]:
+        """
+        The connection type of the DNS name. Can be either `PUBLIC`, `PRIVATE_SERVICES_ACCESS`, or `PRIVATE_SERVICE_CONNECT`.
+        """
+        return pulumi.get(self, "connection_type")
+
+    @property
+    @pulumi.getter(name="dnsScope")
+    def dns_scope(self) -> Optional[builtins.str]:
+        """
+        The scope that the DNS name applies to.
+        """
+        return pulumi.get(self, "dns_scope")
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[builtins.str]:
+        """
+        The name of the instance. If the name is left
+        blank, the provider will randomly generate one when the instance is first
+        created. This is done because after a name is used, it cannot be reused for
+        up to [one week](https://cloud.google.com/sql/docs/delete-instance).
+        """
+        return pulumi.get(self, "name")
+
+
 @pulumi.output_type
 class DatabaseInstanceIpAddress(dict):
     @staticmethod
@@ -686,6 +763,8 @@ class DatabaseInstanceSettings(dict):
             suggest = "availability_type"
         elif key == "backupConfiguration":
             suggest = "backup_configuration"
+        elif key == "connectionPoolConfigs":
+            suggest = "connection_pool_configs"
         elif key == "connectorEnforcement":
             suggest = "connector_enforcement"
         elif key == "dataCacheConfig":
@@ -752,6 +831,7 @@ class DatabaseInstanceSettings(dict):
                  availability_type: Optional[builtins.str] = None,
                  backup_configuration: Optional['outputs.DatabaseInstanceSettingsBackupConfiguration'] = None,
                  collation: Optional[builtins.str] = None,
+                 connection_pool_configs: Optional[Sequence['outputs.DatabaseInstanceSettingsConnectionPoolConfig']] = None,
                  connector_enforcement: Optional[builtins.str] = None,
                  data_cache_config: Optional['outputs.DatabaseInstanceSettingsDataCacheConfig'] = None,
                  data_disk_provisioned_iops: Optional[builtins.int] = None,
@@ -790,6 +870,7 @@ class DatabaseInstanceSettings(dict):
                For Postgres and SQL Server instances, ensure that `settings.backup_configuration.point_in_time_recovery_enabled`
                is set to `true`. Defaults to `ZONAL`.
         :param builtins.str collation: The name of server instance collation.
+        :param Sequence['DatabaseInstanceSettingsConnectionPoolConfigArgs'] connection_pool_configs: The managed connection pool setting for a Cloud SQL instance.
         :param builtins.str connector_enforcement: Control the enforcement of Cloud SQL Auth Proxy or Cloud SQL connectors for all the connections, can be `REQUIRED` or `NOT_REQUIRED`. If enabled, all the direct connections are rejected.
         :param 'DatabaseInstanceSettingsDataCacheConfigArgs' data_cache_config: Data cache configurations.
         :param builtins.int data_disk_provisioned_iops: Provisioned number of I/O operations per second for the data disk. This field is only used for `HYPERDISK_BALANCED` disk types.
@@ -824,6 +905,8 @@ class DatabaseInstanceSettings(dict):
             pulumi.set(__self__, "backup_configuration", backup_configuration)
         if collation is not None:
             pulumi.set(__self__, "collation", collation)
+        if connection_pool_configs is not None:
+            pulumi.set(__self__, "connection_pool_configs", connection_pool_configs)
         if connector_enforcement is not None:
             pulumi.set(__self__, "connector_enforcement", connector_enforcement)
         if data_cache_config is not None:
@@ -930,6 +1013,14 @@ class DatabaseInstanceSettings(dict):
         """
         return pulumi.get(self, "collation")
 
+    @property
+    @pulumi.getter(name="connectionPoolConfigs")
+    def connection_pool_configs(self) -> Optional[Sequence['outputs.DatabaseInstanceSettingsConnectionPoolConfig']]:
+        """
+        The managed connection pool setting for a Cloud SQL instance.
+        """
+        return pulumi.get(self, "connection_pool_configs")
+
     @property
     @pulumi.getter(name="connectorEnforcement")
     def connector_enforcement(self) -> Optional[builtins.str]:
@@ -1341,6 +1432,83 @@ class DatabaseInstanceSettingsBackupConfigurationBackupRetentionSettings(dict):
         return pulumi.get(self, "retention_unit")
 
 
+@pulumi.output_type
+class DatabaseInstanceSettingsConnectionPoolConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "connectionPoolingEnabled":
+            suggest = "connection_pooling_enabled"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DatabaseInstanceSettingsConnectionPoolConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DatabaseInstanceSettingsConnectionPoolConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DatabaseInstanceSettingsConnectionPoolConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 connection_pooling_enabled: Optional[builtins.bool] = None,
+                 flags: Optional[Sequence['outputs.DatabaseInstanceSettingsConnectionPoolConfigFlag']] = None):
+        """
+        :param builtins.bool connection_pooling_enabled: True if the manager connection pooling configuration is enabled.
+        :param Sequence['DatabaseInstanceSettingsConnectionPoolConfigFlagArgs'] flags: List of connection pool configuration flags
+        """
+        if connection_pooling_enabled is not None:
+            pulumi.set(__self__, "connection_pooling_enabled", connection_pooling_enabled)
+        if flags is not None:
+            pulumi.set(__self__, "flags", flags)
+
+    @property
+    @pulumi.getter(name="connectionPoolingEnabled")
+    def connection_pooling_enabled(self) -> Optional[builtins.bool]:
+        """
+        True if the manager connection pooling configuration is enabled.
+        """
+        return pulumi.get(self, "connection_pooling_enabled")
+
+    @property
+    @pulumi.getter
+    def flags(self) -> Optional[Sequence['outputs.DatabaseInstanceSettingsConnectionPoolConfigFlag']]:
+        """
+        List of connection pool configuration flags
+        """
+        return pulumi.get(self, "flags")
+
+
+@pulumi.output_type
+class DatabaseInstanceSettingsConnectionPoolConfigFlag(dict):
+    def __init__(__self__, *,
+                 name: builtins.str,
+                 value: builtins.str):
+        """
+        :param builtins.str name: Name of the flag.
+        :param builtins.str value: Value of the flag.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        Name of the flag.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def value(self) -> builtins.str:
+        """
+        Value of the flag.
+        """
+        return pulumi.get(self, "value")
+
+
 @pulumi.output_type
 class DatabaseInstanceSettingsDataCacheConfig(dict):
     @staticmethod
@@ -2502,6 +2670,38 @@ class GetDatabaseInstanceCloneResult(dict):
         return pulumi.get(self, "source_instance_name")
 
 
+@pulumi.output_type
+class GetDatabaseInstanceDnsNameResult(dict):
+    def __init__(__self__, *,
+                 connection_type: builtins.str,
+                 dns_scope: builtins.str,
+                 name: builtins.str):
+        """
+        :param builtins.str name: The name of the instance.
+        """
+        pulumi.set(__self__, "connection_type", connection_type)
+        pulumi.set(__self__, "dns_scope", dns_scope)
+        pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter(name="connectionType")
+    def connection_type(self) -> builtins.str:
+        return pulumi.get(self, "connection_type")
+
+    @property
+    @pulumi.getter(name="dnsScope")
+    def dns_scope(self) -> builtins.str:
+        return pulumi.get(self, "dns_scope")
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        The name of the instance.
+        """
+        return pulumi.get(self, "name")
+
+
 @pulumi.output_type
 class GetDatabaseInstanceIpAddressResult(dict):
     def __init__(__self__, *,
@@ -2807,6 +3007,7 @@ class GetDatabaseInstanceSettingResult(dict):
                  availability_type: builtins.str,
                  backup_configurations: Sequence['outputs.GetDatabaseInstanceSettingBackupConfigurationResult'],
                  collation: builtins.str,
+                 connection_pool_configs: Sequence['outputs.GetDatabaseInstanceSettingConnectionPoolConfigResult'],
                  connector_enforcement: builtins.str,
                  data_cache_configs: Sequence['outputs.GetDatabaseInstanceSettingDataCacheConfigResult'],
                  data_disk_provisioned_iops: builtins.int,
@@ -2842,6 +3043,7 @@ class GetDatabaseInstanceSettingResult(dict):
                For Postgres instances, ensure that settings.backup_configuration.point_in_time_recovery_enabled
                is set to true. Defaults to ZONAL.
         :param builtins.str collation: The name of server instance collation.
+        :param Sequence['GetDatabaseInstanceSettingConnectionPoolConfigArgs'] connection_pool_configs: The managed connection pool setting for a Cloud SQL instance.
         :param builtins.str connector_enforcement: Enables the enforcement of Cloud SQL Auth Proxy or Cloud SQL connectors for all the connections. If enabled, all the direct connections are rejected.
         :param Sequence['GetDatabaseInstanceSettingDataCacheConfigArgs'] data_cache_configs: Data cache configurations.
         :param builtins.int data_disk_provisioned_iops: Provisioned number of I/O operations per second for the data disk. This field is only used for HYPERDISK_BALANCED disk types.
@@ -2850,7 +3052,7 @@ class GetDatabaseInstanceSettingResult(dict):
         :param builtins.bool disk_autoresize: Enables auto-resizing of the storage size. Defaults to true.
         :param builtins.int disk_autoresize_limit: The maximum size, in GB, to which storage capacity can be automatically increased. The default value is 0, which specifies that there is no limit.
         :param builtins.int disk_size: The size of data disk, in GB. Size of a running instance cannot be reduced but can be increased. The minimum value is 10GB for PD_SSD, PD_HDD and 20GB for HYPERDISK_BALANCED.
-        :param builtins.str disk_type: The type of data disk: PD_SSD, PD_HDD, or HYPERDISK_BALANCED. Defaults to PD_SSD.
+        :param builtins.str disk_type: The type of supported data disk is tier dependent and can be PD_SSD or PD_HDD or HYPERDISK_BALANCED.
         :param builtins.str edition: The edition of the instance, can be ENTERPRISE or ENTERPRISE_PLUS.
         :param builtins.bool enable_dataplex_integration: Enables Dataplex Integration.
         :param builtins.bool enable_google_ml_integration: Enables Vertex AI Integration.
@@ -2869,6 +3071,7 @@ class GetDatabaseInstanceSettingResult(dict):
         pulumi.set(__self__, "availability_type", availability_type)
         pulumi.set(__self__, "backup_configurations", backup_configurations)
         pulumi.set(__self__, "collation", collation)
+        pulumi.set(__self__, "connection_pool_configs", connection_pool_configs)
         pulumi.set(__self__, "connector_enforcement", connector_enforcement)
         pulumi.set(__self__, "data_cache_configs", data_cache_configs)
         pulumi.set(__self__, "data_disk_provisioned_iops", data_disk_provisioned_iops)
@@ -2940,6 +3143,14 @@ class GetDatabaseInstanceSettingResult(dict):
         """
         return pulumi.get(self, "collation")
 
+    @property
+    @pulumi.getter(name="connectionPoolConfigs")
+    def connection_pool_configs(self) -> Sequence['outputs.GetDatabaseInstanceSettingConnectionPoolConfigResult']:
+        """
+        The managed connection pool setting for a Cloud SQL instance.
+        """
+        return pulumi.get(self, "connection_pool_configs")
+
     @property
     @pulumi.getter(name="connectorEnforcement")
     def connector_enforcement(self) -> builtins.str:
@@ -3018,7 +3229,7 @@ class GetDatabaseInstanceSettingResult(dict):
     @pulumi.getter(name="diskType")
     def disk_type(self) -> builtins.str:
         """
-        The type of data disk: PD_SSD, PD_HDD, or HYPERDISK_BALANCED. Defaults to PD_SSD.
+        The type of supported data disk is tier dependent and can be PD_SSD or PD_HDD or HYPERDISK_BALANCED.
         """
         return pulumi.get(self, "disk_type")
 
@@ -3276,6 +3487,64 @@ class GetDatabaseInstanceSettingBackupConfigurationBackupRetentionSettingResult(
         return pulumi.get(self, "retention_unit")
 
 
+@pulumi.output_type
+class GetDatabaseInstanceSettingConnectionPoolConfigResult(dict):
+    def __init__(__self__, *,
+                 connection_pooling_enabled: builtins.bool,
+                 flags: Sequence['outputs.GetDatabaseInstanceSettingConnectionPoolConfigFlagResult']):
+        """
+        :param builtins.bool connection_pooling_enabled: Whether Managed Connection Pool is enabled for this instance.
+        :param Sequence['GetDatabaseInstanceSettingConnectionPoolConfigFlagArgs'] flags: List of connection pool configuration flags
+        """
+        pulumi.set(__self__, "connection_pooling_enabled", connection_pooling_enabled)
+        pulumi.set(__self__, "flags", flags)
+
+    @property
+    @pulumi.getter(name="connectionPoolingEnabled")
+    def connection_pooling_enabled(self) -> builtins.bool:
+        """
+        Whether Managed Connection Pool is enabled for this instance.
+        """
+        return pulumi.get(self, "connection_pooling_enabled")
+
+    @property
+    @pulumi.getter
+    def flags(self) -> Sequence['outputs.GetDatabaseInstanceSettingConnectionPoolConfigFlagResult']:
+        """
+        List of connection pool configuration flags
+        """
+        return pulumi.get(self, "flags")
+
+
+@pulumi.output_type
+class GetDatabaseInstanceSettingConnectionPoolConfigFlagResult(dict):
+    def __init__(__self__, *,
+                 name: builtins.str,
+                 value: builtins.str):
+        """
+        :param builtins.str name: The name of the instance.
+        :param builtins.str value: Value of the flag.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        The name of the instance.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def value(self) -> builtins.str:
+        """
+        Value of the flag.
+        """
+        return pulumi.get(self, "value")
+
+
 @pulumi.output_type
 class GetDatabaseInstanceSettingDataCacheConfigResult(dict):
     def __init__(__self__, *,
@@ -3841,6 +4110,7 @@ class GetDatabaseInstancesInstanceResult(dict):
                  database_version: builtins.str,
                  deletion_protection: builtins.bool,
                  dns_name: builtins.str,
+                 dns_names: Sequence['outputs.GetDatabaseInstancesInstanceDnsNameResult'],
                  encryption_key_name: builtins.str,
                  first_ip_address: builtins.str,
                  instance_type: builtins.str,
@@ -3867,7 +4137,8 @@ class GetDatabaseInstancesInstanceResult(dict):
         :param Sequence['GetDatabaseInstancesInstanceCloneArgs'] clones: Configuration for creating a new instance as a clone of another instance.
         :param builtins.str connection_name: The connection name of the instance to be used in connection strings. For example, when connecting with Cloud SQL Proxy.
         :param builtins.str database_version: To filter out the Cloud SQL instances which are of the specified database version.
-        :param builtins.str dns_name: The dns name of the instance.
+        :param builtins.str dns_name: The instance-level dns name of the instance for PSC instances or public IP CAS instances.
+        :param Sequence['GetDatabaseInstancesInstanceDnsNameArgs'] dns_names: The list of DNS names used by this instance. Different connection types for an instance may have different DNS names. DNS names can apply to an individual instance or a cluster of instances.
         :param builtins.str instance_type: The type of the instance. The valid values are:- 'SQL_INSTANCE_TYPE_UNSPECIFIED', 'CLOUD_SQL_INSTANCE', 'ON_PREMISES_INSTANCE' and 'READ_REPLICA_INSTANCE'.
         :param builtins.str maintenance_version: Maintenance version.
         :param builtins.str master_instance_name: The name of the instance that will act as the master in the replication setup. Note, this requires the master to have binary_log_enabled set, as well as existing backups.
@@ -3888,6 +4159,7 @@ class GetDatabaseInstancesInstanceResult(dict):
         pulumi.set(__self__, "database_version", database_version)
         pulumi.set(__self__, "deletion_protection", deletion_protection)
         pulumi.set(__self__, "dns_name", dns_name)
+        pulumi.set(__self__, "dns_names", dns_names)
         pulumi.set(__self__, "encryption_key_name", encryption_key_name)
         pulumi.set(__self__, "first_ip_address", first_ip_address)
         pulumi.set(__self__, "instance_type", instance_type)
@@ -3951,10 +4223,18 @@ class GetDatabaseInstancesInstanceResult(dict):
     @pulumi.getter(name="dnsName")
     def dns_name(self) -> builtins.str:
         """
-        The dns name of the instance.
+        The instance-level dns name of the instance for PSC instances or public IP CAS instances.
         """
         return pulumi.get(self, "dns_name")
 
+    @property
+    @pulumi.getter(name="dnsNames")
+    def dns_names(self) -> Sequence['outputs.GetDatabaseInstancesInstanceDnsNameResult']:
+        """
+        The list of DNS names used by this instance. Different connection types for an instance may have different DNS names. DNS names can apply to an individual instance or a cluster of instances.
+        """
+        return pulumi.get(self, "dns_names")
+
     @property
     @pulumi.getter(name="encryptionKeyName")
     def encryption_key_name(self) -> builtins.str:
@@ -4162,6 +4442,32 @@ class GetDatabaseInstancesInstanceCloneResult(dict):
         return pulumi.get(self, "source_instance_name")
 
 
+@pulumi.output_type
+class GetDatabaseInstancesInstanceDnsNameResult(dict):
+    def __init__(__self__, *,
+                 connection_type: builtins.str,
+                 dns_scope: builtins.str,
+                 name: builtins.str):
+        pulumi.set(__self__, "connection_type", connection_type)
+        pulumi.set(__self__, "dns_scope", dns_scope)
+        pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter(name="connectionType")
+    def connection_type(self) -> builtins.str:
+        return pulumi.get(self, "connection_type")
+
+    @property
+    @pulumi.getter(name="dnsScope")
+    def dns_scope(self) -> builtins.str:
+        return pulumi.get(self, "dns_scope")
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        return pulumi.get(self, "name")
+
+
 @pulumi.output_type
 class GetDatabaseInstancesInstanceIpAddressResult(dict):
     def __init__(__self__, *,
@@ -4467,6 +4773,7 @@ class GetDatabaseInstancesInstanceSettingResult(dict):
                  availability_type: builtins.str,
                  backup_configurations: Sequence['outputs.GetDatabaseInstancesInstanceSettingBackupConfigurationResult'],
                  collation: builtins.str,
+                 connection_pool_configs: Sequence['outputs.GetDatabaseInstancesInstanceSettingConnectionPoolConfigResult'],
                  connector_enforcement: builtins.str,
                  data_cache_configs: Sequence['outputs.GetDatabaseInstancesInstanceSettingDataCacheConfigResult'],
                  data_disk_provisioned_iops: builtins.int,
@@ -4502,6 +4809,7 @@ class GetDatabaseInstancesInstanceSettingResult(dict):
                For Postgres instances, ensure that settings.backup_configuration.point_in_time_recovery_enabled
                is set to true. Defaults to ZONAL.
         :param builtins.str collation: The name of server instance collation.
+        :param Sequence['GetDatabaseInstancesInstanceSettingConnectionPoolConfigArgs'] connection_pool_configs: The managed connection pool setting for a Cloud SQL instance.
         :param builtins.str connector_enforcement: Enables the enforcement of Cloud SQL Auth Proxy or Cloud SQL connectors for all the connections. If enabled, all the direct connections are rejected.
         :param Sequence['GetDatabaseInstancesInstanceSettingDataCacheConfigArgs'] data_cache_configs: Data cache configurations.
         :param builtins.int data_disk_provisioned_iops: Provisioned number of I/O operations per second for the data disk. This field is only used for HYPERDISK_BALANCED disk types.
@@ -4510,7 +4818,7 @@ class GetDatabaseInstancesInstanceSettingResult(dict):
         :param builtins.bool disk_autoresize: Enables auto-resizing of the storage size. Defaults to true.
         :param builtins.int disk_autoresize_limit: The maximum size, in GB, to which storage capacity can be automatically increased. The default value is 0, which specifies that there is no limit.
         :param builtins.int disk_size: The size of data disk, in GB. Size of a running instance cannot be reduced but can be increased. The minimum value is 10GB for PD_SSD, PD_HDD and 20GB for HYPERDISK_BALANCED.
-        :param builtins.str disk_type: The type of data disk: PD_SSD, PD_HDD, or HYPERDISK_BALANCED. Defaults to PD_SSD.
+        :param builtins.str disk_type: The type of supported data disk is tier dependent and can be PD_SSD or PD_HDD or HYPERDISK_BALANCED.
         :param builtins.str edition: The edition of the instance, can be ENTERPRISE or ENTERPRISE_PLUS.
         :param builtins.bool enable_dataplex_integration: Enables Dataplex Integration.
         :param builtins.bool enable_google_ml_integration: Enables Vertex AI Integration.
@@ -4529,6 +4837,7 @@ class GetDatabaseInstancesInstanceSettingResult(dict):
         pulumi.set(__self__, "availability_type", availability_type)
         pulumi.set(__self__, "backup_configurations", backup_configurations)
         pulumi.set(__self__, "collation", collation)
+        pulumi.set(__self__, "connection_pool_configs", connection_pool_configs)
         pulumi.set(__self__, "connector_enforcement", connector_enforcement)
         pulumi.set(__self__, "data_cache_configs", data_cache_configs)
         pulumi.set(__self__, "data_disk_provisioned_iops", data_disk_provisioned_iops)
@@ -4600,6 +4909,14 @@ class GetDatabaseInstancesInstanceSettingResult(dict):
         """
         return pulumi.get(self, "collation")
 
+    @property
+    @pulumi.getter(name="connectionPoolConfigs")
+    def connection_pool_configs(self) -> Sequence['outputs.GetDatabaseInstancesInstanceSettingConnectionPoolConfigResult']:
+        """
+        The managed connection pool setting for a Cloud SQL instance.
+        """
+        return pulumi.get(self, "connection_pool_configs")
+
     @property
     @pulumi.getter(name="connectorEnforcement")
     def connector_enforcement(self) -> builtins.str:
@@ -4678,7 +4995,7 @@ class GetDatabaseInstancesInstanceSettingResult(dict):
     @pulumi.getter(name="diskType")
     def disk_type(self) -> builtins.str:
         """
-        The type of data disk: PD_SSD, PD_HDD, or HYPERDISK_BALANCED. Defaults to PD_SSD.
+        The type of supported data disk is tier dependent and can be PD_SSD or PD_HDD or HYPERDISK_BALANCED.
         """
         return pulumi.get(self, "disk_type")
 
@@ -4936,6 +5253,64 @@ class GetDatabaseInstancesInstanceSettingBackupConfigurationBackupRetentionSetti
         return pulumi.get(self, "retention_unit")
 
 
+@pulumi.output_type
+class GetDatabaseInstancesInstanceSettingConnectionPoolConfigResult(dict):
+    def __init__(__self__, *,
+                 connection_pooling_enabled: builtins.bool,
+                 flags: Sequence['outputs.GetDatabaseInstancesInstanceSettingConnectionPoolConfigFlagResult']):
+        """
+        :param builtins.bool connection_pooling_enabled: Whether Managed Connection Pool is enabled for this instance.
+        :param Sequence['GetDatabaseInstancesInstanceSettingConnectionPoolConfigFlagArgs'] flags: List of connection pool configuration flags
+        """
+        pulumi.set(__self__, "connection_pooling_enabled", connection_pooling_enabled)
+        pulumi.set(__self__, "flags", flags)
+
+    @property
+    @pulumi.getter(name="connectionPoolingEnabled")
+    def connection_pooling_enabled(self) -> builtins.bool:
+        """
+        Whether Managed Connection Pool is enabled for this instance.
+        """
+        return pulumi.get(self, "connection_pooling_enabled")
+
+    @property
+    @pulumi.getter
+    def flags(self) -> Sequence['outputs.GetDatabaseInstancesInstanceSettingConnectionPoolConfigFlagResult']:
+        """
+        List of connection pool configuration flags
+        """
+        return pulumi.get(self, "flags")
+
+
+@pulumi.output_type
+class GetDatabaseInstancesInstanceSettingConnectionPoolConfigFlagResult(dict):
+    def __init__(__self__, *,
+                 name: builtins.str,
+                 value: builtins.str):
+        """
+        :param builtins.str name: Name of the flag.
+        :param builtins.str value: Value of the flag.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> builtins.str:
+        """
+        Name of the flag.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def value(self) -> builtins.str:
+        """
+        Value of the flag.
+        """
+        return pulumi.get(self, "value")
+
+
 @pulumi.output_type
 class GetDatabaseInstancesInstanceSettingDataCacheConfigResult(dict):
     def __init__(__self__, *,

pulumi_gcp/sql/source_representation_instance.py

@@ -443,10 +443,8 @@ class _SourceRepresentationInstanceState:
         pulumi.set(self, "username", value)
 
 
+@pulumi.type_token("gcp:sql/sourceRepresentationInstance:SourceRepresentationInstance")
 class SourceRepresentationInstance(pulumi.CustomResource):
-
-    pulumi_type = "gcp:sql/sourceRepresentationInstance:SourceRepresentationInstance"
-
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/sql/ssl_cert.py

@@ -255,10 +255,8 @@ class _SslCertState:
         pulumi.set(self, "sha1_fingerprint", value)
 
 
+@pulumi.type_token("gcp:sql/sslCert:SslCert")
 class SslCert(pulumi.CustomResource):
-
-    pulumi_type = "gcp:sql/sslCert:SslCert"
-
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/sql/user.py

@@ -362,10 +362,8 @@ class _UserState:
         pulumi.set(self, "type", value)
 
 
+@pulumi.type_token("gcp:sql/user:User")
 class User(pulumi.CustomResource):
-
-    pulumi_type = "gcp:sql/user:User"
-
     @overload
     def __init__(__self__,
                  resource_name: str,