pulumi-aiven 6.21.0a1722057299__py3-none-any.whl → 6.22.0__py3-none-any.whl

pulumi_aiven/outputs.py

@@ -101,6 +101,7 @@ __all__ = [
     'KafkaConnectorTask',
     'KafkaKafka',
     'KafkaKafkaUserConfig',
+    'KafkaKafkaUserConfigFollowerFetching',
     'KafkaKafkaUserConfigIpFilterObject',
     'KafkaKafkaUserConfigKafka',
     'KafkaKafkaUserConfigKafkaAuthenticationMethods',
@@ -109,6 +110,7 @@ __all__ = [
     'KafkaKafkaUserConfigKafkaConnectSecretProviderAws',
     'KafkaKafkaUserConfigKafkaConnectSecretProviderVault',
     'KafkaKafkaUserConfigKafkaRestConfig',
+    'KafkaKafkaUserConfigKafkaSaslMechanisms',
     'KafkaKafkaUserConfigPrivateAccess',
     'KafkaKafkaUserConfigPrivatelinkAccess',
     'KafkaKafkaUserConfigPublicAccess',
@@ -169,7 +171,10 @@ __all__ = [
     'OpenSearchComponent',
     'OpenSearchOpensearch',
     'OpenSearchOpensearchUserConfig',
+    'OpenSearchOpensearchUserConfigAzureMigration',
+    'OpenSearchOpensearchUserConfigGcsMigration',
     'OpenSearchOpensearchUserConfigIndexPattern',
+    'OpenSearchOpensearchUserConfigIndexRollup',
     'OpenSearchOpensearchUserConfigIndexTemplate',
     'OpenSearchOpensearchUserConfigIpFilterObject',
     'OpenSearchOpensearchUserConfigOpenid',
@@ -181,6 +186,7 @@ __all__ = [
     'OpenSearchOpensearchUserConfigPrivateAccess',
     'OpenSearchOpensearchUserConfigPrivatelinkAccess',
     'OpenSearchOpensearchUserConfigPublicAccess',
+    'OpenSearchOpensearchUserConfigS3Migration',
     'OpenSearchOpensearchUserConfigSaml',
     'OpenSearchServiceIntegration',
     'OpenSearchTag',
@@ -380,6 +386,7 @@ __all__ = [
     'GetKafkaConnectorTaskResult',
     'GetKafkaKafkaResult',
     'GetKafkaKafkaUserConfigResult',
+    'GetKafkaKafkaUserConfigFollowerFetchingResult',
     'GetKafkaKafkaUserConfigIpFilterObjectResult',
     'GetKafkaKafkaUserConfigKafkaResult',
     'GetKafkaKafkaUserConfigKafkaAuthenticationMethodsResult',
@@ -388,6 +395,7 @@ __all__ = [
     'GetKafkaKafkaUserConfigKafkaConnectSecretProviderAwsResult',
     'GetKafkaKafkaUserConfigKafkaConnectSecretProviderVaultResult',
     'GetKafkaKafkaUserConfigKafkaRestConfigResult',
+    'GetKafkaKafkaUserConfigKafkaSaslMechanismsResult',
     'GetKafkaKafkaUserConfigPrivateAccessResult',
     'GetKafkaKafkaUserConfigPrivatelinkAccessResult',
     'GetKafkaKafkaUserConfigPublicAccessResult',
@@ -448,7 +456,10 @@ __all__ = [
     'GetOpenSearchComponentResult',
     'GetOpenSearchOpensearchResult',
     'GetOpenSearchOpensearchUserConfigResult',
+    'GetOpenSearchOpensearchUserConfigAzureMigrationResult',
+    'GetOpenSearchOpensearchUserConfigGcsMigrationResult',
     'GetOpenSearchOpensearchUserConfigIndexPatternResult',
+    'GetOpenSearchOpensearchUserConfigIndexRollupResult',
     'GetOpenSearchOpensearchUserConfigIndexTemplateResult',
     'GetOpenSearchOpensearchUserConfigIpFilterObjectResult',
     'GetOpenSearchOpensearchUserConfigOpenidResult',
@@ -460,6 +471,7 @@ __all__ = [
     'GetOpenSearchOpensearchUserConfigPrivateAccessResult',
     'GetOpenSearchOpensearchUserConfigPrivatelinkAccessResult',
     'GetOpenSearchOpensearchUserConfigPublicAccessResult',
+    'GetOpenSearchOpensearchUserConfigS3MigrationResult',
     'GetOpenSearchOpensearchUserConfigSamlResult',
     'GetOpenSearchServiceIntegrationResult',
     'GetOpenSearchTagResult',
@@ -2520,6 +2532,8 @@ class DragonflyDragonflyUserConfigMigration(dict):
         suggest = None
         if key == "ignoreDbs":
             suggest = "ignore_dbs"
+        elif key == "ignoreRoles":
+            suggest = "ignore_roles"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in DragonflyDragonflyUserConfigMigration. Access the value via the '{suggest}' property getter instead.")
@@ -2537,6 +2551,7 @@ class DragonflyDragonflyUserConfigMigration(dict):
                  port: int,
                  dbname: Optional[str] = None,
                  ignore_dbs: Optional[str] = None,
+                 ignore_roles: Optional[str] = None,
                  method: Optional[str] = None,
                  password: Optional[str] = None,
                  ssl: Optional[bool] = None,
@@ -2546,6 +2561,7 @@ class DragonflyDragonflyUserConfigMigration(dict):
         :param int port: Port number of the server where to migrate data from. Example: `1234`.
         :param str dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
         :param str ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
+        :param str ignore_roles: Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
         :param str method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         :param str password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
         :param bool ssl: The server where to migrate data from is secured with SSL. Default: `true`.
@@ -2557,6 +2573,8 @@ class DragonflyDragonflyUserConfigMigration(dict):
             pulumi.set(__self__, "dbname", dbname)
         if ignore_dbs is not None:
             pulumi.set(__self__, "ignore_dbs", ignore_dbs)
+        if ignore_roles is not None:
+            pulumi.set(__self__, "ignore_roles", ignore_roles)
         if method is not None:
             pulumi.set(__self__, "method", method)
         if password is not None:
@@ -2598,6 +2616,14 @@ class DragonflyDragonflyUserConfigMigration(dict):
         """
         return pulumi.get(self, "ignore_dbs")
 
+    @property
+    @pulumi.getter(name="ignoreRoles")
+    def ignore_roles(self) -> Optional[str]:
+        """
+        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
+        """
+        return pulumi.get(self, "ignore_roles")
+
     @property
     @pulumi.getter
     def method(self) -> Optional[str]:
@@ -3665,7 +3691,8 @@ class GrafanaGrafanaUserConfig(dict):
                  unified_alerting_enabled: Optional[bool] = None,
                  user_auto_assign_org: Optional[bool] = None,
                  user_auto_assign_org_role: Optional[str] = None,
-                 viewers_can_edit: Optional[bool] = None):
+                 viewers_can_edit: Optional[bool] = None,
+                 wal: Optional[bool] = None):
         """
         :param str additional_backup_regions: Additional Cloud Regions for Backup Replication.
         :param bool alerting_enabled: Enable or disable Grafana legacy alerting functionality. This should not be enabled with unified*alerting*enabled.
@@ -3709,6 +3736,7 @@ class GrafanaGrafanaUserConfig(dict):
         :param bool user_auto_assign_org: Auto-assign new users on signup to main organization. Defaults to false.
         :param str user_auto_assign_org_role: Enum: `Viewer`, `Admin`, `Editor`. Set role for new signups. Defaults to Viewer.
         :param bool viewers_can_edit: Users with view-only permission can edit but not save dashboards.
+        :param bool wal: Setting to enable/disable Write-Ahead Logging. The default value is false (disabled).
         """
         if additional_backup_regions is not None:
             pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
@@ -3794,6 +3822,8 @@ class GrafanaGrafanaUserConfig(dict):
             pulumi.set(__self__, "user_auto_assign_org_role", user_auto_assign_org_role)
         if viewers_can_edit is not None:
             pulumi.set(__self__, "viewers_can_edit", viewers_can_edit)
+        if wal is not None:
+            pulumi.set(__self__, "wal", wal)
 
     @property
     @pulumi.getter(name="additionalBackupRegions")
@@ -4132,6 +4162,14 @@ class GrafanaGrafanaUserConfig(dict):
         """
         return pulumi.get(self, "viewers_can_edit")
 
+    @property
+    @pulumi.getter
+    def wal(self) -> Optional[bool]:
+        """
+        Setting to enable/disable Write-Ahead Logging. The default value is false (disabled).
+        """
+        return pulumi.get(self, "wal")
+
 
 @pulumi.output_type
 class GrafanaGrafanaUserConfigAuthAzuread(dict):
@@ -7230,6 +7268,8 @@ class KafkaKafkaUserConfig(dict):
             suggest = "aiven_kafka_topic_messages"
         elif key == "customDomain":
             suggest = "custom_domain"
+        elif key == "followerFetching":
+            suggest = "follower_fetching"
         elif key == "ipFilterObjects":
             suggest = "ip_filter_objects"
         elif key == "ipFilterStrings":
@@ -7250,6 +7290,8 @@ class KafkaKafkaUserConfig(dict):
             suggest = "kafka_rest_authorization"
         elif key == "kafkaRestConfig":
             suggest = "kafka_rest_config"
+        elif key == "kafkaSaslMechanisms":
+            suggest = "kafka_sasl_mechanisms"
         elif key == "kafkaVersion":
             suggest = "kafka_version"
         elif key == "letsencryptSaslPrivatelink":
@@ -7286,6 +7328,7 @@ class KafkaKafkaUserConfig(dict):
                  additional_backup_regions: Optional[str] = None,
                  aiven_kafka_topic_messages: Optional[bool] = None,
                  custom_domain: Optional[str] = None,
+                 follower_fetching: Optional['outputs.KafkaKafkaUserConfigFollowerFetching'] = None,
                  ip_filter_objects: Optional[Sequence['outputs.KafkaKafkaUserConfigIpFilterObject']] = None,
                  ip_filter_strings: Optional[Sequence[str]] = None,
                  ip_filters: Optional[Sequence[str]] = None,
@@ -7297,6 +7340,7 @@ class KafkaKafkaUserConfig(dict):
                  kafka_rest: Optional[bool] = None,
                  kafka_rest_authorization: Optional[bool] = None,
                  kafka_rest_config: Optional['outputs.KafkaKafkaUserConfigKafkaRestConfig'] = None,
+                 kafka_sasl_mechanisms: Optional['outputs.KafkaKafkaUserConfigKafkaSaslMechanisms'] = None,
                  kafka_version: Optional[str] = None,
                  letsencrypt_sasl_privatelink: Optional[bool] = None,
                  private_access: Optional['outputs.KafkaKafkaUserConfigPrivateAccess'] = None,
@@ -7311,6 +7355,7 @@ class KafkaKafkaUserConfig(dict):
         :param str additional_backup_regions: Additional Cloud Regions for Backup Replication.
         :param bool aiven_kafka_topic_messages: Allow access to read Kafka topic messages in the Aiven Console and REST API.
         :param str custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. Example: `grafana.example.org`.
+        :param 'KafkaKafkaUserConfigFollowerFetchingArgs' follower_fetching: Enable follower fetching
         :param Sequence['KafkaKafkaUserConfigIpFilterObjectArgs'] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
         :param Sequence[str] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
         :param Sequence[str] ip_filters: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
@@ -7321,6 +7366,7 @@ class KafkaKafkaUserConfig(dict):
         :param bool kafka_rest: Enable Kafka-REST service. Default: `false`.
         :param bool kafka_rest_authorization: Enable authorization in Kafka-REST service.
         :param 'KafkaKafkaUserConfigKafkaRestConfigArgs' kafka_rest_config: Kafka REST configuration
+        :param 'KafkaKafkaUserConfigKafkaSaslMechanismsArgs' kafka_sasl_mechanisms: Kafka SASL mechanisms
         :param str kafka_version: Enum: `3.1`, `3.2`, `3.3`, `3.4`, `3.5`, `3.6`, `3.7`, and newer. Kafka major version.
         :param bool letsencrypt_sasl_privatelink: Use Letsencrypt CA for Kafka SASL via Privatelink.
         :param 'KafkaKafkaUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
@@ -7338,6 +7384,8 @@ class KafkaKafkaUserConfig(dict):
             pulumi.set(__self__, "aiven_kafka_topic_messages", aiven_kafka_topic_messages)
         if custom_domain is not None:
             pulumi.set(__self__, "custom_domain", custom_domain)
+        if follower_fetching is not None:
+            pulumi.set(__self__, "follower_fetching", follower_fetching)
         if ip_filter_objects is not None:
             pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
         if ip_filter_strings is not None:
@@ -7360,6 +7408,8 @@ class KafkaKafkaUserConfig(dict):
             pulumi.set(__self__, "kafka_rest_authorization", kafka_rest_authorization)
         if kafka_rest_config is not None:
             pulumi.set(__self__, "kafka_rest_config", kafka_rest_config)
+        if kafka_sasl_mechanisms is not None:
+            pulumi.set(__self__, "kafka_sasl_mechanisms", kafka_sasl_mechanisms)
         if kafka_version is not None:
             pulumi.set(__self__, "kafka_version", kafka_version)
         if letsencrypt_sasl_privatelink is not None:
@@ -7406,6 +7456,14 @@ class KafkaKafkaUserConfig(dict):
         """
         return pulumi.get(self, "custom_domain")
 
+    @property
+    @pulumi.getter(name="followerFetching")
+    def follower_fetching(self) -> Optional['outputs.KafkaKafkaUserConfigFollowerFetching']:
+        """
+        Enable follower fetching
+        """
+        return pulumi.get(self, "follower_fetching")
+
     @property
     @pulumi.getter(name="ipFilterObjects")
     def ip_filter_objects(self) -> Optional[Sequence['outputs.KafkaKafkaUserConfigIpFilterObject']]:
@@ -7492,6 +7550,14 @@ class KafkaKafkaUserConfig(dict):
         """
         return pulumi.get(self, "kafka_rest_config")
 
+    @property
+    @pulumi.getter(name="kafkaSaslMechanisms")
+    def kafka_sasl_mechanisms(self) -> Optional['outputs.KafkaKafkaUserConfigKafkaSaslMechanisms']:
+        """
+        Kafka SASL mechanisms
+        """
+        return pulumi.get(self, "kafka_sasl_mechanisms")
+
     @property
     @pulumi.getter(name="kafkaVersion")
     def kafka_version(self) -> Optional[str]:
@@ -7573,6 +7639,25 @@ class KafkaKafkaUserConfig(dict):
         return pulumi.get(self, "tiered_storage")
 
 
+@pulumi.output_type
+class KafkaKafkaUserConfigFollowerFetching(dict):
+    def __init__(__self__, *,
+                 enabled: Optional[bool] = None):
+        """
+        :param bool enabled: Whether to enable the follower fetching functionality.
+        """
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[bool]:
+        """
+        Whether to enable the follower fetching functionality.
+        """
+        return pulumi.get(self, "enabled")
+
+
 @pulumi.output_type
 class KafkaKafkaUserConfigIpFilterObject(dict):
     def __init__(__self__, *,
@@ -7760,52 +7845,52 @@ class KafkaKafkaUserConfigKafka(dict):
                  transaction_remove_expired_transaction_cleanup_interval_ms: Optional[int] = None,
                  transaction_state_log_segment_bytes: Optional[int] = None):
         """
-        :param bool auto_create_topics_enable: Enable auto creation of topics.
-        :param 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 int connections_max_idle_ms: Idle connections timeout: the server socket processor threads close the connections that idle for longer than this. Example: `540000`.
-        :param int default_replication_factor: Replication factor for autocreated topics.
-        :param 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. Example: `3000`.
-        :param int group_max_session_timeout_ms: The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. Example: `1800000`.
-        :param int group_min_session_timeout_ms: The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. Example: `6000`.
-        :param int log_cleaner_delete_retention_ms: How long are delete records retained? Example: `86400000`.
-        :param 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 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. Example: `0.5`.
-        :param 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 str log_cleanup_policy: Enum: `delete`, `compact`, `compact,delete`. The default cleanup policy for segments beyond the retention window.
-        :param int log_flush_interval_messages: The number of messages accumulated on a log partition before messages are flushed to disk. Example: `9223372036854775807`.
-        :param 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 int log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index. Example: `4096`.
-        :param int log_index_size_max_bytes: The maximum size in bytes of the offset index. Example: `10485760`.
-        :param int log_local_retention_bytes: The maximum size of local log segments that can grow for a partition before it gets eligible for deletion. If set to -2, the value of log.retention.bytes is used. The effective value should always be less than or equal to log.retention.bytes value.
-        :param 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 bool log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
-        :param 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 str log_message_timestamp_type: Enum: `CreateTime`, `LogAppendTime`. Define whether the timestamp in the message is message create time or log append time.
-        :param bool log_preallocate: Should pre allocate file when create new segment?
-        :param int log_retention_bytes: The maximum size of the log before deleting messages.
-        :param int log_retention_hours: The number of hours to keep a log file before deleting it.
-        :param int log_retention_ms: The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied.
-        :param int log_roll_jitter_ms: The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used.
-        :param int log_roll_ms: The maximum time before a new log segment is rolled out (in milliseconds).
-        :param int log_segment_bytes: The maximum size of a single log file.
-        :param int log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem. Example: `60000`.
-        :param int max_connections_per_ip: The maximum number of connections allowed from each ip address (defaults to 2147483647).
-        :param int max_incremental_fetch_session_cache_slots: The maximum number of incremental fetch sessions that the broker will maintain. Example: `1000`.
-        :param int message_max_bytes: The maximum size of message that the server can receive. Example: `1048588`.
-        :param int min_insync_replicas: When a producer sets acks to `all` (or `-1`), min.insync.replicas specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. Example: `1`.
-        :param int num_partitions: Number of partitions for autocreated topics.
-        :param int offsets_retention_minutes: Log retention window in minutes for offsets topic. Example: `10080`.
-        :param int producer_purgatory_purge_interval_requests: The purge interval (in number of requests) of the producer request purgatory(defaults to 1000).
-        :param int replica_fetch_max_bytes: The number of bytes of messages to attempt to fetch for each partition (defaults to 1048576). This is not an absolute maximum, 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 progress can be made.
-        :param int replica_fetch_response_max_bytes: Maximum bytes expected for the entire fetch response (defaults to 10485760). Records are fetched in batches, 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 progress can be made. As such, this is not an absolute maximum.
-        :param str sasl_oauthbearer_expected_audience: The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences.
-        :param str sasl_oauthbearer_expected_issuer: Optional setting for the broker to use to verify that the JWT was created by the expected issuer.
-        :param str sasl_oauthbearer_jwks_endpoint_url: OIDC JWKS endpoint URL. By setting this the SASL SSL OAuth2/OIDC authentication is enabled. See also other options for SASL OAuth2/OIDC.
-        :param str sasl_oauthbearer_sub_claim_name: Name of the scope from which to extract the subject claim from the JWT. Defaults to sub.
-        :param int socket_request_max_bytes: The maximum number of bytes in a socket request (defaults to 104857600).
-        :param bool transaction_partition_verification_enable: Enable verification that checks that the partition has been added to the transaction before writing transactional records to the partition.
-        :param int transaction_remove_expired_transaction_cleanup_interval_ms: The interval at which to remove transactions that have expired due to transactional.id.expiration.ms passing (defaults to 3600000 (1 hour)).
-        :param int transaction_state_log_segment_bytes: The transaction topic segment bytes should be kept relatively small in order to facilitate faster log compaction and cache loads (defaults to 104857600 (100 mebibytes)).
+        :param bool auto_create_topics_enable: Enable auto-creation of topics. (Default: true).
+        :param 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.(Default: producer).
+        :param int connections_max_idle_ms: Idle connections timeout: the server socket processor threads close the connections that idle for longer than this. (Default: 600000 ms (10 minutes)). Example: `540000`.
+        :param int default_replication_factor: Replication factor for auto-created topics (Default: 3).
+        :param 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. (Default: 3000 ms (3 seconds)). Example: `3000`.
+        :param int group_max_session_timeout_ms: The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. Default: 1800000 ms (30 minutes). Example: `1800000`.
+        :param int group_min_session_timeout_ms: The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. (Default: 6000 ms (6 seconds)). Example: `6000`.
+        :param int log_cleaner_delete_retention_ms: How long are delete records retained? (Default: 86400000 (1 day)). Example: `86400000`.
+        :param int log_cleaner_max_compaction_lag_ms: The maximum amount of time message will remain uncompacted. Only applicable for logs that are being compacted. (Default: 9223372036854775807 ms (Long.MAX_VALUE)).
+        :param 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. (Default: 0.5). Example: `0.5`.
+        :param 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. (Default: 0 ms).
+        :param str log_cleanup_policy: Enum: `delete`, `compact`, `compact,delete`. The default cleanup policy for segments beyond the retention window (Default: delete).
+        :param int log_flush_interval_messages: The number of messages accumulated on a log partition before messages are flushed to disk (Default: 9223372036854775807 (Long.MAX_VALUE)). Example: `9223372036854775807`.
+        :param int log_flush_interval_ms: The maximum time in ms that a message in any topic is kept in memory (page-cache) before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used (Default: null).
+        :param int log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index (Default: 4096 bytes (4 kibibytes)). Example: `4096`.
+        :param int log_index_size_max_bytes: The maximum size in bytes of the offset index (Default: 10485760 (10 mebibytes)). Example: `10485760`.
+        :param int log_local_retention_bytes: The maximum size of local log segments that can grow for a partition before it gets eligible for deletion. If set to -2, the value of log.retention.bytes is used. The effective value should always be less than or equal to log.retention.bytes value. (Default: -2).
+        :param 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. (Default: -2).
+        :param bool log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests. (Default: true).
+        :param 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 (Default: 9223372036854775807 (Long.MAX_VALUE)).
+        :param str log_message_timestamp_type: Enum: `CreateTime`, `LogAppendTime`. Define whether the timestamp in the message is message create time or log append time. (Default: CreateTime).
+        :param bool log_preallocate: Should pre allocate file when create new segment? (Default: false).
+        :param int log_retention_bytes: The maximum size of the log before deleting messages (Default: -1).
+        :param int log_retention_hours: The number of hours to keep a log file before deleting it (Default: 168 hours (1 week)).
+        :param int log_retention_ms: The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied. (Default: null, log.retention.hours applies).
+        :param int log_roll_jitter_ms: The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used (Default: null).
+        :param int log_roll_ms: The maximum time before a new log segment is rolled out (in milliseconds). (Default: null, log.roll.hours applies (Default: 168, 7 days)).
+        :param int log_segment_bytes: The maximum size of a single log file (Default: 1073741824 bytes (1 gibibyte)).
+        :param int log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem (Default: 60000 ms (1 minute)). Example: `60000`.
+        :param int max_connections_per_ip: The maximum number of connections allowed from each ip address (Default: 2147483647).
+        :param int max_incremental_fetch_session_cache_slots: The maximum number of incremental fetch sessions that the broker will maintain. (Default: 1000). Example: `1000`.
+        :param int message_max_bytes: The maximum size of message that the server can receive. (Default: 1048588 bytes (1 mebibyte + 12 bytes)). Example: `1048588`.
+        :param int min_insync_replicas: When a producer sets acks to `all` (or `-1`), min.insync.replicas specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. (Default: 1). Example: `1`.
+        :param int num_partitions: Number of partitions for auto-created topics (Default: 1).
+        :param int offsets_retention_minutes: Log retention window in minutes for offsets topic (Default: 10080 minutes (7 days)). Example: `10080`.
+        :param int producer_purgatory_purge_interval_requests: The purge interval (in number of requests) of the producer request purgatory (Default: 1000).
+        :param int replica_fetch_max_bytes: The number of bytes of messages to attempt to fetch for each partition . This is not an absolute maximum, 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 progress can be made. (Default: 1048576 bytes (1 mebibytes)).
+        :param int replica_fetch_response_max_bytes: Maximum bytes expected for the entire fetch response. Records are fetched in batches, 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 progress can be made. As such, this is not an absolute maximum. (Default: 10485760 bytes (10 mebibytes)).
+        :param str sasl_oauthbearer_expected_audience: The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences. (Default: null).
+        :param str sasl_oauthbearer_expected_issuer: Optional setting for the broker to use to verify that the JWT was created by the expected issuer.(Default: null).
+        :param str sasl_oauthbearer_jwks_endpoint_url: OIDC JWKS endpoint URL. By setting this the SASL SSL OAuth2/OIDC authentication is enabled. See also other options for SASL OAuth2/OIDC. (Default: null).
+        :param str sasl_oauthbearer_sub_claim_name: Name of the scope from which to extract the subject claim from the JWT.(Default: sub).
+        :param int socket_request_max_bytes: The maximum number of bytes in a socket request (Default: 104857600 bytes).
+        :param bool transaction_partition_verification_enable: Enable verification that checks that the partition has been added to the transaction before writing transactional records to the partition. (Default: true).
+        :param int transaction_remove_expired_transaction_cleanup_interval_ms: The interval at which to remove transactions that have expired due to transactional.id.expiration.ms passing (Default: 3600000 ms (1 hour)). Example: `3600000`.
+        :param int transaction_state_log_segment_bytes: The transaction topic segment bytes should be kept relatively small in order to facilitate faster log compaction and cache loads (Default: 104857600 bytes (100 mebibytes)). Example: `104857600`.
         """
         if auto_create_topics_enable is not None:
             pulumi.set(__self__, "auto_create_topics_enable", auto_create_topics_enable)
@@ -7904,7 +7989,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="autoCreateTopicsEnable")
     def auto_create_topics_enable(self) -> Optional[bool]:
         """
-        Enable auto creation of topics.
+        Enable auto-creation of topics. (Default: true).
         """
         return pulumi.get(self, "auto_create_topics_enable")
 
@@ -7912,7 +7997,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="compressionType")
     def compression_type(self) -> Optional[str]:
         """
-        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.
+        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.(Default: producer).
         """
         return pulumi.get(self, "compression_type")
 
@@ -7920,7 +8005,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="connectionsMaxIdleMs")
     def connections_max_idle_ms(self) -> Optional[int]:
         """
-        Idle connections timeout: the server socket processor threads close the connections that idle for longer than this. Example: `540000`.
+        Idle connections timeout: the server socket processor threads close the connections that idle for longer than this. (Default: 600000 ms (10 minutes)). Example: `540000`.
         """
         return pulumi.get(self, "connections_max_idle_ms")
 
@@ -7928,7 +8013,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="defaultReplicationFactor")
     def default_replication_factor(self) -> Optional[int]:
         """
-        Replication factor for autocreated topics.
+        Replication factor for auto-created topics (Default: 3).
         """
         return pulumi.get(self, "default_replication_factor")
 
@@ -7936,7 +8021,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="groupInitialRebalanceDelayMs")
     def group_initial_rebalance_delay_ms(self) -> Optional[int]:
         """
-        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. Example: `3000`.
+        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. (Default: 3000 ms (3 seconds)). Example: `3000`.
         """
         return pulumi.get(self, "group_initial_rebalance_delay_ms")
 
@@ -7944,7 +8029,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="groupMaxSessionTimeoutMs")
     def group_max_session_timeout_ms(self) -> Optional[int]:
         """
-        The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. Example: `1800000`.
+        The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. Default: 1800000 ms (30 minutes). Example: `1800000`.
         """
         return pulumi.get(self, "group_max_session_timeout_ms")
 
@@ -7952,7 +8037,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="groupMinSessionTimeoutMs")
     def group_min_session_timeout_ms(self) -> Optional[int]:
         """
-        The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. Example: `6000`.
+        The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. (Default: 6000 ms (6 seconds)). Example: `6000`.
         """
         return pulumi.get(self, "group_min_session_timeout_ms")
 
@@ -7960,7 +8045,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logCleanerDeleteRetentionMs")
     def log_cleaner_delete_retention_ms(self) -> Optional[int]:
         """
-        How long are delete records retained? Example: `86400000`.
+        How long are delete records retained? (Default: 86400000 (1 day)). Example: `86400000`.
         """
         return pulumi.get(self, "log_cleaner_delete_retention_ms")
 
@@ -7968,7 +8053,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logCleanerMaxCompactionLagMs")
     def log_cleaner_max_compaction_lag_ms(self) -> Optional[int]:
         """
-        The maximum amount of time message will remain uncompacted. Only applicable for logs that are being compacted.
+        The maximum amount of time message will remain uncompacted. Only applicable for logs that are being compacted. (Default: 9223372036854775807 ms (Long.MAX_VALUE)).
         """
         return pulumi.get(self, "log_cleaner_max_compaction_lag_ms")
 
@@ -7976,7 +8061,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logCleanerMinCleanableRatio")
     def log_cleaner_min_cleanable_ratio(self) -> Optional[float]:
         """
-        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. Example: `0.5`.
+        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. (Default: 0.5). Example: `0.5`.
         """
         return pulumi.get(self, "log_cleaner_min_cleanable_ratio")
 
@@ -7984,7 +8069,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logCleanerMinCompactionLagMs")
     def log_cleaner_min_compaction_lag_ms(self) -> Optional[int]:
         """
-        The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.
+        The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted. (Default: 0 ms).
         """
         return pulumi.get(self, "log_cleaner_min_compaction_lag_ms")
 
@@ -7992,7 +8077,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logCleanupPolicy")
     def log_cleanup_policy(self) -> Optional[str]:
         """
-        Enum: `delete`, `compact`, `compact,delete`. 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 (Default: delete).
         """
         return pulumi.get(self, "log_cleanup_policy")
 
@@ -8000,7 +8085,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logFlushIntervalMessages")
     def log_flush_interval_messages(self) -> Optional[int]:
         """
-        The number of messages accumulated on a log partition before messages are flushed to disk. Example: `9223372036854775807`.
+        The number of messages accumulated on a log partition before messages are flushed to disk (Default: 9223372036854775807 (Long.MAX_VALUE)). Example: `9223372036854775807`.
         """
         return pulumi.get(self, "log_flush_interval_messages")
 
@@ -8008,7 +8093,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logFlushIntervalMs")
     def log_flush_interval_ms(self) -> Optional[int]:
         """
-        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.
+        The maximum time in ms that a message in any topic is kept in memory (page-cache) before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used (Default: null).
         """
         return pulumi.get(self, "log_flush_interval_ms")
 
@@ -8016,7 +8101,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logIndexIntervalBytes")
     def log_index_interval_bytes(self) -> Optional[int]:
         """
-        The interval with which Kafka adds an entry to the offset index. Example: `4096`.
+        The interval with which Kafka adds an entry to the offset index (Default: 4096 bytes (4 kibibytes)). Example: `4096`.
         """
         return pulumi.get(self, "log_index_interval_bytes")
 
@@ -8024,7 +8109,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logIndexSizeMaxBytes")
     def log_index_size_max_bytes(self) -> Optional[int]:
         """
-        The maximum size in bytes of the offset index. Example: `10485760`.
+        The maximum size in bytes of the offset index (Default: 10485760 (10 mebibytes)). Example: `10485760`.
         """
         return pulumi.get(self, "log_index_size_max_bytes")
 
@@ -8032,7 +8117,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logLocalRetentionBytes")
     def log_local_retention_bytes(self) -> Optional[int]:
         """
-        The maximum size of local log segments that can grow for a partition before it gets eligible for deletion. If set to -2, the value of log.retention.bytes is used. The effective value should always be less than or equal to log.retention.bytes value.
+        The maximum size of local log segments that can grow for a partition before it gets eligible for deletion. If set to -2, the value of log.retention.bytes is used. The effective value should always be less than or equal to log.retention.bytes value. (Default: -2).
         """
         return pulumi.get(self, "log_local_retention_bytes")
 
@@ -8040,7 +8125,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logLocalRetentionMs")
     def log_local_retention_ms(self) -> Optional[int]:
         """
-        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.
+        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. (Default: -2).
         """
         return pulumi.get(self, "log_local_retention_ms")
 
@@ -8048,7 +8133,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logMessageDownconversionEnable")
     def log_message_downconversion_enable(self) -> Optional[bool]:
         """
-        This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
+        This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests. (Default: true).
         """
         return pulumi.get(self, "log_message_downconversion_enable")
 
@@ -8056,7 +8141,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logMessageTimestampDifferenceMaxMs")
     def log_message_timestamp_difference_max_ms(self) -> Optional[int]:
         """
-        The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message.
+        The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message (Default: 9223372036854775807 (Long.MAX_VALUE)).
         """
         return pulumi.get(self, "log_message_timestamp_difference_max_ms")
 
@@ -8064,7 +8149,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logMessageTimestampType")
     def log_message_timestamp_type(self) -> Optional[str]:
         """
-        Enum: `CreateTime`, `LogAppendTime`. 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. (Default: CreateTime).
         """
         return pulumi.get(self, "log_message_timestamp_type")
 
@@ -8072,7 +8157,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logPreallocate")
     def log_preallocate(self) -> Optional[bool]:
         """
-        Should pre allocate file when create new segment?
+        Should pre allocate file when create new segment? (Default: false).
         """
         return pulumi.get(self, "log_preallocate")
 
@@ -8080,7 +8165,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logRetentionBytes")
     def log_retention_bytes(self) -> Optional[int]:
         """
-        The maximum size of the log before deleting messages.
+        The maximum size of the log before deleting messages (Default: -1).
         """
         return pulumi.get(self, "log_retention_bytes")
 
@@ -8088,7 +8173,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logRetentionHours")
     def log_retention_hours(self) -> Optional[int]:
         """
-        The number of hours to keep a log file before deleting it.
+        The number of hours to keep a log file before deleting it (Default: 168 hours (1 week)).
         """
         return pulumi.get(self, "log_retention_hours")
 
@@ -8096,7 +8181,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logRetentionMs")
     def log_retention_ms(self) -> Optional[int]:
         """
-        The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied.
+        The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied. (Default: null, log.retention.hours applies).
         """
         return pulumi.get(self, "log_retention_ms")
 
@@ -8104,7 +8189,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logRollJitterMs")
     def log_roll_jitter_ms(self) -> Optional[int]:
         """
-        The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used.
+        The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used (Default: null).
         """
         return pulumi.get(self, "log_roll_jitter_ms")
 
@@ -8112,7 +8197,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logRollMs")
     def log_roll_ms(self) -> Optional[int]:
         """
-        The maximum time before a new log segment is rolled out (in milliseconds).
+        The maximum time before a new log segment is rolled out (in milliseconds). (Default: null, log.roll.hours applies (Default: 168, 7 days)).
         """
         return pulumi.get(self, "log_roll_ms")
 
@@ -8120,7 +8205,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logSegmentBytes")
     def log_segment_bytes(self) -> Optional[int]:
         """
-        The maximum size of a single log file.
+        The maximum size of a single log file (Default: 1073741824 bytes (1 gibibyte)).
         """
         return pulumi.get(self, "log_segment_bytes")
 
@@ -8128,7 +8213,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="logSegmentDeleteDelayMs")
     def log_segment_delete_delay_ms(self) -> Optional[int]:
         """
-        The amount of time to wait before deleting a file from the filesystem. Example: `60000`.
+        The amount of time to wait before deleting a file from the filesystem (Default: 60000 ms (1 minute)). Example: `60000`.
         """
         return pulumi.get(self, "log_segment_delete_delay_ms")
 
