pulumi-aiven 6.28.0a1731647682__py3-none-any.whl → 6.29.0__py3-none-any.whl

pulumi_aiven/outputs.py

@@ -194,6 +194,10 @@ __all__ = [
     'OpenSearchOpensearchUserConfigOpensearchSearchBackpressureNodeDuress',
     'OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchShardTask',
     'OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTask',
+    'OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueries',
+    'OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpu',
+    'OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatency',
+    'OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemory',
     'OpenSearchOpensearchUserConfigOpensearchShardIndexingPressure',
     'OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureOperatingFactor',
     'OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameter',
@@ -251,6 +255,8 @@ __all__ = [
     'ServiceIntegrationDatadogUserConfigDatadogTag',
     'ServiceIntegrationDatadogUserConfigOpensearch',
     'ServiceIntegrationDatadogUserConfigRedis',
+    'ServiceIntegrationEndpointAutoscalerUserConfig',
+    'ServiceIntegrationEndpointAutoscalerUserConfigAutoscaling',
     'ServiceIntegrationEndpointDatadogUserConfig',
     'ServiceIntegrationEndpointDatadogUserConfigDatadogTag',
     'ServiceIntegrationEndpointExternalAwsCloudwatchLogsUserConfig',
@@ -264,6 +270,7 @@ __all__ = [
     'ServiceIntegrationEndpointExternalMysqlUserConfig',
     'ServiceIntegrationEndpointExternalOpensearchLogsUserConfig',
     'ServiceIntegrationEndpointExternalPostgresql',
+    'ServiceIntegrationEndpointExternalPrometheusUserConfig',
     'ServiceIntegrationEndpointExternalSchemaRegistryUserConfig',
     'ServiceIntegrationEndpointJolokiaUserConfig',
     'ServiceIntegrationEndpointPrometheusUserConfig',
@@ -295,6 +302,8 @@ __all__ = [
     'ThanosThanosUserConfig',
     'ThanosThanosUserConfigCompactor',
     'ThanosThanosUserConfigIpFilterObject',
+    'ThanosThanosUserConfigPrivateAccess',
+    'ThanosThanosUserConfigPrivatelinkAccess',
     'ThanosThanosUserConfigPublicAccess',
     'ThanosThanosUserConfigQuery',
     'ThanosThanosUserConfigQueryFrontend',
@@ -495,6 +504,10 @@ __all__ = [
     'GetOpenSearchOpensearchUserConfigOpensearchSearchBackpressureNodeDuressResult',
     'GetOpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchShardTaskResult',
     'GetOpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTaskResult',
+    'GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesResult',
+    'GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpuResult',
+    'GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatencyResult',
+    'GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemoryResult',
     'GetOpenSearchOpensearchUserConfigOpensearchShardIndexingPressureResult',
     'GetOpenSearchOpensearchUserConfigOpensearchShardIndexingPressureOperatingFactorResult',
     'GetOpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterResult',
@@ -550,6 +563,8 @@ __all__ = [
     'GetServiceIntegrationDatadogUserConfigDatadogTagResult',
     'GetServiceIntegrationDatadogUserConfigOpensearchResult',
     'GetServiceIntegrationDatadogUserConfigRedisResult',
+    'GetServiceIntegrationEndpointAutoscalerUserConfigResult',
+    'GetServiceIntegrationEndpointAutoscalerUserConfigAutoscalingResult',
     'GetServiceIntegrationEndpointDatadogUserConfigResult',
     'GetServiceIntegrationEndpointDatadogUserConfigDatadogTagResult',
     'GetServiceIntegrationEndpointExternalAwsCloudwatchLogsUserConfigResult',
@@ -563,6 +578,7 @@ __all__ = [
     'GetServiceIntegrationEndpointExternalMysqlUserConfigResult',
     'GetServiceIntegrationEndpointExternalOpensearchLogsUserConfigResult',
     'GetServiceIntegrationEndpointExternalPostgresqlResult',
+    'GetServiceIntegrationEndpointExternalPrometheusUserConfigResult',
     'GetServiceIntegrationEndpointExternalSchemaRegistryUserConfigResult',
     'GetServiceIntegrationEndpointJolokiaUserConfigResult',
     'GetServiceIntegrationEndpointPrometheusUserConfigResult',
@@ -594,6 +610,8 @@ __all__ = [
     'GetThanosThanosUserConfigResult',
     'GetThanosThanosUserConfigCompactorResult',
     'GetThanosThanosUserConfigIpFilterObjectResult',
+    'GetThanosThanosUserConfigPrivateAccessResult',
+    'GetThanosThanosUserConfigPrivatelinkAccessResult',
     'GetThanosThanosUserConfigPublicAccessResult',
     'GetThanosThanosUserConfigQueryResult',
     'GetThanosThanosUserConfigQueryFrontendResult',
@@ -834,7 +852,6 @@ class CassandraCassandraUserConfig(dict):
 
     @property
     @pulumi.getter(name="additionalBackupRegions")
-    @_utilities.deprecated("""This property is deprecated.""")
     def additional_backup_regions(self) -> Optional[str]:
         """
         Additional Cloud Regions for Backup Replication.
@@ -2379,7 +2396,7 @@ class DragonflyDragonflyUserConfig(dict):
                  static_ips: Optional[bool] = None):
         """
         :param bool cache_mode: Evict entries when getting close to maxmemory limit. Default: `false`.
-        :param str dragonfly_persistence: Enum: `off`, `rdb`, `dfs`. When persistence is `rdb` or `dfs`, Dragonfly does RDB or DFS dumps every 10 minutes. Dumps are done according to the backup schedule for backup purposes. When persistence is `off`, no RDB/DFS dumps or backups are done, so data can be lost at any moment if the service is restarted for any reason, or if the service is powered off. Also, the service can't be forked.
+        :param str dragonfly_persistence: Enum: `dfs`, `off`, `rdb`. When persistence is `rdb` or `dfs`, Dragonfly does RDB or DFS dumps every 10 minutes. Dumps are done according to the backup schedule for backup purposes. When persistence is `off`, no RDB/DFS dumps or backups are done, so data can be lost at any moment if the service is restarted for any reason, or if the service is powered off. Also, the service can't be forked.
         :param bool dragonfly_ssl: Require SSL to access Dragonfly. Default: `true`.
         :param Sequence['DragonflyDragonflyUserConfigIpFilterObjectArgs'] 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`.
@@ -2437,7 +2454,7 @@ class DragonflyDragonflyUserConfig(dict):
     @pulumi.getter(name="dragonflyPersistence")
     def dragonfly_persistence(self) -> Optional[str]:
         """
-        Enum: `off`, `rdb`, `dfs`. When persistence is `rdb` or `dfs`, Dragonfly does RDB or DFS dumps every 10 minutes. Dumps are done according to the backup schedule for backup purposes. When persistence is `off`, no RDB/DFS dumps or backups are done, so data can be lost at any moment if the service is restarted for any reason, or if the service is powered off. Also, the service can't be forked.
+        Enum: `dfs`, `off`, `rdb`. When persistence is `rdb` or `dfs`, Dragonfly does RDB or DFS dumps every 10 minutes. Dumps are done according to the backup schedule for backup purposes. When persistence is `off`, no RDB/DFS dumps or backups are done, so data can be lost at any moment if the service is restarted for any reason, or if the service is powered off. Also, the service can't be forked.
         """
         return pulumi.get(self, "dragonfly_persistence")
 
@@ -3808,10 +3825,10 @@ class GrafanaGrafanaUserConfig(dict):
                  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.
+        :param bool alerting_enabled: Setting has no effect with Grafana 11 and onward. Enable or disable Grafana legacy alerting functionality. This should not be enabled with unified*alerting*enabled.
         :param str alerting_error_or_timeout: Enum: `alerting`, `keep_state`. Default error or timeout setting for new alerting rules.
         :param int alerting_max_annotations_to_keep: Max number of alert annotations that Grafana stores. 0 (default) keeps all alert annotations. Example: `0`.
-        :param str alerting_nodata_or_nullvalues: Enum: `alerting`, `no_data`, `keep_state`, `ok`. Default value for 'no data or null values' for new alerting rules.
+        :param str alerting_nodata_or_nullvalues: Enum: `alerting`, `keep_state`, `no_data`, `ok`. Default value for 'no data or null values' for new alerting rules.
         :param bool allow_embedding: Allow embedding Grafana dashboards with iframe/frame/object/embed tags. Disabled by default to limit impact of clickjacking.
         :param 'GrafanaGrafanaUserConfigAuthAzureadArgs' auth_azuread: Azure AD OAuth integration
         :param bool auth_basic_enabled: Enable or disable basic authentication form, used by Grafana built-in login.
@@ -3819,9 +3836,9 @@ class GrafanaGrafanaUserConfig(dict):
         :param 'GrafanaGrafanaUserConfigAuthGithubArgs' auth_github: Github Auth integration
         :param 'GrafanaGrafanaUserConfigAuthGitlabArgs' auth_gitlab: GitLab Auth integration
         :param 'GrafanaGrafanaUserConfigAuthGoogleArgs' auth_google: Google Auth integration
-        :param str cookie_samesite: Enum: `lax`, `strict`, `none`. Cookie SameSite attribute: `strict` prevents sending cookie for cross-site requests, effectively disabling direct linking from other sites to Grafana. `lax` is the default value.
+        :param str cookie_samesite: Enum: `lax`, `none`, `strict`. Cookie SameSite attribute: `strict` prevents sending cookie for cross-site requests, effectively disabling direct linking from other sites to Grafana. `lax` is the default value.
         :param str custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. Example: `grafana.example.org`.
-        :param bool dashboard_previews_enabled: This feature is new in Grafana 9 and is quite resource intensive. It may cause low-end plans to work more slowly while the dashboard previews are rendering.
+        :param bool dashboard_previews_enabled: Enable browsing of dashboards in grid (pictures) mode. This feature is new in Grafana 9 and is quite resource intensive. It may cause low-end plans to work more slowly while the dashboard previews are rendering.
         :param str dashboards_min_refresh_interval: Signed sequence of decimal numbers, followed by a unit suffix (ms, s, m, h, d), e.g. 30s, 1h. Example: `5s`.
         :param int dashboards_versions_to_keep: Dashboard versions to keep per dashboard. Example: `20`.
         :param bool dataproxy_send_user_header: Send `X-Grafana-User` header to data source.
@@ -3834,7 +3851,7 @@ class GrafanaGrafanaUserConfig(dict):
         :param Sequence['GrafanaGrafanaUserConfigIpFilterObjectArgs'] 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`.
-        :param bool metrics_enabled: Enable Grafana /metrics endpoint.
+        :param bool metrics_enabled: Enable Grafana's /metrics endpoint.
         :param bool oauth_allow_insecure_email_lookup: Enforce user lookup based on email instead of the unique ID provided by the IdP.
         :param 'GrafanaGrafanaUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
         :param 'GrafanaGrafanaUserConfigPrivatelinkAccessArgs' privatelink_access: Allow access to selected service components through Privatelink
@@ -3845,9 +3862,9 @@ class GrafanaGrafanaUserConfig(dict):
         :param str service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
         :param 'GrafanaGrafanaUserConfigSmtpServerArgs' smtp_server: SMTP server settings
         :param bool static_ips: Use static public IP addresses.
-        :param bool unified_alerting_enabled: Enable or disable Grafana unified alerting functionality. By default this is enabled and any legacy alerts will be migrated on upgrade to Grafana 9+. To stay on legacy alerting, set unified*alerting*enabled to false and alerting_enabled to true. See https://grafana.com/docs/grafana/latest/alerting/set-up/migrating-alerts/ for more details.
+        :param bool unified_alerting_enabled: Enable or disable Grafana unified alerting functionality. By default this is enabled and any legacy alerts will be migrated on upgrade to Grafana 9+. To stay on legacy alerting, set unified*alerting*enabled to false and alerting_enabled to true. See https://grafana.com/docs/grafana/latest/alerting/ for more details.
         :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 str user_auto_assign_org_role: Enum: `Admin`, `Editor`, `Viewer`. 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).
         """
@@ -3950,7 +3967,7 @@ class GrafanaGrafanaUserConfig(dict):
     @pulumi.getter(name="alertingEnabled")
     def alerting_enabled(self) -> Optional[bool]:
         """
-        Enable or disable Grafana legacy alerting functionality. This should not be enabled with unified*alerting*enabled.
+        Setting has no effect with Grafana 11 and onward. Enable or disable Grafana legacy alerting functionality. This should not be enabled with unified*alerting*enabled.
         """
         return pulumi.get(self, "alerting_enabled")
 
@@ -3974,7 +3991,7 @@ class GrafanaGrafanaUserConfig(dict):
     @pulumi.getter(name="alertingNodataOrNullvalues")
     def alerting_nodata_or_nullvalues(self) -> Optional[str]:
         """
-        Enum: `alerting`, `no_data`, `keep_state`, `ok`. Default value for 'no data or null values' for new alerting rules.
+        Enum: `alerting`, `keep_state`, `no_data`, `ok`. Default value for 'no data or null values' for new alerting rules.
         """
         return pulumi.get(self, "alerting_nodata_or_nullvalues")
 
@@ -4038,7 +4055,7 @@ class GrafanaGrafanaUserConfig(dict):
     @pulumi.getter(name="cookieSamesite")
     def cookie_samesite(self) -> Optional[str]:
         """
-        Enum: `lax`, `strict`, `none`. Cookie SameSite attribute: `strict` prevents sending cookie for cross-site requests, effectively disabling direct linking from other sites to Grafana. `lax` is the default value.
+        Enum: `lax`, `none`, `strict`. Cookie SameSite attribute: `strict` prevents sending cookie for cross-site requests, effectively disabling direct linking from other sites to Grafana. `lax` is the default value.
         """
         return pulumi.get(self, "cookie_samesite")
 
@@ -4054,7 +4071,7 @@ class GrafanaGrafanaUserConfig(dict):
     @pulumi.getter(name="dashboardPreviewsEnabled")
     def dashboard_previews_enabled(self) -> Optional[bool]:
         """
-        This feature is new in Grafana 9 and is quite resource intensive. It may cause low-end plans to work more slowly while the dashboard previews are rendering.
+        Enable browsing of dashboards in grid (pictures) mode. This feature is new in Grafana 9 and is quite resource intensive. It may cause low-end plans to work more slowly while the dashboard previews are rendering.
         """
         return pulumi.get(self, "dashboard_previews_enabled")
 
@@ -4159,7 +4176,7 @@ class GrafanaGrafanaUserConfig(dict):
     @pulumi.getter(name="metricsEnabled")
     def metrics_enabled(self) -> Optional[bool]:
         """
-        Enable Grafana /metrics endpoint.
+        Enable Grafana's /metrics endpoint.
         """
         return pulumi.get(self, "metrics_enabled")
 
@@ -4247,7 +4264,7 @@ class GrafanaGrafanaUserConfig(dict):
     @pulumi.getter(name="unifiedAlertingEnabled")
     def unified_alerting_enabled(self) -> Optional[bool]:
         """
-        Enable or disable Grafana unified alerting functionality. By default this is enabled and any legacy alerts will be migrated on upgrade to Grafana 9+. To stay on legacy alerting, set unified*alerting*enabled to false and alerting_enabled to true. See https://grafana.com/docs/grafana/latest/alerting/set-up/migrating-alerts/ for more details.
+        Enable or disable Grafana unified alerting functionality. By default this is enabled and any legacy alerts will be migrated on upgrade to Grafana 9+. To stay on legacy alerting, set unified*alerting*enabled to false and alerting_enabled to true. See https://grafana.com/docs/grafana/latest/alerting/ for more details.
         """
         return pulumi.get(self, "unified_alerting_enabled")
 
@@ -4263,7 +4280,7 @@ class GrafanaGrafanaUserConfig(dict):
     @pulumi.getter(name="userAutoAssignOrgRole")
     def user_auto_assign_org_role(self) -> Optional[str]:
         """
-        Enum: `Viewer`, `Admin`, `Editor`. Set role for new signups. Defaults to Viewer.
+        Enum: `Admin`, `Editor`, `Viewer`. Set role for new signups. Defaults to Viewer.
         """
         return pulumi.get(self, "user_auto_assign_org_role")
 
@@ -4743,9 +4760,9 @@ class GrafanaGrafanaUserConfigAuthGitlab(dict):
         :param str client_id: Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
         :param str client_secret: Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
         :param bool allow_sign_up: Automatically sign-up users on successful sign-in.
-        :param str api_url: API URL. This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/api/v4`.
-        :param str auth_url: Authorization URL. This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/authorize`.
-        :param str token_url: Token URL. This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/token`.
+        :param str api_url: This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/api/v4`.
+        :param str auth_url: This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/authorize`.
+        :param str token_url: This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/token`.
         """
         pulumi.set(__self__, "allowed_groups", allowed_groups)
         pulumi.set(__self__, "client_id", client_id)
@@ -4795,7 +4812,7 @@ class GrafanaGrafanaUserConfigAuthGitlab(dict):
     @pulumi.getter(name="apiUrl")
     def api_url(self) -> Optional[str]:
         """
-        API URL. This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/api/v4`.
+        This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/api/v4`.
         """
         return pulumi.get(self, "api_url")
 
@@ -4803,7 +4820,7 @@ class GrafanaGrafanaUserConfigAuthGitlab(dict):
     @pulumi.getter(name="authUrl")
     def auth_url(self) -> Optional[str]:
         """
-        Authorization URL. This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/authorize`.
+        This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/authorize`.
         """
         return pulumi.get(self, "auth_url")
 
@@ -4811,7 +4828,7 @@ class GrafanaGrafanaUserConfigAuthGitlab(dict):
     @pulumi.getter(name="tokenUrl")
     def token_url(self) -> Optional[str]:
         """
-        Token URL. This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/token`.
+        This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/token`.
         """
         return pulumi.get(self, "token_url")
 
@@ -5056,7 +5073,7 @@ class GrafanaGrafanaUserConfigExternalImageStorage(dict):
         """
         :param str access_key: S3 access key. Requires permissions to the S3 bucket for the s3:PutObject and s3:PutObjectAcl actions. Example: `AAAAAAAAAAAAAAAAAAA`.
         :param str bucket_url: Bucket URL for S3. Example: `https://grafana.s3-ap-southeast-2.amazonaws.com/`.
-        :param str provider: Enum: `s3`. Provider type.
+        :param str provider: Enum: `s3`. External image store provider.
         :param str secret_key: S3 secret key. Example: `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`.
         """
         pulumi.set(__self__, "access_key", access_key)
@@ -5084,7 +5101,7 @@ class GrafanaGrafanaUserConfigExternalImageStorage(dict):
     @pulumi.getter
     def provider(self) -> str:
         """
-        Enum: `s3`. Provider type.
+        Enum: `s3`. External image store provider.
         """
         return pulumi.get(self, "provider")
 
@@ -5225,7 +5242,7 @@ class GrafanaGrafanaUserConfigSmtpServer(dict):
         :param str from_name: Name used in outgoing emails, defaults to Grafana.
         :param str password: Password for SMTP authentication. Example: `ein0eemeev5eeth3Ahfu`.
         :param bool skip_verify: Skip verifying server certificate. Defaults to false.
-        :param str starttls_policy: Enum: `OpportunisticStartTLS`, `MandatoryStartTLS`, `NoStartTLS`. Either OpportunisticStartTLS, MandatoryStartTLS or NoStartTLS. Default is OpportunisticStartTLS.
+        :param str starttls_policy: Enum: `MandatoryStartTLS`, `NoStartTLS`, `OpportunisticStartTLS`. Either OpportunisticStartTLS, MandatoryStartTLS or NoStartTLS. Default is OpportunisticStartTLS.
         :param str username: Username for SMTP authentication. Example: `smtpuser`.
         """
         pulumi.set(__self__, "from_address", from_address)
@@ -5294,7 +5311,7 @@ class GrafanaGrafanaUserConfigSmtpServer(dict):
     @pulumi.getter(name="starttlsPolicy")
     def starttls_policy(self) -> Optional[str]:
         """
-        Enum: `OpportunisticStartTLS`, `MandatoryStartTLS`, `NoStartTLS`. Either OpportunisticStartTLS, MandatoryStartTLS or NoStartTLS. Default is OpportunisticStartTLS.
+        Enum: `MandatoryStartTLS`, `NoStartTLS`, `OpportunisticStartTLS`. Either OpportunisticStartTLS, MandatoryStartTLS or NoStartTLS. Default is OpportunisticStartTLS.
         """
         return pulumi.get(self, "starttls_policy")
 
@@ -5605,6 +5622,8 @@ class InfluxDbInfluxdbUserConfig(dict):
             suggest = "additional_backup_regions"
         elif key == "customDomain":
             suggest = "custom_domain"
+        elif key == "influxdbVersion":
+            suggest = "influxdb_version"
         elif key == "ipFilterObjects":
             suggest = "ip_filter_objects"
         elif key == "ipFilterStrings":
@@ -5643,6 +5662,7 @@ class InfluxDbInfluxdbUserConfig(dict):
                  additional_backup_regions: Optional[str] = None,
                  custom_domain: Optional[str] = None,
                  influxdb: Optional['outputs.InfluxDbInfluxdbUserConfigInfluxdb'] = None,
+                 influxdb_version: Optional[str] = None,
                  ip_filter_objects: Optional[Sequence['outputs.InfluxDbInfluxdbUserConfigIpFilterObject']] = None,
                  ip_filter_strings: Optional[Sequence[str]] = None,
                  ip_filters: Optional[Sequence[str]] = None,
@@ -5658,6 +5678,7 @@ class InfluxDbInfluxdbUserConfig(dict):
         :param str additional_backup_regions: Additional Cloud Regions for Backup Replication.
         :param str custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. Example: `grafana.example.org`.
         :param 'InfluxDbInfluxdbUserConfigInfluxdbArgs' influxdb: influxdb.conf configuration values
+        :param str influxdb_version: Enum: `1.8`, and newer. InfluxDB major version. Default: `1.8`.
         :param Sequence['InfluxDbInfluxdbUserConfigIpFilterObjectArgs'] 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`.
@@ -5676,6 +5697,8 @@ class InfluxDbInfluxdbUserConfig(dict):
             pulumi.set(__self__, "custom_domain", custom_domain)
         if influxdb is not None:
             pulumi.set(__self__, "influxdb", influxdb)
+        if influxdb_version is not None:
+            pulumi.set(__self__, "influxdb_version", influxdb_version)
         if ip_filter_objects is not None:
             pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
         if ip_filter_strings is not None:
@@ -5724,6 +5747,14 @@ class InfluxDbInfluxdbUserConfig(dict):
         """
         return pulumi.get(self, "influxdb")
 
+    @property
+    @pulumi.getter(name="influxdbVersion")
+    def influxdb_version(self) -> Optional[str]:
+        """
+        Enum: `1.8`, and newer. InfluxDB major version. Default: `1.8`.
+        """
+        return pulumi.get(self, "influxdb_version")
+
     @property
     @pulumi.getter(name="ipFilterObjects")
     def ip_filter_objects(self) -> Optional[Sequence['outputs.InfluxDbInfluxdbUserConfigIpFilterObject']]:
@@ -5966,13 +5997,34 @@ class InfluxDbInfluxdbUserConfigIpFilterObject(dict):
 
 @pulumi.output_type
 class InfluxDbInfluxdbUserConfigPrivateAccess(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "userBackup":
+            suggest = "user_backup"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InfluxDbInfluxdbUserConfigPrivateAccess. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InfluxDbInfluxdbUserConfigPrivateAccess.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InfluxDbInfluxdbUserConfigPrivateAccess.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 influxdb: Optional[bool] = None):
+                 influxdb: Optional[bool] = None,
+                 user_backup: Optional[bool] = None):
         """
         :param bool influxdb: Allow clients to connect to influxdb with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        :param bool user_backup: Allow clients to connect to user_backup with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
         """
         if influxdb is not None:
             pulumi.set(__self__, "influxdb", influxdb)
+        if user_backup is not None:
+            pulumi.set(__self__, "user_backup", user_backup)
 
     @property
     @pulumi.getter
@@ -5982,16 +6034,45 @@ class InfluxDbInfluxdbUserConfigPrivateAccess(dict):
         """
         return pulumi.get(self, "influxdb")
 
+    @property
+    @pulumi.getter(name="userBackup")
+    def user_backup(self) -> Optional[bool]:
+        """
+        Allow clients to connect to user_backup with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        return pulumi.get(self, "user_backup")
+
 
 @pulumi.output_type
 class InfluxDbInfluxdbUserConfigPrivatelinkAccess(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "userBackup":
+            suggest = "user_backup"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InfluxDbInfluxdbUserConfigPrivatelinkAccess. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InfluxDbInfluxdbUserConfigPrivatelinkAccess.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InfluxDbInfluxdbUserConfigPrivatelinkAccess.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 influxdb: Optional[bool] = None):
+                 influxdb: Optional[bool] = None,
+                 user_backup: Optional[bool] = None):
         """
         :param bool influxdb: Enable influxdb.
+        :param bool user_backup: Enable user_backup.
         """
         if influxdb is not None:
             pulumi.set(__self__, "influxdb", influxdb)
+        if user_backup is not None:
+            pulumi.set(__self__, "user_backup", user_backup)
 
     @property
     @pulumi.getter
@@ -6001,16 +6082,45 @@ class InfluxDbInfluxdbUserConfigPrivatelinkAccess(dict):
         """
         return pulumi.get(self, "influxdb")
 
+    @property
+    @pulumi.getter(name="userBackup")
+    def user_backup(self) -> Optional[bool]:
+        """
+        Enable user_backup.
+        """
+        return pulumi.get(self, "user_backup")
+
 
 @pulumi.output_type
 class InfluxDbInfluxdbUserConfigPublicAccess(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "userBackup":
+            suggest = "user_backup"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InfluxDbInfluxdbUserConfigPublicAccess. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InfluxDbInfluxdbUserConfigPublicAccess.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InfluxDbInfluxdbUserConfigPublicAccess.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 influxdb: Optional[bool] = None):
+                 influxdb: Optional[bool] = None,
+                 user_backup: Optional[bool] = None):
         """
         :param bool influxdb: Allow clients to connect to influxdb from the public internet for service nodes that are in a project VPC or another type of private network.
+        :param bool user_backup: Allow clients to connect to user_backup from the public internet for service nodes that are in a project VPC or another type of private network.
         """
         if influxdb is not None:
             pulumi.set(__self__, "influxdb", influxdb)
+        if user_backup is not None:
+            pulumi.set(__self__, "user_backup", user_backup)
 
     @property
     @pulumi.getter
@@ -6020,6 +6130,14 @@ class InfluxDbInfluxdbUserConfigPublicAccess(dict):
         """
         return pulumi.get(self, "influxdb")
 
+    @property
+    @pulumi.getter(name="userBackup")
+    def user_backup(self) -> Optional[bool]:
+        """
+        Allow clients to connect to user_backup from the public internet for service nodes that are in a project VPC or another type of private network.
+        """
+        return pulumi.get(self, "user_backup")
+
 
 @pulumi.output_type
 class InfluxDbServiceIntegration(dict):
@@ -6631,10 +6749,10 @@ class KafkaConnectKafkaConnectUserConfigKafkaConnect(dict):
                  scheduled_rebalance_max_delay_ms: Optional[int] = None,
                  session_timeout_ms: Optional[int] = None):
         """
-        :param str connector_client_config_override_policy: Enum: `None`, `All`. Defines what client configurations can be overridden by the connector. Default is None.
+        :param str connector_client_config_override_policy: Enum: `All`, `None`. Defines what client configurations can be overridden by the connector. Default is None.
         :param str consumer_auto_offset_reset: Enum: `earliest`, `latest`. What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
         :param int consumer_fetch_max_bytes: Records are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not a absolute maximum. Example: `52428800`.
-        :param str consumer_isolation_level: Enum: `read_uncommitted`, `read_committed`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
+        :param str consumer_isolation_level: Enum: `read_committed`, `read_uncommitted`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
         :param int consumer_max_partition_fetch_bytes: Records are fetched in batches by the consumer.If the first record batch in the first non-empty partition of the fetch is larger than this limit, the batch will still be returned to ensure that the consumer can make progress. Example: `1048576`.
         :param int consumer_max_poll_interval_ms: The maximum delay in milliseconds between invocations of poll() when using consumer group management (defaults to 300000).
         :param int consumer_max_poll_records: The maximum number of records returned in a single call to poll() (defaults to 500).
@@ -6642,7 +6760,7 @@ class KafkaConnectKafkaConnectUserConfigKafkaConnect(dict):
         :param int offset_flush_timeout_ms: Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt (defaults to 5000).
         :param int producer_batch_size: This setting gives the upper bound of the batch size to be sent. If there are fewer than this many bytes accumulated for this partition, the producer will `linger` for the linger.ms time waiting for more records to show up. A batch size of zero will disable batching entirely (defaults to 16384).
         :param int producer_buffer_memory: The total bytes of memory the producer can use to buffer records waiting to be sent to the broker (defaults to 33554432).
-        :param str producer_compression_type: Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
+        :param str producer_compression_type: Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
         :param int producer_linger_ms: This setting gives the upper bound on the delay for batching: once there is batch.size worth of records for a partition it will be sent immediately regardless of this setting, however if there are fewer than this many bytes accumulated for this partition the producer will `linger` for the specified time waiting for more records to show up. Defaults to 0.
         :param int producer_max_request_size: This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests. Example: `1048576`.
         :param int scheduled_rebalance_max_delay_ms: The maximum delay that is scheduled in order to wait for the return of one or more departed workers before rebalancing and reassigning their connectors and tasks to the group. During this period the connectors and tasks of the departed workers remain unassigned. Defaults to 5 minutes.
@@ -6685,7 +6803,7 @@ class KafkaConnectKafkaConnectUserConfigKafkaConnect(dict):
     @pulumi.getter(name="connectorClientConfigOverridePolicy")
     def connector_client_config_override_policy(self) -> Optional[str]:
         """
-        Enum: `None`, `All`. Defines what client configurations can be overridden by the connector. Default is None.
+        Enum: `All`, `None`. Defines what client configurations can be overridden by the connector. Default is None.
         """
         return pulumi.get(self, "connector_client_config_override_policy")
 
@@ -6709,7 +6827,7 @@ class KafkaConnectKafkaConnectUserConfigKafkaConnect(dict):
     @pulumi.getter(name="consumerIsolationLevel")
     def consumer_isolation_level(self) -> Optional[str]:
         """
-        Enum: `read_uncommitted`, `read_committed`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
+        Enum: `read_committed`, `read_uncommitted`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
         """
         return pulumi.get(self, "consumer_isolation_level")
 
@@ -6773,7 +6891,7 @@ class KafkaConnectKafkaConnectUserConfigKafkaConnect(dict):
     @pulumi.getter(name="producerCompressionType")
     def producer_compression_type(self) -> Optional[str]:
         """
-        Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
+        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
         """
         return pulumi.get(self, "producer_compression_type")
 
@@ -6974,8 +7092,8 @@ class KafkaConnectKafkaConnectUserConfigSecretProvider(dict):
                  vault: Optional['outputs.KafkaConnectKafkaConnectUserConfigSecretProviderVault'] = None):
         """
         :param str name: Name of the secret provider. Used to reference secrets in connector config.
-        :param 'KafkaConnectKafkaConnectUserConfigSecretProviderAwsArgs' aws: AWS config for Secret Provider
-        :param 'KafkaConnectKafkaConnectUserConfigSecretProviderVaultArgs' vault: Vault Config for Secret Provider
+        :param 'KafkaConnectKafkaConnectUserConfigSecretProviderAwsArgs' aws: AWS secret provider configuration
+        :param 'KafkaConnectKafkaConnectUserConfigSecretProviderVaultArgs' vault: Vault secret provider configuration
         """
         pulumi.set(__self__, "name", name)
         if aws is not None:
@@ -6995,7 +7113,7 @@ class KafkaConnectKafkaConnectUserConfigSecretProvider(dict):
     @pulumi.getter
     def aws(self) -> Optional['outputs.KafkaConnectKafkaConnectUserConfigSecretProviderAws']:
         """
-        AWS config for Secret Provider
+        AWS secret provider configuration
         """
         return pulumi.get(self, "aws")
 
@@ -7003,7 +7121,7 @@ class KafkaConnectKafkaConnectUserConfigSecretProvider(dict):
     @pulumi.getter
     def vault(self) -> Optional['outputs.KafkaConnectKafkaConnectUserConfigSecretProviderVault']:
         """
-        Vault Config for Secret Provider
+        Vault secret provider configuration
         """
         return pulumi.get(self, "vault")
 
@@ -8001,7 +8119,7 @@ class KafkaKafkaUserConfigKafka(dict):
                  transaction_state_log_segment_bytes: Optional[int] = None):
         """
         :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 str compression_type: Enum: `gzip`, `lz4`, `producer`, `snappy`, `uncompressed`, `zstd`. 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`.
@@ -8011,8 +8129,8 @@ class KafkaKafkaUserConfigKafka(dict):
         :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 str log_cleanup_policy: Enum: `compact`, `compact,delete`, `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)).
         :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`.
@@ -8152,7 +8270,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.(Default: producer).
+        Enum: `gzip`, `lz4`, `producer`, `snappy`, `uncompressed`, `zstd`. 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")
 
@@ -8232,7 +8350,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 (Default: delete).
+        Enum: `compact`, `compact,delete`, `delete`. The default cleanup policy for segments beyond the retention window (Default: delete).
         """
         return pulumi.get(self, "log_cleanup_policy")
 
@@ -8240,7 +8358,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 (Default: 9223372036854775807 (Long.MAX_VALUE)). Example: `9223372036854775807`.
+        The number of messages accumulated on a log partition before messages are flushed to disk (Default: 9223372036854775807 (Long.MAX_VALUE)).
         """
         return pulumi.get(self, "log_flush_interval_messages")
 
@@ -8607,10 +8725,10 @@ class KafkaKafkaUserConfigKafkaConnectConfig(dict):
                  scheduled_rebalance_max_delay_ms: Optional[int] = None,
                  session_timeout_ms: Optional[int] = None):
         """
-        :param str connector_client_config_override_policy: Enum: `None`, `All`. Defines what client configurations can be overridden by the connector. Default is None.
+        :param str connector_client_config_override_policy: Enum: `All`, `None`. Defines what client configurations can be overridden by the connector. Default is None.
         :param str consumer_auto_offset_reset: Enum: `earliest`, `latest`. What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
         :param int consumer_fetch_max_bytes: Records are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not a absolute maximum. Example: `52428800`.
-        :param str consumer_isolation_level: Enum: `read_uncommitted`, `read_committed`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
+        :param str consumer_isolation_level: Enum: `read_committed`, `read_uncommitted`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
         :param int consumer_max_partition_fetch_bytes: Records are fetched in batches by the consumer.If the first record batch in the first non-empty partition of the fetch is larger than this limit, the batch will still be returned to ensure that the consumer can make progress. Example: `1048576`.
         :param int consumer_max_poll_interval_ms: The maximum delay in milliseconds between invocations of poll() when using consumer group management (defaults to 300000).
         :param int consumer_max_poll_records: The maximum number of records returned in a single call to poll() (defaults to 500).
@@ -8618,7 +8736,7 @@ class KafkaKafkaUserConfigKafkaConnectConfig(dict):
         :param int offset_flush_timeout_ms: Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt (defaults to 5000).
         :param int producer_batch_size: This setting gives the upper bound of the batch size to be sent. If there are fewer than this many bytes accumulated for this partition, the producer will `linger` for the linger.ms time waiting for more records to show up. A batch size of zero will disable batching entirely (defaults to 16384).
         :param int producer_buffer_memory: The total bytes of memory the producer can use to buffer records waiting to be sent to the broker (defaults to 33554432).
-        :param str producer_compression_type: Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
+        :param str producer_compression_type: Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
         :param int producer_linger_ms: This setting gives the upper bound on the delay for batching: once there is batch.size worth of records for a partition it will be sent immediately regardless of this setting, however if there are fewer than this many bytes accumulated for this partition the producer will `linger` for the specified time waiting for more records to show up. Defaults to 0.
         :param int producer_max_request_size: This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests. Example: `1048576`.
         :param int scheduled_rebalance_max_delay_ms: The maximum delay that is scheduled in order to wait for the return of one or more departed workers before rebalancing and reassigning their connectors and tasks to the group. During this period the connectors and tasks of the departed workers remain unassigned. Defaults to 5 minutes.
@@ -8661,7 +8779,7 @@ class KafkaKafkaUserConfigKafkaConnectConfig(dict):
     @pulumi.getter(name="connectorClientConfigOverridePolicy")
     def connector_client_config_override_policy(self) -> Optional[str]:
         """
-        Enum: `None`, `All`. Defines what client configurations can be overridden by the connector. Default is None.
+        Enum: `All`, `None`. Defines what client configurations can be overridden by the connector. Default is None.
         """
         return pulumi.get(self, "connector_client_config_override_policy")
 
@@ -8685,7 +8803,7 @@ class KafkaKafkaUserConfigKafkaConnectConfig(dict):
     @pulumi.getter(name="consumerIsolationLevel")
     def consumer_isolation_level(self) -> Optional[str]:
         """
-        Enum: `read_uncommitted`, `read_committed`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
+        Enum: `read_committed`, `read_uncommitted`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
         """
         return pulumi.get(self, "consumer_isolation_level")
 
@@ -8749,7 +8867,7 @@ class KafkaKafkaUserConfigKafkaConnectConfig(dict):
     @pulumi.getter(name="producerCompressionType")
     def producer_compression_type(self) -> Optional[str]:
         """
-        Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
+        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
         """
         return pulumi.get(self, "producer_compression_type")
 
@@ -8794,8 +8912,8 @@ class KafkaKafkaUserConfigKafkaConnectSecretProvider(dict):
                  vault: Optional['outputs.KafkaKafkaUserConfigKafkaConnectSecretProviderVault'] = None):
         """
         :param str name: Name of the secret provider. Used to reference secrets in connector config.
-        :param 'KafkaKafkaUserConfigKafkaConnectSecretProviderAwsArgs' aws: AWS config for Secret Provider
-        :param 'KafkaKafkaUserConfigKafkaConnectSecretProviderVaultArgs' vault: Vault Config for Secret Provider
+        :param 'KafkaKafkaUserConfigKafkaConnectSecretProviderAwsArgs' aws: AWS secret provider configuration
+        :param 'KafkaKafkaUserConfigKafkaConnectSecretProviderVaultArgs' vault: Vault secret provider configuration
         """
         pulumi.set(__self__, "name", name)
         if aws is not None:
@@ -8815,7 +8933,7 @@ class KafkaKafkaUserConfigKafkaConnectSecretProvider(dict):
     @pulumi.getter
     def aws(self) -> Optional['outputs.KafkaKafkaUserConfigKafkaConnectSecretProviderAws']:
         """
-        AWS config for Secret Provider
+        AWS secret provider configuration
         """
         return pulumi.get(self, "aws")
 
@@ -8823,7 +8941,7 @@ class KafkaKafkaUserConfigKafkaConnectSecretProvider(dict):
     @pulumi.getter
     def vault(self) -> Optional['outputs.KafkaKafkaUserConfigKafkaConnectSecretProviderVault']:
         """
-        Vault Config for Secret Provider
+        Vault secret provider configuration
         """
         return pulumi.get(self, "vault")
 
@@ -9040,10 +9158,10 @@ class KafkaKafkaUserConfigKafkaRestConfig(dict):
         :param bool consumer_enable_auto_commit: If true the consumer's offset will be periodically committed to Kafka in the background. Default: `true`.
         :param int consumer_request_max_bytes: Maximum number of bytes in unencoded message keys and values by a single request. Default: `67108864`.
         :param int consumer_request_timeout_ms: Enum: `1000`, `15000`, `30000`. The maximum total time to wait for messages for a request if the maximum number of messages has not yet been reached. Default: `1000`.
-        :param str name_strategy: Enum: `topic_name`, `record_name`, `topic_record_name`. Name strategy to use when selecting subject for storing schemas. Default: `topic_name`.
+        :param str name_strategy: Enum: `record_name`, `topic_name`, `topic_record_name`. Name strategy to use when selecting subject for storing schemas. Default: `topic_name`.
         :param bool name_strategy_validation: If true, validate that given schema is registered under expected subject name by the used name strategy when producing messages. Default: `true`.
-        :param str producer_acks: Enum: `all`, `-1`, `0`, `1`. The number of acknowledgments the producer requires the leader to have received before considering a request complete. If set to `all` or `-1`, the leader will wait for the full set of in-sync replicas to acknowledge the record. Default: `1`.
-        :param str producer_compression_type: Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
+        :param str producer_acks: Enum: `-1`, `0`, `1`, `all`. The number of acknowledgments the producer requires the leader to have received before considering a request complete. If set to `all` or `-1`, the leader will wait for the full set of in-sync replicas to acknowledge the record. Default: `1`.
+        :param str producer_compression_type: Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
         :param int producer_linger_ms: Wait for up to the given delay to allow batching records together. Default: `0`.
         :param int producer_max_request_size: The maximum size of a request in bytes. Note that Kafka broker can also cap the record batch size. Default: `1048576`.
         :param int simpleconsumer_pool_size_max: Maximum number of SimpleConsumers that can be instantiated per broker. Default: `25`.
@@ -9097,7 +9215,7 @@ class KafkaKafkaUserConfigKafkaRestConfig(dict):
     @pulumi.getter(name="nameStrategy")
     def name_strategy(self) -> Optional[str]:
         """
-        Enum: `topic_name`, `record_name`, `topic_record_name`. Name strategy to use when selecting subject for storing schemas. Default: `topic_name`.
+        Enum: `record_name`, `topic_name`, `topic_record_name`. Name strategy to use when selecting subject for storing schemas. Default: `topic_name`.
         """
         return pulumi.get(self, "name_strategy")
 
@@ -9113,7 +9231,7 @@ class KafkaKafkaUserConfigKafkaRestConfig(dict):
     @pulumi.getter(name="producerAcks")
     def producer_acks(self) -> Optional[str]:
         """
-        Enum: `all`, `-1`, `0`, `1`. The number of acknowledgments the producer requires the leader to have received before considering a request complete. If set to `all` or `-1`, the leader will wait for the full set of in-sync replicas to acknowledge the record. Default: `1`.
+        Enum: `-1`, `0`, `1`, `all`. The number of acknowledgments the producer requires the leader to have received before considering a request complete. If set to `all` or `-1`, the leader will wait for the full set of in-sync replicas to acknowledge the record. Default: `1`.
         """
         return pulumi.get(self, "producer_acks")
 
@@ -9121,7 +9239,7 @@ class KafkaKafkaUserConfigKafkaRestConfig(dict):
     @pulumi.getter(name="producerCompressionType")
     def producer_compression_type(self) -> Optional[str]:
         """
-        Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
+        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
         """
         return pulumi.get(self, "producer_compression_type")
 
@@ -10432,8 +10550,8 @@ class KafkaTopicConfig(dict):
                  segment_ms: Optional[str] = None,
                  unclean_leader_election_enable: Optional[bool] = None):
         """
-        :param str cleanup_policy: cleanup.policy value
-        :param str compression_type: compression.type value
+        :param str cleanup_policy: cleanup.policy value. The possible values are `delete`, `compact` and `compact,delete`.
+        :param str compression_type: compression.type value. The possible values are `snappy`, `gzip`, `lz4`, `producer`, `uncompressed` and `zstd`.
         :param str delete_retention_ms: delete.retention.ms value
         :param str file_delete_delay_ms: file.delete.delay.ms value
         :param str flush_messages: flush.messages value
@@ -10444,9 +10562,9 @@ class KafkaTopicConfig(dict):
         :param str max_compaction_lag_ms: max.compaction.lag.ms value
         :param str max_message_bytes: max.message.bytes value
         :param bool message_downconversion_enable: message.downconversion.enable value
-        :param str message_format_version: message.format.version value
+        :param str message_format_version: message.format.version value. The possible values are `0.8.0`, `0.8.1`, `0.8.2`, `0.9.0`, `0.10.0`, `0.10.0-IV0`, `0.10.0-IV1`, `0.10.1`, `0.10.1-IV0`, `0.10.1-IV1`, `0.10.1-IV2`, `0.10.2`, `0.10.2-IV0`, `0.11.0`, `0.11.0-IV0`, `0.11.0-IV1`, `0.11.0-IV2`, `1.0`, `1.0-IV0`, `1.1`, `1.1-IV0`, `2.0`, `2.0-IV0`, `2.0-IV1`, `2.1`, `2.1-IV0`, `2.1-IV1`, `2.1-IV2`, `2.2`, `2.2-IV0`, `2.2-IV1`, `2.3`, `2.3-IV0`, `2.3-IV1`, `2.4`, `2.4-IV0`, `2.4-IV1`, `2.5`, `2.5-IV0`, `2.6`, `2.6-IV0`, `2.7`, `2.7-IV0`, `2.7-IV1`, `2.7-IV2`, `2.8`, `2.8-IV0`, `2.8-IV1`, `3.0`, `3.0-IV0`, `3.0-IV1`, `3.1`, `3.1-IV0`, `3.2`, `3.2-IV0`, `3.3`, `3.3-IV0`, `3.3-IV1`, `3.3-IV2`, `3.3-IV3`, `3.4`, `3.4-IV0`, `3.5`, `3.5-IV0`, `3.5-IV1`, `3.5-IV2`, `3.6`, `3.6-IV0`, `3.6-IV1`, `3.6-IV2`, `3.7`, `3.7-IV0`, `3.7-IV1`, `3.7-IV2`, `3.7-IV3`, `3.7-IV4`, `3.8`, `3.8-IV0`, `3.9`, `3.9-IV0` and `3.9-IV1`.
         :param str message_timestamp_difference_max_ms: message.timestamp.difference.max.ms value
-        :param str message_timestamp_type: message.timestamp.type value
+        :param str message_timestamp_type: message.timestamp.type value. The possible values are `CreateTime` and `LogAppendTime`.
         :param float min_cleanable_dirty_ratio: min.cleanable.dirty.ratio value
         :param str min_compaction_lag_ms: min.compaction.lag.ms value
         :param str min_insync_replicas: min.insync.replicas value
@@ -10519,7 +10637,7 @@ class KafkaTopicConfig(dict):
     @pulumi.getter(name="cleanupPolicy")
     def cleanup_policy(self) -> Optional[str]:
         """
-        cleanup.policy value
+        cleanup.policy value. The possible values are `delete`, `compact` and `compact,delete`.
         """
         return pulumi.get(self, "cleanup_policy")
 
@@ -10527,7 +10645,7 @@ class KafkaTopicConfig(dict):
     @pulumi.getter(name="compressionType")
     def compression_type(self) -> Optional[str]:
         """
-        compression.type value
+        compression.type value. The possible values are `snappy`, `gzip`, `lz4`, `producer`, `uncompressed` and `zstd`.
         """
         return pulumi.get(self, "compression_type")
 
@@ -10615,7 +10733,7 @@ class KafkaTopicConfig(dict):
     @pulumi.getter(name="messageFormatVersion")
     def message_format_version(self) -> Optional[str]:
         """
-        message.format.version value
+        message.format.version value. The possible values are `0.8.0`, `0.8.1`, `0.8.2`, `0.9.0`, `0.10.0`, `0.10.0-IV0`, `0.10.0-IV1`, `0.10.1`, `0.10.1-IV0`, `0.10.1-IV1`, `0.10.1-IV2`, `0.10.2`, `0.10.2-IV0`, `0.11.0`, `0.11.0-IV0`, `0.11.0-IV1`, `0.11.0-IV2`, `1.0`, `1.0-IV0`, `1.1`, `1.1-IV0`, `2.0`, `2.0-IV0`, `2.0-IV1`, `2.1`, `2.1-IV0`, `2.1-IV1`, `2.1-IV2`, `2.2`, `2.2-IV0`, `2.2-IV1`, `2.3`, `2.3-IV0`, `2.3-IV1`, `2.4`, `2.4-IV0`, `2.4-IV1`, `2.5`, `2.5-IV0`, `2.6`, `2.6-IV0`, `2.7`, `2.7-IV0`, `2.7-IV1`, `2.7-IV2`, `2.8`, `2.8-IV0`, `2.8-IV1`, `3.0`, `3.0-IV0`, `3.0-IV1`, `3.1`, `3.1-IV0`, `3.2`, `3.2-IV0`, `3.3`, `3.3-IV0`, `3.3-IV1`, `3.3-IV2`, `3.3-IV3`, `3.4`, `3.4-IV0`, `3.5`, `3.5-IV0`, `3.5-IV1`, `3.5-IV2`, `3.6`, `3.6-IV0`, `3.6-IV1`, `3.6-IV2`, `3.7`, `3.7-IV0`, `3.7-IV1`, `3.7-IV2`, `3.7-IV3`, `3.7-IV4`, `3.8`, `3.8-IV0`, `3.9`, `3.9-IV0` and `3.9-IV1`.
         """
         return pulumi.get(self, "message_format_version")
 
@@ -10631,7 +10749,7 @@ class KafkaTopicConfig(dict):
     @pulumi.getter(name="messageTimestampType")
     def message_timestamp_type(self) -> Optional[str]:
         """
-        message.timestamp.type value
+        message.timestamp.type value. The possible values are `CreateTime` and `LogAppendTime`.
         """
         return pulumi.get(self, "message_timestamp_type")
 
@@ -13345,9 +13463,9 @@ class MySqlMysqlUserConfigMysql(dict):
         :param int innodb_thread_concurrency: Defines the maximum number of threads permitted inside of InnoDB. Default is 0 (infinite concurrency - no limit). Example: `10`.
         :param int innodb_write_io_threads: The number of I/O threads for write operations in InnoDB. Default is 4. Changing this parameter will lead to a restart of the MySQL service. Example: `10`.
         :param int interactive_timeout: The number of seconds the server waits for activity on an interactive connection before closing it. Example: `3600`.
-        :param str internal_tmp_mem_storage_engine: Enum: `TempTable`, `MEMORY`. The storage engine for in-memory internal temporary tables.
-        :param str log_output: Enum: `INSIGHTS`, `NONE`, `TABLE`, `INSIGHTS,TABLE`. The slow log output destination when slow*query*log is ON. To enable MySQL AI Insights, choose INSIGHTS. To use MySQL AI Insights and the mysql.slow*log table at the same time, choose INSIGHTS,TABLE. To only use the mysql.slow*log table, choose TABLE. To silence slow logs, choose NONE.
-        :param float long_query_time: The slow*query*logs work as SQL statements that take more than long*query*time seconds to execute. Example: `10`.
+        :param str internal_tmp_mem_storage_engine: Enum: `MEMORY`, `TempTable`. The storage engine for in-memory internal temporary tables.
+        :param str log_output: Enum: `INSIGHTS`, `INSIGHTS,TABLE`, `NONE`, `TABLE`. The slow log output destination when slow*query*log is ON. To enable MySQL AI Insights, choose INSIGHTS. To use MySQL AI Insights and the mysql.slow*log table at the same time, choose INSIGHTS,TABLE. To only use the mysql.slow*log table, choose TABLE. To silence slow logs, choose NONE.
+        :param float long_query_time: The slow*query*logs work as SQL statements that take more than long*query*time seconds to execute. Example: `10.0`.
         :param int max_allowed_packet: Size of the largest message in bytes that can be received by the server. Default is 67108864 (64M). Example: `67108864`.
         :param int max_heap_table_size: Limits the size of internal in-memory tables. Also set tmp*table*size. Default is 16777216 (16M). Example: `16777216`.
         :param int net_buffer_length: Start sizes of connection buffer and result buffer. Default is 16384 (16K). Changing this parameter will lead to a restart of the MySQL service. Example: `16384`.
@@ -13563,7 +13681,7 @@ class MySqlMysqlUserConfigMysql(dict):
     @pulumi.getter(name="internalTmpMemStorageEngine")
     def internal_tmp_mem_storage_engine(self) -> Optional[str]:
         """
-        Enum: `TempTable`, `MEMORY`. The storage engine for in-memory internal temporary tables.
+        Enum: `MEMORY`, `TempTable`. The storage engine for in-memory internal temporary tables.
         """
         return pulumi.get(self, "internal_tmp_mem_storage_engine")
 
@@ -13571,7 +13689,7 @@ class MySqlMysqlUserConfigMysql(dict):
     @pulumi.getter(name="logOutput")
     def log_output(self) -> Optional[str]:
         """
-        Enum: `INSIGHTS`, `NONE`, `TABLE`, `INSIGHTS,TABLE`. The slow log output destination when slow*query*log is ON. To enable MySQL AI Insights, choose INSIGHTS. To use MySQL AI Insights and the mysql.slow*log table at the same time, choose INSIGHTS,TABLE. To only use the mysql.slow*log table, choose TABLE. To silence slow logs, choose NONE.
+        Enum: `INSIGHTS`, `INSIGHTS,TABLE`, `NONE`, `TABLE`. The slow log output destination when slow*query*log is ON. To enable MySQL AI Insights, choose INSIGHTS. To use MySQL AI Insights and the mysql.slow*log table at the same time, choose INSIGHTS,TABLE. To only use the mysql.slow*log table, choose TABLE. To silence slow logs, choose NONE.
         """
         return pulumi.get(self, "log_output")
 
@@ -13579,7 +13697,7 @@ class MySqlMysqlUserConfigMysql(dict):
     @pulumi.getter(name="longQueryTime")
     def long_query_time(self) -> Optional[float]:
         """
-        The slow*query*logs work as SQL statements that take more than long*query*time seconds to execute. Example: `10`.
+        The slow*query*logs work as SQL statements that take more than long*query*time seconds to execute. Example: `10.0`.
         """
         return pulumi.get(self, "long_query_time")
 
@@ -14202,7 +14320,7 @@ class OpenSearchOpensearchUserConfig(dict):
         :param str additional_backup_regions: Additional Cloud Regions for Backup Replication.
         :param 'OpenSearchOpensearchUserConfigAzureMigrationArgs' azure_migration: Azure migration settings
         :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 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 not be activated unless specifically allowed for the project.
         :param 'OpenSearchOpensearchUserConfigGcsMigrationArgs' gcs_migration: Google Cloud Storage migration settings
         :param Sequence['OpenSearchOpensearchUserConfigIndexPatternArgs'] index_patterns: Index patterns
         :param 'OpenSearchOpensearchUserConfigIndexRollupArgs' index_rollup: Index rollup settings
@@ -14310,7 +14428,7 @@ class OpenSearchOpensearchUserConfig(dict):
     @pulumi.getter(name="disableReplicationFactorAdjustment")
     def disable_replication_factor_adjustment(self) -> Optional[bool]:
         """
-        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.
+        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 not be activated unless specifically allowed for the project.
         """
         return pulumi.get(self, "disable_replication_factor_adjustment")
 
@@ -14513,6 +14631,10 @@ class OpenSearchOpensearchUserConfigAzureMigration(dict):
             suggest = "chunk_size"
         elif key == "endpointSuffix":
             suggest = "endpoint_suffix"
+        elif key == "includeAliases":
+            suggest = "include_aliases"
+        elif key == "restoreGlobalState":
+            suggest = "restore_global_state"
         elif key == "sasToken":
             suggest = "sas_token"
 
@@ -14531,28 +14653,33 @@ class OpenSearchOpensearchUserConfigAzureMigration(dict):
                  account: str,
                  base_path: str,
                  container: str,
+                 indices: str,
                  snapshot_name: str,
                  chunk_size: Optional[str] = None,
                  compress: Optional[bool] = None,
                  endpoint_suffix: Optional[str] = None,
-                 indices: Optional[str] = None,
+                 include_aliases: Optional[bool] = None,
                  key: Optional[str] = None,
+                 restore_global_state: Optional[bool] = None,
                  sas_token: Optional[str] = None):
         """
-        :param str account: Azure account name.
+        :param str account: 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 indices: A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
         :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 indices: A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. By default, a restore operation includes all data streams and indices in the snapshot. If this argument is provided, the restore operation only includes the data streams and indices that you specify. Example: `metrics*,logs*,data-20240823`.
+        :param bool include_aliases: Whether to restore aliases alongside their associated indexes. Default is true.
         :param str key: Azure account secret key. One of key or sas_token should be specified.
+        :param bool restore_global_state: If true, restore the cluster state. Defaults to false.
         :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__, "indices", indices)
         pulumi.set(__self__, "snapshot_name", snapshot_name)
         if chunk_size is not None:
             pulumi.set(__self__, "chunk_size", chunk_size)
@@ -14560,10 +14687,12 @@ class OpenSearchOpensearchUserConfigAzureMigration(dict):
             pulumi.set(__self__, "compress", compress)
         if endpoint_suffix is not None:
             pulumi.set(__self__, "endpoint_suffix", endpoint_suffix)
-        if indices is not None:
-            pulumi.set(__self__, "indices", indices)
+        if include_aliases is not None:
+            pulumi.set(__self__, "include_aliases", include_aliases)
         if key is not None:
             pulumi.set(__self__, "key", key)
+        if restore_global_state is not None:
+            pulumi.set(__self__, "restore_global_state", restore_global_state)
         if sas_token is not None:
             pulumi.set(__self__, "sas_token", sas_token)
 
@@ -14571,7 +14700,7 @@ class OpenSearchOpensearchUserConfigAzureMigration(dict):
     @pulumi.getter
     def account(self) -> str:
         """
-        Azure account name.
+        Account name.
         """
         return pulumi.get(self, "account")
 
@@ -14591,6 +14720,14 @@ class OpenSearchOpensearchUserConfigAzureMigration(dict):
         """
         return pulumi.get(self, "container")
 
+    @property
+    @pulumi.getter
+    def indices(self) -> str:
+        """
+        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
+        """
+        return pulumi.get(self, "indices")
+
     @property
     @pulumi.getter(name="snapshotName")
     def snapshot_name(self) -> str:
@@ -14624,12 +14761,12 @@ class OpenSearchOpensearchUserConfigAzureMigration(dict):
         return pulumi.get(self, "endpoint_suffix")
 
     @property
-    @pulumi.getter
-    def indices(self) -> Optional[str]:
+    @pulumi.getter(name="includeAliases")
+    def include_aliases(self) -> Optional[bool]:
         """
-        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. By default, a restore operation includes all data streams and indices in the snapshot. If this argument is provided, the restore operation only includes the data streams and indices that you specify. Example: `metrics*,logs*,data-20240823`.
+        Whether to restore aliases alongside their associated indexes. Default is true.
         """
-        return pulumi.get(self, "indices")
+        return pulumi.get(self, "include_aliases")
 
     @property
     @pulumi.getter
@@ -14639,6 +14776,14 @@ class OpenSearchOpensearchUserConfigAzureMigration(dict):
         """
         return pulumi.get(self, "key")
 
+    @property
+    @pulumi.getter(name="restoreGlobalState")
+    def restore_global_state(self) -> Optional[bool]:
+        """
+        If true, restore the cluster state. Defaults to false.
+        """
+        return pulumi.get(self, "restore_global_state")
+
     @property
     @pulumi.getter(name="sasToken")
     def sas_token(self) -> Optional[str]:
@@ -14659,6 +14804,10 @@ class OpenSearchOpensearchUserConfigGcsMigration(dict):
             suggest = "snapshot_name"
         elif key == "chunkSize":
             suggest = "chunk_size"
+        elif key == "includeAliases":
+            suggest = "include_aliases"
+        elif key == "restoreGlobalState":
+            suggest = "restore_global_state"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in OpenSearchOpensearchUserConfigGcsMigration. Access the value via the '{suggest}' property getter instead.")
@@ -14675,29 +14824,36 @@ class OpenSearchOpensearchUserConfigGcsMigration(dict):
                  base_path: str,
                  bucket: str,
                  credentials: str,
+                 indices: str,
                  snapshot_name: str,
                  chunk_size: Optional[str] = None,
                  compress: Optional[bool] = None,
-                 indices: Optional[str] = None):
+                 include_aliases: Optional[bool] = None,
+                 restore_global_state: 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 indices: A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
         :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 indices: A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. By default, a restore operation includes all data streams and indices in the snapshot. If this argument is provided, the restore operation only includes the data streams and indices that you specify. Example: `metrics*,logs*,data-20240823`.
+        :param bool include_aliases: Whether to restore aliases alongside their associated indexes. Default is true.
+        :param bool restore_global_state: If true, restore the cluster state. Defaults to false.
         """
         pulumi.set(__self__, "base_path", base_path)
         pulumi.set(__self__, "bucket", bucket)
         pulumi.set(__self__, "credentials", credentials)
+        pulumi.set(__self__, "indices", indices)
         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 indices is not None:
-            pulumi.set(__self__, "indices", indices)
+        if include_aliases is not None:
+            pulumi.set(__self__, "include_aliases", include_aliases)
+        if restore_global_state is not None:
+            pulumi.set(__self__, "restore_global_state", restore_global_state)
 
     @property
     @pulumi.getter(name="basePath")
@@ -14723,6 +14879,14 @@ class OpenSearchOpensearchUserConfigGcsMigration(dict):
         """
         return pulumi.get(self, "credentials")
 
+    @property
+    @pulumi.getter
+    def indices(self) -> str:
+        """
+        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
+        """
+        return pulumi.get(self, "indices")
+
     @property
     @pulumi.getter(name="snapshotName")
     def snapshot_name(self) -> str:
@@ -14748,12 +14912,20 @@ class OpenSearchOpensearchUserConfigGcsMigration(dict):
         return pulumi.get(self, "compress")
 
     @property
-    @pulumi.getter
-    def indices(self) -> Optional[str]:
+    @pulumi.getter(name="includeAliases")
+    def include_aliases(self) -> Optional[bool]:
         """
-        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. By default, a restore operation includes all data streams and indices in the snapshot. If this argument is provided, the restore operation only includes the data streams and indices that you specify. Example: `metrics*,logs*,data-20240823`.
+        Whether to restore aliases alongside their associated indexes. Default is true.
         """
-        return pulumi.get(self, "indices")
+        return pulumi.get(self, "include_aliases")
+
+    @property
+    @pulumi.getter(name="restoreGlobalState")
+    def restore_global_state(self) -> Optional[bool]:
+        """
+        If true, restore the cluster state. Defaults to false.
+        """
+        return pulumi.get(self, "restore_global_state")
 
 
 @pulumi.output_type
@@ -15253,6 +15425,8 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
             suggest = "script_max_compilations_rate"
         elif key == "searchBackpressure":
             suggest = "search_backpressure"
+        elif key == "searchInsightsTopQueries":
+            suggest = "search_insights_top_queries"
         elif key == "searchMaxBuckets":
             suggest = "search_max_buckets"
         elif key == "shardIndexingPressure":
@@ -15325,6 +15499,7 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
                  reindex_remote_whitelists: Optional[Sequence[str]] = None,
                  script_max_compilations_rate: Optional[str] = None,
                  search_backpressure: Optional['outputs.OpenSearchOpensearchUserConfigOpensearchSearchBackpressure'] = None,
+                 search_insights_top_queries: Optional['outputs.OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueries'] = None,
                  search_max_buckets: Optional[int] = None,
                  shard_indexing_pressure: Optional['outputs.OpenSearchOpensearchUserConfigOpensearchShardIndexingPressure'] = None,
                  thread_pool_analyze_queue_size: Optional[int] = None,
@@ -15452,6 +15627,8 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
             pulumi.set(__self__, "script_max_compilations_rate", script_max_compilations_rate)
         if search_backpressure is not None:
             pulumi.set(__self__, "search_backpressure", search_backpressure)
+        if search_insights_top_queries is not None:
+            pulumi.set(__self__, "search_insights_top_queries", search_insights_top_queries)
         if search_max_buckets is not None:
             pulumi.set(__self__, "search_max_buckets", search_max_buckets)
         if shard_indexing_pressure is not None:
@@ -15743,6 +15920,11 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
         """
         return pulumi.get(self, "search_backpressure")
 
+    @property
+    @pulumi.getter(name="searchInsightsTopQueries")
+    def search_insights_top_queries(self) -> Optional['outputs.OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueries']:
+        return pulumi.get(self, "search_insights_top_queries")
+
     @property
     @pulumi.getter(name="searchMaxBuckets")
     def search_max_buckets(self) -> Optional[int]:
@@ -16207,7 +16389,7 @@ class OpenSearchOpensearchUserConfigOpensearchSearchBackpressure(dict):
                  search_shard_task: Optional['outputs.OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchShardTask'] = None,
                  search_task: Optional['outputs.OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTask'] = None):
         """
-        :param str mode: Enum: `monitor_only`, `enforced`, `disabled`. The search backpressure mode. Valid values are monitor*only, enforced, or disabled. Default is monitor*only.
+        :param str mode: Enum: `disabled`, `enforced`, `monitor_only`. The search backpressure mode. Valid values are monitor*only, enforced, or disabled. Default is monitor*only.
         :param 'OpenSearchOpensearchUserConfigOpensearchSearchBackpressureNodeDuressArgs' node_duress: Node duress settings
         :param 'OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchShardTaskArgs' search_shard_task: Search shard settings
         :param 'OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTaskArgs' search_task: Search task settings
@@ -16225,7 +16407,7 @@ class OpenSearchOpensearchUserConfigOpensearchSearchBackpressure(dict):
     @pulumi.getter
     def mode(self) -> Optional[str]:
         """
-        Enum: `monitor_only`, `enforced`, `disabled`. The search backpressure mode. Valid values are monitor*only, enforced, or disabled. Default is monitor*only.
+        Enum: `disabled`, `enforced`, `monitor_only`. The search backpressure mode. Valid values are monitor*only, enforced, or disabled. Default is monitor*only.
         """
         return pulumi.get(self, "mode")
 
@@ -16614,6 +16796,235 @@ class OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTask(dict)
         return pulumi.get(self, "total_heap_percent_threshold")
 
 
+@pulumi.output_type
+class OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueries(dict):
+    def __init__(__self__, *,
+                 cpu: Optional['outputs.OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpu'] = None,
+                 latency: Optional['outputs.OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatency'] = None,
+                 memory: Optional['outputs.OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemory'] = None):
+        """
+        :param 'OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpuArgs' cpu: Top N queries monitoring by CPU
+        :param 'OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatencyArgs' latency: Top N queries monitoring by latency
+        :param 'OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemoryArgs' memory: Top N queries monitoring by memory
+        """
+        if cpu is not None:
+            pulumi.set(__self__, "cpu", cpu)
+        if latency is not None:
+            pulumi.set(__self__, "latency", latency)
+        if memory is not None:
+            pulumi.set(__self__, "memory", memory)
+
+    @property
+    @pulumi.getter
+    def cpu(self) -> Optional['outputs.OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpu']:
+        """
+        Top N queries monitoring by CPU
+        """
+        return pulumi.get(self, "cpu")
+
+    @property
+    @pulumi.getter
+    def latency(self) -> Optional['outputs.OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatency']:
+        """
+        Top N queries monitoring by latency
+        """
+        return pulumi.get(self, "latency")
+
+    @property
+    @pulumi.getter
+    def memory(self) -> Optional['outputs.OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemory']:
+        """
+        Top N queries monitoring by memory
+        """
+        return pulumi.get(self, "memory")
+
+
+@pulumi.output_type
+class OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpu(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "topNSize":
+            suggest = "top_n_size"
+        elif key == "windowSize":
+            suggest = "window_size"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpu. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpu.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpu.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 enabled: Optional[bool] = None,
+                 top_n_size: Optional[int] = None,
+                 window_size: Optional[str] = None):
+        """
+        :param bool enabled: Enable or disable top N query monitoring by the metric. Default: `false`.
+        :param int top_n_size: Specify the value of N for the top N queries by the metric.
+        :param str window_size: The window size of the top N queries by the metric.
+        """
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+        if top_n_size is not None:
+            pulumi.set(__self__, "top_n_size", top_n_size)
+        if window_size is not None:
+            pulumi.set(__self__, "window_size", window_size)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[bool]:
+        """
+        Enable or disable top N query monitoring by the metric. Default: `false`.
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter(name="topNSize")
+    def top_n_size(self) -> Optional[int]:
+        """
+        Specify the value of N for the top N queries by the metric.
+        """
+        return pulumi.get(self, "top_n_size")
+
+    @property
+    @pulumi.getter(name="windowSize")
+    def window_size(self) -> Optional[str]:
+        """
+        The window size of the top N queries by the metric.
+        """
+        return pulumi.get(self, "window_size")
+
+
+@pulumi.output_type
+class OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatency(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "topNSize":
+            suggest = "top_n_size"
+        elif key == "windowSize":
+            suggest = "window_size"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatency. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatency.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatency.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 enabled: Optional[bool] = None,
+                 top_n_size: Optional[int] = None,
+                 window_size: Optional[str] = None):
+        """
+        :param bool enabled: Enable or disable top N query monitoring by the metric. Default: `false`.
+        :param int top_n_size: Specify the value of N for the top N queries by the metric.
+        :param str window_size: The window size of the top N queries by the metric.
+        """
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+        if top_n_size is not None:
+            pulumi.set(__self__, "top_n_size", top_n_size)
+        if window_size is not None:
+            pulumi.set(__self__, "window_size", window_size)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[bool]:
+        """
+        Enable or disable top N query monitoring by the metric. Default: `false`.
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter(name="topNSize")
+    def top_n_size(self) -> Optional[int]:
+        """
+        Specify the value of N for the top N queries by the metric.
+        """
+        return pulumi.get(self, "top_n_size")
+
+    @property
+    @pulumi.getter(name="windowSize")
+    def window_size(self) -> Optional[str]:
+        """
+        The window size of the top N queries by the metric.
+        """
+        return pulumi.get(self, "window_size")
+
+
+@pulumi.output_type
+class OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemory(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "topNSize":
+            suggest = "top_n_size"
+        elif key == "windowSize":
+            suggest = "window_size"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemory. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemory.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemory.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 enabled: Optional[bool] = None,
+                 top_n_size: Optional[int] = None,
+                 window_size: Optional[str] = None):
+        """
+        :param bool enabled: Enable or disable top N query monitoring by the metric. Default: `false`.
+        :param int top_n_size: Specify the value of N for the top N queries by the metric.
+        :param str window_size: The window size of the top N queries by the metric.
+        """
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+        if top_n_size is not None:
+            pulumi.set(__self__, "top_n_size", top_n_size)
+        if window_size is not None:
+            pulumi.set(__self__, "window_size", window_size)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[bool]:
+        """
+        Enable or disable top N query monitoring by the metric. Default: `false`.
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter(name="topNSize")
+    def top_n_size(self) -> Optional[int]:
+        """
+        Specify the value of N for the top N queries by the metric.
+        """
+        return pulumi.get(self, "top_n_size")
+
+    @property
+    @pulumi.getter(name="windowSize")
+    def window_size(self) -> Optional[str]:
+        """
+        The window size of the top N queries by the metric.
+        """
+        return pulumi.get(self, "window_size")
+
+
 @pulumi.output_type
 class OpenSearchOpensearchUserConfigOpensearchShardIndexingPressure(dict):
     @staticmethod
@@ -17055,6 +17466,10 @@ class OpenSearchOpensearchUserConfigS3Migration(dict):
             suggest = "snapshot_name"
         elif key == "chunkSize":
             suggest = "chunk_size"
+        elif key == "includeAliases":
+            suggest = "include_aliases"
+        elif key == "restoreGlobalState":
+            suggest = "restore_global_state"
         elif key == "serverSideEncryption":
             suggest = "server_side_encryption"
 
@@ -17073,30 +17488,35 @@ class OpenSearchOpensearchUserConfigS3Migration(dict):
                  access_key: str,
                  base_path: str,
                  bucket: str,
+                 indices: str,
                  region: str,
                  secret_key: str,
                  snapshot_name: str,
                  chunk_size: Optional[str] = None,
                  compress: Optional[bool] = None,
                  endpoint: Optional[str] = None,
-                 indices: Optional[str] = None,
+                 include_aliases: Optional[bool] = None,
+                 restore_global_state: Optional[bool] = 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 indices: A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
         :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 str indices: A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. By default, a restore operation includes all data streams and indices in the snapshot. If this argument is provided, the restore operation only includes the data streams and indices that you specify. Example: `metrics*,logs*,data-20240823`.
+        :param bool include_aliases: Whether to restore aliases alongside their associated indexes. Default is true.
+        :param bool restore_global_state: If true, restore the cluster state. Defaults to false.
         :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__, "indices", indices)
         pulumi.set(__self__, "region", region)
         pulumi.set(__self__, "secret_key", secret_key)
         pulumi.set(__self__, "snapshot_name", snapshot_name)
@@ -17106,8 +17526,10 @@ class OpenSearchOpensearchUserConfigS3Migration(dict):
             pulumi.set(__self__, "compress", compress)
         if endpoint is not None:
             pulumi.set(__self__, "endpoint", endpoint)
-        if indices is not None:
-            pulumi.set(__self__, "indices", indices)
+        if include_aliases is not None:
+            pulumi.set(__self__, "include_aliases", include_aliases)
+        if restore_global_state is not None:
+            pulumi.set(__self__, "restore_global_state", restore_global_state)
         if server_side_encryption is not None:
             pulumi.set(__self__, "server_side_encryption", server_side_encryption)
 
@@ -17135,6 +17557,14 @@ class OpenSearchOpensearchUserConfigS3Migration(dict):
         """
         return pulumi.get(self, "bucket")
 
+    @property
+    @pulumi.getter
+    def indices(self) -> str:
+        """
+        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
+        """
+        return pulumi.get(self, "indices")
+
     @property
     @pulumi.getter
     def region(self) -> str:
@@ -17184,12 +17614,20 @@ class OpenSearchOpensearchUserConfigS3Migration(dict):
         return pulumi.get(self, "endpoint")
 
     @property
-    @pulumi.getter
-    def indices(self) -> Optional[str]:
+    @pulumi.getter(name="includeAliases")
+    def include_aliases(self) -> Optional[bool]:
         """
-        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. By default, a restore operation includes all data streams and indices in the snapshot. If this argument is provided, the restore operation only includes the data streams and indices that you specify. Example: `metrics*,logs*,data-20240823`.
+        Whether to restore aliases alongside their associated indexes. Default is true.
         """
-        return pulumi.get(self, "indices")
+        return pulumi.get(self, "include_aliases")
+
+    @property
+    @pulumi.getter(name="restoreGlobalState")
+    def restore_global_state(self) -> Optional[bool]:
+        """
+        If true, restore the cluster state. Defaults to false.
+        """
+        return pulumi.get(self, "restore_global_state")
 
     @property
     @pulumi.getter(name="serverSideEncryption")
@@ -17502,8 +17940,8 @@ class OrganizationPermissionPermission(dict):
                  create_time: Optional[str] = None,
                  update_time: Optional[str] = None):
         """
-        :param Sequence[str] permissions: List of permissions. The possible values are `admin`, `developer`, `operator`, `project:permissions:read`, `read_only` and `service:logs:read`.
-        :param str principal_id: ID of the user or group.
+        :param Sequence[str] permissions: List of [roles and permissions](https://aiven.io/docs/platform/concepts/permissions) to grant. The possible values are `admin`, `developer`, `operator`, `organization:app_users:write`, `organization:audit_logs:read`, `organization:billing:read`, `organization:billing:write`, `organization:domains:write`, `organization:groups:write`, `organization:idps:write`, `organization:network:read`, `organization:network:write`, `organization:permissions:read`, `organization:permissions:write`, `organization:projects:read`, `organization:projects:write`, `organization:users:write`, `project:audit_logs:read`, `project:integrations:read`, `project:integrations:write`, `project:networking:read`, `project:networking:write`, `project:permissions:read`, `project:services:read`, `project:services:write`, `read_only`, `role:organization:admin`, `role:services:maintenance`, `role:services:recover`, `service:configuration:write`, `service:data:write`, `service:logs:read`, `service:secrets:read` and `service:users:write`.
+        :param str principal_id: ID of the user or group to grant permissions to. Only active users who have accepted an [invite](https://aiven.io/docs/platform/howto/manage-org-users) to join the organization can be granted permissions.
         :param str principal_type: The type of principal. The possible values are `user` and `user_group`.
         :param str create_time: Time created.
         :param str update_time: Time updated.
@@ -17520,7 +17958,7 @@ class OrganizationPermissionPermission(dict):
     @pulumi.getter
     def permissions(self) -> Sequence[str]:
         """
-        List of permissions. The possible values are `admin`, `developer`, `operator`, `project:permissions:read`, `read_only` and `service:logs:read`.
+        List of [roles and permissions](https://aiven.io/docs/platform/concepts/permissions) to grant. The possible values are `admin`, `developer`, `operator`, `organization:app_users:write`, `organization:audit_logs:read`, `organization:billing:read`, `organization:billing:write`, `organization:domains:write`, `organization:groups:write`, `organization:idps:write`, `organization:network:read`, `organization:network:write`, `organization:permissions:read`, `organization:permissions:write`, `organization:projects:read`, `organization:projects:write`, `organization:users:write`, `project:audit_logs:read`, `project:integrations:read`, `project:integrations:write`, `project:networking:read`, `project:networking:write`, `project:permissions:read`, `project:services:read`, `project:services:write`, `read_only`, `role:organization:admin`, `role:services:maintenance`, `role:services:recover`, `service:configuration:write`, `service:data:write`, `service:logs:read`, `service:secrets:read` and `service:users:write`.
         """
         return pulumi.get(self, "permissions")
 
@@ -17528,7 +17966,7 @@ class OrganizationPermissionPermission(dict):
     @pulumi.getter(name="principalId")
     def principal_id(self) -> str:
         """
-        ID of the user or group.
+        ID of the user or group to grant permissions to. Only active users who have accepted an [invite](https://aiven.io/docs/platform/howto/manage-org-users) to join the organization can be granted permissions.
         """
         return pulumi.get(self, "principal_id")
 
@@ -18213,7 +18651,7 @@ class PgPgUserConfig(dict):
         :param str service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
         :param float shared_buffers_percentage: Percentage of total RAM that the database server uses for shared memory buffers. Valid range is 20-60 (float), which corresponds to 20% - 60%. This setting adjusts the shared_buffers configuration value. Example: `41.5`.
         :param bool static_ips: Use static public IP addresses.
-        :param str synchronous_replication: Enum: `quorum`, `off`. Synchronous replication type. Note that the service plan also needs to support synchronous replication.
+        :param str synchronous_replication: Enum: `off`, `quorum`. Synchronous replication type. Note that the service plan also needs to support synchronous replication.
         :param 'PgPgUserConfigTimescaledbArgs' timescaledb: System-wide settings for the timescaledb extension
         :param str variant: Enum: `aiven`, `timescale`. Variant of the PostgreSQL service, may affect the features that are exposed by default.
         :param int work_mem: Sets the maximum amount of memory to be used by a query operation (such as a sort or hash table) before writing to temporary disk files, in MB. Default is 1MB + 0.075% of total RAM (up to 32MB). Example: `4`.
@@ -18515,7 +18953,7 @@ class PgPgUserConfig(dict):
     @pulumi.getter(name="synchronousReplication")
     def synchronous_replication(self) -> Optional[str]:
         """
-        Enum: `quorum`, `off`. Synchronous replication type. Note that the service plan also needs to support synchronous replication.
+        Enum: `off`, `quorum`. Synchronous replication type. Note that the service plan also needs to support synchronous replication.
         """
         return pulumi.get(self, "synchronous_replication")
 
@@ -18886,8 +19324,8 @@ class PgPgUserConfigPg(dict):
         :param int idle_in_transaction_session_timeout: Time out sessions with open transactions after this number of milliseconds.
         :param bool jit: Controls system-wide use of Just-in-Time Compilation (JIT).
         :param int log_autovacuum_min_duration: Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one (the default) disables logging autovacuum actions.
-        :param str log_error_verbosity: Enum: `TERSE`, `DEFAULT`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
-        :param str log_line_prefix: Enum: `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
+        :param str log_error_verbosity: Enum: `DEFAULT`, `TERSE`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
+        :param str log_line_prefix: Enum: `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
         :param int log_min_duration_statement: Log statements that take more than this number of milliseconds to run, -1 disables.
         :param int log_temp_files: Log statements for each temporary file created larger than this number of kilobytes, -1 disables.
         :param int max_files_per_process: PostgreSQL maximum number of files that can be open per process.
@@ -18908,12 +19346,12 @@ class PgPgUserConfigPg(dict):
         :param str pg_partman_bgw_dot_role: Controls which role to use for pg_partman's scheduled background tasks. Example: `myrolename`.
         :param bool pg_stat_monitor_dot_pgsm_enable_query_plan: Enables or disables query plan monitoring.
         :param int pg_stat_monitor_dot_pgsm_max_buckets: Sets the maximum number of buckets. Example: `10`.
-        :param str pg_stat_statements_dot_track: Enum: `all`, `top`, `none`. Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default value is top.
+        :param str pg_stat_statements_dot_track: Enum: `all`, `none`, `top`. Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default value is top.
         :param int temp_file_limit: PostgreSQL temporary file limit in KiB, -1 for unlimited. Example: `5000000`.
         :param str timezone: PostgreSQL service timezone. Example: `Europe/Helsinki`.
         :param int track_activity_query_size: Specifies the number of bytes reserved to track the currently executing command for each active session. Example: `1024`.
         :param str track_commit_timestamp: Enum: `off`, `on`. Record commit time of transactions.
-        :param str track_functions: Enum: `all`, `pl`, `none`. Enables tracking of function call counts and time used.
+        :param str track_functions: Enum: `all`, `none`, `pl`. Enables tracking of function call counts and time used.
         :param str track_io_timing: Enum: `off`, `on`. Enables timing of database I/O calls. This parameter is off by default, because it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms.
         :param int wal_sender_timeout: Terminate replication connections that are inactive for longer than this amount of time, in milliseconds. Setting this value to zero disables the timeout. Example: `60000`.
         :param int wal_writer_delay: WAL flush interval in milliseconds. Note that setting this value to lower than the default 200ms may negatively impact performance. Example: `50`.
@@ -19165,7 +19603,7 @@ class PgPgUserConfigPg(dict):
     @pulumi.getter(name="logErrorVerbosity")
     def log_error_verbosity(self) -> Optional[str]:
         """
-        Enum: `TERSE`, `DEFAULT`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
+        Enum: `DEFAULT`, `TERSE`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
         """
         return pulumi.get(self, "log_error_verbosity")
 
@@ -19173,7 +19611,7 @@ class PgPgUserConfigPg(dict):
     @pulumi.getter(name="logLinePrefix")
     def log_line_prefix(self) -> Optional[str]:
         """
-        Enum: `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
+        Enum: `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
         """
         return pulumi.get(self, "log_line_prefix")
 
@@ -19341,7 +19779,7 @@ class PgPgUserConfigPg(dict):
     @pulumi.getter(name="pgStatStatementsDotTrack")
     def pg_stat_statements_dot_track(self) -> Optional[str]:
         """
-        Enum: `all`, `top`, `none`. Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default value is top.
+        Enum: `all`, `none`, `top`. Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default value is top.
         """
         return pulumi.get(self, "pg_stat_statements_dot_track")
 
@@ -19381,7 +19819,7 @@ class PgPgUserConfigPg(dict):
     @pulumi.getter(name="trackFunctions")
     def track_functions(self) -> Optional[str]:
         """
-        Enum: `all`, `pl`, `none`. Enables tracking of function call counts and time used.
+        Enum: `all`, `none`, `pl`. Enables tracking of function call counts and time used.
         """
         return pulumi.get(self, "track_functions")
 
@@ -19784,7 +20222,7 @@ class PgPgUserConfigPgbouncer(dict):
         """
         :param int autodb_idle_timeout: If the automatically created database pools have been unused this many seconds, they are freed. If 0 then timeout is disabled. (seconds). Default: `3600`.
         :param int autodb_max_db_connections: Do not allow more than this many server connections per database (regardless of user). Setting it to 0 means unlimited. Example: `0`.
-        :param str autodb_pool_mode: Enum: `session`, `transaction`, `statement`. PGBouncer pool mode. Default: `transaction`.
+        :param str autodb_pool_mode: Enum: `session`, `statement`, `transaction`. 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`.
@@ -19834,7 +20272,7 @@ class PgPgUserConfigPgbouncer(dict):
     @pulumi.getter(name="autodbPoolMode")
     def autodb_pool_mode(self) -> Optional[str]:
         """
-        Enum: `session`, `transaction`, `statement`. PGBouncer pool mode. Default: `transaction`.
+        Enum: `session`, `statement`, `transaction`. PGBouncer pool mode. Default: `transaction`.
         """
         return pulumi.get(self, "autodb_pool_mode")
 
@@ -20530,7 +20968,7 @@ class RedisRedisUserConfig(dict):
         :param int redis_io_threads: Set Redis IO thread count. Changing this will cause a restart of the Redis service. Example: `1`.
         :param int redis_lfu_decay_time: LFU maxmemory-policy counter decay time in minutes. Default: `1`.
         :param int redis_lfu_log_factor: Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies. Default: `10`.
-        :param str redis_maxmemory_policy: Enum: `noeviction`, `allkeys-lru`, `volatile-lru`, `allkeys-random`, `volatile-random`, `volatile-ttl`, `volatile-lfu`, `allkeys-lfu`. Redis maxmemory-policy. Default: `noeviction`.
+        :param str redis_maxmemory_policy: Enum: `allkeys-lfu`, `allkeys-lru`, `allkeys-random`, `noeviction`, `volatile-lfu`, `volatile-lru`, `volatile-random`, `volatile-ttl`. Redis maxmemory-policy. Default: `noeviction`.
         :param str redis_notify_keyspace_events: Set notify-keyspace-events option.
         :param int redis_number_of_databases: Set number of Redis databases. Changing this will cause a restart of the Redis service. Example: `16`.
         :param str redis_persistence: Enum: `off`, `rdb`. When persistence is `rdb`, Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to the backup schedule for backup purposes. When persistence is `off`, no RDB dumps or backups are done, so data can be lost at any moment if the service is restarted for any reason, or if the service is powered off. Also, the service can't be forked.
@@ -20730,7 +21168,7 @@ class RedisRedisUserConfig(dict):
     @pulumi.getter(name="redisMaxmemoryPolicy")
     def redis_maxmemory_policy(self) -> Optional[str]:
         """
-        Enum: `noeviction`, `allkeys-lru`, `volatile-lru`, `allkeys-random`, `volatile-random`, `volatile-ttl`, `volatile-lfu`, `allkeys-lfu`. Redis maxmemory-policy. Default: `noeviction`.
+        Enum: `allkeys-lfu`, `allkeys-lru`, `allkeys-random`, `noeviction`, `volatile-lfu`, `volatile-lru`, `volatile-random`, `volatile-ttl`. Redis maxmemory-policy. Default: `noeviction`.
         """
         return pulumi.get(self, "redis_maxmemory_policy")
 
@@ -21243,11 +21681,11 @@ class ServiceIntegrationClickhouseKafkaUserConfigTable(dict):
                  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`.
+        :param str data_format: Enum: `Avro`, `AvroConfluent`, `CSV`, `JSONAsString`, `JSONCompactEachRow`, `JSONCompactStringsEachRow`, `JSONEachRow`, `JSONStringsEachRow`, `MsgPack`, `Parquet`, `RawBLOB`, `TSKV`, `TSV`, `TabSeparated`. Message data format. Default: `JSONEachRow`.
         :param str group_name: Kafka consumers group. Default: `clickhouse`.
         :param str name: Name of the table. Example: `events`.
         :param Sequence['ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs'] topics: Kafka topics
-        :param str auto_offset_reset: Enum: `smallest`, `earliest`, `beginning`, `largest`, `latest`, `end`. Action to take when there is no initial offset in offset store or the desired offset is out of range. Default: `earliest`.
+        :param str auto_offset_reset: Enum: `beginning`, `earliest`, `end`, `largest`, `latest`, `smallest`. Action to take when there is no initial offset in offset store or the desired offset is out of range. Default: `earliest`.
         :param str date_time_input_format: Enum: `basic`, `best_effort`, `best_effort_us`. Method to read DateTime from text input formats. Default: `basic`.
         :param str handle_error_mode: Enum: `default`, `stream`. How to handle errors for Kafka engine. Default: `default`.
         :param int max_block_size: Number of row collected by poll(s) for flushing data from Kafka. Default: `0`.
@@ -21296,7 +21734,7 @@ class ServiceIntegrationClickhouseKafkaUserConfigTable(dict):
     @pulumi.getter(name="dataFormat")
     def data_format(self) -> str:
         """
-        Enum: `Avro`, `CSV`, `JSONAsString`, `JSONCompactEachRow`, `JSONCompactStringsEachRow`, `JSONEachRow`, `JSONStringsEachRow`, `MsgPack`, `TSKV`, `TSV`, `TabSeparated`, `RawBLOB`, `AvroConfluent`, `Parquet`. Message data format. Default: `JSONEachRow`.
+        Enum: `Avro`, `AvroConfluent`, `CSV`, `JSONAsString`, `JSONCompactEachRow`, `JSONCompactStringsEachRow`, `JSONEachRow`, `JSONStringsEachRow`, `MsgPack`, `Parquet`, `RawBLOB`, `TSKV`, `TSV`, `TabSeparated`. Message data format. Default: `JSONEachRow`.
         """
         return pulumi.get(self, "data_format")
 
@@ -21328,7 +21766,7 @@ class ServiceIntegrationClickhouseKafkaUserConfigTable(dict):
     @pulumi.getter(name="autoOffsetReset")
     def auto_offset_reset(self) -> Optional[str]:
         """
-        Enum: `smallest`, `earliest`, `beginning`, `largest`, `latest`, `end`. Action to take when there is no initial offset in offset store or the desired offset is out of range. Default: `earliest`.
+        Enum: `beginning`, `earliest`, `end`, `largest`, `latest`, `smallest`. Action to take when there is no initial offset in offset store or the desired offset is out of range. Default: `earliest`.
         """
         return pulumi.get(self, "auto_offset_reset")
 
@@ -21832,6 +22270,70 @@ class ServiceIntegrationDatadogUserConfigRedis(dict):
         return pulumi.get(self, "command_stats_enabled")
 
 
+@pulumi.output_type
+class ServiceIntegrationEndpointAutoscalerUserConfig(dict):
+    def __init__(__self__, *,
+                 autoscalings: Sequence['outputs.ServiceIntegrationEndpointAutoscalerUserConfigAutoscaling']):
+        """
+        :param Sequence['ServiceIntegrationEndpointAutoscalerUserConfigAutoscalingArgs'] autoscalings: Configure autoscaling thresholds for a service
+        """
+        pulumi.set(__self__, "autoscalings", autoscalings)
+
+    @property
+    @pulumi.getter
+    def autoscalings(self) -> Sequence['outputs.ServiceIntegrationEndpointAutoscalerUserConfigAutoscaling']:
+        """
+        Configure autoscaling thresholds for a service
+        """
+        return pulumi.get(self, "autoscalings")
+
+
+@pulumi.output_type
+class ServiceIntegrationEndpointAutoscalerUserConfigAutoscaling(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "capGb":
+            suggest = "cap_gb"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServiceIntegrationEndpointAutoscalerUserConfigAutoscaling. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServiceIntegrationEndpointAutoscalerUserConfigAutoscaling.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServiceIntegrationEndpointAutoscalerUserConfigAutoscaling.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 cap_gb: int,
+                 type: str):
+        """
+        :param int cap_gb: The maximum total disk size (in gb) to allow autoscaler to scale up to. Example: `300`.
+        :param str type: Enum: `autoscale_disk`. Type of autoscale event.
+        """
+        pulumi.set(__self__, "cap_gb", cap_gb)
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter(name="capGb")
+    def cap_gb(self) -> int:
+        """
+        The maximum total disk size (in gb) to allow autoscaler to scale up to. Example: `300`.
+        """
+        return pulumi.get(self, "cap_gb")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        Enum: `autoscale_disk`. Type of autoscale event.
+        """
+        return pulumi.get(self, "type")
+
+
 @pulumi.output_type
 class ServiceIntegrationEndpointDatadogUserConfig(dict):
     @staticmethod
@@ -21843,6 +22345,8 @@ class ServiceIntegrationEndpointDatadogUserConfig(dict):
             suggest = "datadog_tags"
         elif key == "disableConsumerStats":
             suggest = "disable_consumer_stats"
+        elif key == "extraTagsPrefix":
+            suggest = "extra_tags_prefix"
         elif key == "kafkaConsumerCheckInstances":
             suggest = "kafka_consumer_check_instances"
         elif key == "kafkaConsumerStatsTimeout":
@@ -21865,6 +22369,7 @@ class ServiceIntegrationEndpointDatadogUserConfig(dict):
                  datadog_api_key: str,
                  datadog_tags: Optional[Sequence['outputs.ServiceIntegrationEndpointDatadogUserConfigDatadogTag']] = None,
                  disable_consumer_stats: Optional[bool] = None,
+                 extra_tags_prefix: Optional[str] = None,
                  kafka_consumer_check_instances: Optional[int] = None,
                  kafka_consumer_stats_timeout: Optional[int] = None,
                  max_partition_contexts: Optional[int] = None,
@@ -21873,16 +22378,19 @@ class ServiceIntegrationEndpointDatadogUserConfig(dict):
         :param str datadog_api_key: Datadog API key. Example: `848f30907c15c55d601fe45487cce9b6`.
         :param Sequence['ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgs'] datadog_tags: Custom tags provided by user
         :param bool disable_consumer_stats: Disable consumer group metrics.
+        :param str extra_tags_prefix: Extra tags prefix. Defaults to aiven.
         :param int kafka_consumer_check_instances: Number of separate instances to fetch kafka consumer statistics with. Example: `8`.
         :param int kafka_consumer_stats_timeout: Number of seconds that datadog will wait to get consumer statistics from brokers. Example: `60`.
         :param int max_partition_contexts: Maximum number of partition contexts to send. Example: `32000`.
-        :param str site: Enum: `datadoghq.com`, `datadoghq.eu`, `us3.datadoghq.com`, `us5.datadoghq.com`, `ddog-gov.com`, `ap1.datadoghq.com`. Datadog intake site. Defaults to datadoghq.com.
+        :param str site: Enum: `ap1.datadoghq.com`, `datadoghq.com`, `datadoghq.eu`, `ddog-gov.com`, `us3.datadoghq.com`, `us5.datadoghq.com`. Datadog intake site. Defaults to datadoghq.com.
         """
         pulumi.set(__self__, "datadog_api_key", datadog_api_key)
         if datadog_tags is not None:
             pulumi.set(__self__, "datadog_tags", datadog_tags)
         if disable_consumer_stats is not None:
             pulumi.set(__self__, "disable_consumer_stats", disable_consumer_stats)
+        if extra_tags_prefix is not None:
+            pulumi.set(__self__, "extra_tags_prefix", extra_tags_prefix)
         if kafka_consumer_check_instances is not None:
             pulumi.set(__self__, "kafka_consumer_check_instances", kafka_consumer_check_instances)
         if kafka_consumer_stats_timeout is not None:
@@ -21916,6 +22424,14 @@ class ServiceIntegrationEndpointDatadogUserConfig(dict):
         """
         return pulumi.get(self, "disable_consumer_stats")
 
+    @property
+    @pulumi.getter(name="extraTagsPrefix")
+    def extra_tags_prefix(self) -> Optional[str]:
+        """
+        Extra tags prefix. Defaults to aiven.
+        """
+        return pulumi.get(self, "extra_tags_prefix")
+
     @property
     @pulumi.getter(name="kafkaConsumerCheckInstances")
     def kafka_consumer_check_instances(self) -> Optional[int]:
@@ -21944,7 +22460,7 @@ class ServiceIntegrationEndpointDatadogUserConfig(dict):
     @pulumi.getter
     def site(self) -> Optional[str]:
         """
-        Enum: `datadoghq.com`, `datadoghq.eu`, `us3.datadoghq.com`, `us5.datadoghq.com`, `ddog-gov.com`, `ap1.datadoghq.com`. Datadog intake site. Defaults to datadoghq.com.
+        Enum: `ap1.datadoghq.com`, `datadoghq.com`, `datadoghq.eu`, `ddog-gov.com`, `us3.datadoghq.com`, `us5.datadoghq.com`. Datadog intake site. Defaults to datadoghq.com.
         """
         return pulumi.get(self, "site")
 
@@ -22478,7 +22994,7 @@ class ServiceIntegrationEndpointExternalKafkaUserConfig(dict):
                  ssl_endpoint_identification_algorithm: Optional[str] = None):
         """
         :param str bootstrap_servers: Bootstrap servers. Example: `10.0.0.1:9092,10.0.0.2:9092`.
-        :param str security_protocol: Enum: `PLAINTEXT`, `SSL`, `SASL_PLAINTEXT`, `SASL_SSL`. Security protocol.
+        :param str security_protocol: Enum: `PLAINTEXT`, `SASL_PLAINTEXT`, `SASL_SSL`, `SSL`. Security protocol.
         :param str sasl_mechanism: Enum: `PLAIN`, `SCRAM-SHA-256`, `SCRAM-SHA-512`. SASL mechanism used for connections to the Kafka server.
         :param str sasl_plain_password: Password for SASL PLAIN mechanism in the Kafka server. Example: `admin`.
         :param str sasl_plain_username: Username for SASL PLAIN mechanism in the Kafka server. Example: `admin`.
@@ -22525,7 +23041,7 @@ class ServiceIntegrationEndpointExternalKafkaUserConfig(dict):
     @pulumi.getter(name="securityProtocol")
     def security_protocol(self) -> str:
         """
-        Enum: `PLAINTEXT`, `SSL`, `SASL_PLAINTEXT`, `SASL_SSL`. Security protocol.
+        Enum: `PLAINTEXT`, `SASL_PLAINTEXT`, `SASL_SSL`, `SSL`. Security protocol.
         """
         return pulumi.get(self, "security_protocol")
 
@@ -22835,7 +23351,7 @@ class ServiceIntegrationEndpointExternalPostgresql(dict):
         :param str ssl_client_key: Client key. Example: `-----BEGIN PRIVATE KEY-----
                ...
                -----END PRIVATE KEY-----`.
-        :param str ssl_mode: Enum: `disable`, `allow`, `prefer`, `require`, `verify-ca`, `verify-full`. SSL mode to use for the connection.  Please note that Aiven requires TLS for all connections to external PostgreSQL services. Default: `verify-full`.
+        :param str ssl_mode: Enum: `allow`, `disable`, `prefer`, `require`, `verify-ca`, `verify-full`. SSL mode to use for the connection.  Please note that Aiven requires TLS for all connections to external PostgreSQL services. Default: `verify-full`.
         :param str ssl_root_cert: SSL Root Cert. Example: `-----BEGIN CERTIFICATE-----
                ...
                -----END CERTIFICATE-----
@@ -22922,7 +23438,7 @@ class ServiceIntegrationEndpointExternalPostgresql(dict):
     @pulumi.getter(name="sslMode")
     def ssl_mode(self) -> Optional[str]:
         """
-        Enum: `disable`, `allow`, `prefer`, `require`, `verify-ca`, `verify-full`. SSL mode to use for the connection.  Please note that Aiven requires TLS for all connections to external PostgreSQL services. Default: `verify-full`.
+        Enum: `allow`, `disable`, `prefer`, `require`, `verify-ca`, `verify-full`. SSL mode to use for the connection.  Please note that Aiven requires TLS for all connections to external PostgreSQL services. Default: `verify-full`.
         """
         return pulumi.get(self, "ssl_mode")
 
@@ -22938,6 +23454,70 @@ class ServiceIntegrationEndpointExternalPostgresql(dict):
         return pulumi.get(self, "ssl_root_cert")
 
 
+@pulumi.output_type
+class ServiceIntegrationEndpointExternalPrometheusUserConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "basicAuthPassword":
+            suggest = "basic_auth_password"
+        elif key == "basicAuthUsername":
+            suggest = "basic_auth_username"
+        elif key == "serviceUri":
+            suggest = "service_uri"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServiceIntegrationEndpointExternalPrometheusUserConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServiceIntegrationEndpointExternalPrometheusUserConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServiceIntegrationEndpointExternalPrometheusUserConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 basic_auth_password: Optional[str] = None,
+                 basic_auth_username: Optional[str] = None,
+                 service_uri: Optional[str] = None):
+        """
+        :param str basic_auth_password: Prometheus basic authentication password. Example: `fhyFNBjj3R`.
+        :param str basic_auth_username: Prometheus basic authentication username. Example: `prom4851`.
+        :param str service_uri: Prometheus enabled write endpoint. Example: `https://write.example.com/`.
+        """
+        if basic_auth_password is not None:
+            pulumi.set(__self__, "basic_auth_password", basic_auth_password)
+        if basic_auth_username is not None:
+            pulumi.set(__self__, "basic_auth_username", basic_auth_username)
+        if service_uri is not None:
+            pulumi.set(__self__, "service_uri", service_uri)
+
+    @property
+    @pulumi.getter(name="basicAuthPassword")
+    def basic_auth_password(self) -> Optional[str]:
+        """
+        Prometheus basic authentication password. Example: `fhyFNBjj3R`.
+        """
+        return pulumi.get(self, "basic_auth_password")
+
+    @property
+    @pulumi.getter(name="basicAuthUsername")
+    def basic_auth_username(self) -> Optional[str]:
+        """
+        Prometheus basic authentication username. Example: `prom4851`.
+        """
+        return pulumi.get(self, "basic_auth_username")
+
+    @property
+    @pulumi.getter(name="serviceUri")
+    def service_uri(self) -> Optional[str]:
+        """
+        Prometheus enabled write endpoint. Example: `https://write.example.com/`.
+        """
+        return pulumi.get(self, "service_uri")
+
+
 @pulumi.output_type
 class ServiceIntegrationEndpointExternalSchemaRegistryUserConfig(dict):
     @staticmethod
@@ -22965,7 +23545,7 @@ class ServiceIntegrationEndpointExternalSchemaRegistryUserConfig(dict):
                  basic_auth_password: Optional[str] = None,
                  basic_auth_username: Optional[str] = None):
         """
-        :param str authentication: Enum: `none`, `basic`. Authentication method.
+        :param str authentication: Enum: `basic`, `none`. Authentication method.
         :param str url: Schema Registry URL. Example: `https://schema-registry.kafka.company.com:28419`.
         :param str basic_auth_password: Basic authentication password. Example: `Zm9vYg==`.
         :param str basic_auth_username: Basic authentication user name. Example: `avnadmin`.
@@ -22981,7 +23561,7 @@ class ServiceIntegrationEndpointExternalSchemaRegistryUserConfig(dict):
     @pulumi.getter
     def authentication(self) -> str:
         """
