pulumi-aiven 6.19.0a1721845827__py3-none-any.whl → 6.20.0__py3-none-any.whl

pulumi_aiven/outputs.py

@@ -271,6 +271,17 @@ __all__ = [
     'ThanosThanosUserConfigPublicAccess',
     'ThanosThanosUserConfigQuery',
     'ThanosThanosUserConfigQueryFrontend',
+    'ValkeyComponent',
+    'ValkeyServiceIntegration',
+    'ValkeyTag',
+    'ValkeyTechEmail',
+    'ValkeyValkey',
+    'ValkeyValkeyUserConfig',
+    'ValkeyValkeyUserConfigIpFilterObject',
+    'ValkeyValkeyUserConfigMigration',
+    'ValkeyValkeyUserConfigPrivateAccess',
+    'ValkeyValkeyUserConfigPrivatelinkAccess',
+    'ValkeyValkeyUserConfigPublicAccess',
     'GetAccountAuthenticationSamlFieldMappingResult',
     'GetCassandaCassandraResult',
     'GetCassandaCassandraUserConfigResult',
@@ -536,6 +547,17 @@ __all__ = [
     'GetThanosThanosUserConfigPublicAccessResult',
     'GetThanosThanosUserConfigQueryResult',
     'GetThanosThanosUserConfigQueryFrontendResult',
+    'GetValkeyComponentResult',
+    'GetValkeyServiceIntegrationResult',
+    'GetValkeyTagResult',
+    'GetValkeyTechEmailResult',
+    'GetValkeyValkeyResult',
+    'GetValkeyValkeyUserConfigResult',
+    'GetValkeyValkeyUserConfigIpFilterObjectResult',
+    'GetValkeyValkeyUserConfigMigrationResult',
+    'GetValkeyValkeyUserConfigPrivateAccessResult',
+    'GetValkeyValkeyUserConfigPrivatelinkAccessResult',
+    'GetValkeyValkeyUserConfigPublicAccessResult',
 ]
 
 @pulumi.output_type
@@ -900,6 +922,10 @@ class CassandraCassandraUserConfigCassandra(dict):
             suggest = "batch_size_fail_threshold_in_kb"
         elif key == "batchSizeWarnThresholdInKb":
             suggest = "batch_size_warn_threshold_in_kb"
+        elif key == "readRequestTimeoutInMs":
+            suggest = "read_request_timeout_in_ms"
+        elif key == "writeRequestTimeoutInMs":
+            suggest = "write_request_timeout_in_ms"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in CassandraCassandraUserConfigCassandra. Access the value via the '{suggest}' property getter instead.")
@@ -915,11 +941,15 @@ class CassandraCassandraUserConfigCassandra(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):
+                 datacenter: Optional[str] = None,
+                 read_request_timeout_in_ms: Optional[int] = None,
+                 write_request_timeout_in_ms: Optional[int] = None):
         """
         :param int batch_size_fail_threshold_in_kb: Fail any multiple-partition batch exceeding this value. 50kb (10x warn threshold) by default. Example: `50`.
         :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. Example: `5`.
         :param str datacenter: Name of the datacenter to which nodes of this service belong. Can be set only when creating the service. Example: `my-service-google-west1`.
+        :param int read_request_timeout_in_ms: How long the coordinator waits for read operations to complete before timing it out. 5 seconds by default. Example: `5000`.
+        :param int write_request_timeout_in_ms: How long the coordinator waits for write requests to complete with at least one node in the local datacenter. 2 seconds by default. Example: `2000`.
         """
         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)
@@ -927,6 +957,10 @@ class CassandraCassandraUserConfigCassandra(dict):
             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)
+        if read_request_timeout_in_ms is not None:
+            pulumi.set(__self__, "read_request_timeout_in_ms", read_request_timeout_in_ms)
+        if write_request_timeout_in_ms is not None:
+            pulumi.set(__self__, "write_request_timeout_in_ms", write_request_timeout_in_ms)
 
     @property
     @pulumi.getter(name="batchSizeFailThresholdInKb")
@@ -952,6 +986,22 @@ class CassandraCassandraUserConfigCassandra(dict):
         """
         return pulumi.get(self, "datacenter")
 
+    @property
+    @pulumi.getter(name="readRequestTimeoutInMs")
+    def read_request_timeout_in_ms(self) -> Optional[int]:
+        """
+        How long the coordinator waits for read operations to complete before timing it out. 5 seconds by default. Example: `5000`.
+        """
+        return pulumi.get(self, "read_request_timeout_in_ms")
+
+    @property
+    @pulumi.getter(name="writeRequestTimeoutInMs")
+    def write_request_timeout_in_ms(self) -> Optional[int]:
+        """
+        How long the coordinator waits for write requests to complete with at least one node in the local datacenter. 2 seconds by default. Example: `2000`.
+        """
+        return pulumi.get(self, "write_request_timeout_in_ms")
+
 
 @pulumi.output_type
 class CassandraCassandraUserConfigIpFilterObject(dict):
@@ -1243,7 +1293,7 @@ class ClickhouseClickhouse(dict):
     def __init__(__self__, *,
                  uris: Optional[Sequence[str]] = None):
         """
-        :param Sequence[str] uris: Clickhouse server URIs.
+        :param Sequence[str] uris: ClickHouse server URIs.
         """
         if uris is not None:
             pulumi.set(__self__, "uris", uris)
@@ -1252,7 +1302,7 @@ class ClickhouseClickhouse(dict):
     @pulumi.getter
     def uris(self) -> Optional[Sequence[str]]:
         """
-        Clickhouse server URIs.
+        ClickHouse server URIs.
         """
         return pulumi.get(self, "uris")
 
@@ -1835,11 +1885,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. 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.
+        :param str database: The database to grant access 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 to grant access to. Changing this property forces recreation of the resource.
+        :param str privilege: The privileges to grant. For example: `INSERT`, `SELECT`, `CREATE TABLE`. A complete list is available in the [ClickHouse documentation](https://clickhouse.com/docs/en/sql-reference/statements/grant). Changing this property forces recreation of the resource.
+        :param str table: The table to grant access to. Changing this property forces recreation of the resource.
+        :param bool with_grant: Allow grantees to grant their privileges to other grantees. Changing this property forces recreation of the resource.
         """
         pulumi.set(__self__, "database", database)
         if column is not None:
@@ -1855,7 +1905,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. Changing this property forces recreation of the resource.
+        The database to grant access 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")
 
@@ -1863,7 +1913,7 @@ class ClickhouseGrantPrivilegeGrant(dict):
     @pulumi.getter
     def column(self) -> Optional[str]:
         """
-        The column that the grant refers to. Changing this property forces recreation of the resource.
+        The column to grant access to. Changing this property forces recreation of the resource.
         """
         return pulumi.get(self, "column")
 
@@ -1871,7 +1921,7 @@ class ClickhouseGrantPrivilegeGrant(dict):
     @pulumi.getter
     def privilege(self) -> Optional[str]:
         """
-        The privilege to grant, i.e. 'INSERT', 'SELECT', etc. Changing this property forces recreation of the resource.
+        The privileges to grant. For example: `INSERT`, `SELECT`, `CREATE TABLE`. A complete list is available in the [ClickHouse documentation](https://clickhouse.com/docs/en/sql-reference/statements/grant). Changing this property forces recreation of the resource.
         """
         return pulumi.get(self, "privilege")
 
@@ -1879,7 +1929,7 @@ class ClickhouseGrantPrivilegeGrant(dict):
     @pulumi.getter
     def table(self) -> Optional[str]:
         """
-        The table that the grant refers to. Changing this property forces recreation of the resource.
+        The table to grant access to. Changing this property forces recreation of the resource.
         """
         return pulumi.get(self, "table")
 
@@ -1887,7 +1937,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. Changing this property forces recreation of the resource.
+        Allow grantees to grant their privileges to other grantees. Changing this property forces recreation of the resource.
         """
         return pulumi.get(self, "with_grant")
 
@@ -1897,7 +1947,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. Changing this property forces recreation of the resource.
+        :param str role: The roles to grant. 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)
@@ -1906,7 +1956,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. Changing this property forces recreation of the resource.
+        The roles to grant. 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")
 
@@ -1936,8 +1986,8 @@ class ClickhouseServiceIntegration(dict):
                  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 source_service_name: Name of the source service
+        :param str integration_type: Type of the service integration. Supported integrations are `clickhouse_kafka` and `clickhouse_postgresql`.
+        :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)
@@ -1946,7 +1996,7 @@ class ClickhouseServiceIntegration(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. Supported integrations are `clickhouse_kafka` and `clickhouse_postgresql`.
         """
         return pulumi.get(self, "integration_type")
 
@@ -1954,7 +2004,7 @@ class ClickhouseServiceIntegration(dict):
     @pulumi.getter(name="sourceServiceName")
     def source_service_name(self) -> str:
         """
-        Name of the source service
+        Name of the source service.
         """
         return pulumi.get(self, "source_service_name")
 
@@ -3011,7 +3061,7 @@ class FlinkFlink(dict):
     def __init__(__self__, *,
                  host_ports: Optional[Sequence[str]] = None):
         """
-        :param Sequence[str] host_ports: Host and Port of a Flink server
+        :param Sequence[str] host_ports: The host and port of a Flink server.
         """
         if host_ports is not None:
             pulumi.set(__self__, "host_ports", host_ports)
@@ -3020,7 +3070,7 @@ class FlinkFlink(dict):
     @pulumi.getter(name="hostPorts")
     def host_ports(self) -> Optional[Sequence[str]]:
         """
-        Host and Port of a Flink server
+        The host and port of a Flink server.
         """
         return pulumi.get(self, "host_ports")
 
@@ -7041,7 +7091,7 @@ class KafkaConnectorTask(dict):
                  task: Optional[int] = None):
         """
         :param str connector: The name of the related connector.
-        :param int task: The task id of the task.
+        :param int task: The task ID of the task.
         """
         if connector is not None:
             pulumi.set(__self__, "connector", connector)
@@ -7060,7 +7110,7 @@ class KafkaConnectorTask(dict):
     @pulumi.getter
     def task(self) -> Optional[int]:
         """
-        The task id of the task.
+        The task ID of the task.
         """
         return pulumi.get(self, "task")
 
@@ -10312,8 +10362,8 @@ class KafkaTopicTag(dict):
                  key: str,
                  value: Optional[str] = None):
         """
-        :param str key: Topic tag key. Maximum length: `64`.
-        :param str value: Topic tag value. Maximum length: `256`.
+        :param str key: Tag key. Maximum length: `64`.
+        :param str value: Tag value. Maximum length: `256`.
         """
         pulumi.set(__self__, "key", key)
         if value is not None:
@@ -10323,7 +10373,7 @@ class KafkaTopicTag(dict):
     @pulumi.getter
     def key(self) -> str:
         """
-        Topic tag key. Maximum length: `64`.
+        Tag key. Maximum length: `64`.
         """
         return pulumi.get(self, "key")
 
@@ -10331,7 +10381,7 @@ class KafkaTopicTag(dict):
     @pulumi.getter
     def value(self) -> Optional[str]:
         """
-        Topic tag value. Maximum length: `256`.
+        Tag value. Maximum length: `256`.
         """
         return pulumi.get(self, "value")
 
@@ -14379,6 +14429,10 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
             suggest = "ism_history_rollover_check_period"
         elif key == "ismHistoryRolloverRetentionPeriod":
             suggest = "ism_history_rollover_retention_period"
+        elif key == "knnMemoryCircuitBreakerEnabled":
+            suggest = "knn_memory_circuit_breaker_enabled"
+        elif key == "knnMemoryCircuitBreakerLimit":
+            suggest = "knn_memory_circuit_breaker_limit"
         elif key == "overrideMainResponseVersion":
             suggest = "override_main_response_version"
         elif key == "pluginsAlertingFilterByBackendRoles":
@@ -14450,6 +14504,8 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
                  ism_history_max_docs: Optional[int] = None,
                  ism_history_rollover_check_period: Optional[int] = None,
                  ism_history_rollover_retention_period: Optional[int] = None,
+                 knn_memory_circuit_breaker_enabled: Optional[bool] = None,
+                 knn_memory_circuit_breaker_limit: 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,
@@ -14493,6 +14549,8 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
         :param int ism_history_max_docs: The maximum number of documents before rolling over the audit history index. Default: `2500000`.
         :param int ism_history_rollover_check_period: The time between rollover checks for the audit history index in hours. Default: `8`.
         :param int ism_history_rollover_retention_period: How long audit history indices are kept in days. Default: `30`.
+        :param bool knn_memory_circuit_breaker_enabled: Enable or disable KNN memory circuit breaker. Defaults to true. Default: `true`.
+        :param int knn_memory_circuit_breaker_limit: Maximum amount of memory that can be used for KNN index. Defaults to 50% of the JVM heap size. Default: `50`.
         :param bool 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.
@@ -14562,6 +14620,10 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
             pulumi.set(__self__, "ism_history_rollover_check_period", ism_history_rollover_check_period)
         if ism_history_rollover_retention_period is not None:
             pulumi.set(__self__, "ism_history_rollover_retention_period", ism_history_rollover_retention_period)
+        if knn_memory_circuit_breaker_enabled is not None:
+            pulumi.set(__self__, "knn_memory_circuit_breaker_enabled", knn_memory_circuit_breaker_enabled)
+        if knn_memory_circuit_breaker_limit is not None:
+            pulumi.set(__self__, "knn_memory_circuit_breaker_limit", knn_memory_circuit_breaker_limit)
         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:
@@ -14803,6 +14865,22 @@ class OpenSearchOpensearchUserConfigOpensearch(dict):
         """
         return pulumi.get(self, "ism_history_rollover_retention_period")
 
+    @property
+    @pulumi.getter(name="knnMemoryCircuitBreakerEnabled")
+    def knn_memory_circuit_breaker_enabled(self) -> Optional[bool]:
+        """
+        Enable or disable KNN memory circuit breaker. Defaults to true. Default: `true`.
+        """
+        return pulumi.get(self, "knn_memory_circuit_breaker_enabled")
+
+    @property
+    @pulumi.getter(name="knnMemoryCircuitBreakerLimit")
+    def knn_memory_circuit_breaker_limit(self) -> Optional[int]:
+        """
+        Maximum amount of memory that can be used for KNN index. Defaults to 50% of the JVM heap size. Default: `50`.
+        """
+        return pulumi.get(self, "knn_memory_circuit_breaker_limit")
+
     @property
     @pulumi.getter(name="overrideMainResponseVersion")
     def override_main_response_version(self) -> Optional[bool]:
@@ -17026,7 +17104,7 @@ class PgPgUserConfigPg(dict):
         :param bool jit: Controls system-wide use of Just-in-Time Compilation (JIT).
         :param int log_autovacuum_min_duration: Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one (the default) disables logging autovacuum actions.
         :param str log_error_verbosity: Enum: `TERSE`, `DEFAULT`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
-        :param str log_line_prefix: Enum: `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'%m [%p] %q[user=%u,db=%d,app=%a] '`. Choose from one of the available log formats.
+        :param str log_line_prefix: Enum: `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
         :param int log_min_duration_statement: Log statements that take more than this number of milliseconds to run, -1 disables.
         :param int log_temp_files: Log statements for each temporary file created larger than this number of kilobytes, -1 disables.
         :param int max_files_per_process: PostgreSQL maximum number of files that can be open per process.
@@ -17312,7 +17390,7 @@ class PgPgUserConfigPg(dict):
     @pulumi.getter(name="logLinePrefix")
     def log_line_prefix(self) -> Optional[str]:
         """