@@ -8136,7 +8221,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="maxConnectionsPerIp")
     def max_connections_per_ip(self) -> Optional[int]:
         """
-        The maximum number of connections allowed from each ip address (defaults to 2147483647).
+        The maximum number of connections allowed from each ip address (Default: 2147483647).
         """
         return pulumi.get(self, "max_connections_per_ip")
 
@@ -8144,7 +8229,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="maxIncrementalFetchSessionCacheSlots")
     def max_incremental_fetch_session_cache_slots(self) -> Optional[int]:
         """
-        The maximum number of incremental fetch sessions that the broker will maintain. Example: `1000`.
+        The maximum number of incremental fetch sessions that the broker will maintain. (Default: 1000). Example: `1000`.
         """
         return pulumi.get(self, "max_incremental_fetch_session_cache_slots")
 
@@ -8152,7 +8237,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="messageMaxBytes")
     def message_max_bytes(self) -> Optional[int]:
         """
-        The maximum size of message that the server can receive. Example: `1048588`.
+        The maximum size of message that the server can receive. (Default: 1048588 bytes (1 mebibyte + 12 bytes)). Example: `1048588`.
         """
         return pulumi.get(self, "message_max_bytes")
 
@@ -8160,7 +8245,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="minInsyncReplicas")
     def min_insync_replicas(self) -> Optional[int]:
         """
-        When a producer sets acks to `all` (or `-1`), min.insync.replicas specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. Example: `1`.
+        When a producer sets acks to `all` (or `-1`), min.insync.replicas specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. (Default: 1). Example: `1`.
         """
         return pulumi.get(self, "min_insync_replicas")
 
@@ -8168,7 +8253,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="numPartitions")
     def num_partitions(self) -> Optional[int]:
         """
-        Number of partitions for autocreated topics.
+        Number of partitions for auto-created topics (Default: 1).
         """
         return pulumi.get(self, "num_partitions")
 
@@ -8176,7 +8261,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="offsetsRetentionMinutes")
     def offsets_retention_minutes(self) -> Optional[int]:
         """
-        Log retention window in minutes for offsets topic. Example: `10080`.
+        Log retention window in minutes for offsets topic (Default: 10080 minutes (7 days)). Example: `10080`.
         """
         return pulumi.get(self, "offsets_retention_minutes")
 
@@ -8184,7 +8269,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="producerPurgatoryPurgeIntervalRequests")
     def producer_purgatory_purge_interval_requests(self) -> Optional[int]:
         """
-        The purge interval (in number of requests) of the producer request purgatory(defaults to 1000).
+        The purge interval (in number of requests) of the producer request purgatory (Default: 1000).
         """
         return pulumi.get(self, "producer_purgatory_purge_interval_requests")
 
@@ -8192,7 +8277,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="replicaFetchMaxBytes")
     def replica_fetch_max_bytes(self) -> Optional[int]:
         """
-        The number of bytes of messages to attempt to fetch for each partition (defaults to 1048576). This is not an absolute maximum, 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 progress can be made.
+        The number of bytes of messages to attempt to fetch for each partition . This is not an absolute maximum, 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 progress can be made. (Default: 1048576 bytes (1 mebibytes)).
         """
         return pulumi.get(self, "replica_fetch_max_bytes")
 
@@ -8200,7 +8285,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="replicaFetchResponseMaxBytes")
     def replica_fetch_response_max_bytes(self) -> Optional[int]:
         """
-        Maximum bytes expected for the entire fetch response (defaults to 10485760). Records are fetched in batches, 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 progress can be made. As such, this is not an absolute maximum.
+        Maximum bytes expected for the entire fetch response. Records are fetched in batches, 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 progress can be made. As such, this is not an absolute maximum. (Default: 10485760 bytes (10 mebibytes)).
         """
         return pulumi.get(self, "replica_fetch_response_max_bytes")
 
@@ -8208,7 +8293,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="saslOauthbearerExpectedAudience")
     def sasl_oauthbearer_expected_audience(self) -> Optional[str]:
         """
-        The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences.
+        The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences. (Default: null).
         """
         return pulumi.get(self, "sasl_oauthbearer_expected_audience")
 
@@ -8216,7 +8301,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="saslOauthbearerExpectedIssuer")
     def sasl_oauthbearer_expected_issuer(self) -> Optional[str]:
         """
-        Optional setting for the broker to use to verify that the JWT was created by the expected issuer.
+        Optional setting for the broker to use to verify that the JWT was created by the expected issuer.(Default: null).
         """
         return pulumi.get(self, "sasl_oauthbearer_expected_issuer")
 
@@ -8224,7 +8309,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="saslOauthbearerJwksEndpointUrl")
     def sasl_oauthbearer_jwks_endpoint_url(self) -> Optional[str]:
         """
-        OIDC JWKS endpoint URL. By setting this the SASL SSL OAuth2/OIDC authentication is enabled. See also other options for SASL OAuth2/OIDC.
+        OIDC JWKS endpoint URL. By setting this the SASL SSL OAuth2/OIDC authentication is enabled. See also other options for SASL OAuth2/OIDC. (Default: null).
         """
         return pulumi.get(self, "sasl_oauthbearer_jwks_endpoint_url")
 
@@ -8232,7 +8317,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="saslOauthbearerSubClaimName")
     def sasl_oauthbearer_sub_claim_name(self) -> Optional[str]:
         """
-        Name of the scope from which to extract the subject claim from the JWT. Defaults to sub.
+        Name of the scope from which to extract the subject claim from the JWT.(Default: sub).
         """
         return pulumi.get(self, "sasl_oauthbearer_sub_claim_name")
 
@@ -8240,7 +8325,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="socketRequestMaxBytes")
     def socket_request_max_bytes(self) -> Optional[int]:
         """
-        The maximum number of bytes in a socket request (defaults to 104857600).
+        The maximum number of bytes in a socket request (Default: 104857600 bytes).
         """
         return pulumi.get(self, "socket_request_max_bytes")
 
@@ -8248,7 +8333,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="transactionPartitionVerificationEnable")
     def transaction_partition_verification_enable(self) -> Optional[bool]:
         """
-        Enable verification that checks that the partition has been added to the transaction before writing transactional records to the partition.
+        Enable verification that checks that the partition has been added to the transaction before writing transactional records to the partition. (Default: true).
         """
         return pulumi.get(self, "transaction_partition_verification_enable")
 
@@ -8256,7 +8341,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="transactionRemoveExpiredTransactionCleanupIntervalMs")
     def transaction_remove_expired_transaction_cleanup_interval_ms(self) -> Optional[int]:
         """
-        The interval at which to remove transactions that have expired due to transactional.id.expiration.ms passing (defaults to 3600000 (1 hour)).
+        The interval at which to remove transactions that have expired due to transactional.id.expiration.ms passing (Default: 3600000 ms (1 hour)). Example: `3600000`.
         """
         return pulumi.get(self, "transaction_remove_expired_transaction_cleanup_interval_ms")
 
@@ -8264,7 +8349,7 @@ class KafkaKafkaUserConfigKafka(dict):
     @pulumi.getter(name="transactionStateLogSegmentBytes")
     def transaction_state_log_segment_bytes(self) -> Optional[int]:
         """
-        The transaction topic segment bytes should be kept relatively small in order to facilitate faster log compaction and cache loads (defaults to 104857600 (100 mebibytes)).
+        The transaction topic segment bytes should be kept relatively small in order to facilitate faster log compaction and cache loads (Default: 104857600 bytes (100 mebibytes)). Example: `104857600`.
         """
         return pulumi.get(self, "transaction_state_log_segment_bytes")
 
@@ -8896,6 +8981,68 @@ class KafkaKafkaUserConfigKafkaRestConfig(dict):
         return pulumi.get(self, "simpleconsumer_pool_size_max")
 
 
+@pulumi.output_type
+class KafkaKafkaUserConfigKafkaSaslMechanisms(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "scramSha256":
+            suggest = "scram_sha256"
+        elif key == "scramSha512":
+            suggest = "scram_sha512"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in KafkaKafkaUserConfigKafkaSaslMechanisms. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        KafkaKafkaUserConfigKafkaSaslMechanisms.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        KafkaKafkaUserConfigKafkaSaslMechanisms.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 plain: Optional[bool] = None,
+                 scram_sha256: Optional[bool] = None,
+                 scram_sha512: Optional[bool] = None):
+        """
+        :param bool plain: Enable PLAIN mechanism. Default: `true`.
+        :param bool scram_sha256: Enable SCRAM-SHA-256 mechanism. Default: `true`.
+        :param bool scram_sha512: Enable SCRAM-SHA-512 mechanism. Default: `true`.
+        """
+        if plain is not None:
+            pulumi.set(__self__, "plain", plain)
+        if scram_sha256 is not None:
+            pulumi.set(__self__, "scram_sha256", scram_sha256)
+        if scram_sha512 is not None:
+            pulumi.set(__self__, "scram_sha512", scram_sha512)
+
+    @property
+    @pulumi.getter
+    def plain(self) -> Optional[bool]:
+        """
+        Enable PLAIN mechanism. Default: `true`.
+        """
+        return pulumi.get(self, "plain")
+
+    @property
+    @pulumi.getter(name="scramSha256")
+    def scram_sha256(self) -> Optional[bool]:
+        """
+        Enable SCRAM-SHA-256 mechanism. Default: `true`.
+        """
+        return pulumi.get(self, "scram_sha256")
+
+    @property
+    @pulumi.getter(name="scramSha512")
+    def scram_sha512(self) -> Optional[bool]:
+        """
+        Enable SCRAM-SHA-512 mechanism. Default: `true`.
+        """
+        return pulumi.get(self, "scram_sha512")
+
+
 @pulumi.output_type
 class KafkaKafkaUserConfigPrivateAccess(dict):
     @staticmethod