-        Enum: `none`, `basic`. Authentication method.
+        Enum: `basic`, `none`. Authentication method.
         """
         return pulumi.get(self, "authentication")
 
@@ -23141,7 +23721,7 @@ class ServiceIntegrationEndpointRsyslogUserConfig(dict):
                  max_message_size: Optional[int] = None,
                  sd: Optional[str] = None):
         """
-        :param str format: Enum: `rfc5424`, `rfc3164`, `custom`. Message format. Default: `rfc5424`.
+        :param str format: Enum: `custom`, `rfc3164`, `rfc5424`. Message format. Default: `rfc5424`.
         :param int port: Rsyslog server port. Default: `514`.
         :param str server: Rsyslog server IP address or hostname. Example: `logs.example.com`.
         :param bool tls: Require TLS. Default: `true`.
@@ -23182,7 +23762,7 @@ class ServiceIntegrationEndpointRsyslogUserConfig(dict):
     @pulumi.getter
     def format(self) -> str:
         """
-        Enum: `rfc5424`, `rfc3164`, `custom`. Message format. Default: `rfc5424`.
+        Enum: `custom`, `rfc3164`, `rfc5424`. Message format. Default: `rfc5424`.
         """
         return pulumi.get(self, "format")
 
@@ -23764,7 +24344,7 @@ class ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormaker(dict):
         :param int consumer_max_poll_records: Set consumer max.poll.records. The default is 500. Example: `500`.
         :param int producer_batch_size: The batch size in bytes producer will attempt to collect before publishing to broker. Example: `1024`.
         :param int producer_buffer_memory: The amount of bytes producer can use for buffering data before publishing to broker. Example: `8388608`.