-        Enum: `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'%m [%p] %q[user=%u,db=%d,app=%a] '`. Choose from one of the available log formats.
+        Enum: `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
         """
         return pulumi.get(self, "log_line_prefix")
 
@@ -23099,204 +23177,470 @@ class ThanosThanosUserConfigQueryFrontend(dict):
 
 
 @pulumi.output_type
-class GetAccountAuthenticationSamlFieldMappingResult(dict):
+class ValkeyComponent(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 ValkeyComponent. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ValkeyComponent.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ValkeyComponent.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 email: Optional[str] = None,
-                 first_name: Optional[str] = None,
-                 identity: Optional[str] = None,
-                 last_name: Optional[str] = None,
-                 real_name: Optional[str] = None):
+                 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 email: Field name for user email
-        :param str first_name: Field name for user's first name
-        :param str identity: Field name for user's identity. This field must always exist in responses, and must be immutable and unique. Contents of this field are used to identify the user. Using user ID (such as unix user id) is highly recommended, as email address may change, requiring relinking user to Aiven user.
-        :param str last_name: Field name for user's last name
-        :param str real_name: Field name for user's full name. If specified, first_name and last_name mappings are ignored
+        :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 email is not None:
-            pulumi.set(__self__, "email", email)
-        if first_name is not None:
-            pulumi.set(__self__, "first_name", first_name)
-        if identity is not None:
-            pulumi.set(__self__, "identity", identity)
-        if last_name is not None:
-            pulumi.set(__self__, "last_name", last_name)
-        if real_name is not None:
-            pulumi.set(__self__, "real_name", real_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 email(self) -> Optional[str]:
+    def component(self) -> Optional[str]:
         """
-        Field name for user email
+        Service component name
         """
-        return pulumi.get(self, "email")
+        return pulumi.get(self, "component")
 
     @property
-    @pulumi.getter(name="firstName")
-    def first_name(self) -> Optional[str]:
+    @pulumi.getter(name="connectionUri")
+    def connection_uri(self) -> Optional[str]:
         """
-        Field name for user's first name
+        Connection info for connecting to the service component. This is a combination of host and port.
         """
-        return pulumi.get(self, "first_name")
+        return pulumi.get(self, "connection_uri")
 
     @property
     @pulumi.getter
-    def identity(self) -> Optional[str]:
+    def host(self) -> Optional[str]:
         """
-        Field name for user's identity. This field must always exist in responses, and must be immutable and unique. Contents of this field are used to identify the user. Using user ID (such as unix user id) is highly recommended, as email address may change, requiring relinking user to Aiven user.
+        Host name for connecting to the service component
         """
-        return pulumi.get(self, "identity")
+        return pulumi.get(self, "host")
 
     @property
-    @pulumi.getter(name="lastName")
-    def last_name(self) -> Optional[str]:
+    @pulumi.getter(name="kafkaAuthenticationMethod")
+    def kafka_authentication_method(self) -> Optional[str]:
         """
-        Field name for user's last name
+        Kafka authentication method. This is a value specific to the 'kafka' service component
         """
-        return pulumi.get(self, "last_name")
+        return pulumi.get(self, "kafka_authentication_method")
 
     @property
-    @pulumi.getter(name="realName")
-    def real_name(self) -> Optional[str]:
+    @pulumi.getter
+    def port(self) -> Optional[int]:
         """
-        Field name for user's full name. If specified, first_name and last_name mappings are ignored
+        Port number for connecting to the service component
         """
-        return pulumi.get(self, "real_name")
+        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 GetCassandaCassandraResult(dict):
+class ValkeyServiceIntegration(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 ValkeyServiceIntegration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ValkeyServiceIntegration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ValkeyServiceIntegration.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 uris: Sequence[str]):
+                 integration_type: str,
+                 source_service_name: str):
         """
-        :param Sequence[str] uris: Cassandra server URIs.
+        :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__, "uris", uris)
+        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 ValkeyTag(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 uris(self) -> Sequence[str]:
+    def key(self) -> str:
         """
-        Cassandra server URIs.
+        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 ValkeyTechEmail(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 ValkeyValkey(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "replicaUri":
+            suggest = "replica_uri"
+        elif key == "slaveUris":
+            suggest = "slave_uris"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ValkeyValkey. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ValkeyValkey.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ValkeyValkey.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 password: Optional[str] = None,
+                 replica_uri: Optional[str] = None,
+                 slave_uris: Optional[Sequence[str]] = None,
+                 uris: Optional[Sequence[str]] = None):
+        """
+        :param str password: Valkey password.
+        :param str replica_uri: Valkey replica server URI.
+        :param Sequence[str] slave_uris: Valkey slave server URIs.
+        :param Sequence[str] uris: Valkey server URIs.
+        """
+        if password is not None:
+            pulumi.set(__self__, "password", password)
+        if replica_uri is not None:
+            pulumi.set(__self__, "replica_uri", replica_uri)
+        if slave_uris is not None:
+            pulumi.set(__self__, "slave_uris", slave_uris)
+        if uris is not None:
+            pulumi.set(__self__, "uris", uris)
+
+    @property
+    @pulumi.getter
+    def password(self) -> Optional[str]:
+        """
+        Valkey password.
+        """
+        return pulumi.get(self, "password")
+
+    @property
+    @pulumi.getter(name="replicaUri")
+    def replica_uri(self) -> Optional[str]:
+        """
+        Valkey replica server URI.
+        """
+        return pulumi.get(self, "replica_uri")
+
+    @property
+    @pulumi.getter(name="slaveUris")
+    def slave_uris(self) -> Optional[Sequence[str]]:
+        """
+        Valkey slave server URIs.
+        """
+        return pulumi.get(self, "slave_uris")
+
+    @property
+    @pulumi.getter
+    def uris(self) -> Optional[Sequence[str]]:
+        """
+        Valkey server URIs.
         """
         return pulumi.get(self, "uris")
 
 
 @pulumi.output_type
-class GetCassandaCassandraUserConfigResult(dict):
+class ValkeyValkeyUserConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "additionalBackupRegions":
+            suggest = "additional_backup_regions"
+        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"
+        elif key == "valkeyAclChannelsDefault":
+            suggest = "valkey_acl_channels_default"
+        elif key == "valkeyIoThreads":
+            suggest = "valkey_io_threads"
+        elif key == "valkeyLfuDecayTime":
+            suggest = "valkey_lfu_decay_time"
+        elif key == "valkeyLfuLogFactor":
+            suggest = "valkey_lfu_log_factor"
+        elif key == "valkeyMaxmemoryPolicy":
+            suggest = "valkey_maxmemory_policy"
+        elif key == "valkeyNotifyKeyspaceEvents":
+            suggest = "valkey_notify_keyspace_events"
+        elif key == "valkeyNumberOfDatabases":
+            suggest = "valkey_number_of_databases"
+        elif key == "valkeyPersistence":
+            suggest = "valkey_persistence"
+        elif key == "valkeyPubsubClientOutputBufferLimit":
+            suggest = "valkey_pubsub_client_output_buffer_limit"
+        elif key == "valkeySsl":
+            suggest = "valkey_ssl"
+        elif key == "valkeyTimeout":
+            suggest = "valkey_timeout"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ValkeyValkeyUserConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ValkeyValkeyUserConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ValkeyValkeyUserConfig.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
                  additional_backup_regions: Optional[str] = None,
-                 backup_hour: Optional[int] = None,
-                 backup_minute: Optional[int] = None,
-                 cassandra: Optional['outputs.GetCassandaCassandraUserConfigCassandraResult'] = None,
-                 cassandra_version: Optional[str] = None,
-                 ip_filter_objects: Optional[Sequence['outputs.GetCassandaCassandraUserConfigIpFilterObjectResult']] = None,
+                 ip_filter_objects: Optional[Sequence['outputs.ValkeyValkeyUserConfigIpFilterObject']] = None,
                  ip_filter_strings: Optional[Sequence[str]] = None,
                  ip_filters: Optional[Sequence[str]] = None,
-                 migrate_sstableloader: Optional[bool] = None,
-                 private_access: Optional['outputs.GetCassandaCassandraUserConfigPrivateAccessResult'] = None,
+                 migration: Optional['outputs.ValkeyValkeyUserConfigMigration'] = None,
+                 private_access: Optional['outputs.ValkeyValkeyUserConfigPrivateAccess'] = None,
+                 privatelink_access: Optional['outputs.ValkeyValkeyUserConfigPrivatelinkAccess'] = None,
                  project_to_fork_from: Optional[str] = None,
-                 public_access: Optional['outputs.GetCassandaCassandraUserConfigPublicAccessResult'] = None,
+                 public_access: Optional['outputs.ValkeyValkeyUserConfigPublicAccess'] = None,
+                 recovery_basebackup_name: Optional[str] = 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):
+                 static_ips: Optional[bool] = None,
+                 valkey_acl_channels_default: Optional[str] = None,
+                 valkey_io_threads: Optional[int] = None,
+                 valkey_lfu_decay_time: Optional[int] = None,
+                 valkey_lfu_log_factor: Optional[int] = None,
+                 valkey_maxmemory_policy: Optional[str] = None,
+                 valkey_notify_keyspace_events: Optional[str] = None,
+                 valkey_number_of_databases: Optional[int] = None,
+                 valkey_persistence: Optional[str] = None,
+                 valkey_pubsub_client_output_buffer_limit: Optional[int] = None,
+                 valkey_ssl: Optional[bool] = None,
+                 valkey_timeout: Optional[int] = 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. Example: `3`.
-        :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. Example: `30`.
-        :param 'GetCassandaCassandraUserConfigCassandraArgs' cassandra: Cassandra configuration values
-        :param str cassandra_version: Enum: `3`, `4`, `4.1`, and newer. Cassandra version.
-        :param Sequence['GetCassandaCassandraUserConfigIpFilterObjectArgs'] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
+        :param Sequence['ValkeyValkeyUserConfigIpFilterObjectArgs'] 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 'GetCassandaCassandraUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
+        :param 'ValkeyValkeyUserConfigMigrationArgs' migration: Migrate data from existing server
+        :param 'ValkeyValkeyUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
+        :param 'ValkeyValkeyUserConfigPrivatelinkAccessArgs' 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. Example: `anotherprojectname`.
-        :param 'GetCassandaCassandraUserConfigPublicAccessArgs' public_access: Allow access to selected service ports from the public Internet
+        :param 'ValkeyValkeyUserConfigPublicAccessArgs' 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. Example: `backup-20191112t091354293891z`.
         :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. Example: `anotherservicename`.
-        :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. Example: `my-test-cassandra`.
         :param bool static_ips: Use static public IP addresses.
+        :param str valkey_acl_channels_default: Enum: `allchannels`, `resetchannels`. Determines default pub/sub channels' ACL for new users if ACL is not supplied. When this option is not defined, all_channels is assumed to keep backward compatibility. This option doesn't affect Valkey configuration acl-pubsub-default.
+        :param int valkey_io_threads: Set Valkey IO thread count. Changing this will cause a restart of the Valkey service. Example: `1`.
+        :param int valkey_lfu_decay_time: LFU maxmemory-policy counter decay time in minutes. Default: `1`.
+        :param int valkey_lfu_log_factor: Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies. Default: `10`.
+        :param str valkey_maxmemory_policy: Enum: `noeviction`, `allkeys-lru`, `volatile-lru`, `allkeys-random`, `volatile-random`, `volatile-ttl`, `volatile-lfu`, `allkeys-lfu`. Valkey maxmemory-policy. Default: `noeviction`.
+        :param str valkey_notify_keyspace_events: Set notify-keyspace-events option.
+        :param int valkey_number_of_databases: Set number of Valkey databases. Changing this will cause a restart of the Valkey service. Example: `16`.
+        :param str valkey_persistence: Enum: `off`, `rdb`. When persistence is `rdb`, Valkey does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
+        :param int valkey_pubsub_client_output_buffer_limit: Set output buffer limit for pub / sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan. Example: `64`.
+        :param bool valkey_ssl: Require SSL to access Valkey. Default: `true`.
+        :param int valkey_timeout: Valkey idle connection timeout in seconds. Default: `300`.
         """
         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 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 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)
+        if valkey_acl_channels_default is not None:
+            pulumi.set(__self__, "valkey_acl_channels_default", valkey_acl_channels_default)
+        if valkey_io_threads is not None:
+            pulumi.set(__self__, "valkey_io_threads", valkey_io_threads)
+        if valkey_lfu_decay_time is not None:
+            pulumi.set(__self__, "valkey_lfu_decay_time", valkey_lfu_decay_time)
+        if valkey_lfu_log_factor is not None:
+            pulumi.set(__self__, "valkey_lfu_log_factor", valkey_lfu_log_factor)
+        if valkey_maxmemory_policy is not None:
+            pulumi.set(__self__, "valkey_maxmemory_policy", valkey_maxmemory_policy)
+        if valkey_notify_keyspace_events is not None:
+            pulumi.set(__self__, "valkey_notify_keyspace_events", valkey_notify_keyspace_events)
+        if valkey_number_of_databases is not None:
+            pulumi.set(__self__, "valkey_number_of_databases", valkey_number_of_databases)
+        if valkey_persistence is not None:
+            pulumi.set(__self__, "valkey_persistence", valkey_persistence)
+        if valkey_pubsub_client_output_buffer_limit is not None:
+            pulumi.set(__self__, "valkey_pubsub_client_output_buffer_limit", valkey_pubsub_client_output_buffer_limit)
+        if valkey_ssl is not None:
+            pulumi.set(__self__, "valkey_ssl", valkey_ssl)
+        if valkey_timeout is not None:
+            pulumi.set(__self__, "valkey_timeout", valkey_timeout)
 
     @property
     @pulumi.getter(name="additionalBackupRegions")
-    @_utilities.deprecated("""This property is deprecated.""")
     def additional_backup_regions(self) -> Optional[str]:
         """
         Additional Cloud Regions for Backup Replication.
         """
         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. Example: `3`.
-        """
-        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. Example: `30`.
-        """
-        return pulumi.get(self, "backup_minute")
-
-    @property
-    @pulumi.getter
-    def cassandra(self) -> Optional['outputs.GetCassandaCassandraUserConfigCassandraResult']:
-        """
-        Cassandra configuration values
-        """
-        return pulumi.get(self, "cassandra")
-
-    @property
-    @pulumi.getter(name="cassandraVersion")
-    def cassandra_version(self) -> Optional[str]:
-        """
-        Enum: `3`, `4`, `4.1`, and newer. Cassandra version.
-        """
-        return pulumi.get(self, "cassandra_version")
-
     @property
     @pulumi.getter(name="ipFilterObjects")
-    def ip_filter_objects(self) -> Optional[Sequence['outputs.GetCassandaCassandraUserConfigIpFilterObjectResult']]:
+    def ip_filter_objects(self) -> Optional[Sequence['outputs.ValkeyValkeyUserConfigIpFilterObject']]:
         """
         Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
         """
@@ -23320,21 +23664,29 @@ class GetCassandaCassandraUserConfigResult(dict):
         return pulumi.get(self, "ip_filters")
 
     @property
-    @pulumi.getter(name="migrateSstableloader")
-    def migrate_sstableloader(self) -> Optional[bool]:
+    @pulumi.getter
+    def migration(self) -> Optional['outputs.ValkeyValkeyUserConfigMigration']:
         """
-        Sets the service into migration mode enabling the sstableloader utility to be used to upload Cassandra data files. Available only on service create.
+        Migrate data from existing server
         """
-        return pulumi.get(self, "migrate_sstableloader")
+        return pulumi.get(self, "migration")
 
     @property
     @pulumi.getter(name="privateAccess")
-    def private_access(self) -> Optional['outputs.GetCassandaCassandraUserConfigPrivateAccessResult']:
+    def private_access(self) -> Optional['outputs.ValkeyValkeyUserConfigPrivateAccess']:
         """
         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.ValkeyValkeyUserConfigPrivatelinkAccess']:
+        """
+        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]:
@@ -23345,12 +23697,20 @@ class GetCassandaCassandraUserConfigResult(dict):
 
     @property
     @pulumi.getter(name="publicAccess")
-    def public_access(self) -> Optional['outputs.GetCassandaCassandraUserConfigPublicAccessResult']:
+    def public_access(self) -> Optional['outputs.ValkeyValkeyUserConfigPublicAccess']:
         """
         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. Example: `backup-20191112t091354293891z`.
+        """
+        return pulumi.get(self, "recovery_basebackup_name")
+
     @property
     @pulumi.getter(name="serviceLog")
     def service_log(self) -> Optional[bool]:
@@ -23367,14 +23727,6 @@ class GetCassandaCassandraUserConfigResult(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. Example: `my-test-cassandra`.
-        """
-        return pulumi.get(self, "service_to_join_with")
-
     @property
     @pulumi.getter(name="staticIps")
     def static_ips(self) -> Optional[bool]:
@@ -23383,52 +23735,97 @@ class GetCassandaCassandraUserConfigResult(dict):
         """
         return pulumi.get(self, "static_ips")
 
+    @property
+    @pulumi.getter(name="valkeyAclChannelsDefault")
+    def valkey_acl_channels_default(self) -> Optional[str]:
+        """
+        Enum: `allchannels`, `resetchannels`. Determines default pub/sub channels' ACL for new users if ACL is not supplied. When this option is not defined, all_channels is assumed to keep backward compatibility. This option doesn't affect Valkey configuration acl-pubsub-default.
+        """
+        return pulumi.get(self, "valkey_acl_channels_default")
 
-@pulumi.output_type
-class GetCassandaCassandraUserConfigCassandraResult(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):
+    @property
+    @pulumi.getter(name="valkeyIoThreads")
+    def valkey_io_threads(self) -> Optional[int]:
         """
-        :param int batch_size_fail_threshold_in_kb: Fail any multiple-partition batch exceeding this value. 50kb (10x warn threshold) by default. Example: `50`.
-        :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. Example: `5`.
-        :param str datacenter: Name of the datacenter to which nodes of this service belong. Can be set only when creating the service. Example: `my-service-google-west1`.
+        Set Valkey IO thread count. Changing this will cause a restart of the Valkey service. Example: `1`.
         """
-        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)
+        return pulumi.get(self, "valkey_io_threads")
 
     @property
-    @pulumi.getter(name="batchSizeFailThresholdInKb")
-    def batch_size_fail_threshold_in_kb(self) -> Optional[int]:
+    @pulumi.getter(name="valkeyLfuDecayTime")
+    def valkey_lfu_decay_time(self) -> Optional[int]:
         """
-        Fail any multiple-partition batch exceeding this value. 50kb (10x warn threshold) by default. Example: `50`.
+        LFU maxmemory-policy counter decay time in minutes. Default: `1`.
         """
-        return pulumi.get(self, "batch_size_fail_threshold_in_kb")
+        return pulumi.get(self, "valkey_lfu_decay_time")
 
     @property
-    @pulumi.getter(name="batchSizeWarnThresholdInKb")
-    def batch_size_warn_threshold_in_kb(self) -> Optional[int]:
+    @pulumi.getter(name="valkeyLfuLogFactor")
+    def valkey_lfu_log_factor(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. Example: `5`.
+        Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies. Default: `10`.
         """
-        return pulumi.get(self, "batch_size_warn_threshold_in_kb")
+        return pulumi.get(self, "valkey_lfu_log_factor")
 
     @property
-    @pulumi.getter
-    def datacenter(self) -> Optional[str]:
+    @pulumi.getter(name="valkeyMaxmemoryPolicy")
+    def valkey_maxmemory_policy(self) -> Optional[str]:
         """
-        Name of the datacenter to which nodes of this service belong. Can be set only when creating the service. Example: `my-service-google-west1`.
+        Enum: `noeviction`, `allkeys-lru`, `volatile-lru`, `allkeys-random`, `volatile-random`, `volatile-ttl`, `volatile-lfu`, `allkeys-lfu`. Valkey maxmemory-policy. Default: `noeviction`.
         """
-        return pulumi.get(self, "datacenter")
+        return pulumi.get(self, "valkey_maxmemory_policy")
+
+    @property
+    @pulumi.getter(name="valkeyNotifyKeyspaceEvents")
+    def valkey_notify_keyspace_events(self) -> Optional[str]:
+        """
+        Set notify-keyspace-events option.
+        """
+        return pulumi.get(self, "valkey_notify_keyspace_events")
+
+    @property
+    @pulumi.getter(name="valkeyNumberOfDatabases")
+    def valkey_number_of_databases(self) -> Optional[int]:
+        """
+        Set number of Valkey databases. Changing this will cause a restart of the Valkey service. Example: `16`.
+        """
+        return pulumi.get(self, "valkey_number_of_databases")
+
+    @property
+    @pulumi.getter(name="valkeyPersistence")
+    def valkey_persistence(self) -> Optional[str]:
+        """
+        Enum: `off`, `rdb`. When persistence is `rdb`, Valkey does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
+        """
+        return pulumi.get(self, "valkey_persistence")
+
+    @property
+    @pulumi.getter(name="valkeyPubsubClientOutputBufferLimit")
+    def valkey_pubsub_client_output_buffer_limit(self) -> Optional[int]:
+        """
+        Set output buffer limit for pub / sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan. Example: `64`.
+        """
+        return pulumi.get(self, "valkey_pubsub_client_output_buffer_limit")
+
+    @property
+    @pulumi.getter(name="valkeySsl")
+    def valkey_ssl(self) -> Optional[bool]:
+        """
+        Require SSL to access Valkey. Default: `true`.
+        """
+        return pulumi.get(self, "valkey_ssl")
+
+    @property
+    @pulumi.getter(name="valkeyTimeout")
+    def valkey_timeout(self) -> Optional[int]:
+        """
+        Valkey idle connection timeout in seconds. Default: `300`.
+        """
+        return pulumi.get(self, "valkey_timeout")
 
 
 @pulumi.output_type
-class GetCassandaCassandraUserConfigIpFilterObjectResult(dict):
+class ValkeyValkeyUserConfigIpFilterObject(dict):
     def __init__(__self__, *,
                  network: str,
                  description: Optional[str] = None):
@@ -23458,216 +23855,285 @@ class GetCassandaCassandraUserConfigIpFilterObjectResult(dict):
 
 
 @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)
+class ValkeyValkeyUserConfigMigration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "ignoreDbs":
+            suggest = "ignore_dbs"
 
-    @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")
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ValkeyValkeyUserConfigMigration. Access the value via the '{suggest}' property getter instead.")
 
+    def __getitem__(self, key: str) -> Any:
+        ValkeyValkeyUserConfigMigration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ValkeyValkeyUserConfigMigration.__key_warning(key)
+        return super().get(key, default)
 
-@pulumi.output_type
-class GetCassandaCassandraUserConfigPublicAccessResult(dict):
     def __init__(__self__, *,
-                 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 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 str host: Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
+        :param int port: Port number of the server where to migrate data from. Example: `1234`.
+        :param str dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
+        :param str ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
+        :param str method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
+        :param str password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
+        :param bool ssl: The server where to migrate data from is secured with SSL. Default: `true`.
+        :param str username: User name for authentication with the server where to migrate data from. Example: `myname`.
         """
-        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 prometheus(self) -> Optional[bool]:
+    def host(self) -> str:
         """
-        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.
+        Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
         """
-        return pulumi.get(self, "prometheus")
-
+        return pulumi.get(self, "host")
 
-@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):
+    @property
+    @pulumi.getter
+    def port(self) -> int:
         """
-        :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
+        Port number of the server where to migrate data from. Example: `1234`.
         """
-        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)
+        return pulumi.get(self, "port")
 
     @property
     @pulumi.getter
-    def component(self) -> str:
+    def dbname(self) -> Optional[str]:
         """
-        Service component name
+        Database name for bootstrapping the initial connection. Example: `defaultdb`.
         """
-        return pulumi.get(self, "component")
+        return pulumi.get(self, "dbname")
 
     @property
-    @pulumi.getter(name="connectionUri")
-    def connection_uri(self) -> str:
+    @pulumi.getter(name="ignoreDbs")
+    def ignore_dbs(self) -> Optional[str]:
         """
-        Connection info for connecting to the service component. This is a combination of host and port.
+        Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
         """
-        return pulumi.get(self, "connection_uri")
+        return pulumi.get(self, "ignore_dbs")
 
     @property
     @pulumi.getter
-    def host(self) -> str:
+    def method(self) -> Optional[str]:
         """
-        Host name for connecting to the service component
+        Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
         """
-        return pulumi.get(self, "host")
+        return pulumi.get(self, "method")
 
     @property
-    @pulumi.getter(name="kafkaAuthenticationMethod")
-    def kafka_authentication_method(self) -> str:
+    @pulumi.getter
+    def password(self) -> Optional[str]:
         """
-        Kafka authentication method. This is a value specific to the 'kafka' service component
+        Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
         """
-        return pulumi.get(self, "kafka_authentication_method")
+        return pulumi.get(self, "password")
 
     @property
     @pulumi.getter
-    def port(self) -> int:
+    def ssl(self) -> Optional[bool]:
         """
-        Port number for connecting to the service component
+        The server where to migrate data from is secured with SSL. Default: `true`.
         """
-        return pulumi.get(self, "port")
+        return pulumi.get(self, "ssl")
 
     @property
     @pulumi.getter
-    def route(self) -> str:
+    def username(self) -> Optional[str]:
         """
-        Network access route
+        User name for authentication with the server where to migrate data from. Example: `myname`.
         """
-        return pulumi.get(self, "route")
+        return pulumi.get(self, "username")
+
+
+@pulumi.output_type
+class ValkeyValkeyUserConfigPrivateAccess(dict):
+    def __init__(__self__, *,
+                 prometheus: Optional[bool] = None,
+                 valkey: 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.
+        :param bool valkey: Allow clients to connect to valkey 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)
+        if valkey is not None:
+            pulumi.set(__self__, "valkey", valkey)
 
     @property
     @pulumi.getter
-    def ssl(self) -> bool:
+    def prometheus(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 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, "ssl")
+        return pulumi.get(self, "prometheus")
 
     @property
     @pulumi.getter
-    def usage(self) -> str:
+    def valkey(self) -> Optional[bool]:
         """
-        DNS usage name
+        Allow clients to connect to valkey with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
         """
-        return pulumi.get(self, "usage")
+        return pulumi.get(self, "valkey")
 
 
 @pulumi.output_type
-class GetCassandaServiceIntegrationResult(dict):
+class ValkeyValkeyUserConfigPrivatelinkAccess(dict):
     def __init__(__self__, *,
-                 integration_type: str,
-                 source_service_name: str):
+                 prometheus: Optional[bool] = None,
+                 valkey: Optional[bool] = None):
         """
-        :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
+        :param bool prometheus: Enable prometheus.
+        :param bool valkey: Enable valkey.
         """
-        pulumi.set(__self__, "integration_type", integration_type)
-        pulumi.set(__self__, "source_service_name", source_service_name)
+        if prometheus is not None:
+            pulumi.set(__self__, "prometheus", prometheus)
+        if valkey is not None:
+            pulumi.set(__self__, "valkey", valkey)
 
     @property
-    @pulumi.getter(name="integrationType")
-    def integration_type(self) -> str:
+    @pulumi.getter
+    def prometheus(self) -> Optional[bool]:
         """
-        Type of the service integration. The only supported value at the moment is `read_replica`
+        Enable prometheus.
         """
-        return pulumi.get(self, "integration_type")
+        return pulumi.get(self, "prometheus")
 
     @property
-    @pulumi.getter(name="sourceServiceName")
-    def source_service_name(self) -> str:
+    @pulumi.getter
+    def valkey(self) -> Optional[bool]:
         """
-        Name of the source service
+        Enable valkey.
         """
-        return pulumi.get(self, "source_service_name")
+        return pulumi.get(self, "valkey")
 
 
 @pulumi.output_type
-class GetCassandaTagResult(dict):
+class ValkeyValkeyUserConfigPublicAccess(dict):
     def __init__(__self__, *,
-                 key: str,
-                 value: str):
+                 prometheus: Optional[bool] = None,
+                 valkey: Optional[bool] = None):
         """
-        :param str key: Service tag key
-        :param str value: Service tag value
+        :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 valkey: Allow clients to connect to valkey from the public internet for service nodes that are in a project VPC or another type of private network.
         """
-        pulumi.set(__self__, "key", key)
-        pulumi.set(__self__, "value", value)
+        if prometheus is not None:
+            pulumi.set(__self__, "prometheus", prometheus)
+        if valkey is not None:
+            pulumi.set(__self__, "valkey", valkey)
 
     @property
     @pulumi.getter
-    def key(self) -> str:
+    def prometheus(self) -> Optional[bool]:
         """
-        Service tag key
+        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, "key")
+        return pulumi.get(self, "prometheus")
 
     @property
     @pulumi.getter
-    def value(self) -> str:
+    def valkey(self) -> Optional[bool]:
         """
-        Service tag value
+        Allow clients to connect to valkey from the public internet for service nodes that are in a project VPC or another type of private network.
         """
-        return pulumi.get(self, "value")
+        return pulumi.get(self, "valkey")
 
 
 @pulumi.output_type
-class GetCassandaTechEmailResult(dict):
+class GetAccountAuthenticationSamlFieldMappingResult(dict):
     def __init__(__self__, *,
-                 email: str):
+                 email: Optional[str] = None,
+                 first_name: Optional[str] = None,
+                 identity: Optional[str] = None,
+                 last_name: Optional[str] = None,
+                 real_name: Optional[str] = None):
         """
-        :param str email: An email address to contact for technical issues
+        :param str email: Field name for user email
+        :param str first_name: Field name for user's first name
+        :param str identity: Field name for user's identity. This field must always exist in responses, and must be immutable and unique. Contents of this field are used to identify the user. Using user ID (such as unix user id) is highly recommended, as email address may change, requiring relinking user to Aiven user.
+        :param str last_name: Field name for user's last name
+        :param str real_name: Field name for user's full name. If specified, first_name and last_name mappings are ignored
         """
-        pulumi.set(__self__, "email", email)
+        if email is not None:
+            pulumi.set(__self__, "email", email)
+        if first_name is not None:
+            pulumi.set(__self__, "first_name", first_name)
+        if identity is not None:
+            pulumi.set(__self__, "identity", identity)
+        if last_name is not None:
+            pulumi.set(__self__, "last_name", last_name)
+        if real_name is not None:
+            pulumi.set(__self__, "real_name", real_name)
 
     @property
     @pulumi.getter
-    def email(self) -> str:
+    def email(self) -> Optional[str]:
         """
-        An email address to contact for technical issues
+        Field name for user email
         """
         return pulumi.get(self, "email")
 
+    @property
+    @pulumi.getter(name="firstName")
+    def first_name(self) -> Optional[str]:
+        """
+        Field name for user's first name
+        """
+        return pulumi.get(self, "first_name")
+
+    @property
+    @pulumi.getter
+    def identity(self) -> Optional[str]:
+        """
+        Field name for user's identity. This field must always exist in responses, and must be immutable and unique. Contents of this field are used to identify the user. Using user ID (such as unix user id) is highly recommended, as email address may change, requiring relinking user to Aiven user.
+        """
+        return pulumi.get(self, "identity")
+
+    @property
+    @pulumi.getter(name="lastName")
+    def last_name(self) -> Optional[str]:
+        """
+        Field name for user's last name
+        """
+        return pulumi.get(self, "last_name")
+
+    @property
+    @pulumi.getter(name="realName")
+    def real_name(self) -> Optional[str]:
+        """
+        Field name for user's full name. If specified, first_name and last_name mappings are ignored
+        """
+        return pulumi.get(self, "real_name")
+
 
 @pulumi.output_type
-class GetCassandraCassandraResult(dict):
+class GetCassandaCassandraResult(dict):
     def __init__(__self__, *,
                  uris: Sequence[str]):
         """
@@ -23685,20 +24151,20 @@ class GetCassandraCassandraResult(dict):
 
 
 @pulumi.output_type
-class GetCassandraCassandraUserConfigResult(dict):
+class GetCassandaCassandraUserConfigResult(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: Optional['outputs.GetCassandaCassandraUserConfigCassandraResult'] = None,
                  cassandra_version: Optional[str] = None,
-                 ip_filter_objects: Optional[Sequence['outputs.GetCassandraCassandraUserConfigIpFilterObjectResult']] = None,
+                 ip_filter_objects: Optional[Sequence['outputs.GetCassandaCassandraUserConfigIpFilterObjectResult']] = 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.GetCassandaCassandraUserConfigPrivateAccessResult'] = None,
                  project_to_fork_from: Optional[str] = None,
-                 public_access: Optional['outputs.GetCassandraCassandraUserConfigPublicAccessResult'] = None,
+                 public_access: Optional['outputs.GetCassandaCassandraUserConfigPublicAccessResult'] = None,
                  service_log: Optional[bool] = None,
                  service_to_fork_from: Optional[str] = None,
                  service_to_join_with: Optional[str] = None,
@@ -23707,15 +24173,15 @@ class GetCassandraCassandraUserConfigResult(dict):
         :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. Example: `3`.
         :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. Example: `30`.
-        :param 'GetCassandraCassandraUserConfigCassandraArgs' cassandra: Cassandra configuration values
+        :param 'GetCassandaCassandraUserConfigCassandraArgs' cassandra: Cassandra configuration values
         :param str cassandra_version: Enum: `3`, `4`, `4.1`, and newer. Cassandra version.
-        :param Sequence['GetCassandraCassandraUserConfigIpFilterObjectArgs'] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
+        :param Sequence['GetCassandaCassandraUserConfigIpFilterObjectArgs'] 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 'GetCassandaCassandraUserConfigPrivateAccessArgs' 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. Example: `anotherprojectname`.
-        :param 'GetCassandraCassandraUserConfigPublicAccessArgs' public_access: Allow access to selected service ports from the public Internet
+        :param 'GetCassandaCassandraUserConfigPublicAccessArgs' 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. Example: `anotherservicename`.
         :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. Example: `my-test-cassandra`.
@@ -23781,7 +24247,7 @@ class GetCassandraCassandraUserConfigResult(dict):
 
     @property
     @pulumi.getter
-    def cassandra(self) -> Optional['outputs.GetCassandraCassandraUserConfigCassandraResult']:
+    def cassandra(self) -> Optional['outputs.GetCassandaCassandraUserConfigCassandraResult']:
         """
         Cassandra configuration values
         """
@@ -23797,7 +24263,7 @@ class GetCassandraCassandraUserConfigResult(dict):
 
     @property
     @pulumi.getter(name="ipFilterObjects")
-    def ip_filter_objects(self) -> Optional[Sequence['outputs.GetCassandraCassandraUserConfigIpFilterObjectResult']]:
+    def ip_filter_objects(self) -> Optional[Sequence['outputs.GetCassandaCassandraUserConfigIpFilterObjectResult']]:
         """
         Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
         """
@@ -23830,7 +24296,7 @@ class GetCassandraCassandraUserConfigResult(dict):
 
     @property
     @pulumi.getter(name="privateAccess")
-    def private_access(self) -> Optional['outputs.GetCassandraCassandraUserConfigPrivateAccessResult']:
+    def private_access(self) -> Optional['outputs.GetCassandaCassandraUserConfigPrivateAccessResult']:
         """
         Allow access to selected service ports from private networks
         """
@@ -23846,7 +24312,7 @@ class GetCassandraCassandraUserConfigResult(dict):
 
     @property
     @pulumi.getter(name="publicAccess")
-    def public_access(self) -> Optional['outputs.GetCassandraCassandraUserConfigPublicAccessResult']:
+    def public_access(self) -> Optional['outputs.GetCassandaCassandraUserConfigPublicAccessResult']:
         """
         Allow access to selected service ports from the public Internet
         """
@@ -23886,15 +24352,19 @@ class GetCassandraCassandraUserConfigResult(dict):
 
 
 @pulumi.output_type
-class GetCassandraCassandraUserConfigCassandraResult(dict):
+class GetCassandaCassandraUserConfigCassandraResult(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):
+                 datacenter: Optional[str] = None,
+                 read_request_timeout_in_ms: Optional[int] = None,
+                 write_request_timeout_in_ms: Optional[int] = None):
         """
         :param int batch_size_fail_threshold_in_kb: Fail any multiple-partition batch exceeding this value. 50kb (10x warn threshold) by default. Example: `50`.
         :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. Example: `5`.
         :param str datacenter: Name of the datacenter to which nodes of this service belong. Can be set only when creating the service. Example: `my-service-google-west1`.
+        :param int read_request_timeout_in_ms: How long the coordinator waits for read operations to complete before timing it out. 5 seconds by default. Example: `5000`.
+        :param int write_request_timeout_in_ms: How long the coordinator waits for write requests to complete with at least one node in the local datacenter. 2 seconds by default. Example: `2000`.
         """
         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)
@@ -23902,6 +24372,10 @@ class GetCassandraCassandraUserConfigCassandraResult(dict):
             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)
+        if read_request_timeout_in_ms is not None:
+            pulumi.set(__self__, "read_request_timeout_in_ms", read_request_timeout_in_ms)
+        if write_request_timeout_in_ms is not None:
+            pulumi.set(__self__, "write_request_timeout_in_ms", write_request_timeout_in_ms)
 
     @property
     @pulumi.getter(name="batchSizeFailThresholdInKb")
@@ -23927,9 +24401,25 @@ class GetCassandraCassandraUserConfigCassandraResult(dict):
         """
         return pulumi.get(self, "datacenter")
 
+    @property
+    @pulumi.getter(name="readRequestTimeoutInMs")
+    def read_request_timeout_in_ms(self) -> Optional[int]:
+        """
+        How long the coordinator waits for read operations to complete before timing it out. 5 seconds by default. Example: `5000`.
+        """
+        return pulumi.get(self, "read_request_timeout_in_ms")
+
+    @property
+    @pulumi.getter(name="writeRequestTimeoutInMs")
+    def write_request_timeout_in_ms(self) -> Optional[int]:
+        """
+        How long the coordinator waits for write requests to complete with at least one node in the local datacenter. 2 seconds by default. Example: `2000`.
+        """
+        return pulumi.get(self, "write_request_timeout_in_ms")
+
 
 @pulumi.output_type
-class GetCassandraCassandraUserConfigIpFilterObjectResult(dict):
+class GetCassandaCassandraUserConfigIpFilterObjectResult(dict):
     def __init__(__self__, *,
                  network: str,
                  description: Optional[str] = None):
@@ -23959,7 +24449,7 @@ class GetCassandraCassandraUserConfigIpFilterObjectResult(dict):
 
 
 @pulumi.output_type
-class GetCassandraCassandraUserConfigPrivateAccessResult(dict):
+class GetCassandaCassandraUserConfigPrivateAccessResult(dict):
     def __init__(__self__, *,
                  prometheus: Optional[bool] = None):
         """
@@ -23978,7 +24468,7 @@ class GetCassandraCassandraUserConfigPrivateAccessResult(dict):
 
 
 @pulumi.output_type
-class GetCassandraCassandraUserConfigPublicAccessResult(dict):
+class GetCassandaCassandraUserConfigPublicAccessResult(dict):
     def __init__(__self__, *,
                  prometheus: Optional[bool] = None):
         """
@@ -23997,7 +24487,7 @@ class GetCassandraCassandraUserConfigPublicAccessResult(dict):
 
 
 @pulumi.output_type
-class GetCassandraComponentResult(dict):
+class GetCassandaComponentResult(dict):
     def __init__(__self__, *,
                  component: str,
                  connection_uri: str,
@@ -24092,7 +24582,7 @@ class GetCassandraComponentResult(dict):
 
 
 @pulumi.output_type
-class GetCassandraServiceIntegrationResult(dict):
+class GetCassandaServiceIntegrationResult(dict):
     def __init__(__self__, *,
                  integration_type: str,
                  source_service_name: str):
@@ -24121,7 +24611,532 @@ class GetCassandraServiceIntegrationResult(dict):
 
 
 @pulumi.output_type
-class GetCassandraTagResult(dict):
+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__, *,
+                 uris: Sequence[str]):
+        """
+        :param Sequence[str] uris: Cassandra server URIs.
+        """
+        pulumi.set(__self__, "uris", uris)
+
+    @property
+    @pulumi.getter
+    def uris(self) -> Sequence[str]:
+        """
+        Cassandra server URIs.
+        """
+        return pulumi.get(self, "uris")
+
+
+@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. Example: `3`.
+        :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. Example: `30`.
+        :param 'GetCassandraCassandraUserConfigCassandraArgs' cassandra: Cassandra configuration values
+        :param str cassandra_version: Enum: `3`, `4`, `4.1`, and newer. 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. Example: `anotherprojectname`.
+        :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. Example: `anotherservicename`.
+        :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. Example: `my-test-cassandra`.
+        :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")
+    @_utilities.deprecated("""This property is deprecated.""")
+    def additional_backup_regions(self) -> Optional[str]:
+        """
+        Additional Cloud Regions for Backup Replication.
+        """
+        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. Example: `3`.
+        """
+        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. Example: `30`.
+        """
+        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]:
+        """
+        Enum: `3`, `4`, `4.1`, and newer. 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")
+    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
+    def ip_filters(self) -> Optional[Sequence[str]]:
+        """
+        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
+        """
+        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. Example: `anotherprojectname`.
+        """
+        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. Example: `anotherservicename`.
+        """
+        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. Example: `my-test-cassandra`.
+        """
+        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,
+                 read_request_timeout_in_ms: Optional[int] = None,
+                 write_request_timeout_in_ms: Optional[int] = None):
+        """
+        :param int batch_size_fail_threshold_in_kb: Fail any multiple-partition batch exceeding this value. 50kb (10x warn threshold) by default. Example: `50`.
+        :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. Example: `5`.
+        :param str datacenter: Name of the datacenter to which nodes of this service belong. Can be set only when creating the service. Example: `my-service-google-west1`.
+        :param int read_request_timeout_in_ms: How long the coordinator waits for read operations to complete before timing it out. 5 seconds by default. Example: `5000`.
+        :param int write_request_timeout_in_ms: How long the coordinator waits for write requests to complete with at least one node in the local datacenter. 2 seconds by default. Example: `2000`.
+        """
+        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)
+        if read_request_timeout_in_ms is not None:
+            pulumi.set(__self__, "read_request_timeout_in_ms", read_request_timeout_in_ms)
+        if write_request_timeout_in_ms is not None:
+            pulumi.set(__self__, "write_request_timeout_in_ms", write_request_timeout_in_ms)
+
+    @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. Example: `50`.
+        """
+        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. Example: `5`.
+        """
+        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. Example: `my-service-google-west1`.
+        """
+        return pulumi.get(self, "datacenter")
+
+    @property
+    @pulumi.getter(name="readRequestTimeoutInMs")
+    def read_request_timeout_in_ms(self) -> Optional[int]:
+        """
+        How long the coordinator waits for read operations to complete before timing it out. 5 seconds by default. Example: `5000`.
+        """
+        return pulumi.get(self, "read_request_timeout_in_ms")
+
+    @property
+    @pulumi.getter(name="writeRequestTimeoutInMs")
+    def write_request_timeout_in_ms(self) -> Optional[int]:
+        """
+        How long the coordinator waits for write requests to complete with at least one node in the local datacenter. 2 seconds by default. Example: `2000`.
+        """
+        return pulumi.get(self, "write_request_timeout_in_ms")
+
+
+@pulumi.output_type
+class GetCassandraCassandraUserConfigIpFilterObjectResult(dict):
+    def __init__(__self__, *,
+                 network: str,
+                 description: Optional[str] = None):
+        """
+        :param str network: CIDR address block. Example: `10.20.0.0/16`.
+        :param str description: Description for IP filter list entry. Example: `Production service IP range`.
+        """
+        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. Example: `10.20.0.0/16`.
+        """
+        return pulumi.get(self, "network")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[str]:
+        """
+        Description for IP filter list entry. Example: `Production service IP range`.
+        """
+        return pulumi.get(self, "description")
+
+
+@pulumi.output_type
+class GetCassandraCassandraUserConfigPrivateAccessResult(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 GetCassandraCassandraUserConfigPublicAccessResult(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 GetCassandraComponentResult(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 GetCassandraServiceIntegrationResult(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 GetCassandraTagResult(dict):
     def __init__(__self__, *,
                  key: str,
                  value: str):
@@ -24172,7 +25187,7 @@ class GetClickhouseClickhouseResult(dict):
     def __init__(__self__, *,
                  uris: Sequence[str]):
         """
-        :param Sequence[str] uris: Clickhouse server URIs.
+        :param Sequence[str] uris: ClickHouse server URIs.
         """
         pulumi.set(__self__, "uris", uris)
 
@@ -24180,7 +25195,7 @@ class GetClickhouseClickhouseResult(dict):
     @pulumi.getter
     def uris(self) -> Sequence[str]:
         """
-        Clickhouse server URIs.
+        ClickHouse server URIs.
         """
         return pulumi.get(self, "uris")
 
@@ -24622,8 +25637,8 @@ class GetClickhouseServiceIntegrationResult(dict):
                  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 source_service_name: Name of the source service
+        :param str integration_type: Type of the service integration. Supported integrations are `clickhouse_kafka` and `clickhouse_postgresql`.
+        :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)
@@ -24632,7 +25647,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. Supported integrations are `clickhouse_kafka` and `clickhouse_postgresql`.
         """
         return pulumi.get(self, "integration_type")
 
@@ -24640,7 +25655,7 @@ class GetClickhouseServiceIntegrationResult(dict):
     @pulumi.getter(name="sourceServiceName")
     def source_service_name(self) -> str:
         """
-        Name of the source service
+        Name of the source service.
         """
         return pulumi.get(self, "source_service_name")
 
@@ -25486,7 +26501,7 @@ class GetFlinkFlinkResult(dict):
     def __init__(__self__, *,
                  host_ports: Sequence[str]):
         """
-        :param Sequence[str] host_ports: Host and Port of a Flink server
+        :param Sequence[str] host_ports: The host and port of a Flink server.
         """
         pulumi.set(__self__, "host_ports", host_ports)
 
@@ -25494,7 +26509,7 @@ class GetFlinkFlinkResult(dict):
     @pulumi.getter(name="hostPorts")
     def host_ports(self) -> Sequence[str]:
         """
-        Host and Port of a Flink server
+        The host and port of a Flink server.
         """
         return pulumi.get(self, "host_ports")
 
@@ -28714,7 +29729,7 @@ class GetKafkaConnectorTaskResult(dict):
                  task: int):
         """
         :param str connector: The name of the related connector.
-        :param int task: The task id of the task.
+        :param int task: The task ID of the task.
         """
         pulumi.set(__self__, "connector", connector)
         pulumi.set(__self__, "task", task)
@@ -28731,7 +29746,7 @@ class GetKafkaConnectorTaskResult(dict):
     @pulumi.getter
     def task(self) -> int:
         """
-        The task id of the task.
+        The task ID of the task.
         """
         return pulumi.get(self, "task")
 
@@ -31363,8 +32378,8 @@ class GetKafkaTopicTagResult(dict):
                  key: str,
                  value: Optional[str] = None):
         """
-        :param str key: Topic tag key. Maximum length: `64`.
-        :param str value: Topic tag value. Maximum length: `256`.
+        :param str key: Tag key. Maximum length: `64`.
+        :param str value: Tag value. Maximum length: `256`.
         """
         pulumi.set(__self__, "key", key)
         if value is not None:
@@ -31374,7 +32389,7 @@ class GetKafkaTopicTagResult(dict):
     @pulumi.getter
     def key(self) -> str:
         """
-        Topic tag key. Maximum length: `64`.
+        Tag key. Maximum length: `64`.
         """
         return pulumi.get(self, "key")
 
@@ -31382,7 +32397,7 @@ class GetKafkaTopicTagResult(dict):
     @pulumi.getter
     def value(self) -> Optional[str]:
         """
-        Topic tag value. Maximum length: `256`.
+        Tag value. Maximum length: `256`.
         """
         return pulumi.get(self, "value")
 
@@ -34641,6 +35656,8 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
                  ism_history_max_docs: Optional[int] = None,
                  ism_history_rollover_check_period: Optional[int] = None,
                  ism_history_rollover_retention_period: Optional[int] = None,
+                 knn_memory_circuit_breaker_enabled: Optional[bool] = None,
+                 knn_memory_circuit_breaker_limit: 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,
@@ -34684,6 +35701,8 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
         :param int ism_history_max_docs: The maximum number of documents before rolling over the audit history index. Default: `2500000`.
         :param int ism_history_rollover_check_period: The time between rollover checks for the audit history index in hours. Default: `8`.
         :param int ism_history_rollover_retention_period: How long audit history indices are kept in days. Default: `30`.
+        :param bool knn_memory_circuit_breaker_enabled: Enable or disable KNN memory circuit breaker. Defaults to true. Default: `true`.
+        :param int knn_memory_circuit_breaker_limit: Maximum amount of memory that can be used for KNN index. Defaults to 50% of the JVM heap size. Default: `50`.
         :param bool 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.
@@ -34753,6 +35772,10 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
             pulumi.set(__self__, "ism_history_rollover_check_period", ism_history_rollover_check_period)
         if ism_history_rollover_retention_period is not None:
             pulumi.set(__self__, "ism_history_rollover_retention_period", ism_history_rollover_retention_period)
+        if knn_memory_circuit_breaker_enabled is not None:
+            pulumi.set(__self__, "knn_memory_circuit_breaker_enabled", knn_memory_circuit_breaker_enabled)
+        if knn_memory_circuit_breaker_limit is not None:
+            pulumi.set(__self__, "knn_memory_circuit_breaker_limit", knn_memory_circuit_breaker_limit)
         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:
@@ -34994,6 +36017,22 @@ class GetOpenSearchOpensearchUserConfigOpensearchResult(dict):
         """
         return pulumi.get(self, "ism_history_rollover_retention_period")
 
+    @property
+    @pulumi.getter(name="knnMemoryCircuitBreakerEnabled")
+    def knn_memory_circuit_breaker_enabled(self) -> Optional[bool]:
+        """
+        Enable or disable KNN memory circuit breaker. Defaults to true. Default: `true`.
+        """
+        return pulumi.get(self, "knn_memory_circuit_breaker_enabled")
+
+    @property
+    @pulumi.getter(name="knnMemoryCircuitBreakerLimit")
+    def knn_memory_circuit_breaker_limit(self) -> Optional[int]:
+        """
+        Maximum amount of memory that can be used for KNN index. Defaults to 50% of the JVM heap size. Default: `50`.
+        """
+        return pulumi.get(self, "knn_memory_circuit_breaker_limit")
+
     @property
     @pulumi.getter(name="overrideMainResponseVersion")
     def override_main_response_version(self) -> Optional[bool]:
@@ -36587,7 +37626,7 @@ class GetPgPgUserConfigPgResult(dict):
         :param bool jit: Controls system-wide use of Just-in-Time Compilation (JIT).
         :param int log_autovacuum_min_duration: Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one (the default) disables logging autovacuum actions.
         :param str log_error_verbosity: Enum: `TERSE`, `DEFAULT`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
-        :param str log_line_prefix: Enum: `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'%m [%p] %q[user=%u,db=%d,app=%a] '`. Choose from one of the available log formats.
+        :param str log_line_prefix: Enum: `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
         :param int log_min_duration_statement: Log statements that take more than this number of milliseconds to run, -1 disables.
         :param int log_temp_files: Log statements for each temporary file created larger than this number of kilobytes, -1 disables.
         :param int max_files_per_process: PostgreSQL maximum number of files that can be open per process.
