pulumi-aiven 6.16.0a1715922839__py3-none-any.whl → 6.16.0a1716589862__py3-none-any.whl

pulumi_aiven/_inputs.py

@@ -11,6 +11,7 @@ from . import _utilities
 
 __all__ = [
     'AccountAuthenticationSamlFieldMappingArgs',
+    'CassandraCassandraArgs',
     'CassandraCassandraUserConfigArgs',
     'CassandraCassandraUserConfigCassandraArgs',
     'CassandraCassandraUserConfigIpFilterObjectArgs',
@@ -20,6 +21,7 @@ __all__ = [
     'CassandraServiceIntegrationArgs',
     'CassandraTagArgs',
     'CassandraTechEmailArgs',
+    'ClickhouseClickhouseArgs',
     'ClickhouseClickhouseUserConfigArgs',
     'ClickhouseClickhouseUserConfigIpFilterObjectArgs',
     'ClickhouseClickhouseUserConfigPrivateAccessArgs',
@@ -32,6 +34,7 @@ __all__ = [
     'ClickhouseTagArgs',
     'ClickhouseTechEmailArgs',
     'DragonflyComponentArgs',
+    'DragonflyDragonflyArgs',
     'DragonflyDragonflyUserConfigArgs',
     'DragonflyDragonflyUserConfigIpFilterObjectArgs',
     'DragonflyDragonflyUserConfigMigrationArgs',
@@ -52,6 +55,7 @@ __all__ = [
     'FlinkTagArgs',
     'FlinkTechEmailArgs',
     'GrafanaComponentArgs',
+    'GrafanaGrafanaArgs',
     'GrafanaGrafanaUserConfigArgs',
     'GrafanaGrafanaUserConfigAuthAzureadArgs',
     'GrafanaGrafanaUserConfigAuthGenericOauthArgs',
@@ -117,12 +121,14 @@ __all__ = [
     'KafkaTopicConfigArgs',
     'KafkaTopicTagArgs',
     'M3AggregatorComponentArgs',
+    'M3AggregatorM3aggregatorArgs',
     'M3AggregatorM3aggregatorUserConfigArgs',
     'M3AggregatorM3aggregatorUserConfigIpFilterObjectArgs',
     'M3AggregatorServiceIntegrationArgs',
     'M3AggregatorTagArgs',
     'M3AggregatorTechEmailArgs',
     'M3DbComponentArgs',
+    'M3DbM3dbArgs',
     'M3DbM3dbUserConfigArgs',
     'M3DbM3dbUserConfigIpFilterObjectArgs',
     'M3DbM3dbUserConfigLimitsArgs',
@@ -141,6 +147,8 @@ __all__ = [
     'M3DbTagArgs',
     'M3DbTechEmailArgs',
     'MySqlComponentArgs',
+    'MySqlMysqlArgs',
+    'MySqlMysqlParamArgs',
     'MySqlMysqlUserConfigArgs',
     'MySqlMysqlUserConfigIpFilterObjectArgs',
     'MySqlMysqlUserConfigMigrationArgs',
@@ -177,6 +185,7 @@ __all__ = [
     'OrganizationUserGroupMemberTimeoutsArgs',
     'PgComponentArgs',
     'PgPgArgs',
+    'PgPgParamArgs',
     'PgPgUserConfigArgs',
     'PgPgUserConfigIpFilterObjectArgs',
     'PgPgUserConfigMigrationArgs',
@@ -194,6 +203,7 @@ __all__ = [
     'PgTechEmailArgs',
     'ProjectTagArgs',
     'RedisComponentArgs',
+    'RedisRedisArgs',
     'RedisRedisUserConfigArgs',
     'RedisRedisUserConfigIpFilterObjectArgs',
     'RedisRedisUserConfigMigrationArgs',
@@ -334,6 +344,29 @@ class AccountAuthenticationSamlFieldMappingArgs:
         pulumi.set(self, "real_name", value)
 
 
+@pulumi.input_type
+class CassandraCassandraArgs:
+    def __init__(__self__, *,
+                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] uris: Cassandra server URIs.
+        """
+        if uris is not None:
+            pulumi.set(__self__, "uris", uris)
+
+    @property
+    @pulumi.getter
+    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Cassandra server URIs.
+        """
+        return pulumi.get(self, "uris")
+
+    @uris.setter
+    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "uris", value)
+
+
 @pulumi.input_type
 class CassandraCassandraUserConfigArgs:
     def __init__(__self__, *,
@@ -358,7 +391,7 @@ class CassandraCassandraUserConfigArgs:
         :param pulumi.Input[int] backup_hour: The hour of day (in UTC) when backup for the service is started. New backup is only started if previous backup has already completed.
         :param pulumi.Input[int] backup_minute: The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.
         :param pulumi.Input['CassandraCassandraUserConfigCassandraArgs'] cassandra: Cassandra configuration values
-        :param pulumi.Input[str] cassandra_version: Cassandra version.
+        :param pulumi.Input[str] cassandra_version: Enum: `3`, `4`, `4.1`. Cassandra version.
         :param pulumi.Input[Sequence[pulumi.Input['CassandraCassandraUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
         :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
@@ -465,7 +498,7 @@ class CassandraCassandraUserConfigArgs:
     @pulumi.getter(name="cassandraVersion")
     def cassandra_version(self) -> Optional[pulumi.Input[str]]:
         """
-        Cassandra version.
+        Enum: `3`, `4`, `4.1`. Cassandra version.
         """
         return pulumi.get(self, "cassandra_version")
 
@@ -979,6 +1012,29 @@ class CassandraTechEmailArgs:
         pulumi.set(self, "email", value)
 
 
+@pulumi.input_type
+class ClickhouseClickhouseArgs:
+    def __init__(__self__, *,
+                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] uris: Clickhouse server URIs.
+        """
+        if uris is not None:
+            pulumi.set(__self__, "uris", uris)
+
+    @property
+    @pulumi.getter
+    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Clickhouse server URIs.
+        """
+        return pulumi.get(self, "uris")
+
+    @uris.setter
+    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "uris", value)
+
+
 @pulumi.input_type
 class ClickhouseClickhouseUserConfigArgs:
     def __init__(__self__, *,
@@ -1900,6 +1956,77 @@ class DragonflyComponentArgs:
         pulumi.set(self, "usage", value)
 
 
+@pulumi.input_type
+class DragonflyDragonflyArgs:
+    def __init__(__self__, *,
+                 password: Optional[pulumi.Input[str]] = None,
+                 replica_uri: Optional[pulumi.Input[str]] = None,
+                 slave_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[str] password: Dragonfly password.
+        :param pulumi.Input[str] replica_uri: Dragonfly replica server URI.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] slave_uris: Dragonfly slave server URIs.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] uris: Dragonfly server URIs.
+        """
+        if password is not None:
+            pulumi.set(__self__, "password", password)
+        if replica_uri is not None:
+            pulumi.set(__self__, "replica_uri", replica_uri)
+        if slave_uris is not None:
+            pulumi.set(__self__, "slave_uris", slave_uris)
+        if uris is not None:
+            pulumi.set(__self__, "uris", uris)
+
+    @property
+    @pulumi.getter
+    def password(self) -> Optional[pulumi.Input[str]]:
+        """
+        Dragonfly password.
+        """
+        return pulumi.get(self, "password")
+
+    @password.setter
+    def password(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "password", value)
+
+    @property
+    @pulumi.getter(name="replicaUri")
+    def replica_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        Dragonfly replica server URI.
+        """
+        return pulumi.get(self, "replica_uri")
+
+    @replica_uri.setter
+    def replica_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "replica_uri", value)
+
+    @property
+    @pulumi.getter(name="slaveUris")
+    def slave_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Dragonfly slave server URIs.
+        """
+        return pulumi.get(self, "slave_uris")
+
+    @slave_uris.setter
+    def slave_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "slave_uris", value)
+
+    @property
+    @pulumi.getter
+    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Dragonfly server URIs.
+        """
+        return pulumi.get(self, "uris")
+
+    @uris.setter
+    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "uris", value)
+
+
 @pulumi.input_type
 class DragonflyDragonflyUserConfigArgs:
     def __init__(__self__, *,
@@ -1920,7 +2047,7 @@ class DragonflyDragonflyUserConfigArgs:
                  static_ips: Optional[pulumi.Input[bool]] = None):
         """
         :param pulumi.Input[bool] cache_mode: Evict entries when getting close to maxmemory limit. The default value is `false`.
-        :param pulumi.Input[str] dragonfly_persistence: When persistence is 'rdb', Dragonfly does RDB dumps each 10 minutes. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is 'off', no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
+        :param pulumi.Input[str] dragonfly_persistence: Enum: `off`, `rdb`. When persistence is 'rdb', Dragonfly does RDB dumps each 10 minutes. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is 'off', no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
         :param pulumi.Input[bool] dragonfly_ssl: Require SSL to access Dragonfly. The default value is `true`.
         :param pulumi.Input[Sequence[pulumi.Input['DragonflyDragonflyUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
         :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
@@ -1985,7 +2112,7 @@ class DragonflyDragonflyUserConfigArgs:
     @pulumi.getter(name="dragonflyPersistence")
     def dragonfly_persistence(self) -> Optional[pulumi.Input[str]]:
         """
-        When persistence is 'rdb', Dragonfly does RDB dumps each 10 minutes. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is 'off', no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
+        Enum: `off`, `rdb`. When persistence is 'rdb', Dragonfly does RDB dumps each 10 minutes. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is 'off', no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
         """
         return pulumi.get(self, "dragonfly_persistence")
 
@@ -2207,7 +2334,7 @@ class DragonflyDragonflyUserConfigMigrationArgs:
         :param pulumi.Input[int] port: Port number of the server where to migrate data from.
         :param pulumi.Input[str] dbname: Database name for bootstrapping the initial connection.
         :param pulumi.Input[str] ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment).
-        :param pulumi.Input[str] method: The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
+        :param pulumi.Input[str] method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         :param pulumi.Input[str] password: Password for authentication with the server where to migrate data from.
         :param pulumi.Input[bool] ssl: The server where to migrate data from is secured with SSL. The default value is `true`.
         :param pulumi.Input[str] username: User name for authentication with the server where to migrate data from.
@@ -2279,7 +2406,7 @@ class DragonflyDragonflyUserConfigMigrationArgs:
     @pulumi.getter
     def method(self) -> Optional[pulumi.Input[str]]:
         """
-        The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
+        Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         """
         return pulumi.get(self, "method")
 
@@ -2785,7 +2912,7 @@ class FlinkFlinkUserConfigArgs:
                  static_ips: Optional[pulumi.Input[bool]] = None):
         """
         :param pulumi.Input[str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
-        :param pulumi.Input[str] flink_version: Flink major version.
+        :param pulumi.Input[str] flink_version: Enum: `1.16`. Flink major version.
         :param pulumi.Input[Sequence[pulumi.Input['FlinkFlinkUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
         :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
@@ -2838,7 +2965,7 @@ class FlinkFlinkUserConfigArgs:
     @pulumi.getter(name="flinkVersion")
     def flink_version(self) -> Optional[pulumi.Input[str]]:
         """
-        Flink major version.
+        Enum: `1.16`. Flink major version.
         """
         return pulumi.get(self, "flink_version")
 
@@ -3242,6 +3369,29 @@ class GrafanaComponentArgs:
         pulumi.set(self, "usage", value)
 
 
+@pulumi.input_type
+class GrafanaGrafanaArgs:
+    def __init__(__self__, *,
+                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] uris: Grafana server URIs.
+        """
+        if uris is not None:
+            pulumi.set(__self__, "uris", uris)
+
+    @property
+    @pulumi.getter
+    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Grafana server URIs.
+        """
+        return pulumi.get(self, "uris")
+
+    @uris.setter
+    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "uris", value)
+
+
 @pulumi.input_type
 class GrafanaGrafanaUserConfigArgs:
     def __init__(__self__, *,
@@ -3290,9 +3440,9 @@ class GrafanaGrafanaUserConfigArgs:
         """
         :param pulumi.Input[str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
         :param pulumi.Input[bool] alerting_enabled: Enable or disable Grafana legacy alerting functionality. This should not be enabled with unified*alerting*enabled.
-        :param pulumi.Input[str] alerting_error_or_timeout: Default error or timeout setting for new alerting rules.
+        :param pulumi.Input[str] alerting_error_or_timeout: Enum: `alerting`, `keep_state`. Default error or timeout setting for new alerting rules.
         :param pulumi.Input[int] alerting_max_annotations_to_keep: Max number of alert annotations that Grafana stores. 0 (default) keeps all alert annotations.
-        :param pulumi.Input[str] alerting_nodata_or_nullvalues: Default value for 'no data or null values' for new alerting rules.
+        :param pulumi.Input[str] alerting_nodata_or_nullvalues: Enum: `alerting`, `no_data`, `keep_state`, `ok`. Default value for 'no data or null values' for new alerting rules.
         :param pulumi.Input[bool] allow_embedding: Allow embedding Grafana dashboards with iframe/frame/object/embed tags. Disabled by default to limit impact of clickjacking.
         :param pulumi.Input['GrafanaGrafanaUserConfigAuthAzureadArgs'] auth_azuread: Azure AD OAuth integration
         :param pulumi.Input[bool] auth_basic_enabled: Enable or disable basic authentication form, used by Grafana built-in login.
@@ -3300,7 +3450,7 @@ class GrafanaGrafanaUserConfigArgs:
         :param pulumi.Input['GrafanaGrafanaUserConfigAuthGithubArgs'] auth_github: Github Auth integration
         :param pulumi.Input['GrafanaGrafanaUserConfigAuthGitlabArgs'] auth_gitlab: GitLab Auth integration
         :param pulumi.Input['GrafanaGrafanaUserConfigAuthGoogleArgs'] auth_google: Google Auth integration
-        :param pulumi.Input[str] cookie_samesite: Cookie SameSite attribute: 'strict' prevents sending cookie for cross-site requests, effectively disabling direct linking from other sites to Grafana. 'lax' is the default value.
+        :param pulumi.Input[str] cookie_samesite: Enum: `lax`, `strict`, `none`. Cookie SameSite attribute: 'strict' prevents sending cookie for cross-site requests, effectively disabling direct linking from other sites to Grafana. 'lax' is the default value.
         :param pulumi.Input[str] custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name.
         :param pulumi.Input[bool] dashboard_previews_enabled: This feature is new in Grafana 9 and is quite resource intensive. It may cause low-end plans to work more slowly while the dashboard previews are rendering.
         :param pulumi.Input[str] dashboards_min_refresh_interval: Signed sequence of decimal numbers, followed by a unit suffix (ms, s, m, h, d), e.g. 30s, 1h.
@@ -3328,7 +3478,7 @@ class GrafanaGrafanaUserConfigArgs:
         :param pulumi.Input[bool] static_ips: Use static public IP addresses.
         :param pulumi.Input[bool] unified_alerting_enabled: Enable or disable Grafana unified alerting functionality. By default this is enabled and any legacy alerts will be migrated on upgrade to Grafana 9+. To stay on legacy alerting, set unified*alerting*enabled to false and alerting_enabled to true. See https://grafana.com/docs/grafana/latest/alerting/set-up/migrating-alerts/ for more details.
         :param pulumi.Input[bool] user_auto_assign_org: Auto-assign new users on signup to main organization. Defaults to false.
-        :param pulumi.Input[str] user_auto_assign_org_role: Set role for new signups. Defaults to Viewer.
+        :param pulumi.Input[str] user_auto_assign_org_role: Enum: `Viewer`, `Admin`, `Editor`. Set role for new signups. Defaults to Viewer.
         :param pulumi.Input[bool] viewers_can_edit: Users with view-only permission can edit but not save dashboards.
         """
         if additional_backup_regions is not None:
@@ -3447,7 +3597,7 @@ class GrafanaGrafanaUserConfigArgs:
     @pulumi.getter(name="alertingErrorOrTimeout")
     def alerting_error_or_timeout(self) -> Optional[pulumi.Input[str]]:
         """
-        Default error or timeout setting for new alerting rules.
+        Enum: `alerting`, `keep_state`. Default error or timeout setting for new alerting rules.
         """
         return pulumi.get(self, "alerting_error_or_timeout")
 
@@ -3471,7 +3621,7 @@ class GrafanaGrafanaUserConfigArgs:
     @pulumi.getter(name="alertingNodataOrNullvalues")
     def alerting_nodata_or_nullvalues(self) -> Optional[pulumi.Input[str]]:
         """
-        Default value for 'no data or null values' for new alerting rules.
+        Enum: `alerting`, `no_data`, `keep_state`, `ok`. Default value for 'no data or null values' for new alerting rules.
         """
         return pulumi.get(self, "alerting_nodata_or_nullvalues")
 
@@ -3567,7 +3717,7 @@ class GrafanaGrafanaUserConfigArgs:
     @pulumi.getter(name="cookieSamesite")
     def cookie_samesite(self) -> Optional[pulumi.Input[str]]:
         """
-        Cookie SameSite attribute: 'strict' prevents sending cookie for cross-site requests, effectively disabling direct linking from other sites to Grafana. 'lax' is the default value.
+        Enum: `lax`, `strict`, `none`. Cookie SameSite attribute: 'strict' prevents sending cookie for cross-site requests, effectively disabling direct linking from other sites to Grafana. 'lax' is the default value.
         """
         return pulumi.get(self, "cookie_samesite")
 
@@ -3906,7 +4056,7 @@ class GrafanaGrafanaUserConfigArgs:
     @pulumi.getter(name="userAutoAssignOrgRole")
     def user_auto_assign_org_role(self) -> Optional[pulumi.Input[str]]:
         """
-        Set role for new signups. Defaults to Viewer.
+        Enum: `Viewer`, `Admin`, `Editor`. Set role for new signups. Defaults to Viewer.
         """
         return pulumi.get(self, "user_auto_assign_org_role")
 
@@ -4666,7 +4816,7 @@ class GrafanaGrafanaUserConfigExternalImageStorageArgs:
         """
         :param pulumi.Input[str] access_key: S3 access key. Requires permissions to the S3 bucket for the s3:PutObject and s3:PutObjectAcl actions.
         :param pulumi.Input[str] bucket_url: Bucket URL for S3.
-        :param pulumi.Input[str] provider: Provider type.
+        :param pulumi.Input[str] provider: Enum: `s3`. Provider type.
         :param pulumi.Input[str] secret_key: S3 secret key.
         """
         pulumi.set(__self__, "access_key", access_key)
@@ -4702,7 +4852,7 @@ class GrafanaGrafanaUserConfigExternalImageStorageArgs:
     @pulumi.getter
     def provider(self) -> pulumi.Input[str]:
         """
-        Provider type.
+        Enum: `s3`. Provider type.
         """
         return pulumi.get(self, "provider")
 
@@ -4848,7 +4998,7 @@ class GrafanaGrafanaUserConfigSmtpServerArgs:
         :param pulumi.Input[str] from_name: Name used in outgoing emails, defaults to Grafana.
         :param pulumi.Input[str] password: Password for SMTP authentication.
         :param pulumi.Input[bool] skip_verify: Skip verifying server certificate. Defaults to false.
-        :param pulumi.Input[str] starttls_policy: Either OpportunisticStartTLS, MandatoryStartTLS or NoStartTLS. Default is OpportunisticStartTLS.
+        :param pulumi.Input[str] starttls_policy: Enum: `OpportunisticStartTLS`, `MandatoryStartTLS`, `NoStartTLS`. Either OpportunisticStartTLS, MandatoryStartTLS or NoStartTLS. Default is OpportunisticStartTLS.
         :param pulumi.Input[str] username: Username for SMTP authentication.
         """
         pulumi.set(__self__, "from_address", from_address)
@@ -4941,7 +5091,7 @@ class GrafanaGrafanaUserConfigSmtpServerArgs:
     @pulumi.getter(name="starttlsPolicy")
     def starttls_policy(self) -> Optional[pulumi.Input[str]]:
         """
-        Either OpportunisticStartTLS, MandatoryStartTLS or NoStartTLS. Default is OpportunisticStartTLS.
+        Enum: `OpportunisticStartTLS`, `MandatoryStartTLS`, `NoStartTLS`. Either OpportunisticStartTLS, MandatoryStartTLS or NoStartTLS. Default is OpportunisticStartTLS.
         """
         return pulumi.get(self, "starttls_policy")
 
@@ -5196,12 +5346,24 @@ class InfluxDbComponentArgs:
 @pulumi.input_type
 class InfluxDbInfluxdbArgs:
     def __init__(__self__, *,
-                 database_name: Optional[pulumi.Input[str]] = None):
+                 database_name: Optional[pulumi.Input[str]] = None,
+                 password: Optional[pulumi.Input[str]] = None,
+                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 username: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[str] database_name: Name of the default InfluxDB database
+        :param pulumi.Input[str] password: InfluxDB password
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] uris: InfluxDB server URIs.
+        :param pulumi.Input[str] username: InfluxDB username
         """
         if database_name is not None:
             pulumi.set(__self__, "database_name", database_name)
+        if password is not None:
+            pulumi.set(__self__, "password", password)
+        if uris is not None:
+            pulumi.set(__self__, "uris", uris)
+        if username is not None:
+            pulumi.set(__self__, "username", username)
 
     @property
     @pulumi.getter(name="databaseName")
@@ -5215,6 +5377,42 @@ class InfluxDbInfluxdbArgs:
     def database_name(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "database_name", value)
 
+    @property
+    @pulumi.getter
+    def password(self) -> Optional[pulumi.Input[str]]:
+        """
+        InfluxDB password
+        """
+        return pulumi.get(self, "password")
+
+    @password.setter
+    def password(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "password", value)
+
+    @property
+    @pulumi.getter
+    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        InfluxDB server URIs.
+        """
+        return pulumi.get(self, "uris")
+
+    @uris.setter
+    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "uris", value)
+
+    @property
+    @pulumi.getter
+    def username(self) -> Optional[pulumi.Input[str]]:
+        """
+        InfluxDB username
+        """
+        return pulumi.get(self, "username")
+
+    @username.setter
+    def username(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "username", value)
+
 
 @pulumi.input_type
 class InfluxDbInfluxdbUserConfigArgs:
@@ -6288,10 +6486,10 @@ class KafkaConnectKafkaConnectUserConfigKafkaConnectArgs:
                  scheduled_rebalance_max_delay_ms: Optional[pulumi.Input[int]] = None,
                  session_timeout_ms: Optional[pulumi.Input[int]] = None):
         """
-        :param pulumi.Input[str] connector_client_config_override_policy: Defines what client configurations can be overridden by the connector. Default is None.
-        :param pulumi.Input[str] consumer_auto_offset_reset: What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
+        :param pulumi.Input[str] connector_client_config_override_policy: Enum: `None`, `All`. Defines what client configurations can be overridden by the connector. Default is None.
+        :param pulumi.Input[str] consumer_auto_offset_reset: Enum: `earliest`, `latest`. What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
         :param pulumi.Input[int] consumer_fetch_max_bytes: Records are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not a absolute maximum.
-        :param pulumi.Input[str] consumer_isolation_level: Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
+        :param pulumi.Input[str] consumer_isolation_level: Enum: `read_uncommitted`, `read_committed`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
         :param pulumi.Input[int] consumer_max_partition_fetch_bytes: Records are fetched in batches by the consumer.If the first record batch in the first non-empty partition of the fetch is larger than this limit, the batch will still be returned to ensure that the consumer can make progress.
         :param pulumi.Input[int] consumer_max_poll_interval_ms: The maximum delay in milliseconds between invocations of poll() when using consumer group management (defaults to 300000).
         :param pulumi.Input[int] consumer_max_poll_records: The maximum number of records returned in a single call to poll() (defaults to 500).
@@ -6299,7 +6497,7 @@ class KafkaConnectKafkaConnectUserConfigKafkaConnectArgs:
         :param pulumi.Input[int] offset_flush_timeout_ms: Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt (defaults to 5000).
         :param pulumi.Input[int] producer_batch_size: This setting gives the upper bound of the batch size to be sent. If there are fewer than this many bytes accumulated for this partition, the producer will 'linger' for the linger.ms time waiting for more records to show up. A batch size of zero will disable batching entirely (defaults to 16384).
         :param pulumi.Input[int] producer_buffer_memory: The total bytes of memory the producer can use to buffer records waiting to be sent to the broker (defaults to 33554432).
-        :param pulumi.Input[str] producer_compression_type: Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
+        :param pulumi.Input[str] producer_compression_type: Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
         :param pulumi.Input[int] producer_linger_ms: This setting gives the upper bound on the delay for batching: once there is batch.size worth of records for a partition it will be sent immediately regardless of this setting, however if there are fewer than this many bytes accumulated for this partition the producer will 'linger' for the specified time waiting for more records to show up. Defaults to 0.
         :param pulumi.Input[int] producer_max_request_size: This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests.
         :param pulumi.Input[int] scheduled_rebalance_max_delay_ms: The maximum delay that is scheduled in order to wait for the return of one or more departed workers before rebalancing and reassigning their connectors and tasks to the group. During this period the connectors and tasks of the departed workers remain unassigned. Defaults to 5 minutes.
@@ -6342,7 +6540,7 @@ class KafkaConnectKafkaConnectUserConfigKafkaConnectArgs:
     @pulumi.getter(name="connectorClientConfigOverridePolicy")
     def connector_client_config_override_policy(self) -> Optional[pulumi.Input[str]]:
         """
-        Defines what client configurations can be overridden by the connector. Default is None.
+        Enum: `None`, `All`. Defines what client configurations can be overridden by the connector. Default is None.
         """
         return pulumi.get(self, "connector_client_config_override_policy")
 
@@ -6354,7 +6552,7 @@ class KafkaConnectKafkaConnectUserConfigKafkaConnectArgs:
     @pulumi.getter(name="consumerAutoOffsetReset")
     def consumer_auto_offset_reset(self) -> Optional[pulumi.Input[str]]:
         """
-        What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
+        Enum: `earliest`, `latest`. What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
         """
         return pulumi.get(self, "consumer_auto_offset_reset")
 
@@ -6378,7 +6576,7 @@ class KafkaConnectKafkaConnectUserConfigKafkaConnectArgs:
     @pulumi.getter(name="consumerIsolationLevel")
     def consumer_isolation_level(self) -> Optional[pulumi.Input[str]]:
         """
-        Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
+        Enum: `read_uncommitted`, `read_committed`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
         """
         return pulumi.get(self, "consumer_isolation_level")
 
@@ -6474,7 +6672,7 @@ class KafkaConnectKafkaConnectUserConfigKafkaConnectArgs:
     @pulumi.getter(name="producerCompressionType")
     def producer_compression_type(self) -> Optional[pulumi.Input[str]]:
         """
-        Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
+        Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
         """
         return pulumi.get(self, "producer_compression_type")
 
@@ -6806,13 +7004,15 @@ class KafkaKafkaArgs:
                  access_key: Optional[pulumi.Input[str]] = None,
                  connect_uri: Optional[pulumi.Input[str]] = None,
                  rest_uri: Optional[pulumi.Input[str]] = None,
-                 schema_registry_uri: Optional[pulumi.Input[str]] = None):
+                 schema_registry_uri: Optional[pulumi.Input[str]] = None,
+                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
         """
         :param pulumi.Input[str] access_cert: The Kafka client certificate.
         :param pulumi.Input[str] access_key: The Kafka client certificate key.
         :param pulumi.Input[str] connect_uri: The Kafka Connect URI.
         :param pulumi.Input[str] rest_uri: The Kafka REST URI.
         :param pulumi.Input[str] schema_registry_uri: The Schema Registry URI.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] uris: Kafka server URIs.
         """
         if access_cert is not None:
             pulumi.set(__self__, "access_cert", access_cert)
@@ -6824,6 +7024,8 @@ class KafkaKafkaArgs:
             pulumi.set(__self__, "rest_uri", rest_uri)
         if schema_registry_uri is not None:
             pulumi.set(__self__, "schema_registry_uri", schema_registry_uri)
+        if uris is not None:
+            pulumi.set(__self__, "uris", uris)
 
     @property
     @pulumi.getter(name="accessCert")
@@ -6885,6 +7087,18 @@ class KafkaKafkaArgs:
     def schema_registry_uri(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "schema_registry_uri", value)
 
+    @property
+    @pulumi.getter
+    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Kafka server URIs.
+        """
+        return pulumi.get(self, "uris")
+
+    @uris.setter
+    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "uris", value)
+
 
 @pulumi.input_type
 class KafkaKafkaUserConfigArgs:
@@ -6925,7 +7139,7 @@ class KafkaKafkaUserConfigArgs:
         :param pulumi.Input[bool] kafka_rest: Enable Kafka-REST service. The default value is `false`.
         :param pulumi.Input[bool] kafka_rest_authorization: Enable authorization in Kafka-REST service.
         :param pulumi.Input['KafkaKafkaUserConfigKafkaRestConfigArgs'] kafka_rest_config: Kafka REST configuration
-        :param pulumi.Input[str] kafka_version: Kafka major version.
+        :param pulumi.Input[str] kafka_version: Enum: `3.1`, `3.2`, `3.3`, `3.4`, `3.5`, `3.6`, `3.7`. Kafka major version.
         :param pulumi.Input['KafkaKafkaUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks
         :param pulumi.Input['KafkaKafkaUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink
         :param pulumi.Input['KafkaKafkaUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
@@ -7152,7 +7366,7 @@ class KafkaKafkaUserConfigArgs:
     @pulumi.getter(name="kafkaVersion")
     def kafka_version(self) -> Optional[pulumi.Input[str]]:
         """
-        Kafka major version.
+        Enum: `3.1`, `3.2`, `3.3`, `3.4`, `3.5`, `3.6`, `3.7`. Kafka major version.
         """
         return pulumi.get(self, "kafka_version")
 
@@ -7346,7 +7560,7 @@ class KafkaKafkaUserConfigKafkaArgs:
                  transaction_state_log_segment_bytes: Optional[pulumi.Input[int]] = None):
         """
         :param pulumi.Input[bool] auto_create_topics_enable: Enable auto creation of topics.
-        :param pulumi.Input[str] compression_type: Specify the final compression type for a given topic. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'uncompressed' which is equivalent to no compression; and 'producer' which means retain the original compression codec set by the producer.
+        :param pulumi.Input[str] compression_type: Enum: `gzip`, `snappy`, `lz4`, `zstd`, `uncompressed`, `producer`. Specify the final compression type for a given topic. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'uncompressed' which is equivalent to no compression; and 'producer' which means retain the original compression codec set by the producer.
         :param pulumi.Input[int] connections_max_idle_ms: Idle connections timeout: the server socket processor threads close the connections that idle for longer than this.
         :param pulumi.Input[int] default_replication_factor: Replication factor for autocreated topics.
         :param pulumi.Input[int] group_initial_rebalance_delay_ms: The amount of time, in milliseconds, the group coordinator will wait for more consumers to join a new group before performing the first rebalance. A longer delay means potentially fewer rebalances, but increases the time until processing begins. The default value for this is 3 seconds. During development and testing it might be desirable to set this to 0 in order to not delay test execution time.
@@ -7356,7 +7570,7 @@ class KafkaKafkaUserConfigKafkaArgs:
         :param pulumi.Input[int] log_cleaner_max_compaction_lag_ms: The maximum amount of time message will remain uncompacted. Only applicable for logs that are being compacted.
         :param pulumi.Input[float] log_cleaner_min_cleanable_ratio: Controls log compactor frequency. Larger value means more frequent compactions but also more space wasted for logs. Consider setting log.cleaner.max.compaction.lag.ms to enforce compactions sooner, instead of setting a very high value for this option.
         :param pulumi.Input[int] log_cleaner_min_compaction_lag_ms: The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.
-        :param pulumi.Input[str] log_cleanup_policy: The default cleanup policy for segments beyond the retention window.
+        :param pulumi.Input[str] log_cleanup_policy: Enum: `delete`, `compact`, `compact,delete`. The default cleanup policy for segments beyond the retention window.
         :param pulumi.Input[int] log_flush_interval_messages: The number of messages accumulated on a log partition before messages are flushed to disk.
         :param pulumi.Input[int] log_flush_interval_ms: The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
         :param pulumi.Input[int] log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index.
@@ -7365,7 +7579,7 @@ class KafkaKafkaUserConfigKafkaArgs:
         :param pulumi.Input[int] log_local_retention_ms: The number of milliseconds to keep the local log segments before it gets eligible for deletion. If set to -2, the value of log.retention.ms is used. The effective value should always be less than or equal to log.retention.ms value.
         :param pulumi.Input[bool] log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
         :param pulumi.Input[int] log_message_timestamp_difference_max_ms: The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message.
-        :param pulumi.Input[str] log_message_timestamp_type: Define whether the timestamp in the message is message create time or log append time.
+        :param pulumi.Input[str] log_message_timestamp_type: Enum: `CreateTime`, `LogAppendTime`. Define whether the timestamp in the message is message create time or log append time.
         :param pulumi.Input[bool] log_preallocate: Should pre allocate file when create new segment?
         :param pulumi.Input[int] log_retention_bytes: The maximum size of the log before deleting messages.
         :param pulumi.Input[int] log_retention_hours: The number of hours to keep a log file before deleting it.
@@ -7501,7 +7715,7 @@ class KafkaKafkaUserConfigKafkaArgs:
     @pulumi.getter(name="compressionType")
     def compression_type(self) -> Optional[pulumi.Input[str]]:
         """
-        Specify the final compression type for a given topic. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'uncompressed' which is equivalent to no compression; and 'producer' which means retain the original compression codec set by the producer.
+        Enum: `gzip`, `snappy`, `lz4`, `zstd`, `uncompressed`, `producer`. Specify the final compression type for a given topic. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'uncompressed' which is equivalent to no compression; and 'producer' which means retain the original compression codec set by the producer.
         """
         return pulumi.get(self, "compression_type")
 
@@ -7621,7 +7835,7 @@ class KafkaKafkaUserConfigKafkaArgs:
     @pulumi.getter(name="logCleanupPolicy")
     def log_cleanup_policy(self) -> Optional[pulumi.Input[str]]:
         """
-        The default cleanup policy for segments beyond the retention window.
+        Enum: `delete`, `compact`, `compact,delete`. The default cleanup policy for segments beyond the retention window.
         """
         return pulumi.get(self, "log_cleanup_policy")
 
@@ -7729,7 +7943,7 @@ class KafkaKafkaUserConfigKafkaArgs:
     @pulumi.getter(name="logMessageTimestampType")
     def log_message_timestamp_type(self) -> Optional[pulumi.Input[str]]:
         """
-        Define whether the timestamp in the message is message create time or log append time.
+        Enum: `CreateTime`, `LogAppendTime`. Define whether the timestamp in the message is message create time or log append time.
         """
         return pulumi.get(self, "log_message_timestamp_type")
 
@@ -8097,10 +8311,10 @@ class KafkaKafkaUserConfigKafkaConnectConfigArgs:
                  scheduled_rebalance_max_delay_ms: Optional[pulumi.Input[int]] = None,
                  session_timeout_ms: Optional[pulumi.Input[int]] = None):
         """
-        :param pulumi.Input[str] connector_client_config_override_policy: Defines what client configurations can be overridden by the connector. Default is None.
-        :param pulumi.Input[str] consumer_auto_offset_reset: What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
+        :param pulumi.Input[str] connector_client_config_override_policy: Enum: `None`, `All`. Defines what client configurations can be overridden by the connector. Default is None.
+        :param pulumi.Input[str] consumer_auto_offset_reset: Enum: `earliest`, `latest`. What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
         :param pulumi.Input[int] consumer_fetch_max_bytes: Records are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not a absolute maximum.
-        :param pulumi.Input[str] consumer_isolation_level: Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
+        :param pulumi.Input[str] consumer_isolation_level: Enum: `read_uncommitted`, `read_committed`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
         :param pulumi.Input[int] consumer_max_partition_fetch_bytes: Records are fetched in batches by the consumer.If the first record batch in the first non-empty partition of the fetch is larger than this limit, the batch will still be returned to ensure that the consumer can make progress.
         :param pulumi.Input[int] consumer_max_poll_interval_ms: The maximum delay in milliseconds between invocations of poll() when using consumer group management (defaults to 300000).
         :param pulumi.Input[int] consumer_max_poll_records: The maximum number of records returned in a single call to poll() (defaults to 500).
@@ -8108,7 +8322,7 @@ class KafkaKafkaUserConfigKafkaConnectConfigArgs:
         :param pulumi.Input[int] offset_flush_timeout_ms: Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt (defaults to 5000).
         :param pulumi.Input[int] producer_batch_size: This setting gives the upper bound of the batch size to be sent. If there are fewer than this many bytes accumulated for this partition, the producer will 'linger' for the linger.ms time waiting for more records to show up. A batch size of zero will disable batching entirely (defaults to 16384).
         :param pulumi.Input[int] producer_buffer_memory: The total bytes of memory the producer can use to buffer records waiting to be sent to the broker (defaults to 33554432).
-        :param pulumi.Input[str] producer_compression_type: Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
+        :param pulumi.Input[str] producer_compression_type: Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
         :param pulumi.Input[int] producer_linger_ms: This setting gives the upper bound on the delay for batching: once there is batch.size worth of records for a partition it will be sent immediately regardless of this setting, however if there are fewer than this many bytes accumulated for this partition the producer will 'linger' for the specified time waiting for more records to show up. Defaults to 0.
         :param pulumi.Input[int] producer_max_request_size: This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests.
         :param pulumi.Input[int] scheduled_rebalance_max_delay_ms: The maximum delay that is scheduled in order to wait for the return of one or more departed workers before rebalancing and reassigning their connectors and tasks to the group. During this period the connectors and tasks of the departed workers remain unassigned. Defaults to 5 minutes.
@@ -8151,7 +8365,7 @@ class KafkaKafkaUserConfigKafkaConnectConfigArgs:
     @pulumi.getter(name="connectorClientConfigOverridePolicy")
     def connector_client_config_override_policy(self) -> Optional[pulumi.Input[str]]:
         """
-        Defines what client configurations can be overridden by the connector. Default is None.
+        Enum: `None`, `All`. Defines what client configurations can be overridden by the connector. Default is None.
         """
         return pulumi.get(self, "connector_client_config_override_policy")
 
@@ -8163,7 +8377,7 @@ class KafkaKafkaUserConfigKafkaConnectConfigArgs:
     @pulumi.getter(name="consumerAutoOffsetReset")
     def consumer_auto_offset_reset(self) -> Optional[pulumi.Input[str]]:
         """
-        What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
+        Enum: `earliest`, `latest`. What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
         """
         return pulumi.get(self, "consumer_auto_offset_reset")
 
@@ -8187,7 +8401,7 @@ class KafkaKafkaUserConfigKafkaConnectConfigArgs:
     @pulumi.getter(name="consumerIsolationLevel")
     def consumer_isolation_level(self) -> Optional[pulumi.Input[str]]:
         """
-        Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
+        Enum: `read_uncommitted`, `read_committed`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
         """
         return pulumi.get(self, "consumer_isolation_level")
 
@@ -8283,7 +8497,7 @@ class KafkaKafkaUserConfigKafkaConnectConfigArgs:
     @pulumi.getter(name="producerCompressionType")
     def producer_compression_type(self) -> Optional[pulumi.Input[str]]:
         """
-        Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
+        Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
         """
         return pulumi.get(self, "producer_compression_type")
 
@@ -8356,11 +8570,11 @@ class KafkaKafkaUserConfigKafkaRestConfigArgs:
         """
         :param pulumi.Input[bool] consumer_enable_auto_commit: If true the consumer's offset will be periodically committed to Kafka in the background. The default value is `true`.
         :param pulumi.Input[int] consumer_request_max_bytes: Maximum number of bytes in unencoded message keys and values by a single request. The default value is `67108864`.
-        :param pulumi.Input[int] consumer_request_timeout_ms: The maximum total time to wait for messages for a request if the maximum number of messages has not yet been reached. The default value is `1000`.
-        :param pulumi.Input[str] name_strategy: Name strategy to use when selecting subject for storing schemas. The default value is `topic_name`.
+        :param pulumi.Input[int] consumer_request_timeout_ms: Enum: `1000`, `15000`, `30000`. The maximum total time to wait for messages for a request if the maximum number of messages has not yet been reached. The default value is `1000`.
+        :param pulumi.Input[str] name_strategy: Enum: `topic_name`, `record_name`, `topic_record_name`. Name strategy to use when selecting subject for storing schemas. The default value is `topic_name`.
         :param pulumi.Input[bool] name_strategy_validation: If true, validate that given schema is registered under expected subject name by the used name strategy when producing messages. The default value is `true`.
-        :param pulumi.Input[str] producer_acks: The number of acknowledgments the producer requires the leader to have received before considering a request complete. If set to 'all' or '-1', the leader will wait for the full set of in-sync replicas to acknowledge the record. The default value is `1`.
-        :param pulumi.Input[str] producer_compression_type: Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
+        :param pulumi.Input[str] producer_acks: Enum: `all`, `-1`, `0`, `1`. The number of acknowledgments the producer requires the leader to have received before considering a request complete. If set to 'all' or '-1', the leader will wait for the full set of in-sync replicas to acknowledge the record. The default value is `1`.
+        :param pulumi.Input[str] producer_compression_type: Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
         :param pulumi.Input[int] producer_linger_ms: Wait for up to the given delay to allow batching records together. The default value is `0`.
         :param pulumi.Input[int] producer_max_request_size: The maximum size of a request in bytes. Note that Kafka broker can also cap the record batch size. The default value is `1048576`.
         :param pulumi.Input[int] simpleconsumer_pool_size_max: Maximum number of SimpleConsumers that can be instantiated per broker. The default value is `25`.
@@ -8414,7 +8628,7 @@ class KafkaKafkaUserConfigKafkaRestConfigArgs:
     @pulumi.getter(name="consumerRequestTimeoutMs")
     def consumer_request_timeout_ms(self) -> Optional[pulumi.Input[int]]:
         """
-        The maximum total time to wait for messages for a request if the maximum number of messages has not yet been reached. The default value is `1000`.
+        Enum: `1000`, `15000`, `30000`. The maximum total time to wait for messages for a request if the maximum number of messages has not yet been reached. The default value is `1000`.
         """
         return pulumi.get(self, "consumer_request_timeout_ms")
 
@@ -8426,7 +8640,7 @@ class KafkaKafkaUserConfigKafkaRestConfigArgs:
     @pulumi.getter(name="nameStrategy")
     def name_strategy(self) -> Optional[pulumi.Input[str]]:
         """
-        Name strategy to use when selecting subject for storing schemas. The default value is `topic_name`.
+        Enum: `topic_name`, `record_name`, `topic_record_name`. Name strategy to use when selecting subject for storing schemas. The default value is `topic_name`.
         """
         return pulumi.get(self, "name_strategy")
 
@@ -8450,7 +8664,7 @@ class KafkaKafkaUserConfigKafkaRestConfigArgs:
     @pulumi.getter(name="producerAcks")
     def producer_acks(self) -> Optional[pulumi.Input[str]]:
         """
-        The number of acknowledgments the producer requires the leader to have received before considering a request complete. If set to 'all' or '-1', the leader will wait for the full set of in-sync replicas to acknowledge the record. The default value is `1`.
+        Enum: `all`, `-1`, `0`, `1`. The number of acknowledgments the producer requires the leader to have received before considering a request complete. If set to 'all' or '-1', the leader will wait for the full set of in-sync replicas to acknowledge the record. The default value is `1`.
         """
         return pulumi.get(self, "producer_acks")
 
@@ -8462,7 +8676,7 @@ class KafkaKafkaUserConfigKafkaRestConfigArgs:
     @pulumi.getter(name="producerCompressionType")
     def producer_compression_type(self) -> Optional[pulumi.Input[str]]:
         """
-        Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
+        Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
         """
         return pulumi.get(self, "producer_compression_type")
 
@@ -10226,6 +10440,45 @@ class M3AggregatorComponentArgs:
         pulumi.set(self, "usage", value)
 
 
+@pulumi.input_type
+class M3AggregatorM3aggregatorArgs:
+    def __init__(__self__, *,
+                 aggregator_http_uri: Optional[pulumi.Input[str]] = None,
+                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[str] aggregator_http_uri: M3 Aggregator HTTP URI.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] uris: M3 Aggregator server URIs.
+        """
+        if aggregator_http_uri is not None:
+            pulumi.set(__self__, "aggregator_http_uri", aggregator_http_uri)
+        if uris is not None:
+            pulumi.set(__self__, "uris", uris)
+
+    @property
+    @pulumi.getter(name="aggregatorHttpUri")
+    def aggregator_http_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        M3 Aggregator HTTP URI.
+        """
+        return pulumi.get(self, "aggregator_http_uri")
+
+    @aggregator_http_uri.setter
+    def aggregator_http_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "aggregator_http_uri", value)
+
+    @property
+    @pulumi.getter
+    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        M3 Aggregator server URIs.
+        """
+        return pulumi.get(self, "uris")
+
+    @uris.setter
+    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "uris", value)
+
+
 @pulumi.input_type
 class M3AggregatorM3aggregatorUserConfigArgs:
     def __init__(__self__, *,
@@ -10242,8 +10495,8 @@ class M3AggregatorM3aggregatorUserConfigArgs:
         :param pulumi.Input[Sequence[pulumi.Input['M3AggregatorM3aggregatorUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
         :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
-        :param pulumi.Input[str] m3_version: M3 major version (deprecated, use m3aggregator_version).
-        :param pulumi.Input[str] m3aggregator_version: M3 major version (the minimum compatible version).
+        :param pulumi.Input[str] m3_version: Enum: `1.1`, `1.2`, `1.5`. M3 major version (deprecated, use m3aggregator_version).
+        :param pulumi.Input[str] m3aggregator_version: Enum: `1.1`, `1.2`, `1.5`. M3 major version (the minimum compatible version).
         :param pulumi.Input[bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
         :param pulumi.Input[bool] static_ips: Use static public IP addresses.
         """
@@ -10322,7 +10575,7 @@ class M3AggregatorM3aggregatorUserConfigArgs:
     @pulumi.getter(name="m3Version")
     def m3_version(self) -> Optional[pulumi.Input[str]]:
         """
-        M3 major version (deprecated, use m3aggregator_version).
+        Enum: `1.1`, `1.2`, `1.5`. M3 major version (deprecated, use m3aggregator_version).
         """
         return pulumi.get(self, "m3_version")
 
@@ -10334,7 +10587,7 @@ class M3AggregatorM3aggregatorUserConfigArgs:
     @pulumi.getter(name="m3aggregatorVersion")
     def m3aggregator_version(self) -> Optional[pulumi.Input[str]]:
         """
-        M3 major version (the minimum compatible version).
+        Enum: `1.1`, `1.2`, `1.5`. M3 major version (the minimum compatible version).
         """
         return pulumi.get(self, "m3aggregator_version")
 
@@ -10636,6 +10889,109 @@ class M3DbComponentArgs:
         pulumi.set(self, "usage", value)
 
 
+@pulumi.input_type
+class M3DbM3dbArgs:
+    def __init__(__self__, *,
+                 http_cluster_uri: Optional[pulumi.Input[str]] = None,
+                 http_node_uri: Optional[pulumi.Input[str]] = None,
+                 influxdb_uri: Optional[pulumi.Input[str]] = None,
+                 prometheus_remote_read_uri: Optional[pulumi.Input[str]] = None,
+                 prometheus_remote_write_uri: Optional[pulumi.Input[str]] = None,
+                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[str] http_cluster_uri: M3DB cluster URI.
+        :param pulumi.Input[str] http_node_uri: M3DB node URI.
+        :param pulumi.Input[str] influxdb_uri: InfluxDB URI.
+        :param pulumi.Input[str] prometheus_remote_read_uri: Prometheus remote read URI.
+        :param pulumi.Input[str] prometheus_remote_write_uri: Prometheus remote write URI.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] uris: M3DB server URIs.
+        """
+        if http_cluster_uri is not None:
+            pulumi.set(__self__, "http_cluster_uri", http_cluster_uri)
+        if http_node_uri is not None:
+            pulumi.set(__self__, "http_node_uri", http_node_uri)
+        if influxdb_uri is not None:
+            pulumi.set(__self__, "influxdb_uri", influxdb_uri)
+        if prometheus_remote_read_uri is not None:
+            pulumi.set(__self__, "prometheus_remote_read_uri", prometheus_remote_read_uri)
+        if prometheus_remote_write_uri is not None:
+            pulumi.set(__self__, "prometheus_remote_write_uri", prometheus_remote_write_uri)
+        if uris is not None:
+            pulumi.set(__self__, "uris", uris)
+
+    @property
+    @pulumi.getter(name="httpClusterUri")
+    def http_cluster_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        M3DB cluster URI.
+        """
+        return pulumi.get(self, "http_cluster_uri")
+
+    @http_cluster_uri.setter
+    def http_cluster_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "http_cluster_uri", value)
+
+    @property
+    @pulumi.getter(name="httpNodeUri")
+    def http_node_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        M3DB node URI.
+        """
+        return pulumi.get(self, "http_node_uri")
+
+    @http_node_uri.setter
+    def http_node_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "http_node_uri", value)
+
+    @property
+    @pulumi.getter(name="influxdbUri")
+    def influxdb_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        InfluxDB URI.
+        """
+        return pulumi.get(self, "influxdb_uri")
+
+    @influxdb_uri.setter
+    def influxdb_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "influxdb_uri", value)
+
+    @property
+    @pulumi.getter(name="prometheusRemoteReadUri")
+    def prometheus_remote_read_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        Prometheus remote read URI.
+        """
+        return pulumi.get(self, "prometheus_remote_read_uri")
+
+    @prometheus_remote_read_uri.setter
+    def prometheus_remote_read_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "prometheus_remote_read_uri", value)
+
+    @property
+    @pulumi.getter(name="prometheusRemoteWriteUri")
+    def prometheus_remote_write_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        Prometheus remote write URI.
+        """
+        return pulumi.get(self, "prometheus_remote_write_uri")
+
+    @prometheus_remote_write_uri.setter
+    def prometheus_remote_write_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "prometheus_remote_write_uri", value)
+
+    @property
+    @pulumi.getter
+    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        M3DB server URIs.
+        """
+        return pulumi.get(self, "uris")
+
+    @uris.setter
+    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "uris", value)
+
+
 @pulumi.input_type
 class M3DbM3dbUserConfigArgs:
     def __init__(__self__, *,
@@ -10665,9 +11021,9 @@ class M3DbM3dbUserConfigArgs:
         :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
         :param pulumi.Input['M3DbM3dbUserConfigLimitsArgs'] limits: M3 limits
         :param pulumi.Input['M3DbM3dbUserConfigM3Args'] m3: M3 specific configuration options
-        :param pulumi.Input[str] m3_version: M3 major version (deprecated, use m3db_version).
+        :param pulumi.Input[str] m3_version: Enum: `1.1`, `1.2`, `1.5`. M3 major version (deprecated, use m3db_version).
         :param pulumi.Input[bool] m3coordinator_enable_graphite_carbon_ingest: Enables access to Graphite Carbon plaintext metrics ingestion. It can be enabled only for services inside VPCs. The metrics are written to aggregated namespaces only.
-        :param pulumi.Input[str] m3db_version: M3 major version (the minimum compatible version).
+        :param pulumi.Input[str] m3db_version: Enum: `1.1`, `1.2`, `1.5`. M3 major version (the minimum compatible version).
         :param pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigNamespaceArgs']]] namespaces: List of M3 namespaces
         :param pulumi.Input['M3DbM3dbUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks
         :param pulumi.Input[str] project_to_fork_from: Name of another project to fork a service from. This has effect only when a new service is being created.
@@ -10808,7 +11164,7 @@ class M3DbM3dbUserConfigArgs:
     @pulumi.getter(name="m3Version")
     def m3_version(self) -> Optional[pulumi.Input[str]]:
         """
-        M3 major version (deprecated, use m3db_version).
+        Enum: `1.1`, `1.2`, `1.5`. M3 major version (deprecated, use m3db_version).
         """
         return pulumi.get(self, "m3_version")
 
@@ -10832,7 +11188,7 @@ class M3DbM3dbUserConfigArgs:
     @pulumi.getter(name="m3dbVersion")
     def m3db_version(self) -> Optional[pulumi.Input[str]]:
         """
-        M3 major version (the minimum compatible version).
+        Enum: `1.1`, `1.2`, `1.5`. M3 major version (the minimum compatible version).
         """
         return pulumi.get(self, "m3db_version")
 
@@ -11149,7 +11505,7 @@ class M3DbM3dbUserConfigNamespaceArgs:
                  resolution: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[str] name: The name of the namespace.
-        :param pulumi.Input[str] type: The type of aggregation (aggregated/unaggregated).
+        :param pulumi.Input[str] type: Enum: `aggregated`, `unaggregated`. The type of aggregation (aggregated/unaggregated).
         :param pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsArgs'] options: Namespace options
         :param pulumi.Input[str] resolution: The resolution for an aggregated namespace.
         """
@@ -11176,7 +11532,7 @@ class M3DbM3dbUserConfigNamespaceArgs:
     @pulumi.getter
     def type(self) -> pulumi.Input[str]:
         """
-        The type of aggregation (aggregated/unaggregated).
+        Enum: `aggregated`, `unaggregated`. The type of aggregation (aggregated/unaggregated).
         """
         return pulumi.get(self, "type")
 
@@ -11866,85 +12222,275 @@ class MySqlComponentArgs:
 
 
 @pulumi.input_type
-class MySqlMysqlUserConfigArgs:
+class MySqlMysqlArgs:
     def __init__(__self__, *,
-                 additional_backup_regions: Optional[pulumi.Input[str]] = None,
-                 admin_password: Optional[pulumi.Input[str]] = None,
-                 admin_username: Optional[pulumi.Input[str]] = None,
-                 backup_hour: Optional[pulumi.Input[int]] = None,
-                 backup_minute: Optional[pulumi.Input[int]] = None,
-                 binlog_retention_period: Optional[pulumi.Input[int]] = None,
-                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['MySqlMysqlUserConfigIpFilterObjectArgs']]]] = None,
-                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-                 migration: Optional[pulumi.Input['MySqlMysqlUserConfigMigrationArgs']] = None,
-                 mysql: Optional[pulumi.Input['MySqlMysqlUserConfigMysqlArgs']] = None,
-                 mysql_version: Optional[pulumi.Input[str]] = None,
-                 private_access: Optional[pulumi.Input['MySqlMysqlUserConfigPrivateAccessArgs']] = None,
-                 privatelink_access: Optional[pulumi.Input['MySqlMysqlUserConfigPrivatelinkAccessArgs']] = None,
-                 project_to_fork_from: Optional[pulumi.Input[str]] = None,
-                 public_access: Optional[pulumi.Input['MySqlMysqlUserConfigPublicAccessArgs']] = None,
-                 recovery_target_time: Optional[pulumi.Input[str]] = None,
-                 service_log: Optional[pulumi.Input[bool]] = None,
-                 service_to_fork_from: Optional[pulumi.Input[str]] = None,
-                 static_ips: Optional[pulumi.Input[bool]] = None):
+                 params: Optional[pulumi.Input[Sequence[pulumi.Input['MySqlMysqlParamArgs']]]] = None,
+                 replica_uri: Optional[pulumi.Input[str]] = None,
+                 standby_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 syncing_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input['MySqlMysqlParamArgs']]] params: MySQL connection parameters
+        :param pulumi.Input[str] replica_uri: MySQL replica URI for services with a replica
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] standby_uris: MySQL standby connection URIs
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] syncing_uris: MySQL syncing connection URIs
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] uris: MySQL master connection URIs
+        """
+        if params is not None:
+            pulumi.set(__self__, "params", params)
+        if replica_uri is not None:
+            pulumi.set(__self__, "replica_uri", replica_uri)
+        if standby_uris is not None:
+            pulumi.set(__self__, "standby_uris", standby_uris)
+        if syncing_uris is not None:
+            pulumi.set(__self__, "syncing_uris", syncing_uris)
+        if uris is not None:
+            pulumi.set(__self__, "uris", uris)
+
+    @property
+    @pulumi.getter
+    def params(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MySqlMysqlParamArgs']]]]:
         """