-        :param str producer_compression_type: Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
+        :param str producer_compression_type: Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
         :param int producer_linger_ms: The linger time (ms) for waiting new data to arrive for publishing. Example: `100`.
         :param int producer_max_request_size: The maximum request size in bytes. Example: `1048576`.
         """
@@ -23829,7 +24409,7 @@ class ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormaker(dict):
     @pulumi.getter(name="producerCompressionType")
     def producer_compression_type(self) -> Optional[str]:
         """
-        Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
+        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
         """
         return pulumi.get(self, "producer_compression_type")
 
@@ -24818,10 +25398,18 @@ class ThanosThanosUserConfig(dict):
             suggest = "ip_filters"
         elif key == "objectStorageUsageAlertThresholdGb":
             suggest = "object_storage_usage_alert_threshold_gb"
+        elif key == "privateAccess":
+            suggest = "private_access"
+        elif key == "privatelinkAccess":
+            suggest = "privatelink_access"
         elif key == "publicAccess":
             suggest = "public_access"
         elif key == "queryFrontend":
             suggest = "query_frontend"
+        elif key == "receiverIngesting":
+            suggest = "receiver_ingesting"
+        elif key == "receiverRouting":
+            suggest = "receiver_routing"
         elif key == "serviceLog":
             suggest = "service_log"
         elif key == "staticIps":
@@ -24845,23 +25433,35 @@ class ThanosThanosUserConfig(dict):
                  ip_filter_strings: Optional[Sequence[str]] = None,
                  ip_filters: Optional[Sequence[str]] = None,
                  object_storage_usage_alert_threshold_gb: Optional[int] = None,
+                 private_access: Optional['outputs.ThanosThanosUserConfigPrivateAccess'] = None,
+                 privatelink_access: Optional['outputs.ThanosThanosUserConfigPrivatelinkAccess'] = None,
                  public_access: Optional['outputs.ThanosThanosUserConfigPublicAccess'] = None,
                  query: Optional['outputs.ThanosThanosUserConfigQuery'] = None,
                  query_frontend: Optional['outputs.ThanosThanosUserConfigQueryFrontend'] = None,
+                 receiver_ingesting: Optional[Mapping[str, str]] = None,
+                 receiver_routing: Optional[Mapping[str, str]] = None,
+                 ruler: Optional[Mapping[str, str]] = None,
                  service_log: Optional[bool] = None,
-                 static_ips: Optional[bool] = None):
+                 static_ips: Optional[bool] = None,
+                 store: Optional[Mapping[str, str]] = None):
         """