@@ -9570,7 +9717,9 @@ class KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormaker(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "emitCheckpointsEnabled":
+        if key == "adminTimeoutMs":
+            suggest = "admin_timeout_ms"
+        elif key == "emitCheckpointsEnabled":
             suggest = "emit_checkpoints_enabled"
         elif key == "emitCheckpointsIntervalSeconds":
             suggest = "emit_checkpoints_interval_seconds"
@@ -9607,6 +9756,7 @@ class KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormaker(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 admin_timeout_ms: Optional[int] = None,
                  emit_checkpoints_enabled: Optional[bool] = None,
                  emit_checkpoints_interval_seconds: Optional[int] = None,
                  groups: Optional[str] = None,
@@ -9621,6 +9771,7 @@ class KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormaker(dict):
                  sync_topic_configs_enabled: Optional[bool] = None,
                  tasks_max_per_cpu: Optional[int] = None):
         """
+        :param int admin_timeout_ms: Timeout for administrative tasks, e.g. detecting new topics, loading of consumer group and offsets. Defaults to 60000 milliseconds (1 minute).
         :param bool emit_checkpoints_enabled: Whether to emit consumer group offset checkpoints to target cluster periodically (default: true).
         :param int emit_checkpoints_interval_seconds: Frequency at which consumer group offset checkpoints are emitted (default: 60, every minute). Example: `60`.
         :param str groups: Consumer groups to replicate. Supports comma-separated group IDs and regexes. Example: `.*`.
@@ -9635,6 +9786,8 @@ class KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormaker(dict):
         :param bool sync_topic_configs_enabled: Whether to periodically configure remote topics to match their corresponding upstream topics.
         :param int tasks_max_per_cpu: `tasks.max` is set to this multiplied by the number of CPUs in the service. Default: `1`.
         """
+        if admin_timeout_ms is not None:
+            pulumi.set(__self__, "admin_timeout_ms", admin_timeout_ms)
         if emit_checkpoints_enabled is not None:
             pulumi.set(__self__, "emit_checkpoints_enabled", emit_checkpoints_enabled)
         if emit_checkpoints_interval_seconds is not None:
@@ -9662,6 +9815,14 @@ class KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormaker(dict):
         if tasks_max_per_cpu is not None:
             pulumi.set(__self__, "tasks_max_per_cpu", tasks_max_per_cpu)
 
+    @property
+    @pulumi.getter(name="adminTimeoutMs")
+    def admin_timeout_ms(self) -> Optional[int]:
+        """
+        Timeout for administrative tasks, e.g. detecting new topics, loading of consumer group and offsets. Defaults to 60000 milliseconds (1 minute).
+        """
+        return pulumi.get(self, "admin_timeout_ms")
+
     @property
     @pulumi.getter(name="emitCheckpointsEnabled")
     def emit_checkpoints_enabled(self) -> Optional[bool]:
@@ -12714,6 +12875,8 @@ class MySqlMysqlUserConfigMigration(dict):
         suggest = None
         if key == "ignoreDbs":
             suggest = "ignore_dbs"
+        elif key == "ignoreRoles":
+            suggest = "ignore_roles"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in MySqlMysqlUserConfigMigration. Access the value via the '{suggest}' property getter instead.")
@@ -12731,6 +12894,7 @@ class MySqlMysqlUserConfigMigration(dict):
                  port: int,
                  dbname: Optional[str] = None,
                  ignore_dbs: Optional[str] = None,
+                 ignore_roles: Optional[str] = None,
                  method: Optional[str] = None,
                  password: Optional[str] = None,
                  ssl: Optional[bool] = None,
@@ -12740,6 +12904,7 @@ class MySqlMysqlUserConfigMigration(dict):
         :param int port: Port number of the server where to migrate data from. Example: `1234`.
         :param str dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
         :param str ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
+        :param str ignore_roles: Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
         :param str method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         :param str password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
         :param bool ssl: The server where to migrate data from is secured with SSL. Default: `true`.
@@ -12751,6 +12916,8 @@ class MySqlMysqlUserConfigMigration(dict):
             pulumi.set(__self__, "dbname", dbname)
         if ignore_dbs is not None:
             pulumi.set(__self__, "ignore_dbs", ignore_dbs)
+        if ignore_roles is not None:
+            pulumi.set(__self__, "ignore_roles", ignore_roles)
         if method is not None:
             pulumi.set(__self__, "method", method)
         if password is not None:
@@ -12792,6 +12959,14 @@ class MySqlMysqlUserConfigMigration(dict):
         """
         return pulumi.get(self, "ignore_dbs")
 
+    @property
+    @pulumi.getter(name="ignoreRoles")
+    def ignore_roles(self) -> Optional[str]:
+        """
+        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
+        """
+        return pulumi.get(self, "ignore_roles")
+
     @property
     @pulumi.getter
     def method(self) -> Optional[str]:
@@ -13706,12 +13881,18 @@ class OpenSearchOpensearchUserConfig(dict):
         suggest = None
         if key == "additionalBackupRegions":
             suggest = "additional_backup_regions"
+        elif key == "azureMigration":
+            suggest = "azure_migration"
         elif key == "customDomain":
             suggest = "custom_domain"
         elif key == "disableReplicationFactorAdjustment":
             suggest = "disable_replication_factor_adjustment"
+        elif key == "gcsMigration":
+            suggest = "gcs_migration"
         elif key == "indexPatterns":
             suggest = "index_patterns"
+        elif key == "indexRollup":
+            suggest = "index_rollup"
         elif key == "indexTemplate":
             suggest = "index_template"
         elif key == "ipFilterObjects":
@@ -13738,6 +13919,8 @@ class OpenSearchOpensearchUserConfig(dict):
             suggest = "public_access"
         elif key == "recoveryBasebackupName":
             suggest = "recovery_basebackup_name"
+        elif key == "s3Migration":
+            suggest = "s3_migration"
         elif key == "serviceLog":
             suggest = "service_log"
         elif key == "serviceToForkFrom":
@@ -13758,9 +13941,12 @@ class OpenSearchOpensearchUserConfig(dict):
 
     def __init__(__self__, *,
                  additional_backup_regions: Optional[str] = None,
+                 azure_migration: Optional['outputs.OpenSearchOpensearchUserConfigAzureMigration'] = None,
                  custom_domain: Optional[str] = None,
                  disable_replication_factor_adjustment: Optional[bool] = None,
+                 gcs_migration: Optional['outputs.OpenSearchOpensearchUserConfigGcsMigration'] = None,
                  index_patterns: Optional[Sequence['outputs.OpenSearchOpensearchUserConfigIndexPattern']] = None,
+                 index_rollup: Optional['outputs.OpenSearchOpensearchUserConfigIndexRollup'] = None,
                  index_template: Optional['outputs.OpenSearchOpensearchUserConfigIndexTemplate'] = None,
                  ip_filter_objects: Optional[Sequence['outputs.OpenSearchOpensearchUserConfigIpFilterObject']] = None,
                  ip_filter_strings: Optional[Sequence[str]] = None,
@@ -13776,6 +13962,7 @@ class OpenSearchOpensearchUserConfig(dict):
                  project_to_fork_from: Optional[str] = None,
                  public_access: Optional['outputs.OpenSearchOpensearchUserConfigPublicAccess'] = None,
                  recovery_basebackup_name: Optional[str] = None,
+                 s3_migration: Optional['outputs.OpenSearchOpensearchUserConfigS3Migration'] = None,
                  saml: Optional['outputs.OpenSearchOpensearchUserConfigSaml'] = None,
                  service_log: Optional[bool] = None,
                  service_to_fork_from: Optional[str] = None,
@@ -13785,6 +13972,7 @@ class OpenSearchOpensearchUserConfig(dict):
         :param str custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. Example: `grafana.example.org`.
         :param bool disable_replication_factor_adjustment: Disable automatic replication factor adjustment for multi-node services. By default, Aiven ensures all indexes are replicated at least to two nodes. Note: Due to potential data loss in case of losing a service node, this setting can no longer be activated.
         :param Sequence['OpenSearchOpensearchUserConfigIndexPatternArgs'] index_patterns: Index patterns
+        :param 'OpenSearchOpensearchUserConfigIndexRollupArgs' index_rollup: Index rollup settings
         :param 'OpenSearchOpensearchUserConfigIndexTemplateArgs' index_template: Template settings for all new indexes
         :param Sequence['OpenSearchOpensearchUserConfigIpFilterObjectArgs'] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
         :param Sequence[str] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
@@ -13807,12 +13995,18 @@ class OpenSearchOpensearchUserConfig(dict):
         """
         if additional_backup_regions is not None:
             pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
+        if azure_migration is not None:
+            pulumi.set(__self__, "azure_migration", azure_migration)
         if custom_domain is not None:
             pulumi.set(__self__, "custom_domain", custom_domain)
         if disable_replication_factor_adjustment is not None:
             pulumi.set(__self__, "disable_replication_factor_adjustment", disable_replication_factor_adjustment)
+        if gcs_migration is not None:
+            pulumi.set(__self__, "gcs_migration", gcs_migration)
         if index_patterns is not None:
             pulumi.set(__self__, "index_patterns", index_patterns)
+        if index_rollup is not None:
+            pulumi.set(__self__, "index_rollup", index_rollup)
         if index_template is not None:
             pulumi.set(__self__, "index_template", index_template)
         if ip_filter_objects is not None:
@@ -13843,6 +14037,8 @@ class OpenSearchOpensearchUserConfig(dict):
             pulumi.set(__self__, "public_access", public_access)
         if recovery_basebackup_name is not None:
             pulumi.set(__self__, "recovery_basebackup_name", recovery_basebackup_name)
+        if s3_migration is not None:
+            pulumi.set(__self__, "s3_migration", s3_migration)
         if saml is not None:
             pulumi.set(__self__, "saml", saml)
         if service_log is not None:
@@ -13860,6 +14056,11 @@ class OpenSearchOpensearchUserConfig(dict):
         """
         return pulumi.get(self, "additional_backup_regions")
 
+    @property
+    @pulumi.getter(name="azureMigration")
+    def azure_migration(self) -> Optional['outputs.OpenSearchOpensearchUserConfigAzureMigration']:
+        return pulumi.get(self, "azure_migration")
+
     @property
     @pulumi.getter(name="customDomain")
     def custom_domain(self) -> Optional[str]:
@@ -13876,6 +14077,11 @@ class OpenSearchOpensearchUserConfig(dict):
         """
         return pulumi.get(self, "disable_replication_factor_adjustment")
 
+    @property
+    @pulumi.getter(name="gcsMigration")
+    def gcs_migration(self) -> Optional['outputs.OpenSearchOpensearchUserConfigGcsMigration']:
+        return pulumi.get(self, "gcs_migration")
+
     @property
     @pulumi.getter(name="indexPatterns")
     def index_patterns(self) -> Optional[Sequence['outputs.OpenSearchOpensearchUserConfigIndexPattern']]:
@@ -13884,6 +14090,14 @@ class OpenSearchOpensearchUserConfig(dict):
         """
         return pulumi.get(self, "index_patterns")
 
+    @property
+    @pulumi.getter(name="indexRollup")
+    def index_rollup(self) -> Optional['outputs.OpenSearchOpensearchUserConfigIndexRollup']:
+        """
+        Index rollup settings
+        """
+        return pulumi.get(self, "index_rollup")
+
     @property
     @pulumi.getter(name="indexTemplate")
     def index_template(self) -> Optional['outputs.OpenSearchOpensearchUserConfigIndexTemplate']:
@@ -14005,6 +14219,11 @@ class OpenSearchOpensearchUserConfig(dict):
         """
         return pulumi.get(self, "recovery_basebackup_name")
 
+    @property
+    @pulumi.getter(name="s3Migration")
+    def s3_migration(self) -> Optional['outputs.OpenSearchOpensearchUserConfigS3Migration']:
+        return pulumi.get(self, "s3_migration")
+
     @property
     @pulumi.getter
     def saml(self) -> Optional['outputs.OpenSearchOpensearchUserConfigSaml']:
@@ -14038,6 +14257,238 @@ class OpenSearchOpensearchUserConfig(dict):
         return pulumi.get(self, "static_ips")
 
 
+@pulumi.output_type
+class OpenSearchOpensearchUserConfigAzureMigration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "basePath":
+            suggest = "base_path"
+        elif key == "snapshotName":
+            suggest = "snapshot_name"
+        elif key == "chunkSize":
+            suggest = "chunk_size"
+        elif key == "endpointSuffix":
+            suggest = "endpoint_suffix"
+        elif key == "sasToken":
+            suggest = "sas_token"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in OpenSearchOpensearchUserConfigAzureMigration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        OpenSearchOpensearchUserConfigAzureMigration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        OpenSearchOpensearchUserConfigAzureMigration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 account: str,
+                 base_path: str,
+                 container: str,
+                 snapshot_name: str,
+                 chunk_size: Optional[str] = None,
+                 compress: Optional[bool] = None,
+                 endpoint_suffix: Optional[str] = None,
+                 key: Optional[str] = None,
+                 sas_token: Optional[str] = None):
+        """
+        :param str account: Azure account name.
+        :param str base_path: The path to the repository data within its container. The value of this setting should not start or end with a /.
+        :param str container: Azure container name.
+        :param str snapshot_name: The snapshot name to restore from.
+        :param str chunk_size: Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
+        :param bool compress: When set to true metadata files are stored in compressed format.
+        :param str endpoint_suffix: Defines the DNS suffix for Azure Storage endpoints.
+        :param str key: Azure account secret key. One of key or sas_token should be specified.
+        :param str sas_token: A shared access signatures (SAS) token. One of key or sas_token should be specified.
+        """
+        pulumi.set(__self__, "account", account)
+        pulumi.set(__self__, "base_path", base_path)
+        pulumi.set(__self__, "container", container)
+        pulumi.set(__self__, "snapshot_name", snapshot_name)
+        if chunk_size is not None:
+            pulumi.set(__self__, "chunk_size", chunk_size)
+        if compress is not None:
+            pulumi.set(__self__, "compress", compress)
+        if endpoint_suffix is not None:
+            pulumi.set(__self__, "endpoint_suffix", endpoint_suffix)
+        if key is not None:
+            pulumi.set(__self__, "key", key)
+        if sas_token is not None:
+            pulumi.set(__self__, "sas_token", sas_token)
+
+    @property
+    @pulumi.getter
+    def account(self) -> str:
+        """
+        Azure account name.
+        """
+        return pulumi.get(self, "account")
+
+    @property
+    @pulumi.getter(name="basePath")
+    def base_path(self) -> str:
+        """
+        The path to the repository data within its container. The value of this setting should not start or end with a /.
+        """
+        return pulumi.get(self, "base_path")
+
+    @property
+    @pulumi.getter
+    def container(self) -> str:
+        """
+        Azure container name.
+        """
+        return pulumi.get(self, "container")
+
+    @property
+    @pulumi.getter(name="snapshotName")
+    def snapshot_name(self) -> str:
+        """
+        The snapshot name to restore from.
+        """
+        return pulumi.get(self, "snapshot_name")
+
+    @property
+    @pulumi.getter(name="chunkSize")
+    def chunk_size(self) -> Optional[str]:
+        """
+        Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
+        """
+        return pulumi.get(self, "chunk_size")
+
+    @property
+    @pulumi.getter
+    def compress(self) -> Optional[bool]:
+        """
+        When set to true metadata files are stored in compressed format.
+        """
+        return pulumi.get(self, "compress")
+
+    @property
+    @pulumi.getter(name="endpointSuffix")
+    def endpoint_suffix(self) -> Optional[str]:
+        """
+        Defines the DNS suffix for Azure Storage endpoints.
+        """
+        return pulumi.get(self, "endpoint_suffix")
+
+    @property
+    @pulumi.getter
+    def key(self) -> Optional[str]:
+        """
+        Azure account secret key. One of key or sas_token should be specified.
+        """
+        return pulumi.get(self, "key")
+
+    @property
+    @pulumi.getter(name="sasToken")
+    def sas_token(self) -> Optional[str]:
+        """
+        A shared access signatures (SAS) token. One of key or sas_token should be specified.
+        """
+        return pulumi.get(self, "sas_token")
+
+
+@pulumi.output_type
+class OpenSearchOpensearchUserConfigGcsMigration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "basePath":
+            suggest = "base_path"
+        elif key == "snapshotName":
+            suggest = "snapshot_name"
+        elif key == "chunkSize":
+            suggest = "chunk_size"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in OpenSearchOpensearchUserConfigGcsMigration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        OpenSearchOpensearchUserConfigGcsMigration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        OpenSearchOpensearchUserConfigGcsMigration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 base_path: str,
+                 bucket: str,
+                 credentials: str,
+                 snapshot_name: str,
+                 chunk_size: Optional[str] = None,
+                 compress: Optional[bool] = None):
+        """
+        :param str base_path: The path to the repository data within its container. The value of this setting should not start or end with a /.
+        :param str bucket: The path to the repository data within its container.
+        :param str credentials: Google Cloud Storage credentials file content.
+        :param str snapshot_name: The snapshot name to restore from.
+        :param str chunk_size: Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
+        :param bool compress: When set to true metadata files are stored in compressed format.
+        """
+        pulumi.set(__self__, "base_path", base_path)
+        pulumi.set(__self__, "bucket", bucket)
+        pulumi.set(__self__, "credentials", credentials)
+        pulumi.set(__self__, "snapshot_name", snapshot_name)
+        if chunk_size is not None:
+            pulumi.set(__self__, "chunk_size", chunk_size)
+        if compress is not None:
+            pulumi.set(__self__, "compress", compress)
+
+    @property
+    @pulumi.getter(name="basePath")
+    def base_path(self) -> str:
+        """
+        The path to the repository data within its container. The value of this setting should not start or end with a /.
+        """
+        return pulumi.get(self, "base_path")
+
+    @property
+    @pulumi.getter
+    def bucket(self) -> str:
+        """
+        The path to the repository data within its container.
+        """
+        return pulumi.get(self, "bucket")
+
+    @property
+    @pulumi.getter
+    def credentials(self) -> str:
+        """
+        Google Cloud Storage credentials file content.
+        """
+        return pulumi.get(self, "credentials")
+
+    @property
+    @pulumi.getter(name="snapshotName")
+    def snapshot_name(self) -> str:
+        """
+        The snapshot name to restore from.
+        """
+        return pulumi.get(self, "snapshot_name")
+
+    @property
+    @pulumi.getter(name="chunkSize")
+    def chunk_size(self) -> Optional[str]:
+        """
+        Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
+        """
+        return pulumi.get(self, "chunk_size")
+
+    @property
+    @pulumi.getter
+    def compress(self) -> Optional[bool]:
+        """
+        When set to true metadata files are stored in compressed format.
+        """
+        return pulumi.get(self, "compress")
+
+
 @pulumi.output_type
 class OpenSearchOpensearchUserConfigIndexPattern(dict):
     @staticmethod
@@ -14098,6 +14549,98 @@ class OpenSearchOpensearchUserConfigIndexPattern(dict):
         return pulumi.get(self, "sorting_algorithm")
 
 
+@pulumi.output_type
+class OpenSearchOpensearchUserConfigIndexRollup(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "rollupDashboardsEnabled":
+            suggest = "rollup_dashboards_enabled"
+        elif key == "rollupEnabled":
+            suggest = "rollup_enabled"
+        elif key == "rollupSearchBackoffCount":
+            suggest = "rollup_search_backoff_count"
+        elif key == "rollupSearchBackoffMillis":
+            suggest = "rollup_search_backoff_millis"
+        elif key == "rollupSearchSearchAllJobs":
+            suggest = "rollup_search_search_all_jobs"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in OpenSearchOpensearchUserConfigIndexRollup. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        OpenSearchOpensearchUserConfigIndexRollup.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        OpenSearchOpensearchUserConfigIndexRollup.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 rollup_dashboards_enabled: Optional[bool] = None,
+                 rollup_enabled: Optional[bool] = None,
+                 rollup_search_backoff_count: Optional[int] = None,
+                 rollup_search_backoff_millis: Optional[int] = None,
+                 rollup_search_search_all_jobs: Optional[bool] = None):
+        """
+        :param bool rollup_dashboards_enabled: Whether rollups are enabled in OpenSearch Dashboards. Defaults to true.
+        :param bool rollup_enabled: Whether the rollup plugin is enabled. Defaults to true.
+        :param int rollup_search_backoff_count: How many retries the plugin should attempt for failed rollup jobs. Defaults to 5.
+        :param int rollup_search_backoff_millis: The backoff time between retries for failed rollup jobs. Defaults to 1000ms.
+        :param bool rollup_search_search_all_jobs: Whether OpenSearch should return all jobs that match all specified search terms. If disabled, OpenSearch returns just one, as opposed to all, of the jobs that matches the search terms. Defaults to false.
+        """
+        if rollup_dashboards_enabled is not None:
+            pulumi.set(__self__, "rollup_dashboards_enabled", rollup_dashboards_enabled)
+        if rollup_enabled is not None:
+            pulumi.set(__self__, "rollup_enabled", rollup_enabled)
+        if rollup_search_backoff_count is not None:
+            pulumi.set(__self__, "rollup_search_backoff_count", rollup_search_backoff_count)
+        if rollup_search_backoff_millis is not None:
+            pulumi.set(__self__, "rollup_search_backoff_millis", rollup_search_backoff_millis)
+        if rollup_search_search_all_jobs is not None:
+            pulumi.set(__self__, "rollup_search_search_all_jobs", rollup_search_search_all_jobs)
+
+    @property
+    @pulumi.getter(name="rollupDashboardsEnabled")
+    def rollup_dashboards_enabled(self) -> Optional[bool]:
+        """
+        Whether rollups are enabled in OpenSearch Dashboards. Defaults to true.
+        """
+        return pulumi.get(self, "rollup_dashboards_enabled")
+
+    @property
+    @pulumi.getter(name="rollupEnabled")
+    def rollup_enabled(self) -> Optional[bool]:
+        """
+        Whether the rollup plugin is enabled. Defaults to true.
+        """
+        return pulumi.get(self, "rollup_enabled")
+
+    @property
+    @pulumi.getter(name="rollupSearchBackoffCount")
+    def rollup_search_backoff_count(self) -> Optional[int]:
+        """
+        How many retries the plugin should attempt for failed rollup jobs. Defaults to 5.
+        """
+        return pulumi.get(self, "rollup_search_backoff_count")
+
+    @property
+    @pulumi.getter(name="rollupSearchBackoffMillis")
+    def rollup_search_backoff_millis(self) -> Optional[int]:
+        """
+        The backoff time between retries for failed rollup jobs. Defaults to 1000ms.
+        """
+        return pulumi.get(self, "rollup_search_backoff_millis")
+
+    @property
+    @pulumi.getter(name="rollupSearchSearchAllJobs")
+    def rollup_search_search_all_jobs(self) -> Optional[bool]:
+        """
+        Whether OpenSearch should return all jobs that match all specified search terms. If disabled, OpenSearch returns just one, as opposed to all, of the jobs that matches the search terms. Defaults to false.
+        """
+        return pulumi.get(self, "rollup_search_search_all_jobs")
+
+
 @pulumi.output_type
 class OpenSearchOpensearchUserConfigIndexTemplate(dict):
     @staticmethod
@@ -14241,8 +14784,8 @@ class OpenSearchOpensearchUserConfigOpenid(dict):
                  scope: Optional[str] = None,
                  subject_key: Optional[str] = None):
         """
-        :param str client_id: The ID of the OpenID Connect client configured in your IdP. Required. Example: ``.
-        :param str client_secret: The client secret of the OpenID Connect client configured in your IdP. Required. Example: ``.
+        :param str client_id: The ID of the OpenID Connect client configured in your IdP. Required.
+        :param str client_secret: The client secret of the OpenID Connect client configured in your IdP. Required.
         :param str connect_url: The URL of your IdP where the Security plugin can find the OpenID Connect metadata/configuration settings. Example: `https://test-account.okta.com/app/exk491jujcVc83LEX697/sso/saml/metadata`.
         :param bool enabled: Enables or disables OpenID Connect authentication for OpenSearch. When enabled, users can authenticate using OpenID Connect with an Identity Provider. Default: `true`.
         :param str header: HTTP header name of the JWT token. Optional. Default is Authorization. Default: `Authorization`.
@@ -14251,7 +14794,7 @@ class OpenSearchOpensearchUserConfigOpenid(dict):
         :param int refresh_rate_limit_count: The maximum number of unknown key IDs in the time frame. Default is 10. Optional. Default: `10`.
         :param int refresh_rate_limit_time_window_ms: The time frame to use when checking the maximum number of unknown key IDs, in milliseconds. Optional.Default is 10000 (10 seconds). Default: `10000`.
         :param str roles_key: The key in the JSON payload that stores the user’s roles. The value of this key must be a comma-separated list of roles. Required only if you want to use roles in the JWT. Example: `roles`.
-        :param str scope: The scope of the identity token issued by the IdP. Optional. Default is openid profile email address phone. Example: ``.
+        :param str scope: The scope of the identity token issued by the IdP. Optional. Default is openid profile email address phone.
         :param str subject_key: The key in the JSON payload that stores the user’s name. If not defined, the subject registered claim is used. Most IdP providers use the preferred_username claim. Optional. Example: `preferred_username`.
         """
         pulumi.set(__self__, "client_id", client_id)
@@ -14279,7 +14822,7 @@ class OpenSearchOpensearchUserConfigOpenid(dict):
     @pulumi.getter(name="clientId")
     def client_id(self) -> str:
         """
-        The ID of the OpenID Connect client configured in your IdP. Required. Example: ``.
+        The ID of the OpenID Connect client configured in your IdP. Required.
         """
         return pulumi.get(self, "client_id")
 
@@ -14287,7 +14830,7 @@ class OpenSearchOpensearchUserConfigOpenid(dict):
     @pulumi.getter(name="clientSecret")
     def client_secret(self) -> str:
         """
-        The client secret of the OpenID Connect client configured in your IdP. Required. Example: ``.
+        The client secret of the OpenID Connect client configured in your IdP. Required.
         """
         return pulumi.get(self, "client_secret")
 
@@ -14359,7 +14902,7 @@ class OpenSearchOpensearchUserConfigOpenid(dict):
     @pulumi.getter
     def scope(self) -> Optional[str]:
         """
-        The scope of the identity token issued by the IdP. Optional. Default is openid profile email address phone. Example: ``.
+        The scope of the identity token issued by the IdP. Optional. Default is openid profile email address phone.
         """
         return pulumi.get(self, "scope")
 
@@ -14531,7 +15074,7 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
         :param str email_sender_name: Sender name placeholder to be used in Opensearch Dashboards and Opensearch keystore. Example: `alert-sender`.
         :param str email_sender_password: Sender password for Opensearch alerts to authenticate with SMTP server. Example: `very-secure-mail-password`.
         :param str email_sender_username: Sender username for Opensearch alerts. Example: `jane@example.com`.
-        :param bool enable_security_audit: Enable/Disable security audit. Default: `false`.
+        :param bool enable_security_audit: Enable/Disable security audit.
         :param int http_max_content_length: Maximum content length for HTTP requests to the OpenSearch HTTP API, in bytes.
         :param int http_max_header_size: The max size of allowed headers, in bytes. Example: `8192`.
         :param int http_max_initial_line_length: The max length of an HTTP URL, in bytes. Example: `4096`.
@@ -14543,14 +15086,14 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
         :param int indices_query_bool_max_clause_count: Maximum number of clauses Lucene BooleanQuery can have. The default value (1024) is relatively high, and increasing it may cause performance issues. Investigate other approaches first before increasing this value.
         :param int indices_recovery_max_bytes_per_sec: Limits total inbound and outbound recovery traffic for each node. Applies to both peer recoveries as well as snapshot recoveries (i.e., restores from a snapshot). Defaults to 40mb.
         :param int indices_recovery_max_concurrent_file_chunks: Number of file chunks sent in parallel for each recovery. Defaults to 2.
-        :param bool ism_enabled: Specifies whether ISM is enabled or not. Default: `true`.
-        :param bool ism_history_enabled: Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document. Default: `true`.
-        :param int ism_history_max_age: The maximum age before rolling over the audit history index in hours. Default: `24`.
-        :param int ism_history_max_docs: The maximum number of documents before rolling over the audit history index. Default: `2500000`.
-        :param int ism_history_rollover_check_period: The time between rollover checks for the audit history index in hours. Default: `8`.
-        :param int ism_history_rollover_retention_period: How long audit history indices are kept in days. Default: `30`.
-        :param bool knn_memory_circuit_breaker_enabled: Enable or disable KNN memory circuit breaker. Defaults to true. Default: `true`.
-        :param int knn_memory_circuit_breaker_limit: Maximum amount of memory that can be used for KNN index. Defaults to 50% of the JVM heap size. Default: `50`.
+        :param bool ism_enabled: Specifies whether ISM is enabled or not.
+        :param bool ism_history_enabled: Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document.
+        :param int ism_history_max_age: The maximum age before rolling over the audit history index in hours. Example: `24`.
+        :param int ism_history_max_docs: The maximum number of documents before rolling over the audit history index. Example: `2500000`.
+        :param int ism_history_rollover_check_period: The time between rollover checks for the audit history index in hours. Example: `8`.
+        :param int ism_history_rollover_retention_period: How long audit history indices are kept in days. Example: `30`.
+        :param bool knn_memory_circuit_breaker_enabled: Enable or disable KNN memory circuit breaker. Defaults to true.
+        :param int knn_memory_circuit_breaker_limit: Maximum amount of memory that can be used for KNN index. Defaults to 50% of the JVM heap size.
         :param bool override_main_response_version: Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default is false.
         :param bool plugins_alerting_filter_by_backend_roles: Enable or disable filtering of alerting by backend roles. Requires Security plugin. Defaults to false.
         :param Sequence[str] reindex_remote_whitelists: Whitelisted addresses for reindexing. Changing this value will cause all OpenSearch instances to restart.
