pulumi-aiven 6.7.0a1693027281__tar.gz → 6.7.0a1694131986__tar.gz

{pulumi_aiven-6.7.0a1693027281 → pulumi_aiven-6.7.0a1694131986}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pulumi_aiven
-Version: 6.7.0a1693027281
+Version: 6.7.0a1694131986
 Summary: A Pulumi package for creating and managing Aiven cloud resources.
 Home-page: https://pulumi.io
 License: Apache-2.0

{pulumi_aiven-6.7.0a1693027281 → pulumi_aiven-6.7.0a1694131986}/pulumi_aiven/__init__.py

@@ -80,6 +80,7 @@ from .get_open_search_acl_rule import *
 from .get_opensearch_user import *
 from .get_organization import *
 from .get_organization_user import *
+from .get_organization_user_group import *
 from .get_organizational_unit import *
 from .get_pg import *
 from .get_pg_database import *
@@ -120,6 +121,7 @@ from .open_search_acl_rule import *
 from .opensearch_user import *
 from .organization import *
 from .organization_user import *
+from .organization_user_group import *
 from .organizational_unit import *
 from .pg import *
 from .pg_database import *
@@ -571,6 +573,14 @@ _utilities.register(
    "aiven:index/organizationUser:OrganizationUser": "OrganizationUser"
   }
  },