-        :param 'ThanosThanosUserConfigCompactorArgs' compactor: ThanosCompactor
+        :param 'ThanosThanosUserConfigCompactorArgs' compactor: Configuration options for Thanos Compactor
         :param Mapping[str, str] env: Environmental variables.
         :param Sequence['ThanosThanosUserConfigIpFilterObjectArgs'] 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`.
         :param int object_storage_usage_alert_threshold_gb: After exceeding the limit a service alert is going to be raised (0 means not set).
+        :param 'ThanosThanosUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
+        :param 'ThanosThanosUserConfigPrivatelinkAccessArgs' privatelink_access: Allow access to selected service components through Privatelink
         :param 'ThanosThanosUserConfigPublicAccessArgs' public_access: Allow access to selected service ports from the public Internet
-        :param 'ThanosThanosUserConfigQueryArgs' query: ThanosQuery
-        :param 'ThanosThanosUserConfigQueryFrontendArgs' query_frontend: ThanosQueryFrontend
+        :param 'ThanosThanosUserConfigQueryArgs' query: Configuration options for Thanos Query
+        :param 'ThanosThanosUserConfigQueryFrontendArgs' query_frontend: Configuration options for Thanos Query Frontend
+        :param Mapping[str, str] receiver_ingesting: Common configuration options for Thanos Receive.
+        :param Mapping[str, str] receiver_routing: Configuration options for Thanos Receive Routing.
+        :param Mapping[str, str] ruler: Configuration options for Thanos Ruler.
         :param bool service_log: Store logs for the service so that they are available in the HTTP API and console.
         :param bool static_ips: Use static public IP addresses.
+        :param Mapping[str, str] store: Configuration options for Thanos Store.
         """
         if compactor is not None:
             pulumi.set(__self__, "compactor", compactor)
@@ -24875,22 +25475,34 @@ class ThanosThanosUserConfig(dict):
             pulumi.set(__self__, "ip_filters", ip_filters)
         if object_storage_usage_alert_threshold_gb is not None:
             pulumi.set(__self__, "object_storage_usage_alert_threshold_gb", object_storage_usage_alert_threshold_gb)
+        if private_access is not None:
+            pulumi.set(__self__, "private_access", private_access)
+        if privatelink_access is not None:
+            pulumi.set(__self__, "privatelink_access", privatelink_access)
         if public_access is not None:
             pulumi.set(__self__, "public_access", public_access)
         if query is not None:
             pulumi.set(__self__, "query", query)
         if query_frontend is not None:
             pulumi.set(__self__, "query_frontend", query_frontend)
+        if receiver_ingesting is not None:
+            pulumi.set(__self__, "receiver_ingesting", receiver_ingesting)
+        if receiver_routing is not None:
+            pulumi.set(__self__, "receiver_routing", receiver_routing)
+        if ruler is not None:
+            pulumi.set(__self__, "ruler", ruler)
         if service_log is not None:
             pulumi.set(__self__, "service_log", service_log)
         if static_ips is not None:
             pulumi.set(__self__, "static_ips", static_ips)
+        if store is not None:
+            pulumi.set(__self__, "store", store)
 
     @property
     @pulumi.getter
     def compactor(self) -> Optional['outputs.ThanosThanosUserConfigCompactor']:
         """
-        ThanosCompactor
+        Configuration options for Thanos Compactor
         """
         return pulumi.get(self, "compactor")
 
@@ -24936,6 +25548,22 @@ class ThanosThanosUserConfig(dict):
         """
         return pulumi.get(self, "object_storage_usage_alert_threshold_gb")
 
+    @property
+    @pulumi.getter(name="privateAccess")
+    def private_access(self) -> Optional['outputs.ThanosThanosUserConfigPrivateAccess']:
+        """
+        Allow access to selected service ports from private networks
+        """
+        return pulumi.get(self, "private_access")
+
+    @property
+    @pulumi.getter(name="privatelinkAccess")
+    def privatelink_access(self) -> Optional['outputs.ThanosThanosUserConfigPrivatelinkAccess']:
+        """
+        Allow access to selected service components through Privatelink
+        """
+        return pulumi.get(self, "privatelink_access")
+
     @property
     @pulumi.getter(name="publicAccess")
     def public_access(self) -> Optional['outputs.ThanosThanosUserConfigPublicAccess']:
@@ -24948,7 +25576,7 @@ class ThanosThanosUserConfig(dict):
     @pulumi.getter
     def query(self) -> Optional['outputs.ThanosThanosUserConfigQuery']:
         """
-        ThanosQuery
+        Configuration options for Thanos Query
         """
         return pulumi.get(self, "query")
 
@@ -24956,10 +25584,34 @@ class ThanosThanosUserConfig(dict):
     @pulumi.getter(name="queryFrontend")
     def query_frontend(self) -> Optional['outputs.ThanosThanosUserConfigQueryFrontend']:
         """
-        ThanosQueryFrontend
+        Configuration options for Thanos Query Frontend
         """
         return pulumi.get(self, "query_frontend")
 
+    @property
+    @pulumi.getter(name="receiverIngesting")
+    def receiver_ingesting(self) -> Optional[Mapping[str, str]]:
+        """
+        Common configuration options for Thanos Receive.
+        """
+        return pulumi.get(self, "receiver_ingesting")
+
+    @property
+    @pulumi.getter(name="receiverRouting")
+    def receiver_routing(self) -> Optional[Mapping[str, str]]:
+        """
+        Configuration options for Thanos Receive Routing.
+        """
+        return pulumi.get(self, "receiver_routing")
+
+    @property
+    @pulumi.getter
+    def ruler(self) -> Optional[Mapping[str, str]]:
+        """
+        Configuration options for Thanos Ruler.
+        """
+        return pulumi.get(self, "ruler")
+
     @property
     @pulumi.getter(name="serviceLog")
     def service_log(self) -> Optional[bool]:
@@ -24976,6 +25628,14 @@ class ThanosThanosUserConfig(dict):
         """
         return pulumi.get(self, "static_ips")
 
+    @property
+    @pulumi.getter
+    def store(self) -> Optional[Mapping[str, str]]:
+        """
+        Configuration options for Thanos Store.
+        """
+        return pulumi.get(self, "store")
+
 
 @pulumi.output_type
 class ThanosThanosUserConfigCompactor(dict):
@@ -25043,6 +25703,106 @@ class ThanosThanosUserConfigIpFilterObject(dict):
         return pulumi.get(self, "description")
 
 
+@pulumi.output_type
+class ThanosThanosUserConfigPrivateAccess(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "queryFrontend":
+            suggest = "query_frontend"
+        elif key == "receiverRouting":
+            suggest = "receiver_routing"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ThanosThanosUserConfigPrivateAccess. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ThanosThanosUserConfigPrivateAccess.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ThanosThanosUserConfigPrivateAccess.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 query_frontend: Optional[bool] = None,
+                 receiver_routing: Optional[bool] = None):
+        """
+        :param bool query_frontend: Allow clients to connect to query_frontend with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        :param bool receiver_routing: Allow clients to connect to receiver_routing with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        if query_frontend is not None:
+            pulumi.set(__self__, "query_frontend", query_frontend)
+        if receiver_routing is not None:
+            pulumi.set(__self__, "receiver_routing", receiver_routing)
+
+    @property
+    @pulumi.getter(name="queryFrontend")
+    def query_frontend(self) -> Optional[bool]:
+        """
+        Allow clients to connect to query_frontend with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        return pulumi.get(self, "query_frontend")
+
+    @property
+    @pulumi.getter(name="receiverRouting")
+    def receiver_routing(self) -> Optional[bool]:
+        """
+        Allow clients to connect to receiver_routing with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        return pulumi.get(self, "receiver_routing")
+
+
+@pulumi.output_type
+class ThanosThanosUserConfigPrivatelinkAccess(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "queryFrontend":
+            suggest = "query_frontend"
+        elif key == "receiverRouting":
+            suggest = "receiver_routing"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ThanosThanosUserConfigPrivatelinkAccess. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ThanosThanosUserConfigPrivatelinkAccess.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ThanosThanosUserConfigPrivatelinkAccess.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 query_frontend: Optional[bool] = None,
+                 receiver_routing: Optional[bool] = None):
+        """
+        :param bool query_frontend: Enable query_frontend.
+        :param bool receiver_routing: Enable receiver_routing.
+        """
+        if query_frontend is not None:
+            pulumi.set(__self__, "query_frontend", query_frontend)
+        if receiver_routing is not None:
+            pulumi.set(__self__, "receiver_routing", receiver_routing)
+
+    @property
+    @pulumi.getter(name="queryFrontend")
+    def query_frontend(self) -> Optional[bool]:
+        """
+        Enable query_frontend.
+        """
+        return pulumi.get(self, "query_frontend")
+
+    @property
+    @pulumi.getter(name="receiverRouting")
+    def receiver_routing(self) -> Optional[bool]:
+        """
+        Enable receiver_routing.
+        """
+        return pulumi.get(self, "receiver_routing")
+
+
 @pulumi.output_type
 class ThanosThanosUserConfigPublicAccess(dict):
     @staticmethod
@@ -25702,7 +26462,7 @@ class ValkeyValkeyUserConfig(dict):
         :param int valkey_io_threads: Set Valkey IO thread count. Changing this will cause a restart of the Valkey service. Example: `1`.
         :param int valkey_lfu_decay_time: LFU maxmemory-policy counter decay time in minutes. Default: `1`.
         :param int valkey_lfu_log_factor: Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies. Default: `10`.
-        :param str valkey_maxmemory_policy: Enum: `noeviction`, `allkeys-lru`, `volatile-lru`, `allkeys-random`, `volatile-random`, `volatile-ttl`, `volatile-lfu`, `allkeys-lfu`. Valkey maxmemory-policy. Default: `noeviction`.
+        :param str valkey_maxmemory_policy: Enum: `allkeys-lfu`, `allkeys-lru`, `allkeys-random`, `noeviction`, `volatile-lfu`, `volatile-lru`, `volatile-random`, `volatile-ttl`. Valkey maxmemory-policy. Default: `noeviction`.
         :param str valkey_notify_keyspace_events: Set notify-keyspace-events option.
         :param int valkey_number_of_databases: Set number of Valkey databases. Changing this will cause a restart of the Valkey service. Example: `16`.
         :param str valkey_persistence: Enum: `off`, `rdb`. When persistence is `rdb`, Valkey does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
@@ -25920,7 +26680,7 @@ class ValkeyValkeyUserConfig(dict):
     @pulumi.getter(name="valkeyMaxmemoryPolicy")
     def valkey_maxmemory_policy(self) -> Optional[str]:
         """
-        Enum: `noeviction`, `allkeys-lru`, `volatile-lru`, `allkeys-random`, `volatile-random`, `volatile-ttl`, `volatile-lfu`, `allkeys-lfu`. Valkey maxmemory-policy. Default: `noeviction`.
+        Enum: `allkeys-lfu`, `allkeys-lru`, `allkeys-random`, `noeviction`, `volatile-lfu`, `volatile-lru`, `volatile-random`, `volatile-ttl`. Valkey maxmemory-policy. Default: `noeviction`.
         """
         return pulumi.get(self, "valkey_maxmemory_policy")
 
@@ -26385,7 +27145,6 @@ class GetCassandaCassandraUserConfigResult(dict):
 
     @property
     @pulumi.getter(name="additionalBackupRegions")
-    @_utilities.deprecated("""This property is deprecated.""")
     def additional_backup_regions(self) -> Optional[str]:
         """
         Additional Cloud Regions for Backup Replication.
@@ -26910,7 +27669,6 @@ class GetCassandraCassandraUserConfigResult(dict):
 
     @property
     @pulumi.getter(name="additionalBackupRegions")
-    @_utilities.deprecated("""This property is deprecated.""")
     def additional_backup_regions(self) -> Optional[str]:
         """
         Additional Cloud Regions for Backup Replication.
@@ -28048,7 +28806,7 @@ class GetDragonflyDragonflyUserConfigResult(dict):
                  static_ips: Optional[bool] = None):
         """
         :param bool cache_mode: Evict entries when getting close to maxmemory limit. Default: `false`.
-        :param str dragonfly_persistence: Enum: `off`, `rdb`, `dfs`. When persistence is `rdb` or `dfs`, Dragonfly does RDB or DFS dumps every 10 minutes. Dumps are done according to the backup schedule for backup purposes. When persistence is `off`, no RDB/DFS dumps or backups are done, so data can be lost at any moment if the service is restarted for any reason, or if the service is powered off. Also, the service can't be forked.
+        :param str dragonfly_persistence: Enum: `dfs`, `off`, `rdb`. When persistence is `rdb` or `dfs`, Dragonfly does RDB or DFS dumps every 10 minutes. Dumps are done according to the backup schedule for backup purposes. When persistence is `off`, no RDB/DFS dumps or backups are done, so data can be lost at any moment if the service is restarted for any reason, or if the service is powered off. Also, the service can't be forked.
         :param bool dragonfly_ssl: Require SSL to access Dragonfly. Default: `true`.
         :param Sequence['GetDragonflyDragonflyUserConfigIpFilterObjectArgs'] 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`.
