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

pulumi_gcp/sql/_inputs.py

@@ -40,6 +40,10 @@ __all__ = [
     'DatabaseInstanceSettingsBackupConfigurationArgsDict',
     'DatabaseInstanceSettingsBackupConfigurationBackupRetentionSettingsArgs',
     'DatabaseInstanceSettingsBackupConfigurationBackupRetentionSettingsArgsDict',
+    'DatabaseInstanceSettingsConnectionPoolConfigArgs',
+    'DatabaseInstanceSettingsConnectionPoolConfigArgsDict',
+    'DatabaseInstanceSettingsConnectionPoolConfigFlagArgs',
+    'DatabaseInstanceSettingsConnectionPoolConfigFlagArgsDict',
     'DatabaseInstanceSettingsDataCacheConfigArgs',
     'DatabaseInstanceSettingsDataCacheConfigArgsDict',
     'DatabaseInstanceSettingsDatabaseFlagArgs',
@@ -908,6 +912,10 @@ if not MYPY:
         """
         The name of server instance collation.
         """
+        connection_pool_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['DatabaseInstanceSettingsConnectionPoolConfigArgsDict']]]]
+        """
+        The managed connection pool setting for a Cloud SQL instance.
+        """
         connector_enforcement: NotRequired[pulumi.Input[builtins.str]]
         """
         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.
@@ -1004,6 +1012,7 @@ class DatabaseInstanceSettingsArgs:
                  availability_type: Optional[pulumi.Input[builtins.str]] = None,
                  backup_configuration: Optional[pulumi.Input['DatabaseInstanceSettingsBackupConfigurationArgs']] = None,
                  collation: Optional[pulumi.Input[builtins.str]] = None,
+                 connection_pool_configs: Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseInstanceSettingsConnectionPoolConfigArgs']]]] = None,
                  connector_enforcement: Optional[pulumi.Input[builtins.str]] = None,
                  data_cache_config: Optional[pulumi.Input['DatabaseInstanceSettingsDataCacheConfigArgs']] = None,
                  data_disk_provisioned_iops: Optional[pulumi.Input[builtins.int]] = None,
@@ -1042,6 +1051,7 @@ class DatabaseInstanceSettingsArgs:
                For Postgres and SQL Server instances, ensure that `settings.backup_configuration.point_in_time_recovery_enabled`
                is set to `true`. Defaults to `ZONAL`.
         :param pulumi.Input[builtins.str] collation: The name of server instance collation.
+        :param pulumi.Input[Sequence[pulumi.Input['DatabaseInstanceSettingsConnectionPoolConfigArgs']]] connection_pool_configs: The managed connection pool setting for a Cloud SQL instance.
         :param pulumi.Input[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 pulumi.Input['DatabaseInstanceSettingsDataCacheConfigArgs'] data_cache_config: Data cache configurations.
         :param pulumi.Input[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.
@@ -1076,6 +1086,8 @@ class DatabaseInstanceSettingsArgs:
             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:
@@ -1210,6 +1222,18 @@ class DatabaseInstanceSettingsArgs:
     def collation(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "collation", value)
 
+    @property
+    @pulumi.getter(name="connectionPoolConfigs")
+    def connection_pool_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseInstanceSettingsConnectionPoolConfigArgs']]]]:
+        """
+        The managed connection pool setting for a Cloud SQL instance.
+        """
+        return pulumi.get(self, "connection_pool_configs")
+
+    @connection_pool_configs.setter
+    def connection_pool_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseInstanceSettingsConnectionPoolConfigArgs']]]]):
+        pulumi.set(self, "connection_pool_configs", value)
+
     @property
     @pulumi.getter(name="connectorEnforcement")
     def connector_enforcement(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -1772,6 +1796,108 @@ class DatabaseInstanceSettingsBackupConfigurationBackupRetentionSettingsArgs:
         pulumi.set(self, "retention_unit", value)
 
 
+if not MYPY:
+    class DatabaseInstanceSettingsConnectionPoolConfigArgsDict(TypedDict):
+        connection_pooling_enabled: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        True if the manager connection pooling configuration is enabled.
+        """
+        flags: NotRequired[pulumi.Input[Sequence[pulumi.Input['DatabaseInstanceSettingsConnectionPoolConfigFlagArgsDict']]]]
+        """
+        List of connection pool configuration flags
+        """
+elif False:
+    DatabaseInstanceSettingsConnectionPoolConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DatabaseInstanceSettingsConnectionPoolConfigArgs:
+    def __init__(__self__, *,
+                 connection_pooling_enabled: Optional[pulumi.Input[builtins.bool]] = None,
+                 flags: Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseInstanceSettingsConnectionPoolConfigFlagArgs']]]] = None):
+        """
+        :param pulumi.Input[builtins.bool] connection_pooling_enabled: True if the manager connection pooling configuration is enabled.
+        :param pulumi.Input[Sequence[pulumi.Input['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[pulumi.Input[builtins.bool]]:
+        """
+        True if the manager connection pooling configuration is enabled.
+        """
+        return pulumi.get(self, "connection_pooling_enabled")
+
+    @connection_pooling_enabled.setter
+    def connection_pooling_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "connection_pooling_enabled", value)
+
+    @property
+    @pulumi.getter
+    def flags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseInstanceSettingsConnectionPoolConfigFlagArgs']]]]:
+        """
+        List of connection pool configuration flags
+        """
+        return pulumi.get(self, "flags")
+
+    @flags.setter
+    def flags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DatabaseInstanceSettingsConnectionPoolConfigFlagArgs']]]]):
+        pulumi.set(self, "flags", value)
+
+
+if not MYPY:
+    class DatabaseInstanceSettingsConnectionPoolConfigFlagArgsDict(TypedDict):
+        name: pulumi.Input[builtins.str]
+        """
+        Name of the flag.
+        """
+        value: pulumi.Input[builtins.str]
+        """
+        Value of the flag.
+        """
+elif False:
+    DatabaseInstanceSettingsConnectionPoolConfigFlagArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class DatabaseInstanceSettingsConnectionPoolConfigFlagArgs:
+    def __init__(__self__, *,
+                 name: pulumi.Input[builtins.str],
+                 value: pulumi.Input[builtins.str]):
+        """
+        :param pulumi.Input[builtins.str] name: Name of the flag.
+        :param pulumi.Input[builtins.str] value: Value of the flag.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[builtins.str]:
+        """
+        Name of the flag.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def value(self) -> pulumi.Input[builtins.str]:
+        """
+        Value of the flag.
+        """
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "value", value)
+
+
 if not MYPY:
     class DatabaseInstanceSettingsDataCacheConfigArgsDict(TypedDict):
         data_cache_enabled: NotRequired[pulumi.Input[builtins.bool]]

pulumi_gcp/sql/database.py

@@ -308,10 +308,8 @@ class _DatabaseState:
         pulumi.set(self, "self_link", value)
 
 
+@pulumi.type_token("gcp:sql/database:Database")
 class Database(pulumi.CustomResource):
-
-    pulumi_type = "gcp:sql/database:Database"
-
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/sql/database_instance.py

@@ -866,10 +866,8 @@ class _DatabaseInstanceState:
         pulumi.set(self, "settings", value)
 
 
+@pulumi.type_token("gcp:sql/databaseInstance:DatabaseInstance")
 class DatabaseInstance(pulumi.CustomResource):
-
-    pulumi_type = "gcp:sql/databaseInstance:DatabaseInstance"
-
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/sql/outputs.py

@@ -29,6 +29,8 @@ __all__ = [
     'DatabaseInstanceSettingsAdvancedMachineFeatures',
     'DatabaseInstanceSettingsBackupConfiguration',
     'DatabaseInstanceSettingsBackupConfigurationBackupRetentionSettings',
+    'DatabaseInstanceSettingsConnectionPoolConfig',
+    'DatabaseInstanceSettingsConnectionPoolConfigFlag',
     'DatabaseInstanceSettingsDataCacheConfig',
     'DatabaseInstanceSettingsDatabaseFlag',
     'DatabaseInstanceSettingsDenyMaintenancePeriod',
@@ -57,6 +59,8 @@ __all__ = [
     'GetDatabaseInstanceSettingAdvancedMachineFeatureResult',
     'GetDatabaseInstanceSettingBackupConfigurationResult',
     'GetDatabaseInstanceSettingBackupConfigurationBackupRetentionSettingResult',
+    'GetDatabaseInstanceSettingConnectionPoolConfigResult',
+    'GetDatabaseInstanceSettingConnectionPoolConfigFlagResult',
     'GetDatabaseInstanceSettingDataCacheConfigResult',
     'GetDatabaseInstanceSettingDatabaseFlagResult',
     'GetDatabaseInstanceSettingDenyMaintenancePeriodResult',
@@ -82,6 +86,8 @@ __all__ = [
     'GetDatabaseInstancesInstanceSettingAdvancedMachineFeatureResult',
     'GetDatabaseInstancesInstanceSettingBackupConfigurationResult',
     'GetDatabaseInstancesInstanceSettingBackupConfigurationBackupRetentionSettingResult',
+    'GetDatabaseInstancesInstanceSettingConnectionPoolConfigResult',
+    'GetDatabaseInstancesInstanceSettingConnectionPoolConfigFlagResult',
     'GetDatabaseInstancesInstanceSettingDataCacheConfigResult',
     'GetDatabaseInstancesInstanceSettingDatabaseFlagResult',
     'GetDatabaseInstancesInstanceSettingDenyMaintenancePeriodResult',
@@ -757,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":
@@ -823,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,
@@ -861,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.
@@ -895,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:
@@ -1001,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]:
@@ -1412,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
@@ -2910,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,
@@ -2945,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.
@@ -2953,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 supported data disk is tier dependent and can be PD_SSD or PD_HDD or HyperDisk_Balanced
+        :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.
@@ -2972,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)
@@ -3043,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:
@@ -3121,7 +3229,7 @@ class GetDatabaseInstanceSettingResult(dict):
     @pulumi.getter(name="diskType")
     def disk_type(self) -> builtins.str:
         """
-        The type of supported data disk is tier dependent and can be PD_SSD or PD_HDD or HyperDisk_Balanced
+        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")
 
@@ -3379,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__, *,
@@ -4607,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,
@@ -4642,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.
@@ -4650,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 supported data disk is tier dependent and can be PD_SSD or PD_HDD or HyperDisk_Balanced
+        :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.
@@ -4669,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)
@@ -4740,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:
@@ -4818,7 +4995,7 @@ class GetDatabaseInstancesInstanceSettingResult(dict):
     @pulumi.getter(name="diskType")
     def disk_type(self) -> builtins.str:
         """
-        The type of supported data disk is tier dependent and can be PD_SSD or PD_HDD or HyperDisk_Balanced
+        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")
 
@@ -5076,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,

pulumi_gcp/storage/anywhere_cache.py

@@ -259,10 +259,8 @@ class _AnywhereCacheState:
         pulumi.set(self, "zone", value)
 
 
+@pulumi.type_token("gcp:storage/anywhereCache:AnywhereCache")
 class AnywhereCache(pulumi.CustomResource):
-
-    pulumi_type = "gcp:storage/anywhereCache:AnywhereCache"
-
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/storage/batch_operations_job.py

@@ -395,10 +395,8 @@ class _BatchOperationsJobState:
         pulumi.set(self, "update_time", value)
 
 
+@pulumi.type_token("gcp:storage/batchOperationsJob:BatchOperationsJob")
 class BatchOperationsJob(pulumi.CustomResource):
-
-    pulumi_type = "gcp:storage/batchOperationsJob:BatchOperationsJob"
-
     @overload
     def __init__(__self__,
                  resource_name: str,