pulumi-aiven 6.13.0a1710994538__py3-none-any.whl → 6.13.0a1711361534__py3-none-any.whl

pulumi_aiven/outputs.py

@@ -34,6 +34,17 @@ __all__ = [
     'ClickhouseServiceIntegration',
     'ClickhouseTag',
     'ClickhouseTechEmail',
+    'DragonflyComponent',
+    'DragonflyDragonfly',
+    'DragonflyDragonflyUserConfig',
+    'DragonflyDragonflyUserConfigIpFilterObject',
+    'DragonflyDragonflyUserConfigMigration',
+    'DragonflyDragonflyUserConfigPrivateAccess',
+    'DragonflyDragonflyUserConfigPrivatelinkAccess',
+    'DragonflyDragonflyUserConfigPublicAccess',
+    'DragonflyServiceIntegration',
+    'DragonflyTag',
+    'DragonflyTechEmail',
     'FlinkApplicationVersionSink',
     'FlinkApplicationVersionSource',
     'FlinkComponent',
@@ -169,7 +180,9 @@ __all__ = [
     'OpenSearchServiceIntegration',
     'OpenSearchTag',
     'OpenSearchTechEmail',
+    'OrganizationGroupProjectTimeouts',
     'OrganizationTimeouts',
+    'OrganizationUserGroupMemberTimeouts',
     'PgComponent',
     'PgPg',
     'PgPgUserConfig',
@@ -177,6 +190,7 @@ __all__ = [
     'PgPgUserConfigMigration',
     'PgPgUserConfigPg',
     'PgPgUserConfigPgQualstats',
+    'PgPgUserConfigPgaudit',
     'PgPgUserConfigPgbouncer',
     'PgPgUserConfigPglookout',
     'PgPgUserConfigPrivateAccess',
@@ -222,9 +236,12 @@ __all__ = [
     'ServiceIntegrationEndpointJolokiaUserConfig',
     'ServiceIntegrationEndpointPrometheusUserConfig',
     'ServiceIntegrationEndpointRsyslogUserConfig',
+    'ServiceIntegrationExternalAwsCloudwatchLogsUserConfig',
     'ServiceIntegrationExternalAwsCloudwatchMetricsUserConfig',
     'ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetric',
     'ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetric',
+    'ServiceIntegrationExternalElasticsearchLogsUserConfig',
+    'ServiceIntegrationExternalOpensearchLogsUserConfig',
     'ServiceIntegrationKafkaConnectUserConfig',
     'ServiceIntegrationKafkaConnectUserConfigKafkaConnect',
     'ServiceIntegrationKafkaLogsUserConfig',
@@ -234,6 +251,9 @@ __all__ = [
     'ServiceIntegrationMetricsUserConfig',
     'ServiceIntegrationMetricsUserConfigSourceMysql',
     'ServiceIntegrationMetricsUserConfigSourceMysqlTelegraf',
+    'ServiceIntegrationPrometheusUserConfig',
+    'ServiceIntegrationPrometheusUserConfigSourceMysql',
+    'ServiceIntegrationPrometheusUserConfigSourceMysqlTelegraf',
     'GetAccountAuthenticationSamlFieldMappingResult',
     'GetCassandaCassandraResult',
     'GetCassandaCassandraUserConfigResult',
@@ -265,6 +285,17 @@ __all__ = [
     'GetClickhouseServiceIntegrationResult',
     'GetClickhouseTagResult',
     'GetClickhouseTechEmailResult',
+    'GetDragonflyComponentResult',
+    'GetDragonflyDragonflyResult',
+    'GetDragonflyDragonflyUserConfigResult',
+    'GetDragonflyDragonflyUserConfigIpFilterObjectResult',
+    'GetDragonflyDragonflyUserConfigMigrationResult',
+    'GetDragonflyDragonflyUserConfigPrivateAccessResult',
+    'GetDragonflyDragonflyUserConfigPrivatelinkAccessResult',
+    'GetDragonflyDragonflyUserConfigPublicAccessResult',
+    'GetDragonflyServiceIntegrationResult',
+    'GetDragonflyTagResult',
+    'GetDragonflyTechEmailResult',
     'GetFlinkApplicationVersionSinkResult',
     'GetFlinkApplicationVersionSourceResult',
     'GetFlinkComponentResult',
@@ -407,6 +438,7 @@ __all__ = [
     'GetPgPgUserConfigMigrationResult',
     'GetPgPgUserConfigPgResult',
     'GetPgPgUserConfigPgQualstatsResult',
+    'GetPgPgUserConfigPgauditResult',
     'GetPgPgUserConfigPgbouncerResult',
     'GetPgPgUserConfigPglookoutResult',
     'GetPgPgUserConfigPrivateAccessResult',
@@ -452,9 +484,12 @@ __all__ = [
     'GetServiceIntegrationEndpointJolokiaUserConfigResult',
     'GetServiceIntegrationEndpointPrometheusUserConfigResult',
     'GetServiceIntegrationEndpointRsyslogUserConfigResult',
+    'GetServiceIntegrationExternalAwsCloudwatchLogsUserConfigResult',
     'GetServiceIntegrationExternalAwsCloudwatchMetricsUserConfigResult',
     'GetServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricResult',
     'GetServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricResult',
+    'GetServiceIntegrationExternalElasticsearchLogsUserConfigResult',
+    'GetServiceIntegrationExternalOpensearchLogsUserConfigResult',
     'GetServiceIntegrationKafkaConnectUserConfigResult',
     'GetServiceIntegrationKafkaConnectUserConfigKafkaConnectResult',
     'GetServiceIntegrationKafkaLogsUserConfigResult',
@@ -464,6 +499,9 @@ __all__ = [
     'GetServiceIntegrationMetricsUserConfigResult',
     'GetServiceIntegrationMetricsUserConfigSourceMysqlResult',
     'GetServiceIntegrationMetricsUserConfigSourceMysqlTelegrafResult',
+    'GetServiceIntegrationPrometheusUserConfigResult',
+    'GetServiceIntegrationPrometheusUserConfigSourceMysqlResult',
+    'GetServiceIntegrationPrometheusUserConfigSourceMysqlTelegrafResult',
 ]
 
 @pulumi.output_type
@@ -1745,11 +1783,11 @@ class ClickhouseGrantPrivilegeGrant(dict):
                  table: Optional[str] = None,
                  with_grant: Optional[bool] = None):
         """
-        :param str database: The database that the grant refers to. To set up proper dependencies please refer to this variable as a reference. This property cannot be changed, doing so forces recreation of the resource.
-        :param str column: The column that the grant refers to. This property cannot be changed, doing so forces recreation of the resource.
-        :param str privilege: The privilege to grant, i.e. 'INSERT', 'SELECT', etc. This property cannot be changed, doing so forces recreation of the resource.
-        :param str table: The table that the grant refers to. This property cannot be changed, doing so forces recreation of the resource.
-        :param bool with_grant: If true then the grantee gets the ability to grant the privileges he received too. This property cannot be changed, doing so forces recreation of the resource.
+        :param str database: The database that the grant refers to. To set up proper dependencies please refer to this variable as a reference. Changing this property forces recreation of the resource.
+        :param str column: The column that the grant refers to. Changing this property forces recreation of the resource.
+        :param str privilege: The privilege to grant, i.e. 'INSERT', 'SELECT', etc. Changing this property forces recreation of the resource.
+        :param str table: The table that the grant refers to. Changing this property forces recreation of the resource.
+        :param bool with_grant: If true then the grantee gets the ability to grant the privileges he received too. Changing this property forces recreation of the resource.
         """
         pulumi.set(__self__, "database", database)
         if column is not None:
@@ -1765,7 +1803,7 @@ class ClickhouseGrantPrivilegeGrant(dict):
     @pulumi.getter
     def database(self) -> str:
         """
-        The database that the grant refers to. To set up proper dependencies please refer to this variable as a reference. This property cannot be changed, doing so forces recreation of the resource.
+        The database that the grant refers to. To set up proper dependencies please refer to this variable as a reference. Changing this property forces recreation of the resource.
         """
         return pulumi.get(self, "database")
 
@@ -1773,7 +1811,7 @@ class ClickhouseGrantPrivilegeGrant(dict):
     @pulumi.getter
     def column(self) -> Optional[str]:
         """
-        The column that the grant refers to. This property cannot be changed, doing so forces recreation of the resource.
+        The column that the grant refers to. Changing this property forces recreation of the resource.
         """
         return pulumi.get(self, "column")
 
@@ -1781,7 +1819,7 @@ class ClickhouseGrantPrivilegeGrant(dict):
     @pulumi.getter
     def privilege(self) -> Optional[str]:
         """
-        The privilege to grant, i.e. 'INSERT', 'SELECT', etc. This property cannot be changed, doing so forces recreation of the resource.
+        The privilege to grant, i.e. 'INSERT', 'SELECT', etc. Changing this property forces recreation of the resource.
         """
         return pulumi.get(self, "privilege")
 
@@ -1789,7 +1827,7 @@ class ClickhouseGrantPrivilegeGrant(dict):
     @pulumi.getter
     def table(self) -> Optional[str]:
         """
-        The table that the grant refers to. This property cannot be changed, doing so forces recreation of the resource.
+        The table that the grant refers to. Changing this property forces recreation of the resource.
         """
         return pulumi.get(self, "table")
 
@@ -1797,7 +1835,7 @@ class ClickhouseGrantPrivilegeGrant(dict):
     @pulumi.getter(name="withGrant")
     def with_grant(self) -> Optional[bool]:
         """
-        If true then the grantee gets the ability to grant the privileges he received too. This property cannot be changed, doing so forces recreation of the resource.
+        If true then the grantee gets the ability to grant the privileges he received too. Changing this property forces recreation of the resource.
         """
         return pulumi.get(self, "with_grant")
 
@@ -1807,7 +1845,7 @@ class ClickhouseGrantRoleGrant(dict):
     def __init__(__self__, *,
                  role: Optional[str] = None):
         """
-        :param str role: The role that is to be granted. To set up proper dependencies please refer to this variable as a reference. This property cannot be changed, doing so forces recreation of the resource.
+        :param str role: The role that is to be granted. To set up proper dependencies please refer to this variable as a reference. Changing this property forces recreation of the resource.
         """
         if role is not None:
             pulumi.set(__self__, "role", role)
@@ -1816,7 +1854,7 @@ class ClickhouseGrantRoleGrant(dict):
     @pulumi.getter
     def role(self) -> Optional[str]:
         """
-        The role that is to be granted. To set up proper dependencies please refer to this variable as a reference. This property cannot be changed, doing so forces recreation of the resource.
+        The role that is to be granted. To set up proper dependencies please refer to this variable as a reference. Changing this property forces recreation of the resource.
         """
         return pulumi.get(self, "role")
 
@@ -1916,6 +1954,689 @@ class ClickhouseTechEmail(dict):
         return pulumi.get(self, "email")
 
 
+@pulumi.output_type
+class DragonflyComponent(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "connectionUri":
+            suggest = "connection_uri"
+        elif key == "kafkaAuthenticationMethod":
+            suggest = "kafka_authentication_method"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DragonflyComponent. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DragonflyComponent.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DragonflyComponent.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 component: Optional[str] = None,
+                 connection_uri: Optional[str] = None,
+                 host: Optional[str] = None,
+                 kafka_authentication_method: Optional[str] = None,
+                 port: Optional[int] = None,
+                 route: Optional[str] = None,
+                 ssl: Optional[bool] = None,
+                 usage: Optional[str] = None):
+        """
+        :param str component: Service component name
+        :param str connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
+        :param str host: Host name for connecting to the service component
+        :param str kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
+        :param int port: Port number for connecting to the service component
+        :param str route: Network access route
+        :param bool ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
+        :param str usage: DNS usage name
+        """
+        if component is not None:
+            pulumi.set(__self__, "component", component)
+        if connection_uri is not None:
+            pulumi.set(__self__, "connection_uri", connection_uri)
+        if host is not None:
+            pulumi.set(__self__, "host", host)
+        if kafka_authentication_method is not None:
+            pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if route is not None:
+            pulumi.set(__self__, "route", route)
+        if ssl is not None:
+            pulumi.set(__self__, "ssl", ssl)
+        if usage is not None:
+            pulumi.set(__self__, "usage", usage)
+
+    @property
+    @pulumi.getter
+    def component(self) -> Optional[str]:
+        """
+        Service component name
+        """
+        return pulumi.get(self, "component")
+
+    @property
+    @pulumi.getter(name="connectionUri")
+    def connection_uri(self) -> Optional[str]:
+        """
+        Connection info for connecting to the service component. This is a combination of host and port.
+        """
+        return pulumi.get(self, "connection_uri")
+
+    @property
+    @pulumi.getter
+    def host(self) -> Optional[str]:
+        """
+        Host name for connecting to the service component
+        """
+        return pulumi.get(self, "host")
+
+    @property
+    @pulumi.getter(name="kafkaAuthenticationMethod")
+    def kafka_authentication_method(self) -> Optional[str]:
+        """
+        Kafka authentication method. This is a value specific to the 'kafka' service component
+        """
+        return pulumi.get(self, "kafka_authentication_method")
+
+    @property
+    @pulumi.getter
+    def port(self) -> Optional[int]:
+        """
+        Port number for connecting to the service component
+        """
+        return pulumi.get(self, "port")
+
+    @property
+    @pulumi.getter
+    def route(self) -> Optional[str]:
+        """
+        Network access route
+        """
+        return pulumi.get(self, "route")
+
+    @property
+    @pulumi.getter
+    def ssl(self) -> Optional[bool]:
+        """
+        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
+        """
+        return pulumi.get(self, "ssl")
+
+    @property
+    @pulumi.getter
+    def usage(self) -> Optional[str]:
+        """
+        DNS usage name
+        """
+        return pulumi.get(self, "usage")
+
+
+@pulumi.output_type
+class DragonflyDragonfly(dict):
+    def __init__(__self__):
+        pass
+
+
+@pulumi.output_type
+class DragonflyDragonflyUserConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "cacheMode":
+            suggest = "cache_mode"
+        elif key == "dragonflySsl":
+            suggest = "dragonfly_ssl"
+        elif key == "ipFilterObjects":
+            suggest = "ip_filter_objects"
+        elif key == "ipFilterStrings":
+            suggest = "ip_filter_strings"
+        elif key == "ipFilters":
+            suggest = "ip_filters"
+        elif key == "privateAccess":
+            suggest = "private_access"
+        elif key == "privatelinkAccess":
+            suggest = "privatelink_access"
+        elif key == "projectToForkFrom":
+            suggest = "project_to_fork_from"
+        elif key == "publicAccess":
+            suggest = "public_access"
+        elif key == "recoveryBasebackupName":
+            suggest = "recovery_basebackup_name"
+        elif key == "serviceLog":
+            suggest = "service_log"
+        elif key == "serviceToForkFrom":
+            suggest = "service_to_fork_from"
+        elif key == "staticIps":
+            suggest = "static_ips"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DragonflyDragonflyUserConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DragonflyDragonflyUserConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DragonflyDragonflyUserConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 cache_mode: Optional[bool] = None,
+                 dragonfly_ssl: Optional[bool] = None,
+                 ip_filter_objects: Optional[Sequence['outputs.DragonflyDragonflyUserConfigIpFilterObject']] = None,
+                 ip_filter_strings: Optional[Sequence[str]] = None,
+                 ip_filters: Optional[Sequence[str]] = None,
+                 migration: Optional['outputs.DragonflyDragonflyUserConfigMigration'] = None,
+                 private_access: Optional['outputs.DragonflyDragonflyUserConfigPrivateAccess'] = None,
+                 privatelink_access: Optional['outputs.DragonflyDragonflyUserConfigPrivatelinkAccess'] = None,
+                 project_to_fork_from: Optional[str] = None,
+                 public_access: Optional['outputs.DragonflyDragonflyUserConfigPublicAccess'] = None,
+                 recovery_basebackup_name: Optional[str] = None,
+                 service_log: Optional[bool] = None,
+                 service_to_fork_from: Optional[str] = None,
+                 static_ips: Optional[bool] = None):
+        """
+        :param bool cache_mode: Evict entries when getting close to maxmemory limit. The default value is `false`.
+        :param bool dragonfly_ssl: Require SSL to access Dragonfly. The default value is `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'.
+        :param Sequence[str] ip_filters: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
+        :param 'DragonflyDragonflyUserConfigMigrationArgs' migration: Migrate data from existing server
+        :param 'DragonflyDragonflyUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
+        :param 'DragonflyDragonflyUserConfigPrivatelinkAccessArgs' privatelink_access: Allow access to selected service components through Privatelink
+        :param str project_to_fork_from: Name of another project to fork a service from. This has effect only when a new service is being created.
+        :param 'DragonflyDragonflyUserConfigPublicAccessArgs' public_access: Allow access to selected service ports from the public Internet
+        :param str recovery_basebackup_name: Name of the basebackup to restore in forked service.
+        :param bool service_log: Store logs for the service so that they are available in the HTTP API and console.
+        :param str service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created.
+        :param bool static_ips: Use static public IP addresses.
+        """
+        if cache_mode is not None:
+            pulumi.set(__self__, "cache_mode", cache_mode)
+        if dragonfly_ssl is not None:
+            pulumi.set(__self__, "dragonfly_ssl", dragonfly_ssl)
+        if ip_filter_objects is not None:
+            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
+        if ip_filter_strings is not None:
+            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
+        if ip_filters is not None:
+            pulumi.set(__self__, "ip_filters", ip_filters)
+        if migration is not None:
+            pulumi.set(__self__, "migration", migration)
+        if private_access is not None:
+            pulumi.set(__self__, "private_access", private_access)
+        if privatelink_access is not None:
+            pulumi.set(__self__, "privatelink_access", privatelink_access)
+        if project_to_fork_from is not None:
+            pulumi.set(__self__, "project_to_fork_from", project_to_fork_from)
+        if public_access is not None:
+            pulumi.set(__self__, "public_access", public_access)
+        if recovery_basebackup_name is not None:
+            pulumi.set(__self__, "recovery_basebackup_name", recovery_basebackup_name)
+        if service_log is not None:
+            pulumi.set(__self__, "service_log", service_log)
+        if service_to_fork_from is not None:
+            pulumi.set(__self__, "service_to_fork_from", service_to_fork_from)
+        if static_ips is not None:
+            pulumi.set(__self__, "static_ips", static_ips)
+
+    @property
+    @pulumi.getter(name="cacheMode")
+    def cache_mode(self) -> Optional[bool]:
+        """
+        Evict entries when getting close to maxmemory limit. The default value is `false`.
+        """
+        return pulumi.get(self, "cache_mode")
+
+    @property
+    @pulumi.getter(name="dragonflySsl")
+    def dragonfly_ssl(self) -> Optional[bool]:
+        """
+        Require SSL to access Dragonfly. The default value is `true`.
+        """
+        return pulumi.get(self, "dragonfly_ssl")
+
+    @property
+    @pulumi.getter(name="ipFilterObjects")
+    def ip_filter_objects(self) -> Optional[Sequence['outputs.DragonflyDragonflyUserConfigIpFilterObject']]:
+        """
+        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
+        """
+        return pulumi.get(self, "ip_filter_objects")
+
+    @property
+    @pulumi.getter(name="ipFilterStrings")
+    def ip_filter_strings(self) -> Optional[Sequence[str]]:
+        """
+        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
+        """
+        return pulumi.get(self, "ip_filter_strings")
+
+    @property
+    @pulumi.getter(name="ipFilters")
+    def ip_filters(self) -> Optional[Sequence[str]]:
+        """
+        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
+        """
+        warnings.warn("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
+        pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `ip_filter_string` instead.""")
+
+        return pulumi.get(self, "ip_filters")
+
+    @property
+    @pulumi.getter
+    def migration(self) -> Optional['outputs.DragonflyDragonflyUserConfigMigration']:
+        """
+        Migrate data from existing server
+        """
+        return pulumi.get(self, "migration")
+
+    @property
+    @pulumi.getter(name="privateAccess")
+    def private_access(self) -> Optional['outputs.DragonflyDragonflyUserConfigPrivateAccess']:
+        """
+        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.DragonflyDragonflyUserConfigPrivatelinkAccess']:
+        """
+        Allow access to selected service components through Privatelink
+        """
+        return pulumi.get(self, "privatelink_access")
+
+    @property
+    @pulumi.getter(name="projectToForkFrom")
+    def project_to_fork_from(self) -> Optional[str]:
+        """
+        Name of another project to fork a service from. This has effect only when a new service is being created.
+        """
+        return pulumi.get(self, "project_to_fork_from")
+
+    @property
+    @pulumi.getter(name="publicAccess")
+    def public_access(self) -> Optional['outputs.DragonflyDragonflyUserConfigPublicAccess']:
+        """
+        Allow access to selected service ports from the public Internet
+        """
+        return pulumi.get(self, "public_access")
+
+    @property
+    @pulumi.getter(name="recoveryBasebackupName")
+    def recovery_basebackup_name(self) -> Optional[str]:
+        """
+        Name of the basebackup to restore in forked service.
+        """
+        return pulumi.get(self, "recovery_basebackup_name")
+
+    @property
+    @pulumi.getter(name="serviceLog")
+    def service_log(self) -> Optional[bool]:
+        """
+        Store logs for the service so that they are available in the HTTP API and console.
+        """
+        return pulumi.get(self, "service_log")
+
+    @property
+    @pulumi.getter(name="serviceToForkFrom")
+    def service_to_fork_from(self) -> Optional[str]:
+        """
+        Name of another service to fork from. This has effect only when a new service is being created.
+        """
+        return pulumi.get(self, "service_to_fork_from")
+
+    @property
+    @pulumi.getter(name="staticIps")
+    def static_ips(self) -> Optional[bool]:
+        """
+        Use static public IP addresses.
+        """
+        return pulumi.get(self, "static_ips")
+
+
+@pulumi.output_type
+class DragonflyDragonflyUserConfigIpFilterObject(dict):
+    def __init__(__self__, *,
+                 network: str,
+                 description: Optional[str] = None):
+        """
+        :param str network: CIDR address block.
+        :param str description: Description for IP filter list entry.
+        """
+        pulumi.set(__self__, "network", network)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def network(self) -> str:
+        """
+        CIDR address block.
+        """
+        return pulumi.get(self, "network")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[str]:
+        """
+        Description for IP filter list entry.
+        """
+        return pulumi.get(self, "description")
+
+
+@pulumi.output_type
+class DragonflyDragonflyUserConfigMigration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "ignoreDbs":
+            suggest = "ignore_dbs"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DragonflyDragonflyUserConfigMigration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DragonflyDragonflyUserConfigMigration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DragonflyDragonflyUserConfigMigration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 host: str,
+                 port: int,
+                 dbname: Optional[str] = None,
+                 ignore_dbs: Optional[str] = None,
+                 method: Optional[str] = None,
+                 password: Optional[str] = None,
+                 ssl: Optional[bool] = None,
+                 username: Optional[str] = None):
+        """
+        :param str host: Hostname or IP address of the server where to migrate data from.
+        :param int port: Port number of the server where to migrate data from.
+        :param str dbname: Database name for bootstrapping the initial connection.
+        :param str ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment).
+        :param str method: The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
+        :param str password: Password for authentication with the server where to migrate data from.
+        :param bool ssl: The server where to migrate data from is secured with SSL. The default value is `true`.
+        :param str username: User name for authentication with the server where to migrate data from.
+        """
+        pulumi.set(__self__, "host", host)
+        pulumi.set(__self__, "port", port)
+        if dbname is not None:
+            pulumi.set(__self__, "dbname", dbname)
+        if ignore_dbs is not None:
+            pulumi.set(__self__, "ignore_dbs", ignore_dbs)
+        if method is not None:
+            pulumi.set(__self__, "method", method)
+        if password is not None:
+            pulumi.set(__self__, "password", password)
+        if ssl is not None:
+            pulumi.set(__self__, "ssl", ssl)
+        if username is not None:
+            pulumi.set(__self__, "username", username)
+
+    @property
+    @pulumi.getter
+    def host(self) -> str:
+        """
+        Hostname or IP address of the server where to migrate data from.
+        """
+        return pulumi.get(self, "host")
+
+    @property
+    @pulumi.getter
+    def port(self) -> int:
+        """
+        Port number of the server where to migrate data from.
+        """
+        return pulumi.get(self, "port")
+
+    @property
+    @pulumi.getter
+    def dbname(self) -> Optional[str]:
+        """
+        Database name for bootstrapping the initial connection.
+        """
+        return pulumi.get(self, "dbname")
+
+    @property
+    @pulumi.getter(name="ignoreDbs")
+    def ignore_dbs(self) -> Optional[str]:
+        """
+        Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment).
+        """
+        return pulumi.get(self, "ignore_dbs")
+
+    @property
+    @pulumi.getter
+    def method(self) -> Optional[str]:
+        """
+        The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
+        """
+        return pulumi.get(self, "method")
+
+    @property
+    @pulumi.getter
+    def password(self) -> Optional[str]:
+        """
+        Password for authentication with the server where to migrate data from.
+        """
+        return pulumi.get(self, "password")
+
+    @property
+    @pulumi.getter
+    def ssl(self) -> Optional[bool]:
+        """
+        The server where to migrate data from is secured with SSL. The default value is `true`.
+        """
+        return pulumi.get(self, "ssl")
+
+    @property
+    @pulumi.getter
+    def username(self) -> Optional[str]:
+        """
+        User name for authentication with the server where to migrate data from.
+        """
+        return pulumi.get(self, "username")
+
+
+@pulumi.output_type
+class DragonflyDragonflyUserConfigPrivateAccess(dict):
+    def __init__(__self__, *,
+                 dragonfly: Optional[bool] = None,
+                 prometheus: Optional[bool] = None):
+        """
+        :param bool dragonfly: Allow clients to connect to dragonfly with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        :param bool prometheus: Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        if dragonfly is not None:
+            pulumi.set(__self__, "dragonfly", dragonfly)
+        if prometheus is not None:
+            pulumi.set(__self__, "prometheus", prometheus)
+
+    @property
+    @pulumi.getter
+    def dragonfly(self) -> Optional[bool]:
+        """
+        Allow clients to connect to dragonfly with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        return pulumi.get(self, "dragonfly")
+
+    @property
+    @pulumi.getter
+    def prometheus(self) -> Optional[bool]:
+        """
+        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        return pulumi.get(self, "prometheus")
+
+
+@pulumi.output_type
+class DragonflyDragonflyUserConfigPrivatelinkAccess(dict):
+    def __init__(__self__, *,
+                 dragonfly: Optional[bool] = None,
+                 prometheus: Optional[bool] = None):
+        """
+        :param bool dragonfly: Enable dragonfly.
+        :param bool prometheus: Enable prometheus.
+        """
+        if dragonfly is not None:
+            pulumi.set(__self__, "dragonfly", dragonfly)
+        if prometheus is not None:
+            pulumi.set(__self__, "prometheus", prometheus)
+
+    @property
+    @pulumi.getter
+    def dragonfly(self) -> Optional[bool]:
+        """
+        Enable dragonfly.
+        """
+        return pulumi.get(self, "dragonfly")
+
+    @property
+    @pulumi.getter
+    def prometheus(self) -> Optional[bool]:
+        """
+        Enable prometheus.
+        """
+        return pulumi.get(self, "prometheus")
+
+
+@pulumi.output_type
+class DragonflyDragonflyUserConfigPublicAccess(dict):
+    def __init__(__self__, *,
+                 dragonfly: Optional[bool] = None,
+                 prometheus: Optional[bool] = None):
+        """
+        :param bool dragonfly: Allow clients to connect to dragonfly from the public internet for service nodes that are in a project VPC or another type of private network.
+        :param bool prometheus: Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
+        """
+        if dragonfly is not None:
+            pulumi.set(__self__, "dragonfly", dragonfly)
+        if prometheus is not None:
+            pulumi.set(__self__, "prometheus", prometheus)
+
+    @property
+    @pulumi.getter
+    def dragonfly(self) -> Optional[bool]:
+        """
+        Allow clients to connect to dragonfly from the public internet for service nodes that are in a project VPC or another type of private network.
+        """
+        return pulumi.get(self, "dragonfly")
+
+    @property
+    @pulumi.getter
+    def prometheus(self) -> Optional[bool]:
+        """
+        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
+        """
+        return pulumi.get(self, "prometheus")
+
+
+@pulumi.output_type
+class DragonflyServiceIntegration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "integrationType":
+            suggest = "integration_type"
+        elif key == "sourceServiceName":
+            suggest = "source_service_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DragonflyServiceIntegration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DragonflyServiceIntegration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DragonflyServiceIntegration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 integration_type: str,
+                 source_service_name: str):
+        """
+        :param str integration_type: Type of the service integration. The only supported value at the moment is `read_replica`
+        :param str source_service_name: Name of the source service
+        """
+        pulumi.set(__self__, "integration_type", integration_type)
+        pulumi.set(__self__, "source_service_name", source_service_name)
+
+    @property
+    @pulumi.getter(name="integrationType")
+    def integration_type(self) -> str:
+        """
+        Type of the service integration. The only supported value at the moment is `read_replica`
+        """
+        return pulumi.get(self, "integration_type")
+
+    @property
+    @pulumi.getter(name="sourceServiceName")
+    def source_service_name(self) -> str:
+        """
+        Name of the source service
+        """
+        return pulumi.get(self, "source_service_name")
+
+
+@pulumi.output_type
+class DragonflyTag(dict):
+    def __init__(__self__, *,
+                 key: str,
+                 value: str):
+        """
+        :param str key: Service tag key
+        :param str value: Service tag value
+        """
+        pulumi.set(__self__, "key", key)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def key(self) -> str:
+        """
+        Service tag key
+        """
+        return pulumi.get(self, "key")
+
+    @property
+    @pulumi.getter
+    def value(self) -> str:
+        """
+        Service tag value
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class DragonflyTechEmail(dict):
+    def __init__(__self__, *,
+                 email: str):
+        """
+        :param str email: An email address to contact for technical issues
+        """
+        pulumi.set(__self__, "email", email)
+
+    @property
+    @pulumi.getter
+    def email(self) -> str:
+        """
+        An email address to contact for technical issues
+        """
+        return pulumi.get(self, "email")
+
+
 @pulumi.output_type
 class FlinkApplicationVersionSink(dict):
     @staticmethod
@@ -12748,6 +13469,8 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
             suggest = "ism_history_rollover_retention_period"
         elif key == "overrideMainResponseVersion":
             suggest = "override_main_response_version"
+        elif key == "pluginsAlertingFilterByBackendRoles":
+            suggest = "plugins_alerting_filter_by_backend_roles"
         elif key == "reindexRemoteWhitelists":
             suggest = "reindex_remote_whitelists"
         elif key == "scriptMaxCompilationsRate":
@@ -12816,6 +13539,7 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
                  ism_history_rollover_check_period: Optional[int] = None,
                  ism_history_rollover_retention_period: Optional[int] = None,
                  override_main_response_version: Optional[bool] = None,
+                 plugins_alerting_filter_by_backend_roles: Optional[bool] = None,
                  reindex_remote_whitelists: Optional[Sequence[str]] = None,
                  script_max_compilations_rate: Optional[str] = None,
                  search_max_buckets: Optional[int] = None,
@@ -12858,6 +13582,7 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
         :param int ism_history_rollover_check_period: The time between rollover checks for the audit history index in hours. The default value is `8`.
         :param int ism_history_rollover_retention_period: How long audit history indices are kept in days. The default value is `30`.
         :param bool override_main_response_version: Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default is false.
+        :param bool plugins_alerting_filter_by_backend_roles: Enable or disable filtering of alerting by backend roles. Requires Security plugin. Defaults to false.
         :param Sequence[str] reindex_remote_whitelists: Whitelisted addresses for reindexing. Changing this value will cause all OpenSearch instances to restart.
         :param str script_max_compilations_rate: Script compilation circuit breaker limits the number of inline script compilations within a period of time. Default is use-context.
         :param int search_max_buckets: Maximum number of aggregation buckets allowed in a single response. OpenSearch default value is used when this is not defined.
@@ -12927,6 +13652,8 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
             pulumi.set(__self__, "ism_history_rollover_retention_period", ism_history_rollover_retention_period)
         if override_main_response_version is not None:
             pulumi.set(__self__, "override_main_response_version", override_main_response_version)
+        if plugins_alerting_filter_by_backend_roles is not None:
+            pulumi.set(__self__, "plugins_alerting_filter_by_backend_roles", plugins_alerting_filter_by_backend_roles)
         if reindex_remote_whitelists is not None:
             pulumi.set(__self__, "reindex_remote_whitelists", reindex_remote_whitelists)
         if script_max_compilations_rate is not None:
@@ -13172,6 +13899,14 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
         """
         return pulumi.get(self, "override_main_response_version")
 
+    @property
+    @pulumi.getter(name="pluginsAlertingFilterByBackendRoles")
+    def plugins_alerting_filter_by_backend_roles(self) -> Optional[bool]:
+        """
+        Enable or disable filtering of alerting by backend roles. Requires Security plugin. Defaults to false.
+        """
+        return pulumi.get(self, "plugins_alerting_filter_by_backend_roles")
+
     @property
     @pulumi.getter(name="reindexRemoteWhitelists")
     def reindex_remote_whitelists(self) -> Optional[Sequence[str]]:
@@ -14004,6 +14739,61 @@ class OpenSearchTechEmail(dict):
         return pulumi.get(self, "email")
 
 
+@pulumi.output_type
+class OrganizationGroupProjectTimeouts(dict):
+    def __init__(__self__, *,
+                 create: Optional[str] = None,
+                 delete: Optional[str] = None,
+                 read: Optional[str] = None,
+                 update: Optional[str] = None):
+        """
+        :param str create: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        :param str delete: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
+        :param str read: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Read operations occur during any refresh or planning operation when refresh is enabled.
+        :param str update: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+        if create is not None:
+            pulumi.set(__self__, "create", create)
+        if delete is not None:
+            pulumi.set(__self__, "delete", delete)
+        if read is not None:
+            pulumi.set(__self__, "read", read)
+        if update is not None:
+            pulumi.set(__self__, "update", update)
+
+    @property
+    @pulumi.getter
+    def create(self) -> Optional[str]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+        return pulumi.get(self, "create")
+
+    @property
+    @pulumi.getter
+    def delete(self) -> Optional[str]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
+        """
+        return pulumi.get(self, "delete")
+
+    @property
+    @pulumi.getter
+    def read(self) -> Optional[str]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Read operations occur during any refresh or planning operation when refresh is enabled.
+        """
+        return pulumi.get(self, "read")
+
+    @property
+    @pulumi.getter
+    def update(self) -> Optional[str]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+        return pulumi.get(self, "update")
+
+
 @pulumi.output_type
 class OrganizationTimeouts(dict):
     def __init__(__self__, *,
@@ -14059,6 +14849,61 @@ class OrganizationTimeouts(dict):
         return pulumi.get(self, "update")
 
 
+@pulumi.output_type
+class OrganizationUserGroupMemberTimeouts(dict):
+    def __init__(__self__, *,
+                 create: Optional[str] = None,
+                 delete: Optional[str] = None,
+                 read: Optional[str] = None,
+                 update: Optional[str] = None):
+        """
+        :param str create: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        :param str delete: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
+        :param str read: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Read operations occur during any refresh or planning operation when refresh is enabled.
+        :param str update: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+        if create is not None:
+            pulumi.set(__self__, "create", create)
+        if delete is not None:
+            pulumi.set(__self__, "delete", delete)
+        if read is not None:
+            pulumi.set(__self__, "read", read)
+        if update is not None:
+            pulumi.set(__self__, "update", update)
+
+    @property
+    @pulumi.getter
+    def create(self) -> Optional[str]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+        return pulumi.get(self, "create")
+
+    @property
+    @pulumi.getter
+    def delete(self) -> Optional[str]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
+        """
+        return pulumi.get(self, "delete")
+
+    @property
+    @pulumi.getter
+    def read(self) -> Optional[str]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Read operations occur during any refresh or planning operation when refresh is enabled.
+        """
+        return pulumi.get(self, "read")
+
+    @property
+    @pulumi.getter
+    def update(self) -> Optional[str]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+        return pulumi.get(self, "update")
+
+
 @pulumi.output_type
 class PgComponent(dict):
     @staticmethod
@@ -14399,6 +15244,7 @@ class PgPgUserConfig(dict):
                  pg_service_to_fork_from: Optional[str] = None,
                  pg_stat_monitor_enable: Optional[bool] = None,
                  pg_version: Optional[str] = None,
+                 pgaudit: Optional['outputs.PgPgUserConfigPgaudit'] = None,
                  pgbouncer: Optional['outputs.PgPgUserConfigPgbouncer'] = None,
                  pglookout: Optional['outputs.PgPgUserConfigPglookout'] = None,
                  private_access: Optional['outputs.PgPgUserConfigPrivateAccess'] = None,
@@ -14431,6 +15277,7 @@ class PgPgUserConfig(dict):
         :param str pg_service_to_fork_from: Name of the PG Service from which to fork (deprecated, use service*to*fork_from). This has effect only when a new service is being created.
         :param bool pg_stat_monitor_enable: Enable the pg*stat*monitor extension. Enabling this extension will cause the cluster to be restarted.When this extension is enabled, pg*stat*statements results for utility commands are unreliable. The default value is `false`.
         :param str pg_version: PostgreSQL major version.
+        :param 'PgPgUserConfigPgauditArgs' pgaudit: System-wide settings for the pgaudit extension
         :param 'PgPgUserConfigPgbouncerArgs' pgbouncer: PGBouncer connection pooling settings
         :param 'PgPgUserConfigPglookoutArgs' pglookout: System-wide settings for pglookout
         :param 'PgPgUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
@@ -14479,6 +15326,8 @@ class PgPgUserConfig(dict):
             pulumi.set(__self__, "pg_stat_monitor_enable", pg_stat_monitor_enable)
         if pg_version is not None:
             pulumi.set(__self__, "pg_version", pg_version)
+        if pgaudit is not None:
+            pulumi.set(__self__, "pgaudit", pgaudit)
         if pgbouncer is not None:
             pulumi.set(__self__, "pgbouncer", pgbouncer)
         if pglookout is not None:
@@ -14644,6 +15493,14 @@ class PgPgUserConfig(dict):
         """
         return pulumi.get(self, "pg_version")
 
+    @property
+    @pulumi.getter
+    def pgaudit(self) -> Optional['outputs.PgPgUserConfigPgaudit']:
+        """
+        System-wide settings for the pgaudit extension
+        """
+        return pulumi.get(self, "pgaudit")
+
     @property
     @pulumi.getter
     def pgbouncer(self) -> Optional['outputs.PgPgUserConfigPgbouncer']:
@@ -15722,6 +16579,220 @@ class PgPgUserConfigPgQualstats(dict):
         return pulumi.get(self, "track_pg_catalog")
 
 
+@pulumi.output_type
+class PgPgUserConfigPgaudit(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "featureEnabled":
+            suggest = "feature_enabled"
+        elif key == "logCatalog":
+            suggest = "log_catalog"
+        elif key == "logClient":
+            suggest = "log_client"
+        elif key == "logLevel":
+            suggest = "log_level"
+        elif key == "logMaxStringLength":
+            suggest = "log_max_string_length"
+        elif key == "logNestedStatements":
+            suggest = "log_nested_statements"
+        elif key == "logParameter":
+            suggest = "log_parameter"
+        elif key == "logParameterMaxSize":
+            suggest = "log_parameter_max_size"
+        elif key == "logRelation":
+            suggest = "log_relation"
+        elif key == "logRows":
+            suggest = "log_rows"
+        elif key == "logStatement":
+            suggest = "log_statement"
+        elif key == "logStatementOnce":
+            suggest = "log_statement_once"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PgPgUserConfigPgaudit. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PgPgUserConfigPgaudit.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PgPgUserConfigPgaudit.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 feature_enabled: Optional[bool] = None,
+                 log_catalog: Optional[bool] = None,
+                 log_client: Optional[bool] = None,
+                 log_level: Optional[str] = None,
+                 log_max_string_length: Optional[int] = None,
+                 log_nested_statements: Optional[bool] = None,
+                 log_parameter: Optional[bool] = None,
+                 log_parameter_max_size: Optional[int] = None,
+                 log_relation: Optional[bool] = None,
+                 log_rows: Optional[bool] = None,
+                 log_statement: Optional[bool] = None,
+                 log_statement_once: Optional[bool] = None,
+                 logs: Optional[Sequence[str]] = None,
+                 role: Optional[str] = None):
+        """
+        :param bool feature_enabled: Enable pgaudit extension. When enabled, pgaudit extension will be automatically installed.Otherwise, extension will be uninstalled but auditing configurations will be preserved. The default value is `false`.
+        :param bool log_catalog: Specifies that session logging should be enabled in the casewhere all relations in a statement are in pg_catalog. The default value is `true`.
+        :param bool log_client: Specifies whether log messages will be visible to a client process such as psql. The default value is `false`.
+        :param str log_level: Specifies the log level that will be used for log entries. The default value is `log`.
+        :param int log_max_string_length: Crop parameters representation and whole statements if they exceed this threshold. A (default) value of -1 disable the truncation. The default value is `-1`.
+        :param bool log_nested_statements: This GUC allows to turn off logging nested statements, that is, statements that are executed as part of another ExecutorRun. The default value is `true`.
+        :param bool log_parameter: Specifies that audit logging should include the parameters that were passed with the statement. The default value is `false`.
+        :param int log_parameter_max_size: Specifies that parameter values longer than this setting (in bytes) should not be logged, but replaced with \\n\\n. The default value is `0`.
+        :param bool log_relation: Specifies whether session audit logging should create a separate log entry for each relation (TABLE, VIEW, etc.) referenced in a SELECT or DML statement. The default value is `false`.
+        :param bool log_rows: Specifies that audit logging should include the rows retrieved or affected by a statement. When enabled the rows field will be included after the parameter field. The default value is `false`.
+        :param bool log_statement: Specifies whether logging will include the statement text and parameters (if enabled). The default value is `true`.
+        :param bool log_statement_once: Specifies whether logging will include the statement text and parameters with the first log entry for a statement/substatement combination or with every entry. The default value is `false`.
+        :param Sequence[str] logs: Specifies which classes of statements will be logged by session audit logging.
+        :param str role: Specifies the master role to use for object audit logging.
+        """
+        if feature_enabled is not None:
+            pulumi.set(__self__, "feature_enabled", feature_enabled)
+        if log_catalog is not None:
+            pulumi.set(__self__, "log_catalog", log_catalog)
+        if log_client is not None:
+            pulumi.set(__self__, "log_client", log_client)
+        if log_level is not None:
+            pulumi.set(__self__, "log_level", log_level)
+        if log_max_string_length is not None:
+            pulumi.set(__self__, "log_max_string_length", log_max_string_length)
+        if log_nested_statements is not None:
+            pulumi.set(__self__, "log_nested_statements", log_nested_statements)
+        if log_parameter is not None:
+            pulumi.set(__self__, "log_parameter", log_parameter)
+        if log_parameter_max_size is not None:
+            pulumi.set(__self__, "log_parameter_max_size", log_parameter_max_size)
+        if log_relation is not None:
+            pulumi.set(__self__, "log_relation", log_relation)
+        if log_rows is not None:
+            pulumi.set(__self__, "log_rows", log_rows)
+        if log_statement is not None:
+            pulumi.set(__self__, "log_statement", log_statement)
+        if log_statement_once is not None:
+            pulumi.set(__self__, "log_statement_once", log_statement_once)
+        if logs is not None:
+            pulumi.set(__self__, "logs", logs)
+        if role is not None:
+            pulumi.set(__self__, "role", role)
+
+    @property
+    @pulumi.getter(name="featureEnabled")
+    def feature_enabled(self) -> Optional[bool]:
+        """
+        Enable pgaudit extension. When enabled, pgaudit extension will be automatically installed.Otherwise, extension will be uninstalled but auditing configurations will be preserved. The default value is `false`.
+        """
+        return pulumi.get(self, "feature_enabled")
+
+    @property
+    @pulumi.getter(name="logCatalog")
+    def log_catalog(self) -> Optional[bool]:
+        """
+        Specifies that session logging should be enabled in the casewhere all relations in a statement are in pg_catalog. The default value is `true`.
+        """
+        return pulumi.get(self, "log_catalog")
+
+    @property
+    @pulumi.getter(name="logClient")
+    def log_client(self) -> Optional[bool]:
+        """
+        Specifies whether log messages will be visible to a client process such as psql. The default value is `false`.
+        """
+        return pulumi.get(self, "log_client")
+
+    @property
+    @pulumi.getter(name="logLevel")
+    def log_level(self) -> Optional[str]:
+        """
+        Specifies the log level that will be used for log entries. The default value is `log`.
+        """
+        return pulumi.get(self, "log_level")
+
+    @property
+    @pulumi.getter(name="logMaxStringLength")
+    def log_max_string_length(self) -> Optional[int]:
+        """
+        Crop parameters representation and whole statements if they exceed this threshold. A (default) value of -1 disable the truncation. The default value is `-1`.
+        """
+        return pulumi.get(self, "log_max_string_length")
+
+    @property
+    @pulumi.getter(name="logNestedStatements")
+    def log_nested_statements(self) -> Optional[bool]:
+        """
+        This GUC allows to turn off logging nested statements, that is, statements that are executed as part of another ExecutorRun. The default value is `true`.
+        """
+        return pulumi.get(self, "log_nested_statements")
+
+    @property
+    @pulumi.getter(name="logParameter")
+    def log_parameter(self) -> Optional[bool]:
+        """
+        Specifies that audit logging should include the parameters that were passed with the statement. The default value is `false`.
+        """
+        return pulumi.get(self, "log_parameter")
+
+    @property
+    @pulumi.getter(name="logParameterMaxSize")
+    def log_parameter_max_size(self) -> Optional[int]:
+        """
+        Specifies that parameter values longer than this setting (in bytes) should not be logged, but replaced with \\n\\n. The default value is `0`.
+        """
+        return pulumi.get(self, "log_parameter_max_size")
+
+    @property
+    @pulumi.getter(name="logRelation")
+    def log_relation(self) -> Optional[bool]:
+        """
+        Specifies whether session audit logging should create a separate log entry for each relation (TABLE, VIEW, etc.) referenced in a SELECT or DML statement. The default value is `false`.
+        """
+        return pulumi.get(self, "log_relation")
+
+    @property
+    @pulumi.getter(name="logRows")
+    def log_rows(self) -> Optional[bool]:
+        """
+        Specifies that audit logging should include the rows retrieved or affected by a statement. When enabled the rows field will be included after the parameter field. The default value is `false`.
+        """
+        return pulumi.get(self, "log_rows")
+
+    @property
+    @pulumi.getter(name="logStatement")
+    def log_statement(self) -> Optional[bool]:
+        """
+        Specifies whether logging will include the statement text and parameters (if enabled). The default value is `true`.
+        """
+        return pulumi.get(self, "log_statement")
+
+    @property
+    @pulumi.getter(name="logStatementOnce")
+    def log_statement_once(self) -> Optional[bool]:
+        """
+        Specifies whether logging will include the statement text and parameters with the first log entry for a statement/substatement combination or with every entry. The default value is `false`.
+        """
+        return pulumi.get(self, "log_statement_once")
+
+    @property
+    @pulumi.getter
+    def logs(self) -> Optional[Sequence[str]]:
+        """
+        Specifies which classes of statements will be logged by session audit logging.
+        """
+        return pulumi.get(self, "logs")
+
+    @property
+    @pulumi.getter
+    def role(self) -> Optional[str]:
+        """
+        Specifies the master role to use for object audit logging.
+        """
+        return pulumi.get(self, "role")
+
+
 @pulumi.output_type
 class PgPgUserConfigPgbouncer(dict):
     @staticmethod
@@ -17040,7 +18111,7 @@ class ServiceIntegrationClickhouseKafkaUserConfig(dict):
     def __init__(__self__, *,
                  tables: Optional[Sequence['outputs.ServiceIntegrationClickhouseKafkaUserConfigTable']] = None):
         """
-        :param Sequence['ServiceIntegrationClickhouseKafkaUserConfigTableArgs'] tables: Tables to create.
+        :param Sequence['ServiceIntegrationClickhouseKafkaUserConfigTableArgs'] tables: Tables to create
         """
         if tables is not None:
             pulumi.set(__self__, "tables", tables)
@@ -17049,7 +18120,7 @@ class ServiceIntegrationClickhouseKafkaUserConfig(dict):
     @pulumi.getter
     def tables(self) -> Optional[Sequence['outputs.ServiceIntegrationClickhouseKafkaUserConfigTable']]:
         """
-        Tables to create.
+        Tables to create
         """
         return pulumi.get(self, "tables")
 
@@ -17092,25 +18163,26 @@ class ServiceIntegrationClickhouseKafkaUserConfigTable(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 columns: Sequence['outputs.ServiceIntegrationClickhouseKafkaUserConfigTableColumn'],
                  data_format: str,
                  group_name: str,
                  name: str,
+                 topics: Sequence['outputs.ServiceIntegrationClickhouseKafkaUserConfigTableTopic'],
                  auto_offset_reset: Optional[str] = None,
-                 columns: Optional[Sequence['outputs.ServiceIntegrationClickhouseKafkaUserConfigTableColumn']] = None,
                  date_time_input_format: Optional[str] = None,
                  handle_error_mode: Optional[str] = None,
                  max_block_size: Optional[int] = None,
                  max_rows_per_message: Optional[int] = None,
                  num_consumers: Optional[int] = None,
                  poll_max_batch_size: Optional[int] = None,
-                 skip_broken_messages: Optional[int] = None,
-                 topics: Optional[Sequence['outputs.ServiceIntegrationClickhouseKafkaUserConfigTableTopic']] = None):
+                 skip_broken_messages: Optional[int] = None):
         """
+        :param Sequence['ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs'] columns: Table columns
         :param str data_format: Message data format. The default value is `JSONEachRow`.
         :param str group_name: Kafka consumers group. The default value is `clickhouse`.
         :param str name: Column name.
+        :param Sequence['ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs'] topics: Kafka topics
         :param str auto_offset_reset: Action to take when there is no initial offset in offset store or the desired offset is out of range. The default value is `earliest`.
-        :param Sequence['ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs'] columns: Table columns.
         :param str date_time_input_format: Method to read DateTime from text input formats. The default value is `basic`.
         :param str handle_error_mode: How to handle errors for Kafka engine. The default value is `default`.
         :param int max_block_size: Number of row collected by poll(s) for flushing data from Kafka. The default value is `0`.
@@ -17118,15 +18190,14 @@ class ServiceIntegrationClickhouseKafkaUserConfigTable(dict):
         :param int num_consumers: The number of consumers per table per replica. The default value is `1`.
         :param int poll_max_batch_size: Maximum amount of messages to be polled in a single Kafka poll. The default value is `0`.
         :param int skip_broken_messages: Skip at least this number of broken messages from Kafka topic per block. The default value is `0`.
-        :param Sequence['ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs'] topics: Kafka topics.
         """
+        pulumi.set(__self__, "columns", columns)
         pulumi.set(__self__, "data_format", data_format)
         pulumi.set(__self__, "group_name", group_name)
         pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "topics", topics)
         if auto_offset_reset is not None:
             pulumi.set(__self__, "auto_offset_reset", auto_offset_reset)
-        if columns is not None:
-            pulumi.set(__self__, "columns", columns)
         if date_time_input_format is not None:
             pulumi.set(__self__, "date_time_input_format", date_time_input_format)
         if handle_error_mode is not None:
@@ -17141,8 +18212,14 @@ class ServiceIntegrationClickhouseKafkaUserConfigTable(dict):
             pulumi.set(__self__, "poll_max_batch_size", poll_max_batch_size)
         if skip_broken_messages is not None:
             pulumi.set(__self__, "skip_broken_messages", skip_broken_messages)
-        if topics is not None:
-            pulumi.set(__self__, "topics", topics)
+
+    @property
+    @pulumi.getter
+    def columns(self) -> Sequence['outputs.ServiceIntegrationClickhouseKafkaUserConfigTableColumn']:
+        """
+        Table columns
+        """
+        return pulumi.get(self, "columns")
 
     @property
     @pulumi.getter(name="dataFormat")
@@ -17169,20 +18246,20 @@ class ServiceIntegrationClickhouseKafkaUserConfigTable(dict):
         return pulumi.get(self, "name")
 
     @property
-    @pulumi.getter(name="autoOffsetReset")
-    def auto_offset_reset(self) -> Optional[str]:
+    @pulumi.getter
+    def topics(self) -> Sequence['outputs.ServiceIntegrationClickhouseKafkaUserConfigTableTopic']:
         """
-        Action to take when there is no initial offset in offset store or the desired offset is out of range. The default value is `earliest`.
+        Kafka topics
         """
-        return pulumi.get(self, "auto_offset_reset")
+        return pulumi.get(self, "topics")
 
     @property
-    @pulumi.getter
-    def columns(self) -> Optional[Sequence['outputs.ServiceIntegrationClickhouseKafkaUserConfigTableColumn']]:
+    @pulumi.getter(name="autoOffsetReset")
+    def auto_offset_reset(self) -> Optional[str]:
         """
-        Table columns.
+        Action to take when there is no initial offset in offset store or the desired offset is out of range. The default value is `earliest`.
         """
-        return pulumi.get(self, "columns")
+        return pulumi.get(self, "auto_offset_reset")
 
     @property
     @pulumi.getter(name="dateTimeInputFormat")
@@ -17240,14 +18317,6 @@ class ServiceIntegrationClickhouseKafkaUserConfigTable(dict):
         """
         return pulumi.get(self, "skip_broken_messages")
 
-    @property
-    @pulumi.getter
-    def topics(self) -> Optional[Sequence['outputs.ServiceIntegrationClickhouseKafkaUserConfigTableTopic']]:
-        """
-        Kafka topics.
-        """
-        return pulumi.get(self, "topics")
-
 
 @pulumi.output_type
 class ServiceIntegrationClickhouseKafkaUserConfigTableColumn(dict):
@@ -17301,7 +18370,7 @@ class ServiceIntegrationClickhousePostgresqlUserConfig(dict):
     def __init__(__self__, *,
                  databases: Optional[Sequence['outputs.ServiceIntegrationClickhousePostgresqlUserConfigDatabase']] = None):
         """
-        :param Sequence['ServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgs'] databases: Databases to expose.
+        :param Sequence['ServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgs'] databases: Databases to expose
         """
         if databases is not None:
             pulumi.set(__self__, "databases", databases)
@@ -17310,7 +18379,7 @@ class ServiceIntegrationClickhousePostgresqlUserConfig(dict):
     @pulumi.getter
     def databases(self) -> Optional[Sequence['outputs.ServiceIntegrationClickhousePostgresqlUserConfigDatabase']]:
         """
-        Databases to expose.
+        Databases to expose
         """
         return pulumi.get(self, "databases")
 
@@ -17392,15 +18461,15 @@ class ServiceIntegrationDatadogUserConfig(dict):
                  redis: Optional['outputs.ServiceIntegrationDatadogUserConfigRedis'] = None):
         """
         :param bool datadog_dbm_enabled: Enable Datadog Database Monitoring.
-        :param Sequence['ServiceIntegrationDatadogUserConfigDatadogTagArgs'] datadog_tags: Custom tags provided by user.
+        :param Sequence['ServiceIntegrationDatadogUserConfigDatadogTagArgs'] datadog_tags: Custom tags provided by user
         :param Sequence[str] exclude_consumer_groups: List of custom metrics.
         :param Sequence[str] exclude_topics: List of topics to exclude.
         :param Sequence[str] include_consumer_groups: List of custom metrics.
         :param Sequence[str] include_topics: List of topics to include.
         :param Sequence[str] kafka_custom_metrics: List of custom metrics.
         :param int max_jmx_metrics: Maximum number of JMX metrics to send.
-        :param 'ServiceIntegrationDatadogUserConfigOpensearchArgs' opensearch: Datadog Opensearch Options.
-        :param 'ServiceIntegrationDatadogUserConfigRedisArgs' redis: Datadog Redis Options.
+        :param 'ServiceIntegrationDatadogUserConfigOpensearchArgs' opensearch: Datadog Opensearch Options
+        :param 'ServiceIntegrationDatadogUserConfigRedisArgs' redis: Datadog Redis Options
         """
         if datadog_dbm_enabled is not None:
             pulumi.set(__self__, "datadog_dbm_enabled", datadog_dbm_enabled)
@@ -17435,7 +18504,7 @@ class ServiceIntegrationDatadogUserConfig(dict):
     @pulumi.getter(name="datadogTags")
     def datadog_tags(self) -> Optional[Sequence['outputs.ServiceIntegrationDatadogUserConfigDatadogTag']]:
         """
-        Custom tags provided by user.
+        Custom tags provided by user
         """
         return pulumi.get(self, "datadog_tags")
 
@@ -17491,7 +18560,7 @@ class ServiceIntegrationDatadogUserConfig(dict):
     @pulumi.getter
     def opensearch(self) -> Optional['outputs.ServiceIntegrationDatadogUserConfigOpensearch']:
         """
-        Datadog Opensearch Options.
+        Datadog Opensearch Options
         """
         return pulumi.get(self, "opensearch")
 
@@ -17499,7 +18568,7 @@ class ServiceIntegrationDatadogUserConfig(dict):
     @pulumi.getter
     def redis(self) -> Optional['outputs.ServiceIntegrationDatadogUserConfigRedis']:
         """
-        Datadog Redis Options.
+        Datadog Redis Options
         """
         return pulumi.get(self, "redis")
 
@@ -17673,7 +18742,7 @@ class ServiceIntegrationEndpointDatadogUserConfig(dict):
                  site: Optional[str] = None):
         """
         :param str datadog_api_key: Datadog API key.
-        :param Sequence['ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgs'] datadog_tags: Custom tags provided by user.
+        :param Sequence['ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgs'] datadog_tags: Custom tags provided by user
         :param bool disable_consumer_stats: Disable consumer group metrics.
         :param int kafka_consumer_check_instances: Number of separate instances to fetch kafka consumer statistics with.
         :param int kafka_consumer_stats_timeout: Number of seconds that datadog will wait to get consumer statistics from brokers.
@@ -17706,7 +18775,7 @@ class ServiceIntegrationEndpointDatadogUserConfig(dict):
     @pulumi.getter(name="datadogTags")
     def datadog_tags(self) -> Optional[Sequence['outputs.ServiceIntegrationEndpointDatadogUserConfigDatadogTag']]:
         """
-        Custom tags provided by user.
+        Custom tags provided by user
         """
         return pulumi.get(self, "datadog_tags")
 
@@ -18352,7 +19421,9 @@ class ServiceIntegrationEndpointExternalPostgresql(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "sslClientCertificate":
+        if key == "defaultDatabase":
+            suggest = "default_database"
+        elif key == "sslClientCertificate":
             suggest = "ssl_client_certificate"
         elif key == "sslClientKey":
             suggest = "ssl_client_key"
@@ -18376,6 +19447,7 @@ class ServiceIntegrationEndpointExternalPostgresql(dict):
                  host: str,
                  port: int,
                  username: str,
+                 default_database: Optional[str] = None,
                  password: Optional[str] = None,
                  ssl_client_certificate: Optional[str] = None,
                  ssl_client_key: Optional[str] = None,
@@ -18385,6 +19457,7 @@ class ServiceIntegrationEndpointExternalPostgresql(dict):
         :param str host: Hostname or IP address of the server.
         :param int port: Port number of the server.
         :param str username: User name.
+        :param str default_database: Default database.
         :param str password: Password.
         :param str ssl_client_certificate: Client certificate.
         :param str ssl_client_key: Client key.
@@ -18394,6 +19467,8 @@ class ServiceIntegrationEndpointExternalPostgresql(dict):
         pulumi.set(__self__, "host", host)
         pulumi.set(__self__, "port", port)
         pulumi.set(__self__, "username", username)
+        if default_database is not None:
+            pulumi.set(__self__, "default_database", default_database)
         if password is not None:
             pulumi.set(__self__, "password", password)
         if ssl_client_certificate is not None:
@@ -18429,6 +19504,14 @@ class ServiceIntegrationEndpointExternalPostgresql(dict):
         """
         return pulumi.get(self, "username")
 
+    @property
+    @pulumi.getter(name="defaultDatabase")
+    def default_database(self) -> Optional[str]:
+        """
+        Default database.
+        """
+        return pulumi.get(self, "default_database")
+
     @property
     @pulumi.getter
     def password(self) -> Optional[str]:
@@ -18782,6 +19865,42 @@ class ServiceIntegrationEndpointRsyslogUserConfig(dict):
         return pulumi.get(self, "sd")
 
 
+@pulumi.output_type
+class ServiceIntegrationExternalAwsCloudwatchLogsUserConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "selectedLogFields":
+            suggest = "selected_log_fields"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServiceIntegrationExternalAwsCloudwatchLogsUserConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServiceIntegrationExternalAwsCloudwatchLogsUserConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServiceIntegrationExternalAwsCloudwatchLogsUserConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 selected_log_fields: Optional[Sequence[str]] = None):
+        """
+        :param Sequence[str] selected_log_fields: The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
+        """
+        if selected_log_fields is not None:
+            pulumi.set(__self__, "selected_log_fields", selected_log_fields)
+
+    @property
+    @pulumi.getter(name="selectedLogFields")
+    def selected_log_fields(self) -> Optional[Sequence[str]]:
+        """
+        The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
+        """
+        return pulumi.get(self, "selected_log_fields")
+
+
 @pulumi.output_type
 class ServiceIntegrationExternalAwsCloudwatchMetricsUserConfig(dict):
     @staticmethod
@@ -18807,8 +19926,8 @@ class ServiceIntegrationExternalAwsCloudwatchMetricsUserConfig(dict):
                  dropped_metrics: Optional[Sequence['outputs.ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetric']] = None,
                  extra_metrics: Optional[Sequence['outputs.ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetric']] = None):
         """
-        :param Sequence['ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricArgs'] dropped_metrics: Metrics to not send to AWS CloudWatch (takes precedence over extra*metrics).
-        :param Sequence['ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricArgs'] extra_metrics: Metrics to allow through to AWS CloudWatch (in addition to default metrics).
+        :param Sequence['ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricArgs'] dropped_metrics: Metrics to not send to AWS CloudWatch (takes precedence over extra*metrics)
+        :param Sequence['ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricArgs'] extra_metrics: Metrics to allow through to AWS CloudWatch (in addition to default metrics)
         """
         if dropped_metrics is not None:
             pulumi.set(__self__, "dropped_metrics", dropped_metrics)
@@ -18819,7 +19938,7 @@ class ServiceIntegrationExternalAwsCloudwatchMetricsUserConfig(dict):
     @pulumi.getter(name="droppedMetrics")
     def dropped_metrics(self) -> Optional[Sequence['outputs.ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetric']]:
         """
-        Metrics to not send to AWS CloudWatch (takes precedence over extra*metrics).
+        Metrics to not send to AWS CloudWatch (takes precedence over extra*metrics)
         """
         return pulumi.get(self, "dropped_metrics")
 
@@ -18827,7 +19946,7 @@ class ServiceIntegrationExternalAwsCloudwatchMetricsUserConfig(dict):
     @pulumi.getter(name="extraMetrics")
     def extra_metrics(self) -> Optional[Sequence['outputs.ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetric']]:
         """
-        Metrics to allow through to AWS CloudWatch (in addition to default metrics).
+        Metrics to allow through to AWS CloudWatch (in addition to default metrics)
         """
         return pulumi.get(self, "extra_metrics")
 
@@ -18890,6 +20009,78 @@ class ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetric(dict):
         return pulumi.get(self, "metric")
 
 
+@pulumi.output_type
+class ServiceIntegrationExternalElasticsearchLogsUserConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "selectedLogFields":
+            suggest = "selected_log_fields"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServiceIntegrationExternalElasticsearchLogsUserConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServiceIntegrationExternalElasticsearchLogsUserConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServiceIntegrationExternalElasticsearchLogsUserConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 selected_log_fields: Optional[Sequence[str]] = None):
+        """
+        :param Sequence[str] selected_log_fields: The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
+        """
+        if selected_log_fields is not None:
+            pulumi.set(__self__, "selected_log_fields", selected_log_fields)
+
+    @property
+    @pulumi.getter(name="selectedLogFields")
+    def selected_log_fields(self) -> Optional[Sequence[str]]:
+        """
+        The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
+        """
+        return pulumi.get(self, "selected_log_fields")
+
+
+@pulumi.output_type
+class ServiceIntegrationExternalOpensearchLogsUserConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "selectedLogFields":
+            suggest = "selected_log_fields"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServiceIntegrationExternalOpensearchLogsUserConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServiceIntegrationExternalOpensearchLogsUserConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServiceIntegrationExternalOpensearchLogsUserConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 selected_log_fields: Optional[Sequence[str]] = None):
+        """
+        :param Sequence[str] selected_log_fields: The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
+        """
+        if selected_log_fields is not None:
+            pulumi.set(__self__, "selected_log_fields", selected_log_fields)
+
+    @property
+    @pulumi.getter(name="selectedLogFields")
+    def selected_log_fields(self) -> Optional[Sequence[str]]:
+        """
+        The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
+        """
+        return pulumi.get(self, "selected_log_fields")
+
+
 @pulumi.output_type
 class ServiceIntegrationKafkaConnectUserConfig(dict):
     @staticmethod
@@ -18912,7 +20103,7 @@ class ServiceIntegrationKafkaConnectUserConfig(dict):
     def __init__(__self__, *,
                  kafka_connect: Optional['outputs.ServiceIntegrationKafkaConnectUserConfigKafkaConnect'] = None):
         """
-        :param 'ServiceIntegrationKafkaConnectUserConfigKafkaConnectArgs' kafka_connect: Kafka Connect service configuration values.
+        :param 'ServiceIntegrationKafkaConnectUserConfigKafkaConnectArgs' kafka_connect: Kafka Connect service configuration values
         """
         if kafka_connect is not None:
             pulumi.set(__self__, "kafka_connect", kafka_connect)
@@ -18921,7 +20112,7 @@ class ServiceIntegrationKafkaConnectUserConfig(dict):
     @pulumi.getter(name="kafkaConnect")
     def kafka_connect(self) -> Optional['outputs.ServiceIntegrationKafkaConnectUserConfigKafkaConnect']:
         """
-        Kafka Connect service configuration values.
+        Kafka Connect service configuration values
         """
         return pulumi.get(self, "kafka_connect")
 
@@ -19079,7 +20270,7 @@ class ServiceIntegrationKafkaMirrormakerUserConfig(dict):
                  kafka_mirrormaker: Optional['outputs.ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormaker'] = None):
         """
         :param str cluster_alias: The alias under which the Kafka cluster is known to MirrorMaker. Can contain the following symbols: ASCII alphanumerics, '.', '_', and '-'.
-        :param 'ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgs' kafka_mirrormaker: Kafka MirrorMaker configuration values.
+        :param 'ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgs' kafka_mirrormaker: Kafka MirrorMaker configuration values
         """
         if cluster_alias is not None:
             pulumi.set(__self__, "cluster_alias", cluster_alias)
@@ -19098,7 +20289,7 @@ class ServiceIntegrationKafkaMirrormakerUserConfig(dict):
     @pulumi.getter(name="kafkaMirrormaker")
     def kafka_mirrormaker(self) -> Optional['outputs.ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormaker']:
         """
-        Kafka MirrorMaker configuration values.
+        Kafka MirrorMaker configuration values
         """
         return pulumi.get(self, "kafka_mirrormaker")
 
@@ -19306,7 +20497,7 @@ class ServiceIntegrationMetricsUserConfig(dict):
         :param str database: Name of the database where to store metric datapoints. Only affects PostgreSQL destinations. Defaults to 'metrics'. Note that this must be the same for all metrics integrations that write data to the same PostgreSQL service.
         :param int retention_days: Number of days to keep old metrics. Only affects PostgreSQL destinations. Set to 0 for no automatic cleanup. Defaults to 30 days.
         :param str ro_username: Name of a user that can be used to read metrics. This will be used for Grafana integration (if enabled) to prevent Grafana users from making undesired changes. Only affects PostgreSQL destinations. Defaults to 'metrics_reader'. Note that this must be the same for all metrics integrations that write data to the same PostgreSQL service.
-        :param 'ServiceIntegrationMetricsUserConfigSourceMysqlArgs' source_mysql: Configuration options for metrics where source service is MySQL.
+        :param 'ServiceIntegrationMetricsUserConfigSourceMysqlArgs' source_mysql: Configuration options for metrics where source service is MySQL
         :param str username: Name of the user used to write metrics. Only affects PostgreSQL destinations. Defaults to 'metrics_writer'. Note that this must be the same for all metrics integrations that write data to the same PostgreSQL service.
         """
         if database is not None:
@@ -19342,46 +20533,319 @@ class ServiceIntegrationMetricsUserConfig(dict):
         """
         Name of a user that can be used to read metrics. This will be used for Grafana integration (if enabled) to prevent Grafana users from making undesired changes. Only affects PostgreSQL destinations. Defaults to 'metrics_reader'. Note that this must be the same for all metrics integrations that write data to the same PostgreSQL service.
         """
-        return pulumi.get(self, "ro_username")
+        return pulumi.get(self, "ro_username")
+
+    @property
+    @pulumi.getter(name="sourceMysql")
+    def source_mysql(self) -> Optional['outputs.ServiceIntegrationMetricsUserConfigSourceMysql']:
+        """
+        Configuration options for metrics where source service is MySQL
+        """
+        return pulumi.get(self, "source_mysql")
+
+    @property
+    @pulumi.getter
+    def username(self) -> Optional[str]:
+        """
+        Name of the user used to write metrics. Only affects PostgreSQL destinations. Defaults to 'metrics_writer'. Note that this must be the same for all metrics integrations that write data to the same PostgreSQL service.
+        """
+        return pulumi.get(self, "username")
+
+
+@pulumi.output_type
+class ServiceIntegrationMetricsUserConfigSourceMysql(dict):
+    def __init__(__self__, *,
+                 telegraf: Optional['outputs.ServiceIntegrationMetricsUserConfigSourceMysqlTelegraf'] = None):
+        """
+        :param 'ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgs' telegraf: Configuration options for Telegraf MySQL input plugin
+        """
+        if telegraf is not None:
+            pulumi.set(__self__, "telegraf", telegraf)
+
+    @property
+    @pulumi.getter
+    def telegraf(self) -> Optional['outputs.ServiceIntegrationMetricsUserConfigSourceMysqlTelegraf']:
+        """
+        Configuration options for Telegraf MySQL input plugin
+        """
+        return pulumi.get(self, "telegraf")
+
+
+@pulumi.output_type
+class ServiceIntegrationMetricsUserConfigSourceMysqlTelegraf(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "gatherEventWaits":
+            suggest = "gather_event_waits"
+        elif key == "gatherFileEventsStats":
+            suggest = "gather_file_events_stats"
+        elif key == "gatherIndexIoWaits":
+            suggest = "gather_index_io_waits"
+        elif key == "gatherInfoSchemaAutoInc":
+            suggest = "gather_info_schema_auto_inc"
+        elif key == "gatherInnodbMetrics":
+            suggest = "gather_innodb_metrics"
+        elif key == "gatherPerfEventsStatements":
+            suggest = "gather_perf_events_statements"
+        elif key == "gatherProcessList":
+            suggest = "gather_process_list"
+        elif key == "gatherSlaveStatus":
+            suggest = "gather_slave_status"
+        elif key == "gatherTableIoWaits":
+            suggest = "gather_table_io_waits"
+        elif key == "gatherTableLockWaits":
+            suggest = "gather_table_lock_waits"
+        elif key == "gatherTableSchema":
+            suggest = "gather_table_schema"
+        elif key == "perfEventsStatementsDigestTextLimit":
+            suggest = "perf_events_statements_digest_text_limit"
+        elif key == "perfEventsStatementsLimit":
+            suggest = "perf_events_statements_limit"
+        elif key == "perfEventsStatementsTimeLimit":
+            suggest = "perf_events_statements_time_limit"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServiceIntegrationMetricsUserConfigSourceMysqlTelegraf. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServiceIntegrationMetricsUserConfigSourceMysqlTelegraf.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServiceIntegrationMetricsUserConfigSourceMysqlTelegraf.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 gather_event_waits: Optional[bool] = None,
+                 gather_file_events_stats: Optional[bool] = None,
+                 gather_index_io_waits: Optional[bool] = None,
+                 gather_info_schema_auto_inc: Optional[bool] = None,
+                 gather_innodb_metrics: Optional[bool] = None,
+                 gather_perf_events_statements: Optional[bool] = None,
+                 gather_process_list: Optional[bool] = None,
+                 gather_slave_status: Optional[bool] = None,
+                 gather_table_io_waits: Optional[bool] = None,
+                 gather_table_lock_waits: Optional[bool] = None,
+                 gather_table_schema: Optional[bool] = None,
+                 perf_events_statements_digest_text_limit: Optional[int] = None,
+                 perf_events_statements_limit: Optional[int] = None,
+                 perf_events_statements_time_limit: Optional[int] = None):
+        """
+        :param bool gather_event_waits: Gather metrics from PERFORMANCE*SCHEMA.EVENT*WAITS.
+        :param bool gather_file_events_stats: gather metrics from PERFORMANCE*SCHEMA.FILE*SUMMARY*BY*EVENT_NAME.
+        :param bool gather_index_io_waits: Gather metrics from PERFORMANCE*SCHEMA.TABLE*IO*WAITS*SUMMARY*BY*INDEX_USAGE.
+        :param bool gather_info_schema_auto_inc: Gather auto_increment columns and max values from information schema.
+        :param bool gather_innodb_metrics: Gather metrics from INFORMATION*SCHEMA.INNODB*METRICS.
+        :param bool gather_perf_events_statements: Gather metrics from PERFORMANCE*SCHEMA.EVENTS*STATEMENTS*SUMMARY*BY_DIGEST.
+        :param bool gather_process_list: Gather thread state counts from INFORMATION_SCHEMA.PROCESSLIST.
+        :param bool gather_slave_status: Gather metrics from SHOW SLAVE STATUS command output.
+        :param bool gather_table_io_waits: Gather metrics from PERFORMANCE*SCHEMA.TABLE*IO*WAITS*SUMMARY*BY*TABLE.
+        :param bool gather_table_lock_waits: Gather metrics from PERFORMANCE*SCHEMA.TABLE*LOCK_WAITS.
+        :param bool gather_table_schema: Gather metrics from INFORMATION_SCHEMA.TABLES.
+        :param int perf_events_statements_digest_text_limit: Truncates digest text from perf*events*statements into this many characters.
+        :param int perf_events_statements_limit: Limits metrics from perf*events*statements.
+        :param int perf_events_statements_time_limit: Only include perf*events*statements whose last seen is less than this many seconds.
+        """
+        if gather_event_waits is not None:
+            pulumi.set(__self__, "gather_event_waits", gather_event_waits)
+        if gather_file_events_stats is not None:
+            pulumi.set(__self__, "gather_file_events_stats", gather_file_events_stats)
+        if gather_index_io_waits is not None:
+            pulumi.set(__self__, "gather_index_io_waits", gather_index_io_waits)
+        if gather_info_schema_auto_inc is not None:
+            pulumi.set(__self__, "gather_info_schema_auto_inc", gather_info_schema_auto_inc)
+        if gather_innodb_metrics is not None:
+            pulumi.set(__self__, "gather_innodb_metrics", gather_innodb_metrics)
+        if gather_perf_events_statements is not None:
+            pulumi.set(__self__, "gather_perf_events_statements", gather_perf_events_statements)
+        if gather_process_list is not None:
+            pulumi.set(__self__, "gather_process_list", gather_process_list)
+        if gather_slave_status is not None:
+            pulumi.set(__self__, "gather_slave_status", gather_slave_status)
+        if gather_table_io_waits is not None:
+            pulumi.set(__self__, "gather_table_io_waits", gather_table_io_waits)
+        if gather_table_lock_waits is not None:
+            pulumi.set(__self__, "gather_table_lock_waits", gather_table_lock_waits)
+        if gather_table_schema is not None:
+            pulumi.set(__self__, "gather_table_schema", gather_table_schema)
+        if perf_events_statements_digest_text_limit is not None:
+            pulumi.set(__self__, "perf_events_statements_digest_text_limit", perf_events_statements_digest_text_limit)
+        if perf_events_statements_limit is not None:
+            pulumi.set(__self__, "perf_events_statements_limit", perf_events_statements_limit)
+        if perf_events_statements_time_limit is not None:
+            pulumi.set(__self__, "perf_events_statements_time_limit", perf_events_statements_time_limit)
+
+    @property
+    @pulumi.getter(name="gatherEventWaits")
+    def gather_event_waits(self) -> Optional[bool]:
+        """
+        Gather metrics from PERFORMANCE*SCHEMA.EVENT*WAITS.
+        """
+        return pulumi.get(self, "gather_event_waits")
+
+    @property
+    @pulumi.getter(name="gatherFileEventsStats")
+    def gather_file_events_stats(self) -> Optional[bool]:
+        """
+        gather metrics from PERFORMANCE*SCHEMA.FILE*SUMMARY*BY*EVENT_NAME.
+        """
+        return pulumi.get(self, "gather_file_events_stats")
+
+    @property
+    @pulumi.getter(name="gatherIndexIoWaits")
+    def gather_index_io_waits(self) -> Optional[bool]:
+        """
+        Gather metrics from PERFORMANCE*SCHEMA.TABLE*IO*WAITS*SUMMARY*BY*INDEX_USAGE.
+        """
+        return pulumi.get(self, "gather_index_io_waits")
+
+    @property
+    @pulumi.getter(name="gatherInfoSchemaAutoInc")
+    def gather_info_schema_auto_inc(self) -> Optional[bool]:
+        """
+        Gather auto_increment columns and max values from information schema.
+        """
+        return pulumi.get(self, "gather_info_schema_auto_inc")
+
+    @property
+    @pulumi.getter(name="gatherInnodbMetrics")
+    def gather_innodb_metrics(self) -> Optional[bool]:
+        """
+        Gather metrics from INFORMATION*SCHEMA.INNODB*METRICS.
+        """
+        return pulumi.get(self, "gather_innodb_metrics")
+
+    @property
+    @pulumi.getter(name="gatherPerfEventsStatements")
+    def gather_perf_events_statements(self) -> Optional[bool]:
+        """
+        Gather metrics from PERFORMANCE*SCHEMA.EVENTS*STATEMENTS*SUMMARY*BY_DIGEST.
+        """
+        return pulumi.get(self, "gather_perf_events_statements")
+
+    @property
+    @pulumi.getter(name="gatherProcessList")
+    def gather_process_list(self) -> Optional[bool]:
+        """
+        Gather thread state counts from INFORMATION_SCHEMA.PROCESSLIST.
+        """
+        return pulumi.get(self, "gather_process_list")
+
+    @property
+    @pulumi.getter(name="gatherSlaveStatus")
+    def gather_slave_status(self) -> Optional[bool]:
+        """
+        Gather metrics from SHOW SLAVE STATUS command output.
+        """
+        return pulumi.get(self, "gather_slave_status")
+
+    @property
+    @pulumi.getter(name="gatherTableIoWaits")
+    def gather_table_io_waits(self) -> Optional[bool]:
+        """
+        Gather metrics from PERFORMANCE*SCHEMA.TABLE*IO*WAITS*SUMMARY*BY*TABLE.
+        """
+        return pulumi.get(self, "gather_table_io_waits")
+
+    @property
+    @pulumi.getter(name="gatherTableLockWaits")
+    def gather_table_lock_waits(self) -> Optional[bool]:
+        """
+        Gather metrics from PERFORMANCE*SCHEMA.TABLE*LOCK_WAITS.
+        """
+        return pulumi.get(self, "gather_table_lock_waits")
+
+    @property
+    @pulumi.getter(name="gatherTableSchema")
+    def gather_table_schema(self) -> Optional[bool]:
+        """
+        Gather metrics from INFORMATION_SCHEMA.TABLES.
+        """
+        return pulumi.get(self, "gather_table_schema")
+
+    @property
+    @pulumi.getter(name="perfEventsStatementsDigestTextLimit")
+    def perf_events_statements_digest_text_limit(self) -> Optional[int]:
+        """
+        Truncates digest text from perf*events*statements into this many characters.
+        """
+        return pulumi.get(self, "perf_events_statements_digest_text_limit")
+
+    @property
+    @pulumi.getter(name="perfEventsStatementsLimit")
+    def perf_events_statements_limit(self) -> Optional[int]:
+        """
+        Limits metrics from perf*events*statements.
+        """
+        return pulumi.get(self, "perf_events_statements_limit")
+
+    @property
+    @pulumi.getter(name="perfEventsStatementsTimeLimit")
+    def perf_events_statements_time_limit(self) -> Optional[int]:
+        """
+        Only include perf*events*statements whose last seen is less than this many seconds.
+        """
+        return pulumi.get(self, "perf_events_statements_time_limit")
+
+
+@pulumi.output_type
+class ServiceIntegrationPrometheusUserConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "sourceMysql":
+            suggest = "source_mysql"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServiceIntegrationPrometheusUserConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServiceIntegrationPrometheusUserConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServiceIntegrationPrometheusUserConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 source_mysql: Optional['outputs.ServiceIntegrationPrometheusUserConfigSourceMysql'] = None):
+        """
+        :param 'ServiceIntegrationPrometheusUserConfigSourceMysqlArgs' source_mysql: Configuration options for metrics where source service is MySQL
+        """
+        if source_mysql is not None:
+            pulumi.set(__self__, "source_mysql", source_mysql)
 
     @property
     @pulumi.getter(name="sourceMysql")
-    def source_mysql(self) -> Optional['outputs.ServiceIntegrationMetricsUserConfigSourceMysql']:
+    def source_mysql(self) -> Optional['outputs.ServiceIntegrationPrometheusUserConfigSourceMysql']:
         """
-        Configuration options for metrics where source service is MySQL.
+        Configuration options for metrics where source service is MySQL
         """
         return pulumi.get(self, "source_mysql")
 
-    @property
-    @pulumi.getter
-    def username(self) -> Optional[str]:
-        """
-        Name of the user used to write metrics. Only affects PostgreSQL destinations. Defaults to 'metrics_writer'. Note that this must be the same for all metrics integrations that write data to the same PostgreSQL service.
-        """
-        return pulumi.get(self, "username")
-
 
 @pulumi.output_type
-class ServiceIntegrationMetricsUserConfigSourceMysql(dict):
+class ServiceIntegrationPrometheusUserConfigSourceMysql(dict):
     def __init__(__self__, *,
-                 telegraf: Optional['outputs.ServiceIntegrationMetricsUserConfigSourceMysqlTelegraf'] = None):
+                 telegraf: Optional['outputs.ServiceIntegrationPrometheusUserConfigSourceMysqlTelegraf'] = None):
         """
-        :param 'ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgs' telegraf: Configuration options for Telegraf MySQL input plugin.
+        :param 'ServiceIntegrationPrometheusUserConfigSourceMysqlTelegrafArgs' telegraf: Configuration options for Telegraf MySQL input plugin
         """
         if telegraf is not None:
             pulumi.set(__self__, "telegraf", telegraf)
 
     @property
     @pulumi.getter
-    def telegraf(self) -> Optional['outputs.ServiceIntegrationMetricsUserConfigSourceMysqlTelegraf']:
+    def telegraf(self) -> Optional['outputs.ServiceIntegrationPrometheusUserConfigSourceMysqlTelegraf']:
         """
-        Configuration options for Telegraf MySQL input plugin.
+        Configuration options for Telegraf MySQL input plugin
         """
         return pulumi.get(self, "telegraf")
 
 
 @pulumi.output_type
-class ServiceIntegrationMetricsUserConfigSourceMysqlTelegraf(dict):
+class ServiceIntegrationPrometheusUserConfigSourceMysqlTelegraf(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
@@ -19415,14 +20879,14 @@ class ServiceIntegrationMetricsUserConfigSourceMysqlTelegraf(dict):
             suggest = "perf_events_statements_time_limit"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ServiceIntegrationMetricsUserConfigSourceMysqlTelegraf. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in ServiceIntegrationPrometheusUserConfigSourceMysqlTelegraf. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        ServiceIntegrationMetricsUserConfigSourceMysqlTelegraf.__key_warning(key)
+        ServiceIntegrationPrometheusUserConfigSourceMysqlTelegraf.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        ServiceIntegrationMetricsUserConfigSourceMysqlTelegraf.__key_warning(key)
+        ServiceIntegrationPrometheusUserConfigSourceMysqlTelegraf.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
@@ -19920,7 +21384,500 @@ class GetCassandaCassandraUserConfigCassandraResult(dict):
 
 
 @pulumi.output_type
-class GetCassandaCassandraUserConfigIpFilterObjectResult(dict):
+class GetCassandaCassandraUserConfigIpFilterObjectResult(dict):
+    def __init__(__self__, *,
+                 network: str,
+                 description: Optional[str] = None):
+        """
+        :param str network: CIDR address block.
+        :param str description: Description for IP filter list entry.
+        """
+        pulumi.set(__self__, "network", network)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def network(self) -> str:
+        """
+        CIDR address block.
+        """
+        return pulumi.get(self, "network")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[str]:
+        """
+        Description for IP filter list entry.
+        """
+        return pulumi.get(self, "description")
+
+
+@pulumi.output_type
+class GetCassandaCassandraUserConfigPrivateAccessResult(dict):
+    def __init__(__self__, *,
+                 prometheus: Optional[bool] = None):
+        """
+        :param bool prometheus: Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        if prometheus is not None:
+            pulumi.set(__self__, "prometheus", prometheus)
+
+    @property
+    @pulumi.getter
+    def prometheus(self) -> Optional[bool]:
+        """
+        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        return pulumi.get(self, "prometheus")
+
+
+@pulumi.output_type
+class GetCassandaCassandraUserConfigPublicAccessResult(dict):
+    def __init__(__self__, *,
+                 prometheus: Optional[bool] = None):
+        """
+        :param bool prometheus: Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
+        """
+        if prometheus is not None:
+            pulumi.set(__self__, "prometheus", prometheus)
+
+    @property
+    @pulumi.getter
+    def prometheus(self) -> Optional[bool]:
+        """
+        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
+        """
+        return pulumi.get(self, "prometheus")
+
+
+@pulumi.output_type
+class GetCassandaComponentResult(dict):
+    def __init__(__self__, *,
+                 component: str,
+                 connection_uri: str,
+                 host: str,
+                 kafka_authentication_method: str,
+                 port: int,
+                 route: str,
+                 ssl: bool,
+                 usage: str):
+        """
+        :param str component: Service component name
+        :param str connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
+        :param str host: Host name for connecting to the service component
+        :param str kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
+        :param int port: Port number for connecting to the service component
+        :param str route: Network access route
+        :param bool ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
+        :param str usage: DNS usage name
+        """
+        pulumi.set(__self__, "component", component)
+        pulumi.set(__self__, "connection_uri", connection_uri)
+        pulumi.set(__self__, "host", host)
+        pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
+        pulumi.set(__self__, "port", port)
+        pulumi.set(__self__, "route", route)
+        pulumi.set(__self__, "ssl", ssl)
+        pulumi.set(__self__, "usage", usage)
+
+    @property
+    @pulumi.getter
+    def component(self) -> str:
+        """
+        Service component name
+        """
+        return pulumi.get(self, "component")
+
+    @property
+    @pulumi.getter(name="connectionUri")
+    def connection_uri(self) -> str:
+        """
+        Connection info for connecting to the service component. This is a combination of host and port.
+        """
+        return pulumi.get(self, "connection_uri")
+
+    @property
+    @pulumi.getter
+    def host(self) -> str:
+        """
+        Host name for connecting to the service component
+        """
+        return pulumi.get(self, "host")
+
+    @property
+    @pulumi.getter(name="kafkaAuthenticationMethod")
+    def kafka_authentication_method(self) -> str:
+        """
+        Kafka authentication method. This is a value specific to the 'kafka' service component
+        """
+        return pulumi.get(self, "kafka_authentication_method")
+
+    @property
+    @pulumi.getter
+    def port(self) -> int:
+        """
+        Port number for connecting to the service component
+        """
+        return pulumi.get(self, "port")
+
+    @property
+    @pulumi.getter
+    def route(self) -> str:
+        """
+        Network access route
+        """
+        return pulumi.get(self, "route")
+
+    @property
+    @pulumi.getter
+    def ssl(self) -> bool:
+        """
+        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
+        """
+        return pulumi.get(self, "ssl")
+
+    @property
+    @pulumi.getter
+    def usage(self) -> str:
+        """
+        DNS usage name
+        """
+        return pulumi.get(self, "usage")
+
+
+@pulumi.output_type
+class GetCassandaServiceIntegrationResult(dict):
+    def __init__(__self__, *,
+                 integration_type: str,
+                 source_service_name: str):
+        """
+        :param str integration_type: Type of the service integration. The only supported value at the moment is `read_replica`
+        :param str source_service_name: Name of the source service
+        """
+        pulumi.set(__self__, "integration_type", integration_type)
+        pulumi.set(__self__, "source_service_name", source_service_name)
+
+    @property
+    @pulumi.getter(name="integrationType")
+    def integration_type(self) -> str:
+        """
+        Type of the service integration. The only supported value at the moment is `read_replica`
+        """
+        return pulumi.get(self, "integration_type")
+
+    @property
+    @pulumi.getter(name="sourceServiceName")
+    def source_service_name(self) -> str:
+        """
+        Name of the source service
+        """
+        return pulumi.get(self, "source_service_name")
+
+
+@pulumi.output_type
+class GetCassandaTagResult(dict):
+    def __init__(__self__, *,
+                 key: str,
+                 value: str):
+        """
+        :param str key: Service tag key
+        :param str value: Service tag value
+        """
+        pulumi.set(__self__, "key", key)
+        pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def key(self) -> str:
+        """
+        Service tag key
+        """
+        return pulumi.get(self, "key")
+
+    @property
+    @pulumi.getter
+    def value(self) -> str:
+        """
+        Service tag value
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class GetCassandaTechEmailResult(dict):
+    def __init__(__self__, *,
+                 email: str):
+        """
+        :param str email: An email address to contact for technical issues
+        """
+        pulumi.set(__self__, "email", email)
+
+    @property
+    @pulumi.getter
+    def email(self) -> str:
+        """
+        An email address to contact for technical issues
+        """
+        return pulumi.get(self, "email")
+
+
+@pulumi.output_type
+class GetCassandraCassandraResult(dict):
+    def __init__(__self__):
+        pass
+
+
+@pulumi.output_type
+class GetCassandraCassandraUserConfigResult(dict):
+    def __init__(__self__, *,
+                 additional_backup_regions: Optional[str] = None,
+                 backup_hour: Optional[int] = None,
+                 backup_minute: Optional[int] = None,
+                 cassandra: Optional['outputs.GetCassandraCassandraUserConfigCassandraResult'] = None,
+                 cassandra_version: Optional[str] = None,
+                 ip_filter_objects: Optional[Sequence['outputs.GetCassandraCassandraUserConfigIpFilterObjectResult']] = None,
+                 ip_filter_strings: Optional[Sequence[str]] = None,
+                 ip_filters: Optional[Sequence[str]] = None,
+                 migrate_sstableloader: Optional[bool] = None,
+                 private_access: Optional['outputs.GetCassandraCassandraUserConfigPrivateAccessResult'] = None,
+                 project_to_fork_from: Optional[str] = None,
+                 public_access: Optional['outputs.GetCassandraCassandraUserConfigPublicAccessResult'] = None,
+                 service_log: Optional[bool] = None,
+                 service_to_fork_from: Optional[str] = None,
+                 service_to_join_with: Optional[str] = None,
+                 static_ips: Optional[bool] = None):
+        """
+        :param str additional_backup_regions: Additional Cloud Regions for Backup Replication.
+        :param int backup_hour: The hour of day (in UTC) when backup for the service is started. New backup is only started if previous backup has already completed.
+        :param int backup_minute: The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.
+        :param 'GetCassandraCassandraUserConfigCassandraArgs' cassandra: cassandra configuration values
+        :param str cassandra_version: Cassandra version.
+        :param Sequence['GetCassandraCassandraUserConfigIpFilterObjectArgs'] 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 migrate_sstableloader: Sets the service into migration mode enabling the sstableloader utility to be used to upload Cassandra data files. Available only on service create.
+        :param 'GetCassandraCassandraUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
+        :param str project_to_fork_from: Name of another project to fork a service from. This has effect only when a new service is being created.
+        :param 'GetCassandraCassandraUserConfigPublicAccessArgs' public_access: Allow access to selected service ports from the public Internet
+        :param bool service_log: Store logs for the service so that they are available in the HTTP API and console.
+        :param str service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created.
+        :param str service_to_join_with: When bootstrapping, instead of creating a new Cassandra cluster try to join an existing one from another service. Can only be set on service creation.
+        :param bool static_ips: Use static public IP addresses.
+        """
+        if additional_backup_regions is not None:
+            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
+        if backup_hour is not None:
+            pulumi.set(__self__, "backup_hour", backup_hour)
+        if backup_minute is not None:
+            pulumi.set(__self__, "backup_minute", backup_minute)
+        if cassandra is not None:
+            pulumi.set(__self__, "cassandra", cassandra)
+        if cassandra_version is not None:
+            pulumi.set(__self__, "cassandra_version", cassandra_version)
+        if ip_filter_objects is not None:
+            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
+        if ip_filter_strings is not None:
+            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
+        if ip_filters is not None:
+            pulumi.set(__self__, "ip_filters", ip_filters)
+        if migrate_sstableloader is not None:
+            pulumi.set(__self__, "migrate_sstableloader", migrate_sstableloader)
+        if private_access is not None:
+            pulumi.set(__self__, "private_access", private_access)
+        if project_to_fork_from is not None:
+            pulumi.set(__self__, "project_to_fork_from", project_to_fork_from)
+        if public_access is not None:
+            pulumi.set(__self__, "public_access", public_access)
+        if service_log is not None:
+            pulumi.set(__self__, "service_log", service_log)
+        if service_to_fork_from is not None:
+            pulumi.set(__self__, "service_to_fork_from", service_to_fork_from)
+        if service_to_join_with is not None:
+            pulumi.set(__self__, "service_to_join_with", service_to_join_with)
+        if static_ips is not None:
+            pulumi.set(__self__, "static_ips", static_ips)
+
+    @property
+    @pulumi.getter(name="additionalBackupRegions")
+    def additional_backup_regions(self) -> Optional[str]:
+        """
+        Additional Cloud Regions for Backup Replication.
+        """
+        warnings.warn("""This property is deprecated.""", DeprecationWarning)
+        pulumi.log.warn("""additional_backup_regions is deprecated: This property is deprecated.""")
+
+        return pulumi.get(self, "additional_backup_regions")
+
+    @property
+    @pulumi.getter(name="backupHour")
+    def backup_hour(self) -> Optional[int]:
+        """
+        The hour of day (in UTC) when backup for the service is started. New backup is only started if previous backup has already completed.
+        """
+        return pulumi.get(self, "backup_hour")
+
+    @property
+    @pulumi.getter(name="backupMinute")
+    def backup_minute(self) -> Optional[int]:
+        """
+        The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.
+        """
+        return pulumi.get(self, "backup_minute")
+
+    @property
+    @pulumi.getter
+    def cassandra(self) -> Optional['outputs.GetCassandraCassandraUserConfigCassandraResult']:
+        """
+        cassandra configuration values
+        """
+        return pulumi.get(self, "cassandra")
+
+    @property
+    @pulumi.getter(name="cassandraVersion")
+    def cassandra_version(self) -> Optional[str]:
+        """
+        Cassandra version.
+        """
+        return pulumi.get(self, "cassandra_version")
+
+    @property
+    @pulumi.getter(name="ipFilterObjects")
+    def ip_filter_objects(self) -> Optional[Sequence['outputs.GetCassandraCassandraUserConfigIpFilterObjectResult']]:
+        """
+        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
+        """
+        return pulumi.get(self, "ip_filter_objects")
+
+    @property
+    @pulumi.getter(name="ipFilterStrings")
+    def ip_filter_strings(self) -> Optional[Sequence[str]]:
+        """
+        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
+        """
+        return pulumi.get(self, "ip_filter_strings")
+
+    @property
+    @pulumi.getter(name="ipFilters")
+    def ip_filters(self) -> Optional[Sequence[str]]:
+        """
+        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
+        """
+        warnings.warn("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
+        pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `ip_filter_string` instead.""")
+
+        return pulumi.get(self, "ip_filters")
+
+    @property
+    @pulumi.getter(name="migrateSstableloader")
+    def migrate_sstableloader(self) -> Optional[bool]:
+        """
+        Sets the service into migration mode enabling the sstableloader utility to be used to upload Cassandra data files. Available only on service create.
+        """
+        return pulumi.get(self, "migrate_sstableloader")
+
+    @property
+    @pulumi.getter(name="privateAccess")
+    def private_access(self) -> Optional['outputs.GetCassandraCassandraUserConfigPrivateAccessResult']:
+        """
+        Allow access to selected service ports from private networks
+        """
+        return pulumi.get(self, "private_access")
+
+    @property
+    @pulumi.getter(name="projectToForkFrom")
+    def project_to_fork_from(self) -> Optional[str]:
+        """
+        Name of another project to fork a service from. This has effect only when a new service is being created.
+        """
+        return pulumi.get(self, "project_to_fork_from")
+
+    @property
+    @pulumi.getter(name="publicAccess")
+    def public_access(self) -> Optional['outputs.GetCassandraCassandraUserConfigPublicAccessResult']:
+        """
+        Allow access to selected service ports from the public Internet
+        """
+        return pulumi.get(self, "public_access")
+
+    @property
+    @pulumi.getter(name="serviceLog")
+    def service_log(self) -> Optional[bool]:
+        """
+        Store logs for the service so that they are available in the HTTP API and console.
+        """
+        return pulumi.get(self, "service_log")
+
+    @property
+    @pulumi.getter(name="serviceToForkFrom")
+    def service_to_fork_from(self) -> Optional[str]:
+        """
+        Name of another service to fork from. This has effect only when a new service is being created.
+        """
+        return pulumi.get(self, "service_to_fork_from")
+
+    @property
+    @pulumi.getter(name="serviceToJoinWith")
+    def service_to_join_with(self) -> Optional[str]:
+        """
+        When bootstrapping, instead of creating a new Cassandra cluster try to join an existing one from another service. Can only be set on service creation.
+        """
+        return pulumi.get(self, "service_to_join_with")
+
+    @property
+    @pulumi.getter(name="staticIps")
+    def static_ips(self) -> Optional[bool]:
+        """
+        Use static public IP addresses.
+        """
+        return pulumi.get(self, "static_ips")
+
+
+@pulumi.output_type
+class GetCassandraCassandraUserConfigCassandraResult(dict):
+    def __init__(__self__, *,
+                 batch_size_fail_threshold_in_kb: Optional[int] = None,
+                 batch_size_warn_threshold_in_kb: Optional[int] = None,
+                 datacenter: Optional[str] = None):
+        """
+        :param int batch_size_fail_threshold_in_kb: Fail any multiple-partition batch exceeding this value. 50kb (10x warn threshold) by default.
+        :param int batch_size_warn_threshold_in_kb: Log a warning message on any multiple-partition batch size exceeding this value.5kb per batch by default.Caution should be taken on increasing the size of this thresholdas it can lead to node instability.
+        :param str datacenter: Name of the datacenter to which nodes of this service belong. Can be set only when creating the service.
+        """
+        if batch_size_fail_threshold_in_kb is not None:
+            pulumi.set(__self__, "batch_size_fail_threshold_in_kb", batch_size_fail_threshold_in_kb)
+        if batch_size_warn_threshold_in_kb is not None:
+            pulumi.set(__self__, "batch_size_warn_threshold_in_kb", batch_size_warn_threshold_in_kb)
+        if datacenter is not None:
+            pulumi.set(__self__, "datacenter", datacenter)
+
+    @property
+    @pulumi.getter(name="batchSizeFailThresholdInKb")
+    def batch_size_fail_threshold_in_kb(self) -> Optional[int]:
+        """
+        Fail any multiple-partition batch exceeding this value. 50kb (10x warn threshold) by default.
+        """
+        return pulumi.get(self, "batch_size_fail_threshold_in_kb")
+
+    @property
+    @pulumi.getter(name="batchSizeWarnThresholdInKb")
+    def batch_size_warn_threshold_in_kb(self) -> Optional[int]:
+        """
+        Log a warning message on any multiple-partition batch size exceeding this value.5kb per batch by default.Caution should be taken on increasing the size of this thresholdas it can lead to node instability.
+        """
+        return pulumi.get(self, "batch_size_warn_threshold_in_kb")
+
+    @property
+    @pulumi.getter
+    def datacenter(self) -> Optional[str]:
+        """
+        Name of the datacenter to which nodes of this service belong. Can be set only when creating the service.
+        """
+        return pulumi.get(self, "datacenter")
+
+
+@pulumi.output_type
+class GetCassandraCassandraUserConfigIpFilterObjectResult(dict):
     def __init__(__self__, *,
                  network: str,
                  description: Optional[str] = None):
@@ -19950,7 +21907,7 @@ class GetCassandaCassandraUserConfigIpFilterObjectResult(dict):
 
 
 @pulumi.output_type
-class GetCassandaCassandraUserConfigPrivateAccessResult(dict):
+class GetCassandraCassandraUserConfigPrivateAccessResult(dict):
     def __init__(__self__, *,
                  prometheus: Optional[bool] = None):
         """
@@ -19969,7 +21926,7 @@ class GetCassandaCassandraUserConfigPrivateAccessResult(dict):
 
 
 @pulumi.output_type
-class GetCassandaCassandraUserConfigPublicAccessResult(dict):
+class GetCassandraCassandraUserConfigPublicAccessResult(dict):
     def __init__(__self__, *,
                  prometheus: Optional[bool] = None):
         """
@@ -19988,7 +21945,7 @@ class GetCassandaCassandraUserConfigPublicAccessResult(dict):
 
 
 @pulumi.output_type
-class GetCassandaComponentResult(dict):
+class GetCassandraComponentResult(dict):
     def __init__(__self__, *,
                  component: str,
                  connection_uri: str,
@@ -20083,7 +22040,7 @@ class GetCassandaComponentResult(dict):
 
 
 @pulumi.output_type
-class GetCassandaServiceIntegrationResult(dict):
+class GetCassandraServiceIntegrationResult(dict):
     def __init__(__self__, *,
                  integration_type: str,
                  source_service_name: str):
@@ -20112,7 +22069,7 @@ class GetCassandaServiceIntegrationResult(dict):
 
 
 @pulumi.output_type
-class GetCassandaTagResult(dict):
+class GetCassandraTagResult(dict):
     def __init__(__self__, *,
                  key: str,
                  value: str):
@@ -20141,7 +22098,7 @@ class GetCassandaTagResult(dict):
 
 
 @pulumi.output_type
-class GetCassandaTechEmailResult(dict):
+class GetCassandraTechEmailResult(dict):
     def __init__(__self__, *,
                  email: str):
         """
@@ -20159,68 +22116,50 @@ class GetCassandaTechEmailResult(dict):
 
 
 @pulumi.output_type
-class GetCassandraCassandraResult(dict):
+class GetClickhouseClickhouseResult(dict):
     def __init__(__self__):
         pass
 
 
 @pulumi.output_type
-class GetCassandraCassandraUserConfigResult(dict):
+class GetClickhouseClickhouseUserConfigResult(dict):
     def __init__(__self__, *,
                  additional_backup_regions: Optional[str] = None,
-                 backup_hour: Optional[int] = None,
-                 backup_minute: Optional[int] = None,
-                 cassandra: Optional['outputs.GetCassandraCassandraUserConfigCassandraResult'] = None,
-                 cassandra_version: Optional[str] = None,
-                 ip_filter_objects: Optional[Sequence['outputs.GetCassandraCassandraUserConfigIpFilterObjectResult']] = None,
+                 ip_filter_objects: Optional[Sequence['outputs.GetClickhouseClickhouseUserConfigIpFilterObjectResult']] = None,
                  ip_filter_strings: Optional[Sequence[str]] = None,
                  ip_filters: Optional[Sequence[str]] = None,
-                 migrate_sstableloader: Optional[bool] = None,
-                 private_access: Optional['outputs.GetCassandraCassandraUserConfigPrivateAccessResult'] = None,
+                 private_access: Optional['outputs.GetClickhouseClickhouseUserConfigPrivateAccessResult'] = None,
+                 privatelink_access: Optional['outputs.GetClickhouseClickhouseUserConfigPrivatelinkAccessResult'] = None,
                  project_to_fork_from: Optional[str] = None,
-                 public_access: Optional['outputs.GetCassandraCassandraUserConfigPublicAccessResult'] = None,
+                 public_access: Optional['outputs.GetClickhouseClickhouseUserConfigPublicAccessResult'] = None,
                  service_log: Optional[bool] = None,
                  service_to_fork_from: Optional[str] = None,
-                 service_to_join_with: Optional[str] = None,
                  static_ips: Optional[bool] = None):
         """
         :param str additional_backup_regions: Additional Cloud Regions for Backup Replication.
-        :param int backup_hour: The hour of day (in UTC) when backup for the service is started. New backup is only started if previous backup has already completed.
-        :param int backup_minute: The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.
-        :param 'GetCassandraCassandraUserConfigCassandraArgs' cassandra: cassandra configuration values
-        :param str cassandra_version: Cassandra version.
-        :param Sequence['GetCassandraCassandraUserConfigIpFilterObjectArgs'] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
+        :param Sequence['GetClickhouseClickhouseUserConfigIpFilterObjectArgs'] 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 migrate_sstableloader: Sets the service into migration mode enabling the sstableloader utility to be used to upload Cassandra data files. Available only on service create.
-        :param 'GetCassandraCassandraUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
+        :param 'GetClickhouseClickhouseUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
+        :param 'GetClickhouseClickhouseUserConfigPrivatelinkAccessArgs' privatelink_access: Allow access to selected service components through Privatelink
         :param str project_to_fork_from: Name of another project to fork a service from. This has effect only when a new service is being created.
-        :param 'GetCassandraCassandraUserConfigPublicAccessArgs' public_access: Allow access to selected service ports from the public Internet
+        :param 'GetClickhouseClickhouseUserConfigPublicAccessArgs' public_access: Allow access to selected service ports from the public Internet
         :param bool service_log: Store logs for the service so that they are available in the HTTP API and console.
         :param str service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created.
-        :param str service_to_join_with: When bootstrapping, instead of creating a new Cassandra cluster try to join an existing one from another service. Can only be set on service creation.
         :param bool static_ips: Use static public IP addresses.
         """
         if additional_backup_regions is not None:
             pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
-        if backup_hour is not None:
-            pulumi.set(__self__, "backup_hour", backup_hour)
-        if backup_minute is not None:
-            pulumi.set(__self__, "backup_minute", backup_minute)
-        if cassandra is not None:
-            pulumi.set(__self__, "cassandra", cassandra)
-        if cassandra_version is not None:
-            pulumi.set(__self__, "cassandra_version", cassandra_version)
         if ip_filter_objects is not None:
             pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
         if ip_filter_strings is not None:
             pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
         if ip_filters is not None:
             pulumi.set(__self__, "ip_filters", ip_filters)
-        if migrate_sstableloader is not None:
-            pulumi.set(__self__, "migrate_sstableloader", migrate_sstableloader)
         if private_access is not None:
             pulumi.set(__self__, "private_access", private_access)
+        if privatelink_access is not None:
+            pulumi.set(__self__, "privatelink_access", privatelink_access)
         if project_to_fork_from is not None:
             pulumi.set(__self__, "project_to_fork_from", project_to_fork_from)
         if public_access is not None:
@@ -20229,8 +22168,6 @@ class GetCassandraCassandraUserConfigResult(dict):
             pulumi.set(__self__, "service_log", service_log)
         if service_to_fork_from is not None:
             pulumi.set(__self__, "service_to_fork_from", service_to_fork_from)
-        if service_to_join_with is not None:
-            pulumi.set(__self__, "service_to_join_with", service_to_join_with)
         if static_ips is not None:
             pulumi.set(__self__, "static_ips", static_ips)
 
@@ -20245,41 +22182,9 @@ class GetCassandraCassandraUserConfigResult(dict):
 
         return pulumi.get(self, "additional_backup_regions")
 
-    @property
-    @pulumi.getter(name="backupHour")
-    def backup_hour(self) -> Optional[int]:
-        """
-        The hour of day (in UTC) when backup for the service is started. New backup is only started if previous backup has already completed.
-        """
-        return pulumi.get(self, "backup_hour")
-
-    @property
-    @pulumi.getter(name="backupMinute")
-    def backup_minute(self) -> Optional[int]:
-        """
-        The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.
-        """
-        return pulumi.get(self, "backup_minute")
-
-    @property
-    @pulumi.getter
-    def cassandra(self) -> Optional['outputs.GetCassandraCassandraUserConfigCassandraResult']:
-        """
-        cassandra configuration values
-        """
-        return pulumi.get(self, "cassandra")
-
-    @property
-    @pulumi.getter(name="cassandraVersion")
-    def cassandra_version(self) -> Optional[str]:
-        """
-        Cassandra version.
-        """
-        return pulumi.get(self, "cassandra_version")
-
     @property
     @pulumi.getter(name="ipFilterObjects")
-    def ip_filter_objects(self) -> Optional[Sequence['outputs.GetCassandraCassandraUserConfigIpFilterObjectResult']]:
+    def ip_filter_objects(self) -> Optional[Sequence['outputs.GetClickhouseClickhouseUserConfigIpFilterObjectResult']]:
         """
         Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
         """
@@ -20305,20 +22210,20 @@ class GetCassandraCassandraUserConfigResult(dict):
         return pulumi.get(self, "ip_filters")
 
     @property
-    @pulumi.getter(name="migrateSstableloader")
-    def migrate_sstableloader(self) -> Optional[bool]:
+    @pulumi.getter(name="privateAccess")
+    def private_access(self) -> Optional['outputs.GetClickhouseClickhouseUserConfigPrivateAccessResult']:
         """
-        Sets the service into migration mode enabling the sstableloader utility to be used to upload Cassandra data files. Available only on service create.
+        Allow access to selected service ports from private networks
         """
-        return pulumi.get(self, "migrate_sstableloader")
+        return pulumi.get(self, "private_access")
 
     @property
-    @pulumi.getter(name="privateAccess")
-    def private_access(self) -> Optional['outputs.GetCassandraCassandraUserConfigPrivateAccessResult']:
+    @pulumi.getter(name="privatelinkAccess")
+    def privatelink_access(self) -> Optional['outputs.GetClickhouseClickhouseUserConfigPrivatelinkAccessResult']:
         """
-        Allow access to selected service ports from private networks
+        Allow access to selected service components through Privatelink
         """
-        return pulumi.get(self, "private_access")
+        return pulumi.get(self, "privatelink_access")
 
     @property
     @pulumi.getter(name="projectToForkFrom")
@@ -20330,7 +22235,7 @@ class GetCassandraCassandraUserConfigResult(dict):
 
     @property
     @pulumi.getter(name="publicAccess")
-    def public_access(self) -> Optional['outputs.GetCassandraCassandraUserConfigPublicAccessResult']:
+    def public_access(self) -> Optional['outputs.GetClickhouseClickhouseUserConfigPublicAccessResult']:
         """
         Allow access to selected service ports from the public Internet
         """
@@ -20352,14 +22257,6 @@ class GetCassandraCassandraUserConfigResult(dict):
         """
         return pulumi.get(self, "service_to_fork_from")
 
-    @property
-    @pulumi.getter(name="serviceToJoinWith")
-    def service_to_join_with(self) -> Optional[str]:
-        """
-        When bootstrapping, instead of creating a new Cassandra cluster try to join an existing one from another service. Can only be set on service creation.
-        """
-        return pulumi.get(self, "service_to_join_with")
-
     @property
     @pulumi.getter(name="staticIps")
     def static_ips(self) -> Optional[bool]:
@@ -20370,50 +22267,7 @@ class GetCassandraCassandraUserConfigResult(dict):
 
 
 @pulumi.output_type
-class GetCassandraCassandraUserConfigCassandraResult(dict):
-    def __init__(__self__, *,
-                 batch_size_fail_threshold_in_kb: Optional[int] = None,
-                 batch_size_warn_threshold_in_kb: Optional[int] = None,
-                 datacenter: Optional[str] = None):
-        """
-        :param int batch_size_fail_threshold_in_kb: Fail any multiple-partition batch exceeding this value. 50kb (10x warn threshold) by default.
-        :param int batch_size_warn_threshold_in_kb: Log a warning message on any multiple-partition batch size exceeding this value.5kb per batch by default.Caution should be taken on increasing the size of this thresholdas it can lead to node instability.
-        :param str datacenter: Name of the datacenter to which nodes of this service belong. Can be set only when creating the service.
-        """
-        if batch_size_fail_threshold_in_kb is not None:
-            pulumi.set(__self__, "batch_size_fail_threshold_in_kb", batch_size_fail_threshold_in_kb)
-        if batch_size_warn_threshold_in_kb is not None:
-            pulumi.set(__self__, "batch_size_warn_threshold_in_kb", batch_size_warn_threshold_in_kb)
-        if datacenter is not None:
-            pulumi.set(__self__, "datacenter", datacenter)
-
-    @property
-    @pulumi.getter(name="batchSizeFailThresholdInKb")
-    def batch_size_fail_threshold_in_kb(self) -> Optional[int]:
-        """
-        Fail any multiple-partition batch exceeding this value. 50kb (10x warn threshold) by default.
-        """
-        return pulumi.get(self, "batch_size_fail_threshold_in_kb")
-
-    @property
-    @pulumi.getter(name="batchSizeWarnThresholdInKb")
-    def batch_size_warn_threshold_in_kb(self) -> Optional[int]:
-        """
-        Log a warning message on any multiple-partition batch size exceeding this value.5kb per batch by default.Caution should be taken on increasing the size of this thresholdas it can lead to node instability.
-        """
-        return pulumi.get(self, "batch_size_warn_threshold_in_kb")
-
-    @property
-    @pulumi.getter
-    def datacenter(self) -> Optional[str]:
-        """
-        Name of the datacenter to which nodes of this service belong. Can be set only when creating the service.
-        """
-        return pulumi.get(self, "datacenter")
-
-
-@pulumi.output_type
-class GetCassandraCassandraUserConfigIpFilterObjectResult(dict):
+class GetClickhouseClickhouseUserConfigIpFilterObjectResult(dict):
     def __init__(__self__, *,
                  network: str,
                  description: Optional[str] = None):
@@ -20443,15 +22297,51 @@ class GetCassandraCassandraUserConfigIpFilterObjectResult(dict):
 
 
 @pulumi.output_type
-class GetCassandraCassandraUserConfigPrivateAccessResult(dict):
+class GetClickhouseClickhouseUserConfigPrivateAccessResult(dict):
     def __init__(__self__, *,
+                 clickhouse: Optional[bool] = None,
+                 clickhouse_https: Optional[bool] = None,
+                 clickhouse_mysql: Optional[bool] = None,
                  prometheus: Optional[bool] = None):
         """
+        :param bool clickhouse: Allow clients to connect to clickhouse with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        :param bool clickhouse_https: Allow clients to connect to clickhouse_https with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        :param bool clickhouse_mysql: Allow clients to connect to clickhouse_mysql with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
         :param bool prometheus: Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
         """
+        if clickhouse is not None:
+            pulumi.set(__self__, "clickhouse", clickhouse)
+        if clickhouse_https is not None:
+            pulumi.set(__self__, "clickhouse_https", clickhouse_https)
+        if clickhouse_mysql is not None:
+            pulumi.set(__self__, "clickhouse_mysql", clickhouse_mysql)
         if prometheus is not None:
             pulumi.set(__self__, "prometheus", prometheus)
 
+    @property
+    @pulumi.getter
+    def clickhouse(self) -> Optional[bool]:
+        """
+        Allow clients to connect to clickhouse with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        return pulumi.get(self, "clickhouse")
+
+    @property
+    @pulumi.getter(name="clickhouseHttps")
+    def clickhouse_https(self) -> Optional[bool]:
+        """
+        Allow clients to connect to clickhouse_https with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        return pulumi.get(self, "clickhouse_https")
+
+    @property
+    @pulumi.getter(name="clickhouseMysql")
+    def clickhouse_mysql(self) -> Optional[bool]:
+        """
+        Allow clients to connect to clickhouse_mysql with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        return pulumi.get(self, "clickhouse_mysql")
+
     @property
     @pulumi.getter
     def prometheus(self) -> Optional[bool]:
@@ -20462,15 +22352,106 @@ class GetCassandraCassandraUserConfigPrivateAccessResult(dict):
 
 
 @pulumi.output_type
-class GetCassandraCassandraUserConfigPublicAccessResult(dict):
+class GetClickhouseClickhouseUserConfigPrivatelinkAccessResult(dict):
     def __init__(__self__, *,
+                 clickhouse: Optional[bool] = None,
+                 clickhouse_https: Optional[bool] = None,
+                 clickhouse_mysql: Optional[bool] = None,
                  prometheus: Optional[bool] = None):
         """
+        :param bool clickhouse: Enable clickhouse.
+        :param bool clickhouse_https: Enable clickhouse_https.
+        :param bool clickhouse_mysql: Enable clickhouse_mysql.
+        :param bool prometheus: Enable prometheus.
+        """
+        if clickhouse is not None:
+            pulumi.set(__self__, "clickhouse", clickhouse)
+        if clickhouse_https is not None:
+            pulumi.set(__self__, "clickhouse_https", clickhouse_https)
+        if clickhouse_mysql is not None:
+            pulumi.set(__self__, "clickhouse_mysql", clickhouse_mysql)
+        if prometheus is not None:
+            pulumi.set(__self__, "prometheus", prometheus)
+
+    @property
+    @pulumi.getter
+    def clickhouse(self) -> Optional[bool]:
+        """
+        Enable clickhouse.
+        """
+        return pulumi.get(self, "clickhouse")
+
+    @property
+    @pulumi.getter(name="clickhouseHttps")
+    def clickhouse_https(self) -> Optional[bool]:
+        """
+        Enable clickhouse_https.
+        """
+        return pulumi.get(self, "clickhouse_https")
+
+    @property
+    @pulumi.getter(name="clickhouseMysql")
+    def clickhouse_mysql(self) -> Optional[bool]:
+        """
+        Enable clickhouse_mysql.
+        """
+        return pulumi.get(self, "clickhouse_mysql")
+
+    @property
+    @pulumi.getter
+    def prometheus(self) -> Optional[bool]:
+        """
+        Enable prometheus.
+        """
+        return pulumi.get(self, "prometheus")
+
+
+@pulumi.output_type
+class GetClickhouseClickhouseUserConfigPublicAccessResult(dict):
+    def __init__(__self__, *,
+                 clickhouse: Optional[bool] = None,
+                 clickhouse_https: Optional[bool] = None,
+                 clickhouse_mysql: Optional[bool] = None,
+                 prometheus: Optional[bool] = None):
+        """
+        :param bool clickhouse: Allow clients to connect to clickhouse from the public internet for service nodes that are in a project VPC or another type of private network.
+        :param bool clickhouse_https: Allow clients to connect to clickhouse_https from the public internet for service nodes that are in a project VPC or another type of private network.
+        :param bool clickhouse_mysql: Allow clients to connect to clickhouse_mysql from the public internet for service nodes that are in a project VPC or another type of private network.
         :param bool prometheus: Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
         """
+        if clickhouse is not None:
+            pulumi.set(__self__, "clickhouse", clickhouse)
+        if clickhouse_https is not None:
+            pulumi.set(__self__, "clickhouse_https", clickhouse_https)
+        if clickhouse_mysql is not None:
+            pulumi.set(__self__, "clickhouse_mysql", clickhouse_mysql)
         if prometheus is not None:
             pulumi.set(__self__, "prometheus", prometheus)
 
+    @property
+    @pulumi.getter
+    def clickhouse(self) -> Optional[bool]:
+        """
+        Allow clients to connect to clickhouse from the public internet for service nodes that are in a project VPC or another type of private network.
+        """
+        return pulumi.get(self, "clickhouse")
+
+    @property
+    @pulumi.getter(name="clickhouseHttps")
+    def clickhouse_https(self) -> Optional[bool]:
+        """
+        Allow clients to connect to clickhouse_https from the public internet for service nodes that are in a project VPC or another type of private network.
+        """
+        return pulumi.get(self, "clickhouse_https")
+
+    @property
+    @pulumi.getter(name="clickhouseMysql")
+    def clickhouse_mysql(self) -> Optional[bool]:
+        """
+        Allow clients to connect to clickhouse_mysql from the public internet for service nodes that are in a project VPC or another type of private network.
+        """
+        return pulumi.get(self, "clickhouse_mysql")
+
     @property
     @pulumi.getter
     def prometheus(self) -> Optional[bool]:
@@ -20481,7 +22462,7 @@ class GetCassandraCassandraUserConfigPublicAccessResult(dict):
 
 
 @pulumi.output_type
-class GetCassandraComponentResult(dict):
+class GetClickhouseComponentResult(dict):
     def __init__(__self__, *,
                  component: str,
                  connection_uri: str,
@@ -20576,12 +22557,12 @@ class GetCassandraComponentResult(dict):
 
 
 @pulumi.output_type
-class GetCassandraServiceIntegrationResult(dict):
+class GetClickhouseServiceIntegrationResult(dict):
     def __init__(__self__, *,
                  integration_type: str,
                  source_service_name: str):
         """
-        :param str integration_type: Type of the service integration. The only supported value at the moment is `read_replica`
+        :param str integration_type: Type of the service integration. The only supported values at the moment are `clickhouse_kafka` and `clickhouse_postgresql`.
         :param str source_service_name: Name of the source service
         """
         pulumi.set(__self__, "integration_type", integration_type)
@@ -20591,7 +22572,7 @@ class GetCassandraServiceIntegrationResult(dict):
     @pulumi.getter(name="integrationType")
     def integration_type(self) -> str:
         """
-        Type of the service integration. The only supported value at the moment is `read_replica`
+        Type of the service integration. The only supported values at the moment are `clickhouse_kafka` and `clickhouse_postgresql`.
         """
         return pulumi.get(self, "integration_type")
 
@@ -20605,7 +22586,7 @@ class GetCassandraServiceIntegrationResult(dict):
 
 
 @pulumi.output_type
-class GetCassandraTagResult(dict):
+class GetClickhouseTagResult(dict):
     def __init__(__self__, *,
                  key: str,
                  value: str):
@@ -20634,7 +22615,7 @@ class GetCassandraTagResult(dict):
 
 
 @pulumi.output_type
-class GetCassandraTechEmailResult(dict):
+class GetClickhouseTechEmailResult(dict):
     def __init__(__self__, *,
                  email: str):
         """
@@ -20652,46 +22633,151 @@ class GetCassandraTechEmailResult(dict):
 
 
 @pulumi.output_type
-class GetClickhouseClickhouseResult(dict):
+class GetDragonflyComponentResult(dict):
+    def __init__(__self__, *,
+                 component: str,
+                 connection_uri: str,
+                 host: str,
+                 kafka_authentication_method: str,
+                 port: int,
+                 route: str,
+                 ssl: bool,
+                 usage: str):
+        """
+        :param str component: Service component name
+        :param str connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
+        :param str host: Host name for connecting to the service component
+        :param str kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
+        :param int port: Port number for connecting to the service component
+        :param str route: Network access route
+        :param bool ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
+        :param str usage: DNS usage name
+        """
+        pulumi.set(__self__, "component", component)
+        pulumi.set(__self__, "connection_uri", connection_uri)
+        pulumi.set(__self__, "host", host)
+        pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
+        pulumi.set(__self__, "port", port)
+        pulumi.set(__self__, "route", route)
+        pulumi.set(__self__, "ssl", ssl)
+        pulumi.set(__self__, "usage", usage)
+
+    @property
+    @pulumi.getter
+    def component(self) -> str:
+        """
+        Service component name
+        """
+        return pulumi.get(self, "component")
+
+    @property
+    @pulumi.getter(name="connectionUri")
+    def connection_uri(self) -> str:
+        """
+        Connection info for connecting to the service component. This is a combination of host and port.
+        """
+        return pulumi.get(self, "connection_uri")
+
+    @property
+    @pulumi.getter
+    def host(self) -> str:
+        """
+        Host name for connecting to the service component
+        """
+        return pulumi.get(self, "host")
+
+    @property
+    @pulumi.getter(name="kafkaAuthenticationMethod")
+    def kafka_authentication_method(self) -> str:
+        """
+        Kafka authentication method. This is a value specific to the 'kafka' service component
+        """
+        return pulumi.get(self, "kafka_authentication_method")
+
+    @property
+    @pulumi.getter
+    def port(self) -> int:
+        """
+        Port number for connecting to the service component
+        """
+        return pulumi.get(self, "port")
+
+    @property
+    @pulumi.getter
+    def route(self) -> str:
+        """
+        Network access route
+        """
+        return pulumi.get(self, "route")
+
+    @property
+    @pulumi.getter
+    def ssl(self) -> bool:
+        """
+        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
+        """
+        return pulumi.get(self, "ssl")
+
+    @property
+    @pulumi.getter
+    def usage(self) -> str:
+        """
+        DNS usage name
+        """
+        return pulumi.get(self, "usage")
+
+
+@pulumi.output_type
+class GetDragonflyDragonflyResult(dict):
     def __init__(__self__):
         pass
 
 
 @pulumi.output_type
-class GetClickhouseClickhouseUserConfigResult(dict):
+class GetDragonflyDragonflyUserConfigResult(dict):
     def __init__(__self__, *,
-                 additional_backup_regions: Optional[str] = None,
-                 ip_filter_objects: Optional[Sequence['outputs.GetClickhouseClickhouseUserConfigIpFilterObjectResult']] = None,
+                 cache_mode: Optional[bool] = None,
+                 dragonfly_ssl: Optional[bool] = None,
+                 ip_filter_objects: Optional[Sequence['outputs.GetDragonflyDragonflyUserConfigIpFilterObjectResult']] = None,
                  ip_filter_strings: Optional[Sequence[str]] = None,
                  ip_filters: Optional[Sequence[str]] = None,
-                 private_access: Optional['outputs.GetClickhouseClickhouseUserConfigPrivateAccessResult'] = None,
-                 privatelink_access: Optional['outputs.GetClickhouseClickhouseUserConfigPrivatelinkAccessResult'] = None,
+                 migration: Optional['outputs.GetDragonflyDragonflyUserConfigMigrationResult'] = None,
+                 private_access: Optional['outputs.GetDragonflyDragonflyUserConfigPrivateAccessResult'] = None,
+                 privatelink_access: Optional['outputs.GetDragonflyDragonflyUserConfigPrivatelinkAccessResult'] = None,
                  project_to_fork_from: Optional[str] = None,
-                 public_access: Optional['outputs.GetClickhouseClickhouseUserConfigPublicAccessResult'] = None,
+                 public_access: Optional['outputs.GetDragonflyDragonflyUserConfigPublicAccessResult'] = None,
+                 recovery_basebackup_name: Optional[str] = None,
                  service_log: Optional[bool] = None,
                  service_to_fork_from: Optional[str] = None,
                  static_ips: Optional[bool] = None):
         """
-        :param str additional_backup_regions: Additional Cloud Regions for Backup Replication.
-        :param Sequence['GetClickhouseClickhouseUserConfigIpFilterObjectArgs'] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
+        :param bool cache_mode: Evict entries when getting close to maxmemory limit. The default value is `false`.
+        :param bool dragonfly_ssl: Require SSL to access Dragonfly. The default value is `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'.
         :param Sequence[str] ip_filters: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
-        :param 'GetClickhouseClickhouseUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
-        :param 'GetClickhouseClickhouseUserConfigPrivatelinkAccessArgs' privatelink_access: Allow access to selected service components through Privatelink
+        :param 'GetDragonflyDragonflyUserConfigMigrationArgs' migration: Migrate data from existing server
+        :param 'GetDragonflyDragonflyUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
+        :param 'GetDragonflyDragonflyUserConfigPrivatelinkAccessArgs' privatelink_access: Allow access to selected service components through Privatelink
         :param str project_to_fork_from: Name of another project to fork a service from. This has effect only when a new service is being created.
-        :param 'GetClickhouseClickhouseUserConfigPublicAccessArgs' public_access: Allow access to selected service ports from the public Internet
+        :param 'GetDragonflyDragonflyUserConfigPublicAccessArgs' public_access: Allow access to selected service ports from the public Internet
+        :param str recovery_basebackup_name: Name of the basebackup to restore in forked service.
         :param bool service_log: Store logs for the service so that they are available in the HTTP API and console.
         :param str service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created.
         :param bool static_ips: Use static public IP addresses.
         """
-        if additional_backup_regions is not None:
-            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
+        if cache_mode is not None:
+            pulumi.set(__self__, "cache_mode", cache_mode)
+        if dragonfly_ssl is not None:
+            pulumi.set(__self__, "dragonfly_ssl", dragonfly_ssl)
         if ip_filter_objects is not None:
             pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
         if ip_filter_strings is not None:
             pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
         if ip_filters is not None:
             pulumi.set(__self__, "ip_filters", ip_filters)
+        if migration is not None:
+            pulumi.set(__self__, "migration", migration)
         if private_access is not None:
             pulumi.set(__self__, "private_access", private_access)
         if privatelink_access is not None:
@@ -20700,6 +22786,8 @@ class GetClickhouseClickhouseUserConfigResult(dict):
             pulumi.set(__self__, "project_to_fork_from", project_to_fork_from)
         if public_access is not None:
             pulumi.set(__self__, "public_access", public_access)
+        if recovery_basebackup_name is not None:
+            pulumi.set(__self__, "recovery_basebackup_name", recovery_basebackup_name)
         if service_log is not None:
             pulumi.set(__self__, "service_log", service_log)
         if service_to_fork_from is not None:
@@ -20708,19 +22796,24 @@ class GetClickhouseClickhouseUserConfigResult(dict):
             pulumi.set(__self__, "static_ips", static_ips)
 
     @property
-    @pulumi.getter(name="additionalBackupRegions")
-    def additional_backup_regions(self) -> Optional[str]:
+    @pulumi.getter(name="cacheMode")
+    def cache_mode(self) -> Optional[bool]:
         """
-        Additional Cloud Regions for Backup Replication.
+        Evict entries when getting close to maxmemory limit. The default value is `false`.
         """
-        warnings.warn("""This property is deprecated.""", DeprecationWarning)
-        pulumi.log.warn("""additional_backup_regions is deprecated: This property is deprecated.""")
+        return pulumi.get(self, "cache_mode")
 
-        return pulumi.get(self, "additional_backup_regions")
+    @property
+    @pulumi.getter(name="dragonflySsl")
+    def dragonfly_ssl(self) -> Optional[bool]:
+        """
+        Require SSL to access Dragonfly. The default value is `true`.
+        """
+        return pulumi.get(self, "dragonfly_ssl")
 
     @property
     @pulumi.getter(name="ipFilterObjects")
-    def ip_filter_objects(self) -> Optional[Sequence['outputs.GetClickhouseClickhouseUserConfigIpFilterObjectResult']]:
+    def ip_filter_objects(self) -> Optional[Sequence['outputs.GetDragonflyDragonflyUserConfigIpFilterObjectResult']]:
         """
         Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'
         """
@@ -20745,9 +22838,17 @@ class GetClickhouseClickhouseUserConfigResult(dict):
 
         return pulumi.get(self, "ip_filters")
 
+    @property
+    @pulumi.getter
+    def migration(self) -> Optional['outputs.GetDragonflyDragonflyUserConfigMigrationResult']:
+        """
+        Migrate data from existing server
+        """
+        return pulumi.get(self, "migration")
+
     @property
     @pulumi.getter(name="privateAccess")
-    def private_access(self) -> Optional['outputs.GetClickhouseClickhouseUserConfigPrivateAccessResult']:
+    def private_access(self) -> Optional['outputs.GetDragonflyDragonflyUserConfigPrivateAccessResult']:
         """
         Allow access to selected service ports from private networks
         """
@@ -20755,7 +22856,7 @@ class GetClickhouseClickhouseUserConfigResult(dict):
 
     @property
     @pulumi.getter(name="privatelinkAccess")
-    def privatelink_access(self) -> Optional['outputs.GetClickhouseClickhouseUserConfigPrivatelinkAccessResult']:
+    def privatelink_access(self) -> Optional['outputs.GetDragonflyDragonflyUserConfigPrivatelinkAccessResult']:
         """
         Allow access to selected service components through Privatelink
         """
@@ -20771,12 +22872,20 @@ class GetClickhouseClickhouseUserConfigResult(dict):
 
     @property
     @pulumi.getter(name="publicAccess")
-    def public_access(self) -> Optional['outputs.GetClickhouseClickhouseUserConfigPublicAccessResult']:
+    def public_access(self) -> Optional['outputs.GetDragonflyDragonflyUserConfigPublicAccessResult']:
         """
         Allow access to selected service ports from the public Internet
         """
         return pulumi.get(self, "public_access")
 
+    @property
+    @pulumi.getter(name="recoveryBasebackupName")
+    def recovery_basebackup_name(self) -> Optional[str]:
+        """
+        Name of the basebackup to restore in forked service.
+        """
+        return pulumi.get(self, "recovery_basebackup_name")
+
     @property
     @pulumi.getter(name="serviceLog")
     def service_log(self) -> Optional[bool]:
@@ -20803,7 +22912,7 @@ class GetClickhouseClickhouseUserConfigResult(dict):
 
 
 @pulumi.output_type
-class GetClickhouseClickhouseUserConfigIpFilterObjectResult(dict):
+class GetDragonflyDragonflyUserConfigIpFilterObjectResult(dict):
     def __init__(__self__, *,
                  network: str,
                  description: Optional[str] = None):
@@ -20833,272 +22942,206 @@ class GetClickhouseClickhouseUserConfigIpFilterObjectResult(dict):
 
 
 @pulumi.output_type
-class GetClickhouseClickhouseUserConfigPrivateAccessResult(dict):
+class GetDragonflyDragonflyUserConfigMigrationResult(dict):
     def __init__(__self__, *,
-                 clickhouse: Optional[bool] = None,
-                 clickhouse_https: Optional[bool] = None,
-                 clickhouse_mysql: Optional[bool] = None,
-                 prometheus: Optional[bool] = None):
+                 host: str,
+                 port: int,
+                 dbname: Optional[str] = None,
+                 ignore_dbs: Optional[str] = None,
+                 method: Optional[str] = None,
+                 password: Optional[str] = None,
+                 ssl: Optional[bool] = None,
+                 username: Optional[str] = None):
         """
-        :param bool clickhouse: Allow clients to connect to clickhouse with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
-        :param bool clickhouse_https: Allow clients to connect to clickhouse_https with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
-        :param bool clickhouse_mysql: Allow clients to connect to clickhouse_mysql with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
-        :param bool prometheus: Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        :param str host: Hostname or IP address of the server where to migrate data from.
+        :param int port: Port number of the server where to migrate data from.
+        :param str dbname: Database name for bootstrapping the initial connection.
+        :param str ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment).
+        :param str method: The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
+        :param str password: Password for authentication with the server where to migrate data from.
+        :param bool ssl: The server where to migrate data from is secured with SSL. The default value is `true`.
+        :param str username: User name for authentication with the server where to migrate data from.
         """
-        if clickhouse is not None:
-            pulumi.set(__self__, "clickhouse", clickhouse)
-        if clickhouse_https is not None:
-            pulumi.set(__self__, "clickhouse_https", clickhouse_https)
-        if clickhouse_mysql is not None:
-            pulumi.set(__self__, "clickhouse_mysql", clickhouse_mysql)
-        if prometheus is not None:
-            pulumi.set(__self__, "prometheus", prometheus)
+        pulumi.set(__self__, "host", host)
+        pulumi.set(__self__, "port", port)
+        if dbname is not None:
+            pulumi.set(__self__, "dbname", dbname)
+        if ignore_dbs is not None:
+            pulumi.set(__self__, "ignore_dbs", ignore_dbs)
+        if method is not None:
+            pulumi.set(__self__, "method", method)
+        if password is not None:
+            pulumi.set(__self__, "password", password)
+        if ssl is not None:
+            pulumi.set(__self__, "ssl", ssl)
+        if username is not None:
+            pulumi.set(__self__, "username", username)
 
     @property
     @pulumi.getter
-    def clickhouse(self) -> Optional[bool]:
-        """
-        Allow clients to connect to clickhouse with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
-        """
-        return pulumi.get(self, "clickhouse")
-
-    @property
-    @pulumi.getter(name="clickhouseHttps")
-    def clickhouse_https(self) -> Optional[bool]:
+    def host(self) -> str:
         """
-        Allow clients to connect to clickhouse_https with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        Hostname or IP address of the server where to migrate data from.
         """
-        return pulumi.get(self, "clickhouse_https")
+        return pulumi.get(self, "host")
 
     @property
-    @pulumi.getter(name="clickhouseMysql")
-    def clickhouse_mysql(self) -> Optional[bool]:
+    @pulumi.getter
+    def port(self) -> int:
         """
-        Allow clients to connect to clickhouse_mysql with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        Port number of the server where to migrate data from.
         """
-        return pulumi.get(self, "clickhouse_mysql")
+        return pulumi.get(self, "port")
 
     @property
     @pulumi.getter
-    def prometheus(self) -> Optional[bool]:
+    def dbname(self) -> Optional[str]:
         """
-        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        Database name for bootstrapping the initial connection.
         """
-        return pulumi.get(self, "prometheus")
-
+        return pulumi.get(self, "dbname")
 
-@pulumi.output_type
-class GetClickhouseClickhouseUserConfigPrivatelinkAccessResult(dict):
-    def __init__(__self__, *,
-                 clickhouse: Optional[bool] = None,
-                 clickhouse_https: Optional[bool] = None,
-                 clickhouse_mysql: Optional[bool] = None,
-                 prometheus: Optional[bool] = None):
+    @property
+    @pulumi.getter(name="ignoreDbs")
+    def ignore_dbs(self) -> Optional[str]:
         """
-        :param bool clickhouse: Enable clickhouse.
-        :param bool clickhouse_https: Enable clickhouse_https.
-        :param bool clickhouse_mysql: Enable clickhouse_mysql.
-        :param bool prometheus: Enable prometheus.
+        Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment).
         """
-        if clickhouse is not None:
-            pulumi.set(__self__, "clickhouse", clickhouse)
-        if clickhouse_https is not None:
-            pulumi.set(__self__, "clickhouse_https", clickhouse_https)
-        if clickhouse_mysql is not None:
-            pulumi.set(__self__, "clickhouse_mysql", clickhouse_mysql)
-        if prometheus is not None:
-            pulumi.set(__self__, "prometheus", prometheus)
+        return pulumi.get(self, "ignore_dbs")
 
     @property
     @pulumi.getter
-    def clickhouse(self) -> Optional[bool]:
+    def method(self) -> Optional[str]:
         """
-        Enable clickhouse.
+        The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         """
-        return pulumi.get(self, "clickhouse")
+        return pulumi.get(self, "method")
 
     @property
-    @pulumi.getter(name="clickhouseHttps")
-    def clickhouse_https(self) -> Optional[bool]:
+    @pulumi.getter
+    def password(self) -> Optional[str]:
         """
-        Enable clickhouse_https.
+        Password for authentication with the server where to migrate data from.
         """
-        return pulumi.get(self, "clickhouse_https")
+        return pulumi.get(self, "password")
 
     @property
-    @pulumi.getter(name="clickhouseMysql")
-    def clickhouse_mysql(self) -> Optional[bool]:
+    @pulumi.getter
+    def ssl(self) -> Optional[bool]:
         """
-        Enable clickhouse_mysql.
+        The server where to migrate data from is secured with SSL. The default value is `true`.
         """
-        return pulumi.get(self, "clickhouse_mysql")
+        return pulumi.get(self, "ssl")
 
     @property
     @pulumi.getter
-    def prometheus(self) -> Optional[bool]:
+    def username(self) -> Optional[str]:
         """
-        Enable prometheus.
+        User name for authentication with the server where to migrate data from.
         """
-        return pulumi.get(self, "prometheus")
+        return pulumi.get(self, "username")
 
 
 @pulumi.output_type
-class GetClickhouseClickhouseUserConfigPublicAccessResult(dict):
+class GetDragonflyDragonflyUserConfigPrivateAccessResult(dict):
     def __init__(__self__, *,
-                 clickhouse: Optional[bool] = None,
-                 clickhouse_https: Optional[bool] = None,
-                 clickhouse_mysql: Optional[bool] = None,
+                 dragonfly: Optional[bool] = None,
                  prometheus: Optional[bool] = None):
         """
-        :param bool clickhouse: Allow clients to connect to clickhouse from the public internet for service nodes that are in a project VPC or another type of private network.
-        :param bool clickhouse_https: Allow clients to connect to clickhouse_https from the public internet for service nodes that are in a project VPC or another type of private network.
-        :param bool clickhouse_mysql: Allow clients to connect to clickhouse_mysql from the public internet for service nodes that are in a project VPC or another type of private network.
-        :param bool prometheus: Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
+        :param bool dragonfly: Allow clients to connect to dragonfly with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        :param bool prometheus: Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
         """
-        if clickhouse is not None:
-            pulumi.set(__self__, "clickhouse", clickhouse)
-        if clickhouse_https is not None:
-            pulumi.set(__self__, "clickhouse_https", clickhouse_https)
-        if clickhouse_mysql is not None:
-            pulumi.set(__self__, "clickhouse_mysql", clickhouse_mysql)
+        if dragonfly is not None:
+            pulumi.set(__self__, "dragonfly", dragonfly)
         if prometheus is not None:
             pulumi.set(__self__, "prometheus", prometheus)
 
     @property
     @pulumi.getter
-    def clickhouse(self) -> Optional[bool]:
-        """
-        Allow clients to connect to clickhouse from the public internet for service nodes that are in a project VPC or another type of private network.
-        """
-        return pulumi.get(self, "clickhouse")
-
-    @property
-    @pulumi.getter(name="clickhouseHttps")
-    def clickhouse_https(self) -> Optional[bool]:
-        """
-        Allow clients to connect to clickhouse_https from the public internet for service nodes that are in a project VPC or another type of private network.
-        """
-        return pulumi.get(self, "clickhouse_https")
-
-    @property
-    @pulumi.getter(name="clickhouseMysql")
-    def clickhouse_mysql(self) -> Optional[bool]:
+    def dragonfly(self) -> Optional[bool]:
         """
-        Allow clients to connect to clickhouse_mysql from the public internet for service nodes that are in a project VPC or another type of private network.
+        Allow clients to connect to dragonfly with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
         """
-        return pulumi.get(self, "clickhouse_mysql")
+        return pulumi.get(self, "dragonfly")
 
     @property
     @pulumi.getter
     def prometheus(self) -> Optional[bool]:
         """
-        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
+        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
         """
         return pulumi.get(self, "prometheus")
 
 
 @pulumi.output_type
-class GetClickhouseComponentResult(dict):
+class GetDragonflyDragonflyUserConfigPrivatelinkAccessResult(dict):
     def __init__(__self__, *,
-                 component: str,
-                 connection_uri: str,
-                 host: str,
-                 kafka_authentication_method: str,
-                 port: int,
-                 route: str,
-                 ssl: bool,
-                 usage: str):
+                 dragonfly: Optional[bool] = None,
+                 prometheus: Optional[bool] = None):
         """
-        :param str component: Service component name
-        :param str connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
-        :param str host: Host name for connecting to the service component
-        :param str kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
-        :param int port: Port number for connecting to the service component
-        :param str route: Network access route
-        :param bool ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
-        :param str usage: DNS usage name
+        :param bool dragonfly: Enable dragonfly.
+        :param bool prometheus: Enable prometheus.
         """
-        pulumi.set(__self__, "component", component)
-        pulumi.set(__self__, "connection_uri", connection_uri)
-        pulumi.set(__self__, "host", host)
-        pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
-        pulumi.set(__self__, "port", port)
-        pulumi.set(__self__, "route", route)
-        pulumi.set(__self__, "ssl", ssl)
-        pulumi.set(__self__, "usage", usage)
+        if dragonfly is not None:
+            pulumi.set(__self__, "dragonfly", dragonfly)
+        if prometheus is not None:
+            pulumi.set(__self__, "prometheus", prometheus)
 
     @property
     @pulumi.getter
-    def component(self) -> str:
+    def dragonfly(self) -> Optional[bool]:
         """
-        Service component name
+        Enable dragonfly.
         """
-        return pulumi.get(self, "component")
-
-    @property
-    @pulumi.getter(name="connectionUri")
-    def connection_uri(self) -> str:
-        """
-        Connection info for connecting to the service component. This is a combination of host and port.
-        """
-        return pulumi.get(self, "connection_uri")
+        return pulumi.get(self, "dragonfly")
 
     @property
     @pulumi.getter
-    def host(self) -> str:
+    def prometheus(self) -> Optional[bool]:
         """
-        Host name for connecting to the service component
+        Enable prometheus.
         """
-        return pulumi.get(self, "host")
+        return pulumi.get(self, "prometheus")
 
-    @property
-    @pulumi.getter(name="kafkaAuthenticationMethod")
-    def kafka_authentication_method(self) -> str:
-        """
-        Kafka authentication method. This is a value specific to the 'kafka' service component
-        """
-        return pulumi.get(self, "kafka_authentication_method")
 
-    @property
-    @pulumi.getter
-    def port(self) -> int:
-        """
-        Port number for connecting to the service component
-        """
-        return pulumi.get(self, "port")
-
-    @property
-    @pulumi.getter
-    def route(self) -> str:
+@pulumi.output_type
+class GetDragonflyDragonflyUserConfigPublicAccessResult(dict):
+    def __init__(__self__, *,
+                 dragonfly: Optional[bool] = None,
+                 prometheus: Optional[bool] = None):
         """
-        Network access route
+        :param bool dragonfly: Allow clients to connect to dragonfly from the public internet for service nodes that are in a project VPC or another type of private network.
+        :param bool prometheus: Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
         """
-        return pulumi.get(self, "route")
+        if dragonfly is not None:
+            pulumi.set(__self__, "dragonfly", dragonfly)
+        if prometheus is not None:
+            pulumi.set(__self__, "prometheus", prometheus)
 
     @property
     @pulumi.getter
-    def ssl(self) -> bool:
+    def dragonfly(self) -> Optional[bool]:
         """
-        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
+        Allow clients to connect to dragonfly from the public internet for service nodes that are in a project VPC or another type of private network.
         """
-        return pulumi.get(self, "ssl")
+        return pulumi.get(self, "dragonfly")
 
     @property
     @pulumi.getter
-    def usage(self) -> str:
+    def prometheus(self) -> Optional[bool]:
         """
-        DNS usage name
+        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
         """
-        return pulumi.get(self, "usage")
+        return pulumi.get(self, "prometheus")
 
 
 @pulumi.output_type
-class GetClickhouseServiceIntegrationResult(dict):
+class GetDragonflyServiceIntegrationResult(dict):
     def __init__(__self__, *,
                  integration_type: str,
                  source_service_name: str):
         """
-        :param str integration_type: Type of the service integration. The only supported values at the moment are `clickhouse_kafka` and `clickhouse_postgresql`.
+        :param str integration_type: Type of the service integration. The only supported value at the moment is `read_replica`
         :param str source_service_name: Name of the source service
         """
         pulumi.set(__self__, "integration_type", integration_type)
@@ -21108,7 +23151,7 @@ class GetClickhouseServiceIntegrationResult(dict):
     @pulumi.getter(name="integrationType")
     def integration_type(self) -> str:
         """
-        Type of the service integration. The only supported values at the moment are `clickhouse_kafka` and `clickhouse_postgresql`.
+        Type of the service integration. The only supported value at the moment is `read_replica`
         """
         return pulumi.get(self, "integration_type")
 
@@ -21122,7 +23165,7 @@ class GetClickhouseServiceIntegrationResult(dict):
 
 
 @pulumi.output_type
-class GetClickhouseTagResult(dict):
+class GetDragonflyTagResult(dict):
     def __init__(__self__, *,
                  key: str,
                  value: str):
@@ -21151,7 +23194,7 @@ class GetClickhouseTagResult(dict):
 
 
 @pulumi.output_type
-class GetClickhouseTechEmailResult(dict):
+class GetDragonflyTechEmailResult(dict):
     def __init__(__self__, *,
                  email: str):
         """
@@ -29900,6 +31943,7 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
                  ism_history_rollover_check_period: Optional[int] = None,
                  ism_history_rollover_retention_period: Optional[int] = None,
                  override_main_response_version: Optional[bool] = None,
+                 plugins_alerting_filter_by_backend_roles: Optional[bool] = None,
                  reindex_remote_whitelists: Optional[Sequence[str]] = None,
                  script_max_compilations_rate: Optional[str] = None,
                  search_max_buckets: Optional[int] = None,
@@ -29942,6 +31986,7 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
         :param int ism_history_rollover_check_period: The time between rollover checks for the audit history index in hours. The default value is `8`.
         :param int ism_history_rollover_retention_period: How long audit history indices are kept in days. The default value is `30`.
         :param bool override_main_response_version: Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default is false.
+        :param bool plugins_alerting_filter_by_backend_roles: Enable or disable filtering of alerting by backend roles. Requires Security plugin. Defaults to false.
         :param Sequence[str] reindex_remote_whitelists: Whitelisted addresses for reindexing. Changing this value will cause all OpenSearch instances to restart.
         :param str script_max_compilations_rate: Script compilation circuit breaker limits the number of inline script compilations within a period of time. Default is use-context.
         :param int search_max_buckets: Maximum number of aggregation buckets allowed in a single response. OpenSearch default value is used when this is not defined.
@@ -30011,6 +32056,8 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
             pulumi.set(__self__, "ism_history_rollover_retention_period", ism_history_rollover_retention_period)
         if override_main_response_version is not None:
             pulumi.set(__self__, "override_main_response_version", override_main_response_version)
+        if plugins_alerting_filter_by_backend_roles is not None:
+            pulumi.set(__self__, "plugins_alerting_filter_by_backend_roles", plugins_alerting_filter_by_backend_roles)
         if reindex_remote_whitelists is not None:
             pulumi.set(__self__, "reindex_remote_whitelists", reindex_remote_whitelists)
         if script_max_compilations_rate is not None:
@@ -30256,6 +32303,14 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
         """
         return pulumi.get(self, "override_main_response_version")
 
+    @property
+    @pulumi.getter(name="pluginsAlertingFilterByBackendRoles")
+    def plugins_alerting_filter_by_backend_roles(self) -> Optional[bool]:
+        """
+        Enable or disable filtering of alerting by backend roles. Requires Security plugin. Defaults to false.
+        """
+        return pulumi.get(self, "plugins_alerting_filter_by_backend_roles")
+
     @property
     @pulumi.getter(name="reindexRemoteWhitelists")
     def reindex_remote_whitelists(self) -> Optional[Sequence[str]]:
@@ -31121,6 +33176,7 @@ class GetPgPgUserConfigResult(dict):
                  pg_service_to_fork_from: Optional[str] = None,
                  pg_stat_monitor_enable: Optional[bool] = None,
                  pg_version: Optional[str] = None,
+                 pgaudit: Optional['outputs.GetPgPgUserConfigPgauditResult'] = None,
                  pgbouncer: Optional['outputs.GetPgPgUserConfigPgbouncerResult'] = None,
                  pglookout: Optional['outputs.GetPgPgUserConfigPglookoutResult'] = None,
                  private_access: Optional['outputs.GetPgPgUserConfigPrivateAccessResult'] = None,
@@ -31153,6 +33209,7 @@ class GetPgPgUserConfigResult(dict):
         :param str pg_service_to_fork_from: Name of the PG Service from which to fork (deprecated, use service_to_fork_from). This has effect only when a new service is being created.
         :param bool pg_stat_monitor_enable: Enable the pg_stat_monitor extension. Enabling this extension will cause the cluster to be restarted.When this extension is enabled, pg_stat_statements results for utility commands are unreliable. The default value is `false`.
         :param str pg_version: PostgreSQL major version.
+        :param 'GetPgPgUserConfigPgauditArgs' pgaudit: System-wide settings for the pgaudit extension
         :param 'GetPgPgUserConfigPgbouncerArgs' pgbouncer: PGBouncer connection pooling settings
         :param 'GetPgPgUserConfigPglookoutArgs' pglookout: System-wide settings for pglookout
         :param 'GetPgPgUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
@@ -31201,6 +33258,8 @@ class GetPgPgUserConfigResult(dict):
             pulumi.set(__self__, "pg_stat_monitor_enable", pg_stat_monitor_enable)
         if pg_version is not None:
             pulumi.set(__self__, "pg_version", pg_version)
+        if pgaudit is not None:
+            pulumi.set(__self__, "pgaudit", pgaudit)
         if pgbouncer is not None:
             pulumi.set(__self__, "pgbouncer", pgbouncer)
         if pglookout is not None:
@@ -31366,6 +33425,14 @@ class GetPgPgUserConfigResult(dict):
         """
         return pulumi.get(self, "pg_version")
 
+    @property
+    @pulumi.getter
+    def pgaudit(self) -> Optional['outputs.GetPgPgUserConfigPgauditResult']:
+        """
+        System-wide settings for the pgaudit extension
+        """
+        return pulumi.get(self, "pgaudit")
+
     @property
     @pulumi.getter
     def pgbouncer(self) -> Optional['outputs.GetPgPgUserConfigPgbouncerResult']:
@@ -32295,6 +34362,181 @@ class GetPgPgUserConfigPgQualstatsResult(dict):
         return pulumi.get(self, "track_pg_catalog")
 
 
+@pulumi.output_type
+class GetPgPgUserConfigPgauditResult(dict):
+    def __init__(__self__, *,
+                 feature_enabled: Optional[bool] = None,
+                 log_catalog: Optional[bool] = None,
+                 log_client: Optional[bool] = None,
+                 log_level: Optional[str] = None,
+                 log_max_string_length: Optional[int] = None,
+                 log_nested_statements: Optional[bool] = None,
+                 log_parameter: Optional[bool] = None,
+                 log_parameter_max_size: Optional[int] = None,
+                 log_relation: Optional[bool] = None,
+                 log_rows: Optional[bool] = None,
+                 log_statement: Optional[bool] = None,
+                 log_statement_once: Optional[bool] = None,
+                 logs: Optional[Sequence[str]] = None,
+                 role: Optional[str] = None):
+        """
+        :param bool feature_enabled: Enable pgaudit extension. When enabled, pgaudit extension will be automatically installed.Otherwise, extension will be uninstalled but auditing configurations will be preserved. The default value is `false`.
+        :param bool log_catalog: Specifies that session logging should be enabled in the casewhere all relations in a statement are in pg_catalog. The default value is `true`.
+        :param bool log_client: Specifies whether log messages will be visible to a client process such as psql. The default value is `false`.
+        :param str log_level: Specifies the log level that will be used for log entries. The default value is `log`.
+        :param int log_max_string_length: Crop parameters representation and whole statements if they exceed this threshold. A (default) value of -1 disable the truncation. The default value is `-1`.
+        :param bool log_nested_statements: This GUC allows to turn off logging nested statements, that is, statements that are executed as part of another ExecutorRun. The default value is `true`.
+        :param bool log_parameter: Specifies that audit logging should include the parameters that were passed with the statement. The default value is `false`.
+        :param int log_parameter_max_size: Specifies that parameter values longer than this setting (in bytes) should not be logged, but replaced with <long param suppressed>. The default value is `0`.
+        :param bool log_relation: Specifies whether session audit logging should create a separate log entry for each relation (TABLE, VIEW, etc.) referenced in a SELECT or DML statement. The default value is `false`.
+        :param bool log_rows: Specifies that audit logging should include the rows retrieved or affected by a statement. When enabled the rows field will be included after the parameter field. The default value is `false`.
+        :param bool log_statement: Specifies whether logging will include the statement text and parameters (if enabled). The default value is `true`.
+        :param bool log_statement_once: Specifies whether logging will include the statement text and parameters with the first log entry for a statement/substatement combination or with every entry. The default value is `false`.
+        :param Sequence[str] logs: Specifies which classes of statements will be logged by session audit logging.
+        :param str role: Specifies the master role to use for object audit logging.
+        """
+        if feature_enabled is not None:
+            pulumi.set(__self__, "feature_enabled", feature_enabled)
+        if log_catalog is not None:
+            pulumi.set(__self__, "log_catalog", log_catalog)
+        if log_client is not None:
+            pulumi.set(__self__, "log_client", log_client)
+        if log_level is not None:
+            pulumi.set(__self__, "log_level", log_level)
+        if log_max_string_length is not None:
+            pulumi.set(__self__, "log_max_string_length", log_max_string_length)
+        if log_nested_statements is not None:
+            pulumi.set(__self__, "log_nested_statements", log_nested_statements)
+        if log_parameter is not None:
+            pulumi.set(__self__, "log_parameter", log_parameter)
+        if log_parameter_max_size is not None:
+            pulumi.set(__self__, "log_parameter_max_size", log_parameter_max_size)
+        if log_relation is not None:
+            pulumi.set(__self__, "log_relation", log_relation)
+        if log_rows is not None:
+            pulumi.set(__self__, "log_rows", log_rows)
+        if log_statement is not None:
+            pulumi.set(__self__, "log_statement", log_statement)
+        if log_statement_once is not None:
+            pulumi.set(__self__, "log_statement_once", log_statement_once)
+        if logs is not None:
+            pulumi.set(__self__, "logs", logs)
+        if role is not None:
+            pulumi.set(__self__, "role", role)
+
+    @property
+    @pulumi.getter(name="featureEnabled")
+    def feature_enabled(self) -> Optional[bool]:
+        """
+        Enable pgaudit extension. When enabled, pgaudit extension will be automatically installed.Otherwise, extension will be uninstalled but auditing configurations will be preserved. The default value is `false`.
+        """
+        return pulumi.get(self, "feature_enabled")
+
+    @property
+    @pulumi.getter(name="logCatalog")
+    def log_catalog(self) -> Optional[bool]:
+        """
+        Specifies that session logging should be enabled in the casewhere all relations in a statement are in pg_catalog. The default value is `true`.
+        """
+        return pulumi.get(self, "log_catalog")
+
+    @property
+    @pulumi.getter(name="logClient")
+    def log_client(self) -> Optional[bool]:
+        """
+        Specifies whether log messages will be visible to a client process such as psql. The default value is `false`.
+        """
+        return pulumi.get(self, "log_client")
+
+    @property
+    @pulumi.getter(name="logLevel")
+    def log_level(self) -> Optional[str]:
+        """
+        Specifies the log level that will be used for log entries. The default value is `log`.
+        """
+        return pulumi.get(self, "log_level")
+
+    @property
+    @pulumi.getter(name="logMaxStringLength")
+    def log_max_string_length(self) -> Optional[int]:
+        """
+        Crop parameters representation and whole statements if they exceed this threshold. A (default) value of -1 disable the truncation. The default value is `-1`.
+        """
+        return pulumi.get(self, "log_max_string_length")
+
+    @property
+    @pulumi.getter(name="logNestedStatements")
+    def log_nested_statements(self) -> Optional[bool]:
+        """
+        This GUC allows to turn off logging nested statements, that is, statements that are executed as part of another ExecutorRun. The default value is `true`.
+        """
+        return pulumi.get(self, "log_nested_statements")
+
+    @property
+    @pulumi.getter(name="logParameter")
+    def log_parameter(self) -> Optional[bool]:
+        """
+        Specifies that audit logging should include the parameters that were passed with the statement. The default value is `false`.
+        """
+        return pulumi.get(self, "log_parameter")
+
+    @property
+    @pulumi.getter(name="logParameterMaxSize")
+    def log_parameter_max_size(self) -> Optional[int]:
+        """
+        Specifies that parameter values longer than this setting (in bytes) should not be logged, but replaced with <long param suppressed>. The default value is `0`.
+        """
+        return pulumi.get(self, "log_parameter_max_size")
+
+    @property
+    @pulumi.getter(name="logRelation")
+    def log_relation(self) -> Optional[bool]:
+        """
+        Specifies whether session audit logging should create a separate log entry for each relation (TABLE, VIEW, etc.) referenced in a SELECT or DML statement. The default value is `false`.
+        """
+        return pulumi.get(self, "log_relation")
+
+    @property
+    @pulumi.getter(name="logRows")
+    def log_rows(self) -> Optional[bool]:
+        """
+        Specifies that audit logging should include the rows retrieved or affected by a statement. When enabled the rows field will be included after the parameter field. The default value is `false`.
+        """
+        return pulumi.get(self, "log_rows")
+
+    @property
+    @pulumi.getter(name="logStatement")
+    def log_statement(self) -> Optional[bool]:
+        """
+        Specifies whether logging will include the statement text and parameters (if enabled). The default value is `true`.
+        """
+        return pulumi.get(self, "log_statement")
+
+    @property
+    @pulumi.getter(name="logStatementOnce")
+    def log_statement_once(self) -> Optional[bool]:
+        """
+        Specifies whether logging will include the statement text and parameters with the first log entry for a statement/substatement combination or with every entry. The default value is `false`.
+        """
+        return pulumi.get(self, "log_statement_once")
+
+    @property
+    @pulumi.getter
+    def logs(self) -> Optional[Sequence[str]]:
+        """
+        Specifies which classes of statements will be logged by session audit logging.
+        """
+        return pulumi.get(self, "logs")
+
+    @property
+    @pulumi.getter
+    def role(self) -> Optional[str]:
+        """
+        Specifies the master role to use for object audit logging.
+        """
+        return pulumi.get(self, "role")
+
+
 @pulumi.output_type
 class GetPgPgUserConfigPgbouncerResult(dict):
     def __init__(__self__, *,
@@ -33401,7 +35643,7 @@ class GetServiceIntegrationClickhouseKafkaUserConfigResult(dict):
     def __init__(__self__, *,
                  tables: Optional[Sequence['outputs.GetServiceIntegrationClickhouseKafkaUserConfigTableResult']] = None):
         """
-        :param Sequence['GetServiceIntegrationClickhouseKafkaUserConfigTableArgs'] tables: Tables to create.
+        :param Sequence['GetServiceIntegrationClickhouseKafkaUserConfigTableArgs'] tables: Tables to create
         """
         if tables is not None:
             pulumi.set(__self__, "tables", tables)
@@ -33410,7 +35652,7 @@ class GetServiceIntegrationClickhouseKafkaUserConfigResult(dict):
     @pulumi.getter
     def tables(self) -> Optional[Sequence['outputs.GetServiceIntegrationClickhouseKafkaUserConfigTableResult']]:
         """
-        Tables to create.
+        Tables to create
         """
         return pulumi.get(self, "tables")
 
@@ -33418,25 +35660,26 @@ class GetServiceIntegrationClickhouseKafkaUserConfigResult(dict):
 @pulumi.output_type
 class GetServiceIntegrationClickhouseKafkaUserConfigTableResult(dict):
     def __init__(__self__, *,
+                 columns: Sequence['outputs.GetServiceIntegrationClickhouseKafkaUserConfigTableColumnResult'],
                  data_format: str,
                  group_name: str,
                  name: str,
+                 topics: Sequence['outputs.GetServiceIntegrationClickhouseKafkaUserConfigTableTopicResult'],
                  auto_offset_reset: Optional[str] = None,
-                 columns: Optional[Sequence['outputs.GetServiceIntegrationClickhouseKafkaUserConfigTableColumnResult']] = None,
                  date_time_input_format: Optional[str] = None,
                  handle_error_mode: Optional[str] = None,
                  max_block_size: Optional[int] = None,
                  max_rows_per_message: Optional[int] = None,
                  num_consumers: Optional[int] = None,
                  poll_max_batch_size: Optional[int] = None,
-                 skip_broken_messages: Optional[int] = None,
-                 topics: Optional[Sequence['outputs.GetServiceIntegrationClickhouseKafkaUserConfigTableTopicResult']] = None):
+                 skip_broken_messages: Optional[int] = None):
         """
+        :param Sequence['GetServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs'] columns: Table columns
         :param str data_format: Message data format. The default value is `JSONEachRow`.
         :param str group_name: Kafka consumers group. The default value is `clickhouse`.
         :param str name: Name of the table.
+        :param Sequence['GetServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs'] topics: Kafka topics
         :param str auto_offset_reset: Action to take when there is no initial offset in offset store or the desired offset is out of range. The default value is `earliest`.
-        :param Sequence['GetServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs'] columns: Table columns.
         :param str date_time_input_format: Method to read DateTime from text input formats. The default value is `basic`.
         :param str handle_error_mode: How to handle errors for Kafka engine. The default value is `default`.
         :param int max_block_size: Number of row collected by poll(s) for flushing data from Kafka. The default value is `0`.
@@ -33444,15 +35687,14 @@ class GetServiceIntegrationClickhouseKafkaUserConfigTableResult(dict):
         :param int num_consumers: The number of consumers per table per replica. The default value is `1`.
         :param int poll_max_batch_size: Maximum amount of messages to be polled in a single Kafka poll. The default value is `0`.
         :param int skip_broken_messages: Skip at least this number of broken messages from Kafka topic per block. The default value is `0`.
-        :param Sequence['GetServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs'] topics: Kafka topics.
         """
+        pulumi.set(__self__, "columns", columns)
         pulumi.set(__self__, "data_format", data_format)
         pulumi.set(__self__, "group_name", group_name)
         pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "topics", topics)
         if auto_offset_reset is not None:
             pulumi.set(__self__, "auto_offset_reset", auto_offset_reset)
-        if columns is not None:
-            pulumi.set(__self__, "columns", columns)
         if date_time_input_format is not None:
             pulumi.set(__self__, "date_time_input_format", date_time_input_format)
         if handle_error_mode is not None:
@@ -33467,8 +35709,14 @@ class GetServiceIntegrationClickhouseKafkaUserConfigTableResult(dict):
             pulumi.set(__self__, "poll_max_batch_size", poll_max_batch_size)
         if skip_broken_messages is not None:
             pulumi.set(__self__, "skip_broken_messages", skip_broken_messages)
-        if topics is not None:
-            pulumi.set(__self__, "topics", topics)
+
+    @property
+    @pulumi.getter
+    def columns(self) -> Sequence['outputs.GetServiceIntegrationClickhouseKafkaUserConfigTableColumnResult']:
+        """
+        Table columns
+        """
+        return pulumi.get(self, "columns")
 
     @property
     @pulumi.getter(name="dataFormat")
@@ -33495,20 +35743,20 @@ class GetServiceIntegrationClickhouseKafkaUserConfigTableResult(dict):
         return pulumi.get(self, "name")
 
     @property
-    @pulumi.getter(name="autoOffsetReset")
-    def auto_offset_reset(self) -> Optional[str]:
+    @pulumi.getter
+    def topics(self) -> Sequence['outputs.GetServiceIntegrationClickhouseKafkaUserConfigTableTopicResult']:
         """
-        Action to take when there is no initial offset in offset store or the desired offset is out of range. The default value is `earliest`.
+        Kafka topics
         """
-        return pulumi.get(self, "auto_offset_reset")
+        return pulumi.get(self, "topics")
 
     @property
-    @pulumi.getter
-    def columns(self) -> Optional[Sequence['outputs.GetServiceIntegrationClickhouseKafkaUserConfigTableColumnResult']]:
+    @pulumi.getter(name="autoOffsetReset")
+    def auto_offset_reset(self) -> Optional[str]:
         """
-        Table columns.
+        Action to take when there is no initial offset in offset store or the desired offset is out of range. The default value is `earliest`.
         """
-        return pulumi.get(self, "columns")
+        return pulumi.get(self, "auto_offset_reset")
 
     @property
     @pulumi.getter(name="dateTimeInputFormat")
@@ -33566,14 +35814,6 @@ class GetServiceIntegrationClickhouseKafkaUserConfigTableResult(dict):
         """
         return pulumi.get(self, "skip_broken_messages")
 
-    @property
-    @pulumi.getter
-    def topics(self) -> Optional[Sequence['outputs.GetServiceIntegrationClickhouseKafkaUserConfigTableTopicResult']]:
-        """
-        Kafka topics.
-        """
-        return pulumi.get(self, "topics")
-
 
 @pulumi.output_type
 class GetServiceIntegrationClickhouseKafkaUserConfigTableColumnResult(dict):
@@ -33627,7 +35867,7 @@ class GetServiceIntegrationClickhousePostgresqlUserConfigResult(dict):
     def __init__(__self__, *,
                  databases: Optional[Sequence['outputs.GetServiceIntegrationClickhousePostgresqlUserConfigDatabaseResult']] = None):
         """
-        :param Sequence['GetServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgs'] databases: Databases to expose.
+        :param Sequence['GetServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgs'] databases: Databases to expose
         """
         if databases is not None:
             pulumi.set(__self__, "databases", databases)
@@ -33636,7 +35876,7 @@ class GetServiceIntegrationClickhousePostgresqlUserConfigResult(dict):
     @pulumi.getter
     def databases(self) -> Optional[Sequence['outputs.GetServiceIntegrationClickhousePostgresqlUserConfigDatabaseResult']]:
         """
-        Databases to expose.
+        Databases to expose
         """
         return pulumi.get(self, "databases")
 
@@ -33687,15 +35927,15 @@ class GetServiceIntegrationDatadogUserConfigResult(dict):
                  redis: Optional['outputs.GetServiceIntegrationDatadogUserConfigRedisResult'] = None):
         """
         :param bool datadog_dbm_enabled: Enable Datadog Database Monitoring.
-        :param Sequence['GetServiceIntegrationDatadogUserConfigDatadogTagArgs'] datadog_tags: Custom tags provided by user.
+        :param Sequence['GetServiceIntegrationDatadogUserConfigDatadogTagArgs'] datadog_tags: Custom tags provided by user
         :param Sequence[str] exclude_consumer_groups: List of custom metrics.
         :param Sequence[str] exclude_topics: List of topics to exclude.
         :param Sequence[str] include_consumer_groups: List of custom metrics.
         :param Sequence[str] include_topics: List of topics to include.
         :param Sequence[str] kafka_custom_metrics: List of custom metrics.
         :param int max_jmx_metrics: Maximum number of JMX metrics to send.
-        :param 'GetServiceIntegrationDatadogUserConfigOpensearchArgs' opensearch: Datadog Opensearch Options.
-        :param 'GetServiceIntegrationDatadogUserConfigRedisArgs' redis: Datadog Redis Options.
+        :param 'GetServiceIntegrationDatadogUserConfigOpensearchArgs' opensearch: Datadog Opensearch Options
+        :param 'GetServiceIntegrationDatadogUserConfigRedisArgs' redis: Datadog Redis Options
         """
         if datadog_dbm_enabled is not None:
             pulumi.set(__self__, "datadog_dbm_enabled", datadog_dbm_enabled)
@@ -33730,7 +35970,7 @@ class GetServiceIntegrationDatadogUserConfigResult(dict):
     @pulumi.getter(name="datadogTags")
     def datadog_tags(self) -> Optional[Sequence['outputs.GetServiceIntegrationDatadogUserConfigDatadogTagResult']]:
         """
-        Custom tags provided by user.
+        Custom tags provided by user
         """
         return pulumi.get(self, "datadog_tags")
 
@@ -33786,7 +36026,7 @@ class GetServiceIntegrationDatadogUserConfigResult(dict):
     @pulumi.getter
     def opensearch(self) -> Optional['outputs.GetServiceIntegrationDatadogUserConfigOpensearchResult']:
         """
-        Datadog Opensearch Options.
+        Datadog Opensearch Options
         """
         return pulumi.get(self, "opensearch")
 
@@ -33794,7 +36034,7 @@ class GetServiceIntegrationDatadogUserConfigResult(dict):
     @pulumi.getter
     def redis(self) -> Optional['outputs.GetServiceIntegrationDatadogUserConfigRedisResult']:
         """
-        Datadog Redis Options.
+        Datadog Redis Options
         """
         return pulumi.get(self, "redis")
 
@@ -33903,7 +36143,7 @@ class GetServiceIntegrationEndpointDatadogUserConfigResult(dict):
                  site: Optional[str] = None):
         """
         :param str datadog_api_key: Datadog API key.
-        :param Sequence['GetServiceIntegrationEndpointDatadogUserConfigDatadogTagArgs'] datadog_tags: Custom tags provided by user.
+        :param Sequence['GetServiceIntegrationEndpointDatadogUserConfigDatadogTagArgs'] datadog_tags: Custom tags provided by user
         :param bool disable_consumer_stats: Disable consumer group metrics.
         :param int kafka_consumer_check_instances: Number of separate instances to fetch kafka consumer statistics with.
         :param int kafka_consumer_stats_timeout: Number of seconds that datadog will wait to get consumer statistics from brokers.
@@ -33936,7 +36176,7 @@ class GetServiceIntegrationEndpointDatadogUserConfigResult(dict):
     @pulumi.getter(name="datadogTags")
     def datadog_tags(self) -> Optional[Sequence['outputs.GetServiceIntegrationEndpointDatadogUserConfigDatadogTagResult']]:
         """
-        Custom tags provided by user.
+        Custom tags provided by user
         """
         return pulumi.get(self, "datadog_tags")
 
@@ -34432,6 +36672,7 @@ class GetServiceIntegrationEndpointExternalPostgresqlResult(dict):
                  host: str,
                  port: int,
                  username: str,
+                 default_database: Optional[str] = None,
                  password: Optional[str] = None,
                  ssl_client_certificate: Optional[str] = None,
                  ssl_client_key: Optional[str] = None,
@@ -34441,6 +36682,7 @@ class GetServiceIntegrationEndpointExternalPostgresqlResult(dict):
         :param str host: Hostname or IP address of the server.
         :param int port: Port number of the server.
         :param str username: User name.
+        :param str default_database: Default database.
         :param str password: Password.
         :param str ssl_client_certificate: Client certificate.
         :param str ssl_client_key: Client key.
@@ -34450,6 +36692,8 @@ class GetServiceIntegrationEndpointExternalPostgresqlResult(dict):
         pulumi.set(__self__, "host", host)
         pulumi.set(__self__, "port", port)
         pulumi.set(__self__, "username", username)
+        if default_database is not None:
+            pulumi.set(__self__, "default_database", default_database)
         if password is not None:
             pulumi.set(__self__, "password", password)
         if ssl_client_certificate is not None:
@@ -34485,6 +36729,14 @@ class GetServiceIntegrationEndpointExternalPostgresqlResult(dict):
         """
         return pulumi.get(self, "username")
 
+    @property
+    @pulumi.getter(name="defaultDatabase")
+    def default_database(self) -> Optional[str]:
+        """
+        Default database.
+        """
+        return pulumi.get(self, "default_database")
+
     @property
     @pulumi.getter
     def password(self) -> Optional[str]:
@@ -34764,14 +37016,33 @@ class GetServiceIntegrationEndpointRsyslogUserConfigResult(dict):
         return pulumi.get(self, "sd")
 
 
+@pulumi.output_type
+class GetServiceIntegrationExternalAwsCloudwatchLogsUserConfigResult(dict):
+    def __init__(__self__, *,
+                 selected_log_fields: Optional[Sequence[str]] = None):
+        """
+        :param Sequence[str] selected_log_fields: The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
+        """
+        if selected_log_fields is not None:
+            pulumi.set(__self__, "selected_log_fields", selected_log_fields)
+
+    @property
+    @pulumi.getter(name="selectedLogFields")
+    def selected_log_fields(self) -> Optional[Sequence[str]]:
+        """
+        The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
+        """
+        return pulumi.get(self, "selected_log_fields")
+
+
 @pulumi.output_type
 class GetServiceIntegrationExternalAwsCloudwatchMetricsUserConfigResult(dict):
     def __init__(__self__, *,
                  dropped_metrics: Optional[Sequence['outputs.GetServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricResult']] = None,
                  extra_metrics: Optional[Sequence['outputs.GetServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricResult']] = None):
         """
-        :param Sequence['GetServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricArgs'] dropped_metrics: Metrics to not send to AWS CloudWatch (takes precedence over extra_metrics).
-        :param Sequence['GetServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricArgs'] extra_metrics: Metrics to allow through to AWS CloudWatch (in addition to default metrics).
+        :param Sequence['GetServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricArgs'] dropped_metrics: Metrics to not send to AWS CloudWatch (takes precedence over extra_metrics)
+        :param Sequence['GetServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricArgs'] extra_metrics: Metrics to allow through to AWS CloudWatch (in addition to default metrics)
         """
         if dropped_metrics is not None:
             pulumi.set(__self__, "dropped_metrics", dropped_metrics)
@@ -34782,7 +37053,7 @@ class GetServiceIntegrationExternalAwsCloudwatchMetricsUserConfigResult(dict):
     @pulumi.getter(name="droppedMetrics")
     def dropped_metrics(self) -> Optional[Sequence['outputs.GetServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricResult']]:
         """
-        Metrics to not send to AWS CloudWatch (takes precedence over extra_metrics).
+        Metrics to not send to AWS CloudWatch (takes precedence over extra_metrics)
         """
         return pulumi.get(self, "dropped_metrics")
 
@@ -34790,7 +37061,7 @@ class GetServiceIntegrationExternalAwsCloudwatchMetricsUserConfigResult(dict):
     @pulumi.getter(name="extraMetrics")
     def extra_metrics(self) -> Optional[Sequence['outputs.GetServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricResult']]:
         """
-        Metrics to allow through to AWS CloudWatch (in addition to default metrics).
+        Metrics to allow through to AWS CloudWatch (in addition to default metrics)
         """
         return pulumi.get(self, "extra_metrics")
 
@@ -34853,12 +37124,50 @@ class GetServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricResu
         return pulumi.get(self, "metric")
 
 
+@pulumi.output_type
+class GetServiceIntegrationExternalElasticsearchLogsUserConfigResult(dict):
+    def __init__(__self__, *,
+                 selected_log_fields: Optional[Sequence[str]] = None):
+        """
+        :param Sequence[str] selected_log_fields: The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
+        """
+        if selected_log_fields is not None:
+            pulumi.set(__self__, "selected_log_fields", selected_log_fields)
+
+    @property
+    @pulumi.getter(name="selectedLogFields")
+    def selected_log_fields(self) -> Optional[Sequence[str]]:
+        """
+        The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
+        """
+        return pulumi.get(self, "selected_log_fields")
+
+
+@pulumi.output_type
+class GetServiceIntegrationExternalOpensearchLogsUserConfigResult(dict):
+    def __init__(__self__, *,
+                 selected_log_fields: Optional[Sequence[str]] = None):
+        """
+        :param Sequence[str] selected_log_fields: The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
+        """
+        if selected_log_fields is not None:
+            pulumi.set(__self__, "selected_log_fields", selected_log_fields)
+
+    @property
+    @pulumi.getter(name="selectedLogFields")
+    def selected_log_fields(self) -> Optional[Sequence[str]]:
+        """
+        The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
+        """
+        return pulumi.get(self, "selected_log_fields")
+
+
 @pulumi.output_type
 class GetServiceIntegrationKafkaConnectUserConfigResult(dict):
     def __init__(__self__, *,
                  kafka_connect: Optional['outputs.GetServiceIntegrationKafkaConnectUserConfigKafkaConnectResult'] = None):
         """
-        :param 'GetServiceIntegrationKafkaConnectUserConfigKafkaConnectArgs' kafka_connect: Kafka Connect service configuration values.
+        :param 'GetServiceIntegrationKafkaConnectUserConfigKafkaConnectArgs' kafka_connect: Kafka Connect service configuration values
         """
         if kafka_connect is not None:
             pulumi.set(__self__, "kafka_connect", kafka_connect)
@@ -34867,7 +37176,7 @@ class GetServiceIntegrationKafkaConnectUserConfigResult(dict):
     @pulumi.getter(name="kafkaConnect")
     def kafka_connect(self) -> Optional['outputs.GetServiceIntegrationKafkaConnectUserConfigKafkaConnectResult']:
         """
-        Kafka Connect service configuration values.
+        Kafka Connect service configuration values
         """
         return pulumi.get(self, "kafka_connect")
 
@@ -34964,7 +37273,7 @@ class GetServiceIntegrationKafkaMirrormakerUserConfigResult(dict):
                  kafka_mirrormaker: Optional['outputs.GetServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerResult'] = None):
         """
         :param str cluster_alias: The alias under which the Kafka cluster is known to MirrorMaker. Can contain the following symbols: ASCII alphanumerics, '.', '_', and '-'.
-        :param 'GetServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgs' kafka_mirrormaker: Kafka MirrorMaker configuration values.
+        :param 'GetServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgs' kafka_mirrormaker: Kafka MirrorMaker configuration values
         """
         if cluster_alias is not None:
             pulumi.set(__self__, "cluster_alias", cluster_alias)