@@ -28106,7 +28864,7 @@ class GetDragonflyDragonflyUserConfigResult(dict):
     @pulumi.getter(name="dragonflyPersistence")
     def dragonfly_persistence(self) -> Optional[str]:
         """
-        Enum: `off`, `rdb`, `dfs`. When persistence is `rdb` or `dfs`, Dragonfly does RDB or DFS dumps every 10 minutes. Dumps are done according to the backup schedule for backup purposes. When persistence is `off`, no RDB/DFS dumps or backups are done, so data can be lost at any moment if the service is restarted for any reason, or if the service is powered off. Also, the service can't be forked.
+        Enum: `dfs`, `off`, `rdb`. When persistence is `rdb` or `dfs`, Dragonfly does RDB or DFS dumps every 10 minutes. Dumps are done according to the backup schedule for backup purposes. When persistence is `off`, no RDB/DFS dumps or backups are done, so data can be lost at any moment if the service is restarted for any reason, or if the service is powered off. Also, the service can't be forked.
         """
         return pulumi.get(self, "dragonfly_persistence")
 
@@ -29171,10 +29929,10 @@ class GetGrafanaGrafanaUserConfigResult(dict):
                  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.
+        :param bool alerting_enabled: Setting has no effect with Grafana 11 and onward. Enable or disable Grafana legacy alerting functionality. This should not be enabled with unified_alerting_enabled.
         :param str alerting_error_or_timeout: Enum: `alerting`, `keep_state`. Default error or timeout setting for new alerting rules.
         :param int alerting_max_annotations_to_keep: Max number of alert annotations that Grafana stores. 0 (default) keeps all alert annotations. Example: `0`.
-        :param str alerting_nodata_or_nullvalues: Enum: `alerting`, `no_data`, `keep_state`, `ok`. Default value for 'no data or null values' for new alerting rules.
+        :param str alerting_nodata_or_nullvalues: Enum: `alerting`, `keep_state`, `no_data`, `ok`. Default value for 'no data or null values' for new alerting rules.
         :param bool allow_embedding: Allow embedding Grafana dashboards with iframe/frame/object/embed tags. Disabled by default to limit impact of clickjacking.
         :param 'GetGrafanaGrafanaUserConfigAuthAzureadArgs' auth_azuread: Azure AD OAuth integration
         :param bool auth_basic_enabled: Enable or disable basic authentication form, used by Grafana built-in login.
@@ -29182,9 +29940,9 @@ class GetGrafanaGrafanaUserConfigResult(dict):
         :param 'GetGrafanaGrafanaUserConfigAuthGithubArgs' auth_github: Github Auth integration
         :param 'GetGrafanaGrafanaUserConfigAuthGitlabArgs' auth_gitlab: GitLab Auth integration
         :param 'GetGrafanaGrafanaUserConfigAuthGoogleArgs' auth_google: Google Auth integration
-        :param str cookie_samesite: Enum: `lax`, `strict`, `none`. Cookie SameSite attribute: `strict` prevents sending cookie for cross-site requests, effectively disabling direct linking from other sites to Grafana. `lax` is the default value.
+        :param str cookie_samesite: Enum: `lax`, `none`, `strict`. Cookie SameSite attribute: `strict` prevents sending cookie for cross-site requests, effectively disabling direct linking from other sites to Grafana. `lax` is the default value.
         :param str custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. Example: `grafana.example.org`.
-        :param bool dashboard_previews_enabled: This feature is new in Grafana 9 and is quite resource intensive. It may cause low-end plans to work more slowly while the dashboard previews are rendering.
+        :param bool dashboard_previews_enabled: Enable browsing of dashboards in grid (pictures) mode. This feature is new in Grafana 9 and is quite resource intensive. It may cause low-end plans to work more slowly while the dashboard previews are rendering.
         :param str dashboards_min_refresh_interval: Signed sequence of decimal numbers, followed by a unit suffix (ms, s, m, h, d), e.g. 30s, 1h. Example: `5s`.
         :param int dashboards_versions_to_keep: Dashboard versions to keep per dashboard. Example: `20`.
         :param bool dataproxy_send_user_header: Send `X-Grafana-User` header to data source.
@@ -29197,7 +29955,7 @@ class GetGrafanaGrafanaUserConfigResult(dict):
         :param Sequence['GetGrafanaGrafanaUserConfigIpFilterObjectArgs'] 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`.
-        :param bool metrics_enabled: Enable Grafana /metrics endpoint.
+        :param bool metrics_enabled: Enable Grafana's /metrics endpoint.
         :param bool oauth_allow_insecure_email_lookup: Enforce user lookup based on email instead of the unique ID provided by the IdP.
         :param 'GetGrafanaGrafanaUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
         :param 'GetGrafanaGrafanaUserConfigPrivatelinkAccessArgs' privatelink_access: Allow access to selected service components through Privatelink
@@ -29208,9 +29966,9 @@ class GetGrafanaGrafanaUserConfigResult(dict):
         :param str service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
         :param 'GetGrafanaGrafanaUserConfigSmtpServerArgs' smtp_server: SMTP server settings
         :param bool static_ips: Use static public IP addresses.
-        :param bool unified_alerting_enabled: Enable or disable Grafana unified alerting functionality. By default this is enabled and any legacy alerts will be migrated on upgrade to Grafana 9+. To stay on legacy alerting, set unified_alerting_enabled to false and alerting_enabled to true. See https://grafana.com/docs/grafana/latest/alerting/set-up/migrating-alerts/ for more details.
+        :param bool unified_alerting_enabled: Enable or disable Grafana unified alerting functionality. By default this is enabled and any legacy alerts will be migrated on upgrade to Grafana 9+. To stay on legacy alerting, set unified_alerting_enabled to false and alerting_enabled to true. See https://grafana.com/docs/grafana/latest/alerting/ for more details.
         :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 str user_auto_assign_org_role: Enum: `Admin`, `Editor`, `Viewer`. 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).
         """
@@ -29313,7 +30071,7 @@ class GetGrafanaGrafanaUserConfigResult(dict):
     @pulumi.getter(name="alertingEnabled")
     def alerting_enabled(self) -> Optional[bool]:
         """
-        Enable or disable Grafana legacy alerting functionality. This should not be enabled with unified_alerting_enabled.
+        Setting has no effect with Grafana 11 and onward. Enable or disable Grafana legacy alerting functionality. This should not be enabled with unified_alerting_enabled.
         """
         return pulumi.get(self, "alerting_enabled")
 
@@ -29337,7 +30095,7 @@ class GetGrafanaGrafanaUserConfigResult(dict):
     @pulumi.getter(name="alertingNodataOrNullvalues")
     def alerting_nodata_or_nullvalues(self) -> Optional[str]:
         """
-        Enum: `alerting`, `no_data`, `keep_state`, `ok`. Default value for 'no data or null values' for new alerting rules.
+        Enum: `alerting`, `keep_state`, `no_data`, `ok`. Default value for 'no data or null values' for new alerting rules.
         """
         return pulumi.get(self, "alerting_nodata_or_nullvalues")
 
@@ -29401,7 +30159,7 @@ class GetGrafanaGrafanaUserConfigResult(dict):
     @pulumi.getter(name="cookieSamesite")
     def cookie_samesite(self) -> Optional[str]:
         """
-        Enum: `lax`, `strict`, `none`. Cookie SameSite attribute: `strict` prevents sending cookie for cross-site requests, effectively disabling direct linking from other sites to Grafana. `lax` is the default value.
+        Enum: `lax`, `none`, `strict`. Cookie SameSite attribute: `strict` prevents sending cookie for cross-site requests, effectively disabling direct linking from other sites to Grafana. `lax` is the default value.
         """
         return pulumi.get(self, "cookie_samesite")
 
@@ -29417,7 +30175,7 @@ class GetGrafanaGrafanaUserConfigResult(dict):
     @pulumi.getter(name="dashboardPreviewsEnabled")
     def dashboard_previews_enabled(self) -> Optional[bool]:
         """
-        This feature is new in Grafana 9 and is quite resource intensive. It may cause low-end plans to work more slowly while the dashboard previews are rendering.
+        Enable browsing of dashboards in grid (pictures) mode. This feature is new in Grafana 9 and is quite resource intensive. It may cause low-end plans to work more slowly while the dashboard previews are rendering.
         """
         return pulumi.get(self, "dashboard_previews_enabled")
 
@@ -29522,7 +30280,7 @@ class GetGrafanaGrafanaUserConfigResult(dict):
     @pulumi.getter(name="metricsEnabled")
     def metrics_enabled(self) -> Optional[bool]:
         """
-        Enable Grafana /metrics endpoint.
+        Enable Grafana's /metrics endpoint.
         """
         return pulumi.get(self, "metrics_enabled")
 
@@ -29610,7 +30368,7 @@ class GetGrafanaGrafanaUserConfigResult(dict):
     @pulumi.getter(name="unifiedAlertingEnabled")
     def unified_alerting_enabled(self) -> Optional[bool]:
         """
-        Enable or disable Grafana unified alerting functionality. By default this is enabled and any legacy alerts will be migrated on upgrade to Grafana 9+. To stay on legacy alerting, set unified_alerting_enabled to false and alerting_enabled to true. See https://grafana.com/docs/grafana/latest/alerting/set-up/migrating-alerts/ for more details.
+        Enable or disable Grafana unified alerting functionality. By default this is enabled and any legacy alerts will be migrated on upgrade to Grafana 9+. To stay on legacy alerting, set unified_alerting_enabled to false and alerting_enabled to true. See https://grafana.com/docs/grafana/latest/alerting/ for more details.
         """
         return pulumi.get(self, "unified_alerting_enabled")
 
@@ -29626,7 +30384,7 @@ class GetGrafanaGrafanaUserConfigResult(dict):
     @pulumi.getter(name="userAutoAssignOrgRole")
     def user_auto_assign_org_role(self) -> Optional[str]:
         """
-        Enum: `Viewer`, `Admin`, `Editor`. Set role for new signups. Defaults to Viewer.
+        Enum: `Admin`, `Editor`, `Viewer`. Set role for new signups. Defaults to Viewer.
         """
         return pulumi.get(self, "user_auto_assign_org_role")
 
@@ -29984,9 +30742,9 @@ class GetGrafanaGrafanaUserConfigAuthGitlabResult(dict):
         :param str client_id: Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
         :param str client_secret: Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
         :param bool allow_sign_up: Automatically sign-up users on successful sign-in.
-        :param str api_url: API URL. This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/api/v4`.
-        :param str auth_url: Authorization URL. This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/authorize`.
-        :param str token_url: Token URL. This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/token`.
+        :param str api_url: This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/api/v4`.
+        :param str auth_url: This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/authorize`.
+        :param str token_url: This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/token`.
         """
         pulumi.set(__self__, "allowed_groups", allowed_groups)
         pulumi.set(__self__, "client_id", client_id)
@@ -30036,7 +30794,7 @@ class GetGrafanaGrafanaUserConfigAuthGitlabResult(dict):
     @pulumi.getter(name="apiUrl")
     def api_url(self) -> Optional[str]:
         """
-        API URL. This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/api/v4`.
+        This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/api/v4`.
         """
         return pulumi.get(self, "api_url")
 
@@ -30044,7 +30802,7 @@ class GetGrafanaGrafanaUserConfigAuthGitlabResult(dict):
     @pulumi.getter(name="authUrl")
     def auth_url(self) -> Optional[str]:
         """
-        Authorization URL. This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/authorize`.
+        This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/authorize`.
         """
         return pulumi.get(self, "auth_url")
 
@@ -30052,7 +30810,7 @@ class GetGrafanaGrafanaUserConfigAuthGitlabResult(dict):
     @pulumi.getter(name="tokenUrl")
     def token_url(self) -> Optional[str]:
         """
-        Token URL. This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/token`.
+        This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/token`.
         """
         return pulumi.get(self, "token_url")
 
@@ -30222,7 +30980,7 @@ class GetGrafanaGrafanaUserConfigExternalImageStorageResult(dict):
         """
         :param str access_key: S3 access key. Requires permissions to the S3 bucket for the s3:PutObject and s3:PutObjectAcl actions. Example: `AAAAAAAAAAAAAAAAAAA`.
         :param str bucket_url: Bucket URL for S3. Example: `https://grafana.s3-ap-southeast-2.amazonaws.com/`.
-        :param str provider: Enum: `s3`. Provider type.
+        :param str provider: Enum: `s3`. External image store provider.
         :param str secret_key: S3 secret key. Example: `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`.
         """
         pulumi.set(__self__, "access_key", access_key)
@@ -30250,7 +31008,7 @@ class GetGrafanaGrafanaUserConfigExternalImageStorageResult(dict):
     @pulumi.getter
     def provider(self) -> str:
         """
-        Enum: `s3`. Provider type.
+        Enum: `s3`. External image store provider.
         """
         return pulumi.get(self, "provider")
 
@@ -30368,7 +31126,7 @@ class GetGrafanaGrafanaUserConfigSmtpServerResult(dict):
         :param str from_name: Name used in outgoing emails, defaults to Grafana.
         :param str password: Password for SMTP authentication. Example: `ein0eemeev5eeth3Ahfu`.
         :param bool skip_verify: Skip verifying server certificate. Defaults to false.
-        :param str starttls_policy: Enum: `OpportunisticStartTLS`, `MandatoryStartTLS`, `NoStartTLS`. Either OpportunisticStartTLS, MandatoryStartTLS or NoStartTLS. Default is OpportunisticStartTLS.
+        :param str starttls_policy: Enum: `MandatoryStartTLS`, `NoStartTLS`, `OpportunisticStartTLS`. Either OpportunisticStartTLS, MandatoryStartTLS or NoStartTLS. Default is OpportunisticStartTLS.
         :param str username: Username for SMTP authentication. Example: `smtpuser`.
         """
         pulumi.set(__self__, "from_address", from_address)
@@ -30437,7 +31195,7 @@ class GetGrafanaGrafanaUserConfigSmtpServerResult(dict):
     @pulumi.getter(name="starttlsPolicy")
     def starttls_policy(self) -> Optional[str]:
         """
-        Enum: `OpportunisticStartTLS`, `MandatoryStartTLS`, `NoStartTLS`. Either OpportunisticStartTLS, MandatoryStartTLS or NoStartTLS. Default is OpportunisticStartTLS.
+        Enum: `MandatoryStartTLS`, `NoStartTLS`, `OpportunisticStartTLS`. Either OpportunisticStartTLS, MandatoryStartTLS or NoStartTLS. Default is OpportunisticStartTLS.
         """
         return pulumi.get(self, "starttls_policy")
 
@@ -30678,6 +31436,7 @@ class GetInfluxDbInfluxdbUserConfigResult(dict):
                  additional_backup_regions: Optional[str] = None,
                  custom_domain: Optional[str] = None,
                  influxdb: Optional['outputs.GetInfluxDbInfluxdbUserConfigInfluxdbResult'] = None,
+                 influxdb_version: Optional[str] = None,
                  ip_filter_objects: Optional[Sequence['outputs.GetInfluxDbInfluxdbUserConfigIpFilterObjectResult']] = None,
                  ip_filter_strings: Optional[Sequence[str]] = None,
                  ip_filters: Optional[Sequence[str]] = None,
@@ -30693,6 +31452,7 @@ class GetInfluxDbInfluxdbUserConfigResult(dict):
         :param str additional_backup_regions: Additional Cloud Regions for Backup Replication.
         :param str custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. Example: `grafana.example.org`.
         :param 'GetInfluxDbInfluxdbUserConfigInfluxdbArgs' influxdb: influxdb.conf configuration values
+        :param str influxdb_version: Enum: `1.8`, and newer. InfluxDB major version. Default: `1.8`.
         :param Sequence['GetInfluxDbInfluxdbUserConfigIpFilterObjectArgs'] 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`.
@@ -30711,6 +31471,8 @@ class GetInfluxDbInfluxdbUserConfigResult(dict):
             pulumi.set(__self__, "custom_domain", custom_domain)
         if influxdb is not None:
             pulumi.set(__self__, "influxdb", influxdb)
+        if influxdb_version is not None:
+            pulumi.set(__self__, "influxdb_version", influxdb_version)
         if ip_filter_objects is not None:
             pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
         if ip_filter_strings is not None:
@@ -30759,6 +31521,14 @@ class GetInfluxDbInfluxdbUserConfigResult(dict):
         """
         return pulumi.get(self, "influxdb")
 
+    @property
+    @pulumi.getter(name="influxdbVersion")
+    def influxdb_version(self) -> Optional[str]:
+        """
+        Enum: `1.8`, and newer. InfluxDB major version. Default: `1.8`.
+        """
+        return pulumi.get(self, "influxdb_version")
+
     @property
     @pulumi.getter(name="ipFilterObjects")
     def ip_filter_objects(self) -> Optional[Sequence['outputs.GetInfluxDbInfluxdbUserConfigIpFilterObjectResult']]:
@@ -30973,12 +31743,16 @@ class GetInfluxDbInfluxdbUserConfigIpFilterObjectResult(dict):
 @pulumi.output_type
 class GetInfluxDbInfluxdbUserConfigPrivateAccessResult(dict):
     def __init__(__self__, *,
-                 influxdb: Optional[bool] = None):
+                 influxdb: Optional[bool] = None,
+                 user_backup: Optional[bool] = None):
         """
         :param bool influxdb: Allow clients to connect to influxdb with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        :param bool user_backup: Allow clients to connect to user_backup with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
         """
         if influxdb is not None:
             pulumi.set(__self__, "influxdb", influxdb)
+        if user_backup is not None:
+            pulumi.set(__self__, "user_backup", user_backup)
 
     @property
     @pulumi.getter
@@ -30988,16 +31762,28 @@ class GetInfluxDbInfluxdbUserConfigPrivateAccessResult(dict):
         """
         return pulumi.get(self, "influxdb")
 
+    @property
+    @pulumi.getter(name="userBackup")
+    def user_backup(self) -> Optional[bool]:
+        """
+        Allow clients to connect to user_backup with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        return pulumi.get(self, "user_backup")
+
 
 @pulumi.output_type
 class GetInfluxDbInfluxdbUserConfigPrivatelinkAccessResult(dict):
     def __init__(__self__, *,
-                 influxdb: Optional[bool] = None):
+                 influxdb: Optional[bool] = None,
+                 user_backup: Optional[bool] = None):
         """
         :param bool influxdb: Enable influxdb.
+        :param bool user_backup: Enable user_backup.
         """
         if influxdb is not None:
             pulumi.set(__self__, "influxdb", influxdb)
+        if user_backup is not None:
+            pulumi.set(__self__, "user_backup", user_backup)
 
     @property
     @pulumi.getter
@@ -31007,16 +31793,28 @@ class GetInfluxDbInfluxdbUserConfigPrivatelinkAccessResult(dict):
         """
         return pulumi.get(self, "influxdb")
 
+    @property
+    @pulumi.getter(name="userBackup")
+    def user_backup(self) -> Optional[bool]:
+        """
+        Enable user_backup.
+        """
+        return pulumi.get(self, "user_backup")
+
 
 @pulumi.output_type
 class GetInfluxDbInfluxdbUserConfigPublicAccessResult(dict):
     def __init__(__self__, *,
-                 influxdb: Optional[bool] = None):
+                 influxdb: Optional[bool] = None,
+                 user_backup: Optional[bool] = None):
         """
         :param bool influxdb: Allow clients to connect to influxdb from the public internet for service nodes that are in a project VPC or another type of private network.
+        :param bool user_backup: Allow clients to connect to user_backup from the public internet for service nodes that are in a project VPC or another type of private network.
         """
         if influxdb is not None:
             pulumi.set(__self__, "influxdb", influxdb)
+        if user_backup is not None:
+            pulumi.set(__self__, "user_backup", user_backup)
 
     @property
     @pulumi.getter
@@ -31026,6 +31824,14 @@ class GetInfluxDbInfluxdbUserConfigPublicAccessResult(dict):
         """
         return pulumi.get(self, "influxdb")
 
+    @property
+    @pulumi.getter(name="userBackup")
+    def user_backup(self) -> Optional[bool]:
+        """
+        Allow clients to connect to user_backup from the public internet for service nodes that are in a project VPC or another type of private network.
+        """
+        return pulumi.get(self, "user_backup")
+
 
 @pulumi.output_type
 class GetInfluxDbServiceIntegrationResult(dict):
@@ -31480,10 +32286,10 @@ class GetKafkaConnectKafkaConnectUserConfigKafkaConnectResult(dict):
                  scheduled_rebalance_max_delay_ms: Optional[int] = None,
                  session_timeout_ms: Optional[int] = None):
         """
-        :param str connector_client_config_override_policy: Enum: `None`, `All`. Defines what client configurations can be overridden by the connector. Default is None.
+        :param str connector_client_config_override_policy: Enum: `All`, `None`. Defines what client configurations can be overridden by the connector. Default is None.
         :param str consumer_auto_offset_reset: Enum: `earliest`, `latest`. What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
         :param int consumer_fetch_max_bytes: Records are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not a absolute maximum. Example: `52428800`.
-        :param str consumer_isolation_level: Enum: `read_uncommitted`, `read_committed`. Transaction read isolation level. read_uncommitted is the default, but read_committed can be used if consume-exactly-once behavior is desired.
+        :param str consumer_isolation_level: Enum: `read_committed`, `read_uncommitted`. Transaction read isolation level. read_uncommitted is the default, but read_committed can be used if consume-exactly-once behavior is desired.
         :param int consumer_max_partition_fetch_bytes: Records are fetched in batches by the consumer.If the first record batch in the first non-empty partition of the fetch is larger than this limit, the batch will still be returned to ensure that the consumer can make progress. Example: `1048576`.
         :param int consumer_max_poll_interval_ms: The maximum delay in milliseconds between invocations of poll() when using consumer group management (defaults to 300000).
         :param int consumer_max_poll_records: The maximum number of records returned in a single call to poll() (defaults to 500).
@@ -31491,7 +32297,7 @@ class GetKafkaConnectKafkaConnectUserConfigKafkaConnectResult(dict):
         :param int offset_flush_timeout_ms: Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt (defaults to 5000).
         :param int producer_batch_size: This setting gives the upper bound of the batch size to be sent. If there are fewer than this many bytes accumulated for this partition, the producer will `linger` for the linger.ms time waiting for more records to show up. A batch size of zero will disable batching entirely (defaults to 16384).
         :param int producer_buffer_memory: The total bytes of memory the producer can use to buffer records waiting to be sent to the broker (defaults to 33554432).
-        :param str producer_compression_type: Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
+        :param str producer_compression_type: Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
         :param int producer_linger_ms: This setting gives the upper bound on the delay for batching: once there is batch.size worth of records for a partition it will be sent immediately regardless of this setting, however if there are fewer than this many bytes accumulated for this partition the producer will `linger` for the specified time waiting for more records to show up. Defaults to 0.
         :param int producer_max_request_size: This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests. Example: `1048576`.
         :param int scheduled_rebalance_max_delay_ms: The maximum delay that is scheduled in order to wait for the return of one or more departed workers before rebalancing and reassigning their connectors and tasks to the group. During this period the connectors and tasks of the departed workers remain unassigned. Defaults to 5 minutes.
@@ -31534,7 +32340,7 @@ class GetKafkaConnectKafkaConnectUserConfigKafkaConnectResult(dict):
     @pulumi.getter(name="connectorClientConfigOverridePolicy")
     def connector_client_config_override_policy(self) -> Optional[str]:
         """
-        Enum: `None`, `All`. Defines what client configurations can be overridden by the connector. Default is None.
+        Enum: `All`, `None`. Defines what client configurations can be overridden by the connector. Default is None.
         """
         return pulumi.get(self, "connector_client_config_override_policy")
 
@@ -31558,7 +32364,7 @@ class GetKafkaConnectKafkaConnectUserConfigKafkaConnectResult(dict):
     @pulumi.getter(name="consumerIsolationLevel")
     def consumer_isolation_level(self) -> Optional[str]:
         """
-        Enum: `read_uncommitted`, `read_committed`. Transaction read isolation level. read_uncommitted is the default, but read_committed can be used if consume-exactly-once behavior is desired.
+        Enum: `read_committed`, `read_uncommitted`. Transaction read isolation level. read_uncommitted is the default, but read_committed can be used if consume-exactly-once behavior is desired.
         """
         return pulumi.get(self, "consumer_isolation_level")
 
@@ -31622,7 +32428,7 @@ class GetKafkaConnectKafkaConnectUserConfigKafkaConnectResult(dict):
     @pulumi.getter(name="producerCompressionType")
     def producer_compression_type(self) -> Optional[str]:
         """
-        Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
+        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
         """
         return pulumi.get(self, "producer_compression_type")
 
@@ -31772,8 +32578,8 @@ class GetKafkaConnectKafkaConnectUserConfigSecretProviderResult(dict):
                  vault: Optional['outputs.GetKafkaConnectKafkaConnectUserConfigSecretProviderVaultResult'] = None):
         """
         :param str name: Name of the secret provider. Used to reference secrets in connector config.
-        :param 'GetKafkaConnectKafkaConnectUserConfigSecretProviderAwsArgs' aws: AWS config for Secret Provider
-        :param 'GetKafkaConnectKafkaConnectUserConfigSecretProviderVaultArgs' vault: Vault Config for Secret Provider
+        :param 'GetKafkaConnectKafkaConnectUserConfigSecretProviderAwsArgs' aws: AWS secret provider configuration
+        :param 'GetKafkaConnectKafkaConnectUserConfigSecretProviderVaultArgs' vault: Vault secret provider configuration
         """
         pulumi.set(__self__, "name", name)
         if aws is not None:
@@ -31793,7 +32599,7 @@ class GetKafkaConnectKafkaConnectUserConfigSecretProviderResult(dict):
     @pulumi.getter
     def aws(self) -> Optional['outputs.GetKafkaConnectKafkaConnectUserConfigSecretProviderAwsResult']:
         """
-        AWS config for Secret Provider
+        AWS secret provider configuration
         """
         return pulumi.get(self, "aws")
 
@@ -31801,7 +32607,7 @@ class GetKafkaConnectKafkaConnectUserConfigSecretProviderResult(dict):
     @pulumi.getter
     def vault(self) -> Optional['outputs.GetKafkaConnectKafkaConnectUserConfigSecretProviderVaultResult']:
         """
-        Vault Config for Secret Provider
+        Vault secret provider configuration
         """
         return pulumi.get(self, "vault")
 
@@ -32531,7 +33337,7 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
                  transaction_state_log_segment_bytes: Optional[int] = None):
         """
         :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 str compression_type: Enum: `gzip`, `lz4`, `producer`, `snappy`, `uncompressed`, `zstd`. 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`.