@@ -14725,7 +15268,7 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
     @pulumi.getter(name="enableSecurityAudit")
     def enable_security_audit(self) -> Optional[bool]:
         """
-        Enable/Disable security audit. Default: `false`.
+        Enable/Disable security audit.
         """
         return pulumi.get(self, "enable_security_audit")
 
@@ -14821,7 +15364,7 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
     @pulumi.getter(name="ismEnabled")
     def ism_enabled(self) -> Optional[bool]:
         """
-        Specifies whether ISM is enabled or not. Default: `true`.
+        Specifies whether ISM is enabled or not.
         """
         return pulumi.get(self, "ism_enabled")
 
@@ -14829,7 +15372,7 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
     @pulumi.getter(name="ismHistoryEnabled")
     def ism_history_enabled(self) -> Optional[bool]:
         """
-        Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document. Default: `true`.
+        Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document.
         """
         return pulumi.get(self, "ism_history_enabled")
 
@@ -14837,7 +15380,7 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
     @pulumi.getter(name="ismHistoryMaxAge")
     def ism_history_max_age(self) -> Optional[int]:
         """
-        The maximum age before rolling over the audit history index in hours. Default: `24`.
+        The maximum age before rolling over the audit history index in hours. Example: `24`.
         """
         return pulumi.get(self, "ism_history_max_age")
 
@@ -14845,7 +15388,7 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
     @pulumi.getter(name="ismHistoryMaxDocs")
     def ism_history_max_docs(self) -> Optional[int]:
         """
-        The maximum number of documents before rolling over the audit history index. Default: `2500000`.
+        The maximum number of documents before rolling over the audit history index. Example: `2500000`.
         """
         return pulumi.get(self, "ism_history_max_docs")
 
@@ -14853,7 +15396,7 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
     @pulumi.getter(name="ismHistoryRolloverCheckPeriod")
     def ism_history_rollover_check_period(self) -> Optional[int]:
         """
-        The time between rollover checks for the audit history index in hours. Default: `8`.
+        The time between rollover checks for the audit history index in hours. Example: `8`.
         """
         return pulumi.get(self, "ism_history_rollover_check_period")
 
@@ -14861,7 +15404,7 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
     @pulumi.getter(name="ismHistoryRolloverRetentionPeriod")
     def ism_history_rollover_retention_period(self) -> Optional[int]:
         """
-        How long audit history indices are kept in days. Default: `30`.
+        How long audit history indices are kept in days. Example: `30`.
         """
         return pulumi.get(self, "ism_history_rollover_retention_period")
 
@@ -14869,7 +15412,7 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
     @pulumi.getter(name="knnMemoryCircuitBreakerEnabled")
     def knn_memory_circuit_breaker_enabled(self) -> Optional[bool]:
         """
-        Enable or disable KNN memory circuit breaker. Defaults to true. Default: `true`.
+        Enable or disable KNN memory circuit breaker. Defaults to true.
         """
         return pulumi.get(self, "knn_memory_circuit_breaker_enabled")
 
@@ -14877,7 +15420,7 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
     @pulumi.getter(name="knnMemoryCircuitBreakerLimit")
     def knn_memory_circuit_breaker_limit(self) -> Optional[int]:
         """
-        Maximum amount of memory that can be used for KNN index. Defaults to 50% of the JVM heap size. Default: `50`.
+        Maximum amount of memory that can be used for KNN index. Defaults to 50% of the JVM heap size.
         """
         return pulumi.get(self, "knn_memory_circuit_breaker_limit")
 
@@ -15520,6 +16063,154 @@ class OpenSearchOpensearchUserConfigPublicAccess(dict):
         return pulumi.get(self, "prometheus")
 
 
+@pulumi.output_type
+class OpenSearchOpensearchUserConfigS3Migration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "accessKey":
+            suggest = "access_key"
+        elif key == "basePath":
+            suggest = "base_path"
+        elif key == "secretKey":
+            suggest = "secret_key"
+        elif key == "snapshotName":
+            suggest = "snapshot_name"
+        elif key == "chunkSize":
+            suggest = "chunk_size"
+        elif key == "serverSideEncryption":
+            suggest = "server_side_encryption"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in OpenSearchOpensearchUserConfigS3Migration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        OpenSearchOpensearchUserConfigS3Migration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        OpenSearchOpensearchUserConfigS3Migration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 access_key: str,
+                 base_path: str,
+                 bucket: str,
+                 region: str,
+                 secret_key: str,
+                 snapshot_name: str,
+                 chunk_size: Optional[str] = None,
+                 compress: Optional[bool] = None,
+                 endpoint: Optional[str] = None,
+                 server_side_encryption: Optional[bool] = None):
+        """
+        :param str access_key: AWS Access key.
+        :param str base_path: The path to the repository data within its container. The value of this setting should not start or end with a /.
+        :param str bucket: S3 bucket name.
+        :param str region: S3 region.
+        :param str secret_key: AWS secret key.
+        :param str snapshot_name: The snapshot name to restore from.
+        :param str chunk_size: Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
+        :param bool compress: When set to true metadata files are stored in compressed format.
+        :param str endpoint: The S3 service endpoint to connect to. If you are using an S3-compatible service then you should set this to the service’s endpoint.
+        :param bool server_side_encryption: When set to true files are encrypted on server side.
+        """
+        pulumi.set(__self__, "access_key", access_key)
+        pulumi.set(__self__, "base_path", base_path)
+        pulumi.set(__self__, "bucket", bucket)
+        pulumi.set(__self__, "region", region)
+        pulumi.set(__self__, "secret_key", secret_key)
+        pulumi.set(__self__, "snapshot_name", snapshot_name)
+        if chunk_size is not None:
+            pulumi.set(__self__, "chunk_size", chunk_size)
+        if compress is not None:
+            pulumi.set(__self__, "compress", compress)
+        if endpoint is not None:
+            pulumi.set(__self__, "endpoint", endpoint)
+        if server_side_encryption is not None:
+            pulumi.set(__self__, "server_side_encryption", server_side_encryption)
+
+    @property
+    @pulumi.getter(name="accessKey")
+    def access_key(self) -> str:
+        """
+        AWS Access key.
+        """
+        return pulumi.get(self, "access_key")
+
+    @property
+    @pulumi.getter(name="basePath")
+    def base_path(self) -> str:
+        """
+        The path to the repository data within its container. The value of this setting should not start or end with a /.
+        """
+        return pulumi.get(self, "base_path")
+
+    @property
+    @pulumi.getter
+    def bucket(self) -> str:
+        """
+        S3 bucket name.
+        """
+        return pulumi.get(self, "bucket")
+
+    @property
+    @pulumi.getter
+    def region(self) -> str:
+        """
+        S3 region.
+        """
+        return pulumi.get(self, "region")
+
+    @property
+    @pulumi.getter(name="secretKey")
+    def secret_key(self) -> str:
+        """
+        AWS secret key.
+        """
+        return pulumi.get(self, "secret_key")
+
+    @property
+    @pulumi.getter(name="snapshotName")
+    def snapshot_name(self) -> str:
+        """
+        The snapshot name to restore from.
+        """
+        return pulumi.get(self, "snapshot_name")
+
+    @property
+    @pulumi.getter(name="chunkSize")
+    def chunk_size(self) -> Optional[str]:
+        """
+        Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
+        """
+        return pulumi.get(self, "chunk_size")
+
+    @property
+    @pulumi.getter
+    def compress(self) -> Optional[bool]:
+        """
+        When set to true metadata files are stored in compressed format.
+        """
+        return pulumi.get(self, "compress")
+
+    @property
+    @pulumi.getter
+    def endpoint(self) -> Optional[str]:
+        """
+        The S3 service endpoint to connect to. If you are using an S3-compatible service then you should set this to the service’s endpoint.
+        """
+        return pulumi.get(self, "endpoint")
+
+    @property
+    @pulumi.getter(name="serverSideEncryption")
+    def server_side_encryption(self) -> Optional[bool]:
+        """
+        When set to true files are encrypted on server side.
+        """
+        return pulumi.get(self, "server_side_encryption")
+
+
 @pulumi.output_type
 class OpenSearchOpensearchUserConfigSaml(dict):
     @staticmethod
@@ -16063,20 +16754,20 @@ class PgPg(dict):
                  uris: Optional[Sequence[str]] = None,
                  user: Optional[str] = None):
         """
-        :param str bouncer: Bouncer connection details
-        :param str dbname: Primary PostgreSQL database name
-        :param str host: PostgreSQL master node host IP or name
-        :param int max_connections: Connection limit
-        :param Sequence['PgPgParamArgs'] params: PostgreSQL connection parameters
-        :param str password: PostgreSQL admin user password
-        :param int port: PostgreSQL port
-        :param str replica_uri: PostgreSQL replica URI for services with a replica
-        :param str sslmode: PostgreSQL sslmode setting (currently always "require")
-        :param Sequence[str] standby_uris: PostgreSQL standby connection URIs
-        :param Sequence[str] syncing_uris: PostgreSQL syncing connection URIs
-        :param str uri: PostgreSQL master connection URI
-        :param Sequence[str] uris: PostgreSQL master connection URIs
-        :param str user: PostgreSQL admin user name
+        :param str bouncer: PgBouncer connection details for [connection pooling](https://aiven.io/docs/products/postgresql/concepts/pg-connection-pooling).
+        :param str dbname: Primary PostgreSQL database name.
+        :param str host: PostgreSQL primary node host IP or name.
+        :param int max_connections: The [number of allowed connections](https://aiven.io/docs/products/postgresql/reference/pg-connection-limits). Varies based on the service plan.
+        :param Sequence['PgPgParamArgs'] params: PostgreSQL connection parameters.
+        :param str password: PostgreSQL admin user password.
+        :param int port: PostgreSQL port.
+        :param str replica_uri: PostgreSQL replica URI for services with a replica.
+        :param str sslmode: PostgreSQL SSL mode setting.
+        :param Sequence[str] standby_uris: PostgreSQL standby connection URIs.
+        :param Sequence[str] syncing_uris: PostgreSQL syncing connection URIs.
+        :param str uri: PostgreSQL primary connection URI.
+        :param Sequence[str] uris: PostgreSQL primary connection URIs.
+        :param str user: PostgreSQL admin user name.
         """
         if bouncer is not None:
             pulumi.set(__self__, "bouncer", bouncer)
@@ -16111,7 +16802,7 @@ class PgPg(dict):
     @pulumi.getter
     def bouncer(self) -> Optional[str]:
         """
-        Bouncer connection details
+        PgBouncer connection details for [connection pooling](https://aiven.io/docs/products/postgresql/concepts/pg-connection-pooling).
         """
         return pulumi.get(self, "bouncer")
 
@@ -16119,7 +16810,7 @@ class PgPg(dict):
     @pulumi.getter
     def dbname(self) -> Optional[str]:
         """
-        Primary PostgreSQL database name
+        Primary PostgreSQL database name.
         """
         return pulumi.get(self, "dbname")
 
@@ -16127,7 +16818,7 @@ class PgPg(dict):
     @pulumi.getter
     def host(self) -> Optional[str]:
         """
-        PostgreSQL master node host IP or name
+        PostgreSQL primary node host IP or name.
         """
         return pulumi.get(self, "host")
 
@@ -16135,7 +16826,7 @@ class PgPg(dict):
     @pulumi.getter(name="maxConnections")
     def max_connections(self) -> Optional[int]:
         """
-        Connection limit
+        The [number of allowed connections](https://aiven.io/docs/products/postgresql/reference/pg-connection-limits). Varies based on the service plan.
         """
         return pulumi.get(self, "max_connections")
 
@@ -16143,7 +16834,7 @@ class PgPg(dict):
     @pulumi.getter
     def params(self) -> Optional[Sequence['outputs.PgPgParam']]:
         """
-        PostgreSQL connection parameters
+        PostgreSQL connection parameters.
         """
         return pulumi.get(self, "params")
 
@@ -16151,7 +16842,7 @@ class PgPg(dict):
     @pulumi.getter
     def password(self) -> Optional[str]:
         """
-        PostgreSQL admin user password
+        PostgreSQL admin user password.
         """
         return pulumi.get(self, "password")
 
@@ -16159,7 +16850,7 @@ class PgPg(dict):
     @pulumi.getter
     def port(self) -> Optional[int]:
         """
-        PostgreSQL port
+        PostgreSQL port.
         """
         return pulumi.get(self, "port")
 
@@ -16167,7 +16858,7 @@ class PgPg(dict):
     @pulumi.getter(name="replicaUri")
     def replica_uri(self) -> Optional[str]:
         """
-        PostgreSQL replica URI for services with a replica
+        PostgreSQL replica URI for services with a replica.
         """
         return pulumi.get(self, "replica_uri")
 
@@ -16175,7 +16866,7 @@ class PgPg(dict):
     @pulumi.getter
     def sslmode(self) -> Optional[str]:
         """
-        PostgreSQL sslmode setting (currently always "require")
+        PostgreSQL SSL mode setting.
         """
         return pulumi.get(self, "sslmode")
 
@@ -16183,7 +16874,7 @@ class PgPg(dict):
     @pulumi.getter(name="standbyUris")
     def standby_uris(self) -> Optional[Sequence[str]]:
         """
-        PostgreSQL standby connection URIs
+        PostgreSQL standby connection URIs.
         """
         return pulumi.get(self, "standby_uris")
 
@@ -16191,7 +16882,7 @@ class PgPg(dict):
     @pulumi.getter(name="syncingUris")
     def syncing_uris(self) -> Optional[Sequence[str]]:
         """
-        PostgreSQL syncing connection URIs
+        PostgreSQL syncing connection URIs.
         """
         return pulumi.get(self, "syncing_uris")
 
@@ -16199,7 +16890,7 @@ class PgPg(dict):
     @pulumi.getter
     def uri(self) -> Optional[str]:
         """
-        PostgreSQL master connection URI
+        PostgreSQL primary connection URI.
         """
         return pulumi.get(self, "uri")
 
@@ -16207,7 +16898,7 @@ class PgPg(dict):
     @pulumi.getter
     def uris(self) -> Optional[Sequence[str]]:
         """
-        PostgreSQL master connection URIs
+        PostgreSQL primary connection URIs.
         """
         return pulumi.get(self, "uris")
 
@@ -16215,7 +16906,7 @@ class PgPg(dict):
     @pulumi.getter
     def user(self) -> Optional[str]:
         """
-        PostgreSQL admin user name
+        PostgreSQL admin user name.
         """
         return pulumi.get(self, "user")
 
@@ -16247,12 +16938,12 @@ class PgPgParam(dict):
                  sslmode: Optional[str] = None,
                  user: Optional[str] = None):
         """
-        :param str database_name: Primary PostgreSQL database name
-        :param str host: PostgreSQL host IP or name
-        :param str password: PostgreSQL admin user password
-        :param int port: PostgreSQL port
-        :param str sslmode: PostgreSQL sslmode setting (currently always "require")
-        :param str user: PostgreSQL admin user name
+        :param str database_name: Primary PostgreSQL database name.
+        :param str host: PostgreSQL host IP or name.
+        :param str password: PostgreSQL admin user password.
+        :param int port: PostgreSQL port.
+        :param str sslmode: PostgreSQL SSL mode setting.
+        :param str user: PostgreSQL admin user name.
         """
         if database_name is not None:
             pulumi.set(__self__, "database_name", database_name)
@@ -16271,7 +16962,7 @@ class PgPgParam(dict):
     @pulumi.getter(name="databaseName")
     def database_name(self) -> Optional[str]:
         """
-        Primary PostgreSQL database name
+        Primary PostgreSQL database name.
         """
         return pulumi.get(self, "database_name")
 
@@ -16279,7 +16970,7 @@ class PgPgParam(dict):
     @pulumi.getter
     def host(self) -> Optional[str]:
         """
-        PostgreSQL host IP or name
+        PostgreSQL host IP or name.
         """
         return pulumi.get(self, "host")
 
@@ -16287,7 +16978,7 @@ class PgPgParam(dict):
     @pulumi.getter
     def password(self) -> Optional[str]:
         """
-        PostgreSQL admin user password
+        PostgreSQL admin user password.
         """
         return pulumi.get(self, "password")
 
@@ -16295,7 +16986,7 @@ class PgPgParam(dict):
     @pulumi.getter
     def port(self) -> Optional[int]:
         """
-        PostgreSQL port
+        PostgreSQL port.
         """
         return pulumi.get(self, "port")
 
@@ -16303,7 +16994,7 @@ class PgPgParam(dict):
     @pulumi.getter
     def sslmode(self) -> Optional[str]:
         """
-        PostgreSQL sslmode setting (currently always "require")
+        PostgreSQL SSL mode setting.
         """
         return pulumi.get(self, "sslmode")
 
@@ -16311,7 +17002,7 @@ class PgPgParam(dict):
     @pulumi.getter
     def user(self) -> Optional[str]:
         """
-        PostgreSQL admin user name
+        PostgreSQL admin user name.
         """
         return pulumi.get(self, "user")
 
@@ -16812,6 +17503,8 @@ class PgPgUserConfigMigration(dict):
         suggest = None
         if key == "ignoreDbs":
             suggest = "ignore_dbs"
+        elif key == "ignoreRoles":
+            suggest = "ignore_roles"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in PgPgUserConfigMigration. Access the value via the '{suggest}' property getter instead.")
@@ -16829,6 +17522,7 @@ class PgPgUserConfigMigration(dict):
                  port: int,
                  dbname: Optional[str] = None,
                  ignore_dbs: Optional[str] = None,
+                 ignore_roles: Optional[str] = None,
                  method: Optional[str] = None,
                  password: Optional[str] = None,
                  ssl: Optional[bool] = None,
@@ -16838,6 +17532,7 @@ class PgPgUserConfigMigration(dict):
         :param int port: Port number of the server where to migrate data from. Example: `1234`.
         :param str dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
         :param str ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
+        :param str ignore_roles: Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
         :param str method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         :param str password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
         :param bool ssl: The server where to migrate data from is secured with SSL. Default: `true`.
@@ -16849,6 +17544,8 @@ class PgPgUserConfigMigration(dict):
             pulumi.set(__self__, "dbname", dbname)
         if ignore_dbs is not None:
             pulumi.set(__self__, "ignore_dbs", ignore_dbs)
+        if ignore_roles is not None:
+            pulumi.set(__self__, "ignore_roles", ignore_roles)
         if method is not None:
             pulumi.set(__self__, "method", method)
         if password is not None:
@@ -16890,6 +17587,14 @@ class PgPgUserConfigMigration(dict):
         """
         return pulumi.get(self, "ignore_dbs")
 
+    @property
+    @pulumi.getter(name="ignoreRoles")
+    def ignore_roles(self) -> Optional[str]:
+        """
+        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
+        """
+        return pulumi.get(self, "ignore_roles")
+
     @property
     @pulumi.getter
     def method(self) -> Optional[str]:
@@ -17965,6 +18670,8 @@ class PgPgUserConfigPgbouncer(dict):
             suggest = "autodb_pool_size"
         elif key == "ignoreStartupParameters":
             suggest = "ignore_startup_parameters"
+        elif key == "maxPreparedStatements":
+            suggest = "max_prepared_statements"
         elif key == "minPoolSize":
             suggest = "min_pool_size"
         elif key == "serverIdleTimeout":
@@ -17991,6 +18698,7 @@ class PgPgUserConfigPgbouncer(dict):
                  autodb_pool_mode: Optional[str] = None,
                  autodb_pool_size: Optional[int] = None,
                  ignore_startup_parameters: Optional[Sequence[str]] = None,
+                 max_prepared_statements: Optional[int] = None,
                  min_pool_size: Optional[int] = None,
                  server_idle_timeout: Optional[int] = None,
                  server_lifetime: Optional[int] = None,
@@ -18001,6 +18709,7 @@ class PgPgUserConfigPgbouncer(dict):
         :param str autodb_pool_mode: Enum: `session`, `transaction`, `statement`. PGBouncer pool mode. Default: `transaction`.
         :param int autodb_pool_size: If non-zero then create automatically a pool of that size per user when a pool doesn't exist. Default: `0`.
         :param Sequence[str] ignore_startup_parameters: List of parameters to ignore when given in startup packet.
+        :param int max_prepared_statements: PgBouncer tracks protocol-level named prepared statements related commands sent by the client in transaction and statement pooling modes when max*prepared*statements is set to a non-zero value. Setting it to 0 disables prepared statements. max*prepared*statements defaults to 100, and its maximum is 3000. Default: `100`.
         :param 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. Default: `0`.
         :param int server_idle_timeout: If a server connection has been idle more than this many seconds it will be dropped. If 0 then timeout is disabled. (seconds). Default: `600`.
         :param int server_lifetime: The pooler will close an unused server connection that has been connected longer than this. (seconds). Default: `3600`.
@@ -18016,6 +18725,8 @@ class PgPgUserConfigPgbouncer(dict):
             pulumi.set(__self__, "autodb_pool_size", autodb_pool_size)
         if ignore_startup_parameters is not None:
             pulumi.set(__self__, "ignore_startup_parameters", ignore_startup_parameters)
+        if max_prepared_statements is not None:
+            pulumi.set(__self__, "max_prepared_statements", max_prepared_statements)
         if min_pool_size is not None:
             pulumi.set(__self__, "min_pool_size", min_pool_size)
         if server_idle_timeout is not None:
@@ -18065,6 +18776,14 @@ class PgPgUserConfigPgbouncer(dict):
         """
         return pulumi.get(self, "ignore_startup_parameters")
 
+    @property
+    @pulumi.getter(name="maxPreparedStatements")
+    def max_prepared_statements(self) -> Optional[int]:
+        """
+        PgBouncer tracks protocol-level named prepared statements related commands sent by the client in transaction and statement pooling modes when max*prepared*statements is set to a non-zero value. Setting it to 0 disables prepared statements. max*prepared*statements defaults to 100, and its maximum is 3000. Default: `100`.
+        """
+        return pulumi.get(self, "max_prepared_statements")
+
     @property
     @pulumi.getter(name="minPoolSize")
     def min_pool_size(self) -> Optional[int]:
@@ -19027,6 +19746,8 @@ class RedisRedisUserConfigMigration(dict):
         suggest = None
         if key == "ignoreDbs":
             suggest = "ignore_dbs"
+        elif key == "ignoreRoles":
+            suggest = "ignore_roles"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in RedisRedisUserConfigMigration. Access the value via the '{suggest}' property getter instead.")
@@ -19044,6 +19765,7 @@ class RedisRedisUserConfigMigration(dict):
                  port: int,
                  dbname: Optional[str] = None,
                  ignore_dbs: Optional[str] = None,
+                 ignore_roles: Optional[str] = None,
                  method: Optional[str] = None,
                  password: Optional[str] = None,
                  ssl: Optional[bool] = None,
@@ -19053,6 +19775,7 @@ class RedisRedisUserConfigMigration(dict):
         :param int port: Port number of the server where to migrate data from. Example: `1234`.
         :param str dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
         :param str ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
+        :param str ignore_roles: Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
         :param str method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         :param str password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
         :param bool ssl: The server where to migrate data from is secured with SSL. Default: `true`.
@@ -19064,6 +19787,8 @@ class RedisRedisUserConfigMigration(dict):
             pulumi.set(__self__, "dbname", dbname)
         if ignore_dbs is not None:
             pulumi.set(__self__, "ignore_dbs", ignore_dbs)
+        if ignore_roles is not None:
+            pulumi.set(__self__, "ignore_roles", ignore_roles)
         if method is not None:
             pulumi.set(__self__, "method", method)
         if password is not None:
@@ -19105,6 +19830,14 @@ class RedisRedisUserConfigMigration(dict):
         """
         return pulumi.get(self, "ignore_dbs")
 
+    @property
+    @pulumi.getter(name="ignoreRoles")
+    def ignore_roles(self) -> Optional[str]:
+        """
+        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
+        """
+        return pulumi.get(self, "ignore_roles")
+
     @property
     @pulumi.getter
     def method(self) -> Optional[str]:
@@ -19368,8 +20101,12 @@ class ServiceIntegrationClickhouseKafkaUserConfigTable(dict):
             suggest = "num_consumers"
         elif key == "pollMaxBatchSize":
             suggest = "poll_max_batch_size"
+        elif key == "pollMaxTimeoutMs":
+            suggest = "poll_max_timeout_ms"
         elif key == "skipBrokenMessages":
             suggest = "skip_broken_messages"
+        elif key == "threadPerConsumer":
+            suggest = "thread_per_consumer"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ServiceIntegrationClickhouseKafkaUserConfigTable. Access the value via the '{suggest}' property getter instead.")
@@ -19395,7 +20132,9 @@ class ServiceIntegrationClickhouseKafkaUserConfigTable(dict):
                  max_rows_per_message: Optional[int] = None,
                  num_consumers: Optional[int] = None,
                  poll_max_batch_size: Optional[int] = None,
-                 skip_broken_messages: Optional[int] = None):
+                 poll_max_timeout_ms: Optional[int] = None,
+                 skip_broken_messages: Optional[int] = None,
+                 thread_per_consumer: Optional[bool] = None):
         """
         :param Sequence['ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs'] columns: Table columns
         :param str data_format: Enum: `Avro`, `CSV`, `JSONAsString`, `JSONCompactEachRow`, `JSONCompactStringsEachRow`, `JSONEachRow`, `JSONStringsEachRow`, `MsgPack`, `TSKV`, `TSV`, `TabSeparated`, `RawBLOB`, `AvroConfluent`, `Parquet`. Message data format. Default: `JSONEachRow`.
