pulumi-confluentcloud 2.52.0a1763617028__tar.gz → 2.53.0__tar.gz

{pulumi_confluentcloud-2.52.0a1763617028 → pulumi_confluentcloud-2.53.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pulumi_confluentcloud
-Version: 2.52.0a1763617028
+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.0a1763617028 → pulumi_confluentcloud-2.53.0}/pulumi_confluentcloud/_inputs.py

@@ -327,6 +327,8 @@ __all__ = [
     'SubjectModeCredentialsArgsDict',
     'SubjectModeSchemaRegistryClusterArgs',
     'SubjectModeSchemaRegistryClusterArgsDict',
+    'TableflowTopicAzureDataLakeStorageGen2Args',
+    'TableflowTopicAzureDataLakeStorageGen2ArgsDict',
     'TableflowTopicByobAwsArgs',
     'TableflowTopicByobAwsArgsDict',
     'TableflowTopicCredentialsArgs',
@@ -3952,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:
@@ -4099,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]]
         """
@@ -4128,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`.
@@ -4151,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")
 
@@ -4278,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:
@@ -4321,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.
@@ -4332,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]]]]:
@@ -4387,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:
@@ -7840,6 +7928,95 @@ class SubjectModeSchemaRegistryClusterArgs:
         pulumi.set(self, "id", value)
 
 
+if not MYPY:
+    class TableflowTopicAzureDataLakeStorageGen2ArgsDict(TypedDict):
+        container_name: pulumi.Input[_builtins.str]
+        """
+        The container name.
+        """
+        provider_integration_id: pulumi.Input[_builtins.str]
+        """
+        The provider integration id.
+        """
+        storage_account_name: pulumi.Input[_builtins.str]
+        """
+        The storage account name.
+        """
+        storage_region: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        (Required String) The storage region.
+        """
+elif False:
+    TableflowTopicAzureDataLakeStorageGen2ArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class TableflowTopicAzureDataLakeStorageGen2Args:
+    def __init__(__self__, *,
+                 container_name: pulumi.Input[_builtins.str],
+                 provider_integration_id: pulumi.Input[_builtins.str],
+                 storage_account_name: pulumi.Input[_builtins.str],
+                 storage_region: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] container_name: The container name.
+        :param pulumi.Input[_builtins.str] provider_integration_id: The provider integration id.
+        :param pulumi.Input[_builtins.str] storage_account_name: The storage account name.
+        :param pulumi.Input[_builtins.str] storage_region: (Required String) The storage region.
+        """
+        pulumi.set(__self__, "container_name", container_name)
+        pulumi.set(__self__, "provider_integration_id", provider_integration_id)
+        pulumi.set(__self__, "storage_account_name", storage_account_name)
+        if storage_region is not None:
+            pulumi.set(__self__, "storage_region", storage_region)
+
+    @_builtins.property
+    @pulumi.getter(name="containerName")
+    def container_name(self) -> pulumi.Input[_builtins.str]:
+        """
+        The container name.
+        """
+        return pulumi.get(self, "container_name")
+
+    @container_name.setter
+    def container_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "container_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="providerIntegrationId")
+    def provider_integration_id(self) -> pulumi.Input[_builtins.str]:
+        """
+        The provider integration id.
+        """
+        return pulumi.get(self, "provider_integration_id")
+
+    @provider_integration_id.setter
+    def provider_integration_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "provider_integration_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="storageAccountName")
+    def storage_account_name(self) -> pulumi.Input[_builtins.str]:
+        """
+        The storage account name.
+        """
+        return pulumi.get(self, "storage_account_name")
+
+    @storage_account_name.setter
+    def storage_account_name(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "storage_account_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="storageRegion")
+    def storage_region(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        (Required String) The storage region.
+        """
+        return pulumi.get(self, "storage_region")
+
+    @storage_region.setter
+    def storage_region(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "storage_region", value)
+
+
 if not MYPY:
     class TableflowTopicByobAwsArgsDict(TypedDict):
         bucket_name: pulumi.Input[_builtins.str]