-        :param pulumi.Input[str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
-        :param pulumi.Input[str] admin_password: Custom password for admin user. Defaults to random string. This must be set only when a new service is being created.
-        :param pulumi.Input[str] admin_username: Custom username for admin user. This must be set only when a new service is being created.
-        :param pulumi.Input[int] backup_hour: The hour of day (in UTC) when backup for the service is started. New backup is only started if previous backup has already completed.
-        :param pulumi.Input[int] backup_minute: The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.
-        :param pulumi.Input[int] binlog_retention_period: The minimum amount of time in seconds to keep binlog entries before deletion. This may be extended for services that require binlog entries for longer than the default for example if using the MySQL Debezium Kafka connector.
-        :param pulumi.Input[Sequence[pulumi.Input['MySqlMysqlUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
-        :param pulumi.Input['MySqlMysqlUserConfigMigrationArgs'] migration: Migrate data from existing server
-        :param pulumi.Input['MySqlMysqlUserConfigMysqlArgs'] mysql: mysql.conf configuration values
-        :param pulumi.Input[str] mysql_version: MySQL major version.
-        :param pulumi.Input['MySqlMysqlUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks
-        :param pulumi.Input['MySqlMysqlUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink
-        :param pulumi.Input[str] project_to_fork_from: Name of another project to fork a service from. This has effect only when a new service is being created.
-        :param pulumi.Input['MySqlMysqlUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
-        :param pulumi.Input[str] recovery_target_time: Recovery target time when forking a service. This has effect only when a new service is being created.
-        :param pulumi.Input[bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
-        :param pulumi.Input[str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created.
-        :param pulumi.Input[bool] static_ips: Use static public IP addresses.
+        MySQL connection parameters
         """
-        if additional_backup_regions is not None:
-            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
-        if admin_password is not None:
-            pulumi.set(__self__, "admin_password", admin_password)
-        if admin_username is not None:
-            pulumi.set(__self__, "admin_username", admin_username)
-        if backup_hour is not None:
-            pulumi.set(__self__, "backup_hour", backup_hour)
-        if backup_minute is not None:
-            pulumi.set(__self__, "backup_minute", backup_minute)
-        if binlog_retention_period is not None:
-            pulumi.set(__self__, "binlog_retention_period", binlog_retention_period)
-        if ip_filter_objects is not None:
-            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
-        if ip_filter_strings is not None:
-            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
-        if ip_filters is not None:
-            warnings.warn("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
-            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `ip_filter_string` instead.""")
-        if ip_filters is not None:
-            pulumi.set(__self__, "ip_filters", ip_filters)
-        if migration is not None:
-            pulumi.set(__self__, "migration", migration)
-        if mysql is not None:
-            pulumi.set(__self__, "mysql", mysql)
-        if mysql_version is not None:
-            pulumi.set(__self__, "mysql_version", mysql_version)
-        if private_access is not None:
-            pulumi.set(__self__, "private_access", private_access)
-        if privatelink_access is not None:
-            pulumi.set(__self__, "privatelink_access", privatelink_access)
-        if project_to_fork_from is not None:
-            pulumi.set(__self__, "project_to_fork_from", project_to_fork_from)
-        if public_access is not None:
-            pulumi.set(__self__, "public_access", public_access)
+        return pulumi.get(self, "params")
+
+    @params.setter
+    def params(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MySqlMysqlParamArgs']]]]):
+        pulumi.set(self, "params", value)
+
+    @property
+    @pulumi.getter(name="replicaUri")
+    def replica_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        MySQL replica URI for services with a replica
+        """
+        return pulumi.get(self, "replica_uri")
+
+    @replica_uri.setter
+    def replica_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "replica_uri", value)
+
+    @property
+    @pulumi.getter(name="standbyUris")
+    def standby_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        MySQL standby connection URIs
+        """
+        return pulumi.get(self, "standby_uris")
+
+    @standby_uris.setter
+    def standby_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "standby_uris", value)
+
+    @property
+    @pulumi.getter(name="syncingUris")
+    def syncing_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        MySQL syncing connection URIs
+        """
+        return pulumi.get(self, "syncing_uris")
+
+    @syncing_uris.setter
+    def syncing_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "syncing_uris", value)
+
+    @property
+    @pulumi.getter
+    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        MySQL master connection URIs
+        """
+        return pulumi.get(self, "uris")
+
+    @uris.setter
+    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "uris", value)
+
+
+@pulumi.input_type
+class MySqlMysqlParamArgs:
+    def __init__(__self__, *,
+                 database_name: Optional[pulumi.Input[str]] = None,
+                 host: Optional[pulumi.Input[str]] = None,
+                 password: Optional[pulumi.Input[str]] = None,
+                 port: Optional[pulumi.Input[int]] = None,
+                 sslmode: Optional[pulumi.Input[str]] = None,
+                 user: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] database_name: Primary MySQL database name
+        :param pulumi.Input[str] host: MySQL host IP or name
+        :param pulumi.Input[str] password: MySQL admin user password
+        :param pulumi.Input[int] port: MySQL port
+        :param pulumi.Input[str] sslmode: MySQL sslmode setting (currently always "require")
+        :param pulumi.Input[str] user: MySQL admin user name
+        """
+        if database_name is not None:
+            pulumi.set(__self__, "database_name", database_name)
+        if host is not None:
+            pulumi.set(__self__, "host", host)
+        if password is not None:
+            pulumi.set(__self__, "password", password)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if sslmode is not None:
+            pulumi.set(__self__, "sslmode", sslmode)
+        if user is not None:
+            pulumi.set(__self__, "user", user)
+
+    @property
+    @pulumi.getter(name="databaseName")
+    def database_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Primary MySQL database name
+        """
+        return pulumi.get(self, "database_name")
+
+    @database_name.setter
+    def database_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "database_name", value)
+
+    @property
+    @pulumi.getter
+    def host(self) -> Optional[pulumi.Input[str]]:
+        """
+        MySQL host IP or name
+        """
+        return pulumi.get(self, "host")
+
+    @host.setter
+    def host(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "host", value)
+
+    @property
+    @pulumi.getter
+    def password(self) -> Optional[pulumi.Input[str]]:
+        """
+        MySQL admin user password
+        """
+        return pulumi.get(self, "password")
+
+    @password.setter
+    def password(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "password", value)
+
+    @property
+    @pulumi.getter
+    def port(self) -> Optional[pulumi.Input[int]]:
+        """
+        MySQL port
+        """
+        return pulumi.get(self, "port")
+
+    @port.setter
+    def port(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "port", value)
+
+    @property
+    @pulumi.getter
+    def sslmode(self) -> Optional[pulumi.Input[str]]:
+        """
+        MySQL sslmode setting (currently always "require")
+        """
+        return pulumi.get(self, "sslmode")
+
+    @sslmode.setter
+    def sslmode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "sslmode", value)
+
+    @property
+    @pulumi.getter
+    def user(self) -> Optional[pulumi.Input[str]]:
+        """
+        MySQL admin user name
+        """
+        return pulumi.get(self, "user")
+
+    @user.setter
+    def user(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "user", value)
+
+
+@pulumi.input_type
+class MySqlMysqlUserConfigArgs:
+    def __init__(__self__, *,
+                 additional_backup_regions: Optional[pulumi.Input[str]] = None,
+                 admin_password: Optional[pulumi.Input[str]] = None,
+                 admin_username: Optional[pulumi.Input[str]] = None,
+                 backup_hour: Optional[pulumi.Input[int]] = None,
+                 backup_minute: Optional[pulumi.Input[int]] = None,
+                 binlog_retention_period: Optional[pulumi.Input[int]] = None,
+                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['MySqlMysqlUserConfigIpFilterObjectArgs']]]] = None,
+                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 migration: Optional[pulumi.Input['MySqlMysqlUserConfigMigrationArgs']] = None,
+                 mysql: Optional[pulumi.Input['MySqlMysqlUserConfigMysqlArgs']] = None,
+                 mysql_version: Optional[pulumi.Input[str]] = None,
+                 private_access: Optional[pulumi.Input['MySqlMysqlUserConfigPrivateAccessArgs']] = None,
+                 privatelink_access: Optional[pulumi.Input['MySqlMysqlUserConfigPrivatelinkAccessArgs']] = None,
+                 project_to_fork_from: Optional[pulumi.Input[str]] = None,
+                 public_access: Optional[pulumi.Input['MySqlMysqlUserConfigPublicAccessArgs']] = None,
+                 recovery_target_time: Optional[pulumi.Input[str]] = None,
+                 service_log: Optional[pulumi.Input[bool]] = None,
+                 service_to_fork_from: Optional[pulumi.Input[str]] = None,
+                 static_ips: Optional[pulumi.Input[bool]] = None):
+        """
+        :param pulumi.Input[str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
+        :param pulumi.Input[str] admin_password: Custom password for admin user. Defaults to random string. This must be set only when a new service is being created.
+        :param pulumi.Input[str] admin_username: Custom username for admin user. This must be set only when a new service is being created.
+        :param pulumi.Input[int] backup_hour: The hour of day (in UTC) when backup for the service is started. New backup is only started if previous backup has already completed.
+        :param pulumi.Input[int] backup_minute: The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.
+        :param pulumi.Input[int] binlog_retention_period: The minimum amount of time in seconds to keep binlog entries before deletion. This may be extended for services that require binlog entries for longer than the default for example if using the MySQL Debezium Kafka connector.
+        :param pulumi.Input[Sequence[pulumi.Input['MySqlMysqlUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
+        :param pulumi.Input['MySqlMysqlUserConfigMigrationArgs'] migration: Migrate data from existing server
+        :param pulumi.Input['MySqlMysqlUserConfigMysqlArgs'] mysql: mysql.conf configuration values
+        :param pulumi.Input[str] mysql_version: Enum: `8`. MySQL major version.
+        :param pulumi.Input['MySqlMysqlUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks
+        :param pulumi.Input['MySqlMysqlUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink
+        :param pulumi.Input[str] project_to_fork_from: Name of another project to fork a service from. This has effect only when a new service is being created.
+        :param pulumi.Input['MySqlMysqlUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
+        :param pulumi.Input[str] recovery_target_time: Recovery target time when forking a service. This has effect only when a new service is being created.
+        :param pulumi.Input[bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
+        :param pulumi.Input[str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created.
+        :param pulumi.Input[bool] static_ips: Use static public IP addresses.
+        """
+        if additional_backup_regions is not None:
+            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
+        if admin_password is not None:
+            pulumi.set(__self__, "admin_password", admin_password)
+        if admin_username is not None:
+            pulumi.set(__self__, "admin_username", admin_username)
+        if backup_hour is not None:
+            pulumi.set(__self__, "backup_hour", backup_hour)
+        if backup_minute is not None:
+            pulumi.set(__self__, "backup_minute", backup_minute)
+        if binlog_retention_period is not None:
+            pulumi.set(__self__, "binlog_retention_period", binlog_retention_period)
+        if ip_filter_objects is not None:
+            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
+        if ip_filter_strings is not None:
+            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
+        if ip_filters is not None:
+            warnings.warn("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
+            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `ip_filter_string` instead.""")
+        if ip_filters is not None:
+            pulumi.set(__self__, "ip_filters", ip_filters)
+        if migration is not None:
+            pulumi.set(__self__, "migration", migration)
+        if mysql is not None:
+            pulumi.set(__self__, "mysql", mysql)
+        if mysql_version is not None:
+            pulumi.set(__self__, "mysql_version", mysql_version)
+        if private_access is not None:
+            pulumi.set(__self__, "private_access", private_access)
+        if privatelink_access is not None:
+            pulumi.set(__self__, "privatelink_access", privatelink_access)
+        if project_to_fork_from is not None:
+            pulumi.set(__self__, "project_to_fork_from", project_to_fork_from)
+        if public_access is not None:
+            pulumi.set(__self__, "public_access", public_access)
         if recovery_target_time is not None:
             pulumi.set(__self__, "recovery_target_time", recovery_target_time)
         if service_log is not None:
@@ -12093,7 +12639,7 @@ class MySqlMysqlUserConfigArgs:
     @pulumi.getter(name="mysqlVersion")
     def mysql_version(self) -> Optional[pulumi.Input[str]]:
         """
-        MySQL major version.
+        Enum: `8`. MySQL major version.
         """
         return pulumi.get(self, "mysql_version")
 
@@ -12252,7 +12798,7 @@ class MySqlMysqlUserConfigMigrationArgs:
         :param pulumi.Input[int] port: Port number of the server where to migrate data from.
         :param pulumi.Input[str] dbname: Database name for bootstrapping the initial connection.
         :param pulumi.Input[str] ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment).
-        :param pulumi.Input[str] method: The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
+        :param pulumi.Input[str] method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         :param pulumi.Input[str] password: Password for authentication with the server where to migrate data from.
         :param pulumi.Input[bool] ssl: The server where to migrate data from is secured with SSL. The default value is `true`.
         :param pulumi.Input[str] username: User name for authentication with the server where to migrate data from.
@@ -12324,7 +12870,7 @@ class MySqlMysqlUserConfigMigrationArgs:
     @pulumi.getter
     def method(self) -> Optional[pulumi.Input[str]]:
         """
-        The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
+        Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         """
         return pulumi.get(self, "method")
 
@@ -12420,7 +12966,7 @@ class MySqlMysqlUserConfigMysqlArgs:
         :param pulumi.Input[int] innodb_thread_concurrency: Defines the maximum number of threads permitted inside of InnoDB. Default is 0 (infinite concurrency - no limit).
         :param pulumi.Input[int] innodb_write_io_threads: The number of I/O threads for write operations in InnoDB. Default is 4. Changing this parameter will lead to a restart of the MySQL service.
         :param pulumi.Input[int] interactive_timeout: The number of seconds the server waits for activity on an interactive connection before closing it.
-        :param pulumi.Input[str] internal_tmp_mem_storage_engine: The storage engine for in-memory internal temporary tables.
+        :param pulumi.Input[str] internal_tmp_mem_storage_engine: Enum: `TempTable`, `MEMORY`. The storage engine for in-memory internal temporary tables.
         :param pulumi.Input[float] long_query_time: The slow*query*logs work as SQL statements that take more than long*query*time seconds to execute. Default is 10s.
         :param pulumi.Input[int] max_allowed_packet: Size of the largest message in bytes that can be received by the server. Default is 67108864 (64M).
         :param pulumi.Input[int] max_heap_table_size: Limits the size of internal in-memory tables. Also set tmp*table*size. Default is 16777216 (16M).
@@ -12703,7 +13249,7 @@ class MySqlMysqlUserConfigMysqlArgs:
     @pulumi.getter(name="internalTmpMemStorageEngine")
     def internal_tmp_mem_storage_engine(self) -> Optional[pulumi.Input[str]]:
         """
-        The storage engine for in-memory internal temporary tables.
+        Enum: `TempTable`, `MEMORY`. The storage engine for in-memory internal temporary tables.
         """
         return pulumi.get(self, "internal_tmp_mem_storage_engine")
 
@@ -13255,12 +13801,40 @@ class OpenSearchComponentArgs:
 @pulumi.input_type
 class OpenSearchOpensearchArgs:
     def __init__(__self__, *,
-                 opensearch_dashboards_uri: Optional[pulumi.Input[str]] = None):
+                 kibana_uri: Optional[pulumi.Input[str]] = None,
+                 opensearch_dashboards_uri: Optional[pulumi.Input[str]] = None,
+                 password: Optional[pulumi.Input[str]] = None,
+                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 username: Optional[pulumi.Input[str]] = None):
         """
+        :param pulumi.Input[str] kibana_uri: URI for Kibana dashboard frontend
         :param pulumi.Input[str] opensearch_dashboards_uri: URI for OpenSearch dashboard frontend
+        :param pulumi.Input[str] password: OpenSearch password
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] uris: OpenSearch server URIs.
+        :param pulumi.Input[str] username: OpenSearch username
         """
+        if kibana_uri is not None:
+            pulumi.set(__self__, "kibana_uri", kibana_uri)
         if opensearch_dashboards_uri is not None:
             pulumi.set(__self__, "opensearch_dashboards_uri", opensearch_dashboards_uri)
+        if password is not None:
+            pulumi.set(__self__, "password", password)
+        if uris is not None:
+            pulumi.set(__self__, "uris", uris)
+        if username is not None:
+            pulumi.set(__self__, "username", username)
+
+    @property
+    @pulumi.getter(name="kibanaUri")
+    def kibana_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        URI for Kibana dashboard frontend
+        """
+        return pulumi.get(self, "kibana_uri")
+
+    @kibana_uri.setter
+    def kibana_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "kibana_uri", value)
 
     @property
     @pulumi.getter(name="opensearchDashboardsUri")
@@ -13274,6 +13848,42 @@ class OpenSearchOpensearchArgs:
     def opensearch_dashboards_uri(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "opensearch_dashboards_uri", value)
 
+    @property
+    @pulumi.getter
+    def password(self) -> Optional[pulumi.Input[str]]:
+        """
+        OpenSearch password
+        """
+        return pulumi.get(self, "password")
+
+    @password.setter
+    def password(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "password", value)
+
+    @property
+    @pulumi.getter
+    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        OpenSearch server URIs.
+        """
+        return pulumi.get(self, "uris")
+
+    @uris.setter
+    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "uris", value)
+
+    @property
+    @pulumi.getter
+    def username(self) -> Optional[pulumi.Input[str]]:
+        """
+        OpenSearch username
+        """
+        return pulumi.get(self, "username")
+
+    @username.setter
+    def username(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "username", value)
+
 
 @pulumi.input_type
 class OpenSearchOpensearchUserConfigArgs:
@@ -13315,7 +13925,7 @@ class OpenSearchOpensearchUserConfigArgs:
         :param pulumi.Input['OpenSearchOpensearchUserConfigOpenidArgs'] openid: OpenSearch OpenID Connect Configuration
         :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchArgs'] opensearch: OpenSearch settings
         :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchDashboardsArgs'] opensearch_dashboards: OpenSearch Dashboards settings
-        :param pulumi.Input[str] opensearch_version: OpenSearch major version.
+        :param pulumi.Input[str] opensearch_version: Enum: `1`, `2`. OpenSearch major version.
         :param pulumi.Input['OpenSearchOpensearchUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks
         :param pulumi.Input['OpenSearchOpensearchUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink
         :param pulumi.Input[str] project_to_fork_from: Name of another project to fork a service from. This has effect only when a new service is being created.
@@ -13539,7 +14149,7 @@ class OpenSearchOpensearchUserConfigArgs:
     @pulumi.getter(name="opensearchVersion")
     def opensearch_version(self) -> Optional[pulumi.Input[str]]:
         """
-        OpenSearch major version.
+        Enum: `1`, `2`. OpenSearch major version.
         """
         return pulumi.get(self, "opensearch_version")
 
@@ -13665,7 +14275,7 @@ class OpenSearchOpensearchUserConfigIndexPatternArgs:
         """
         :param pulumi.Input[int] max_index_count: Maximum number of indexes to keep.
         :param pulumi.Input[str] pattern: fnmatch pattern.
-        :param pulumi.Input[str] sorting_algorithm: Deletion sorting algorithm. The default value is `creation_date`.
+        :param pulumi.Input[str] sorting_algorithm: Enum: `alphabetical`, `creation_date`. Deletion sorting algorithm. The default value is `creation_date`.
         """
         pulumi.set(__self__, "max_index_count", max_index_count)
         pulumi.set(__self__, "pattern", pattern)
@@ -13700,7 +14310,7 @@ class OpenSearchOpensearchUserConfigIndexPatternArgs:
     @pulumi.getter(name="sortingAlgorithm")
     def sorting_algorithm(self) -> Optional[pulumi.Input[str]]:
         """
-        Deletion sorting algorithm. The default value is `creation_date`.
+        Enum: `alphabetical`, `creation_date`. Deletion sorting algorithm. The default value is `creation_date`.
         """
         return pulumi.get(self, "sorting_algorithm")
 
@@ -14723,12 +15333,12 @@ class OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersInternalAuthen
                  type: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[int] allowed_tries: The number of login attempts allowed before login is blocked.
-        :param pulumi.Input[str] authentication_backend: internal*authentication*backend*limiting.authentication*backend.
+        :param pulumi.Input[str] authentication_backend: Enum: `internal`. internal*authentication*backend*limiting.authentication*backend.
         :param pulumi.Input[int] block_expiry_seconds: The duration of time that login remains blocked after a failed login.
         :param pulumi.Input[int] max_blocked_clients: internal*authentication*backend*limiting.max*blocked_clients.
         :param pulumi.Input[int] max_tracked_clients: The maximum number of tracked IP addresses that have failed login.
         :param pulumi.Input[int] time_window_seconds: The window of time in which the value for `allowed_tries` is enforced.
-        :param pulumi.Input[str] type: internal*authentication*backend_limiting.type.
+        :param pulumi.Input[str] type: Enum: `username`. internal*authentication*backend_limiting.type.
         """
         if allowed_tries is not None:
             pulumi.set(__self__, "allowed_tries", allowed_tries)
@@ -14761,7 +15371,7 @@ class OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersInternalAuthen
     @pulumi.getter(name="authenticationBackend")
     def authentication_backend(self) -> Optional[pulumi.Input[str]]:
         """
-        internal*authentication*backend*limiting.authentication*backend.
+        Enum: `internal`. internal*authentication*backend*limiting.authentication*backend.
         """
         return pulumi.get(self, "authentication_backend")
 
@@ -14821,7 +15431,7 @@ class OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersInternalAuthen
     @pulumi.getter
     def type(self) -> Optional[pulumi.Input[str]]:
         """
-        internal*authentication*backend_limiting.type.
+        Enum: `username`. internal*authentication*backend_limiting.type.
         """
         return pulumi.get(self, "type")
 
@@ -14845,7 +15455,7 @@ class OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersIpRateLimiting
         :param pulumi.Input[int] max_blocked_clients: The maximum number of blocked IP addresses.
         :param pulumi.Input[int] max_tracked_clients: The maximum number of tracked IP addresses that have failed login.
         :param pulumi.Input[int] time_window_seconds: The window of time in which the value for `allowed_tries` is enforced.
-        :param pulumi.Input[str] type: The type of rate limiting.
+        :param pulumi.Input[str] type: Enum: `ip`. The type of rate limiting.
         """
         if allowed_tries is not None:
             pulumi.set(__self__, "allowed_tries", allowed_tries)
@@ -14924,7 +15534,7 @@ class OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersIpRateLimiting
     @pulumi.getter
     def type(self) -> Optional[pulumi.Input[str]]:
         """
-        The type of rate limiting.
+        Enum: `ip`. The type of rate limiting.
         """
         return pulumi.get(self, "type")
 
@@ -15857,32 +16467,46 @@ class PgComponentArgs:
 @pulumi.input_type
 class PgPgArgs:
     def __init__(__self__, *,
+                 bouncer: Optional[pulumi.Input[str]] = None,
                  dbname: Optional[pulumi.Input[str]] = None,
                  host: Optional[pulumi.Input[str]] = None,
                  max_connections: Optional[pulumi.Input[int]] = None,
+                 params: Optional[pulumi.Input[Sequence[pulumi.Input['PgPgParamArgs']]]] = None,
                  password: Optional[pulumi.Input[str]] = None,
                  port: Optional[pulumi.Input[int]] = None,
                  replica_uri: Optional[pulumi.Input[str]] = None,
                  sslmode: Optional[pulumi.Input[str]] = None,
+                 standby_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 syncing_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  uri: Optional[pulumi.Input[str]] = None,
+                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  user: Optional[pulumi.Input[str]] = None):
         """
+        :param pulumi.Input[str] bouncer: Bouncer connection details
         :param pulumi.Input[str] dbname: Primary PostgreSQL database name
         :param pulumi.Input[str] host: PostgreSQL master node host IP or name
         :param pulumi.Input[int] max_connections: Connection limit
+        :param pulumi.Input[Sequence[pulumi.Input['PgPgParamArgs']]] params: PostgreSQL connection parameters
         :param pulumi.Input[str] password: PostgreSQL admin user password
         :param pulumi.Input[int] port: PostgreSQL port
         :param pulumi.Input[str] replica_uri: PostgreSQL replica URI for services with a replica
         :param pulumi.Input[str] sslmode: PostgreSQL sslmode setting (currently always "require")
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] standby_uris: PostgreSQL standby connection URIs
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] syncing_uris: PostgreSQL syncing connection URIs
         :param pulumi.Input[str] uri: PostgreSQL master connection URI
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] uris: PostgreSQL master connection URIs
         :param pulumi.Input[str] user: PostgreSQL admin user name
         """
+        if bouncer is not None:
+            pulumi.set(__self__, "bouncer", bouncer)
         if dbname is not None:
             pulumi.set(__self__, "dbname", dbname)
         if host is not None:
             pulumi.set(__self__, "host", host)
         if max_connections is not None:
             pulumi.set(__self__, "max_connections", max_connections)
+        if params is not None:
+            pulumi.set(__self__, "params", params)
         if password is not None:
             pulumi.set(__self__, "password", password)
         if port is not None:
@@ -15891,11 +16515,29 @@ class PgPgArgs:
             pulumi.set(__self__, "replica_uri", replica_uri)
         if sslmode is not None:
             pulumi.set(__self__, "sslmode", sslmode)
+        if standby_uris is not None:
+            pulumi.set(__self__, "standby_uris", standby_uris)
+        if syncing_uris is not None:
+            pulumi.set(__self__, "syncing_uris", syncing_uris)
         if uri is not None:
             pulumi.set(__self__, "uri", uri)
+        if uris is not None:
+            pulumi.set(__self__, "uris", uris)
         if user is not None:
             pulumi.set(__self__, "user", user)
 
+    @property
+    @pulumi.getter
+    def bouncer(self) -> Optional[pulumi.Input[str]]:
+        """
+        Bouncer connection details
+        """
+        return pulumi.get(self, "bouncer")
+
+    @bouncer.setter
+    def bouncer(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "bouncer", value)
+
     @property
     @pulumi.getter
     def dbname(self) -> Optional[pulumi.Input[str]]:
@@ -15932,6 +16574,18 @@ class PgPgArgs:
     def max_connections(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "max_connections", value)
 
+    @property
+    @pulumi.getter
+    def params(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PgPgParamArgs']]]]:
+        """
+        PostgreSQL connection parameters
+        """
+        return pulumi.get(self, "params")
+
+    @params.setter
+    def params(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PgPgParamArgs']]]]):
+        pulumi.set(self, "params", value)
+
     @property
     @pulumi.getter
     def password(self) -> Optional[pulumi.Input[str]]:
@@ -15980,6 +16634,30 @@ class PgPgArgs:
     def sslmode(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "sslmode", value)
 
+    @property
+    @pulumi.getter(name="standbyUris")
+    def standby_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        PostgreSQL standby connection URIs
+        """
+        return pulumi.get(self, "standby_uris")
+
+    @standby_uris.setter
+    def standby_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "standby_uris", value)
+
+    @property
+    @pulumi.getter(name="syncingUris")
+    def syncing_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        PostgreSQL syncing connection URIs
+        """
+        return pulumi.get(self, "syncing_uris")
+
+    @syncing_uris.setter
+    def syncing_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "syncing_uris", value)
+
     @property
     @pulumi.getter
     def uri(self) -> Optional[pulumi.Input[str]]:
@@ -15992,6 +16670,121 @@ class PgPgArgs:
     def uri(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "uri", value)
 
+    @property
+    @pulumi.getter
+    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        PostgreSQL master connection URIs
+        """
+        return pulumi.get(self, "uris")
+
+    @uris.setter
+    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "uris", value)
+
+    @property
+    @pulumi.getter
+    def user(self) -> Optional[pulumi.Input[str]]:
+        """
+        PostgreSQL admin user name
+        """
+        return pulumi.get(self, "user")
+
+    @user.setter
+    def user(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "user", value)
+
+
+@pulumi.input_type
+class PgPgParamArgs:
+    def __init__(__self__, *,
+                 database_name: Optional[pulumi.Input[str]] = None,
+                 host: Optional[pulumi.Input[str]] = None,
+                 password: Optional[pulumi.Input[str]] = None,
+                 port: Optional[pulumi.Input[int]] = None,
+                 sslmode: Optional[pulumi.Input[str]] = None,
+                 user: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] database_name: Primary PostgreSQL database name
+        :param pulumi.Input[str] host: PostgreSQL host IP or name
+        :param pulumi.Input[str] password: PostgreSQL admin user password
+        :param pulumi.Input[int] port: PostgreSQL port
+        :param pulumi.Input[str] sslmode: PostgreSQL sslmode setting (currently always "require")
+        :param pulumi.Input[str] user: PostgreSQL admin user name
+        """
+        if database_name is not None:
+            pulumi.set(__self__, "database_name", database_name)
+        if host is not None:
+            pulumi.set(__self__, "host", host)
+        if password is not None:
+            pulumi.set(__self__, "password", password)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if sslmode is not None:
+            pulumi.set(__self__, "sslmode", sslmode)
+        if user is not None:
+            pulumi.set(__self__, "user", user)
+
+    @property
+    @pulumi.getter(name="databaseName")
+    def database_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Primary PostgreSQL database name
+        """
+        return pulumi.get(self, "database_name")
+
+    @database_name.setter
+    def database_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "database_name", value)
+
+    @property
+    @pulumi.getter
+    def host(self) -> Optional[pulumi.Input[str]]:
+        """
+        PostgreSQL host IP or name
+        """
+        return pulumi.get(self, "host")
+
+    @host.setter
+    def host(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "host", value)
+
+    @property
+    @pulumi.getter
+    def password(self) -> Optional[pulumi.Input[str]]:
+        """
+        PostgreSQL admin user password
+        """
+        return pulumi.get(self, "password")
+
+    @password.setter
+    def password(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "password", value)
+
+    @property
+    @pulumi.getter
+    def port(self) -> Optional[pulumi.Input[int]]:
+        """
+        PostgreSQL port
+        """
+        return pulumi.get(self, "port")
+
+    @port.setter
+    def port(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "port", value)
+
+    @property
+    @pulumi.getter
+    def sslmode(self) -> Optional[pulumi.Input[str]]:
+        """
+        PostgreSQL sslmode setting (currently always "require")
+        """
+        return pulumi.get(self, "sslmode")
+
+    @sslmode.setter
+    def sslmode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "sslmode", value)
+
     @property
     @pulumi.getter
     def user(self) -> Optional[pulumi.Input[str]]:
@@ -16056,7 +16849,7 @@ class PgPgUserConfigArgs:
         :param pulumi.Input[bool] pg_read_replica: Should the service which is being forked be a read replica (deprecated, use read_replica service integration instead).
         :param pulumi.Input[str] pg_service_to_fork_from: Name of the PG Service from which to fork (deprecated, use service*to*fork_from). This has effect only when a new service is being created.
         :param pulumi.Input[bool] pg_stat_monitor_enable: Enable the pg*stat*monitor extension. Enabling this extension will cause the cluster to be restarted.When this extension is enabled, pg*stat*statements results for utility commands are unreliable. The default value is `false`.
-        :param pulumi.Input[str] pg_version: PostgreSQL major version.
+        :param pulumi.Input[str] pg_version: Enum: `10`, `11`, `12`, `13`, `14`, `15`, `16`. PostgreSQL major version.
         :param pulumi.Input['PgPgUserConfigPgauditArgs'] pgaudit: System-wide settings for the pgaudit extension
         :param pulumi.Input['PgPgUserConfigPgbouncerArgs'] pgbouncer: PGBouncer connection pooling settings
         :param pulumi.Input['PgPgUserConfigPglookoutArgs'] pglookout: System-wide settings for pglookout
@@ -16069,9 +16862,9 @@ class PgPgUserConfigArgs:
         :param pulumi.Input[str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created.
         :param pulumi.Input[float] shared_buffers_percentage: Percentage of total RAM that the database server uses for shared memory buffers. Valid range is 20-60 (float), which corresponds to 20% - 60%. This setting adjusts the shared_buffers configuration value.
         :param pulumi.Input[bool] static_ips: Use static public IP addresses.
-        :param pulumi.Input[str] synchronous_replication: Synchronous replication type. Note that the service plan also needs to support synchronous replication.
+        :param pulumi.Input[str] synchronous_replication: Enum: `quorum`, `off`. Synchronous replication type. Note that the service plan also needs to support synchronous replication.
         :param pulumi.Input['PgPgUserConfigTimescaledbArgs'] timescaledb: System-wide settings for the timescaledb extension
-        :param pulumi.Input[str] variant: Variant of the PostgreSQL service, may affect the features that are exposed by default.
+        :param pulumi.Input[str] variant: Enum: `aiven`, `timescale`. Variant of the PostgreSQL service, may affect the features that are exposed by default.
         :param pulumi.Input[int] work_mem: Sets the maximum amount of memory to be used by a query operation (such as a sort or hash table) before writing to temporary disk files, in MB. Default is 1MB + 0.075% of total RAM (up to 32MB).
         """
         if additional_backup_regions is not None:
@@ -16335,7 +17128,7 @@ class PgPgUserConfigArgs:
     @pulumi.getter(name="pgVersion")
     def pg_version(self) -> Optional[pulumi.Input[str]]:
         """
-        PostgreSQL major version.
+        Enum: `10`, `11`, `12`, `13`, `14`, `15`, `16`. PostgreSQL major version.
         """
         return pulumi.get(self, "pg_version")
 
@@ -16491,7 +17284,7 @@ class PgPgUserConfigArgs:
     @pulumi.getter(name="synchronousReplication")
     def synchronous_replication(self) -> Optional[pulumi.Input[str]]:
         """
-        Synchronous replication type. Note that the service plan also needs to support synchronous replication.
+        Enum: `quorum`, `off`. Synchronous replication type. Note that the service plan also needs to support synchronous replication.
         """
         return pulumi.get(self, "synchronous_replication")
 
@@ -16515,7 +17308,7 @@ class PgPgUserConfigArgs:
     @pulumi.getter
     def variant(self) -> Optional[pulumi.Input[str]]:
         """
-        Variant of the PostgreSQL service, may affect the features that are exposed by default.
+        Enum: `aiven`, `timescale`. Variant of the PostgreSQL service, may affect the features that are exposed by default.
         """
         return pulumi.get(self, "variant")
 
@@ -16590,7 +17383,7 @@ class PgPgUserConfigMigrationArgs:
         :param pulumi.Input[int] port: Port number of the server where to migrate data from.
         :param pulumi.Input[str] dbname: Database name for bootstrapping the initial connection.
         :param pulumi.Input[str] ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment).
-        :param pulumi.Input[str] method: The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
+        :param pulumi.Input[str] method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         :param pulumi.Input[str] password: Password for authentication with the server where to migrate data from.
         :param pulumi.Input[bool] ssl: The server where to migrate data from is secured with SSL. The default value is `true`.
         :param pulumi.Input[str] username: User name for authentication with the server where to migrate data from.
@@ -16662,7 +17455,7 @@ class PgPgUserConfigMigrationArgs:
     @pulumi.getter
     def method(self) -> Optional[pulumi.Input[str]]:
         """
-        The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
+        Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         """
         return pulumi.get(self, "method")
 
@@ -16774,12 +17567,12 @@ class PgPgUserConfigPgArgs:
         :param pulumi.Input[int] bgwriter_lru_maxpages: In each round, no more than this many buffers will be written by the background writer. Setting this to zero disables background writing. Default is 100.
         :param pulumi.Input[float] bgwriter_lru_multiplier: The average recent need for new buffers is multiplied by bgwriter*lru*multiplier to arrive at an estimate of the number that will be needed during the next round, (up to bgwriter*lru*maxpages). 1.0 represents a “just in time” policy of writing exactly the number of buffers predicted to be needed. Larger values provide some cushion against spikes in demand, while smaller values intentionally leave writes to be done by server processes. The default is 2.0.
         :param pulumi.Input[int] deadlock_timeout: This is the amount of time, in milliseconds, to wait on a lock before checking to see if there is a deadlock condition.
-        :param pulumi.Input[str] default_toast_compression: Specifies the default TOAST compression method for values of compressible columns (the default is lz4).
+        :param pulumi.Input[str] default_toast_compression: Enum: `lz4`, `pglz`. Specifies the default TOAST compression method for values of compressible columns (the default is lz4).
         :param pulumi.Input[int] idle_in_transaction_session_timeout: Time out sessions with open transactions after this number of milliseconds.
         :param pulumi.Input[bool] jit: Controls system-wide use of Just-in-Time Compilation (JIT).
         :param pulumi.Input[int] log_autovacuum_min_duration: Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one (the default) disables logging autovacuum actions.
-        :param pulumi.Input[str] log_error_verbosity: Controls the amount of detail written in the server log for each message that is logged.
-        :param pulumi.Input[str] log_line_prefix: Choose from one of the available log-formats. These can support popular log analyzers like pgbadger, pganalyze etc.
+        :param pulumi.Input[str] log_error_verbosity: Enum: `TERSE`, `DEFAULT`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
+        :param pulumi.Input[str] log_line_prefix: Enum: `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'%m [%p] %q[user=%u,db=%d,app=%a] '`. Choose from one of the available log-formats. These can support popular log analyzers like pgbadger, pganalyze etc.
         :param pulumi.Input[int] log_min_duration_statement: Log statements that take more than this number of milliseconds to run, -1 disables.
         :param pulumi.Input[int] log_temp_files: Log statements for each temporary file created larger than this number of kilobytes, -1 disables.
         :param pulumi.Input[int] max_files_per_process: PostgreSQL maximum number of files that can be open per process.
@@ -16800,13 +17593,13 @@ class PgPgUserConfigPgArgs:
         :param pulumi.Input[str] pg_partman_bgw_dot_role: Controls which role to use for pg_partman's scheduled background tasks.
         :param pulumi.Input[bool] pg_stat_monitor_dot_pgsm_enable_query_plan: Enables or disables query plan monitoring.
         :param pulumi.Input[int] pg_stat_monitor_dot_pgsm_max_buckets: Sets the maximum number of buckets.
-        :param pulumi.Input[str] pg_stat_statements_dot_track: Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default value is top.
+        :param pulumi.Input[str] pg_stat_statements_dot_track: Enum: `all`, `top`, `none`. Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default value is top.
         :param pulumi.Input[int] temp_file_limit: PostgreSQL temporary file limit in KiB, -1 for unlimited.
         :param pulumi.Input[str] timezone: PostgreSQL service timezone.
         :param pulumi.Input[int] track_activity_query_size: Specifies the number of bytes reserved to track the currently executing command for each active session.
-        :param pulumi.Input[str] track_commit_timestamp: Record commit time of transactions.
-        :param pulumi.Input[str] track_functions: Enables tracking of function call counts and time used.
-        :param pulumi.Input[str] track_io_timing: Enables timing of database I/O calls. This parameter is off by default, because it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms.
+        :param pulumi.Input[str] track_commit_timestamp: Enum: `off`, `on`. Record commit time of transactions.
+        :param pulumi.Input[str] track_functions: Enum: `all`, `pl`, `none`. Enables tracking of function call counts and time used.
+        :param pulumi.Input[str] track_io_timing: Enum: `off`, `on`. Enables timing of database I/O calls. This parameter is off by default, because it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms.
         :param pulumi.Input[int] wal_sender_timeout: Terminate replication connections that are inactive for longer than this amount of time, in milliseconds. Setting this value to zero disables the timeout.
         :param pulumi.Input[int] wal_writer_delay: WAL flush interval in milliseconds. Note that setting this value to lower than the default 200ms may negatively impact performance.
         """
@@ -17081,7 +17874,7 @@ class PgPgUserConfigPgArgs:
     @pulumi.getter(name="defaultToastCompression")
     def default_toast_compression(self) -> Optional[pulumi.Input[str]]:
         """
-        Specifies the default TOAST compression method for values of compressible columns (the default is lz4).
+        Enum: `lz4`, `pglz`. Specifies the default TOAST compression method for values of compressible columns (the default is lz4).
         """
         return pulumi.get(self, "default_toast_compression")
 
@@ -17129,7 +17922,7 @@ class PgPgUserConfigPgArgs:
     @pulumi.getter(name="logErrorVerbosity")
     def log_error_verbosity(self) -> Optional[pulumi.Input[str]]:
         """
-        Controls the amount of detail written in the server log for each message that is logged.
+        Enum: `TERSE`, `DEFAULT`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
         """
         return pulumi.get(self, "log_error_verbosity")
 
@@ -17141,7 +17934,7 @@ class PgPgUserConfigPgArgs:
     @pulumi.getter(name="logLinePrefix")
     def log_line_prefix(self) -> Optional[pulumi.Input[str]]:
         """
-        Choose from one of the available log-formats. These can support popular log analyzers like pgbadger, pganalyze etc.
+        Enum: `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'%m [%p] %q[user=%u,db=%d,app=%a] '`. Choose from one of the available log-formats. These can support popular log analyzers like pgbadger, pganalyze etc.
         """
         return pulumi.get(self, "log_line_prefix")
 
@@ -17393,7 +18186,7 @@ class PgPgUserConfigPgArgs:
     @pulumi.getter(name="pgStatStatementsDotTrack")
     def pg_stat_statements_dot_track(self) -> Optional[pulumi.Input[str]]:
         """
-        Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default value is top.
+        Enum: `all`, `top`, `none`. Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default value is top.
         """
         return pulumi.get(self, "pg_stat_statements_dot_track")
 
@@ -17441,7 +18234,7 @@ class PgPgUserConfigPgArgs:
     @pulumi.getter(name="trackCommitTimestamp")
     def track_commit_timestamp(self) -> Optional[pulumi.Input[str]]:
         """
-        Record commit time of transactions.
+        Enum: `off`, `on`. Record commit time of transactions.
         """
         return pulumi.get(self, "track_commit_timestamp")
 
@@ -17453,7 +18246,7 @@ class PgPgUserConfigPgArgs:
     @pulumi.getter(name="trackFunctions")
     def track_functions(self) -> Optional[pulumi.Input[str]]:
         """
-        Enables tracking of function call counts and time used.
+        Enum: `all`, `pl`, `none`. Enables tracking of function call counts and time used.
         """
         return pulumi.get(self, "track_functions")
 
@@ -17465,7 +18258,7 @@ class PgPgUserConfigPgArgs:
     @pulumi.getter(name="trackIoTiming")
     def track_io_timing(self) -> Optional[pulumi.Input[str]]:
         """
-        Enables timing of database I/O calls. This parameter is off by default, because it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms.
+        Enum: `off`, `on`. Enables timing of database I/O calls. This parameter is off by default, because it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms.
         """
         return pulumi.get(self, "track_io_timing")
 
@@ -17636,7 +18429,7 @@ class PgPgUserConfigPgauditArgs:
         :param pulumi.Input[bool] feature_enabled: Enable pgaudit extension. When enabled, pgaudit extension will be automatically installed.Otherwise, extension will be uninstalled but auditing configurations will be preserved. The default value is `false`.
         :param pulumi.Input[bool] log_catalog: Specifies that session logging should be enabled in the casewhere all relations in a statement are in pg_catalog. The default value is `true`.
         :param pulumi.Input[bool] log_client: Specifies whether log messages will be visible to a client process such as psql. The default value is `false`.
-        :param pulumi.Input[str] log_level: Specifies the log level that will be used for log entries. The default value is `log`.
+        :param pulumi.Input[str] log_level: Enum: `debug1`, `debug2`, `debug3`, `debug4`, `debug5`, `info`, `notice`, `warning`, `log`. Specifies the log level that will be used for log entries. The default value is `log`.
         :param pulumi.Input[int] log_max_string_length: Crop parameters representation and whole statements if they exceed this threshold. A (default) value of -1 disable the truncation. The default value is `-1`.
         :param pulumi.Input[bool] log_nested_statements: This GUC allows to turn off logging nested statements, that is, statements that are executed as part of another ExecutorRun. The default value is `true`.
         :param pulumi.Input[bool] log_parameter: Specifies that audit logging should include the parameters that were passed with the statement. The default value is `false`.
@@ -17717,7 +18510,7 @@ class PgPgUserConfigPgauditArgs:
     @pulumi.getter(name="logLevel")
     def log_level(self) -> Optional[pulumi.Input[str]]:
         """
-        Specifies the log level that will be used for log entries. The default value is `log`.
+        Enum: `debug1`, `debug2`, `debug3`, `debug4`, `debug5`, `info`, `notice`, `warning`, `log`. Specifies the log level that will be used for log entries. The default value is `log`.
         """
         return pulumi.get(self, "log_level")
 
@@ -17861,7 +18654,7 @@ class PgPgUserConfigPgbouncerArgs:
         """
         :param pulumi.Input[int] autodb_idle_timeout: If the automatically created database pools have been unused this many seconds, they are freed. If 0 then timeout is disabled. (seconds). The default value is `3600`.
         :param pulumi.Input[int] autodb_max_db_connections: Do not allow more than this many server connections per database (regardless of user). Setting it to 0 means unlimited.
-        :param pulumi.Input[str] autodb_pool_mode: PGBouncer pool mode. The default value is `transaction`.
+        :param pulumi.Input[str] autodb_pool_mode: Enum: `session`, `transaction`, `statement`. PGBouncer pool mode. The default value is `transaction`.
         :param pulumi.Input[int] autodb_pool_size: If non-zero then create automatically a pool of that size per user when a pool doesn't exist. The default value is `0`.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] ignore_startup_parameters: List of parameters to ignore when given in startup packet.
         :param pulumi.Input[int] min_pool_size: Add more server connections to pool if below this number. Improves behavior when usual load comes suddenly back after period of total inactivity. The value is effectively capped at the pool size. The default value is `0`.
@@ -17916,7 +18709,7 @@ class PgPgUserConfigPgbouncerArgs:
     @pulumi.getter(name="autodbPoolMode")
     def autodb_pool_mode(self) -> Optional[pulumi.Input[str]]:
         """
-        PGBouncer pool mode. The default value is `transaction`.
+        Enum: `session`, `transaction`, `statement`. PGBouncer pool mode. The default value is `transaction`.
         """
         return pulumi.get(self, "autodb_pool_mode")
 
@@ -18476,6 +19269,77 @@ class RedisComponentArgs:
         pulumi.set(self, "usage", value)
 
 
+@pulumi.input_type
+class RedisRedisArgs:
+    def __init__(__self__, *,
+                 password: Optional[pulumi.Input[str]] = None,
+                 replica_uri: Optional[pulumi.Input[str]] = None,
+                 slave_uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[str] password: Redis password.
+        :param pulumi.Input[str] replica_uri: Redis replica server URI.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] slave_uris: Redis slave server URIs.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] uris: Redis server URIs.
+        """
+        if password is not None:
+            pulumi.set(__self__, "password", password)
+        if replica_uri is not None:
+            pulumi.set(__self__, "replica_uri", replica_uri)
+        if slave_uris is not None:
+            pulumi.set(__self__, "slave_uris", slave_uris)
+        if uris is not None:
+            pulumi.set(__self__, "uris", uris)
+
+    @property
+    @pulumi.getter
+    def password(self) -> Optional[pulumi.Input[str]]:
+        """
+        Redis password.
+        """
+        return pulumi.get(self, "password")
+
+    @password.setter
+    def password(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "password", value)
+
+    @property
+    @pulumi.getter(name="replicaUri")
+    def replica_uri(self) -> Optional[pulumi.Input[str]]:
+        """
+        Redis replica server URI.
+        """
+        return pulumi.get(self, "replica_uri")
+
+    @replica_uri.setter
+    def replica_uri(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "replica_uri", value)
+
+    @property
+    @pulumi.getter(name="slaveUris")
+    def slave_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Redis slave server URIs.
+        """
+        return pulumi.get(self, "slave_uris")
+
+    @slave_uris.setter
+    def slave_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "slave_uris", value)
+
+    @property
+    @pulumi.getter
+    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Redis server URIs.
+        """
+        return pulumi.get(self, "uris")
+
+    @uris.setter
+    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "uris", value)
+
+
 @pulumi.input_type
 class RedisRedisUserConfigArgs:
     def __init__(__self__, *,
@@ -18515,18 +19379,18 @@ class RedisRedisUserConfigArgs:
         :param pulumi.Input[str] project_to_fork_from: Name of another project to fork a service from. This has effect only when a new service is being created.
         :param pulumi.Input['RedisRedisUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
         :param pulumi.Input[str] recovery_basebackup_name: Name of the basebackup to restore in forked service.
-        :param pulumi.Input[str] redis_acl_channels_default: Determines default pub/sub channels' ACL for new users if ACL is not supplied. When this option is not defined, all_channels is assumed to keep backward compatibility. This option doesn't affect Redis configuration acl-pubsub-default.
+        :param pulumi.Input[str] redis_acl_channels_default: Enum: `allchannels`, `resetchannels`. Determines default pub/sub channels' ACL for new users if ACL is not supplied. When this option is not defined, all_channels is assumed to keep backward compatibility. This option doesn't affect Redis configuration acl-pubsub-default.
         :param pulumi.Input[int] redis_io_threads: Set Redis IO thread count. Changing this will cause a restart of the Redis service.
         :param pulumi.Input[int] redis_lfu_decay_time: LFU maxmemory-policy counter decay time in minutes. The default value is `1`.
         :param pulumi.Input[int] redis_lfu_log_factor: Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies. The default value is `10`.
-        :param pulumi.Input[str] redis_maxmemory_policy: Redis maxmemory-policy. The default value is `noeviction`.
+        :param pulumi.Input[str] redis_maxmemory_policy: Enum: `noeviction`, `allkeys-lru`, `volatile-lru`, `allkeys-random`, `volatile-random`, `volatile-ttl`, `volatile-lfu`, `allkeys-lfu`. Redis maxmemory-policy. The default value is `noeviction`.
         :param pulumi.Input[str] redis_notify_keyspace_events: Set notify-keyspace-events option.
         :param pulumi.Input[int] redis_number_of_databases: Set number of Redis databases. Changing this will cause a restart of the Redis service.
-        :param pulumi.Input[str] redis_persistence: When persistence is 'rdb', Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is 'off', no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
+        :param pulumi.Input[str] redis_persistence: Enum: `off`, `rdb`. When persistence is 'rdb', Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is 'off', no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
         :param pulumi.Input[int] redis_pubsub_client_output_buffer_limit: Set output buffer limit for pub / sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan.
         :param pulumi.Input[bool] redis_ssl: Require SSL to access Redis. The default value is `true`.
         :param pulumi.Input[int] redis_timeout: Redis idle connection timeout in seconds. The default value is `300`.
-        :param pulumi.Input[str] redis_version: Redis major version.
+        :param pulumi.Input[str] redis_version: Enum: `7.0`. Redis major version.
         :param pulumi.Input[bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
         :param pulumi.Input[str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created.
         :param pulumi.Input[bool] static_ips: Use static public IP addresses.
@@ -18712,7 +19576,7 @@ class RedisRedisUserConfigArgs:
     @pulumi.getter(name="redisAclChannelsDefault")
     def redis_acl_channels_default(self) -> Optional[pulumi.Input[str]]:
         """
-        Determines default pub/sub channels' ACL for new users if ACL is not supplied. When this option is not defined, all_channels is assumed to keep backward compatibility. This option doesn't affect Redis configuration acl-pubsub-default.
+        Enum: `allchannels`, `resetchannels`. Determines default pub/sub channels' ACL for new users if ACL is not supplied. When this option is not defined, all_channels is assumed to keep backward compatibility. This option doesn't affect Redis configuration acl-pubsub-default.
         """
         return pulumi.get(self, "redis_acl_channels_default")
 
@@ -18760,7 +19624,7 @@ class RedisRedisUserConfigArgs:
     @pulumi.getter(name="redisMaxmemoryPolicy")
     def redis_maxmemory_policy(self) -> Optional[pulumi.Input[str]]:
         """
-        Redis maxmemory-policy. The default value is `noeviction`.
+        Enum: `noeviction`, `allkeys-lru`, `volatile-lru`, `allkeys-random`, `volatile-random`, `volatile-ttl`, `volatile-lfu`, `allkeys-lfu`. Redis maxmemory-policy. The default value is `noeviction`.
         """
         return pulumi.get(self, "redis_maxmemory_policy")
 
@@ -18796,7 +19660,7 @@ class RedisRedisUserConfigArgs:
     @pulumi.getter(name="redisPersistence")
     def redis_persistence(self) -> Optional[pulumi.Input[str]]:
         """
-        When persistence is 'rdb', Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is 'off', no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
+        Enum: `off`, `rdb`. When persistence is 'rdb', Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is 'off', no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
         """
         return pulumi.get(self, "redis_persistence")
 
@@ -18844,7 +19708,7 @@ class RedisRedisUserConfigArgs:
     @pulumi.getter(name="redisVersion")
     def redis_version(self) -> Optional[pulumi.Input[str]]:
         """
-        Redis major version.
+        Enum: `7.0`. Redis major version.
         """
         return pulumi.get(self, "redis_version")
 
@@ -18943,7 +19807,7 @@ class RedisRedisUserConfigMigrationArgs:
         :param pulumi.Input[int] port: Port number of the server where to migrate data from.
         :param pulumi.Input[str] dbname: Database name for bootstrapping the initial connection.
         :param pulumi.Input[str] ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment).
-        :param pulumi.Input[str] method: The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
+        :param pulumi.Input[str] method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         :param pulumi.Input[str] password: Password for authentication with the server where to migrate data from.
         :param pulumi.Input[bool] ssl: The server where to migrate data from is secured with SSL. The default value is `true`.
         :param pulumi.Input[str] username: User name for authentication with the server where to migrate data from.
@@ -19015,7 +19879,7 @@ class RedisRedisUserConfigMigrationArgs:
     @pulumi.getter
     def method(self) -> Optional[pulumi.Input[str]]:
         """
-        The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
+        Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         """
         return pulumi.get(self, "method")
 
@@ -19314,13 +20178,13 @@ class ServiceIntegrationClickhouseKafkaUserConfigTableArgs:
                  skip_broken_messages: Optional[pulumi.Input[int]] = None):
         """
         :param pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs']]] columns: Table columns
-        :param pulumi.Input[str] data_format: Message data format. The default value is `JSONEachRow`.
+        :param pulumi.Input[str] data_format: Enum: `Avro`, `CSV`, `JSONAsString`, `JSONCompactEachRow`, `JSONCompactStringsEachRow`, `JSONEachRow`, `JSONStringsEachRow`, `MsgPack`, `TSKV`, `TSV`, `TabSeparated`, `RawBLOB`, `AvroConfluent`. Message data format. The default value is `JSONEachRow`.
         :param pulumi.Input[str] group_name: Kafka consumers group. The default value is `clickhouse`.
         :param pulumi.Input[str] name: Name of the table.
         :param pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs']]] topics: Kafka topics
-        :param pulumi.Input[str] auto_offset_reset: Action to take when there is no initial offset in offset store or the desired offset is out of range. The default value is `earliest`.
-        :param pulumi.Input[str] date_time_input_format: Method to read DateTime from text input formats. The default value is `basic`.
-        :param pulumi.Input[str] handle_error_mode: How to handle errors for Kafka engine. The default value is `default`.
+        :param pulumi.Input[str] auto_offset_reset: Enum: `smallest`, `earliest`, `beginning`, `largest`, `latest`, `end`. Action to take when there is no initial offset in offset store or the desired offset is out of range. The default value is `earliest`.
+        :param pulumi.Input[str] date_time_input_format: Enum: `basic`, `best_effort`, `best_effort_us`. Method to read DateTime from text input formats. The default value is `basic`.
+        :param pulumi.Input[str] handle_error_mode: Enum: `default`, `stream`. How to handle errors for Kafka engine. The default value is `default`.
         :param pulumi.Input[int] max_block_size: Number of row collected by poll(s) for flushing data from Kafka. The default value is `0`.
         :param pulumi.Input[int] max_rows_per_message: The maximum number of rows produced in one kafka message for row-based formats. The default value is `1`.
         :param pulumi.Input[int] num_consumers: The number of consumers per table per replica. The default value is `1`.
@@ -19365,7 +20229,7 @@ class ServiceIntegrationClickhouseKafkaUserConfigTableArgs:
     @pulumi.getter(name="dataFormat")
     def data_format(self) -> pulumi.Input[str]:
         """
-        Message data format. The default value is `JSONEachRow`.
+        Enum: `Avro`, `CSV`, `JSONAsString`, `JSONCompactEachRow`, `JSONCompactStringsEachRow`, `JSONEachRow`, `JSONStringsEachRow`, `MsgPack`, `TSKV`, `TSV`, `TabSeparated`, `RawBLOB`, `AvroConfluent`. Message data format. The default value is `JSONEachRow`.
         """
         return pulumi.get(self, "data_format")
 
@@ -19413,7 +20277,7 @@ class ServiceIntegrationClickhouseKafkaUserConfigTableArgs:
     @pulumi.getter(name="autoOffsetReset")
     def auto_offset_reset(self) -> Optional[pulumi.Input[str]]:
         """
-        Action to take when there is no initial offset in offset store or the desired offset is out of range. The default value is `earliest`.
+        Enum: `smallest`, `earliest`, `beginning`, `largest`, `latest`, `end`. Action to take when there is no initial offset in offset store or the desired offset is out of range. The default value is `earliest`.
         """
         return pulumi.get(self, "auto_offset_reset")
 
@@ -19425,7 +20289,7 @@ class ServiceIntegrationClickhouseKafkaUserConfigTableArgs:
     @pulumi.getter(name="dateTimeInputFormat")
     def date_time_input_format(self) -> Optional[pulumi.Input[str]]:
         """
-        Method to read DateTime from text input formats. The default value is `basic`.
+        Enum: `basic`, `best_effort`, `best_effort_us`. Method to read DateTime from text input formats. The default value is `basic`.
         """
         return pulumi.get(self, "date_time_input_format")
 
@@ -19437,7 +20301,7 @@ class ServiceIntegrationClickhouseKafkaUserConfigTableArgs:
     @pulumi.getter(name="handleErrorMode")
     def handle_error_mode(self) -> Optional[pulumi.Input[str]]:
         """
-        How to handle errors for Kafka engine. The default value is `default`.
+        Enum: `default`, `stream`. How to handle errors for Kafka engine. The default value is `default`.
         """
         return pulumi.get(self, "handle_error_mode")
 
@@ -19631,6 +20495,7 @@ class ServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgs:
 class ServiceIntegrationDatadogUserConfigArgs:
     def __init__(__self__, *,
                  datadog_dbm_enabled: Optional[pulumi.Input[bool]] = None,
+                 datadog_pgbouncer_enabled: Optional[pulumi.Input[bool]] = None,
                  datadog_tags: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationDatadogUserConfigDatadogTagArgs']]]] = None,
                  exclude_consumer_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  exclude_topics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
@@ -19642,6 +20507,7 @@ class ServiceIntegrationDatadogUserConfigArgs:
                  redis: Optional[pulumi.Input['ServiceIntegrationDatadogUserConfigRedisArgs']] = None):
         """
         :param pulumi.Input[bool] datadog_dbm_enabled: Enable Datadog Database Monitoring.
+        :param pulumi.Input[bool] datadog_pgbouncer_enabled: Enable Datadog PgBouncer Metric Tracking.
         :param pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationDatadogUserConfigDatadogTagArgs']]] datadog_tags: Custom tags provided by user
         :param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_consumer_groups: List of custom metrics.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_topics: List of topics to exclude.
@@ -19654,6 +20520,8 @@ class ServiceIntegrationDatadogUserConfigArgs:
         """
         if datadog_dbm_enabled is not None:
             pulumi.set(__self__, "datadog_dbm_enabled", datadog_dbm_enabled)
+        if datadog_pgbouncer_enabled is not None:
+            pulumi.set(__self__, "datadog_pgbouncer_enabled", datadog_pgbouncer_enabled)
         if datadog_tags is not None:
             pulumi.set(__self__, "datadog_tags", datadog_tags)
         if exclude_consumer_groups is not None:
@@ -19685,6 +20553,18 @@ class ServiceIntegrationDatadogUserConfigArgs:
     def datadog_dbm_enabled(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "datadog_dbm_enabled", value)
 
+    @property
+    @pulumi.getter(name="datadogPgbouncerEnabled")
+    def datadog_pgbouncer_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Enable Datadog PgBouncer Metric Tracking.
+        """
+        return pulumi.get(self, "datadog_pgbouncer_enabled")
+
+    @datadog_pgbouncer_enabled.setter
+    def datadog_pgbouncer_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "datadog_pgbouncer_enabled", value)
+
     @property
     @pulumi.getter(name="datadogTags")
     def datadog_tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationDatadogUserConfigDatadogTagArgs']]]]:
@@ -19943,7 +20823,7 @@ class ServiceIntegrationEndpointDatadogUserConfigArgs:
         :param pulumi.Input[int] kafka_consumer_check_instances: Number of separate instances to fetch kafka consumer statistics with.
         :param pulumi.Input[int] kafka_consumer_stats_timeout: Number of seconds that datadog will wait to get consumer statistics from brokers.
         :param pulumi.Input[int] max_partition_contexts: Maximum number of partition contexts to send.
-        :param pulumi.Input[str] site: Datadog intake site. Defaults to datadoghq.com.
+        :param pulumi.Input[str] site: Enum: `datadoghq.com`, `datadoghq.eu`, `us3.datadoghq.com`, `us5.datadoghq.com`, `ddog-gov.com`, `ap1.datadoghq.com`. Datadog intake site. Defaults to datadoghq.com.
         """
         pulumi.set(__self__, "datadog_api_key", datadog_api_key)
         if datadog_tags is not None:
@@ -20035,7 +20915,7 @@ class ServiceIntegrationEndpointDatadogUserConfigArgs:
     @pulumi.getter
     def site(self) -> Optional[pulumi.Input[str]]:
         """
-        Datadog intake site. Defaults to datadoghq.com.
+        Enum: `datadoghq.com`, `datadoghq.eu`, `us3.datadoghq.com`, `us5.datadoghq.com`, `ddog-gov.com`, `ap1.datadoghq.com`. Datadog intake site. Defaults to datadoghq.com.
         """
         return pulumi.get(self, "site")
 
@@ -20405,14 +21285,14 @@ class ServiceIntegrationEndpointExternalKafkaUserConfigArgs:
                  ssl_endpoint_identification_algorithm: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[str] bootstrap_servers: Bootstrap servers.
-        :param pulumi.Input[str] security_protocol: Security protocol.
-        :param pulumi.Input[str] sasl_mechanism: SASL mechanism used for connections to the Kafka server.
+        :param pulumi.Input[str] security_protocol: Enum: `PLAINTEXT`, `SSL`, `SASL_PLAINTEXT`, `SASL_SSL`. Security protocol.
+        :param pulumi.Input[str] sasl_mechanism: Enum: `PLAIN`, `SCRAM-SHA-256`, `SCRAM-SHA-512`. SASL mechanism used for connections to the Kafka server.
         :param pulumi.Input[str] sasl_plain_password: Password for SASL PLAIN mechanism in the Kafka server.
         :param pulumi.Input[str] sasl_plain_username: Username for SASL PLAIN mechanism in the Kafka server.
         :param pulumi.Input[str] ssl_ca_cert: PEM-encoded CA certificate.
         :param pulumi.Input[str] ssl_client_cert: PEM-encoded client certificate.
         :param pulumi.Input[str] ssl_client_key: PEM-encoded client key.
-        :param pulumi.Input[str] ssl_endpoint_identification_algorithm: The endpoint identification algorithm to validate server hostname using server certificate.
+        :param pulumi.Input[str] ssl_endpoint_identification_algorithm: Enum: `https`, ``. The endpoint identification algorithm to validate server hostname using server certificate.
         """
         pulumi.set(__self__, "bootstrap_servers", bootstrap_servers)
         pulumi.set(__self__, "security_protocol", security_protocol)
@@ -20447,7 +21327,7 @@ class ServiceIntegrationEndpointExternalKafkaUserConfigArgs:
     @pulumi.getter(name="securityProtocol")
     def security_protocol(self) -> pulumi.Input[str]:
         """
-        Security protocol.
+        Enum: `PLAINTEXT`, `SSL`, `SASL_PLAINTEXT`, `SASL_SSL`. Security protocol.
         """
         return pulumi.get(self, "security_protocol")
 
@@ -20459,7 +21339,7 @@ class ServiceIntegrationEndpointExternalKafkaUserConfigArgs:
     @pulumi.getter(name="saslMechanism")
     def sasl_mechanism(self) -> Optional[pulumi.Input[str]]:
         """
-        SASL mechanism used for connections to the Kafka server.
+        Enum: `PLAIN`, `SCRAM-SHA-256`, `SCRAM-SHA-512`. SASL mechanism used for connections to the Kafka server.
         """
         return pulumi.get(self, "sasl_mechanism")
 
@@ -20531,7 +21411,7 @@ class ServiceIntegrationEndpointExternalKafkaUserConfigArgs:
     @pulumi.getter(name="sslEndpointIdentificationAlgorithm")
     def ssl_endpoint_identification_algorithm(self) -> Optional[pulumi.Input[str]]:
         """
-        The endpoint identification algorithm to validate server hostname using server certificate.
+        Enum: `https`, ``. The endpoint identification algorithm to validate server hostname using server certificate.
         """
         return pulumi.get(self, "ssl_endpoint_identification_algorithm")
 
@@ -20645,7 +21525,7 @@ class ServiceIntegrationEndpointExternalPostgresqlArgs:
         :param pulumi.Input[str] password: Password.
         :param pulumi.Input[str] ssl_client_certificate: Client certificate.
         :param pulumi.Input[str] ssl_client_key: Client key.
-        :param pulumi.Input[str] ssl_mode: SSL Mode. The default value is `verify-full`.
+        :param pulumi.Input[str] ssl_mode: Enum: `disable`, `allow`, `prefer`, `require`, `verify-ca`, `verify-full`. SSL Mode. The default value is `verify-full`.
         :param pulumi.Input[str] ssl_root_cert: SSL Root Cert.
         """
         pulumi.set(__self__, "host", host)
@@ -20752,7 +21632,7 @@ class ServiceIntegrationEndpointExternalPostgresqlArgs:
     @pulumi.getter(name="sslMode")
     def ssl_mode(self) -> Optional[pulumi.Input[str]]:
         """
-        SSL Mode. The default value is `verify-full`.
+        Enum: `disable`, `allow`, `prefer`, `require`, `verify-ca`, `verify-full`. SSL Mode. The default value is `verify-full`.
         """
         return pulumi.get(self, "ssl_mode")
 
@@ -20781,7 +21661,7 @@ class ServiceIntegrationEndpointExternalSchemaRegistryUserConfigArgs:
                  basic_auth_password: Optional[pulumi.Input[str]] = None,
                  basic_auth_username: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] authentication: Authentication method.
+        :param pulumi.Input[str] authentication: Enum: `none`, `basic`. Authentication method.
         :param pulumi.Input[str] url: Schema Registry URL.
         :param pulumi.Input[str] basic_auth_password: Basic authentication password.
         :param pulumi.Input[str] basic_auth_username: Basic authentication user name.
@@ -20797,7 +21677,7 @@ class ServiceIntegrationEndpointExternalSchemaRegistryUserConfigArgs:
     @pulumi.getter
     def authentication(self) -> pulumi.Input[str]:
         """
-        Authentication method.
+        Enum: `none`, `basic`. Authentication method.
         """
         return pulumi.get(self, "authentication")
 
@@ -20934,7 +21814,7 @@ class ServiceIntegrationEndpointRsyslogUserConfigArgs:
                  max_message_size: Optional[pulumi.Input[int]] = None,
                  sd: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] format: Message format. The default value is `rfc5424`.
+        :param pulumi.Input[str] format: Enum: `rfc5424`, `rfc3164`, `custom`. Message format. The default value is `rfc5424`.
         :param pulumi.Input[int] port: Rsyslog server port. The default value is `514`.
         :param pulumi.Input[str] server: Rsyslog server IP address or hostname.
         :param pulumi.Input[bool] tls: Require TLS. The default value is `true`.
@@ -20966,7 +21846,7 @@ class ServiceIntegrationEndpointRsyslogUserConfigArgs:
     @pulumi.getter
     def format(self) -> pulumi.Input[str]:
         """
-        Message format. The default value is `rfc5424`.
+        Enum: `rfc5424`, `rfc3164`, `custom`. Message format. The default value is `rfc5424`.
         """
         return pulumi.get(self, "format")
 
@@ -21449,7 +22329,7 @@ class ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgs:
         :param pulumi.Input[int] consumer_fetch_min_bytes: The minimum amount of data the server should return for a fetch request.
         :param pulumi.Input[int] producer_batch_size: The batch size in bytes producer will attempt to collect before publishing to broker.
         :param pulumi.Input[int] producer_buffer_memory: The amount of bytes producer can use for buffering data before publishing to broker.
-        :param pulumi.Input[str] producer_compression_type: Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
+        :param pulumi.Input[str] producer_compression_type: Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
         :param pulumi.Input[int] producer_linger_ms: The linger time (ms) for waiting new data to arrive for publishing.
         :param pulumi.Input[int] producer_max_request_size: The maximum request size in bytes.
         """
@@ -21506,7 +22386,7 @@ class ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgs:
     @pulumi.getter(name="producerCompressionType")
     def producer_compression_type(self) -> Optional[pulumi.Input[str]]:
         """
-        Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
+        Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
         """
         return pulumi.get(self, "producer_compression_type")