@@ -19409,7 +20148,9 @@ class ServiceIntegrationClickhouseKafkaUserConfigTable(dict):
         :param int max_rows_per_message: The maximum number of rows produced in one kafka message for row-based formats. Default: `1`.
         :param int num_consumers: The number of consumers per table per replica. Default: `1`.
         :param int poll_max_batch_size: Maximum amount of messages to be polled in a single Kafka poll. Default: `0`.
+        :param int poll_max_timeout_ms: Timeout in milliseconds for a single poll from Kafka. Takes the value of the stream*flush*interval_ms server setting by default (500ms). Default: `0`.
         :param int skip_broken_messages: Skip at least this number of broken messages from Kafka topic per block. Default: `0`.
+        :param bool thread_per_consumer: Provide an independent thread for each consumer. All consumers run in the same thread by default. Default: `false`.
         """
         pulumi.set(__self__, "columns", columns)
         pulumi.set(__self__, "data_format", data_format)
@@ -19430,8 +20171,12 @@ class ServiceIntegrationClickhouseKafkaUserConfigTable(dict):
             pulumi.set(__self__, "num_consumers", num_consumers)
         if poll_max_batch_size is not None:
             pulumi.set(__self__, "poll_max_batch_size", poll_max_batch_size)
+        if poll_max_timeout_ms is not None:
+            pulumi.set(__self__, "poll_max_timeout_ms", poll_max_timeout_ms)
         if skip_broken_messages is not None:
             pulumi.set(__self__, "skip_broken_messages", skip_broken_messages)
+        if thread_per_consumer is not None:
+            pulumi.set(__self__, "thread_per_consumer", thread_per_consumer)
 
     @property
     @pulumi.getter
@@ -19529,6 +20274,14 @@ class ServiceIntegrationClickhouseKafkaUserConfigTable(dict):
         """
         return pulumi.get(self, "poll_max_batch_size")
 
+    @property
+    @pulumi.getter(name="pollMaxTimeoutMs")
+    def poll_max_timeout_ms(self) -> Optional[int]:
+        """
+        Timeout in milliseconds for a single poll from Kafka. Takes the value of the stream*flush*interval_ms server setting by default (500ms). Default: `0`.
+        """
+        return pulumi.get(self, "poll_max_timeout_ms")
+
     @property
     @pulumi.getter(name="skipBrokenMessages")
     def skip_broken_messages(self) -> Optional[int]:
@@ -19537,6 +20290,14 @@ class ServiceIntegrationClickhouseKafkaUserConfigTable(dict):
         """
         return pulumi.get(self, "skip_broken_messages")
 
+    @property
+    @pulumi.getter(name="threadPerConsumer")
+    def thread_per_consumer(self) -> Optional[bool]:
+        """
+        Provide an independent thread for each consumer. All consumers run in the same thread by default. Default: `false`.
+        """
+        return pulumi.get(self, "thread_per_consumer")
+
 
 @pulumi.output_type
 class ServiceIntegrationClickhouseKafkaUserConfigTableColumn(dict):
@@ -23861,6 +24622,8 @@ class ValkeyValkeyUserConfigMigration(dict):
         suggest = None
         if key == "ignoreDbs":
             suggest = "ignore_dbs"
+        elif key == "ignoreRoles":
+            suggest = "ignore_roles"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ValkeyValkeyUserConfigMigration. Access the value via the '{suggest}' property getter instead.")
@@ -23878,6 +24641,7 @@ class ValkeyValkeyUserConfigMigration(dict):
                  port: int,
                  dbname: Optional[str] = None,
                  ignore_dbs: Optional[str] = None,
+                 ignore_roles: Optional[str] = None,
                  method: Optional[str] = None,
                  password: Optional[str] = None,
                  ssl: Optional[bool] = None,
@@ -23887,6 +24651,7 @@ class ValkeyValkeyUserConfigMigration(dict):
         :param int port: Port number of the server where to migrate data from. Example: `1234`.
         :param str dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
         :param str ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
+        :param str ignore_roles: Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
         :param str method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         :param str password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
         :param bool ssl: The server where to migrate data from is secured with SSL. Default: `true`.
@@ -23898,6 +24663,8 @@ class ValkeyValkeyUserConfigMigration(dict):
             pulumi.set(__self__, "dbname", dbname)
         if ignore_dbs is not None:
             pulumi.set(__self__, "ignore_dbs", ignore_dbs)
+        if ignore_roles is not None:
+            pulumi.set(__self__, "ignore_roles", ignore_roles)
         if method is not None:
             pulumi.set(__self__, "method", method)
         if password is not None:
@@ -23939,6 +24706,14 @@ class ValkeyValkeyUserConfigMigration(dict):
         """
         return pulumi.get(self, "ignore_dbs")
 
+    @property
+    @pulumi.getter(name="ignoreRoles")
+    def ignore_roles(self) -> Optional[str]:
+        """
+        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
+        """
+        return pulumi.get(self, "ignore_roles")
+
     @property
     @pulumi.getter
     def method(self) -> Optional[str]:
@@ -26078,6 +26853,7 @@ class GetDragonflyDragonflyUserConfigMigrationResult(dict):
                  port: int,
                  dbname: Optional[str] = None,
                  ignore_dbs: Optional[str] = None,
+                 ignore_roles: Optional[str] = None,
                  method: Optional[str] = None,
                  password: Optional[str] = None,
                  ssl: Optional[bool] = None,
@@ -26087,6 +26863,7 @@ class GetDragonflyDragonflyUserConfigMigrationResult(dict):
         :param int port: Port number of the server where to migrate data from. Example: `1234`.
         :param str dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
         :param str ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
+        :param str ignore_roles: Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
         :param str method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         :param str password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
         :param bool ssl: The server where to migrate data from is secured with SSL. Default: `true`.
@@ -26098,6 +26875,8 @@ class GetDragonflyDragonflyUserConfigMigrationResult(dict):
             pulumi.set(__self__, "dbname", dbname)
         if ignore_dbs is not None:
             pulumi.set(__self__, "ignore_dbs", ignore_dbs)
+        if ignore_roles is not None:
+            pulumi.set(__self__, "ignore_roles", ignore_roles)
         if method is not None:
             pulumi.set(__self__, "method", method)
         if password is not None:
@@ -26139,6 +26918,14 @@ class GetDragonflyDragonflyUserConfigMigrationResult(dict):
         """
         return pulumi.get(self, "ignore_dbs")
 
+    @property
+    @pulumi.getter(name="ignoreRoles")
+    def ignore_roles(self) -> Optional[str]:
+        """
+        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
+        """
+        return pulumi.get(self, "ignore_roles")
+
     @property
     @pulumi.getter
     def method(self) -> Optional[str]:
@@ -26925,7 +27712,8 @@ class GetGrafanaGrafanaUserConfigResult(dict):
                  unified_alerting_enabled: Optional[bool] = None,
                  user_auto_assign_org: Optional[bool] = None,
                  user_auto_assign_org_role: Optional[str] = None,
-                 viewers_can_edit: Optional[bool] = None):
+                 viewers_can_edit: Optional[bool] = None,
+                 wal: Optional[bool] = None):
         """
         :param str additional_backup_regions: Additional Cloud Regions for Backup Replication.
         :param bool alerting_enabled: Enable or disable Grafana legacy alerting functionality. This should not be enabled with unified_alerting_enabled.
@@ -26969,6 +27757,7 @@ class GetGrafanaGrafanaUserConfigResult(dict):
         :param bool user_auto_assign_org: Auto-assign new users on signup to main organization. Defaults to false.
         :param str user_auto_assign_org_role: Enum: `Viewer`, `Admin`, `Editor`. Set role for new signups. Defaults to Viewer.
         :param bool viewers_can_edit: Users with view-only permission can edit but not save dashboards.
+        :param bool wal: Setting to enable/disable Write-Ahead Logging. The default value is false (disabled).
         """
         if additional_backup_regions is not None:
             pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
@@ -27054,6 +27843,8 @@ class GetGrafanaGrafanaUserConfigResult(dict):
             pulumi.set(__self__, "user_auto_assign_org_role", user_auto_assign_org_role)
         if viewers_can_edit is not None:
             pulumi.set(__self__, "viewers_can_edit", viewers_can_edit)
+        if wal is not None:
+            pulumi.set(__self__, "wal", wal)
 
     @property
     @pulumi.getter(name="additionalBackupRegions")
@@ -27392,6 +28183,14 @@ class GetGrafanaGrafanaUserConfigResult(dict):
         """
         return pulumi.get(self, "viewers_can_edit")
 
+    @property
+    @pulumi.getter
+    def wal(self) -> Optional[bool]:
+        """
+        Setting to enable/disable Write-Ahead Logging. The default value is false (disabled).
+        """
+        return pulumi.get(self, "wal")
+
 
 @pulumi.output_type
 class GetGrafanaGrafanaUserConfigAuthAzureadResult(dict):
@@ -29830,6 +30629,7 @@ class GetKafkaKafkaUserConfigResult(dict):
                  additional_backup_regions: Optional[str] = None,
                  aiven_kafka_topic_messages: Optional[bool] = None,
                  custom_domain: Optional[str] = None,
+                 follower_fetching: Optional['outputs.GetKafkaKafkaUserConfigFollowerFetchingResult'] = None,
                  ip_filter_objects: Optional[Sequence['outputs.GetKafkaKafkaUserConfigIpFilterObjectResult']] = None,
                  ip_filter_strings: Optional[Sequence[str]] = None,
                  ip_filters: Optional[Sequence[str]] = None,
@@ -29841,6 +30641,7 @@ class GetKafkaKafkaUserConfigResult(dict):
                  kafka_rest: Optional[bool] = None,
                  kafka_rest_authorization: Optional[bool] = None,
                  kafka_rest_config: Optional['outputs.GetKafkaKafkaUserConfigKafkaRestConfigResult'] = None,
+                 kafka_sasl_mechanisms: Optional['outputs.GetKafkaKafkaUserConfigKafkaSaslMechanismsResult'] = None,
                  kafka_version: Optional[str] = None,
                  letsencrypt_sasl_privatelink: Optional[bool] = None,
                  private_access: Optional['outputs.GetKafkaKafkaUserConfigPrivateAccessResult'] = None,
@@ -29855,6 +30656,7 @@ class GetKafkaKafkaUserConfigResult(dict):
         :param str additional_backup_regions: Additional Cloud Regions for Backup Replication.
         :param bool aiven_kafka_topic_messages: Allow access to read Kafka topic messages in the Aiven Console and REST API.
         :param str custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. Example: `grafana.example.org`.
+        :param 'GetKafkaKafkaUserConfigFollowerFetchingArgs' follower_fetching: Enable follower fetching
         :param Sequence['GetKafkaKafkaUserConfigIpFilterObjectArgs'] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
         :param Sequence[str] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
         :param Sequence[str] ip_filters: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
@@ -29865,6 +30667,7 @@ class GetKafkaKafkaUserConfigResult(dict):
         :param bool kafka_rest: Enable Kafka-REST service. Default: `false`.
         :param bool kafka_rest_authorization: Enable authorization in Kafka-REST service.
         :param 'GetKafkaKafkaUserConfigKafkaRestConfigArgs' kafka_rest_config: Kafka REST configuration
+        :param 'GetKafkaKafkaUserConfigKafkaSaslMechanismsArgs' kafka_sasl_mechanisms: Kafka SASL mechanisms
         :param str kafka_version: Enum: `3.1`, `3.2`, `3.3`, `3.4`, `3.5`, `3.6`, `3.7`, and newer. Kafka major version.
         :param bool letsencrypt_sasl_privatelink: Use Letsencrypt CA for Kafka SASL via Privatelink.
         :param 'GetKafkaKafkaUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
@@ -29882,6 +30685,8 @@ class GetKafkaKafkaUserConfigResult(dict):
             pulumi.set(__self__, "aiven_kafka_topic_messages", aiven_kafka_topic_messages)
         if custom_domain is not None:
             pulumi.set(__self__, "custom_domain", custom_domain)
+        if follower_fetching is not None:
+            pulumi.set(__self__, "follower_fetching", follower_fetching)
         if ip_filter_objects is not None:
             pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
         if ip_filter_strings is not None:
@@ -29904,6 +30709,8 @@ class GetKafkaKafkaUserConfigResult(dict):
             pulumi.set(__self__, "kafka_rest_authorization", kafka_rest_authorization)
         if kafka_rest_config is not None:
             pulumi.set(__self__, "kafka_rest_config", kafka_rest_config)
+        if kafka_sasl_mechanisms is not None:
+            pulumi.set(__self__, "kafka_sasl_mechanisms", kafka_sasl_mechanisms)
         if kafka_version is not None:
             pulumi.set(__self__, "kafka_version", kafka_version)
         if letsencrypt_sasl_privatelink is not None:
@@ -29950,6 +30757,14 @@ class GetKafkaKafkaUserConfigResult(dict):
         """
         return pulumi.get(self, "custom_domain")
 
+    @property
+    @pulumi.getter(name="followerFetching")
+    def follower_fetching(self) -> Optional['outputs.GetKafkaKafkaUserConfigFollowerFetchingResult']:
+        """
+        Enable follower fetching
+        """
+        return pulumi.get(self, "follower_fetching")
+
     @property
     @pulumi.getter(name="ipFilterObjects")
     def ip_filter_objects(self) -> Optional[Sequence['outputs.GetKafkaKafkaUserConfigIpFilterObjectResult']]:
@@ -30036,6 +30851,14 @@ class GetKafkaKafkaUserConfigResult(dict):
         """
         return pulumi.get(self, "kafka_rest_config")
 
+    @property
+    @pulumi.getter(name="kafkaSaslMechanisms")
+    def kafka_sasl_mechanisms(self) -> Optional['outputs.GetKafkaKafkaUserConfigKafkaSaslMechanismsResult']:
+        """
+        Kafka SASL mechanisms
+        """
+        return pulumi.get(self, "kafka_sasl_mechanisms")
+
     @property
     @pulumi.getter(name="kafkaVersion")
     def kafka_version(self) -> Optional[str]:
@@ -30117,6 +30940,25 @@ class GetKafkaKafkaUserConfigResult(dict):
         return pulumi.get(self, "tiered_storage")
 
 
+@pulumi.output_type
+class GetKafkaKafkaUserConfigFollowerFetchingResult(dict):
+    def __init__(__self__, *,
+                 enabled: Optional[bool] = None):
+        """
+        :param bool enabled: Whether to enable the follower fetching functionality.
+        """
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[bool]:
+        """
+        Whether to enable the follower fetching functionality.
+        """
+        return pulumi.get(self, "enabled")
+
+
 @pulumi.output_type
 class GetKafkaKafkaUserConfigIpFilterObjectResult(dict):
     def __init__(__self__, *,
@@ -30197,52 +31039,52 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
                  transaction_remove_expired_transaction_cleanup_interval_ms: Optional[int] = None,
                  transaction_state_log_segment_bytes: Optional[int] = None):
         """
-        :param bool auto_create_topics_enable: Enable auto creation of topics.
-        :param 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 int connections_max_idle_ms: Idle connections timeout: the server socket processor threads close the connections that idle for longer than this. Example: `540000`.
-        :param int default_replication_factor: Replication factor for autocreated topics.
-        :param 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. Example: `3000`.
-        :param int group_max_session_timeout_ms: The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. Example: `1800000`.
-        :param int group_min_session_timeout_ms: The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. Example: `6000`.
-        :param int log_cleaner_delete_retention_ms: How long are delete records retained? Example: `86400000`.
-        :param 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 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. Example: `0.5`.
-        :param 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 str log_cleanup_policy: Enum: `delete`, `compact`, `compact,delete`. The default cleanup policy for segments beyond the retention window.
-        :param int log_flush_interval_messages: The number of messages accumulated on a log partition before messages are flushed to disk. Example: `9223372036854775807`.
-        :param 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 int log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index. Example: `4096`.
-        :param int log_index_size_max_bytes: The maximum size in bytes of the offset index. Example: `10485760`.
-        :param int log_local_retention_bytes: The maximum size of local log segments that can grow for a partition before it gets eligible for deletion. If set to -2, the value of log.retention.bytes is used. The effective value should always be less than or equal to log.retention.bytes value.
-        :param 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 bool log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
-        :param 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 str log_message_timestamp_type: Enum: `CreateTime`, `LogAppendTime`. Define whether the timestamp in the message is message create time or log append time.
-        :param bool log_preallocate: Should pre allocate file when create new segment?
-        :param int log_retention_bytes: The maximum size of the log before deleting messages.
-        :param int log_retention_hours: The number of hours to keep a log file before deleting it.
-        :param int log_retention_ms: The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied.
-        :param int log_roll_jitter_ms: The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used.
-        :param int log_roll_ms: The maximum time before a new log segment is rolled out (in milliseconds).
-        :param int log_segment_bytes: The maximum size of a single log file.
-        :param int log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem. Example: `60000`.
-        :param int max_connections_per_ip: The maximum number of connections allowed from each ip address (defaults to 2147483647).
-        :param int max_incremental_fetch_session_cache_slots: The maximum number of incremental fetch sessions that the broker will maintain. Example: `1000`.
-        :param int message_max_bytes: The maximum size of message that the server can receive. Example: `1048588`.
-        :param int min_insync_replicas: When a producer sets acks to `all` (or `-1`), min.insync.replicas specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. Example: `1`.
-        :param int num_partitions: Number of partitions for autocreated topics.
-        :param int offsets_retention_minutes: Log retention window in minutes for offsets topic. Example: `10080`.
-        :param int producer_purgatory_purge_interval_requests: The purge interval (in number of requests) of the producer request purgatory(defaults to 1000).
-        :param int replica_fetch_max_bytes: The number of bytes of messages to attempt to fetch for each partition (defaults to 1048576). This is not an absolute maximum, 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 progress can be made.
-        :param int replica_fetch_response_max_bytes: Maximum bytes expected for the entire fetch response (defaults to 10485760). Records are fetched in batches, 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 progress can be made. As such, this is not an absolute maximum.
-        :param str sasl_oauthbearer_expected_audience: The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences.
-        :param str sasl_oauthbearer_expected_issuer: Optional setting for the broker to use to verify that the JWT was created by the expected issuer.
-        :param str sasl_oauthbearer_jwks_endpoint_url: OIDC JWKS endpoint URL. By setting this the SASL SSL OAuth2/OIDC authentication is enabled. See also other options for SASL OAuth2/OIDC.
-        :param str sasl_oauthbearer_sub_claim_name: Name of the scope from which to extract the subject claim from the JWT. Defaults to sub.
-        :param int socket_request_max_bytes: The maximum number of bytes in a socket request (defaults to 104857600).
-        :param bool transaction_partition_verification_enable: Enable verification that checks that the partition has been added to the transaction before writing transactional records to the partition.
-        :param int transaction_remove_expired_transaction_cleanup_interval_ms: The interval at which to remove transactions that have expired due to transactional.id.expiration.ms passing (defaults to 3600000 (1 hour)).
-        :param int transaction_state_log_segment_bytes: The transaction topic segment bytes should be kept relatively small in order to facilitate faster log compaction and cache loads (defaults to 104857600 (100 mebibytes)).
+        :param bool auto_create_topics_enable: Enable auto-creation of topics. (Default: true).
+        :param 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.(Default: producer).
+        :param int connections_max_idle_ms: Idle connections timeout: the server socket processor threads close the connections that idle for longer than this. (Default: 600000 ms (10 minutes)). Example: `540000`.
+        :param int default_replication_factor: Replication factor for auto-created topics (Default: 3).
+        :param 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. (Default: 3000 ms (3 seconds)). Example: `3000`.
+        :param int group_max_session_timeout_ms: The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. Default: 1800000 ms (30 minutes). Example: `1800000`.
+        :param int group_min_session_timeout_ms: The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. (Default: 6000 ms (6 seconds)). Example: `6000`.
+        :param int log_cleaner_delete_retention_ms: How long are delete records retained? (Default: 86400000 (1 day)). Example: `86400000`.
+        :param int log_cleaner_max_compaction_lag_ms: The maximum amount of time message will remain uncompacted. Only applicable for logs that are being compacted. (Default: 9223372036854775807 ms (Long.MAX_VALUE)).
+        :param 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. (Default: 0.5). Example: `0.5`.
+        :param 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. (Default: 0 ms).
+        :param str log_cleanup_policy: Enum: `delete`, `compact`, `compact,delete`. The default cleanup policy for segments beyond the retention window (Default: delete).
+        :param int log_flush_interval_messages: The number of messages accumulated on a log partition before messages are flushed to disk (Default: 9223372036854775807 (Long.MAX_VALUE)). Example: `9223372036854775807`.
+        :param int log_flush_interval_ms: The maximum time in ms that a message in any topic is kept in memory (page-cache) before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used (Default: null).
+        :param int log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index (Default: 4096 bytes (4 kibibytes)). Example: `4096`.
+        :param int log_index_size_max_bytes: The maximum size in bytes of the offset index (Default: 10485760 (10 mebibytes)). Example: `10485760`.
+        :param int log_local_retention_bytes: The maximum size of local log segments that can grow for a partition before it gets eligible for deletion. If set to -2, the value of log.retention.bytes is used. The effective value should always be less than or equal to log.retention.bytes value. (Default: -2).
+        :param 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. (Default: -2).
+        :param bool log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests. (Default: true).
+        :param 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 (Default: 9223372036854775807 (Long.MAX_VALUE)).
+        :param str log_message_timestamp_type: Enum: `CreateTime`, `LogAppendTime`. Define whether the timestamp in the message is message create time or log append time. (Default: CreateTime).
+        :param bool log_preallocate: Should pre allocate file when create new segment? (Default: false).
+        :param int log_retention_bytes: The maximum size of the log before deleting messages (Default: -1).
+        :param int log_retention_hours: The number of hours to keep a log file before deleting it (Default: 168 hours (1 week)).
+        :param int log_retention_ms: The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied. (Default: null, log.retention.hours applies).
+        :param int log_roll_jitter_ms: The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used (Default: null).
+        :param int log_roll_ms: The maximum time before a new log segment is rolled out (in milliseconds). (Default: null, log.roll.hours applies (Default: 168, 7 days)).
+        :param int log_segment_bytes: The maximum size of a single log file (Default: 1073741824 bytes (1 gibibyte)).
+        :param int log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem (Default: 60000 ms (1 minute)). Example: `60000`.
+        :param int max_connections_per_ip: The maximum number of connections allowed from each ip address (Default: 2147483647).
+        :param int max_incremental_fetch_session_cache_slots: The maximum number of incremental fetch sessions that the broker will maintain. (Default: 1000). Example: `1000`.
+        :param int message_max_bytes: The maximum size of message that the server can receive. (Default: 1048588 bytes (1 mebibyte + 12 bytes)). Example: `1048588`.
+        :param int min_insync_replicas: When a producer sets acks to `all` (or `-1`), min.insync.replicas specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. (Default: 1). Example: `1`.
+        :param int num_partitions: Number of partitions for auto-created topics (Default: 1).
+        :param int offsets_retention_minutes: Log retention window in minutes for offsets topic (Default: 10080 minutes (7 days)). Example: `10080`.
+        :param int producer_purgatory_purge_interval_requests: The purge interval (in number of requests) of the producer request purgatory (Default: 1000).
+        :param int replica_fetch_max_bytes: The number of bytes of messages to attempt to fetch for each partition . This is not an absolute maximum, 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 progress can be made. (Default: 1048576 bytes (1 mebibytes)).
+        :param int replica_fetch_response_max_bytes: Maximum bytes expected for the entire fetch response. Records are fetched in batches, 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 progress can be made. As such, this is not an absolute maximum. (Default: 10485760 bytes (10 mebibytes)).
+        :param str sasl_oauthbearer_expected_audience: The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences. (Default: null).
+        :param str sasl_oauthbearer_expected_issuer: Optional setting for the broker to use to verify that the JWT was created by the expected issuer.(Default: null).
+        :param str sasl_oauthbearer_jwks_endpoint_url: OIDC JWKS endpoint URL. By setting this the SASL SSL OAuth2/OIDC authentication is enabled. See also other options for SASL OAuth2/OIDC. (Default: null).
+        :param str sasl_oauthbearer_sub_claim_name: Name of the scope from which to extract the subject claim from the JWT.(Default: sub).
+        :param int socket_request_max_bytes: The maximum number of bytes in a socket request (Default: 104857600 bytes).
+        :param bool transaction_partition_verification_enable: Enable verification that checks that the partition has been added to the transaction before writing transactional records to the partition. (Default: true).
+        :param int transaction_remove_expired_transaction_cleanup_interval_ms: The interval at which to remove transactions that have expired due to transactional.id.expiration.ms passing (Default: 3600000 ms (1 hour)). Example: `3600000`.
+        :param int transaction_state_log_segment_bytes: The transaction topic segment bytes should be kept relatively small in order to facilitate faster log compaction and cache loads (Default: 104857600 bytes (100 mebibytes)). Example: `104857600`.
         """
         if auto_create_topics_enable is not None:
             pulumi.set(__self__, "auto_create_topics_enable", auto_create_topics_enable)