@@ -32541,8 +33347,8 @@ class GetKafkaKafkaUserConfigKafkaResult(dict):
         :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 str log_cleanup_policy: Enum: `compact`, `compact,delete`, `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)).
         :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`.
@@ -32682,7 +33488,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.(Default: producer).
+        Enum: `gzip`, `lz4`, `producer`, `snappy`, `uncompressed`, `zstd`. 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")
 
@@ -32762,7 +33568,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 (Default: delete).
+        Enum: `compact`, `compact,delete`, `delete`. The default cleanup policy for segments beyond the retention window (Default: delete).
         """
         return pulumi.get(self, "log_cleanup_policy")
 
@@ -32770,7 +33576,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 (Default: 9223372036854775807 (Long.MAX_VALUE)). Example: `9223372036854775807`.
+        The number of messages accumulated on a log partition before messages are flushed to disk (Default: 9223372036854775807 (Long.MAX_VALUE)).
         """
         return pulumi.get(self, "log_flush_interval_messages")
 
@@ -33090,10 +33896,10 @@ class GetKafkaKafkaUserConfigKafkaConnectConfigResult(dict):
                  scheduled_rebalance_max_delay_ms: Optional[int] = None,
                  session_timeout_ms: Optional[int] = None):
         """
-        :param str connector_client_config_override_policy: Enum: `None`, `All`. Defines what client configurations can be overridden by the connector. Default is None.
+        :param str connector_client_config_override_policy: Enum: `All`, `None`. Defines what client configurations can be overridden by the connector. Default is None.
         :param str consumer_auto_offset_reset: Enum: `earliest`, `latest`. What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
         :param int consumer_fetch_max_bytes: Records are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not a absolute maximum. Example: `52428800`.
-        :param str consumer_isolation_level: Enum: `read_uncommitted`, `read_committed`. Transaction read isolation level. read_uncommitted is the default, but read_committed can be used if consume-exactly-once behavior is desired.
+        :param str consumer_isolation_level: Enum: `read_committed`, `read_uncommitted`. Transaction read isolation level. read_uncommitted is the default, but read_committed can be used if consume-exactly-once behavior is desired.
         :param int consumer_max_partition_fetch_bytes: Records are fetched in batches by the consumer.If the first record batch in the first non-empty partition of the fetch is larger than this limit, the batch will still be returned to ensure that the consumer can make progress. Example: `1048576`.
         :param int consumer_max_poll_interval_ms: The maximum delay in milliseconds between invocations of poll() when using consumer group management (defaults to 300000).
         :param int consumer_max_poll_records: The maximum number of records returned in a single call to poll() (defaults to 500).
@@ -33101,7 +33907,7 @@ class GetKafkaKafkaUserConfigKafkaConnectConfigResult(dict):
         :param int offset_flush_timeout_ms: Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt (defaults to 5000).
         :param int producer_batch_size: This setting gives the upper bound of the batch size to be sent. If there are fewer than this many bytes accumulated for this partition, the producer will `linger` for the linger.ms time waiting for more records to show up. A batch size of zero will disable batching entirely (defaults to 16384).
         :param int producer_buffer_memory: The total bytes of memory the producer can use to buffer records waiting to be sent to the broker (defaults to 33554432).
-        :param str producer_compression_type: Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
+        :param str producer_compression_type: Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
         :param int producer_linger_ms: This setting gives the upper bound on the delay for batching: once there is batch.size worth of records for a partition it will be sent immediately regardless of this setting, however if there are fewer than this many bytes accumulated for this partition the producer will `linger` for the specified time waiting for more records to show up. Defaults to 0.
         :param int producer_max_request_size: This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests. Example: `1048576`.
         :param int scheduled_rebalance_max_delay_ms: The maximum delay that is scheduled in order to wait for the return of one or more departed workers before rebalancing and reassigning their connectors and tasks to the group. During this period the connectors and tasks of the departed workers remain unassigned. Defaults to 5 minutes.
@@ -33144,7 +33950,7 @@ class GetKafkaKafkaUserConfigKafkaConnectConfigResult(dict):
     @pulumi.getter(name="connectorClientConfigOverridePolicy")
     def connector_client_config_override_policy(self) -> Optional[str]:
         """
-        Enum: `None`, `All`. Defines what client configurations can be overridden by the connector. Default is None.
+        Enum: `All`, `None`. Defines what client configurations can be overridden by the connector. Default is None.
         """
         return pulumi.get(self, "connector_client_config_override_policy")
 
@@ -33168,7 +33974,7 @@ class GetKafkaKafkaUserConfigKafkaConnectConfigResult(dict):
     @pulumi.getter(name="consumerIsolationLevel")
     def consumer_isolation_level(self) -> Optional[str]:
         """
-        Enum: `read_uncommitted`, `read_committed`. Transaction read isolation level. read_uncommitted is the default, but read_committed can be used if consume-exactly-once behavior is desired.
+        Enum: `read_committed`, `read_uncommitted`. Transaction read isolation level. read_uncommitted is the default, but read_committed can be used if consume-exactly-once behavior is desired.
         """
         return pulumi.get(self, "consumer_isolation_level")
 
@@ -33232,7 +34038,7 @@ class GetKafkaKafkaUserConfigKafkaConnectConfigResult(dict):
     @pulumi.getter(name="producerCompressionType")
     def producer_compression_type(self) -> Optional[str]:
         """
-        Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
+        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
         """
         return pulumi.get(self, "producer_compression_type")
 
@@ -33277,8 +34083,8 @@ class GetKafkaKafkaUserConfigKafkaConnectSecretProviderResult(dict):
                  vault: Optional['outputs.GetKafkaKafkaUserConfigKafkaConnectSecretProviderVaultResult'] = None):
         """
         :param str name: Name of the secret provider. Used to reference secrets in connector config.
-        :param 'GetKafkaKafkaUserConfigKafkaConnectSecretProviderAwsArgs' aws: AWS config for Secret Provider
-        :param 'GetKafkaKafkaUserConfigKafkaConnectSecretProviderVaultArgs' vault: Vault Config for Secret Provider
+        :param 'GetKafkaKafkaUserConfigKafkaConnectSecretProviderAwsArgs' aws: AWS secret provider configuration
+        :param 'GetKafkaKafkaUserConfigKafkaConnectSecretProviderVaultArgs' vault: Vault secret provider configuration
         """
         pulumi.set(__self__, "name", name)
         if aws is not None:
@@ -33298,7 +34104,7 @@ class GetKafkaKafkaUserConfigKafkaConnectSecretProviderResult(dict):
     @pulumi.getter
     def aws(self) -> Optional['outputs.GetKafkaKafkaUserConfigKafkaConnectSecretProviderAwsResult']:
         """
-        AWS config for Secret Provider
+        AWS secret provider configuration
         """
         return pulumi.get(self, "aws")
 
@@ -33306,7 +34112,7 @@ class GetKafkaKafkaUserConfigKafkaConnectSecretProviderResult(dict):
     @pulumi.getter
     def vault(self) -> Optional['outputs.GetKafkaKafkaUserConfigKafkaConnectSecretProviderVaultResult']:
         """
-        Vault Config for Secret Provider
+        Vault secret provider configuration
         """
         return pulumi.get(self, "vault")
 
@@ -33446,10 +34252,10 @@ class GetKafkaKafkaUserConfigKafkaRestConfigResult(dict):
         :param bool consumer_enable_auto_commit: If true the consumer's offset will be periodically committed to Kafka in the background. Default: `true`.
         :param int consumer_request_max_bytes: Maximum number of bytes in unencoded message keys and values by a single request. Default: `67108864`.
         :param int consumer_request_timeout_ms: Enum: `1000`, `15000`, `30000`. The maximum total time to wait for messages for a request if the maximum number of messages has not yet been reached. Default: `1000`.
-        :param str name_strategy: Enum: `topic_name`, `record_name`, `topic_record_name`. Name strategy to use when selecting subject for storing schemas. Default: `topic_name`.
+        :param str name_strategy: Enum: `record_name`, `topic_name`, `topic_record_name`. Name strategy to use when selecting subject for storing schemas. Default: `topic_name`.
         :param bool name_strategy_validation: If true, validate that given schema is registered under expected subject name by the used name strategy when producing messages. Default: `true`.
-        :param str producer_acks: Enum: `all`, `-1`, `0`, `1`. The number of acknowledgments the producer requires the leader to have received before considering a request complete. If set to `all` or `-1`, the leader will wait for the full set of in-sync replicas to acknowledge the record. Default: `1`.
-        :param str producer_compression_type: Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
+        :param str producer_acks: Enum: `-1`, `0`, `1`, `all`. The number of acknowledgments the producer requires the leader to have received before considering a request complete. If set to `all` or `-1`, the leader will wait for the full set of in-sync replicas to acknowledge the record. Default: `1`.
+        :param str producer_compression_type: Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
         :param int producer_linger_ms: Wait for up to the given delay to allow batching records together. Default: `0`.
         :param int producer_max_request_size: The maximum size of a request in bytes. Note that Kafka broker can also cap the record batch size. Default: `1048576`.
         :param int simpleconsumer_pool_size_max: Maximum number of SimpleConsumers that can be instantiated per broker. Default: `25`.
@@ -33503,7 +34309,7 @@ class GetKafkaKafkaUserConfigKafkaRestConfigResult(dict):
     @pulumi.getter(name="nameStrategy")
     def name_strategy(self) -> Optional[str]:
         """
-        Enum: `topic_name`, `record_name`, `topic_record_name`. Name strategy to use when selecting subject for storing schemas. Default: `topic_name`.
+        Enum: `record_name`, `topic_name`, `topic_record_name`. Name strategy to use when selecting subject for storing schemas. Default: `topic_name`.
         """
         return pulumi.get(self, "name_strategy")
 
@@ -33519,7 +34325,7 @@ class GetKafkaKafkaUserConfigKafkaRestConfigResult(dict):
     @pulumi.getter(name="producerAcks")
     def producer_acks(self) -> Optional[str]:
         """
-        Enum: `all`, `-1`, `0`, `1`. The number of acknowledgments the producer requires the leader to have received before considering a request complete. If set to `all` or `-1`, the leader will wait for the full set of in-sync replicas to acknowledge the record. Default: `1`.
+        Enum: `-1`, `0`, `1`, `all`. The number of acknowledgments the producer requires the leader to have received before considering a request complete. If set to `all` or `-1`, the leader will wait for the full set of in-sync replicas to acknowledge the record. Default: `1`.
         """
         return pulumi.get(self, "producer_acks")
 
@@ -33527,7 +34333,7 @@ class GetKafkaKafkaUserConfigKafkaRestConfigResult(dict):
     @pulumi.getter(name="producerCompressionType")
     def producer_compression_type(self) -> Optional[str]:
         """
-        Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
+        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
         """
         return pulumi.get(self, "producer_compression_type")
 
@@ -34514,8 +35320,8 @@ class GetKafkaTopicConfigResult(dict):
                  segment_ms: Optional[str] = None,
                  unclean_leader_election_enable: Optional[bool] = None):
         """
-        :param str cleanup_policy: cleanup.policy value
-        :param str compression_type: compression.type value
+        :param str cleanup_policy: cleanup.policy value. The possible values are `delete`, `compact` and `compact,delete`.
+        :param str compression_type: compression.type value. The possible values are `snappy`, `gzip`, `lz4`, `producer`, `uncompressed` and `zstd`.
         :param str delete_retention_ms: delete.retention.ms value
         :param str file_delete_delay_ms: file.delete.delay.ms value
         :param str flush_messages: flush.messages value
@@ -34526,9 +35332,9 @@ class GetKafkaTopicConfigResult(dict):
         :param str max_compaction_lag_ms: max.compaction.lag.ms value
         :param str max_message_bytes: max.message.bytes value
         :param bool message_downconversion_enable: message.downconversion.enable value
-        :param str message_format_version: message.format.version value
+        :param str message_format_version: message.format.version value. The possible values are `0.8.0`, `0.8.1`, `0.8.2`, `0.9.0`, `0.10.0`, `0.10.0-IV0`, `0.10.0-IV1`, `0.10.1`, `0.10.1-IV0`, `0.10.1-IV1`, `0.10.1-IV2`, `0.10.2`, `0.10.2-IV0`, `0.11.0`, `0.11.0-IV0`, `0.11.0-IV1`, `0.11.0-IV2`, `1.0`, `1.0-IV0`, `1.1`, `1.1-IV0`, `2.0`, `2.0-IV0`, `2.0-IV1`, `2.1`, `2.1-IV0`, `2.1-IV1`, `2.1-IV2`, `2.2`, `2.2-IV0`, `2.2-IV1`, `2.3`, `2.3-IV0`, `2.3-IV1`, `2.4`, `2.4-IV0`, `2.4-IV1`, `2.5`, `2.5-IV0`, `2.6`, `2.6-IV0`, `2.7`, `2.7-IV0`, `2.7-IV1`, `2.7-IV2`, `2.8`, `2.8-IV0`, `2.8-IV1`, `3.0`, `3.0-IV0`, `3.0-IV1`, `3.1`, `3.1-IV0`, `3.2`, `3.2-IV0`, `3.3`, `3.3-IV0`, `3.3-IV1`, `3.3-IV2`, `3.3-IV3`, `3.4`, `3.4-IV0`, `3.5`, `3.5-IV0`, `3.5-IV1`, `3.5-IV2`, `3.6`, `3.6-IV0`, `3.6-IV1`, `3.6-IV2`, `3.7`, `3.7-IV0`, `3.7-IV1`, `3.7-IV2`, `3.7-IV3`, `3.7-IV4`, `3.8`, `3.8-IV0`, `3.9`, `3.9-IV0` and `3.9-IV1`.
         :param str message_timestamp_difference_max_ms: message.timestamp.difference.max.ms value
-        :param str message_timestamp_type: message.timestamp.type value
+        :param str message_timestamp_type: message.timestamp.type value. The possible values are `CreateTime` and `LogAppendTime`.
         :param float min_cleanable_dirty_ratio: min.cleanable.dirty.ratio value
         :param str min_compaction_lag_ms: min.compaction.lag.ms value
         :param str min_insync_replicas: min.insync.replicas value
@@ -34601,7 +35407,7 @@ class GetKafkaTopicConfigResult(dict):
     @pulumi.getter(name="cleanupPolicy")
     def cleanup_policy(self) -> Optional[str]:
         """
-        cleanup.policy value
+        cleanup.policy value. The possible values are `delete`, `compact` and `compact,delete`.
         """
         return pulumi.get(self, "cleanup_policy")
 
@@ -34609,7 +35415,7 @@ class GetKafkaTopicConfigResult(dict):
     @pulumi.getter(name="compressionType")
     def compression_type(self) -> Optional[str]:
         """
-        compression.type value
+        compression.type value. The possible values are `snappy`, `gzip`, `lz4`, `producer`, `uncompressed` and `zstd`.
         """
         return pulumi.get(self, "compression_type")
 
@@ -34697,7 +35503,7 @@ class GetKafkaTopicConfigResult(dict):
     @pulumi.getter(name="messageFormatVersion")
     def message_format_version(self) -> Optional[str]:
         """
-        message.format.version value
+        message.format.version value. The possible values are `0.8.0`, `0.8.1`, `0.8.2`, `0.9.0`, `0.10.0`, `0.10.0-IV0`, `0.10.0-IV1`, `0.10.1`, `0.10.1-IV0`, `0.10.1-IV1`, `0.10.1-IV2`, `0.10.2`, `0.10.2-IV0`, `0.11.0`, `0.11.0-IV0`, `0.11.0-IV1`, `0.11.0-IV2`, `1.0`, `1.0-IV0`, `1.1`, `1.1-IV0`, `2.0`, `2.0-IV0`, `2.0-IV1`, `2.1`, `2.1-IV0`, `2.1-IV1`, `2.1-IV2`, `2.2`, `2.2-IV0`, `2.2-IV1`, `2.3`, `2.3-IV0`, `2.3-IV1`, `2.4`, `2.4-IV0`, `2.4-IV1`, `2.5`, `2.5-IV0`, `2.6`, `2.6-IV0`, `2.7`, `2.7-IV0`, `2.7-IV1`, `2.7-IV2`, `2.8`, `2.8-IV0`, `2.8-IV1`, `3.0`, `3.0-IV0`, `3.0-IV1`, `3.1`, `3.1-IV0`, `3.2`, `3.2-IV0`, `3.3`, `3.3-IV0`, `3.3-IV1`, `3.3-IV2`, `3.3-IV3`, `3.4`, `3.4-IV0`, `3.5`, `3.5-IV0`, `3.5-IV1`, `3.5-IV2`, `3.6`, `3.6-IV0`, `3.6-IV1`, `3.6-IV2`, `3.7`, `3.7-IV0`, `3.7-IV1`, `3.7-IV2`, `3.7-IV3`, `3.7-IV4`, `3.8`, `3.8-IV0`, `3.9`, `3.9-IV0` and `3.9-IV1`.
         """
         return pulumi.get(self, "message_format_version")
 
@@ -34713,7 +35519,7 @@ class GetKafkaTopicConfigResult(dict):
     @pulumi.getter(name="messageTimestampType")
     def message_timestamp_type(self) -> Optional[str]:
         """
-        message.timestamp.type value
+        message.timestamp.type value. The possible values are `CreateTime` and `LogAppendTime`.
         """
         return pulumi.get(self, "message_timestamp_type")
 
@@ -36860,9 +37666,9 @@ class GetMySqlMysqlUserConfigMysqlResult(dict):
         :param int innodb_thread_concurrency: Defines the maximum number of threads permitted inside of InnoDB. Default is 0 (infinite concurrency - no limit). Example: `10`.
         :param int innodb_write_io_threads: The number of I/O threads for write operations in InnoDB. Default is 4. Changing this parameter will lead to a restart of the MySQL service. Example: `10`.
         :param int interactive_timeout: The number of seconds the server waits for activity on an interactive connection before closing it. Example: `3600`.
-        :param str internal_tmp_mem_storage_engine: Enum: `TempTable`, `MEMORY`. The storage engine for in-memory internal temporary tables.
-        :param str log_output: Enum: `INSIGHTS`, `NONE`, `TABLE`, `INSIGHTS,TABLE`. The slow log output destination when slow_query_log is ON. To enable MySQL AI Insights, choose INSIGHTS. To use MySQL AI Insights and the mysql.slow_log table at the same time, choose INSIGHTS,TABLE. To only use the mysql.slow_log table, choose TABLE. To silence slow logs, choose NONE.
-        :param float long_query_time: The slow_query_logs work as SQL statements that take more than long_query_time seconds to execute. Example: `10`.
+        :param str internal_tmp_mem_storage_engine: Enum: `MEMORY`, `TempTable`. The storage engine for in-memory internal temporary tables.
+        :param str log_output: Enum: `INSIGHTS`, `INSIGHTS,TABLE`, `NONE`, `TABLE`. The slow log output destination when slow_query_log is ON. To enable MySQL AI Insights, choose INSIGHTS. To use MySQL AI Insights and the mysql.slow_log table at the same time, choose INSIGHTS,TABLE. To only use the mysql.slow_log table, choose TABLE. To silence slow logs, choose NONE.
+        :param float long_query_time: The slow_query_logs work as SQL statements that take more than long_query_time seconds to execute. Example: `10.0`.
         :param int max_allowed_packet: Size of the largest message in bytes that can be received by the server. Default is 67108864 (64M). Example: `67108864`.
         :param int max_heap_table_size: Limits the size of internal in-memory tables. Also set tmp_table_size. Default is 16777216 (16M). Example: `16777216`.
         :param int net_buffer_length: Start sizes of connection buffer and result buffer. Default is 16384 (16K). Changing this parameter will lead to a restart of the MySQL service. Example: `16384`.
@@ -37078,7 +37884,7 @@ class GetMySqlMysqlUserConfigMysqlResult(dict):
     @pulumi.getter(name="internalTmpMemStorageEngine")
     def internal_tmp_mem_storage_engine(self) -> Optional[str]:
         """
-        Enum: `TempTable`, `MEMORY`. The storage engine for in-memory internal temporary tables.
+        Enum: `MEMORY`, `TempTable`. The storage engine for in-memory internal temporary tables.
         """
         return pulumi.get(self, "internal_tmp_mem_storage_engine")
 
@@ -37086,7 +37892,7 @@ class GetMySqlMysqlUserConfigMysqlResult(dict):
     @pulumi.getter(name="logOutput")
     def log_output(self) -> Optional[str]:
         """
-        Enum: `INSIGHTS`, `NONE`, `TABLE`, `INSIGHTS,TABLE`. The slow log output destination when slow_query_log is ON. To enable MySQL AI Insights, choose INSIGHTS. To use MySQL AI Insights and the mysql.slow_log table at the same time, choose INSIGHTS,TABLE. To only use the mysql.slow_log table, choose TABLE. To silence slow logs, choose NONE.
+        Enum: `INSIGHTS`, `INSIGHTS,TABLE`, `NONE`, `TABLE`. The slow log output destination when slow_query_log is ON. To enable MySQL AI Insights, choose INSIGHTS. To use MySQL AI Insights and the mysql.slow_log table at the same time, choose INSIGHTS,TABLE. To only use the mysql.slow_log table, choose TABLE. To silence slow logs, choose NONE.
         """
         return pulumi.get(self, "log_output")
 
@@ -37094,7 +37900,7 @@ class GetMySqlMysqlUserConfigMysqlResult(dict):
     @pulumi.getter(name="longQueryTime")
     def long_query_time(self) -> Optional[float]:
         """
-        The slow_query_logs work as SQL statements that take more than long_query_time seconds to execute. Example: `10`.
+        The slow_query_logs work as SQL statements that take more than long_query_time seconds to execute. Example: `10.0`.
         """
         return pulumi.get(self, "long_query_time")
 
@@ -37584,7 +38390,7 @@ class GetOpenSearchOpensearchUserConfigResult(dict):
         :param str additional_backup_regions: Additional Cloud Regions for Backup Replication.
         :param 'GetOpenSearchOpensearchUserConfigAzureMigrationArgs' azure_migration: Azure migration settings
         :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 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 not be activated unless specifically allowed for the project.
         :param 'GetOpenSearchOpensearchUserConfigGcsMigrationArgs' gcs_migration: Google Cloud Storage migration settings
         :param Sequence['GetOpenSearchOpensearchUserConfigIndexPatternArgs'] index_patterns: Index patterns
         :param 'GetOpenSearchOpensearchUserConfigIndexRollupArgs' index_rollup: Index rollup settings
@@ -37692,7 +38498,7 @@ class GetOpenSearchOpensearchUserConfigResult(dict):
     @pulumi.getter(name="disableReplicationFactorAdjustment")
     def disable_replication_factor_adjustment(self) -> Optional[bool]:
         """
-        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.
+        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 not be activated unless specifically allowed for the project.
         """
         return pulumi.get(self, "disable_replication_factor_adjustment")
 
@@ -37888,28 +38694,33 @@ class GetOpenSearchOpensearchUserConfigAzureMigrationResult(dict):
                  account: str,
                  base_path: str,
                  container: str,