@@ -34983,7 +37292,7 @@ class GetServiceIntegrationKafkaMirrormakerUserConfigResult(dict):
     @pulumi.getter(name="kafkaMirrormaker")
     def kafka_mirrormaker(self) -> Optional['outputs.GetServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerResult']:
         """
-        Kafka MirrorMaker configuration values.
+        Kafka MirrorMaker configuration values
         """
         return pulumi.get(self, "kafka_mirrormaker")
 
@@ -35122,7 +37431,7 @@ class GetServiceIntegrationMetricsUserConfigResult(dict):
         :param str database: Name of the database where to store metric datapoints. Only affects PostgreSQL destinations. Defaults to 'metrics'. Note that this must be the same for all metrics integrations that write data to the same PostgreSQL service.
         :param int retention_days: Number of days to keep old metrics. Only affects PostgreSQL destinations. Set to 0 for no automatic cleanup. Defaults to 30 days.
         :param str ro_username: Name of a user that can be used to read metrics. This will be used for Grafana integration (if enabled) to prevent Grafana users from making undesired changes. Only affects PostgreSQL destinations. Defaults to 'metrics_reader'. Note that this must be the same for all metrics integrations that write data to the same PostgreSQL service.
-        :param 'GetServiceIntegrationMetricsUserConfigSourceMysqlArgs' source_mysql: Configuration options for metrics where source service is MySQL.
+        :param 'GetServiceIntegrationMetricsUserConfigSourceMysqlArgs' source_mysql: Configuration options for metrics where source service is MySQL
         :param str username: Name of the user used to write metrics. Only affects PostgreSQL destinations. Defaults to 'metrics_writer'. Note that this must be the same for all metrics integrations that write data to the same PostgreSQL service.
         """
         if database is not None:
@@ -35164,7 +37473,7 @@ class GetServiceIntegrationMetricsUserConfigResult(dict):
     @pulumi.getter(name="sourceMysql")
     def source_mysql(self) -> Optional['outputs.GetServiceIntegrationMetricsUserConfigSourceMysqlResult']:
         """