@@ -9425,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:
@@ -9515,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:
@@ -9564,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.
@@ -9577,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]:
@@ -9604,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-2.52.0a1763617028 → pulumi_confluentcloud-2.53.0}/pulumi_confluentcloud/get_tableflow_topic.py

@@ -28,7 +28,10 @@ class GetTableflowTopicResult:
     """
     A collection of values returned by getTableflowTopic.
     """
-    def __init__(__self__, byob_aws=None, credentials=None, display_name=None, enable_compaction=None, enable_partitioning=None, environment=None, error_handlings=None, id=None, kafka_cluster=None, managed_storages=None, record_failure_strategy=None, retention_ms=None, suspended=None, table_formats=None, table_path=None, write_mode=None):
+    def __init__(__self__, azure_data_lake_storage_gen2s=None, byob_aws=None, credentials=None, display_name=None, enable_compaction=None, enable_partitioning=None, environment=None, error_handlings=None, id=None, kafka_cluster=None, managed_storages=None, record_failure_strategy=None, retention_ms=None, suspended=None, table_formats=None, table_path=None, write_mode=None):
+        if azure_data_lake_storage_gen2s and not isinstance(azure_data_lake_storage_gen2s, list):
+            raise TypeError("Expected argument 'azure_data_lake_storage_gen2s' to be a list")
+        pulumi.set(__self__, "azure_data_lake_storage_gen2s", azure_data_lake_storage_gen2s)
         if byob_aws and not isinstance(byob_aws, list):
             raise TypeError("Expected argument 'byob_aws' to be a list")
         pulumi.set(__self__, "byob_aws", byob_aws)
@@ -78,6 +81,14 @@ class GetTableflowTopicResult:
             raise TypeError("Expected argument 'write_mode' to be a str")
         pulumi.set(__self__, "write_mode", write_mode)
 
+    @_builtins.property
+    @pulumi.getter(name="azureDataLakeStorageGen2s")
+    def azure_data_lake_storage_gen2s(self) -> Sequence['outputs.GetTableflowTopicAzureDataLakeStorageGen2Result']:
+        """
+        (Optional Configuration Block) supports the following:
+        """
+        return pulumi.get(self, "azure_data_lake_storage_gen2s")
+
     @_builtins.property
     @pulumi.getter(name="byobAws")
     def byob_aws(self) -> Sequence['outputs.GetTableflowTopicByobAwResult']:
@@ -201,6 +212,7 @@ class AwaitableGetTableflowTopicResult(GetTableflowTopicResult):
         if False:
             yield self
         return GetTableflowTopicResult(
+            azure_data_lake_storage_gen2s=self.azure_data_lake_storage_gen2s,
             byob_aws=self.byob_aws,
             credentials=self.credentials,
             display_name=self.display_name,
@@ -273,6 +285,7 @@ def get_tableflow_topic(credentials: Optional[Union['GetTableflowTopicCredential
     __ret__ = pulumi.runtime.invoke('confluentcloud:index/getTableflowTopic:getTableflowTopic', __args__, opts=opts, typ=GetTableflowTopicResult).value
 
     return AwaitableGetTableflowTopicResult(
+        azure_data_lake_storage_gen2s=pulumi.get(__ret__, 'azure_data_lake_storage_gen2s'),
         byob_aws=pulumi.get(__ret__, 'byob_aws'),
         credentials=pulumi.get(__ret__, 'credentials'),
         display_name=pulumi.get(__ret__, 'display_name'),
@@ -342,6 +355,7 @@ def get_tableflow_topic_output(credentials: Optional[pulumi.Input[Optional[Union
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('confluentcloud:index/getTableflowTopic:getTableflowTopic', __args__, opts=opts, typ=GetTableflowTopicResult)
     return __ret__.apply(lambda __response__: GetTableflowTopicResult(
+        azure_data_lake_storage_gen2s=pulumi.get(__response__, 'azure_data_lake_storage_gen2s'),
         byob_aws=pulumi.get(__response__, 'byob_aws'),
         credentials=pulumi.get(__response__, 'credentials'),
         display_name=pulumi.get(__response__, 'display_name'),