@@ -30341,7 +31183,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="autoCreateTopicsEnable")
     def auto_create_topics_enable(self) -> Optional[bool]:
         """
-        Enable auto creation of topics.
+        Enable auto-creation of topics. (Default: true).
         """
         return pulumi.get(self, "auto_create_topics_enable")
 
@@ -30349,7 +31191,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="compressionType")
     def compression_type(self) -> Optional[str]:
         """
-        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.
+        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.(Default: producer).
         """
         return pulumi.get(self, "compression_type")
 
@@ -30357,7 +31199,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="connectionsMaxIdleMs")
     def connections_max_idle_ms(self) -> Optional[int]:
         """
-        Idle connections timeout: the server socket processor threads close the connections that idle for longer than this. Example: `540000`.
+        Idle connections timeout: the server socket processor threads close the connections that idle for longer than this. (Default: 600000 ms (10 minutes)). Example: `540000`.
         """
         return pulumi.get(self, "connections_max_idle_ms")
 
@@ -30365,7 +31207,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="defaultReplicationFactor")
     def default_replication_factor(self) -> Optional[int]:
         """
-        Replication factor for autocreated topics.
+        Replication factor for auto-created topics (Default: 3).
         """
         return pulumi.get(self, "default_replication_factor")
 
@@ -30373,7 +31215,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="groupInitialRebalanceDelayMs")
     def group_initial_rebalance_delay_ms(self) -> Optional[int]:
         """
-        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. Example: `3000`.
+        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. (Default: 3000 ms (3 seconds)). Example: `3000`.
         """
         return pulumi.get(self, "group_initial_rebalance_delay_ms")
 
@@ -30381,7 +31223,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="groupMaxSessionTimeoutMs")
     def group_max_session_timeout_ms(self) -> Optional[int]:
         """
-        The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. Example: `1800000`.
+        The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. Default: 1800000 ms (30 minutes). Example: `1800000`.
         """
         return pulumi.get(self, "group_max_session_timeout_ms")
 
@@ -30389,7 +31231,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="groupMinSessionTimeoutMs")
     def group_min_session_timeout_ms(self) -> Optional[int]:
         """
-        The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. Example: `6000`.
+        The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. (Default: 6000 ms (6 seconds)). Example: `6000`.
         """
         return pulumi.get(self, "group_min_session_timeout_ms")
 
@@ -30397,7 +31239,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logCleanerDeleteRetentionMs")
     def log_cleaner_delete_retention_ms(self) -> Optional[int]:
         """
-        How long are delete records retained? Example: `86400000`.
+        How long are delete records retained? (Default: 86400000 (1 day)). Example: `86400000`.
         """
         return pulumi.get(self, "log_cleaner_delete_retention_ms")
 
@@ -30405,7 +31247,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logCleanerMaxCompactionLagMs")
     def log_cleaner_max_compaction_lag_ms(self) -> Optional[int]:
         """
-        The maximum amount of time message will remain uncompacted. Only applicable for logs that are being compacted.
+        The maximum amount of time message will remain uncompacted. Only applicable for logs that are being compacted. (Default: 9223372036854775807 ms (Long.MAX_VALUE)).
         """
         return pulumi.get(self, "log_cleaner_max_compaction_lag_ms")
 
@@ -30413,7 +31255,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logCleanerMinCleanableRatio")
     def log_cleaner_min_cleanable_ratio(self) -> Optional[float]:
         """
-        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. Example: `0.5`.
+        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. (Default: 0.5). Example: `0.5`.
         """
         return pulumi.get(self, "log_cleaner_min_cleanable_ratio")
 
@@ -30421,7 +31263,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logCleanerMinCompactionLagMs")
     def log_cleaner_min_compaction_lag_ms(self) -> Optional[int]:
         """
-        The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.
+        The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted. (Default: 0 ms).
         """
         return pulumi.get(self, "log_cleaner_min_compaction_lag_ms")
 
@@ -30429,7 +31271,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logCleanupPolicy")
     def log_cleanup_policy(self) -> Optional[str]:
         """
-        Enum: `delete`, `compact`, `compact,delete`. 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 (Default: delete).
         """
         return pulumi.get(self, "log_cleanup_policy")
 
@@ -30437,7 +31279,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logFlushIntervalMessages")
     def log_flush_interval_messages(self) -> Optional[int]:
         """
-        The number of messages accumulated on a log partition before messages are flushed to disk. Example: `9223372036854775807`.
+        The number of messages accumulated on a log partition before messages are flushed to disk (Default: 9223372036854775807 (Long.MAX_VALUE)). Example: `9223372036854775807`.
         """
         return pulumi.get(self, "log_flush_interval_messages")
 
@@ -30445,7 +31287,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logFlushIntervalMs")
     def log_flush_interval_ms(self) -> Optional[int]:
         """
-        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.
+        The maximum time in ms that a message in any topic is kept in memory (page-cache) before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used (Default: null).
         """
         return pulumi.get(self, "log_flush_interval_ms")
 
@@ -30453,7 +31295,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logIndexIntervalBytes")
     def log_index_interval_bytes(self) -> Optional[int]:
         """
-        The interval with which Kafka adds an entry to the offset index. Example: `4096`.
+        The interval with which Kafka adds an entry to the offset index (Default: 4096 bytes (4 kibibytes)). Example: `4096`.
         """
         return pulumi.get(self, "log_index_interval_bytes")
 
@@ -30461,7 +31303,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logIndexSizeMaxBytes")
     def log_index_size_max_bytes(self) -> Optional[int]:
         """
-        The maximum size in bytes of the offset index. Example: `10485760`.
+        The maximum size in bytes of the offset index (Default: 10485760 (10 mebibytes)). Example: `10485760`.
         """
         return pulumi.get(self, "log_index_size_max_bytes")
 
@@ -30469,7 +31311,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logLocalRetentionBytes")
     def log_local_retention_bytes(self) -> Optional[int]:
         """
-        The maximum size of local log segments that can grow for a partition before it gets eligible for deletion. If set to -2, the value of log.retention.bytes is used. The effective value should always be less than or equal to log.retention.bytes value.
+        The maximum size of local log segments that can grow for a partition before it gets eligible for deletion. If set to -2, the value of log.retention.bytes is used. The effective value should always be less than or equal to log.retention.bytes value. (Default: -2).
         """
         return pulumi.get(self, "log_local_retention_bytes")
 
@@ -30477,7 +31319,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logLocalRetentionMs")
     def log_local_retention_ms(self) -> Optional[int]:
         """
-        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.
+        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. (Default: -2).
         """
         return pulumi.get(self, "log_local_retention_ms")
 
@@ -30485,7 +31327,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logMessageDownconversionEnable")
     def log_message_downconversion_enable(self) -> Optional[bool]:
         """
-        This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
+        This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests. (Default: true).
         """
         return pulumi.get(self, "log_message_downconversion_enable")
 
@@ -30493,7 +31335,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logMessageTimestampDifferenceMaxMs")
     def log_message_timestamp_difference_max_ms(self) -> Optional[int]:
         """
-        The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message.
+        The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message (Default: 9223372036854775807 (Long.MAX_VALUE)).
         """
         return pulumi.get(self, "log_message_timestamp_difference_max_ms")
 
@@ -30501,7 +31343,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logMessageTimestampType")
     def log_message_timestamp_type(self) -> Optional[str]:
         """
-        Enum: `CreateTime`, `LogAppendTime`. 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. (Default: CreateTime).
         """
         return pulumi.get(self, "log_message_timestamp_type")
 
@@ -30509,7 +31351,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logPreallocate")
     def log_preallocate(self) -> Optional[bool]:
         """
-        Should pre allocate file when create new segment?
+        Should pre allocate file when create new segment? (Default: false).
         """
         return pulumi.get(self, "log_preallocate")
 
@@ -30517,7 +31359,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logRetentionBytes")
     def log_retention_bytes(self) -> Optional[int]:
         """
-        The maximum size of the log before deleting messages.
+        The maximum size of the log before deleting messages (Default: -1).
         """
         return pulumi.get(self, "log_retention_bytes")
 
@@ -30525,7 +31367,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logRetentionHours")
     def log_retention_hours(self) -> Optional[int]:
         """
-        The number of hours to keep a log file before deleting it.
+        The number of hours to keep a log file before deleting it (Default: 168 hours (1 week)).
         """
         return pulumi.get(self, "log_retention_hours")
 
@@ -30533,7 +31375,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logRetentionMs")
     def log_retention_ms(self) -> Optional[int]:
         """
-        The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied.
+        The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied. (Default: null, log.retention.hours applies).
         """
         return pulumi.get(self, "log_retention_ms")
 
@@ -30541,7 +31383,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logRollJitterMs")
     def log_roll_jitter_ms(self) -> Optional[int]:
         """
-        The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used.
+        The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used (Default: null).
         """
         return pulumi.get(self, "log_roll_jitter_ms")
 
@@ -30549,7 +31391,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logRollMs")
     def log_roll_ms(self) -> Optional[int]:
         """
-        The maximum time before a new log segment is rolled out (in milliseconds).
+        The maximum time before a new log segment is rolled out (in milliseconds). (Default: null, log.roll.hours applies (Default: 168, 7 days)).
         """
         return pulumi.get(self, "log_roll_ms")
 
@@ -30557,7 +31399,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logSegmentBytes")
     def log_segment_bytes(self) -> Optional[int]:
         """
-        The maximum size of a single log file.
+        The maximum size of a single log file (Default: 1073741824 bytes (1 gibibyte)).
         """
         return pulumi.get(self, "log_segment_bytes")
 
@@ -30565,7 +31407,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="logSegmentDeleteDelayMs")
     def log_segment_delete_delay_ms(self) -> Optional[int]:
         """
-        The amount of time to wait before deleting a file from the filesystem. Example: `60000`.
+        The amount of time to wait before deleting a file from the filesystem (Default: 60000 ms (1 minute)). Example: `60000`.
         """
         return pulumi.get(self, "log_segment_delete_delay_ms")
 
@@ -30573,7 +31415,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="maxConnectionsPerIp")
     def max_connections_per_ip(self) -> Optional[int]:
         """
-        The maximum number of connections allowed from each ip address (defaults to 2147483647).
+        The maximum number of connections allowed from each ip address (Default: 2147483647).
         """
         return pulumi.get(self, "max_connections_per_ip")
 
@@ -30581,7 +31423,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="maxIncrementalFetchSessionCacheSlots")
     def max_incremental_fetch_session_cache_slots(self) -> Optional[int]:
         """
-        The maximum number of incremental fetch sessions that the broker will maintain. Example: `1000`.
+        The maximum number of incremental fetch sessions that the broker will maintain. (Default: 1000). Example: `1000`.
         """
         return pulumi.get(self, "max_incremental_fetch_session_cache_slots")
 
@@ -30589,7 +31431,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="messageMaxBytes")
     def message_max_bytes(self) -> Optional[int]:
         """
-        The maximum size of message that the server can receive. Example: `1048588`.
+        The maximum size of message that the server can receive. (Default: 1048588 bytes (1 mebibyte + 12 bytes)). Example: `1048588`.
         """
         return pulumi.get(self, "message_max_bytes")
 
@@ -30597,7 +31439,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="minInsyncReplicas")
     def min_insync_replicas(self) -> Optional[int]:
         """
-        When a producer sets acks to `all` (or `-1`), min.insync.replicas specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. Example: `1`.
+        When a producer sets acks to `all` (or `-1`), min.insync.replicas specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. (Default: 1). Example: `1`.
         """
         return pulumi.get(self, "min_insync_replicas")
 
@@ -30605,7 +31447,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="numPartitions")
     def num_partitions(self) -> Optional[int]:
         """
-        Number of partitions for autocreated topics.
+        Number of partitions for auto-created topics (Default: 1).
         """
         return pulumi.get(self, "num_partitions")
 
@@ -30613,7 +31455,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="offsetsRetentionMinutes")
     def offsets_retention_minutes(self) -> Optional[int]:
         """
-        Log retention window in minutes for offsets topic. Example: `10080`.
+        Log retention window in minutes for offsets topic (Default: 10080 minutes (7 days)). Example: `10080`.
         """
         return pulumi.get(self, "offsets_retention_minutes")
 
@@ -30621,7 +31463,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="producerPurgatoryPurgeIntervalRequests")
     def producer_purgatory_purge_interval_requests(self) -> Optional[int]:
         """
-        The purge interval (in number of requests) of the producer request purgatory(defaults to 1000).
+        The purge interval (in number of requests) of the producer request purgatory (Default: 1000).
         """
         return pulumi.get(self, "producer_purgatory_purge_interval_requests")
 
@@ -30629,7 +31471,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="replicaFetchMaxBytes")
     def replica_fetch_max_bytes(self) -> Optional[int]:
         """
-        The number of bytes of messages to attempt to fetch for each partition (defaults to 1048576). This is not an absolute maximum, 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 progress can be made.
+        The number of bytes of messages to attempt to fetch for each partition . This is not an absolute maximum, 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 progress can be made. (Default: 1048576 bytes (1 mebibytes)).
         """
         return pulumi.get(self, "replica_fetch_max_bytes")
 
@@ -30637,7 +31479,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="replicaFetchResponseMaxBytes")
     def replica_fetch_response_max_bytes(self) -> Optional[int]:
         """
-        Maximum bytes expected for the entire fetch response (defaults to 10485760). Records are fetched in batches, 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 progress can be made. As such, this is not an absolute maximum.
+        Maximum bytes expected for the entire fetch response. Records are fetched in batches, 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 progress can be made. As such, this is not an absolute maximum. (Default: 10485760 bytes (10 mebibytes)).
         """
         return pulumi.get(self, "replica_fetch_response_max_bytes")
 
@@ -30645,7 +31487,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="saslOauthbearerExpectedAudience")
     def sasl_oauthbearer_expected_audience(self) -> Optional[str]:
         """
-        The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences.
+        The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences. (Default: null).
         """
         return pulumi.get(self, "sasl_oauthbearer_expected_audience")
 
@@ -30653,7 +31495,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="saslOauthbearerExpectedIssuer")
     def sasl_oauthbearer_expected_issuer(self) -> Optional[str]:
         """
-        Optional setting for the broker to use to verify that the JWT was created by the expected issuer.
+        Optional setting for the broker to use to verify that the JWT was created by the expected issuer.(Default: null).
         """
         return pulumi.get(self, "sasl_oauthbearer_expected_issuer")
 
@@ -30661,7 +31503,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="saslOauthbearerJwksEndpointUrl")
     def sasl_oauthbearer_jwks_endpoint_url(self) -> Optional[str]:
         """
-        OIDC JWKS endpoint URL. By setting this the SASL SSL OAuth2/OIDC authentication is enabled. See also other options for SASL OAuth2/OIDC.
+        OIDC JWKS endpoint URL. By setting this the SASL SSL OAuth2/OIDC authentication is enabled. See also other options for SASL OAuth2/OIDC. (Default: null).
         """
         return pulumi.get(self, "sasl_oauthbearer_jwks_endpoint_url")
 
@@ -30669,7 +31511,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="saslOauthbearerSubClaimName")
     def sasl_oauthbearer_sub_claim_name(self) -> Optional[str]:
         """
-        Name of the scope from which to extract the subject claim from the JWT. Defaults to sub.
+        Name of the scope from which to extract the subject claim from the JWT.(Default: sub).
         """
         return pulumi.get(self, "sasl_oauthbearer_sub_claim_name")
 
@@ -30677,7 +31519,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="socketRequestMaxBytes")
     def socket_request_max_bytes(self) -> Optional[int]:
         """
-        The maximum number of bytes in a socket request (defaults to 104857600).
+        The maximum number of bytes in a socket request (Default: 104857600 bytes).
         """
         return pulumi.get(self, "socket_request_max_bytes")
 
@@ -30685,7 +31527,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="transactionPartitionVerificationEnable")
     def transaction_partition_verification_enable(self) -> Optional[bool]:
         """
-        Enable verification that checks that the partition has been added to the transaction before writing transactional records to the partition.
+        Enable verification that checks that the partition has been added to the transaction before writing transactional records to the partition. (Default: true).
         """
         return pulumi.get(self, "transaction_partition_verification_enable")
 
@@ -30693,7 +31535,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="transactionRemoveExpiredTransactionCleanupIntervalMs")
     def transaction_remove_expired_transaction_cleanup_interval_ms(self) -> Optional[int]:
         """
-        The interval at which to remove transactions that have expired due to transactional.id.expiration.ms passing (defaults to 3600000 (1 hour)).
+        The interval at which to remove transactions that have expired due to transactional.id.expiration.ms passing (Default: 3600000 ms (1 hour)). Example: `3600000`.
         """
         return pulumi.get(self, "transaction_remove_expired_transaction_cleanup_interval_ms")
 
@@ -30701,7 +31543,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
     @pulumi.getter(name="transactionStateLogSegmentBytes")
     def transaction_state_log_segment_bytes(self) -> Optional[int]:
         """
-        The transaction topic segment bytes should be kept relatively small in order to facilitate faster log compaction and cache loads (defaults to 104857600 (100 mebibytes)).
+        The transaction topic segment bytes should be kept relatively small in order to facilitate faster log compaction and cache loads (Default: 104857600 bytes (100 mebibytes)). Example: `104857600`.
         """
         return pulumi.get(self, "transaction_state_log_segment_bytes")
 
@@ -31211,6 +32053,49 @@ class GetKafkaKafkaUserConfigKafkaRestConfigResult(dict):
         return pulumi.get(self, "simpleconsumer_pool_size_max")
 
 