-        Configuration options for metrics where source service is MySQL.
+        Configuration options for metrics where source service is MySQL
         """
         return pulumi.get(self, "source_mysql")
 
@@ -35182,7 +37491,7 @@ class GetServiceIntegrationMetricsUserConfigSourceMysqlResult(dict):
     def __init__(__self__, *,
                  telegraf: Optional['outputs.GetServiceIntegrationMetricsUserConfigSourceMysqlTelegrafResult'] = None):
         """
-        :param 'GetServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgs' telegraf: Configuration options for Telegraf MySQL input plugin.
+        :param 'GetServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgs' telegraf: Configuration options for Telegraf MySQL input plugin
         """
         if telegraf is not None:
             pulumi.set(__self__, "telegraf", telegraf)
@@ -35191,7 +37500,7 @@ class GetServiceIntegrationMetricsUserConfigSourceMysqlResult(dict):
     @pulumi.getter
     def telegraf(self) -> Optional['outputs.GetServiceIntegrationMetricsUserConfigSourceMysqlTelegrafResult']:
         """
-        Configuration options for Telegraf MySQL input plugin.
+        Configuration options for Telegraf MySQL input plugin
         """
         return pulumi.get(self, "telegraf")
 
@@ -35371,3 +37680,216 @@ class GetServiceIntegrationMetricsUserConfigSourceMysqlTelegrafResult(dict):
         return pulumi.get(self, "perf_events_statements_time_limit")
 
 
+@pulumi.output_type
+class GetServiceIntegrationPrometheusUserConfigResult(dict):
+    def __init__(__self__, *,
+                 source_mysql: Optional['outputs.GetServiceIntegrationPrometheusUserConfigSourceMysqlResult'] = None):
+        """
+        :param 'GetServiceIntegrationPrometheusUserConfigSourceMysqlArgs' source_mysql: Configuration options for metrics where source service is MySQL
+        """
+        if source_mysql is not None:
+            pulumi.set(__self__, "source_mysql", source_mysql)
+
+    @property
+    @pulumi.getter(name="sourceMysql")
+    def source_mysql(self) -> Optional['outputs.GetServiceIntegrationPrometheusUserConfigSourceMysqlResult']:
+        """
+        Configuration options for metrics where source service is MySQL
+        """
+        return pulumi.get(self, "source_mysql")
+
+
+@pulumi.output_type
+class GetServiceIntegrationPrometheusUserConfigSourceMysqlResult(dict):
+    def __init__(__self__, *,
+                 telegraf: Optional['outputs.GetServiceIntegrationPrometheusUserConfigSourceMysqlTelegrafResult'] = None):
+        """
+        :param 'GetServiceIntegrationPrometheusUserConfigSourceMysqlTelegrafArgs' telegraf: Configuration options for Telegraf MySQL input plugin
+        """
+        if telegraf is not None:
+            pulumi.set(__self__, "telegraf", telegraf)
+
+    @property
+    @pulumi.getter
+    def telegraf(self) -> Optional['outputs.GetServiceIntegrationPrometheusUserConfigSourceMysqlTelegrafResult']:
+        """
+        Configuration options for Telegraf MySQL input plugin
+        """
+        return pulumi.get(self, "telegraf")
+
+
+@pulumi.output_type
+class GetServiceIntegrationPrometheusUserConfigSourceMysqlTelegrafResult(dict):
+    def __init__(__self__, *,
+                 gather_event_waits: Optional[bool] = None,
+                 gather_file_events_stats: Optional[bool] = None,
+                 gather_index_io_waits: Optional[bool] = None,
+                 gather_info_schema_auto_inc: Optional[bool] = None,
+                 gather_innodb_metrics: Optional[bool] = None,
+                 gather_perf_events_statements: Optional[bool] = None,
+                 gather_process_list: Optional[bool] = None,
+                 gather_slave_status: Optional[bool] = None,
+                 gather_table_io_waits: Optional[bool] = None,
+                 gather_table_lock_waits: Optional[bool] = None,
+                 gather_table_schema: Optional[bool] = None,
+                 perf_events_statements_digest_text_limit: Optional[int] = None,
+                 perf_events_statements_limit: Optional[int] = None,
+                 perf_events_statements_time_limit: Optional[int] = None):
+        """
+        :param bool gather_event_waits: Gather metrics from PERFORMANCE_SCHEMA.EVENT_WAITS.
+        :param bool gather_file_events_stats: gather metrics from PERFORMANCE_SCHEMA.FILE_SUMMARY_BY_EVENT_NAME.
+        :param bool gather_index_io_waits: Gather metrics from PERFORMANCE_SCHEMA.TABLE_IO_WAITS_SUMMARY_BY_INDEX_USAGE.
+        :param bool gather_info_schema_auto_inc: Gather auto_increment columns and max values from information schema.
+        :param bool gather_innodb_metrics: Gather metrics from INFORMATION_SCHEMA.INNODB_METRICS.
+        :param bool gather_perf_events_statements: Gather metrics from PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_DIGEST.
+        :param bool gather_process_list: Gather thread state counts from INFORMATION_SCHEMA.PROCESSLIST.
+        :param bool gather_slave_status: Gather metrics from SHOW SLAVE STATUS command output.
+        :param bool gather_table_io_waits: Gather metrics from PERFORMANCE_SCHEMA.TABLE_IO_WAITS_SUMMARY_BY_TABLE.
+        :param bool gather_table_lock_waits: Gather metrics from PERFORMANCE_SCHEMA.TABLE_LOCK_WAITS.
+        :param bool gather_table_schema: Gather metrics from INFORMATION_SCHEMA.TABLES.
+        :param int perf_events_statements_digest_text_limit: Truncates digest text from perf_events_statements into this many characters.
+        :param int perf_events_statements_limit: Limits metrics from perf_events_statements.
+        :param int perf_events_statements_time_limit: Only include perf_events_statements whose last seen is less than this many seconds.
+        """
+        if gather_event_waits is not None:
+            pulumi.set(__self__, "gather_event_waits", gather_event_waits)
+        if gather_file_events_stats is not None:
+            pulumi.set(__self__, "gather_file_events_stats", gather_file_events_stats)
+        if gather_index_io_waits is not None:
+            pulumi.set(__self__, "gather_index_io_waits", gather_index_io_waits)
+        if gather_info_schema_auto_inc is not None:
+            pulumi.set(__self__, "gather_info_schema_auto_inc", gather_info_schema_auto_inc)
+        if gather_innodb_metrics is not None:
+            pulumi.set(__self__, "gather_innodb_metrics", gather_innodb_metrics)
+        if gather_perf_events_statements is not None:
+            pulumi.set(__self__, "gather_perf_events_statements", gather_perf_events_statements)
+        if gather_process_list is not None:
+            pulumi.set(__self__, "gather_process_list", gather_process_list)
+        if gather_slave_status is not None:
+            pulumi.set(__self__, "gather_slave_status", gather_slave_status)
+        if gather_table_io_waits is not None:
+            pulumi.set(__self__, "gather_table_io_waits", gather_table_io_waits)
+        if gather_table_lock_waits is not None:
+            pulumi.set(__self__, "gather_table_lock_waits", gather_table_lock_waits)
+        if gather_table_schema is not None:
+            pulumi.set(__self__, "gather_table_schema", gather_table_schema)
+        if perf_events_statements_digest_text_limit is not None:
+            pulumi.set(__self__, "perf_events_statements_digest_text_limit", perf_events_statements_digest_text_limit)
+        if perf_events_statements_limit is not None:
+            pulumi.set(__self__, "perf_events_statements_limit", perf_events_statements_limit)
+        if perf_events_statements_time_limit is not None:
+            pulumi.set(__self__, "perf_events_statements_time_limit", perf_events_statements_time_limit)
+
+    @property
+    @pulumi.getter(name="gatherEventWaits")
+    def gather_event_waits(self) -> Optional[bool]:
+        """
+        Gather metrics from PERFORMANCE_SCHEMA.EVENT_WAITS.
+        """
+        return pulumi.get(self, "gather_event_waits")
+
+    @property
+    @pulumi.getter(name="gatherFileEventsStats")
+    def gather_file_events_stats(self) -> Optional[bool]:
+        """
+        gather metrics from PERFORMANCE_SCHEMA.FILE_SUMMARY_BY_EVENT_NAME.
+        """
+        return pulumi.get(self, "gather_file_events_stats")
+
+    @property
+    @pulumi.getter(name="gatherIndexIoWaits")
+    def gather_index_io_waits(self) -> Optional[bool]:
+        """
+        Gather metrics from PERFORMANCE_SCHEMA.TABLE_IO_WAITS_SUMMARY_BY_INDEX_USAGE.
+        """
+        return pulumi.get(self, "gather_index_io_waits")
+
+    @property
+    @pulumi.getter(name="gatherInfoSchemaAutoInc")
+    def gather_info_schema_auto_inc(self) -> Optional[bool]:
+        """
+        Gather auto_increment columns and max values from information schema.
+        """
+        return pulumi.get(self, "gather_info_schema_auto_inc")
+
+    @property
+    @pulumi.getter(name="gatherInnodbMetrics")
+    def gather_innodb_metrics(self) -> Optional[bool]:
+        """
+        Gather metrics from INFORMATION_SCHEMA.INNODB_METRICS.
+        """
+        return pulumi.get(self, "gather_innodb_metrics")
+
+    @property
+    @pulumi.getter(name="gatherPerfEventsStatements")
+    def gather_perf_events_statements(self) -> Optional[bool]:
+        """
+        Gather metrics from PERFORMANCE_SCHEMA.EVENTS_STATEMENTS_SUMMARY_BY_DIGEST.
+        """
+        return pulumi.get(self, "gather_perf_events_statements")
+
+    @property
+    @pulumi.getter(name="gatherProcessList")
+    def gather_process_list(self) -> Optional[bool]:
+        """
+        Gather thread state counts from INFORMATION_SCHEMA.PROCESSLIST.
+        """
+        return pulumi.get(self, "gather_process_list")
+
+    @property
+    @pulumi.getter(name="gatherSlaveStatus")
+    def gather_slave_status(self) -> Optional[bool]:
+        """
+        Gather metrics from SHOW SLAVE STATUS command output.
+        """
+        return pulumi.get(self, "gather_slave_status")
+
+    @property
+    @pulumi.getter(name="gatherTableIoWaits")
+    def gather_table_io_waits(self) -> Optional[bool]:
+        """
+        Gather metrics from PERFORMANCE_SCHEMA.TABLE_IO_WAITS_SUMMARY_BY_TABLE.
+        """
+        return pulumi.get(self, "gather_table_io_waits")
+
+    @property
+    @pulumi.getter(name="gatherTableLockWaits")
+    def gather_table_lock_waits(self) -> Optional[bool]:
+        """
+        Gather metrics from PERFORMANCE_SCHEMA.TABLE_LOCK_WAITS.
+        """
+        return pulumi.get(self, "gather_table_lock_waits")
+
+    @property
+    @pulumi.getter(name="gatherTableSchema")
+    def gather_table_schema(self) -> Optional[bool]:
+        """
+        Gather metrics from INFORMATION_SCHEMA.TABLES.
+        """
+        return pulumi.get(self, "gather_table_schema")
+
+    @property
+    @pulumi.getter(name="perfEventsStatementsDigestTextLimit")
+    def perf_events_statements_digest_text_limit(self) -> Optional[int]:
+        """
+        Truncates digest text from perf_events_statements into this many characters.
+        """
+        return pulumi.get(self, "perf_events_statements_digest_text_limit")
+
+    @property
+    @pulumi.getter(name="perfEventsStatementsLimit")
+    def perf_events_statements_limit(self) -> Optional[int]:
+        """
+        Limits metrics from perf_events_statements.
+        """
+        return pulumi.get(self, "perf_events_statements_limit")
+
+    @property
+    @pulumi.getter(name="perfEventsStatementsTimeLimit")
+    def perf_events_statements_time_limit(self) -> Optional[int]:
+        """
+        Only include perf_events_statements whose last seen is less than this many seconds.
+        """
+        return pulumi.get(self, "perf_events_statements_time_limit")
+
+