pulumi-confluentcloud 2.52.0a1763696172__py3-none-any.whl → 2.53.0__py3-none-any.whl

pulumi_confluentcloud/_inputs.py

@@ -3954,14 +3954,34 @@ class KafkaClientQuotaThroughputArgs:
 
 if not MYPY:
     class KafkaClusterBasicArgsDict(TypedDict):
-        pass
+        max_ecku: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
 elif False:
     KafkaClusterBasicArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class KafkaClusterBasicArgs:
-    def __init__(__self__):
-        pass
+    def __init__(__self__, *,
+                 max_ecku: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.int] max_ecku: The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
+        if max_ecku is not None:
+            pulumi.set(__self__, "max_ecku", max_ecku)
+
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
+        return pulumi.get(self, "max_ecku")
+
+    @max_ecku.setter
+    def max_ecku(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "max_ecku", value)
 
 
 if not MYPY:
@@ -4101,6 +4121,8 @@ if not MYPY:
         !> **Warning:** You can only upgrade clusters from `basic` to `standard`.
 
         > **Note:** Currently, provisioning of a Dedicated Kafka cluster takes around 25 minutes on average but might take up to 24 hours. If you can't wait for the `pulumi up` step to finish, you can exit it and import the cluster by using the `pulumi import` command once it has been provisioned. When the cluster is provisioned, you will receive an email notification, and you can also follow updates on the Target Environment web page of the Confluent Cloud website.
+
+        > **Note:** Refer to [eCKU/CKU comparison](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#ecku-cku-comparison) documentation for the minimum/maximum eCKU requirements for each cluster type.
         """
         encryption_key: NotRequired[pulumi.Input[_builtins.str]]
         """
@@ -4130,6 +4152,8 @@ class KafkaClusterDedicatedArgs:
                !> **Warning:** You can only upgrade clusters from `basic` to `standard`.
                
                > **Note:** Currently, provisioning of a Dedicated Kafka cluster takes around 25 minutes on average but might take up to 24 hours. If you can't wait for the `pulumi up` step to finish, you can exit it and import the cluster by using the `pulumi import` command once it has been provisioned. When the cluster is provisioned, you will receive an email notification, and you can also follow updates on the Target Environment web page of the Confluent Cloud website.
+               
+               > **Note:** Refer to [eCKU/CKU comparison](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#ecku-cku-comparison) documentation for the minimum/maximum eCKU requirements for each cluster type.
         :param pulumi.Input[_builtins.str] encryption_key: The ID of the encryption key that is used to encrypt the data in the Kafka cluster.
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] zones: (Required List of String) The list of zones the cluster is in.
                - On AWS, zones are AWS [AZ IDs](https://docs.aws.amazon.com/ram/latest/userguide/working-with-az-ids.html), for example, `use1-az3`.
@@ -4153,6 +4177,8 @@ class KafkaClusterDedicatedArgs:
         !> **Warning:** You can only upgrade clusters from `basic` to `standard`.
 
         > **Note:** Currently, provisioning of a Dedicated Kafka cluster takes around 25 minutes on average but might take up to 24 hours. If you can't wait for the `pulumi up` step to finish, you can exit it and import the cluster by using the `pulumi import` command once it has been provisioned. When the cluster is provisioned, you will receive an email notification, and you can also follow updates on the Target Environment web page of the Confluent Cloud website.
+
+        > **Note:** Refer to [eCKU/CKU comparison](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#ecku-cku-comparison) documentation for the minimum/maximum eCKU requirements for each cluster type.
         """
         return pulumi.get(self, "cku")
 
@@ -4280,14 +4306,34 @@ class KafkaClusterEndpointArgs:
 
 if not MYPY:
     class KafkaClusterEnterpriseArgsDict(TypedDict):
-        pass
+        max_ecku: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
 elif False:
     KafkaClusterEnterpriseArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class KafkaClusterEnterpriseArgs:
-    def __init__(__self__):
-        pass
+    def __init__(__self__, *,
+                 max_ecku: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.int] max_ecku: The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
+        if max_ecku is not None:
+            pulumi.set(__self__, "max_ecku", max_ecku)
+
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
+        return pulumi.get(self, "max_ecku")
+
+    @max_ecku.setter
+    def max_ecku(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "max_ecku", value)
 
 
 if not MYPY:
@@ -4323,6 +4369,10 @@ class KafkaClusterEnvironmentArgs:
 
 if not MYPY:
     class KafkaClusterFreightArgsDict(TypedDict):
+        max_ecku: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
         zones: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
         """
         (Required List of String) The list of zones the cluster is in.
@@ -4334,14 +4384,30 @@ elif False:
 @pulumi.input_type
 class KafkaClusterFreightArgs:
     def __init__(__self__, *,
+                 max_ecku: Optional[pulumi.Input[_builtins.int]] = None,
                  zones: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
         """
+        :param pulumi.Input[_builtins.int] max_ecku: The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
         :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] zones: (Required List of String) The list of zones the cluster is in.
                - On AWS, zones are AWS [AZ IDs](https://docs.aws.amazon.com/ram/latest/userguide/working-with-az-ids.html), for example, `use1-az3`.
         """
+        if max_ecku is not None:
+            pulumi.set(__self__, "max_ecku", max_ecku)
         if zones is not None:
             pulumi.set(__self__, "zones", zones)
 
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
+        return pulumi.get(self, "max_ecku")
+
+    @max_ecku.setter
+    def max_ecku(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "max_ecku", value)
+
     @_builtins.property
     @pulumi.getter
     def zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
@@ -4389,14 +4455,34 @@ class KafkaClusterNetworkArgs:
 
 if not MYPY:
     class KafkaClusterStandardArgsDict(TypedDict):
-        pass
+        max_ecku: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
 elif False:
     KafkaClusterStandardArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class KafkaClusterStandardArgs:
-    def __init__(__self__):
-        pass
+    def __init__(__self__, *,
+                 max_ecku: Optional[pulumi.Input[_builtins.int]] = None):
+        """
+        :param pulumi.Input[_builtins.int] max_ecku: The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
+        if max_ecku is not None:
+            pulumi.set(__self__, "max_ecku", max_ecku)
+
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
+        return pulumi.get(self, "max_ecku")
+
+    @max_ecku.setter
+    def max_ecku(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "max_ecku", value)
 
 
 if not MYPY:
@@ -9516,14 +9602,33 @@ class GetIpAddressesFilterArgs:
 
 if not MYPY:
     class GetKafkaClusterBasicArgsDict(TypedDict):
-        pass
+        max_ecku: _builtins.int
+        """
+        (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
 elif False:
     GetKafkaClusterBasicArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class GetKafkaClusterBasicArgs:
-    def __init__(__self__):
-        pass
+    def __init__(__self__, *,
+                 max_ecku: _builtins.int):
+        """
+        :param _builtins.int max_ecku: (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
+        pulumi.set(__self__, "max_ecku", max_ecku)
+
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> _builtins.int:
+        """
+        (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
+        return pulumi.get(self, "max_ecku")
+
+    @max_ecku.setter
+    def max_ecku(self, value: _builtins.int):
+        pulumi.set(self, "max_ecku", value)
 
 
 if not MYPY:
@@ -9606,14 +9711,33 @@ class GetKafkaClusterDedicatedArgs:
 
 if not MYPY:
     class GetKafkaClusterEnterpriseArgsDict(TypedDict):
-        pass
+        max_ecku: _builtins.int
+        """
+        (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
 elif False:
     GetKafkaClusterEnterpriseArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class GetKafkaClusterEnterpriseArgs:
-    def __init__(__self__):
-        pass
+    def __init__(__self__, *,
+                 max_ecku: _builtins.int):
+        """
+        :param _builtins.int max_ecku: (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
+        pulumi.set(__self__, "max_ecku", max_ecku)
+
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> _builtins.int:
+        """
+        (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
+        return pulumi.get(self, "max_ecku")
+
+    @max_ecku.setter
+    def max_ecku(self, value: _builtins.int):
+        pulumi.set(self, "max_ecku", value)
 
 
 if not MYPY:
@@ -9655,6 +9779,10 @@ class GetKafkaClusterEnvironmentArgs:
 
 if not MYPY:
     class GetKafkaClusterFreightArgsDict(TypedDict):
+        max_ecku: _builtins.int
+        """
+        (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
         zones: Sequence[_builtins.str]
         """
         (Required List of String) The list of zones the cluster is in.
@@ -9668,15 +9796,30 @@ elif False:
 @pulumi.input_type
 class GetKafkaClusterFreightArgs:
     def __init__(__self__, *,
+                 max_ecku: _builtins.int,
                  zones: Sequence[_builtins.str]):
         """
+        :param _builtins.int max_ecku: (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
         :param Sequence[_builtins.str] zones: (Required List of String) The list of zones the cluster is in.
                - On AWS, zones are AWS [AZ IDs](https://docs.aws.amazon.com/ram/latest/userguide/working-with-az-ids.html), for example, `use1-az3`.
                - On GCP, zones are GCP [zones](https://cloud.google.com/compute/docs/regions-zones), for example, `us-central1-c`.
                - On Azure, zones are Confluent-chosen names (for example, `1`, `2`, `3`) since Azure does not have universal zone identifiers.
         """
+        pulumi.set(__self__, "max_ecku", max_ecku)
         pulumi.set(__self__, "zones", zones)
 
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> _builtins.int:
+        """
+        (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
+        return pulumi.get(self, "max_ecku")
+
+    @max_ecku.setter
+    def max_ecku(self, value: _builtins.int):
+        pulumi.set(self, "max_ecku", value)
+
     @_builtins.property
     @pulumi.getter
     def zones(self) -> Sequence[_builtins.str]:
@@ -9695,14 +9838,33 @@ class GetKafkaClusterFreightArgs:
 
 if not MYPY:
     class GetKafkaClusterStandardArgsDict(TypedDict):
-        pass
+        max_ecku: _builtins.int
+        """
+        (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
 elif False:
     GetKafkaClusterStandardArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class GetKafkaClusterStandardArgs:
-    def __init__(__self__):
-        pass
+    def __init__(__self__, *,
+                 max_ecku: _builtins.int):
+        """
+        :param _builtins.int max_ecku: (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
+        pulumi.set(__self__, "max_ecku", max_ecku)
+
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> _builtins.int:
+        """
+        (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
+        return pulumi.get(self, "max_ecku")
+
+    @max_ecku.setter
+    def max_ecku(self, value: _builtins.int):
+        pulumi.set(self, "max_ecku", value)
 
 
 if not MYPY:

pulumi_confluentcloud/outputs.py

@@ -2757,8 +2757,38 @@ class KafkaClientQuotaThroughput(dict):
 
 @pulumi.output_type
 class KafkaClusterBasic(dict):
-    def __init__(__self__):
-        pass
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "maxEcku":
+            suggest = "max_ecku"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in KafkaClusterBasic. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        KafkaClusterBasic.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        KafkaClusterBasic.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 max_ecku: Optional[_builtins.int] = None):
+        """
+        :param _builtins.int max_ecku: The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
+        if max_ecku is not None:
+            pulumi.set(__self__, "max_ecku", max_ecku)
+
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> Optional[_builtins.int]:
+        """
+        The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
+        return pulumi.get(self, "max_ecku")
 
 
 @pulumi.output_type
@@ -2867,6 +2897,8 @@ class KafkaClusterDedicated(dict):
                !> **Warning:** You can only upgrade clusters from `basic` to `standard`.
                
                > **Note:** Currently, provisioning of a Dedicated Kafka cluster takes around 25 minutes on average but might take up to 24 hours. If you can't wait for the `pulumi up` step to finish, you can exit it and import the cluster by using the `pulumi import` command once it has been provisioned. When the cluster is provisioned, you will receive an email notification, and you can also follow updates on the Target Environment web page of the Confluent Cloud website.
+               
+               > **Note:** Refer to [eCKU/CKU comparison](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#ecku-cku-comparison) documentation for the minimum/maximum eCKU requirements for each cluster type.
         :param _builtins.str encryption_key: The ID of the encryption key that is used to encrypt the data in the Kafka cluster.
         :param Sequence[_builtins.str] zones: (Required List of String) The list of zones the cluster is in.
                - On AWS, zones are AWS [AZ IDs](https://docs.aws.amazon.com/ram/latest/userguide/working-with-az-ids.html), for example, `use1-az3`.
@@ -2890,6 +2922,8 @@ class KafkaClusterDedicated(dict):
         !> **Warning:** You can only upgrade clusters from `basic` to `standard`.
 
         > **Note:** Currently, provisioning of a Dedicated Kafka cluster takes around 25 minutes on average but might take up to 24 hours. If you can't wait for the `pulumi up` step to finish, you can exit it and import the cluster by using the `pulumi import` command once it has been provisioned. When the cluster is provisioned, you will receive an email notification, and you can also follow updates on the Target Environment web page of the Confluent Cloud website.
+
+        > **Note:** Refer to [eCKU/CKU comparison](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#ecku-cku-comparison) documentation for the minimum/maximum eCKU requirements for each cluster type.
         """
         return pulumi.get(self, "cku")
 
@@ -2991,8 +3025,38 @@ class KafkaClusterEndpoint(dict):
 
 @pulumi.output_type
 class KafkaClusterEnterprise(dict):
-    def __init__(__self__):
-        pass
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "maxEcku":
+            suggest = "max_ecku"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in KafkaClusterEnterprise. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        KafkaClusterEnterprise.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        KafkaClusterEnterprise.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 max_ecku: Optional[_builtins.int] = None):
+        """
+        :param _builtins.int max_ecku: The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
+        if max_ecku is not None:
+            pulumi.set(__self__, "max_ecku", max_ecku)
+
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> Optional[_builtins.int]:
+        """
+        The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
+        return pulumi.get(self, "max_ecku")
 
 
 @pulumi.output_type
@@ -3015,15 +3079,44 @@ class KafkaClusterEnvironment(dict):
 
 @pulumi.output_type
 class KafkaClusterFreight(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "maxEcku":
+            suggest = "max_ecku"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in KafkaClusterFreight. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        KafkaClusterFreight.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        KafkaClusterFreight.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
+                 max_ecku: Optional[_builtins.int] = None,
                  zones: Optional[Sequence[_builtins.str]] = None):
         """
+        :param _builtins.int max_ecku: The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
         :param Sequence[_builtins.str] zones: (Required List of String) The list of zones the cluster is in.
                - On AWS, zones are AWS [AZ IDs](https://docs.aws.amazon.com/ram/latest/userguide/working-with-az-ids.html), for example, `use1-az3`.
         """
+        if max_ecku is not None:
+            pulumi.set(__self__, "max_ecku", max_ecku)
         if zones is not None:
             pulumi.set(__self__, "zones", zones)
 
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> Optional[_builtins.int]:
+        """
+        The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
+        return pulumi.get(self, "max_ecku")
+
     @_builtins.property
     @pulumi.getter
     def zones(self) -> Optional[Sequence[_builtins.str]]:
@@ -3054,8 +3147,38 @@ class KafkaClusterNetwork(dict):
 
 @pulumi.output_type
 class KafkaClusterStandard(dict):
-    def __init__(__self__):
-        pass
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "maxEcku":
+            suggest = "max_ecku"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in KafkaClusterStandard. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        KafkaClusterStandard.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        KafkaClusterStandard.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 max_ecku: Optional[_builtins.int] = None):
+        """
+        :param _builtins.int max_ecku: The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
+        if max_ecku is not None:
+            pulumi.set(__self__, "max_ecku", max_ecku)
+
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> Optional[_builtins.int]:
+        """
+        The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs.
+        """
+        return pulumi.get(self, "max_ecku")
 
 
 @pulumi.output_type
@@ -7331,8 +7454,20 @@ class GetKafkaClientQuotaThroughputResult(dict):
 
 @pulumi.output_type
 class GetKafkaClusterBasicResult(dict):
-    def __init__(__self__):
-        pass
+    def __init__(__self__, *,
+                 max_ecku: _builtins.int):
+        """
+        :param _builtins.int max_ecku: (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
+        pulumi.set(__self__, "max_ecku", max_ecku)
+
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> _builtins.int:
+        """
+        (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
+        return pulumi.get(self, "max_ecku")
 
 
 @pulumi.output_type
@@ -7452,8 +7587,20 @@ class GetKafkaClusterEndpointResult(dict):
 
 @pulumi.output_type
 class GetKafkaClusterEnterpriseResult(dict):
-    def __init__(__self__):
-        pass
+    def __init__(__self__, *,
+                 max_ecku: _builtins.int):
+        """
+        :param _builtins.int max_ecku: (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
+        pulumi.set(__self__, "max_ecku", max_ecku)
+
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> _builtins.int:
+        """
+        (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
+        return pulumi.get(self, "max_ecku")
 
 
 @pulumi.output_type
@@ -7481,15 +7628,26 @@ class GetKafkaClusterEnvironmentResult(dict):
 @pulumi.output_type
 class GetKafkaClusterFreightResult(dict):
     def __init__(__self__, *,
+                 max_ecku: _builtins.int,
                  zones: Sequence[_builtins.str]):
         """
+        :param _builtins.int max_ecku: (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
         :param Sequence[_builtins.str] zones: (Required List of String) The list of zones the cluster is in.
                - On AWS, zones are AWS [AZ IDs](https://docs.aws.amazon.com/ram/latest/userguide/working-with-az-ids.html), for example, `use1-az3`.
                - On GCP, zones are GCP [zones](https://cloud.google.com/compute/docs/regions-zones), for example, `us-central1-c`.
                - On Azure, zones are Confluent-chosen names (for example, `1`, `2`, `3`) since Azure does not have universal zone identifiers.
         """
+        pulumi.set(__self__, "max_ecku", max_ecku)
         pulumi.set(__self__, "zones", zones)
 
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> _builtins.int:
+        """
+        (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
+        return pulumi.get(self, "max_ecku")
+
     @_builtins.property
     @pulumi.getter
     def zones(self) -> Sequence[_builtins.str]:
@@ -7522,8 +7680,20 @@ class GetKafkaClusterNetworkResult(dict):
 
 @pulumi.output_type
 class GetKafkaClusterStandardResult(dict):
-    def __init__(__self__):
-        pass
+    def __init__(__self__, *,
+                 max_ecku: _builtins.int):
+        """
+        :param _builtins.int max_ecku: (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
+        pulumi.set(__self__, "max_ecku", max_ecku)
+
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> _builtins.int:
+        """
+        (Optional Number) The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with "HIGH" availability must have at least two eCKUs. For more details, see [Maximum eCKU requirements](https://docs.confluent.io/cloud/current/clusters/cluster-types.html#minimum-maximum-ecku-requirements).
+        """
+        return pulumi.get(self, "max_ecku")
 
 
 @pulumi.output_type
@@ -7749,8 +7919,20 @@ class GetKafkaClustersClusterResult(dict):
 
 @pulumi.output_type
 class GetKafkaClustersClusterBasicResult(dict):
-    def __init__(__self__):
-        pass
+    def __init__(__self__, *,
+                 max_ecku: _builtins.int):
+        """
+        :param _builtins.int max_ecku: The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with HIGH availability must have at least two eCKUs.
+        """
+        pulumi.set(__self__, "max_ecku", max_ecku)
+
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> _builtins.int:
+        """
+        The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with HIGH availability must have at least two eCKUs.
+        """
+        return pulumi.get(self, "max_ecku")
 
 
 @pulumi.output_type
@@ -7870,8 +8052,20 @@ class GetKafkaClustersClusterEndpointResult(dict):
 
 @pulumi.output_type
 class GetKafkaClustersClusterEnterpriseResult(dict):
-    def __init__(__self__):
-        pass
+    def __init__(__self__, *,
+                 max_ecku: _builtins.int):
+        """
+        :param _builtins.int max_ecku: The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with HIGH availability must have at least two eCKUs.
+        """
+        pulumi.set(__self__, "max_ecku", max_ecku)
+
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> _builtins.int:
+        """
+        The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with HIGH availability must have at least two eCKUs.
+        """
+        return pulumi.get(self, "max_ecku")
 
 
 @pulumi.output_type
@@ -7895,15 +8089,26 @@ class GetKafkaClustersClusterEnvironmentResult(dict):
 @pulumi.output_type
 class GetKafkaClustersClusterFreightResult(dict):
     def __init__(__self__, *,
+                 max_ecku: _builtins.int,
                  zones: Sequence[_builtins.str]):
         """
+        :param _builtins.int max_ecku: The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with HIGH availability must have at least two eCKUs.
         :param Sequence[_builtins.str] zones: (Required List of String) The list of zones the cluster is in.
                - On AWS, zones are AWS [AZ IDs](https://docs.aws.amazon.com/ram/latest/userguide/working-with-az-ids.html), for example, `use1-az3`.
                - On GCP, zones are GCP [zones](https://cloud.google.com/compute/docs/regions-zones), for example, `us-central1-c`.
                - On Azure, zones are Confluent-chosen names (for example, `1`, `2`, `3`) since Azure does not have universal zone identifiers.
         """
+        pulumi.set(__self__, "max_ecku", max_ecku)
         pulumi.set(__self__, "zones", zones)
 
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> _builtins.int:
+        """
+        The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with HIGH availability must have at least two eCKUs.
+        """
+        return pulumi.get(self, "max_ecku")
+
     @_builtins.property
     @pulumi.getter
     def zones(self) -> Sequence[_builtins.str]:
@@ -7936,8 +8141,20 @@ class GetKafkaClustersClusterNetworkResult(dict):
 
 @pulumi.output_type
 class GetKafkaClustersClusterStandardResult(dict):
-    def __init__(__self__):
-        pass
+    def __init__(__self__, *,
+                 max_ecku: _builtins.int):
+        """
+        :param _builtins.int max_ecku: The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with HIGH availability must have at least two eCKUs.
+        """
+        pulumi.set(__self__, "max_ecku", max_ecku)
+
+    @_builtins.property
+    @pulumi.getter(name="maxEcku")
+    def max_ecku(self) -> _builtins.int:
+        """
+        The maximum number of Elastic Confluent Kafka Units (eCKUs) that Kafka clusters should auto-scale to. Kafka clusters with HIGH availability must have at least two eCKUs.
+        """
+        return pulumi.get(self, "max_ecku")
 
 
 @pulumi.output_type

pulumi_confluentcloud/pulumi-plugin.json

@@ -1,5 +1,5 @@
 {
   "resource": true,
   "name": "confluentcloud",
-  "version": "2.52.0-alpha.1763696172"
+  "version": "2.53.0"
 }

{pulumi_confluentcloud-2.52.0a1763696172.dist-info → pulumi_confluentcloud-2.53.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pulumi_confluentcloud
-Version: 2.52.0a1763696172
+Version: 2.53.0
 Summary: A Pulumi package for creating and managing Confluent cloud resources.
 License: Apache-2.0
 Project-URL: Homepage, https://www.pulumi.com

{pulumi_confluentcloud-2.52.0a1763696172.dist-info → pulumi_confluentcloud-2.53.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 pulumi_confluentcloud/__init__.py,sha256=njoOocldDmVmxvwjY0h3gDa9vLDo_vpJsKmu8LK1Uks,16765
-pulumi_confluentcloud/_inputs.py,sha256=T1lZNvkdO0i2ujq__I58IvunwXp20PRcKUxNNWzPywg,479260
+pulumi_confluentcloud/_inputs.py,sha256=yoo6vKQAeNBel1RiUSwlgNnrQr6QE_VmGXOh3AtsQ7c,490648
 pulumi_confluentcloud/_utilities.py,sha256=66uLGQDI1oMFOI3Fe5igAphtexWhcSLDyuVW50jW3ik,10789
 pulumi_confluentcloud/access_point.py,sha256=EWjw5oS5Zvch3deV4n8oUv9AV73aYy7qUrEJ6ji0Db0,32976
 pulumi_confluentcloud/api_key.py,sha256=-jTRJ8ztmZQoqb3T9IzR7bhBdV9PxwUHDj8sG4O93Dc,36850
@@ -97,7 +97,7 @@ pulumi_confluentcloud/ksql_cluster.py,sha256=2iHuwHft1nFCJHHUZ_OQ6za0Wwhc01VyfdV
 pulumi_confluentcloud/network.py,sha256=8CtwHx8oTbnbgX7F4WLcmyFHUR5v-d6mt4XtcYdGShw,65777
 pulumi_confluentcloud/network_link_endpoint.py,sha256=mIDIlsxhKa5wwaLJzBn9aMGGl_lYRcZvUDjLFEh5aYI,21019
 pulumi_confluentcloud/network_link_service.py,sha256=1EYvdSSxGVyf9EYUb9KQEGF_d7ct74B4BTQcy5VvTto,21597
-pulumi_confluentcloud/outputs.py,sha256=i-3OrQV2Ld-zbySmJLDY0gBrXVIpesxx3X2uczhrI68,422261
+pulumi_confluentcloud/outputs.py,sha256=1iYkIO1caI4h3izic5HCj_pSmiUPc_-WekBVxGJjRnc,434591
 pulumi_confluentcloud/peering.py,sha256=JLZhrSeVal5O2KcWqgKjcA_NVxm4jCgdmKkeVqEcLAI,26219
 pulumi_confluentcloud/plugin.py,sha256=CKzFzVS27r-z8IC6uQKg6JMTAY-58RfRp9WZfybQC9c,19241
 pulumi_confluentcloud/private_link_access.py,sha256=RXRS63n0MtU1rqscLqDiZXCPTyB6Agn4CwKu5BEg6BY,26465
@@ -107,7 +107,7 @@ pulumi_confluentcloud/provider.py,sha256=sN-VlTRE0cOeq78IKZopdjt1JLVRJpXA3LYYbYi
 pulumi_confluentcloud/provider_integration.py,sha256=RmBOJN9EFsKlRiBAEP2_hXl-LR0FMWA6_qC61HWocPQ,16497
 pulumi_confluentcloud/provider_integration_authorization.py,sha256=iESH7OhbtppHB3wY8oBgpWAl9mrvp6Iar9vWtuXjHso,17537
 pulumi_confluentcloud/provider_integration_setup.py,sha256=q06Qw844J2N0uoctoACyySDy9piyuqjHzAjZS_WsHIc,19706
-pulumi_confluentcloud/pulumi-plugin.json,sha256=aFQPflYWaZG07Lbr8ZIR0vy4CHVEow3pPB4MnVhFnxk,91
+pulumi_confluentcloud/pulumi-plugin.json,sha256=D_DqYBDIACo_GBFRRe7eopvXz-qTerwzUgq4UYwVMI4,74
 pulumi_confluentcloud/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pulumi_confluentcloud/role_binding.py,sha256=MbeRwcuWNj_KSnNP2zEqNSthGBV1z1haBjbk97pvMZk,20463
 pulumi_confluentcloud/schema.py,sha256=CYdHdFIw-VYplimUSaTWGittfo5wUOEWuFYfD_kUbvI,49055
@@ -128,7 +128,7 @@ pulumi_confluentcloud/config/__init__.py,sha256=XWnQfVtc2oPapjSXXCdORFJvMpXt_SMJ
 pulumi_confluentcloud/config/__init__.pyi,sha256=wUpGQFTVXK9rFefT-KLKGEPtajQG_D4Due_TzbOT5jE,2151
 pulumi_confluentcloud/config/outputs.py,sha256=j9KabfxdzVhzLBDXzRsfQbM3kPvizCnfA4jT1GiYu7I,5369
 pulumi_confluentcloud/config/vars.py,sha256=a6jklkyhkLNyX1ZeL2snOeaA6uX4dqwUZl5fUDp3wMQ,4915
-pulumi_confluentcloud-2.52.0a1763696172.dist-info/METADATA,sha256=2RuXvjNlKfz7rx97oKZwZ7d76W_WSEOv2710edU4zRo,2898
-pulumi_confluentcloud-2.52.0a1763696172.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pulumi_confluentcloud-2.52.0a1763696172.dist-info/top_level.txt,sha256=0spb6Wqsv3xa9v5poWmP3cWll3tbfOwOKwneN7S2DjM,22
-pulumi_confluentcloud-2.52.0a1763696172.dist-info/RECORD,,
+pulumi_confluentcloud-2.53.0.dist-info/METADATA,sha256=GpL5GDkQHWCUcALqsvwQzHoRXIFXBsrC6K6De-956pk,2887
+pulumi_confluentcloud-2.53.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pulumi_confluentcloud-2.53.0.dist-info/top_level.txt,sha256=0spb6Wqsv3xa9v5poWmP3cWll3tbfOwOKwneN7S2DjM,22
+pulumi_confluentcloud-2.53.0.dist-info/RECORD,,