+                 indices: str,
                  snapshot_name: str,
                  chunk_size: Optional[str] = None,
                  compress: Optional[bool] = None,
                  endpoint_suffix: Optional[str] = None,
-                 indices: Optional[str] = None,
+                 include_aliases: Optional[bool] = None,
                  key: Optional[str] = None,
+                 restore_global_state: Optional[bool] = None,
                  sas_token: Optional[str] = None):
         """
-        :param str account: Azure account name.
+        :param str account: 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 indices: A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
         :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 indices: A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. By default, a restore operation includes all data streams and indices in the snapshot. If this argument is provided, the restore operation only includes the data streams and indices that you specify. Example: `metrics*,logs*,data-20240823`.
+        :param bool include_aliases: Whether to restore aliases alongside their associated indexes. Default is true.
         :param str key: Azure account secret key. One of key or sas_token should be specified.
+        :param bool restore_global_state: If true, restore the cluster state. Defaults to false.
         :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__, "indices", indices)
         pulumi.set(__self__, "snapshot_name", snapshot_name)
         if chunk_size is not None:
             pulumi.set(__self__, "chunk_size", chunk_size)
@@ -37917,10 +38728,12 @@ class GetOpenSearchOpensearchUserConfigAzureMigrationResult(dict):
             pulumi.set(__self__, "compress", compress)
         if endpoint_suffix is not None:
             pulumi.set(__self__, "endpoint_suffix", endpoint_suffix)
-        if indices is not None:
-            pulumi.set(__self__, "indices", indices)
+        if include_aliases is not None:
+            pulumi.set(__self__, "include_aliases", include_aliases)
         if key is not None:
             pulumi.set(__self__, "key", key)
+        if restore_global_state is not None:
+            pulumi.set(__self__, "restore_global_state", restore_global_state)
         if sas_token is not None:
             pulumi.set(__self__, "sas_token", sas_token)
 
@@ -37928,7 +38741,7 @@ class GetOpenSearchOpensearchUserConfigAzureMigrationResult(dict):
     @pulumi.getter
     def account(self) -> str:
         """
-        Azure account name.
+        Account name.
         """
         return pulumi.get(self, "account")
 
@@ -37948,6 +38761,14 @@ class GetOpenSearchOpensearchUserConfigAzureMigrationResult(dict):
         """
         return pulumi.get(self, "container")
 
+    @property
+    @pulumi.getter
+    def indices(self) -> str:
+        """
+        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
+        """
+        return pulumi.get(self, "indices")
+
     @property
     @pulumi.getter(name="snapshotName")
     def snapshot_name(self) -> str:
@@ -37981,12 +38802,12 @@ class GetOpenSearchOpensearchUserConfigAzureMigrationResult(dict):
         return pulumi.get(self, "endpoint_suffix")
 
     @property
-    @pulumi.getter
-    def indices(self) -> Optional[str]:
+    @pulumi.getter(name="includeAliases")
+    def include_aliases(self) -> Optional[bool]:
         """
-        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. By default, a restore operation includes all data streams and indices in the snapshot. If this argument is provided, the restore operation only includes the data streams and indices that you specify. Example: `metrics*,logs*,data-20240823`.
+        Whether to restore aliases alongside their associated indexes. Default is true.
         """
-        return pulumi.get(self, "indices")
+        return pulumi.get(self, "include_aliases")
 
     @property
     @pulumi.getter
@@ -37996,6 +38817,14 @@ class GetOpenSearchOpensearchUserConfigAzureMigrationResult(dict):
         """
         return pulumi.get(self, "key")
 
+    @property
+    @pulumi.getter(name="restoreGlobalState")
+    def restore_global_state(self) -> Optional[bool]:
+        """
+        If true, restore the cluster state. Defaults to false.
+        """
+        return pulumi.get(self, "restore_global_state")
+
     @property
     @pulumi.getter(name="sasToken")
     def sas_token(self) -> Optional[str]:
@@ -38011,29 +38840,36 @@ class GetOpenSearchOpensearchUserConfigGcsMigrationResult(dict):
                  base_path: str,
                  bucket: str,
                  credentials: str,
+                 indices: str,
                  snapshot_name: str,
                  chunk_size: Optional[str] = None,
                  compress: Optional[bool] = None,
-                 indices: Optional[str] = None):
+                 include_aliases: Optional[bool] = None,
+                 restore_global_state: 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 indices: A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
         :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 indices: A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. By default, a restore operation includes all data streams and indices in the snapshot. If this argument is provided, the restore operation only includes the data streams and indices that you specify. Example: `metrics*,logs*,data-20240823`.
+        :param bool include_aliases: Whether to restore aliases alongside their associated indexes. Default is true.
+        :param bool restore_global_state: If true, restore the cluster state. Defaults to false.
         """
         pulumi.set(__self__, "base_path", base_path)
         pulumi.set(__self__, "bucket", bucket)
         pulumi.set(__self__, "credentials", credentials)
+        pulumi.set(__self__, "indices", indices)
         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 indices is not None:
-            pulumi.set(__self__, "indices", indices)
+        if include_aliases is not None:
+            pulumi.set(__self__, "include_aliases", include_aliases)
+        if restore_global_state is not None:
+            pulumi.set(__self__, "restore_global_state", restore_global_state)
 
     @property
     @pulumi.getter(name="basePath")
@@ -38059,6 +38895,14 @@ class GetOpenSearchOpensearchUserConfigGcsMigrationResult(dict):
         """
         return pulumi.get(self, "credentials")
 
+    @property
+    @pulumi.getter
+    def indices(self) -> str:
+        """
+        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
+        """
+        return pulumi.get(self, "indices")
+
     @property
     @pulumi.getter(name="snapshotName")
     def snapshot_name(self) -> str:
@@ -38084,12 +38928,20 @@ class GetOpenSearchOpensearchUserConfigGcsMigrationResult(dict):
         return pulumi.get(self, "compress")
 
     @property
-    @pulumi.getter
-    def indices(self) -> Optional[str]:
+    @pulumi.getter(name="includeAliases")
+    def include_aliases(self) -> Optional[bool]:
         """
-        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. By default, a restore operation includes all data streams and indices in the snapshot. If this argument is provided, the restore operation only includes the data streams and indices that you specify. Example: `metrics*,logs*,data-20240823`.
+        Whether to restore aliases alongside their associated indexes. Default is true.
         """
-        return pulumi.get(self, "indices")
+        return pulumi.get(self, "include_aliases")
+
+    @property
+    @pulumi.getter(name="restoreGlobalState")
+    def restore_global_state(self) -> Optional[bool]:
+        """
+        If true, restore the cluster state. Defaults to false.
+        """
+        return pulumi.get(self, "restore_global_state")
 
 
 @pulumi.output_type
@@ -38456,6 +39308,7 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
                  reindex_remote_whitelists: Optional[Sequence[str]] = None,
                  script_max_compilations_rate: Optional[str] = None,
                  search_backpressure: Optional['outputs.GetOpenSearchOpensearchUserConfigOpensearchSearchBackpressureResult'] = None,
+                 search_insights_top_queries: Optional['outputs.GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesResult'] = None,
                  search_max_buckets: Optional[int] = None,
                  shard_indexing_pressure: Optional['outputs.GetOpenSearchOpensearchUserConfigOpensearchShardIndexingPressureResult'] = None,
                  thread_pool_analyze_queue_size: Optional[int] = None,
@@ -38583,6 +39436,8 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
             pulumi.set(__self__, "script_max_compilations_rate", script_max_compilations_rate)
         if search_backpressure is not None:
             pulumi.set(__self__, "search_backpressure", search_backpressure)
+        if search_insights_top_queries is not None:
+            pulumi.set(__self__, "search_insights_top_queries", search_insights_top_queries)
         if search_max_buckets is not None:
             pulumi.set(__self__, "search_max_buckets", search_max_buckets)
         if shard_indexing_pressure is not None:
@@ -38874,6 +39729,11 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
         """
         return pulumi.get(self, "search_backpressure")
 
+    @property
+    @pulumi.getter(name="searchInsightsTopQueries")
+    def search_insights_top_queries(self) -> Optional['outputs.GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesResult']:
+        return pulumi.get(self, "search_insights_top_queries")
+
     @property
     @pulumi.getter(name="searchMaxBuckets")
     def search_max_buckets(self) -> Optional[int]:
@@ -39227,7 +40087,7 @@ class GetOpenSearchOpensearchUserConfigOpensearchSearchBackpressureResult(dict):
                  search_shard_task: Optional['outputs.GetOpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchShardTaskResult'] = None,
                  search_task: Optional['outputs.GetOpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTaskResult'] = None):
         """
-        :param str mode: Enum: `monitor_only`, `enforced`, `disabled`. The search backpressure mode. Valid values are monitor_only, enforced, or disabled. Default is monitor_only.
+        :param str mode: Enum: `disabled`, `enforced`, `monitor_only`. The search backpressure mode. Valid values are monitor_only, enforced, or disabled. Default is monitor_only.
         :param 'GetOpenSearchOpensearchUserConfigOpensearchSearchBackpressureNodeDuressArgs' node_duress: Node duress settings
         :param 'GetOpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchShardTaskArgs' search_shard_task: Search shard settings
         :param 'GetOpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTaskArgs' search_task: Search task settings
@@ -39245,7 +40105,7 @@ class GetOpenSearchOpensearchUserConfigOpensearchSearchBackpressureResult(dict):
     @pulumi.getter
     def mode(self) -> Optional[str]:
         """
-        Enum: `monitor_only`, `enforced`, `disabled`. The search backpressure mode. Valid values are monitor_only, enforced, or disabled. Default is monitor_only.
+        Enum: `disabled`, `enforced`, `monitor_only`. The search backpressure mode. Valid values are monitor_only, enforced, or disabled. Default is monitor_only.
         """
         return pulumi.get(self, "mode")
 
@@ -39547,6 +40407,178 @@ class GetOpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTaskRes
         return pulumi.get(self, "total_heap_percent_threshold")
 
 
+@pulumi.output_type
+class GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesResult(dict):
+    def __init__(__self__, *,
+                 cpu: Optional['outputs.GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpuResult'] = None,
+                 latency: Optional['outputs.GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatencyResult'] = None,
+                 memory: Optional['outputs.GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemoryResult'] = None):
+        """
+        :param 'GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpuArgs' cpu: Top N queries monitoring by CPU
+        :param 'GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatencyArgs' latency: Top N queries monitoring by latency
+        :param 'GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemoryArgs' memory: Top N queries monitoring by memory
+        """
+        if cpu is not None:
+            pulumi.set(__self__, "cpu", cpu)
+        if latency is not None:
+            pulumi.set(__self__, "latency", latency)
+        if memory is not None:
+            pulumi.set(__self__, "memory", memory)
+
+    @property
+    @pulumi.getter
+    def cpu(self) -> Optional['outputs.GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpuResult']:
+        """
+        Top N queries monitoring by CPU
+        """
+        return pulumi.get(self, "cpu")
+
+    @property
+    @pulumi.getter
+    def latency(self) -> Optional['outputs.GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatencyResult']:
+        """
+        Top N queries monitoring by latency
+        """
+        return pulumi.get(self, "latency")
+
+    @property
+    @pulumi.getter
+    def memory(self) -> Optional['outputs.GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemoryResult']:
+        """
+        Top N queries monitoring by memory
+        """
+        return pulumi.get(self, "memory")
+
+
+@pulumi.output_type
+class GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpuResult(dict):
+    def __init__(__self__, *,
+                 enabled: Optional[bool] = None,
+                 top_n_size: Optional[int] = None,
+                 window_size: Optional[str] = None):
+        """
+        :param bool enabled: Enable or disable top N query monitoring by the metric. Default: `false`.
+        :param int top_n_size: Specify the value of N for the top N queries by the metric.
+        :param str window_size: The window size of the top N queries by the metric.
+        """
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+        if top_n_size is not None:
+            pulumi.set(__self__, "top_n_size", top_n_size)
+        if window_size is not None:
+            pulumi.set(__self__, "window_size", window_size)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[bool]:
+        """
+        Enable or disable top N query monitoring by the metric. Default: `false`.
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter(name="topNSize")
+    def top_n_size(self) -> Optional[int]:
+        """
+        Specify the value of N for the top N queries by the metric.
+        """
+        return pulumi.get(self, "top_n_size")
+
+    @property
+    @pulumi.getter(name="windowSize")
+    def window_size(self) -> Optional[str]:
+        """
+        The window size of the top N queries by the metric.
+        """
+        return pulumi.get(self, "window_size")
+
+
+@pulumi.output_type
+class GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatencyResult(dict):
+    def __init__(__self__, *,
+                 enabled: Optional[bool] = None,
+                 top_n_size: Optional[int] = None,
+                 window_size: Optional[str] = None):
+        """
+        :param bool enabled: Enable or disable top N query monitoring by the metric. Default: `false`.
+        :param int top_n_size: Specify the value of N for the top N queries by the metric.
+        :param str window_size: The window size of the top N queries by the metric.
+        """
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+        if top_n_size is not None:
+            pulumi.set(__self__, "top_n_size", top_n_size)
+        if window_size is not None:
+            pulumi.set(__self__, "window_size", window_size)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[bool]:
+        """
+        Enable or disable top N query monitoring by the metric. Default: `false`.
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter(name="topNSize")
+    def top_n_size(self) -> Optional[int]:
+        """
+        Specify the value of N for the top N queries by the metric.
+        """
+        return pulumi.get(self, "top_n_size")
+
+    @property
+    @pulumi.getter(name="windowSize")
+    def window_size(self) -> Optional[str]:
+        """
+        The window size of the top N queries by the metric.
+        """
+        return pulumi.get(self, "window_size")
+
+
+@pulumi.output_type
+class GetOpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemoryResult(dict):
+    def __init__(__self__, *,
+                 enabled: Optional[bool] = None,
+                 top_n_size: Optional[int] = None,
+                 window_size: Optional[str] = None):
+        """
+        :param bool enabled: Enable or disable top N query monitoring by the metric. Default: `false`.
+        :param int top_n_size: Specify the value of N for the top N queries by the metric.
+        :param str window_size: The window size of the top N queries by the metric.
+        """
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+        if top_n_size is not None:
+            pulumi.set(__self__, "top_n_size", top_n_size)
+        if window_size is not None:
+            pulumi.set(__self__, "window_size", window_size)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[bool]:
+        """
+        Enable or disable top N query monitoring by the metric. Default: `false`.
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter(name="topNSize")
+    def top_n_size(self) -> Optional[int]:
+        """
+        Specify the value of N for the top N queries by the metric.
+        """
+        return pulumi.get(self, "top_n_size")
+
+    @property
+    @pulumi.getter(name="windowSize")
+    def window_size(self) -> Optional[str]:
+        """
+        The window size of the top N queries by the metric.
+        """
+        return pulumi.get(self, "window_size")
+
+
 @pulumi.output_type
 class GetOpenSearchOpensearchUserConfigOpensearchShardIndexingPressureResult(dict):
     def __init__(__self__, *,
@@ -39875,30 +40907,35 @@ class GetOpenSearchOpensearchUserConfigS3MigrationResult(dict):
                  access_key: str,
                  base_path: str,
                  bucket: str,
+                 indices: str,
                  region: str,
                  secret_key: str,
                  snapshot_name: str,
                  chunk_size: Optional[str] = None,
                  compress: Optional[bool] = None,
                  endpoint: Optional[str] = None,
-                 indices: Optional[str] = None,
+                 include_aliases: Optional[bool] = None,
+                 restore_global_state: Optional[bool] = 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 indices: A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
         :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 str indices: A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. By default, a restore operation includes all data streams and indices in the snapshot. If this argument is provided, the restore operation only includes the data streams and indices that you specify. Example: `metrics*,logs*,data-20240823`.
+        :param bool include_aliases: Whether to restore aliases alongside their associated indexes. Default is true.
+        :param bool restore_global_state: If true, restore the cluster state. Defaults to false.
         :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__, "indices", indices)
         pulumi.set(__self__, "region", region)
         pulumi.set(__self__, "secret_key", secret_key)
         pulumi.set(__self__, "snapshot_name", snapshot_name)
@@ -39908,8 +40945,10 @@ class GetOpenSearchOpensearchUserConfigS3MigrationResult(dict):
             pulumi.set(__self__, "compress", compress)
         if endpoint is not None:
             pulumi.set(__self__, "endpoint", endpoint)
-        if indices is not None:
-            pulumi.set(__self__, "indices", indices)
+        if include_aliases is not None:
+            pulumi.set(__self__, "include_aliases", include_aliases)
+        if restore_global_state is not None:
+            pulumi.set(__self__, "restore_global_state", restore_global_state)
         if server_side_encryption is not None:
             pulumi.set(__self__, "server_side_encryption", server_side_encryption)
 
@@ -39937,6 +40976,14 @@ class GetOpenSearchOpensearchUserConfigS3MigrationResult(dict):
         """
         return pulumi.get(self, "bucket")
 
+    @property
+    @pulumi.getter
+    def indices(self) -> str:
+        """
+        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
+        """
+        return pulumi.get(self, "indices")
+
     @property
     @pulumi.getter
     def region(self) -> str:
@@ -39986,12 +41033,20 @@ class GetOpenSearchOpensearchUserConfigS3MigrationResult(dict):
         return pulumi.get(self, "endpoint")
 
     @property
-    @pulumi.getter
-    def indices(self) -> Optional[str]:
+    @pulumi.getter(name="includeAliases")
+    def include_aliases(self) -> Optional[bool]:
         """
-        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. By default, a restore operation includes all data streams and indices in the snapshot. If this argument is provided, the restore operation only includes the data streams and indices that you specify. Example: `metrics*,logs*,data-20240823`.
+        Whether to restore aliases alongside their associated indexes. Default is true.
         """
-        return pulumi.get(self, "indices")
+        return pulumi.get(self, "include_aliases")
+
+    @property
+    @pulumi.getter(name="restoreGlobalState")
+    def restore_global_state(self) -> Optional[bool]:
+        """
+        If true, restore the cluster state. Defaults to false.
+        """
+        return pulumi.get(self, "restore_global_state")
 
     @property
     @pulumi.getter(name="serverSideEncryption")
@@ -40751,7 +41806,7 @@ class GetPgPgUserConfigResult(dict):
         :param str service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
         :param float shared_buffers_percentage: Percentage of total RAM that the database server uses for shared memory buffers. Valid range is 20-60 (float), which corresponds to 20% - 60%. This setting adjusts the shared_buffers configuration value. Example: `41.5`.
         :param bool static_ips: Use static public IP addresses.
-        :param str synchronous_replication: Enum: `quorum`, `off`. Synchronous replication type. Note that the service plan also needs to support synchronous replication.
+        :param str synchronous_replication: Enum: `off`, `quorum`. Synchronous replication type. Note that the service plan also needs to support synchronous replication.
         :param 'GetPgPgUserConfigTimescaledbArgs' timescaledb: System-wide settings for the timescaledb extension
         :param str variant: Enum: `aiven`, `timescale`. Variant of the PostgreSQL service, may affect the features that are exposed by default.
         :param int work_mem: Sets the maximum amount of memory to be used by a query operation (such as a sort or hash table) before writing to temporary disk files, in MB. Default is 1MB + 0.075% of total RAM (up to 32MB). Example: `4`.
@@ -41053,7 +42108,7 @@ class GetPgPgUserConfigResult(dict):
     @pulumi.getter(name="synchronousReplication")
     def synchronous_replication(self) -> Optional[str]:
         """
-        Enum: `quorum`, `off`. Synchronous replication type. Note that the service plan also needs to support synchronous replication.
+        Enum: `off`, `quorum`. Synchronous replication type. Note that the service plan also needs to support synchronous replication.
         """
         return pulumi.get(self, "synchronous_replication")
 
@@ -41296,8 +42351,8 @@ class GetPgPgUserConfigPgResult(dict):
         :param int idle_in_transaction_session_timeout: Time out sessions with open transactions after this number of milliseconds.
         :param bool jit: Controls system-wide use of Just-in-Time Compilation (JIT).
         :param int log_autovacuum_min_duration: Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one (the default) disables logging autovacuum actions.
-        :param str log_error_verbosity: Enum: `TERSE`, `DEFAULT`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
-        :param str log_line_prefix: Enum: `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
+        :param str log_error_verbosity: Enum: `DEFAULT`, `TERSE`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
+        :param str log_line_prefix: Enum: `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
         :param int log_min_duration_statement: Log statements that take more than this number of milliseconds to run, -1 disables.
         :param int log_temp_files: Log statements for each temporary file created larger than this number of kilobytes, -1 disables.
         :param int max_files_per_process: PostgreSQL maximum number of files that can be open per process.
@@ -41318,12 +42373,12 @@ class GetPgPgUserConfigPgResult(dict):
         :param str pg_partman_bgw_dot_role: Controls which role to use for pg_partman's scheduled background tasks. Example: `myrolename`.
         :param bool pg_stat_monitor_dot_pgsm_enable_query_plan: Enables or disables query plan monitoring.
         :param int pg_stat_monitor_dot_pgsm_max_buckets: Sets the maximum number of buckets. Example: `10`.
-        :param str pg_stat_statements_dot_track: Enum: `all`, `top`, `none`. Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default value is top.
+        :param str pg_stat_statements_dot_track: Enum: `all`, `none`, `top`. Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default value is top.
         :param int temp_file_limit: PostgreSQL temporary file limit in KiB, -1 for unlimited. Example: `5000000`.
         :param str timezone: PostgreSQL service timezone. Example: `Europe/Helsinki`.
         :param int track_activity_query_size: Specifies the number of bytes reserved to track the currently executing command for each active session. Example: `1024`.
         :param str track_commit_timestamp: Enum: `off`, `on`. Record commit time of transactions.
-        :param str track_functions: Enum: `all`, `pl`, `none`. Enables tracking of function call counts and time used.
+        :param str track_functions: Enum: `all`, `none`, `pl`. Enables tracking of function call counts and time used.
         :param str track_io_timing: Enum: `off`, `on`. Enables timing of database I/O calls. This parameter is off by default, because it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms.
         :param int wal_sender_timeout: Terminate replication connections that are inactive for longer than this amount of time, in milliseconds. Setting this value to zero disables the timeout. Example: `60000`.
         :param int wal_writer_delay: WAL flush interval in milliseconds. Note that setting this value to lower than the default 200ms may negatively impact performance. Example: `50`.
@@ -41575,7 +42630,7 @@ class GetPgPgUserConfigPgResult(dict):
     @pulumi.getter(name="logErrorVerbosity")
     def log_error_verbosity(self) -> Optional[str]:
         """
-        Enum: `TERSE`, `DEFAULT`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
+        Enum: `DEFAULT`, `TERSE`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
         """
         return pulumi.get(self, "log_error_verbosity")
 
@@ -41583,7 +42638,7 @@ class GetPgPgUserConfigPgResult(dict):
     @pulumi.getter(name="logLinePrefix")
     def log_line_prefix(self) -> Optional[str]:
         """
-        Enum: `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
+        Enum: `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
         """
         return pulumi.get(self, "log_line_prefix")
 
@@ -41751,7 +42806,7 @@ class GetPgPgUserConfigPgResult(dict):
     @pulumi.getter(name="pgStatStatementsDotTrack")
     def pg_stat_statements_dot_track(self) -> Optional[str]:
         """
-        Enum: `all`, `top`, `none`. Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default value is top.
+        Enum: `all`, `none`, `top`. Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default value is top.
         """
         return pulumi.get(self, "pg_stat_statements_dot_track")
 
@@ -41791,7 +42846,7 @@ class GetPgPgUserConfigPgResult(dict):
     @pulumi.getter(name="trackFunctions")
     def track_functions(self) -> Optional[str]:
         """
-        Enum: `all`, `pl`, `none`. Enables tracking of function call counts and time used.
+        Enum: `all`, `none`, `pl`. Enables tracking of function call counts and time used.
         """
         return pulumi.get(self, "track_functions")
 
@@ -42097,7 +43152,7 @@ class GetPgPgUserConfigPgbouncerResult(dict):
         """
         :param int autodb_idle_timeout: If the automatically created database pools have been unused this many seconds, they are freed. If 0 then timeout is disabled. (seconds). Default: `3600`.
         :param int autodb_max_db_connections: Do not allow more than this many server connections per database (regardless of user). Setting it to 0 means unlimited. Example: `0`.
-        :param str autodb_pool_mode: Enum: `session`, `transaction`, `statement`. PGBouncer pool mode. Default: `transaction`.
+        :param str autodb_pool_mode: Enum: `session`, `statement`, `transaction`. 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`.
@@ -42147,7 +43202,7 @@ class GetPgPgUserConfigPgbouncerResult(dict):
     @pulumi.getter(name="autodbPoolMode")
     def autodb_pool_mode(self) -> Optional[str]:
         """
-        Enum: `session`, `transaction`, `statement`. PGBouncer pool mode. Default: `transaction`.
+        Enum: `session`, `statement`, `transaction`. PGBouncer pool mode. Default: `transaction`.
         """
         return pulumi.get(self, "autodb_pool_mode")
 
@@ -42673,7 +43728,7 @@ class GetRedisRedisUserConfigResult(dict):
         :param int redis_io_threads: Set Redis IO thread count. Changing this will cause a restart of the Redis service. Example: `1`.
         :param int redis_lfu_decay_time: LFU maxmemory-policy counter decay time in minutes. Default: `1`.
         :param int redis_lfu_log_factor: Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies. Default: `10`.
-        :param str redis_maxmemory_policy: Enum: `noeviction`, `allkeys-lru`, `volatile-lru`, `allkeys-random`, `volatile-random`, `volatile-ttl`, `volatile-lfu`, `allkeys-lfu`. Redis maxmemory-policy. Default: `noeviction`.
+        :param str redis_maxmemory_policy: Enum: `allkeys-lfu`, `allkeys-lru`, `allkeys-random`, `noeviction`, `volatile-lfu`, `volatile-lru`, `volatile-random`, `volatile-ttl`. Redis maxmemory-policy. Default: `noeviction`.
         :param str redis_notify_keyspace_events: Set notify-keyspace-events option.
         :param int redis_number_of_databases: Set number of Redis databases. Changing this will cause a restart of the Redis service. Example: `16`.
         :param str redis_persistence: Enum: `off`, `rdb`. When persistence is `rdb`, Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to the backup schedule for backup purposes. When persistence is `off`, no RDB dumps or backups are done, so data can be lost at any moment if the service is restarted for any reason, or if the service is powered off. Also, the service can't be forked.
@@ -42873,7 +43928,7 @@ class GetRedisRedisUserConfigResult(dict):
     @pulumi.getter(name="redisMaxmemoryPolicy")
     def redis_maxmemory_policy(self) -> Optional[str]:
         """
-        Enum: `noeviction`, `allkeys-lru`, `volatile-lru`, `allkeys-random`, `volatile-random`, `volatile-ttl`, `volatile-lfu`, `allkeys-lfu`. Redis maxmemory-policy. Default: `noeviction`.
+        Enum: `allkeys-lfu`, `allkeys-lru`, `allkeys-random`, `noeviction`, `volatile-lfu`, `volatile-lru`, `volatile-random`, `volatile-ttl`. Redis maxmemory-policy. Default: `noeviction`.
         """
         return pulumi.get(self, "redis_maxmemory_policy")
 
@@ -43309,11 +44364,11 @@ class GetServiceIntegrationClickhouseKafkaUserConfigTableResult(dict):
                  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`.
+        :param str data_format: Enum: `Avro`, `AvroConfluent`, `CSV`, `JSONAsString`, `JSONCompactEachRow`, `JSONCompactStringsEachRow`, `JSONEachRow`, `JSONStringsEachRow`, `MsgPack`, `Parquet`, `RawBLOB`, `TSKV`, `TSV`, `TabSeparated`. Message data format. Default: `JSONEachRow`.
         :param str group_name: Kafka consumers group. Default: `clickhouse`.
         :param str name: Name of the table. Example: `events`.
         :param Sequence['GetServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs'] topics: Kafka topics