+ {
+  "pkg": "aiven",
+  "mod": "index/organizationUserGroup",
+  "fqn": "pulumi_aiven",
+  "classes": {
+   "aiven:index/organizationUserGroup:OrganizationUserGroup": "OrganizationUserGroup"
+  }
+ },
  {
   "pkg": "aiven",
   "mod": "index/organizationalUnit",

{pulumi_aiven-6.7.0a1693027281 → pulumi_aiven-6.7.0a1694131986}/pulumi_aiven/_inputs.py

@@ -142,6 +142,7 @@ __all__ = [
     'OpenSearchOpensearchUserConfigIndexPatternArgs',
     'OpenSearchOpensearchUserConfigIndexTemplateArgs',
     'OpenSearchOpensearchUserConfigIpFilterObjectArgs',
+    'OpenSearchOpensearchUserConfigOpenidArgs',
     'OpenSearchOpensearchUserConfigOpensearchArgs',
     'OpenSearchOpensearchUserConfigOpensearchDashboardsArgs',
     'OpenSearchOpensearchUserConfigPrivateAccessArgs',
@@ -150,6 +151,7 @@ __all__ = [
     'OpenSearchOpensearchUserConfigSamlArgs',
     'OpenSearchServiceIntegrationArgs',
     'OpenSearchTagArgs',
+    'OrganizationTimeoutsArgs',
     'PgComponentArgs',
     'PgPgArgs',
     'PgPgUserConfigArgs',
@@ -2003,6 +2005,7 @@ class GrafanaGrafanaUserConfigArgs:
                  ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  metrics_enabled: Optional[pulumi.Input[bool]] = None,
+                 oauth_allow_insecure_email_lookup: Optional[pulumi.Input[bool]] = None,
                  private_access: Optional[pulumi.Input['GrafanaGrafanaUserConfigPrivateAccessArgs']] = None,
                  privatelink_access: Optional[pulumi.Input['GrafanaGrafanaUserConfigPrivatelinkAccessArgs']] = None,
                  project_to_fork_from: Optional[pulumi.Input[str]] = None,
@@ -2073,6 +2076,8 @@ class GrafanaGrafanaUserConfigArgs:
             pulumi.set(__self__, "ip_filters", ip_filters)
         if metrics_enabled is not None:
             pulumi.set(__self__, "metrics_enabled", metrics_enabled)
+        if oauth_allow_insecure_email_lookup is not None:
+            pulumi.set(__self__, "oauth_allow_insecure_email_lookup", oauth_allow_insecure_email_lookup)
         if private_access is not None:
             pulumi.set(__self__, "private_access", private_access)
         if privatelink_access is not None:
@@ -2351,6 +2356,15 @@ class GrafanaGrafanaUserConfigArgs:
     def metrics_enabled(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "metrics_enabled", value)
 
+    @property
+    @pulumi.getter(name="oauthAllowInsecureEmailLookup")
+    def oauth_allow_insecure_email_lookup(self) -> Optional[pulumi.Input[bool]]:
+        return pulumi.get(self, "oauth_allow_insecure_email_lookup")
+
+    @oauth_allow_insecure_email_lookup.setter
+    def oauth_allow_insecure_email_lookup(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "oauth_allow_insecure_email_lookup", value)
+
     @property
     @pulumi.getter(name="privateAccess")
     def private_access(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigPrivateAccessArgs']]:
@@ -2547,6 +2561,7 @@ class GrafanaGrafanaUserConfigAuthGenericOauthArgs:
                  allow_sign_up: Optional[pulumi.Input[bool]] = None,
                  allowed_domains: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  allowed_organizations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 auto_login: Optional[pulumi.Input[bool]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
         pulumi.set(__self__, "api_url", api_url)
@@ -2560,6 +2575,8 @@ class GrafanaGrafanaUserConfigAuthGenericOauthArgs:
             pulumi.set(__self__, "allowed_domains", allowed_domains)
         if allowed_organizations is not None:
             pulumi.set(__self__, "allowed_organizations", allowed_organizations)
+        if auto_login is not None:
+            pulumi.set(__self__, "auto_login", auto_login)
         if name is not None:
             pulumi.set(__self__, "name", name)
         if scopes is not None:
@@ -2637,6 +2654,15 @@ class GrafanaGrafanaUserConfigAuthGenericOauthArgs:
     def allowed_organizations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
         pulumi.set(self, "allowed_organizations", value)
 
+    @property
+    @pulumi.getter(name="autoLogin")
+    def auto_login(self) -> Optional[pulumi.Input[bool]]:
+        return pulumi.get(self, "auto_login")
+
+    @auto_login.setter
+    def auto_login(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "auto_login", value)
+
     @property
     @pulumi.getter
     def name(self) -> Optional[pulumi.Input[str]]:
@@ -4173,6 +4199,7 @@ class KafkaConnectKafkaConnectUserConfigKafkaConnectArgs:
                  producer_compression_type: Optional[pulumi.Input[str]] = None,
                  producer_linger_ms: Optional[pulumi.Input[int]] = None,
                  producer_max_request_size: Optional[pulumi.Input[int]] = None,
+                 scheduled_rebalance_max_delay_ms: Optional[pulumi.Input[int]] = None,
                  session_timeout_ms: Optional[pulumi.Input[int]] = None):
         if connector_client_config_override_policy is not None:
             pulumi.set(__self__, "connector_client_config_override_policy", connector_client_config_override_policy)
@@ -4202,6 +4229,8 @@ class KafkaConnectKafkaConnectUserConfigKafkaConnectArgs:
             pulumi.set(__self__, "producer_linger_ms", producer_linger_ms)
         if producer_max_request_size is not None:
             pulumi.set(__self__, "producer_max_request_size", producer_max_request_size)
+        if scheduled_rebalance_max_delay_ms is not None:
+            pulumi.set(__self__, "scheduled_rebalance_max_delay_ms", scheduled_rebalance_max_delay_ms)
         if session_timeout_ms is not None:
             pulumi.set(__self__, "session_timeout_ms", session_timeout_ms)
 
@@ -4331,6 +4360,15 @@ class KafkaConnectKafkaConnectUserConfigKafkaConnectArgs:
     def producer_max_request_size(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "producer_max_request_size", value)
 
+    @property
+    @pulumi.getter(name="scheduledRebalanceMaxDelayMs")
+    def scheduled_rebalance_max_delay_ms(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "scheduled_rebalance_max_delay_ms")
+
+    @scheduled_rebalance_max_delay_ms.setter
+    def scheduled_rebalance_max_delay_ms(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "scheduled_rebalance_max_delay_ms", value)
+
     @property
     @pulumi.getter(name="sessionTimeoutMs")
     def session_timeout_ms(self) -> Optional[pulumi.Input[int]]:
@@ -5458,6 +5496,7 @@ class KafkaKafkaUserConfigKafkaConnectConfigArgs:
                  producer_compression_type: Optional[pulumi.Input[str]] = None,
                  producer_linger_ms: Optional[pulumi.Input[int]] = None,
                  producer_max_request_size: Optional[pulumi.Input[int]] = None,
+                 scheduled_rebalance_max_delay_ms: Optional[pulumi.Input[int]] = None,
                  session_timeout_ms: Optional[pulumi.Input[int]] = None):
         if connector_client_config_override_policy is not None:
             pulumi.set(__self__, "connector_client_config_override_policy", connector_client_config_override_policy)
@@ -5487,6 +5526,8 @@ class KafkaKafkaUserConfigKafkaConnectConfigArgs:
             pulumi.set(__self__, "producer_linger_ms", producer_linger_ms)
         if producer_max_request_size is not None:
             pulumi.set(__self__, "producer_max_request_size", producer_max_request_size)
+        if scheduled_rebalance_max_delay_ms is not None:
+            pulumi.set(__self__, "scheduled_rebalance_max_delay_ms", scheduled_rebalance_max_delay_ms)
         if session_timeout_ms is not None:
             pulumi.set(__self__, "session_timeout_ms", session_timeout_ms)
 
@@ -5616,6 +5657,15 @@ class KafkaKafkaUserConfigKafkaConnectConfigArgs:
     def producer_max_request_size(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "producer_max_request_size", value)
 
+    @property
+    @pulumi.getter(name="scheduledRebalanceMaxDelayMs")
+    def scheduled_rebalance_max_delay_ms(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "scheduled_rebalance_max_delay_ms")
+
+    @scheduled_rebalance_max_delay_ms.setter
+    def scheduled_rebalance_max_delay_ms(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "scheduled_rebalance_max_delay_ms", value)
+
     @property
     @pulumi.getter(name="sessionTimeoutMs")
     def session_timeout_ms(self) -> Optional[pulumi.Input[int]]:
@@ -9166,6 +9216,7 @@ class OpenSearchOpensearchUserConfigArgs:
                  ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  keep_index_refresh_interval: Optional[pulumi.Input[bool]] = None,
                  max_index_count: Optional[pulumi.Input[int]] = None,
+                 openid: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpenidArgs']] = None,
                  opensearch: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchArgs']] = None,
                  opensearch_dashboards: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchDashboardsArgs']] = None,
                  opensearch_version: Optional[pulumi.Input[str]] = None,
@@ -9188,6 +9239,7 @@ class OpenSearchOpensearchUserConfigArgs:
         :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
         :param pulumi.Input[bool] keep_index_refresh_interval: Aiven automation resets index.refresh_interval to default value for every index to be sure that indices are always visible to search. If it doesn't fit your case, you can disable this by setting up this flag to true.
         :param pulumi.Input[int] max_index_count: Use index_patterns instead. The default value is `0`.
+        :param pulumi.Input['OpenSearchOpensearchUserConfigOpenidArgs'] openid: OpenSearch OpenID Connect Configuration.
         :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchArgs'] opensearch: OpenSearch settings.
         :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchDashboardsArgs'] opensearch_dashboards: OpenSearch Dashboards settings.
         :param pulumi.Input[str] opensearch_version: OpenSearch major version.
@@ -9229,6 +9281,8 @@ class OpenSearchOpensearchUserConfigArgs:
             pulumi.log.warn("""max_index_count is deprecated: Usage of this field is discouraged.""")
         if max_index_count is not None:
             pulumi.set(__self__, "max_index_count", max_index_count)
+        if openid is not None:
+            pulumi.set(__self__, "openid", openid)
         if opensearch is not None:
             pulumi.set(__self__, "opensearch", opensearch)
         if opensearch_dashboards is not None:
@@ -9381,6 +9435,18 @@ class OpenSearchOpensearchUserConfigArgs:
     def max_index_count(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "max_index_count", value)
 
+    @property
+    @pulumi.getter
+    def openid(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpenidArgs']]:
+        """
+        OpenSearch OpenID Connect Configuration.
+        """
+        return pulumi.get(self, "openid")
+
+    @openid.setter
+    def openid(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpenidArgs']]):
+        pulumi.set(self, "openid", value)
+
     @property
     @pulumi.getter
     def opensearch(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchArgs']]:
@@ -9622,6 +9688,152 @@ class OpenSearchOpensearchUserConfigIpFilterObjectArgs:
         pulumi.set(self, "description", value)
 
 
+@pulumi.input_type
+class OpenSearchOpensearchUserConfigOpenidArgs:
+    def __init__(__self__, *,
+                 client_id: pulumi.Input[str],
+                 client_secret: pulumi.Input[str],
+                 connect_url: pulumi.Input[str],
+                 enabled: Optional[pulumi.Input[bool]] = None,
+                 header: Optional[pulumi.Input[str]] = None,
+                 jwt_header: Optional[pulumi.Input[str]] = None,
+                 jwt_url_parameter: Optional[pulumi.Input[str]] = None,
+                 refresh_rate_limit_count: Optional[pulumi.Input[int]] = None,
+                 refresh_rate_limit_time_window_ms: Optional[pulumi.Input[int]] = None,
+                 roles_key: Optional[pulumi.Input[str]] = None,
+                 scope: Optional[pulumi.Input[str]] = None,
+                 subject_key: Optional[pulumi.Input[str]] = None):
+        pulumi.set(__self__, "client_id", client_id)
+        pulumi.set(__self__, "client_secret", client_secret)
+        pulumi.set(__self__, "connect_url", connect_url)
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+        if header is not None:
+            pulumi.set(__self__, "header", header)
+        if jwt_header is not None:
+            pulumi.set(__self__, "jwt_header", jwt_header)
+        if jwt_url_parameter is not None:
+            pulumi.set(__self__, "jwt_url_parameter", jwt_url_parameter)
+        if refresh_rate_limit_count is not None:
+            pulumi.set(__self__, "refresh_rate_limit_count", refresh_rate_limit_count)
+        if refresh_rate_limit_time_window_ms is not None:
+            pulumi.set(__self__, "refresh_rate_limit_time_window_ms", refresh_rate_limit_time_window_ms)
+        if roles_key is not None:
+            pulumi.set(__self__, "roles_key", roles_key)
+        if scope is not None:
+            pulumi.set(__self__, "scope", scope)
+        if subject_key is not None:
+            pulumi.set(__self__, "subject_key", subject_key)
+
+    @property
+    @pulumi.getter(name="clientId")
+    def client_id(self) -> pulumi.Input[str]:
+        return pulumi.get(self, "client_id")
+
+    @client_id.setter
+    def client_id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "client_id", value)
+
+    @property
+    @pulumi.getter(name="clientSecret")
+    def client_secret(self) -> pulumi.Input[str]:
+        return pulumi.get(self, "client_secret")
+
+    @client_secret.setter
+    def client_secret(self, value: pulumi.Input[str]):
+        pulumi.set(self, "client_secret", value)
+
+    @property
+    @pulumi.getter(name="connectUrl")
+    def connect_url(self) -> pulumi.Input[str]:
+        return pulumi.get(self, "connect_url")
+
+    @connect_url.setter
+    def connect_url(self, value: pulumi.Input[str]):
+        pulumi.set(self, "connect_url", value)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[pulumi.Input[bool]]:
+        return pulumi.get(self, "enabled")
+
+    @enabled.setter
+    def enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "enabled", value)
+
+    @property
+    @pulumi.getter
+    def header(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "header")
+
+    @header.setter
+    def header(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "header", value)
+
+    @property
+    @pulumi.getter(name="jwtHeader")
+    def jwt_header(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "jwt_header")
+
+    @jwt_header.setter
+    def jwt_header(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "jwt_header", value)
+
+    @property
+    @pulumi.getter(name="jwtUrlParameter")
+    def jwt_url_parameter(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "jwt_url_parameter")
+
+    @jwt_url_parameter.setter
+    def jwt_url_parameter(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "jwt_url_parameter", value)
+
+    @property
+    @pulumi.getter(name="refreshRateLimitCount")
+    def refresh_rate_limit_count(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "refresh_rate_limit_count")
+
+    @refresh_rate_limit_count.setter
+    def refresh_rate_limit_count(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "refresh_rate_limit_count", value)
+
+    @property
+    @pulumi.getter(name="refreshRateLimitTimeWindowMs")
+    def refresh_rate_limit_time_window_ms(self) -> Optional[pulumi.Input[int]]:
+        return pulumi.get(self, "refresh_rate_limit_time_window_ms")
+
+    @refresh_rate_limit_time_window_ms.setter
+    def refresh_rate_limit_time_window_ms(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "refresh_rate_limit_time_window_ms", value)
+
+    @property
+    @pulumi.getter(name="rolesKey")
+    def roles_key(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "roles_key")
+
+    @roles_key.setter
+    def roles_key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "roles_key", value)
+
+    @property
+    @pulumi.getter
+    def scope(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "scope")
+
+    @scope.setter
+    def scope(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "scope", value)
+
+    @property
+    @pulumi.getter(name="subjectKey")
+    def subject_key(self) -> Optional[pulumi.Input[str]]:
+        return pulumi.get(self, "subject_key")
+
+    @subject_key.setter
+    def subject_key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "subject_key", value)
+
+
 @pulumi.input_type
 class OpenSearchOpensearchUserConfigOpensearchArgs:
     def __init__(__self__, *,
@@ -10340,6 +10552,77 @@ class OpenSearchTagArgs:
         pulumi.set(self, "value", value)
 
 
+@pulumi.input_type
+class OrganizationTimeoutsArgs:
+    def __init__(__self__, *,
+                 create: Optional[pulumi.Input[str]] = None,
+                 delete: Optional[pulumi.Input[str]] = None,
+                 read: Optional[pulumi.Input[str]] = None,
+                 update: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] create: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        :param pulumi.Input[str] delete: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
+        :param pulumi.Input[str] read: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Read operations occur during any refresh or planning operation when refresh is enabled.
+        :param pulumi.Input[str] update: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+        if create is not None:
+            pulumi.set(__self__, "create", create)
+        if delete is not None:
+            pulumi.set(__self__, "delete", delete)
+        if read is not None:
+            pulumi.set(__self__, "read", read)
+        if update is not None:
+            pulumi.set(__self__, "update", update)
+
+    @property
+    @pulumi.getter
+    def create(self) -> Optional[pulumi.Input[str]]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+        return pulumi.get(self, "create")
+
+    @create.setter
+    def create(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "create", value)
+
+    @property
+    @pulumi.getter
+    def delete(self) -> Optional[pulumi.Input[str]]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
+        """
+        return pulumi.get(self, "delete")
+
+    @delete.setter
+    def delete(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "delete", value)
+
+    @property
+    @pulumi.getter
+    def read(self) -> Optional[pulumi.Input[str]]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Read operations occur during any refresh or planning operation when refresh is enabled.
+        """
+        return pulumi.get(self, "read")
+
+    @read.setter
+    def read(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "read", value)
+
+    @property
+    @pulumi.getter
+    def update(self) -> Optional[pulumi.Input[str]]:
+        """
+        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
+        """
+        return pulumi.get(self, "update")
+
+    @update.setter
+    def update(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "update", value)
+
+
 @pulumi.input_type
 class PgComponentArgs:
     def __init__(__self__, *,

{pulumi_aiven-6.7.0a1693027281 → pulumi_aiven-6.7.0a1694131986}/pulumi_aiven/cassandra.py

@@ -16,6 +16,7 @@ __all__ = ['CassandraArgs', 'Cassandra']
 @pulumi.input_type
 class CassandraArgs:
     def __init__(__self__, *,
+                 plan: pulumi.Input[str],
                  project: pulumi.Input[str],
                  service_name: pulumi.Input[str],
                  additional_disk_space: Optional[pulumi.Input[str]] = None,
@@ -24,7 +25,6 @@ class CassandraArgs:
                  disk_space: Optional[pulumi.Input[str]] = None,
                  maintenance_window_dow: Optional[pulumi.Input[str]] = None,
                  maintenance_window_time: Optional[pulumi.Input[str]] = None,
-                 plan: Optional[pulumi.Input[str]] = None,
                  project_vpc_id: Optional[pulumi.Input[str]] = None,
                  service_integrations: Optional[pulumi.Input[Sequence[pulumi.Input['CassandraServiceIntegrationArgs']]]] = None,
                  static_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
@@ -32,6 +32,7 @@ class CassandraArgs:
                  termination_protection: Optional[pulumi.Input[bool]] = None):
         """
         The set of arguments for constructing a Cassandra resource.
+        :param pulumi.Input[str] plan: Defines what kind of computing resources are allocated for the service. It can be changed after creation, though there are some restrictions when going to a smaller plan such as the new plan must have sufficient amount of disk space to store all current data and switching to a plan with fewer nodes might not be supported. The basic plan names are `hobbyist`, `startup-x`, `business-x` and `premium-x` where `x` is (roughly) the amount of memory on each node (also other attributes like number of CPUs and amount of disk space varies but naming is based on memory). The available options can be seem from the [Aiven pricing page](https://aiven.io/pricing).
         :param pulumi.Input[str] project: Identifies the project this resource belongs to. To set up proper dependencies please refer to this variable as a reference. This property cannot be changed, doing so forces recreation of the resource.
         :param pulumi.Input[str] service_name: Specifies the actual name of the service. The name cannot be changed later without destroying and re-creating the service so name should be picked based on intended service usage rather than current attributes.
         :param pulumi.Input[str] additional_disk_space: Additional disk space. Possible values depend on the service type, the cloud provider and the project. Therefore, reducing will result in the service rebalancing.
@@ -40,13 +41,13 @@ class CassandraArgs:
         :param pulumi.Input[str] disk_space: Service disk space. Possible values depend on the service type, the cloud provider and the project. Therefore, reducing will result in the service rebalancing.
         :param pulumi.Input[str] maintenance_window_dow: Day of week when maintenance operations should be performed. One monday, tuesday, wednesday, etc.
         :param pulumi.Input[str] maintenance_window_time: Time of day when maintenance operations should be performed. UTC time in HH:mm:ss format.
-        :param pulumi.Input[str] plan: Defines what kind of computing resources are allocated for the service. It can be changed after creation, though there are some restrictions when going to a smaller plan such as the new plan must have sufficient amount of disk space to store all current data and switching to a plan with fewer nodes might not be supported. The basic plan names are `hobbyist`, `startup-x`, `business-x` and `premium-x` where `x` is (roughly) the amount of memory on each node (also other attributes like number of CPUs and amount of disk space varies but naming is based on memory). The available options can be seem from the [Aiven pricing page](https://aiven.io/pricing).
         :param pulumi.Input[str] project_vpc_id: Specifies the VPC the service should run in. If the value is not set the service is not run inside a VPC. When set, the value should be given as a reference to set up dependencies correctly and the VPC must be in the same cloud and region as the service itself. Project can be freely moved to and from VPC after creation but doing so triggers migration to new servers so the operation can take significant amount of time to complete if the service has a lot of data.
         :param pulumi.Input[Sequence[pulumi.Input['CassandraServiceIntegrationArgs']]] service_integrations: Service integrations to specify when creating a service. Not applied after initial service creation
         :param pulumi.Input[Sequence[pulumi.Input[str]]] static_ips: Static IPs that are going to be associated with this service. Please assign a value using the 'toset' function. Once a static ip resource is in the 'assigned' state it cannot be unbound from the node again
         :param pulumi.Input[Sequence[pulumi.Input['CassandraTagArgs']]] tags: Tags are key-value pairs that allow you to categorize services.
         :param pulumi.Input[bool] termination_protection: Prevents the service from being deleted. It is recommended to set this to `true` for all production services to prevent unintentional service deletion. This does not shield against deleting databases or topics but for services with backups much of the content can at least be restored from backup in case accidental deletion is done.
         """
+        pulumi.set(__self__, "plan", plan)
         pulumi.set(__self__, "project", project)
         pulumi.set(__self__, "service_name", service_name)
         if additional_disk_space is not None:
@@ -56,16 +57,14 @@ class CassandraArgs:
         if cloud_name is not None:
             pulumi.set(__self__, "cloud_name", cloud_name)
         if disk_space is not None:
-            warnings.warn("""This will be removed in v5.0.0 and replaced with additional_disk_space instead.""", DeprecationWarning)
-            pulumi.log.warn("""disk_space is deprecated: This will be removed in v5.0.0 and replaced with additional_disk_space instead.""")
+            warnings.warn("""This will be removed in v5.0.0. Please use `additional_disk_space` to specify the space to be added to the default `disk_space` defined by the plan.""", DeprecationWarning)
+            pulumi.log.warn("""disk_space is deprecated: This will be removed in v5.0.0. Please use `additional_disk_space` to specify the space to be added to the default `disk_space` defined by the plan.""")
         if disk_space is not None:
             pulumi.set(__self__, "disk_space", disk_space)
         if maintenance_window_dow is not None:
             pulumi.set(__self__, "maintenance_window_dow", maintenance_window_dow)
         if maintenance_window_time is not None:
             pulumi.set(__self__, "maintenance_window_time", maintenance_window_time)
-        if plan is not None:
-            pulumi.set(__self__, "plan", plan)
         if project_vpc_id is not None:
             pulumi.set(__self__, "project_vpc_id", project_vpc_id)
         if service_integrations is not None:
@@ -77,6 +76,18 @@ class CassandraArgs:
         if termination_protection is not None:
             pulumi.set(__self__, "termination_protection", termination_protection)
 
+    @property
+    @pulumi.getter
+    def plan(self) -> pulumi.Input[str]:
+        """
+        Defines what kind of computing resources are allocated for the service. It can be changed after creation, though there are some restrictions when going to a smaller plan such as the new plan must have sufficient amount of disk space to store all current data and switching to a plan with fewer nodes might not be supported. The basic plan names are `hobbyist`, `startup-x`, `business-x` and `premium-x` where `x` is (roughly) the amount of memory on each node (also other attributes like number of CPUs and amount of disk space varies but naming is based on memory). The available options can be seem from the [Aiven pricing page](https://aiven.io/pricing).
+        """
+        return pulumi.get(self, "plan")
+
+    @plan.setter
+    def plan(self, value: pulumi.Input[str]):
+        pulumi.set(self, "plan", value)
+
     @property
     @pulumi.getter
     def project(self) -> pulumi.Input[str]:
@@ -143,8 +154,8 @@ class CassandraArgs:
         """
         Service disk space. Possible values depend on the service type, the cloud provider and the project. Therefore, reducing will result in the service rebalancing.
         """
-        warnings.warn("""This will be removed in v5.0.0 and replaced with additional_disk_space instead.""", DeprecationWarning)
-        pulumi.log.warn("""disk_space is deprecated: This will be removed in v5.0.0 and replaced with additional_disk_space instead.""")
+        warnings.warn("""This will be removed in v5.0.0. Please use `additional_disk_space` to specify the space to be added to the default `disk_space` defined by the plan.""", DeprecationWarning)
+        pulumi.log.warn("""disk_space is deprecated: This will be removed in v5.0.0. Please use `additional_disk_space` to specify the space to be added to the default `disk_space` defined by the plan.""")
 
         return pulumi.get(self, "disk_space")
 
@@ -176,18 +187,6 @@ class CassandraArgs:
     def maintenance_window_time(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "maintenance_window_time", value)
 
-    @property
-    @pulumi.getter
-    def plan(self) -> Optional[pulumi.Input[str]]:
-        """
-        Defines what kind of computing resources are allocated for the service. It can be changed after creation, though there are some restrictions when going to a smaller plan such as the new plan must have sufficient amount of disk space to store all current data and switching to a plan with fewer nodes might not be supported. The basic plan names are `hobbyist`, `startup-x`, `business-x` and `premium-x` where `x` is (roughly) the amount of memory on each node (also other attributes like number of CPUs and amount of disk space varies but naming is based on memory). The available options can be seem from the [Aiven pricing page](https://aiven.io/pricing).
-        """
-        return pulumi.get(self, "plan")
-
-    @plan.setter
-    def plan(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "plan", value)
-
     @property
     @pulumi.getter(name="projectVpcId")
     def project_vpc_id(self) -> Optional[pulumi.Input[str]]:
@@ -320,8 +319,8 @@ class _CassandraState:
         if components is not None:
             pulumi.set(__self__, "components", components)
         if disk_space is not None:
-            warnings.warn("""This will be removed in v5.0.0 and replaced with additional_disk_space instead.""", DeprecationWarning)
-            pulumi.log.warn("""disk_space is deprecated: This will be removed in v5.0.0 and replaced with additional_disk_space instead.""")
+            warnings.warn("""This will be removed in v5.0.0. Please use `additional_disk_space` to specify the space to be added to the default `disk_space` defined by the plan.""", DeprecationWarning)
+            pulumi.log.warn("""disk_space is deprecated: This will be removed in v5.0.0. Please use `additional_disk_space` to specify the space to be added to the default `disk_space` defined by the plan.""")
         if disk_space is not None:
             pulumi.set(__self__, "disk_space", disk_space)
         if disk_space_cap is not None:
@@ -433,8 +432,8 @@ class _CassandraState:
         """
         Service disk space. Possible values depend on the service type, the cloud provider and the project. Therefore, reducing will result in the service rebalancing.
         """
-        warnings.warn("""This will be removed in v5.0.0 and replaced with additional_disk_space instead.""", DeprecationWarning)
-        pulumi.log.warn("""disk_space is deprecated: This will be removed in v5.0.0 and replaced with additional_disk_space instead.""")
+        warnings.warn("""This will be removed in v5.0.0. Please use `additional_disk_space` to specify the space to be added to the default `disk_space` defined by the plan.""", DeprecationWarning)
+        pulumi.log.warn("""disk_space is deprecated: This will be removed in v5.0.0. Please use `additional_disk_space` to specify the space to be added to the default `disk_space` defined by the plan.""")
 
         return pulumi.get(self, "disk_space")
 
@@ -840,11 +839,13 @@ class Cassandra(pulumi.CustomResource):
             __props__.__dict__["cassandra_user_config"] = cassandra_user_config
             __props__.__dict__["cloud_name"] = cloud_name
             if disk_space is not None and not opts.urn:
-                warnings.warn("""This will be removed in v5.0.0 and replaced with additional_disk_space instead.""", DeprecationWarning)
-                pulumi.log.warn("""disk_space is deprecated: This will be removed in v5.0.0 and replaced with additional_disk_space instead.""")
+                warnings.warn("""This will be removed in v5.0.0. Please use `additional_disk_space` to specify the space to be added to the default `disk_space` defined by the plan.""", DeprecationWarning)
+                pulumi.log.warn("""disk_space is deprecated: This will be removed in v5.0.0. Please use `additional_disk_space` to specify the space to be added to the default `disk_space` defined by the plan.""")
             __props__.__dict__["disk_space"] = disk_space
             __props__.__dict__["maintenance_window_dow"] = maintenance_window_dow
             __props__.__dict__["maintenance_window_time"] = maintenance_window_time
+            if plan is None and not opts.urn:
+                raise TypeError("Missing required property 'plan'")
             __props__.__dict__["plan"] = plan
             if project is None and not opts.urn:
                 raise TypeError("Missing required property 'project'")
@@ -1023,8 +1024,8 @@ class Cassandra(pulumi.CustomResource):
         """
         Service disk space. Possible values depend on the service type, the cloud provider and the project. Therefore, reducing will result in the service rebalancing.
         """
-        warnings.warn("""This will be removed in v5.0.0 and replaced with additional_disk_space instead.""", DeprecationWarning)
-        pulumi.log.warn("""disk_space is deprecated: This will be removed in v5.0.0 and replaced with additional_disk_space instead.""")
+        warnings.warn("""This will be removed in v5.0.0. Please use `additional_disk_space` to specify the space to be added to the default `disk_space` defined by the plan.""", DeprecationWarning)
+        pulumi.log.warn("""disk_space is deprecated: This will be removed in v5.0.0. Please use `additional_disk_space` to specify the space to be added to the default `disk_space` defined by the plan.""")
 
         return pulumi.get(self, "disk_space")
 
@@ -1078,7 +1079,7 @@ class Cassandra(pulumi.CustomResource):
 
     @property
     @pulumi.getter
-    def plan(self) -> pulumi.Output[Optional[str]]:
+    def plan(self) -> pulumi.Output[str]:
         """
         Defines what kind of computing resources are allocated for the service. It can be changed after creation, though there are some restrictions when going to a smaller plan such as the new plan must have sufficient amount of disk space to store all current data and switching to a plan with fewer nodes might not be supported. The basic plan names are `hobbyist`, `startup-x`, `business-x` and `premium-x` where `x` is (roughly) the amount of memory on each node (also other attributes like number of CPUs and amount of disk space varies but naming is based on memory). The available options can be seem from the [Aiven pricing page](https://aiven.io/pricing).
         """