@@ -36873,7 +37912,7 @@ class GetPgPgUserConfigPgResult(dict):
     @pulumi.getter(name="logLinePrefix")
     def log_line_prefix(self) -> Optional[str]:
         """
-        Enum: `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'%m [%p] %q[user=%u,db=%d,app=%a] '`. Choose from one of the available log formats.
+        Enum: `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
         """
         return pulumi.get(self, "log_line_prefix")
 
@@ -41465,3 +42504,745 @@ class GetThanosThanosUserConfigQueryFrontendResult(dict):
         return pulumi.get(self, "query_range_align_range_with_step")
 
 
+@pulumi.output_type
+class GetValkeyComponentResult(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 GetValkeyServiceIntegrationResult(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 GetValkeyTagResult(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 GetValkeyTechEmailResult(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 GetValkeyValkeyResult(dict):
+    def __init__(__self__, *,
+                 password: str,
+                 replica_uri: str,
+                 slave_uris: Sequence[str],
+                 uris: Sequence[str]):
+        """
+        :param str password: Valkey password.
+        :param str replica_uri: Valkey replica server URI.
+        :param Sequence[str] slave_uris: Valkey slave server URIs.
+        :param Sequence[str] uris: Valkey server URIs.
+        """
+        pulumi.set(__self__, "password", password)
+        pulumi.set(__self__, "replica_uri", replica_uri)
+        pulumi.set(__self__, "slave_uris", slave_uris)
+        pulumi.set(__self__, "uris", uris)
+
+    @property
+    @pulumi.getter
+    def password(self) -> str:
+        """
+        Valkey password.
+        """
+        return pulumi.get(self, "password")
+
+    @property
+    @pulumi.getter(name="replicaUri")
+    def replica_uri(self) -> str:
+        """
+        Valkey replica server URI.
+        """
+        return pulumi.get(self, "replica_uri")
+
+    @property
+    @pulumi.getter(name="slaveUris")
+    def slave_uris(self) -> Sequence[str]:
+        """
+        Valkey slave server URIs.
+        """
+        return pulumi.get(self, "slave_uris")
+
+    @property
+    @pulumi.getter
+    def uris(self) -> Sequence[str]:
+        """
+        Valkey server URIs.
+        """
+        return pulumi.get(self, "uris")
+
+
+@pulumi.output_type
+class GetValkeyValkeyUserConfigResult(dict):
+    def __init__(__self__, *,
+                 additional_backup_regions: Optional[str] = None,
+                 ip_filter_objects: Optional[Sequence['outputs.GetValkeyValkeyUserConfigIpFilterObjectResult']] = None,
+                 ip_filter_strings: Optional[Sequence[str]] = None,
+                 ip_filters: Optional[Sequence[str]] = None,
+                 migration: Optional['outputs.GetValkeyValkeyUserConfigMigrationResult'] = None,
+                 private_access: Optional['outputs.GetValkeyValkeyUserConfigPrivateAccessResult'] = None,
+                 privatelink_access: Optional['outputs.GetValkeyValkeyUserConfigPrivatelinkAccessResult'] = None,
+                 project_to_fork_from: Optional[str] = None,
+                 public_access: Optional['outputs.GetValkeyValkeyUserConfigPublicAccessResult'] = None,
+                 recovery_basebackup_name: Optional[str] = None,
+                 service_log: Optional[bool] = None,
+                 service_to_fork_from: Optional[str] = None,
+                 static_ips: Optional[bool] = None,
+                 valkey_acl_channels_default: Optional[str] = None,
+                 valkey_io_threads: Optional[int] = None,
+                 valkey_lfu_decay_time: Optional[int] = None,
+                 valkey_lfu_log_factor: Optional[int] = None,
+                 valkey_maxmemory_policy: Optional[str] = None,
+                 valkey_notify_keyspace_events: Optional[str] = None,
+                 valkey_number_of_databases: Optional[int] = None,
+                 valkey_persistence: Optional[str] = None,
+                 valkey_pubsub_client_output_buffer_limit: Optional[int] = None,
+                 valkey_ssl: Optional[bool] = None,
+                 valkey_timeout: Optional[int] = None):
+        """
+        :param str additional_backup_regions: Additional Cloud Regions for Backup Replication.
+        :param Sequence['GetValkeyValkeyUserConfigIpFilterObjectArgs'] 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 'GetValkeyValkeyUserConfigMigrationArgs' migration: Migrate data from existing server
+        :param 'GetValkeyValkeyUserConfigPrivateAccessArgs' private_access: Allow access to selected service ports from private networks
+        :param 'GetValkeyValkeyUserConfigPrivatelinkAccessArgs' 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. Example: `anotherprojectname`.
+        :param 'GetValkeyValkeyUserConfigPublicAccessArgs' 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. Example: `backup-20191112t091354293891z`.
+        :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. Example: `anotherservicename`.
+        :param bool static_ips: Use static public IP addresses.
+        :param str valkey_acl_channels_default: Enum: `allchannels`, `resetchannels`. Determines default pub/sub channels' ACL for new users if ACL is not supplied. When this option is not defined, all_channels is assumed to keep backward compatibility. This option doesn't affect Valkey configuration acl-pubsub-default.
+        :param int valkey_io_threads: Set Valkey IO thread count. Changing this will cause a restart of the Valkey service. Example: `1`.
+        :param int valkey_lfu_decay_time: LFU maxmemory-policy counter decay time in minutes. Default: `1`.
+        :param int valkey_lfu_log_factor: Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies. Default: `10`.
+        :param str valkey_maxmemory_policy: Enum: `noeviction`, `allkeys-lru`, `volatile-lru`, `allkeys-random`, `volatile-random`, `volatile-ttl`, `volatile-lfu`, `allkeys-lfu`. Valkey maxmemory-policy. Default: `noeviction`.
+        :param str valkey_notify_keyspace_events: Set notify-keyspace-events option.
+        :param int valkey_number_of_databases: Set number of Valkey databases. Changing this will cause a restart of the Valkey service. Example: `16`.
+        :param str valkey_persistence: Enum: `off`, `rdb`. When persistence is `rdb`, Valkey does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
+        :param int valkey_pubsub_client_output_buffer_limit: Set output buffer limit for pub / sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan. Example: `64`.
+        :param bool valkey_ssl: Require SSL to access Valkey. Default: `true`.
+        :param int valkey_timeout: Valkey idle connection timeout in seconds. Default: `300`.
+        """
+        if additional_backup_regions is not None:
+            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
+        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)
+        if valkey_acl_channels_default is not None:
+            pulumi.set(__self__, "valkey_acl_channels_default", valkey_acl_channels_default)
+        if valkey_io_threads is not None:
+            pulumi.set(__self__, "valkey_io_threads", valkey_io_threads)
+        if valkey_lfu_decay_time is not None:
+            pulumi.set(__self__, "valkey_lfu_decay_time", valkey_lfu_decay_time)
+        if valkey_lfu_log_factor is not None:
+            pulumi.set(__self__, "valkey_lfu_log_factor", valkey_lfu_log_factor)
+        if valkey_maxmemory_policy is not None:
+            pulumi.set(__self__, "valkey_maxmemory_policy", valkey_maxmemory_policy)
+        if valkey_notify_keyspace_events is not None:
+            pulumi.set(__self__, "valkey_notify_keyspace_events", valkey_notify_keyspace_events)
+        if valkey_number_of_databases is not None:
+            pulumi.set(__self__, "valkey_number_of_databases", valkey_number_of_databases)
+        if valkey_persistence is not None:
+            pulumi.set(__self__, "valkey_persistence", valkey_persistence)
+        if valkey_pubsub_client_output_buffer_limit is not None:
+            pulumi.set(__self__, "valkey_pubsub_client_output_buffer_limit", valkey_pubsub_client_output_buffer_limit)
+        if valkey_ssl is not None:
+            pulumi.set(__self__, "valkey_ssl", valkey_ssl)
+        if valkey_timeout is not None:
+            pulumi.set(__self__, "valkey_timeout", valkey_timeout)
+
+    @property
+    @pulumi.getter(name="additionalBackupRegions")
+    def additional_backup_regions(self) -> Optional[str]:
+        """
+        Additional Cloud Regions for Backup Replication.
+        """
+        return pulumi.get(self, "additional_backup_regions")
+
+    @property
+    @pulumi.getter(name="ipFilterObjects")
+    def ip_filter_objects(self) -> Optional[Sequence['outputs.GetValkeyValkeyUserConfigIpFilterObjectResult']]:
+        """
+        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")
+    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
+    def ip_filters(self) -> Optional[Sequence[str]]:
+        """
+        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
+        """
+        return pulumi.get(self, "ip_filters")
+
+    @property
+    @pulumi.getter
+    def migration(self) -> Optional['outputs.GetValkeyValkeyUserConfigMigrationResult']:
+        """
+        Migrate data from existing server
+        """
+        return pulumi.get(self, "migration")
+
+    @property
+    @pulumi.getter(name="privateAccess")
+    def private_access(self) -> Optional['outputs.GetValkeyValkeyUserConfigPrivateAccessResult']:
+        """
+        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.GetValkeyValkeyUserConfigPrivatelinkAccessResult']:
+        """
+        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. Example: `anotherprojectname`.
+        """
+        return pulumi.get(self, "project_to_fork_from")
+
+    @property
+    @pulumi.getter(name="publicAccess")
+    def public_access(self) -> Optional['outputs.GetValkeyValkeyUserConfigPublicAccessResult']:
+        """
+        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. Example: `backup-20191112t091354293891z`.
+        """
+        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. Example: `anotherservicename`.
+        """
+        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")
+
+    @property
+    @pulumi.getter(name="valkeyAclChannelsDefault")
+    def valkey_acl_channels_default(self) -> Optional[str]:
+        """
+        Enum: `allchannels`, `resetchannels`. Determines default pub/sub channels' ACL for new users if ACL is not supplied. When this option is not defined, all_channels is assumed to keep backward compatibility. This option doesn't affect Valkey configuration acl-pubsub-default.
+        """
+        return pulumi.get(self, "valkey_acl_channels_default")
+
+    @property
+    @pulumi.getter(name="valkeyIoThreads")
+    def valkey_io_threads(self) -> Optional[int]:
+        """
+        Set Valkey IO thread count. Changing this will cause a restart of the Valkey service. Example: `1`.
+        """
+        return pulumi.get(self, "valkey_io_threads")
+
+    @property
+    @pulumi.getter(name="valkeyLfuDecayTime")
+    def valkey_lfu_decay_time(self) -> Optional[int]:
+        """
+        LFU maxmemory-policy counter decay time in minutes. Default: `1`.
+        """
+        return pulumi.get(self, "valkey_lfu_decay_time")
+
+    @property
+    @pulumi.getter(name="valkeyLfuLogFactor")
+    def valkey_lfu_log_factor(self) -> Optional[int]:
+        """
+        Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies. Default: `10`.
+        """
+        return pulumi.get(self, "valkey_lfu_log_factor")
+
+    @property
+    @pulumi.getter(name="valkeyMaxmemoryPolicy")
+    def valkey_maxmemory_policy(self) -> Optional[str]:
+        """
+        Enum: `noeviction`, `allkeys-lru`, `volatile-lru`, `allkeys-random`, `volatile-random`, `volatile-ttl`, `volatile-lfu`, `allkeys-lfu`. Valkey maxmemory-policy. Default: `noeviction`.
+        """
+        return pulumi.get(self, "valkey_maxmemory_policy")
+
+    @property
+    @pulumi.getter(name="valkeyNotifyKeyspaceEvents")
+    def valkey_notify_keyspace_events(self) -> Optional[str]:
+        """
+        Set notify-keyspace-events option.
+        """
+        return pulumi.get(self, "valkey_notify_keyspace_events")
+
+    @property
+    @pulumi.getter(name="valkeyNumberOfDatabases")
+    def valkey_number_of_databases(self) -> Optional[int]:
+        """
+        Set number of Valkey databases. Changing this will cause a restart of the Valkey service. Example: `16`.
+        """
+        return pulumi.get(self, "valkey_number_of_databases")
+
+    @property
+    @pulumi.getter(name="valkeyPersistence")
+    def valkey_persistence(self) -> Optional[str]:
+        """
+        Enum: `off`, `rdb`. When persistence is `rdb`, Valkey does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
+        """
+        return pulumi.get(self, "valkey_persistence")
+
+    @property
+    @pulumi.getter(name="valkeyPubsubClientOutputBufferLimit")
+    def valkey_pubsub_client_output_buffer_limit(self) -> Optional[int]:
+        """
+        Set output buffer limit for pub / sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan. Example: `64`.
+        """
+        return pulumi.get(self, "valkey_pubsub_client_output_buffer_limit")
+
+    @property
+    @pulumi.getter(name="valkeySsl")
+    def valkey_ssl(self) -> Optional[bool]:
+        """
+        Require SSL to access Valkey. Default: `true`.
+        """
+        return pulumi.get(self, "valkey_ssl")
+
+    @property
+    @pulumi.getter(name="valkeyTimeout")
+    def valkey_timeout(self) -> Optional[int]:
+        """
+        Valkey idle connection timeout in seconds. Default: `300`.
+        """
+        return pulumi.get(self, "valkey_timeout")
+
+
+@pulumi.output_type
+class GetValkeyValkeyUserConfigIpFilterObjectResult(dict):
+    def __init__(__self__, *,
+                 network: str,
+                 description: Optional[str] = None):
+        """
+        :param str network: CIDR address block. Example: `10.20.0.0/16`.
+        :param str description: Description for IP filter list entry. Example: `Production service IP range`.
+        """
+        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. Example: `10.20.0.0/16`.
+        """
+        return pulumi.get(self, "network")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[str]:
+        """
+        Description for IP filter list entry. Example: `Production service IP range`.
+        """
+        return pulumi.get(self, "description")
+
+
+@pulumi.output_type
+class GetValkeyValkeyUserConfigMigrationResult(dict):
+    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. Example: `my.server.com`.
+        :param int port: Port number of the server where to migrate data from. Example: `1234`.
+        :param str dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
+        :param str ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
+        :param str method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
+        :param str password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
+        :param bool ssl: The server where to migrate data from is secured with SSL. Default: `true`.
+        :param str username: User name for authentication with the server where to migrate data from. Example: `myname`.
+        """
+        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. Example: `my.server.com`.
+        """
+        return pulumi.get(self, "host")
+
+    @property
+    @pulumi.getter
+    def port(self) -> int:
+        """
+        Port number of the server where to migrate data from. Example: `1234`.
+        """
+        return pulumi.get(self, "port")
+
+    @property
+    @pulumi.getter
+    def dbname(self) -> Optional[str]:
+        """
+        Database name for bootstrapping the initial connection. Example: `defaultdb`.
+        """
+        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). Example: `db1,db2`.
+        """
+        return pulumi.get(self, "ignore_dbs")
+
+    @property
+    @pulumi.getter
+    def method(self) -> Optional[str]:
+        """
+        Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
+        """
+        return pulumi.get(self, "method")
+
+    @property
+    @pulumi.getter
+    def password(self) -> Optional[str]:
+        """
+        Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
+        """
+        return pulumi.get(self, "password")
+
+    @property
+    @pulumi.getter
+    def ssl(self) -> Optional[bool]:
+        """
+        The server where to migrate data from is secured with SSL. Default: `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. Example: `myname`.
+        """
+        return pulumi.get(self, "username")
+
+
+@pulumi.output_type
+class GetValkeyValkeyUserConfigPrivateAccessResult(dict):
+    def __init__(__self__, *,
+                 prometheus: Optional[bool] = None,
+                 valkey: 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.
+        :param bool valkey: Allow clients to connect to valkey 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)
+        if valkey is not None:
+            pulumi.set(__self__, "valkey", valkey)
+
+    @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")
+
+    @property
+    @pulumi.getter
+    def valkey(self) -> Optional[bool]:
+        """
+        Allow clients to connect to valkey with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
+        """
+        return pulumi.get(self, "valkey")
+
+
+@pulumi.output_type
+class GetValkeyValkeyUserConfigPrivatelinkAccessResult(dict):
+    def __init__(__self__, *,
+                 prometheus: Optional[bool] = None,
+                 valkey: Optional[bool] = None):
+        """
+        :param bool prometheus: Enable prometheus.
+        :param bool valkey: Enable valkey.
+        """
+        if prometheus is not None:
+            pulumi.set(__self__, "prometheus", prometheus)
+        if valkey is not None:
+            pulumi.set(__self__, "valkey", valkey)
+
+    @property
+    @pulumi.getter
+    def prometheus(self) -> Optional[bool]:
+        """
+        Enable prometheus.
+        """
+        return pulumi.get(self, "prometheus")
+
+    @property
+    @pulumi.getter
+    def valkey(self) -> Optional[bool]:
+        """
+        Enable valkey.
+        """
+        return pulumi.get(self, "valkey")
+
+
+@pulumi.output_type
+class GetValkeyValkeyUserConfigPublicAccessResult(dict):
+    def __init__(__self__, *,
+                 prometheus: Optional[bool] = None,
+                 valkey: 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.
+        :param bool valkey: Allow clients to connect to valkey 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)
+        if valkey is not None:
+            pulumi.set(__self__, "valkey", valkey)
+
+    @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")
+
+    @property
+    @pulumi.getter
+    def valkey(self) -> Optional[bool]:
+        """
+        Allow clients to connect to valkey from the public internet for service nodes that are in a project VPC or another type of private network.
+        """
+        return pulumi.get(self, "valkey")
+
+