-        :param str auto_offset_reset: Enum: `smallest`, `earliest`, `beginning`, `largest`, `latest`, `end`. Action to take when there is no initial offset in offset store or the desired offset is out of range. Default: `earliest`.
+        :param str auto_offset_reset: Enum: `beginning`, `earliest`, `end`, `largest`, `latest`, `smallest`. Action to take when there is no initial offset in offset store or the desired offset is out of range. Default: `earliest`.
         :param str date_time_input_format: Enum: `basic`, `best_effort`, `best_effort_us`. Method to read DateTime from text input formats. Default: `basic`.
         :param str handle_error_mode: Enum: `default`, `stream`. How to handle errors for Kafka engine. Default: `default`.
         :param int max_block_size: Number of row collected by poll(s) for flushing data from Kafka. Default: `0`.
@@ -43362,7 +44417,7 @@ class GetServiceIntegrationClickhouseKafkaUserConfigTableResult(dict):
     @pulumi.getter(name="dataFormat")
     def data_format(self) -> str:
         """
-        Enum: `Avro`, `CSV`, `JSONAsString`, `JSONCompactEachRow`, `JSONCompactStringsEachRow`, `JSONEachRow`, `JSONStringsEachRow`, `MsgPack`, `TSKV`, `TSV`, `TabSeparated`, `RawBLOB`, `AvroConfluent`, `Parquet`. Message data format. Default: `JSONEachRow`.
+        Enum: `Avro`, `AvroConfluent`, `CSV`, `JSONAsString`, `JSONCompactEachRow`, `JSONCompactStringsEachRow`, `JSONEachRow`, `JSONStringsEachRow`, `MsgPack`, `Parquet`, `RawBLOB`, `TSKV`, `TSV`, `TabSeparated`. Message data format. Default: `JSONEachRow`.
         """
         return pulumi.get(self, "data_format")
 
@@ -43394,7 +44449,7 @@ class GetServiceIntegrationClickhouseKafkaUserConfigTableResult(dict):
     @pulumi.getter(name="autoOffsetReset")
     def auto_offset_reset(self) -> Optional[str]:
         """
-        Enum: `smallest`, `earliest`, `beginning`, `largest`, `latest`, `end`. Action to take when there is no initial offset in offset store or the desired offset is out of range. Default: `earliest`.
+        Enum: `beginning`, `earliest`, `end`, `largest`, `latest`, `smallest`. Action to take when there is no initial offset in offset store or the desired offset is out of range. Default: `earliest`.
         """
         return pulumi.get(self, "auto_offset_reset")
 
@@ -43823,12 +44878,60 @@ class GetServiceIntegrationDatadogUserConfigRedisResult(dict):
         return pulumi.get(self, "command_stats_enabled")
 
 
+@pulumi.output_type
+class GetServiceIntegrationEndpointAutoscalerUserConfigResult(dict):
+    def __init__(__self__, *,
+                 autoscalings: Sequence['outputs.GetServiceIntegrationEndpointAutoscalerUserConfigAutoscalingResult']):
+        """
+        :param Sequence['GetServiceIntegrationEndpointAutoscalerUserConfigAutoscalingArgs'] autoscalings: Configure autoscaling thresholds for a service
+        """
+        pulumi.set(__self__, "autoscalings", autoscalings)
+
+    @property
+    @pulumi.getter
+    def autoscalings(self) -> Sequence['outputs.GetServiceIntegrationEndpointAutoscalerUserConfigAutoscalingResult']:
+        """
+        Configure autoscaling thresholds for a service
+        """
+        return pulumi.get(self, "autoscalings")
+
+
+@pulumi.output_type
+class GetServiceIntegrationEndpointAutoscalerUserConfigAutoscalingResult(dict):
+    def __init__(__self__, *,
+                 cap_gb: int,
+                 type: str):
+        """
+        :param int cap_gb: The maximum total disk size (in gb) to allow autoscaler to scale up to. Example: `300`.
+        :param str type: Enum: `autoscale_disk`. Type of autoscale event.
+        """
+        pulumi.set(__self__, "cap_gb", cap_gb)
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter(name="capGb")
+    def cap_gb(self) -> int:
+        """
+        The maximum total disk size (in gb) to allow autoscaler to scale up to. Example: `300`.
+        """
+        return pulumi.get(self, "cap_gb")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        Enum: `autoscale_disk`. Type of autoscale event.
+        """
+        return pulumi.get(self, "type")
+
+
 @pulumi.output_type
 class GetServiceIntegrationEndpointDatadogUserConfigResult(dict):
     def __init__(__self__, *,
                  datadog_api_key: str,
                  datadog_tags: Optional[Sequence['outputs.GetServiceIntegrationEndpointDatadogUserConfigDatadogTagResult']] = None,
                  disable_consumer_stats: Optional[bool] = None,
+                 extra_tags_prefix: Optional[str] = None,
                  kafka_consumer_check_instances: Optional[int] = None,
                  kafka_consumer_stats_timeout: Optional[int] = None,
                  max_partition_contexts: Optional[int] = None,
@@ -43837,16 +44940,19 @@ class GetServiceIntegrationEndpointDatadogUserConfigResult(dict):
         :param str datadog_api_key: Datadog API key. Example: `848f30907c15c55d601fe45487cce9b6`.
         :param Sequence['GetServiceIntegrationEndpointDatadogUserConfigDatadogTagArgs'] datadog_tags: Custom tags provided by user
         :param bool disable_consumer_stats: Disable consumer group metrics.
+        :param str extra_tags_prefix: Extra tags prefix. Defaults to aiven.
         :param int kafka_consumer_check_instances: Number of separate instances to fetch kafka consumer statistics with. Example: `8`.
         :param int kafka_consumer_stats_timeout: Number of seconds that datadog will wait to get consumer statistics from brokers. Example: `60`.
         :param int max_partition_contexts: Maximum number of partition contexts to send. Example: `32000`.
-        :param str site: Enum: `datadoghq.com`, `datadoghq.eu`, `us3.datadoghq.com`, `us5.datadoghq.com`, `ddog-gov.com`, `ap1.datadoghq.com`. Datadog intake site. Defaults to datadoghq.com.
+        :param str site: Enum: `ap1.datadoghq.com`, `datadoghq.com`, `datadoghq.eu`, `ddog-gov.com`, `us3.datadoghq.com`, `us5.datadoghq.com`. Datadog intake site. Defaults to datadoghq.com.
         """
         pulumi.set(__self__, "datadog_api_key", datadog_api_key)
         if datadog_tags is not None:
             pulumi.set(__self__, "datadog_tags", datadog_tags)
         if disable_consumer_stats is not None:
             pulumi.set(__self__, "disable_consumer_stats", disable_consumer_stats)
+        if extra_tags_prefix is not None:
+            pulumi.set(__self__, "extra_tags_prefix", extra_tags_prefix)
         if kafka_consumer_check_instances is not None:
             pulumi.set(__self__, "kafka_consumer_check_instances", kafka_consumer_check_instances)
         if kafka_consumer_stats_timeout is not None:
@@ -43880,6 +44986,14 @@ class GetServiceIntegrationEndpointDatadogUserConfigResult(dict):
         """
         return pulumi.get(self, "disable_consumer_stats")
 
+    @property
+    @pulumi.getter(name="extraTagsPrefix")
+    def extra_tags_prefix(self) -> Optional[str]:
+        """
+        Extra tags prefix. Defaults to aiven.
+        """
+        return pulumi.get(self, "extra_tags_prefix")
+
     @property
     @pulumi.getter(name="kafkaConsumerCheckInstances")
     def kafka_consumer_check_instances(self) -> Optional[int]:
@@ -43908,7 +45022,7 @@ class GetServiceIntegrationEndpointDatadogUserConfigResult(dict):
     @pulumi.getter
     def site(self) -> Optional[str]:
         """
-        Enum: `datadoghq.com`, `datadoghq.eu`, `us3.datadoghq.com`, `us5.datadoghq.com`, `ddog-gov.com`, `ap1.datadoghq.com`. Datadog intake site. Defaults to datadoghq.com.
+        Enum: `ap1.datadoghq.com`, `datadoghq.com`, `datadoghq.eu`, `ddog-gov.com`, `us3.datadoghq.com`, `us5.datadoghq.com`. Datadog intake site. Defaults to datadoghq.com.
         """
         return pulumi.get(self, "site")
 
@@ -44291,7 +45405,7 @@ class GetServiceIntegrationEndpointExternalKafkaUserConfigResult(dict):
                  ssl_endpoint_identification_algorithm: Optional[str] = None):
         """
         :param str bootstrap_servers: Bootstrap servers. Example: `10.0.0.1:9092,10.0.0.2:9092`.
-        :param str security_protocol: Enum: `PLAINTEXT`, `SSL`, `SASL_PLAINTEXT`, `SASL_SSL`. Security protocol.
+        :param str security_protocol: Enum: `PLAINTEXT`, `SASL_PLAINTEXT`, `SASL_SSL`, `SSL`. Security protocol.
         :param str sasl_mechanism: Enum: `PLAIN`, `SCRAM-SHA-256`, `SCRAM-SHA-512`. SASL mechanism used for connections to the Kafka server.
         :param str sasl_plain_password: Password for SASL PLAIN mechanism in the Kafka server. Example: `admin`.
         :param str sasl_plain_username: Username for SASL PLAIN mechanism in the Kafka server. Example: `admin`.
@@ -44338,7 +45452,7 @@ class GetServiceIntegrationEndpointExternalKafkaUserConfigResult(dict):
     @pulumi.getter(name="securityProtocol")
     def security_protocol(self) -> str:
         """
-        Enum: `PLAINTEXT`, `SSL`, `SASL_PLAINTEXT`, `SASL_SSL`. Security protocol.
+        Enum: `PLAINTEXT`, `SASL_PLAINTEXT`, `SASL_SSL`, `SSL`. Security protocol.
         """
         return pulumi.get(self, "security_protocol")
 
@@ -44585,7 +45699,7 @@ class GetServiceIntegrationEndpointExternalPostgresqlResult(dict):
         :param str ssl_client_key: Client key. Example: `-----BEGIN PRIVATE KEY-----
                ...
                -----END PRIVATE KEY-----`.
-        :param str ssl_mode: Enum: `disable`, `allow`, `prefer`, `require`, `verify-ca`, `verify-full`. SSL mode to use for the connection.  Please note that Aiven requires TLS for all connections to external PostgreSQL services. Default: `verify-full`.
+        :param str ssl_mode: Enum: `allow`, `disable`, `prefer`, `require`, `verify-ca`, `verify-full`. SSL mode to use for the connection.  Please note that Aiven requires TLS for all connections to external PostgreSQL services. Default: `verify-full`.
         :param str ssl_root_cert: SSL Root Cert. Example: `-----BEGIN CERTIFICATE-----
                ...
                -----END CERTIFICATE-----
@@ -44672,7 +45786,7 @@ class GetServiceIntegrationEndpointExternalPostgresqlResult(dict):
     @pulumi.getter(name="sslMode")
     def ssl_mode(self) -> Optional[str]:
         """
-        Enum: `disable`, `allow`, `prefer`, `require`, `verify-ca`, `verify-full`. SSL mode to use for the connection.  Please note that Aiven requires TLS for all connections to external PostgreSQL services. Default: `verify-full`.
+        Enum: `allow`, `disable`, `prefer`, `require`, `verify-ca`, `verify-full`. SSL mode to use for the connection.  Please note that Aiven requires TLS for all connections to external PostgreSQL services. Default: `verify-full`.
         """
         return pulumi.get(self, "ssl_mode")
 
@@ -44688,6 +45802,49 @@ class GetServiceIntegrationEndpointExternalPostgresqlResult(dict):
         return pulumi.get(self, "ssl_root_cert")
 
 
+@pulumi.output_type
+class GetServiceIntegrationEndpointExternalPrometheusUserConfigResult(dict):
+    def __init__(__self__, *,
+                 basic_auth_password: Optional[str] = None,
+                 basic_auth_username: Optional[str] = None,
+                 service_uri: Optional[str] = None):
+        """
+        :param str basic_auth_password: Prometheus basic authentication password. Example: `fhyFNBjj3R`.
+        :param str basic_auth_username: Prometheus basic authentication username. Example: `prom4851`.
+        :param str service_uri: Prometheus enabled write endpoint. Example: `https://write.example.com/`.
+        """
+        if basic_auth_password is not None:
+            pulumi.set(__self__, "basic_auth_password", basic_auth_password)
+        if basic_auth_username is not None:
+            pulumi.set(__self__, "basic_auth_username", basic_auth_username)
+        if service_uri is not None:
+            pulumi.set(__self__, "service_uri", service_uri)
+
+    @property
+    @pulumi.getter(name="basicAuthPassword")
+    def basic_auth_password(self) -> Optional[str]:
+        """
+        Prometheus basic authentication password. Example: `fhyFNBjj3R`.
+        """
+        return pulumi.get(self, "basic_auth_password")
+
+    @property
+    @pulumi.getter(name="basicAuthUsername")
+    def basic_auth_username(self) -> Optional[str]:
+        """
+        Prometheus basic authentication username. Example: `prom4851`.
+        """
+        return pulumi.get(self, "basic_auth_username")
+
+    @property
+    @pulumi.getter(name="serviceUri")
+    def service_uri(self) -> Optional[str]:
+        """
+        Prometheus enabled write endpoint. Example: `https://write.example.com/`.
+        """
+        return pulumi.get(self, "service_uri")
+
+
 @pulumi.output_type
 class GetServiceIntegrationEndpointExternalSchemaRegistryUserConfigResult(dict):
     def __init__(__self__, *,
@@ -44696,7 +45853,7 @@ class GetServiceIntegrationEndpointExternalSchemaRegistryUserConfigResult(dict):
                  basic_auth_password: Optional[str] = None,
                  basic_auth_username: Optional[str] = None):
         """
-        :param str authentication: Enum: `none`, `basic`. Authentication method.
+        :param str authentication: Enum: `basic`, `none`. Authentication method.
         :param str url: Schema Registry URL. Example: `https://schema-registry.kafka.company.com:28419`.
         :param str basic_auth_password: Basic authentication password. Example: `Zm9vYg==`.
         :param str basic_auth_username: Basic authentication user name. Example: `avnadmin`.
@@ -44712,7 +45869,7 @@ class GetServiceIntegrationEndpointExternalSchemaRegistryUserConfigResult(dict):
     @pulumi.getter
     def authentication(self) -> str:
         """
-        Enum: `none`, `basic`. Authentication method.
+        Enum: `basic`, `none`. Authentication method.
         """
         return pulumi.get(self, "authentication")
 
@@ -44817,7 +45974,7 @@ class GetServiceIntegrationEndpointRsyslogUserConfigResult(dict):
                  max_message_size: Optional[int] = None,
                  sd: Optional[str] = None):
         """
-        :param str format: Enum: `rfc5424`, `rfc3164`, `custom`. Message format. Default: `rfc5424`.
+        :param str format: Enum: `custom`, `rfc3164`, `rfc5424`. Message format. Default: `rfc5424`.
         :param int port: Rsyslog server port. Default: `514`.
         :param str server: Rsyslog server IP address or hostname. Example: `logs.example.com`.
         :param bool tls: Require TLS. Default: `true`.
@@ -44858,7 +46015,7 @@ class GetServiceIntegrationEndpointRsyslogUserConfigResult(dict):
     @pulumi.getter
     def format(self) -> str:
         """
-        Enum: `rfc5424`, `rfc3164`, `custom`. Message format. Default: `rfc5424`.
+        Enum: `custom`, `rfc3164`, `rfc5424`. Message format. Default: `rfc5424`.
         """
         return pulumi.get(self, "format")
 
@@ -45261,7 +46418,7 @@ class GetServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerResult(dict
         :param int consumer_max_poll_records: Set consumer max.poll.records. The default is 500. Example: `500`.
         :param int producer_batch_size: The batch size in bytes producer will attempt to collect before publishing to broker. Example: `1024`.
         :param int producer_buffer_memory: The amount of bytes producer can use for buffering data before publishing to broker. Example: `8388608`.
-        :param str producer_compression_type: Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
+        :param str producer_compression_type: Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
         :param int producer_linger_ms: The linger time (ms) for waiting new data to arrive for publishing. Example: `100`.
         :param int producer_max_request_size: The maximum request size in bytes. Example: `1048576`.
         """
@@ -45326,7 +46483,7 @@ class GetServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerResult(dict
     @pulumi.getter(name="producerCompressionType")
     def producer_compression_type(self) -> Optional[str]:
         """
-        Enum: `gzip`, `snappy`, `lz4`, `zstd`, `none`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
+        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
         """
         return pulumi.get(self, "producer_compression_type")
 
@@ -46095,23 +47252,35 @@ class GetThanosThanosUserConfigResult(dict):
                  ip_filter_strings: Optional[Sequence[str]] = None,
                  ip_filters: Optional[Sequence[str]] = None,
                  object_storage_usage_alert_threshold_gb: Optional[int] = None,
+                 private_access: Optional['outputs.GetThanosThanosUserConfigPrivateAccessResult'] = None,
+                 privatelink_access: Optional['outputs.GetThanosThanosUserConfigPrivatelinkAccessResult'] = None,
                  public_access: Optional['outputs.GetThanosThanosUserConfigPublicAccessResult'] = None,
                  query: Optional['outputs.GetThanosThanosUserConfigQueryResult'] = None,
                  query_frontend: Optional['outputs.GetThanosThanosUserConfigQueryFrontendResult'] = None,
+                 receiver_ingesting: Optional[Mapping[str, str]] = None,
+                 receiver_routing: Optional[Mapping[str, str]] = None,
+                 ruler: Optional[Mapping[str, str]] = None,
                  service_log: Optional[bool] = None,
-                 static_ips: Optional[bool] = None):
+                 static_ips: Optional[bool] = None,
+                 store: Optional[Mapping[str, str]] = None):
         """
-        :param 'GetThanosThanosUserConfigCompactorArgs' compactor: ThanosCompactor
+        :param 'GetThanosThanosUserConfigCompactorArgs' compactor: Configuration options for Thanos Compactor
         :param Mapping[str, str] env: Environmental variables.
         :param Sequence['GetThanosThanosUserConfigIpFilterObjectArgs'] 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`.
         :param int object_storage_usage_alert_threshold_gb: After exceeding the limit a service alert is going to be raised (0 means not set).
+        :param 'GetThanosThanosUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
+        :param 'GetThanosThanosUserConfigPrivatelinkAccessArgs' privatelink_access: Allow access to selected service components through Privatelink
         :param 'GetThanosThanosUserConfigPublicAccessArgs' public_access: Allow access to selected service ports from the public Internet
-        :param 'GetThanosThanosUserConfigQueryArgs' query: ThanosQuery
-        :param 'GetThanosThanosUserConfigQueryFrontendArgs' query_frontend: ThanosQueryFrontend
+        :param 'GetThanosThanosUserConfigQueryArgs' query: Configuration options for Thanos Query
+        :param 'GetThanosThanosUserConfigQueryFrontendArgs' query_frontend: Configuration options for Thanos Query Frontend
+        :param Mapping[str, str] receiver_ingesting: Common configuration options for Thanos Receive.
+        :param Mapping[str, str] receiver_routing: Configuration options for Thanos Receive Routing.
+        :param Mapping[str, str] ruler: Configuration options for Thanos Ruler.
         :param bool service_log: Store logs for the service so that they are available in the HTTP API and console.
         :param bool static_ips: Use static public IP addresses.
+        :param Mapping[str, str] store: Configuration options for Thanos Store.
         """
         if compactor is not None:
             pulumi.set(__self__, "compactor", compactor)
@@ -46125,22 +47294,34 @@ class GetThanosThanosUserConfigResult(dict):
             pulumi.set(__self__, "ip_filters", ip_filters)
         if object_storage_usage_alert_threshold_gb is not None:
             pulumi.set(__self__, "object_storage_usage_alert_threshold_gb", object_storage_usage_alert_threshold_gb)
+        if private_access is not None:
+            pulumi.set(__self__, "private_access", private_access)
+        if privatelink_access is not None:
+            pulumi.set(__self__, "privatelink_access", privatelink_access)
         if public_access is not None:
             pulumi.set(__self__, "public_access", public_access)
         if query is not None:
             pulumi.set(__self__, "query", query)
         if query_frontend is not None:
             pulumi.set(__self__, "query_frontend", query_frontend)
+        if receiver_ingesting is not None:
+            pulumi.set(__self__, "receiver_ingesting", receiver_ingesting)
+        if receiver_routing is not None:
+            pulumi.set(__self__, "receiver_routing", receiver_routing)
+        if ruler is not None:
+            pulumi.set(__self__, "ruler", ruler)
         if service_log is not None:
             pulumi.set(__self__, "service_log", service_log)
         if static_ips is not None:
             pulumi.set(__self__, "static_ips", static_ips)
+        if store is not None:
+            pulumi.set(__self__, "store", store)
 
     @property
     @pulumi.getter
     def compactor(self) -> Optional['outputs.GetThanosThanosUserConfigCompactorResult']:
         """
-        ThanosCompactor
+        Configuration options for Thanos Compactor
         """
         return pulumi.get(self, "compactor")
 
@@ -46186,6 +47367,22 @@ class GetThanosThanosUserConfigResult(dict):
         """
         return pulumi.get(self, "object_storage_usage_alert_threshold_gb")
 
+    @property
+    @pulumi.getter(name="privateAccess")
+    def private_access(self) -> Optional['outputs.GetThanosThanosUserConfigPrivateAccessResult']:
+        """
+        Allow access to selected service ports from private networks
+        """
+        return pulumi.get(self, "private_access")
+
+    @property
+    @pulumi.getter(name="privatelinkAccess")
+    def privatelink_access(self) -> Optional['outputs.GetThanosThanosUserConfigPrivatelinkAccessResult']:
+        """
+        Allow access to selected service components through Privatelink
+        """
+        return pulumi.get(self, "privatelink_access")
+
     @property
     @pulumi.getter(name="publicAccess")
     def public_access(self) -> Optional['outputs.GetThanosThanosUserConfigPublicAccessResult']:
@@ -46198,7 +47395,7 @@ class GetThanosThanosUserConfigResult(dict):
     @pulumi.getter
     def query(self) -> Optional['outputs.GetThanosThanosUserConfigQueryResult']:
         """
-        ThanosQuery
+        Configuration options for Thanos Query
         """
         return pulumi.get(self, "query")
 
@@ -46206,10 +47403,34 @@ class GetThanosThanosUserConfigResult(dict):
     @pulumi.getter(name="queryFrontend")
     def query_frontend(self) -> Optional['outputs.GetThanosThanosUserConfigQueryFrontendResult']:
         """
-        ThanosQueryFrontend
+        Configuration options for Thanos Query Frontend
         """
         return pulumi.get(self, "query_frontend")
 
+    @property
+    @pulumi.getter(name="receiverIngesting")
+    def receiver_ingesting(self) -> Optional[Mapping[str, str]]:
+        """
+        Common configuration options for Thanos Receive.
+        """
+        return pulumi.get(self, "receiver_ingesting")
+
+    @property
+    @pulumi.getter(name="receiverRouting")
+    def receiver_routing(self) -> Optional[Mapping[str, str]]:
+        """
+        Configuration options for Thanos Receive Routing.
+        """
+        return pulumi.get(self, "receiver_routing")
+
+    @property
+    @pulumi.getter
+    def ruler(self) -> Optional[Mapping[str, str]]:
+        """
+        Configuration options for Thanos Ruler.
+        """
+        return pulumi.get(self, "ruler")
+
     @property
     @pulumi.getter(name="serviceLog")
     def service_log(self) -> Optional[bool]:
@@ -46226,6 +47447,14 @@ class GetThanosThanosUserConfigResult(dict):
         """
         return pulumi.get(self, "static_ips")
 
+    @property
+    @pulumi.getter
+    def store(self) -> Optional[Mapping[str, str]]:
+        """
+        Configuration options for Thanos Store.
+        """
+        return pulumi.get(self, "store")
+
 
 @pulumi.output_type
 class GetThanosThanosUserConfigCompactorResult(dict):
@@ -46276,6 +47505,68 @@ class GetThanosThanosUserConfigIpFilterObjectResult(dict):
         return pulumi.get(self, "description")
 
 
+@pulumi.output_type
+class GetThanosThanosUserConfigPrivateAccessResult(dict):
+    def __init__(__self__, *,
+                 query_frontend: Optional[bool] = None,
+                 receiver_routing: Optional[bool] = None):
+        """
+        :param bool query_frontend: Allow clients to connect to query_frontend with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        :param bool receiver_routing: Allow clients to connect to receiver_routing with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        if query_frontend is not None:
+            pulumi.set(__self__, "query_frontend", query_frontend)
+        if receiver_routing is not None:
+            pulumi.set(__self__, "receiver_routing", receiver_routing)
+
+    @property
+    @pulumi.getter(name="queryFrontend")
+    def query_frontend(self) -> Optional[bool]:
+        """
+        Allow clients to connect to query_frontend with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        return pulumi.get(self, "query_frontend")
+
+    @property
+    @pulumi.getter(name="receiverRouting")
+    def receiver_routing(self) -> Optional[bool]:
+        """
+        Allow clients to connect to receiver_routing with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        return pulumi.get(self, "receiver_routing")
+
+
+@pulumi.output_type
+class GetThanosThanosUserConfigPrivatelinkAccessResult(dict):
+    def __init__(__self__, *,
+                 query_frontend: Optional[bool] = None,
+                 receiver_routing: Optional[bool] = None):
+        """
+        :param bool query_frontend: Enable query_frontend.
+        :param bool receiver_routing: Enable receiver_routing.
+        """
+        if query_frontend is not None:
+            pulumi.set(__self__, "query_frontend", query_frontend)
+        if receiver_routing is not None:
+            pulumi.set(__self__, "receiver_routing", receiver_routing)
+
+    @property
+    @pulumi.getter(name="queryFrontend")
+    def query_frontend(self) -> Optional[bool]:
+        """
+        Enable query_frontend.
+        """
+        return pulumi.get(self, "query_frontend")
+
+    @property
+    @pulumi.getter(name="receiverRouting")
+    def receiver_routing(self) -> Optional[bool]:
+        """
+        Enable receiver_routing.
+        """
+        return pulumi.get(self, "receiver_routing")
+
+
 @pulumi.output_type
 class GetThanosThanosUserConfigPublicAccessResult(dict):
     def __init__(__self__, *,
@@ -46736,7 +48027,7 @@ class GetValkeyValkeyUserConfigResult(dict):
         :param int valkey_io_threads: Set Valkey IO thread count. Changing this will cause a restart of the Valkey service. Example: `1`.
         :param int valkey_lfu_decay_time: LFU maxmemory-policy counter decay time in minutes. Default: `1`.
         :param int valkey_lfu_log_factor: Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies. Default: `10`.
-        :param str valkey_maxmemory_policy: Enum: `noeviction`, `allkeys-lru`, `volatile-lru`, `allkeys-random`, `volatile-random`, `volatile-ttl`, `volatile-lfu`, `allkeys-lfu`. Valkey maxmemory-policy. Default: `noeviction`.
+        :param str valkey_maxmemory_policy: Enum: `allkeys-lfu`, `allkeys-lru`, `allkeys-random`, `noeviction`, `volatile-lfu`, `volatile-lru`, `volatile-random`, `volatile-ttl`. Valkey maxmemory-policy. Default: `noeviction`.
         :param str valkey_notify_keyspace_events: Set notify-keyspace-events option.
         :param int valkey_number_of_databases: Set number of Valkey databases. Changing this will cause a restart of the Valkey service. Example: `16`.
         :param str valkey_persistence: Enum: `off`, `rdb`. When persistence is `rdb`, Valkey does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
@@ -46954,7 +48245,7 @@ class GetValkeyValkeyUserConfigResult(dict):
     @pulumi.getter(name="valkeyMaxmemoryPolicy")
     def valkey_maxmemory_policy(self) -> Optional[str]:
         """
-        Enum: `noeviction`, `allkeys-lru`, `volatile-lru`, `allkeys-random`, `volatile-random`, `volatile-ttl`, `volatile-lfu`, `allkeys-lfu`. Valkey maxmemory-policy. Default: `noeviction`.
+        Enum: `allkeys-lfu`, `allkeys-lru`, `allkeys-random`, `noeviction`, `volatile-lfu`, `volatile-lru`, `volatile-random`, `volatile-ttl`. Valkey maxmemory-policy. Default: `noeviction`.
         """
         return pulumi.get(self, "valkey_maxmemory_policy")