+@pulumi.output_type
+class GetKafkaKafkaUserConfigKafkaSaslMechanismsResult(dict):
+    def __init__(__self__, *,
+                 plain: Optional[bool] = None,
+                 scram_sha256: Optional[bool] = None,
+                 scram_sha512: Optional[bool] = None):
+        """
+        :param bool plain: Enable PLAIN mechanism. Default: `true`.
+        :param bool scram_sha256: Enable SCRAM-SHA-256 mechanism. Default: `true`.
+        :param bool scram_sha512: Enable SCRAM-SHA-512 mechanism. Default: `true`.
+        """
+        if plain is not None:
+            pulumi.set(__self__, "plain", plain)
+        if scram_sha256 is not None:
+            pulumi.set(__self__, "scram_sha256", scram_sha256)
+        if scram_sha512 is not None:
+            pulumi.set(__self__, "scram_sha512", scram_sha512)
+
+    @property
+    @pulumi.getter
+    def plain(self) -> Optional[bool]:
+        """
+        Enable PLAIN mechanism. Default: `true`.
+        """
+        return pulumi.get(self, "plain")
+
+    @property
+    @pulumi.getter(name="scramSha256")
+    def scram_sha256(self) -> Optional[bool]:
+        """
+        Enable SCRAM-SHA-256 mechanism. Default: `true`.
+        """
+        return pulumi.get(self, "scram_sha256")
+
+    @property
+    @pulumi.getter(name="scramSha512")
+    def scram_sha512(self) -> Optional[bool]:
+        """
+        Enable SCRAM-SHA-512 mechanism. Default: `true`.
+        """
+        return pulumi.get(self, "scram_sha512")
+
+
 @pulumi.output_type
 class GetKafkaKafkaUserConfigPrivateAccessResult(dict):
     def __init__(__self__, *,
@@ -31728,6 +32613,7 @@ class GetKafkaMirrorMakerKafkaMirrormakerUserConfigIpFilterObjectResult(dict):
 @pulumi.output_type
 class GetKafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerResult(dict):
     def __init__(__self__, *,
+                 admin_timeout_ms: Optional[int] = None,
                  emit_checkpoints_enabled: Optional[bool] = None,
                  emit_checkpoints_interval_seconds: Optional[int] = None,
                  groups: Optional[str] = None,
@@ -31742,6 +32628,7 @@ class GetKafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerResult(dict):
                  sync_topic_configs_enabled: Optional[bool] = None,
                  tasks_max_per_cpu: Optional[int] = None):
         """
+        :param int admin_timeout_ms: Timeout for administrative tasks, e.g. detecting new topics, loading of consumer group and offsets. Defaults to 60000 milliseconds (1 minute).
         :param bool emit_checkpoints_enabled: Whether to emit consumer group offset checkpoints to target cluster periodically (default: true).
         :param int emit_checkpoints_interval_seconds: Frequency at which consumer group offset checkpoints are emitted (default: 60, every minute). Example: `60`.
         :param str groups: Consumer groups to replicate. Supports comma-separated group IDs and regexes. Example: `.*`.
@@ -31756,6 +32643,8 @@ class GetKafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerResult(dict):
         :param bool sync_topic_configs_enabled: Whether to periodically configure remote topics to match their corresponding upstream topics.
         :param int tasks_max_per_cpu: `tasks.max` is set to this multiplied by the number of CPUs in the service. Default: `1`.
         """
+        if admin_timeout_ms is not None:
+            pulumi.set(__self__, "admin_timeout_ms", admin_timeout_ms)
         if emit_checkpoints_enabled is not None:
             pulumi.set(__self__, "emit_checkpoints_enabled", emit_checkpoints_enabled)
         if emit_checkpoints_interval_seconds is not None:
@@ -31783,6 +32672,14 @@ class GetKafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerResult(dict):
         if tasks_max_per_cpu is not None:
             pulumi.set(__self__, "tasks_max_per_cpu", tasks_max_per_cpu)
 
+    @property
+    @pulumi.getter(name="adminTimeoutMs")
+    def admin_timeout_ms(self) -> Optional[int]:
+        """
+        Timeout for administrative tasks, e.g. detecting new topics, loading of consumer group and offsets. Defaults to 60000 milliseconds (1 minute).
+        """
+        return pulumi.get(self, "admin_timeout_ms")
+
     @property
     @pulumi.getter(name="emitCheckpointsEnabled")
     def emit_checkpoints_enabled(self) -> Optional[bool]:
@@ -34259,6 +35156,7 @@ class GetMySqlMysqlUserConfigMigrationResult(dict):
                  port: int,
                  dbname: Optional[str] = None,
                  ignore_dbs: Optional[str] = None,
+                 ignore_roles: Optional[str] = None,
                  method: Optional[str] = None,
                  password: Optional[str] = None,
                  ssl: Optional[bool] = None,
@@ -34268,6 +35166,7 @@ class GetMySqlMysqlUserConfigMigrationResult(dict):
         :param int port: Port number of the server where to migrate data from. Example: `1234`.
         :param str dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
         :param str ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
+        :param str ignore_roles: Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
         :param str method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         :param str password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
         :param bool ssl: The server where to migrate data from is secured with SSL. Default: `true`.
@@ -34279,6 +35178,8 @@ class GetMySqlMysqlUserConfigMigrationResult(dict):
             pulumi.set(__self__, "dbname", dbname)
         if ignore_dbs is not None:
             pulumi.set(__self__, "ignore_dbs", ignore_dbs)
+        if ignore_roles is not None:
+            pulumi.set(__self__, "ignore_roles", ignore_roles)
         if method is not None:
             pulumi.set(__self__, "method", method)
         if password is not None:
@@ -34320,6 +35221,14 @@ class GetMySqlMysqlUserConfigMigrationResult(dict):
         """
         return pulumi.get(self, "ignore_dbs")
 
+    @property
+    @pulumi.getter(name="ignoreRoles")
+    def ignore_roles(self) -> Optional[str]:
+        """
+        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
+        """
+        return pulumi.get(self, "ignore_roles")
+
     @property
     @pulumi.getter
     def method(self) -> Optional[str]:
@@ -35086,9 +35995,12 @@ class GetOpenSearchOpensearchResult(dict):
 class GetOpenSearchOpensearchUserConfigResult(dict):
     def __init__(__self__, *,
                  additional_backup_regions: Optional[str] = None,
+                 azure_migration: Optional['outputs.GetOpenSearchOpensearchUserConfigAzureMigrationResult'] = None,
                  custom_domain: Optional[str] = None,
                  disable_replication_factor_adjustment: Optional[bool] = None,
+                 gcs_migration: Optional['outputs.GetOpenSearchOpensearchUserConfigGcsMigrationResult'] = None,
                  index_patterns: Optional[Sequence['outputs.GetOpenSearchOpensearchUserConfigIndexPatternResult']] = None,
+                 index_rollup: Optional['outputs.GetOpenSearchOpensearchUserConfigIndexRollupResult'] = None,
                  index_template: Optional['outputs.GetOpenSearchOpensearchUserConfigIndexTemplateResult'] = None,
                  ip_filter_objects: Optional[Sequence['outputs.GetOpenSearchOpensearchUserConfigIpFilterObjectResult']] = None,
                  ip_filter_strings: Optional[Sequence[str]] = None,
@@ -35104,6 +36016,7 @@ class GetOpenSearchOpensearchUserConfigResult(dict):
                  project_to_fork_from: Optional[str] = None,
                  public_access: Optional['outputs.GetOpenSearchOpensearchUserConfigPublicAccessResult'] = None,
                  recovery_basebackup_name: Optional[str] = None,
+                 s3_migration: Optional['outputs.GetOpenSearchOpensearchUserConfigS3MigrationResult'] = None,
                  saml: Optional['outputs.GetOpenSearchOpensearchUserConfigSamlResult'] = None,
                  service_log: Optional[bool] = None,
                  service_to_fork_from: Optional[str] = None,
@@ -35113,6 +36026,7 @@ class GetOpenSearchOpensearchUserConfigResult(dict):
         :param str custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. Example: `grafana.example.org`.
         :param bool disable_replication_factor_adjustment: Disable automatic replication factor adjustment for multi-node services. By default, Aiven ensures all indexes are replicated at least to two nodes. Note: Due to potential data loss in case of losing a service node, this setting can no longer be activated.
         :param Sequence['GetOpenSearchOpensearchUserConfigIndexPatternArgs'] index_patterns: Index patterns
+        :param 'GetOpenSearchOpensearchUserConfigIndexRollupArgs' index_rollup: Index rollup settings
         :param 'GetOpenSearchOpensearchUserConfigIndexTemplateArgs' index_template: Template settings for all new indexes
         :param Sequence['GetOpenSearchOpensearchUserConfigIpFilterObjectArgs'] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
         :param Sequence[str] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
@@ -35135,12 +36049,18 @@ class GetOpenSearchOpensearchUserConfigResult(dict):
         """
         if additional_backup_regions is not None:
             pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
+        if azure_migration is not None:
+            pulumi.set(__self__, "azure_migration", azure_migration)
         if custom_domain is not None:
             pulumi.set(__self__, "custom_domain", custom_domain)
         if disable_replication_factor_adjustment is not None:
             pulumi.set(__self__, "disable_replication_factor_adjustment", disable_replication_factor_adjustment)
+        if gcs_migration is not None:
+            pulumi.set(__self__, "gcs_migration", gcs_migration)
         if index_patterns is not None:
             pulumi.set(__self__, "index_patterns", index_patterns)
+        if index_rollup is not None:
+            pulumi.set(__self__, "index_rollup", index_rollup)
         if index_template is not None:
             pulumi.set(__self__, "index_template", index_template)
         if ip_filter_objects is not None:
@@ -35171,6 +36091,8 @@ class GetOpenSearchOpensearchUserConfigResult(dict):
             pulumi.set(__self__, "public_access", public_access)
         if recovery_basebackup_name is not None:
             pulumi.set(__self__, "recovery_basebackup_name", recovery_basebackup_name)
+        if s3_migration is not None:
+            pulumi.set(__self__, "s3_migration", s3_migration)
         if saml is not None:
             pulumi.set(__self__, "saml", saml)
         if service_log is not None:
@@ -35188,6 +36110,11 @@ class GetOpenSearchOpensearchUserConfigResult(dict):
         """
         return pulumi.get(self, "additional_backup_regions")
 
+    @property
+    @pulumi.getter(name="azureMigration")
+    def azure_migration(self) -> Optional['outputs.GetOpenSearchOpensearchUserConfigAzureMigrationResult']:
+        return pulumi.get(self, "azure_migration")
+
     @property
     @pulumi.getter(name="customDomain")
     def custom_domain(self) -> Optional[str]:
@@ -35204,6 +36131,11 @@ class GetOpenSearchOpensearchUserConfigResult(dict):
         """
         return pulumi.get(self, "disable_replication_factor_adjustment")
 
+    @property
+    @pulumi.getter(name="gcsMigration")
+    def gcs_migration(self) -> Optional['outputs.GetOpenSearchOpensearchUserConfigGcsMigrationResult']:
+        return pulumi.get(self, "gcs_migration")
+
     @property
     @pulumi.getter(name="indexPatterns")
     def index_patterns(self) -> Optional[Sequence['outputs.GetOpenSearchOpensearchUserConfigIndexPatternResult']]:
@@ -35212,6 +36144,14 @@ class GetOpenSearchOpensearchUserConfigResult(dict):
         """
         return pulumi.get(self, "index_patterns")
 
+    @property
+    @pulumi.getter(name="indexRollup")
+    def index_rollup(self) -> Optional['outputs.GetOpenSearchOpensearchUserConfigIndexRollupResult']:
+        """
+        Index rollup settings
+        """
+        return pulumi.get(self, "index_rollup")
+
     @property
     @pulumi.getter(name="indexTemplate")
     def index_template(self) -> Optional['outputs.GetOpenSearchOpensearchUserConfigIndexTemplateResult']:
@@ -35333,6 +36273,11 @@ class GetOpenSearchOpensearchUserConfigResult(dict):
         """
         return pulumi.get(self, "recovery_basebackup_name")
 
+    @property
+    @pulumi.getter(name="s3Migration")
+    def s3_migration(self) -> Optional['outputs.GetOpenSearchOpensearchUserConfigS3MigrationResult']:
+        return pulumi.get(self, "s3_migration")
+
     @property
     @pulumi.getter
     def saml(self) -> Optional['outputs.GetOpenSearchOpensearchUserConfigSamlResult']:
@@ -35366,6 +36311,192 @@ class GetOpenSearchOpensearchUserConfigResult(dict):
         return pulumi.get(self, "static_ips")
 
 
+@pulumi.output_type
+class GetOpenSearchOpensearchUserConfigAzureMigrationResult(dict):
+    def __init__(__self__, *,
+                 account: str,
+                 base_path: str,
+                 container: str,
+                 snapshot_name: str,
+                 chunk_size: Optional[str] = None,
+                 compress: Optional[bool] = None,
+                 endpoint_suffix: Optional[str] = None,
+                 key: Optional[str] = None,
+                 sas_token: Optional[str] = None):
+        """
+        :param str account: Azure account name.
+        :param str base_path: The path to the repository data within its container. The value of this setting should not start or end with a /.
+        :param str container: Azure container name.
+        :param str snapshot_name: The snapshot name to restore from.
+        :param str chunk_size: Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
+        :param bool compress: When set to true metadata files are stored in compressed format.
+        :param str endpoint_suffix: Defines the DNS suffix for Azure Storage endpoints.
+        :param str key: Azure account secret key. One of key or sas_token should be specified.
+        :param str sas_token: A shared access signatures (SAS) token. One of key or sas_token should be specified.
+        """
+        pulumi.set(__self__, "account", account)
+        pulumi.set(__self__, "base_path", base_path)
+        pulumi.set(__self__, "container", container)
+        pulumi.set(__self__, "snapshot_name", snapshot_name)
+        if chunk_size is not None:
+            pulumi.set(__self__, "chunk_size", chunk_size)
+        if compress is not None:
+            pulumi.set(__self__, "compress", compress)
+        if endpoint_suffix is not None:
+            pulumi.set(__self__, "endpoint_suffix", endpoint_suffix)
+        if key is not None:
+            pulumi.set(__self__, "key", key)
+        if sas_token is not None:
+            pulumi.set(__self__, "sas_token", sas_token)
+
+    @property
+    @pulumi.getter
+    def account(self) -> str:
+        """
+        Azure account name.
+        """
+        return pulumi.get(self, "account")
+
+    @property
+    @pulumi.getter(name="basePath")
+    def base_path(self) -> str:
+        """
+        The path to the repository data within its container. The value of this setting should not start or end with a /.
+        """
+        return pulumi.get(self, "base_path")
+
+    @property
+    @pulumi.getter
+    def container(self) -> str:
+        """
+        Azure container name.
+        """
+        return pulumi.get(self, "container")
+
+    @property
+    @pulumi.getter(name="snapshotName")
+    def snapshot_name(self) -> str:
+        """
+        The snapshot name to restore from.
+        """
+        return pulumi.get(self, "snapshot_name")
+
+    @property
+    @pulumi.getter(name="chunkSize")
+    def chunk_size(self) -> Optional[str]:
+        """
+        Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
+        """
+        return pulumi.get(self, "chunk_size")
+
+    @property
+    @pulumi.getter
+    def compress(self) -> Optional[bool]:
+        """
+        When set to true metadata files are stored in compressed format.
+        """
+        return pulumi.get(self, "compress")
+
+    @property
+    @pulumi.getter(name="endpointSuffix")
+    def endpoint_suffix(self) -> Optional[str]:
+        """
+        Defines the DNS suffix for Azure Storage endpoints.
+        """
+        return pulumi.get(self, "endpoint_suffix")
+
+    @property
+    @pulumi.getter
+    def key(self) -> Optional[str]:
+        """
+        Azure account secret key. One of key or sas_token should be specified.
+        """
+        return pulumi.get(self, "key")
+
+    @property
+    @pulumi.getter(name="sasToken")
+    def sas_token(self) -> Optional[str]:
+        """
+        A shared access signatures (SAS) token. One of key or sas_token should be specified.
+        """
+        return pulumi.get(self, "sas_token")
+
+
+@pulumi.output_type
+class GetOpenSearchOpensearchUserConfigGcsMigrationResult(dict):
+    def __init__(__self__, *,
+                 base_path: str,
+                 bucket: str,
+                 credentials: str,
+                 snapshot_name: str,
+                 chunk_size: Optional[str] = None,
+                 compress: Optional[bool] = None):
+        """
+        :param str base_path: The path to the repository data within its container. The value of this setting should not start or end with a /.
+        :param str bucket: The path to the repository data within its container.
+        :param str credentials: Google Cloud Storage credentials file content.
+        :param str snapshot_name: The snapshot name to restore from.
+        :param str chunk_size: Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
+        :param bool compress: When set to true metadata files are stored in compressed format.
+        """
+        pulumi.set(__self__, "base_path", base_path)
+        pulumi.set(__self__, "bucket", bucket)
+        pulumi.set(__self__, "credentials", credentials)
+        pulumi.set(__self__, "snapshot_name", snapshot_name)
+        if chunk_size is not None:
+            pulumi.set(__self__, "chunk_size", chunk_size)
+        if compress is not None:
+            pulumi.set(__self__, "compress", compress)
+
+    @property
+    @pulumi.getter(name="basePath")
+    def base_path(self) -> str:
+        """
+        The path to the repository data within its container. The value of this setting should not start or end with a /.
+        """
+        return pulumi.get(self, "base_path")
+
+    @property
+    @pulumi.getter
+    def bucket(self) -> str:
+        """
+        The path to the repository data within its container.
+        """
+        return pulumi.get(self, "bucket")
+
+    @property
+    @pulumi.getter
+    def credentials(self) -> str:
+        """
+        Google Cloud Storage credentials file content.
+        """
+        return pulumi.get(self, "credentials")
+
+    @property
+    @pulumi.getter(name="snapshotName")
+    def snapshot_name(self) -> str:
+        """
+        The snapshot name to restore from.
+        """
+        return pulumi.get(self, "snapshot_name")
+
+    @property
+    @pulumi.getter(name="chunkSize")
+    def chunk_size(self) -> Optional[str]:
+        """
+        Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
+        """
+        return pulumi.get(self, "chunk_size")
+
+    @property
+    @pulumi.getter
+    def compress(self) -> Optional[bool]:
+        """
+        When set to true metadata files are stored in compressed format.
+        """
+        return pulumi.get(self, "compress")
+
+
 @pulumi.output_type
 class GetOpenSearchOpensearchUserConfigIndexPatternResult(dict):
     def __init__(__self__, *,
@@ -35407,6 +36538,73 @@ class GetOpenSearchOpensearchUserConfigIndexPatternResult(dict):
         return pulumi.get(self, "sorting_algorithm")
 
 
+@pulumi.output_type
+class GetOpenSearchOpensearchUserConfigIndexRollupResult(dict):
+    def __init__(__self__, *,
+                 rollup_dashboards_enabled: Optional[bool] = None,
+                 rollup_enabled: Optional[bool] = None,
+                 rollup_search_backoff_count: Optional[int] = None,
+                 rollup_search_backoff_millis: Optional[int] = None,
+                 rollup_search_search_all_jobs: Optional[bool] = None):
+        """
+        :param bool rollup_dashboards_enabled: Whether rollups are enabled in OpenSearch Dashboards. Defaults to true.
+        :param bool rollup_enabled: Whether the rollup plugin is enabled. Defaults to true.
+        :param int rollup_search_backoff_count: How many retries the plugin should attempt for failed rollup jobs. Defaults to 5.
+        :param int rollup_search_backoff_millis: The backoff time between retries for failed rollup jobs. Defaults to 1000ms.
+        :param bool rollup_search_search_all_jobs: Whether OpenSearch should return all jobs that match all specified search terms. If disabled, OpenSearch returns just one, as opposed to all, of the jobs that matches the search terms. Defaults to false.
+        """
+        if rollup_dashboards_enabled is not None:
+            pulumi.set(__self__, "rollup_dashboards_enabled", rollup_dashboards_enabled)
+        if rollup_enabled is not None:
+            pulumi.set(__self__, "rollup_enabled", rollup_enabled)
+        if rollup_search_backoff_count is not None:
+            pulumi.set(__self__, "rollup_search_backoff_count", rollup_search_backoff_count)
+        if rollup_search_backoff_millis is not None:
+            pulumi.set(__self__, "rollup_search_backoff_millis", rollup_search_backoff_millis)
+        if rollup_search_search_all_jobs is not None:
+            pulumi.set(__self__, "rollup_search_search_all_jobs", rollup_search_search_all_jobs)
+
+    @property
+    @pulumi.getter(name="rollupDashboardsEnabled")
+    def rollup_dashboards_enabled(self) -> Optional[bool]:
+        """
+        Whether rollups are enabled in OpenSearch Dashboards. Defaults to true.
+        """
+        return pulumi.get(self, "rollup_dashboards_enabled")
+
+    @property
+    @pulumi.getter(name="rollupEnabled")
+    def rollup_enabled(self) -> Optional[bool]:
+        """
+        Whether the rollup plugin is enabled. Defaults to true.
+        """
+        return pulumi.get(self, "rollup_enabled")
+
+    @property
+    @pulumi.getter(name="rollupSearchBackoffCount")
+    def rollup_search_backoff_count(self) -> Optional[int]:
+        """
+        How many retries the plugin should attempt for failed rollup jobs. Defaults to 5.
+        """
+        return pulumi.get(self, "rollup_search_backoff_count")
+
+    @property
+    @pulumi.getter(name="rollupSearchBackoffMillis")
+    def rollup_search_backoff_millis(self) -> Optional[int]:
+        """
+        The backoff time between retries for failed rollup jobs. Defaults to 1000ms.
+        """
+        return pulumi.get(self, "rollup_search_backoff_millis")
+
+    @property
+    @pulumi.getter(name="rollupSearchSearchAllJobs")
+    def rollup_search_search_all_jobs(self) -> Optional[bool]:
+        """
+        Whether OpenSearch should return all jobs that match all specified search terms. If disabled, OpenSearch returns just one, as opposed to all, of the jobs that matches the search terms. Defaults to false.
+        """
+        return pulumi.get(self, "rollup_search_search_all_jobs")
+
+
 @pulumi.output_type
 class GetOpenSearchOpensearchUserConfigIndexTemplateResult(dict):
     def __init__(__self__, *,
@@ -35496,8 +36694,8 @@ class GetOpenSearchOpensearchUserConfigOpenidResult(dict):
                  scope: Optional[str] = None,
                  subject_key: Optional[str] = None):
         """
-        :param str client_id: The ID of the OpenID Connect client configured in your IdP. Required. Example: ``.
-        :param str client_secret: The client secret of the OpenID Connect client configured in your IdP. Required. Example: ``.
+        :param str client_id: The ID of the OpenID Connect client configured in your IdP. Required.
+        :param str client_secret: The client secret of the OpenID Connect client configured in your IdP. Required.
         :param str connect_url: The URL of your IdP where the Security plugin can find the OpenID Connect metadata/configuration settings. Example: `https://test-account.okta.com/app/exk491jujcVc83LEX697/sso/saml/metadata`.
         :param bool enabled: Enables or disables OpenID Connect authentication for OpenSearch. When enabled, users can authenticate using OpenID Connect with an Identity Provider. Default: `true`.
         :param str header: HTTP header name of the JWT token. Optional. Default is Authorization. Default: `Authorization`.
@@ -35506,7 +36704,7 @@ class GetOpenSearchOpensearchUserConfigOpenidResult(dict):
         :param int refresh_rate_limit_count: The maximum number of unknown key IDs in the time frame. Default is 10. Optional. Default: `10`.
         :param int refresh_rate_limit_time_window_ms: The time frame to use when checking the maximum number of unknown key IDs, in milliseconds. Optional.Default is 10000 (10 seconds). Default: `10000`.
         :param str roles_key: The key in the JSON payload that stores the user’s roles. The value of this key must be a comma-separated list of roles. Required only if you want to use roles in the JWT. Example: `roles`.
-        :param str scope: The scope of the identity token issued by the IdP. Optional. Default is openid profile email address phone. Example: ``.
+        :param str scope: The scope of the identity token issued by the IdP. Optional. Default is openid profile email address phone.
         :param str subject_key: The key in the JSON payload that stores the user’s name. If not defined, the subject registered claim is used. Most IdP providers use the preferred_username claim. Optional. Example: `preferred_username`.
         """
         pulumi.set(__self__, "client_id", client_id)
@@ -35534,7 +36732,7 @@ class GetOpenSearchOpensearchUserConfigOpenidResult(dict):
     @pulumi.getter(name="clientId")
     def client_id(self) -> str:
         """
-        The ID of the OpenID Connect client configured in your IdP. Required. Example: ``.
+        The ID of the OpenID Connect client configured in your IdP. Required.
         """
         return pulumi.get(self, "client_id")
 
@@ -35542,7 +36740,7 @@ class GetOpenSearchOpensearchUserConfigOpenidResult(dict):
     @pulumi.getter(name="clientSecret")
     def client_secret(self) -> str:
         """
-        The client secret of the OpenID Connect client configured in your IdP. Required. Example: ``.
+        The client secret of the OpenID Connect client configured in your IdP. Required.
         """
         return pulumi.get(self, "client_secret")
 
@@ -35614,7 +36812,7 @@ class GetOpenSearchOpensearchUserConfigOpenidResult(dict):
     @pulumi.getter
     def scope(self) -> Optional[str]:
         """
-        The scope of the identity token issued by the IdP. Optional. Default is openid profile email address phone. Example: ``.
+        The scope of the identity token issued by the IdP. Optional. Default is openid profile email address phone.
         """
         return pulumi.get(self, "scope")
 
@@ -35683,7 +36881,7 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
         :param str email_sender_name: Sender name placeholder to be used in Opensearch Dashboards and Opensearch keystore. Example: `alert-sender`.
         :param str email_sender_password: Sender password for Opensearch alerts to authenticate with SMTP server. Example: `very-secure-mail-password`.
         :param str email_sender_username: Sender username for Opensearch alerts. Example: `jane@example.com`.
-        :param bool enable_security_audit: Enable/Disable security audit. Default: `false`.
+        :param bool enable_security_audit: Enable/Disable security audit.
         :param int http_max_content_length: Maximum content length for HTTP requests to the OpenSearch HTTP API, in bytes.
         :param int http_max_header_size: The max size of allowed headers, in bytes. Example: `8192`.
         :param int http_max_initial_line_length: The max length of an HTTP URL, in bytes. Example: `4096`.
@@ -35695,14 +36893,14 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
         :param int indices_query_bool_max_clause_count: Maximum number of clauses Lucene BooleanQuery can have. The default value (1024) is relatively high, and increasing it may cause performance issues. Investigate other approaches first before increasing this value.
         :param int indices_recovery_max_bytes_per_sec: Limits total inbound and outbound recovery traffic for each node. Applies to both peer recoveries as well as snapshot recoveries (i.e., restores from a snapshot). Defaults to 40mb.
         :param int indices_recovery_max_concurrent_file_chunks: Number of file chunks sent in parallel for each recovery. Defaults to 2.
-        :param bool ism_enabled: Specifies whether ISM is enabled or not. Default: `true`.
-        :param bool ism_history_enabled: Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document. Default: `true`.
-        :param int ism_history_max_age: The maximum age before rolling over the audit history index in hours. Default: `24`.
-        :param int ism_history_max_docs: The maximum number of documents before rolling over the audit history index. Default: `2500000`.
-        :param int ism_history_rollover_check_period: The time between rollover checks for the audit history index in hours. Default: `8`.
-        :param int ism_history_rollover_retention_period: How long audit history indices are kept in days. Default: `30`.
-        :param bool knn_memory_circuit_breaker_enabled: Enable or disable KNN memory circuit breaker. Defaults to true. Default: `true`.
-        :param int knn_memory_circuit_breaker_limit: Maximum amount of memory that can be used for KNN index. Defaults to 50% of the JVM heap size. Default: `50`.
+        :param bool ism_enabled: Specifies whether ISM is enabled or not.
+        :param bool ism_history_enabled: Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document.
+        :param int ism_history_max_age: The maximum age before rolling over the audit history index in hours. Example: `24`.
+        :param int ism_history_max_docs: The maximum number of documents before rolling over the audit history index. Example: `2500000`.
+        :param int ism_history_rollover_check_period: The time between rollover checks for the audit history index in hours. Example: `8`.
+        :param int ism_history_rollover_retention_period: How long audit history indices are kept in days. Example: `30`.
+        :param bool knn_memory_circuit_breaker_enabled: Enable or disable KNN memory circuit breaker. Defaults to true.
+        :param int knn_memory_circuit_breaker_limit: Maximum amount of memory that can be used for KNN index. Defaults to 50% of the JVM heap size.
         :param bool override_main_response_version: Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default is false.
         :param bool plugins_alerting_filter_by_backend_roles: Enable or disable filtering of alerting by backend roles. Requires Security plugin. Defaults to false.
         :param Sequence[str] reindex_remote_whitelists: Whitelisted addresses for reindexing. Changing this value will cause all OpenSearch instances to restart.
@@ -35877,7 +37075,7 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
     @pulumi.getter(name="enableSecurityAudit")
     def enable_security_audit(self) -> Optional[bool]:
         """
-        Enable/Disable security audit. Default: `false`.
+        Enable/Disable security audit.
         """
         return pulumi.get(self, "enable_security_audit")
 
@@ -35973,7 +37171,7 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
     @pulumi.getter(name="ismEnabled")
     def ism_enabled(self) -> Optional[bool]:
         """
-        Specifies whether ISM is enabled or not. Default: `true`.
+        Specifies whether ISM is enabled or not.
         """
         return pulumi.get(self, "ism_enabled")
 
@@ -35981,7 +37179,7 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
     @pulumi.getter(name="ismHistoryEnabled")
     def ism_history_enabled(self) -> Optional[bool]:
         """
-        Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document. Default: `true`.
+        Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document.
         """
         return pulumi.get(self, "ism_history_enabled")
 
@@ -35989,7 +37187,7 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
     @pulumi.getter(name="ismHistoryMaxAge")
     def ism_history_max_age(self) -> Optional[int]:
         """
-        The maximum age before rolling over the audit history index in hours. Default: `24`.
+        The maximum age before rolling over the audit history index in hours. Example: `24`.
         """
         return pulumi.get(self, "ism_history_max_age")
 
@@ -35997,7 +37195,7 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
     @pulumi.getter(name="ismHistoryMaxDocs")
     def ism_history_max_docs(self) -> Optional[int]:
         """
-        The maximum number of documents before rolling over the audit history index. Default: `2500000`.
+        The maximum number of documents before rolling over the audit history index. Example: `2500000`.
         """
         return pulumi.get(self, "ism_history_max_docs")
 
@@ -36005,7 +37203,7 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
     @pulumi.getter(name="ismHistoryRolloverCheckPeriod")
     def ism_history_rollover_check_period(self) -> Optional[int]:
         """
-        The time between rollover checks for the audit history index in hours. Default: `8`.
+        The time between rollover checks for the audit history index in hours. Example: `8`.
         """
         return pulumi.get(self, "ism_history_rollover_check_period")
 
@@ -36013,7 +37211,7 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
     @pulumi.getter(name="ismHistoryRolloverRetentionPeriod")
     def ism_history_rollover_retention_period(self) -> Optional[int]:
         """
-        How long audit history indices are kept in days. Default: `30`.
+        How long audit history indices are kept in days. Example: `30`.
         """
         return pulumi.get(self, "ism_history_rollover_retention_period")
 
@@ -36021,7 +37219,7 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
     @pulumi.getter(name="knnMemoryCircuitBreakerEnabled")
     def knn_memory_circuit_breaker_enabled(self) -> Optional[bool]:
         """
-        Enable or disable KNN memory circuit breaker. Defaults to true. Default: `true`.
+        Enable or disable KNN memory circuit breaker. Defaults to true.
         """
         return pulumi.get(self, "knn_memory_circuit_breaker_enabled")
 
@@ -36029,7 +37227,7 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
     @pulumi.getter(name="knnMemoryCircuitBreakerLimit")
     def knn_memory_circuit_breaker_limit(self) -> Optional[int]:
         """
-        Maximum amount of memory that can be used for KNN index. Defaults to 50% of the JVM heap size. Default: `50`.
+        Maximum amount of memory that can be used for KNN index. Defaults to 50% of the JVM heap size.
         """
         return pulumi.get(self, "knn_memory_circuit_breaker_limit")
 
@@ -36531,6 +37729,127 @@ class GetOpenSearchOpensearchUserConfigPublicAccessResult(dict):
         return pulumi.get(self, "prometheus")
 
 
+@pulumi.output_type
+class GetOpenSearchOpensearchUserConfigS3MigrationResult(dict):
+    def __init__(__self__, *,
+                 access_key: str,
+                 base_path: str,
+                 bucket: str,
+                 region: str,
+                 secret_key: str,
+                 snapshot_name: str,
+                 chunk_size: Optional[str] = None,
+                 compress: Optional[bool] = None,
+                 endpoint: Optional[str] = None,
+                 server_side_encryption: Optional[bool] = None):
+        """
+        :param str access_key: AWS Access key.
+        :param str base_path: The path to the repository data within its container. The value of this setting should not start or end with a /.
+        :param str bucket: S3 bucket name.
+        :param str region: S3 region.
+        :param str secret_key: AWS secret key.
+        :param str snapshot_name: The snapshot name to restore from.
+        :param str chunk_size: Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
+        :param bool compress: When set to true metadata files are stored in compressed format.
+        :param str endpoint: The S3 service endpoint to connect to. If you are using an S3-compatible service then you should set this to the service’s endpoint.
+        :param bool server_side_encryption: When set to true files are encrypted on server side.
+        """
+        pulumi.set(__self__, "access_key", access_key)
+        pulumi.set(__self__, "base_path", base_path)
+        pulumi.set(__self__, "bucket", bucket)
+        pulumi.set(__self__, "region", region)
+        pulumi.set(__self__, "secret_key", secret_key)
+        pulumi.set(__self__, "snapshot_name", snapshot_name)
+        if chunk_size is not None:
+            pulumi.set(__self__, "chunk_size", chunk_size)
+        if compress is not None:
+            pulumi.set(__self__, "compress", compress)
+        if endpoint is not None:
+            pulumi.set(__self__, "endpoint", endpoint)
+        if server_side_encryption is not None:
+            pulumi.set(__self__, "server_side_encryption", server_side_encryption)
+
+    @property
+    @pulumi.getter(name="accessKey")
+    def access_key(self) -> str:
+        """
+        AWS Access key.
+        """
+        return pulumi.get(self, "access_key")
+
+    @property
+    @pulumi.getter(name="basePath")
+    def base_path(self) -> str:
+        """
+        The path to the repository data within its container. The value of this setting should not start or end with a /.
+        """
+        return pulumi.get(self, "base_path")
+
+    @property
+    @pulumi.getter
+    def bucket(self) -> str:
+        """
+        S3 bucket name.
+        """
+        return pulumi.get(self, "bucket")
+
+    @property
+    @pulumi.getter
+    def region(self) -> str:
+        """
+        S3 region.
+        """
+        return pulumi.get(self, "region")
+
+    @property
+    @pulumi.getter(name="secretKey")
+    def secret_key(self) -> str:
+        """
+        AWS secret key.
+        """
+        return pulumi.get(self, "secret_key")
+
+    @property
+    @pulumi.getter(name="snapshotName")
+    def snapshot_name(self) -> str:
+        """
+        The snapshot name to restore from.
+        """
+        return pulumi.get(self, "snapshot_name")
+
+    @property
+    @pulumi.getter(name="chunkSize")
+    def chunk_size(self) -> Optional[str]:
+        """
+        Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
+        """
+        return pulumi.get(self, "chunk_size")
+
+    @property
+    @pulumi.getter
+    def compress(self) -> Optional[bool]:
+        """
+        When set to true metadata files are stored in compressed format.
+        """
+        return pulumi.get(self, "compress")
+
+    @property
+    @pulumi.getter
+    def endpoint(self) -> Optional[str]:
+        """
+        The S3 service endpoint to connect to. If you are using an S3-compatible service then you should set this to the service’s endpoint.
+        """
+        return pulumi.get(self, "endpoint")
+
+    @property
+    @pulumi.getter(name="serverSideEncryption")
+    def server_side_encryption(self) -> Optional[bool]:
+        """
+        When set to true files are encrypted on server side.
+        """
+        return pulumi.get(self, "server_side_encryption")
+
+
 @pulumi.output_type
 class GetOpenSearchOpensearchUserConfigSamlResult(dict):
     def __init__(__self__, *,
@@ -36813,20 +38132,20 @@ class GetPgPgResult(dict):
                  uris: Sequence[str],
                  user: str):
         """
-        :param str bouncer: Bouncer connection details
-        :param str dbname: Primary PostgreSQL database name
-        :param str host: PostgreSQL master node host IP or name
-        :param int max_connections: Connection limit
-        :param Sequence['GetPgPgParamArgs'] params: PostgreSQL connection parameters
-        :param str password: PostgreSQL admin user password
-        :param int port: PostgreSQL port
-        :param str replica_uri: PostgreSQL replica URI for services with a replica
-        :param str sslmode: PostgreSQL sslmode setting (currently always "require")
-        :param Sequence[str] standby_uris: PostgreSQL standby connection URIs
-        :param Sequence[str] syncing_uris: PostgreSQL syncing connection URIs
-        :param str uri: PostgreSQL master connection URI
-        :param Sequence[str] uris: PostgreSQL master connection URIs
-        :param str user: PostgreSQL admin user name
+        :param str bouncer: PgBouncer connection details for [connection pooling](https://aiven.io/docs/products/postgresql/concepts/pg-connection-pooling).
+        :param str dbname: Primary PostgreSQL database name.
+        :param str host: PostgreSQL primary node host IP or name.
+        :param int max_connections: The [number of allowed connections](https://aiven.io/docs/products/postgresql/reference/pg-connection-limits). Varies based on the service plan.
+        :param Sequence['GetPgPgParamArgs'] params: PostgreSQL connection parameters.
+        :param str password: PostgreSQL admin user password.
+        :param int port: PostgreSQL port.
+        :param str replica_uri: PostgreSQL replica URI for services with a replica.
+        :param str sslmode: PostgreSQL SSL mode setting.
+        :param Sequence[str] standby_uris: PostgreSQL standby connection URIs.
+        :param Sequence[str] syncing_uris: PostgreSQL syncing connection URIs.
+        :param str uri: PostgreSQL primary connection URI.
+        :param Sequence[str] uris: PostgreSQL primary connection URIs.
+        :param str user: PostgreSQL admin user name.
         """
         pulumi.set(__self__, "bouncer", bouncer)
         pulumi.set(__self__, "dbname", dbname)
@@ -36847,7 +38166,7 @@ class GetPgPgResult(dict):
     @pulumi.getter
     def bouncer(self) -> str:
         """
-        Bouncer connection details
+        PgBouncer connection details for [connection pooling](https://aiven.io/docs/products/postgresql/concepts/pg-connection-pooling).
         """
         return pulumi.get(self, "bouncer")
 
@@ -36855,7 +38174,7 @@ class GetPgPgResult(dict):
     @pulumi.getter
     def dbname(self) -> str:
         """
-        Primary PostgreSQL database name
+        Primary PostgreSQL database name.
         """
         return pulumi.get(self, "dbname")
 
@@ -36863,7 +38182,7 @@ class GetPgPgResult(dict):
     @pulumi.getter
     def host(self) -> str:
         """
-        PostgreSQL master node host IP or name
+        PostgreSQL primary node host IP or name.
         """
         return pulumi.get(self, "host")
 
@@ -36871,7 +38190,7 @@ class GetPgPgResult(dict):
     @pulumi.getter(name="maxConnections")
     def max_connections(self) -> int:
         """
-        Connection limit
+        The [number of allowed connections](https://aiven.io/docs/products/postgresql/reference/pg-connection-limits). Varies based on the service plan.
         """
         return pulumi.get(self, "max_connections")
 
@@ -36879,7 +38198,7 @@ class GetPgPgResult(dict):
     @pulumi.getter
     def params(self) -> Sequence['outputs.GetPgPgParamResult']:
         """
-        PostgreSQL connection parameters
+        PostgreSQL connection parameters.
         """
         return pulumi.get(self, "params")
 
@@ -36887,7 +38206,7 @@ class GetPgPgResult(dict):
     @pulumi.getter
     def password(self) -> str:
         """
-        PostgreSQL admin user password
+        PostgreSQL admin user password.
         """
         return pulumi.get(self, "password")
 
@@ -36895,7 +38214,7 @@ class GetPgPgResult(dict):
     @pulumi.getter
     def port(self) -> int:
         """
-        PostgreSQL port
+        PostgreSQL port.
         """
         return pulumi.get(self, "port")
 
@@ -36903,7 +38222,7 @@ class GetPgPgResult(dict):
     @pulumi.getter(name="replicaUri")
     def replica_uri(self) -> str:
         """
-        PostgreSQL replica URI for services with a replica
+        PostgreSQL replica URI for services with a replica.
         """
         return pulumi.get(self, "replica_uri")
 
@@ -36911,7 +38230,7 @@ class GetPgPgResult(dict):
     @pulumi.getter
     def sslmode(self) -> str:
         """
-        PostgreSQL sslmode setting (currently always "require")
+        PostgreSQL SSL mode setting.
         """
         return pulumi.get(self, "sslmode")
 
@@ -36919,7 +38238,7 @@ class GetPgPgResult(dict):
     @pulumi.getter(name="standbyUris")
     def standby_uris(self) -> Sequence[str]:
         """
-        PostgreSQL standby connection URIs
+        PostgreSQL standby connection URIs.
         """
         return pulumi.get(self, "standby_uris")
 
@@ -36927,7 +38246,7 @@ class GetPgPgResult(dict):
     @pulumi.getter(name="syncingUris")
     def syncing_uris(self) -> Sequence[str]:
         """
-        PostgreSQL syncing connection URIs
+        PostgreSQL syncing connection URIs.
         """
         return pulumi.get(self, "syncing_uris")
 
@@ -36935,7 +38254,7 @@ class GetPgPgResult(dict):
     @pulumi.getter
     def uri(self) -> str:
         """
-        PostgreSQL master connection URI
+        PostgreSQL primary connection URI.
         """
         return pulumi.get(self, "uri")
 
@@ -36943,7 +38262,7 @@ class GetPgPgResult(dict):
     @pulumi.getter
     def uris(self) -> Sequence[str]:
         """
-        PostgreSQL master connection URIs
+        PostgreSQL primary connection URIs.
         """
         return pulumi.get(self, "uris")
 
@@ -36951,7 +38270,7 @@ class GetPgPgResult(dict):
     @pulumi.getter
     def user(self) -> str:
         """
-        PostgreSQL admin user name
+        PostgreSQL admin user name.
         """
         return pulumi.get(self, "user")
 
@@ -36966,12 +38285,12 @@ class GetPgPgParamResult(dict):
                  sslmode: str,
                  user: str):
         """
-        :param str database_name: Primary PostgreSQL database name
-        :param str host: PostgreSQL host IP or name
-        :param str password: PostgreSQL admin user password
-        :param int port: PostgreSQL port
-        :param str sslmode: PostgreSQL sslmode setting (currently always "require")
-        :param str user: PostgreSQL admin user name
+        :param str database_name: Primary PostgreSQL database name.
+        :param str host: PostgreSQL host IP or name.
+        :param str password: PostgreSQL admin user password.
+        :param int port: PostgreSQL port.
+        :param str sslmode: PostgreSQL SSL mode setting.
+        :param str user: PostgreSQL admin user name.
         """
         pulumi.set(__self__, "database_name", database_name)
         pulumi.set(__self__, "host", host)
@@ -36984,7 +38303,7 @@ class GetPgPgParamResult(dict):
     @pulumi.getter(name="databaseName")
     def database_name(self) -> str:
         """
-        Primary PostgreSQL database name
+        Primary PostgreSQL database name.
         """
         return pulumi.get(self, "database_name")
 
@@ -36992,7 +38311,7 @@ class GetPgPgParamResult(dict):
     @pulumi.getter
     def host(self) -> str:
         """
-        PostgreSQL host IP or name
+        PostgreSQL host IP or name.
         """
         return pulumi.get(self, "host")
 
@@ -37000,7 +38319,7 @@ class GetPgPgParamResult(dict):
     @pulumi.getter
     def password(self) -> str:
         """
-        PostgreSQL admin user password
+        PostgreSQL admin user password.
         """
         return pulumi.get(self, "password")
 
@@ -37008,7 +38327,7 @@ class GetPgPgParamResult(dict):
     @pulumi.getter
     def port(self) -> int:
         """
-        PostgreSQL port
+        PostgreSQL port.
         """
         return pulumi.get(self, "port")
 
@@ -37016,7 +38335,7 @@ class GetPgPgParamResult(dict):
     @pulumi.getter
     def sslmode(self) -> str:
         """
-        PostgreSQL sslmode setting (currently always "require")
+        PostgreSQL SSL mode setting.
         """
         return pulumi.get(self, "sslmode")
 
@@ -37024,7 +38343,7 @@ class GetPgPgParamResult(dict):
     @pulumi.getter
     def user(self) -> str:
         """
-        PostgreSQL admin user name
+        PostgreSQL admin user name.
         """
         return pulumi.get(self, "user")
 
@@ -37460,6 +38779,7 @@ class GetPgPgUserConfigMigrationResult(dict):
                  port: int,
                  dbname: Optional[str] = None,
                  ignore_dbs: Optional[str] = None,
+                 ignore_roles: Optional[str] = None,
                  method: Optional[str] = None,
                  password: Optional[str] = None,
                  ssl: Optional[bool] = None,
@@ -37469,6 +38789,7 @@ class GetPgPgUserConfigMigrationResult(dict):
         :param int port: Port number of the server where to migrate data from. Example: `1234`.
         :param str dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
         :param str ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
+        :param str ignore_roles: Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
         :param str method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         :param str password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
         :param bool ssl: The server where to migrate data from is secured with SSL. Default: `true`.
@@ -37480,6 +38801,8 @@ class GetPgPgUserConfigMigrationResult(dict):
             pulumi.set(__self__, "dbname", dbname)
         if ignore_dbs is not None:
             pulumi.set(__self__, "ignore_dbs", ignore_dbs)
+        if ignore_roles is not None:
+            pulumi.set(__self__, "ignore_roles", ignore_roles)
         if method is not None:
             pulumi.set(__self__, "method", method)
         if password is not None:
@@ -37521,6 +38844,14 @@ class GetPgPgUserConfigMigrationResult(dict):
         """
         return pulumi.get(self, "ignore_dbs")
 
+    @property
+    @pulumi.getter(name="ignoreRoles")
+    def ignore_roles(self) -> Optional[str]:
+        """
+        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
+        """
+        return pulumi.get(self, "ignore_roles")
+
     @property
     @pulumi.getter
     def method(self) -> Optional[str]:
@@ -38418,6 +39749,7 @@ class GetPgPgUserConfigPgbouncerResult(dict):
                  autodb_pool_mode: Optional[str] = None,
                  autodb_pool_size: Optional[int] = None,
                  ignore_startup_parameters: Optional[Sequence[str]] = None,
+                 max_prepared_statements: Optional[int] = None,
                  min_pool_size: Optional[int] = None,
                  server_idle_timeout: Optional[int] = None,
                  server_lifetime: Optional[int] = None,
@@ -38428,6 +39760,7 @@ class GetPgPgUserConfigPgbouncerResult(dict):
         :param str autodb_pool_mode: Enum: `session`, `transaction`, `statement`. PGBouncer pool mode. Default: `transaction`.
         :param int autodb_pool_size: If non-zero then create automatically a pool of that size per user when a pool doesn't exist. Default: `0`.
         :param Sequence[str] ignore_startup_parameters: List of parameters to ignore when given in startup packet.
+        :param int max_prepared_statements: PgBouncer tracks protocol-level named prepared statements related commands sent by the client in transaction and statement pooling modes when max_prepared_statements is set to a non-zero value. Setting it to 0 disables prepared statements. max_prepared_statements defaults to 100, and its maximum is 3000. Default: `100`.
         :param 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. Default: `0`.
         :param int server_idle_timeout: If a server connection has been idle more than this many seconds it will be dropped. If 0 then timeout is disabled. (seconds). Default: `600`.
         :param int server_lifetime: The pooler will close an unused server connection that has been connected longer than this. (seconds). Default: `3600`.
@@ -38443,6 +39776,8 @@ class GetPgPgUserConfigPgbouncerResult(dict):
             pulumi.set(__self__, "autodb_pool_size", autodb_pool_size)
         if ignore_startup_parameters is not None:
             pulumi.set(__self__, "ignore_startup_parameters", ignore_startup_parameters)
+        if max_prepared_statements is not None:
+            pulumi.set(__self__, "max_prepared_statements", max_prepared_statements)
         if min_pool_size is not None:
             pulumi.set(__self__, "min_pool_size", min_pool_size)
         if server_idle_timeout is not None:
@@ -38492,6 +39827,14 @@ class GetPgPgUserConfigPgbouncerResult(dict):
         """
         return pulumi.get(self, "ignore_startup_parameters")
 
+    @property
+    @pulumi.getter(name="maxPreparedStatements")
+    def max_prepared_statements(self) -> Optional[int]:
+        """
+        PgBouncer tracks protocol-level named prepared statements related commands sent by the client in transaction and statement pooling modes when max_prepared_statements is set to a non-zero value. Setting it to 0 disables prepared statements. max_prepared_statements defaults to 100, and its maximum is 3000. Default: `100`.
+        """
+        return pulumi.get(self, "max_prepared_statements")
+
     @property
     @pulumi.getter(name="minPoolSize")
     def min_pool_size(self) -> Optional[int]:
@@ -39288,6 +40631,7 @@ class GetRedisRedisUserConfigMigrationResult(dict):
                  port: int,
                  dbname: Optional[str] = None,
                  ignore_dbs: Optional[str] = None,
+                 ignore_roles: Optional[str] = None,
                  method: Optional[str] = None,
                  password: Optional[str] = None,
                  ssl: Optional[bool] = None,
@@ -39297,6 +40641,7 @@ class GetRedisRedisUserConfigMigrationResult(dict):
         :param int port: Port number of the server where to migrate data from. Example: `1234`.
         :param str dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
         :param str ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
+        :param str ignore_roles: Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
         :param str method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         :param str password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
         :param bool ssl: The server where to migrate data from is secured with SSL. Default: `true`.
@@ -39308,6 +40653,8 @@ class GetRedisRedisUserConfigMigrationResult(dict):
             pulumi.set(__self__, "dbname", dbname)
         if ignore_dbs is not None:
             pulumi.set(__self__, "ignore_dbs", ignore_dbs)
+        if ignore_roles is not None:
+            pulumi.set(__self__, "ignore_roles", ignore_roles)
         if method is not None:
             pulumi.set(__self__, "method", method)
         if password is not None:
@@ -39349,6 +40696,14 @@ class GetRedisRedisUserConfigMigrationResult(dict):
         """
         return pulumi.get(self, "ignore_dbs")
 
+    @property
+    @pulumi.getter(name="ignoreRoles")
+    def ignore_roles(self) -> Optional[str]:
+        """
+        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
+        """
+        return pulumi.get(self, "ignore_roles")
+
     @property
     @pulumi.getter
     def method(self) -> Optional[str]:
@@ -39585,7 +40940,9 @@ class GetServiceIntegrationClickhouseKafkaUserConfigTableResult(dict):
                  max_rows_per_message: Optional[int] = None,
                  num_consumers: Optional[int] = None,
                  poll_max_batch_size: Optional[int] = None,
-                 skip_broken_messages: Optional[int] = None):
+                 poll_max_timeout_ms: Optional[int] = None,
+                 skip_broken_messages: Optional[int] = None,
+                 thread_per_consumer: Optional[bool] = None):
         """
         :param Sequence['GetServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs'] columns: Table columns
         :param str data_format: Enum: `Avro`, `CSV`, `JSONAsString`, `JSONCompactEachRow`, `JSONCompactStringsEachRow`, `JSONEachRow`, `JSONStringsEachRow`, `MsgPack`, `TSKV`, `TSV`, `TabSeparated`, `RawBLOB`, `AvroConfluent`, `Parquet`. Message data format. Default: `JSONEachRow`.
@@ -39599,7 +40956,9 @@ class GetServiceIntegrationClickhouseKafkaUserConfigTableResult(dict):
         :param int max_rows_per_message: The maximum number of rows produced in one kafka message for row-based formats. Default: `1`.
         :param int num_consumers: The number of consumers per table per replica. Default: `1`.
         :param int poll_max_batch_size: Maximum amount of messages to be polled in a single Kafka poll. Default: `0`.
+        :param int poll_max_timeout_ms: Timeout in milliseconds for a single poll from Kafka. Takes the value of the stream_flush_interval_ms server setting by default (500ms). Default: `0`.
         :param int skip_broken_messages: Skip at least this number of broken messages from Kafka topic per block. Default: `0`.
+        :param bool thread_per_consumer: Provide an independent thread for each consumer. All consumers run in the same thread by default. Default: `false`.
         """
         pulumi.set(__self__, "columns", columns)
         pulumi.set(__self__, "data_format", data_format)
@@ -39620,8 +40979,12 @@ class GetServiceIntegrationClickhouseKafkaUserConfigTableResult(dict):
             pulumi.set(__self__, "num_consumers", num_consumers)
         if poll_max_batch_size is not None:
             pulumi.set(__self__, "poll_max_batch_size", poll_max_batch_size)
+        if poll_max_timeout_ms is not None:
+            pulumi.set(__self__, "poll_max_timeout_ms", poll_max_timeout_ms)
         if skip_broken_messages is not None:
             pulumi.set(__self__, "skip_broken_messages", skip_broken_messages)
+        if thread_per_consumer is not None:
+            pulumi.set(__self__, "thread_per_consumer", thread_per_consumer)
 
     @property
     @pulumi.getter
@@ -39719,6 +41082,14 @@ class GetServiceIntegrationClickhouseKafkaUserConfigTableResult(dict):
         """
         return pulumi.get(self, "poll_max_batch_size")
 
+    @property
+    @pulumi.getter(name="pollMaxTimeoutMs")
+    def poll_max_timeout_ms(self) -> Optional[int]:
+        """
+        Timeout in milliseconds for a single poll from Kafka. Takes the value of the stream_flush_interval_ms server setting by default (500ms). Default: `0`.
+        """
+        return pulumi.get(self, "poll_max_timeout_ms")
+
     @property
     @pulumi.getter(name="skipBrokenMessages")
     def skip_broken_messages(self) -> Optional[int]:
@@ -39727,6 +41098,14 @@ class GetServiceIntegrationClickhouseKafkaUserConfigTableResult(dict):
         """
         return pulumi.get(self, "skip_broken_messages")
 
+    @property
+    @pulumi.getter(name="threadPerConsumer")
+    def thread_per_consumer(self) -> Optional[bool]:
+        """
+        Provide an independent thread for each consumer. All consumers run in the same thread by default. Default: `false`.
+        """
+        return pulumi.get(self, "thread_per_consumer")
+
 
 @pulumi.output_type
 class GetServiceIntegrationClickhouseKafkaUserConfigTableColumnResult(dict):
@@ -43059,6 +44438,7 @@ class GetValkeyValkeyUserConfigMigrationResult(dict):
                  port: int,
                  dbname: Optional[str] = None,
                  ignore_dbs: Optional[str] = None,
+                 ignore_roles: Optional[str] = None,
                  method: Optional[str] = None,
                  password: Optional[str] = None,
                  ssl: Optional[bool] = None,
@@ -43068,6 +44448,7 @@ class GetValkeyValkeyUserConfigMigrationResult(dict):
         :param int port: Port number of the server where to migrate data from. Example: `1234`.
         :param str dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
         :param str ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
+        :param str ignore_roles: Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
         :param str method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         :param str password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
         :param bool ssl: The server where to migrate data from is secured with SSL. Default: `true`.
@@ -43079,6 +44460,8 @@ class GetValkeyValkeyUserConfigMigrationResult(dict):
             pulumi.set(__self__, "dbname", dbname)
         if ignore_dbs is not None:
             pulumi.set(__self__, "ignore_dbs", ignore_dbs)
+        if ignore_roles is not None:
+            pulumi.set(__self__, "ignore_roles", ignore_roles)
         if method is not None:
             pulumi.set(__self__, "method", method)
         if password is not None:
@@ -43120,6 +44503,14 @@ class GetValkeyValkeyUserConfigMigrationResult(dict):
         """
         return pulumi.get(self, "ignore_dbs")
 
+    @property
+    @pulumi.getter(name="ignoreRoles")
+    def ignore_roles(self) -> Optional[str]:
+        """
+        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
+        """
+        return pulumi.get(self, "ignore_roles")
+
     @property
     @pulumi.getter
     def method(self) -> Optional[str]: