pulumi-confluentcloud 2.42.0__py3-none-any.whl → 2.54.0a1766503424__py3-none-any.whl

pulumi_confluentcloud/outputs.py

@@ -141,8 +141,12 @@ __all__ = [
     'PrivateLinkAttachmentConnectionPrivateLinkAttachment',
     'PrivateLinkAttachmentEnvironment',
     'PrivateLinkAttachmentGcp',
+    'ProviderIntegrationAuthorizationAzure',
+    'ProviderIntegrationAuthorizationEnvironment',
+    'ProviderIntegrationAuthorizationGcp',
     'ProviderIntegrationAws',
     'ProviderIntegrationEnvironment',
+    'ProviderIntegrationSetupEnvironment',
     'SchemaCredentials',
     'SchemaExporterCredentials',
     'SchemaExporterDestinationSchemaRegistryCluster',
@@ -167,9 +171,11 @@ __all__ = [
     'SubjectConfigSchemaRegistryCluster',
     'SubjectModeCredentials',
     'SubjectModeSchemaRegistryCluster',
+    'TableflowTopicAzureDataLakeStorageGen2',
     'TableflowTopicByobAws',
     'TableflowTopicCredentials',
     'TableflowTopicEnvironment',
+    'TableflowTopicErrorHandling',
     'TableflowTopicKafkaCluster',
     'TableflowTopicManagedStorage',
     'TagBindingCredentials',
@@ -239,6 +245,17 @@ __all__ = [
     'GetKafkaClusterFreightResult',
     'GetKafkaClusterNetworkResult',
     'GetKafkaClusterStandardResult',
+    'GetKafkaClustersClusterResult',
+    'GetKafkaClustersClusterBasicResult',
+    'GetKafkaClustersClusterByokKeyResult',
+    'GetKafkaClustersClusterDedicatedResult',
+    'GetKafkaClustersClusterEndpointResult',
+    'GetKafkaClustersClusterEnterpriseResult',
+    'GetKafkaClustersClusterEnvironmentResult',
+    'GetKafkaClustersClusterFreightResult',
+    'GetKafkaClustersClusterNetworkResult',
+    'GetKafkaClustersClusterStandardResult',
+    'GetKafkaClustersEnvironmentResult',
     'GetKafkaTopicCredentialsResult',
     'GetKafkaTopicKafkaClusterResult',
     'GetKsqlClusterCredentialIdentityResult',
@@ -276,8 +293,12 @@ __all__ = [
     'GetPrivateLinkAttachmentConnectionPrivateLinkAttachmentResult',
     'GetPrivateLinkAttachmentEnvironmentResult',
     'GetPrivateLinkAttachmentGcpResult',
+    'GetProviderIntegrationAuthorizationAzureResult',
+    'GetProviderIntegrationAuthorizationEnvironmentResult',
+    'GetProviderIntegrationAuthorizationGcpResult',
     'GetProviderIntegrationAwResult',
     'GetProviderIntegrationEnvironmentResult',
+    'GetProviderIntegrationSetupEnvironmentResult',
     'GetSchemaCredentialsResult',
     'GetSchemaMetadataResult',
     'GetSchemaMetadataTagResult',
@@ -307,9 +328,11 @@ __all__ = [
     'GetSubjectConfigSchemaRegistryClusterResult',
     'GetSubjectModeCredentialsResult',
     'GetSubjectModeSchemaRegistryClusterResult',
+    'GetTableflowTopicAzureDataLakeStorageGen2Result',
     'GetTableflowTopicByobAwResult',
     'GetTableflowTopicCredentialsResult',
     'GetTableflowTopicEnvironmentResult',
+    'GetTableflowTopicErrorHandlingResult',
     'GetTableflowTopicKafkaClusterResult',
     'GetTableflowTopicManagedStorageResult',
     'GetTagBindingCredentialsResult',
@@ -2734,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
@@ -2844,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`.
@@ -2867,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")
 
@@ -2968,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
@@ -2992,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]]:
@@ -3031,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
@@ -4108,8 +4254,8 @@ class PrivateLinkAttachmentAzure(dict):
                  private_link_service_alias: Optional[_builtins.str] = None,
                  private_link_service_resource_id: Optional[_builtins.str] = None):
         """
-        :param _builtins.str private_link_service_alias: Azure PrivateLink service alias for the availability zone.
-        :param _builtins.str private_link_service_resource_id: (Required String) Azure Private Link service resource id for the availability zone.
+        :param _builtins.str private_link_service_alias: (Required String) Azure Private Link service alias for the availability zone.
+        :param _builtins.str private_link_service_resource_id: (Required String) Azure Private Link service resource ID for the availability zone.
         """
         if private_link_service_alias is not None:
             pulumi.set(__self__, "private_link_service_alias", private_link_service_alias)
@@ -4120,7 +4266,7 @@ class PrivateLinkAttachmentAzure(dict):
     @pulumi.getter(name="privateLinkServiceAlias")
     def private_link_service_alias(self) -> Optional[_builtins.str]:
         """
-        Azure PrivateLink service alias for the availability zone.
+        (Required String) Azure Private Link service alias for the availability zone.
         """
         return pulumi.get(self, "private_link_service_alias")
 
@@ -4128,7 +4274,7 @@ class PrivateLinkAttachmentAzure(dict):
     @pulumi.getter(name="privateLinkServiceResourceId")
     def private_link_service_resource_id(self) -> Optional[_builtins.str]:
         """
-        (Required String) Azure Private Link service resource id for the availability zone.
+        (Required String) Azure Private Link service resource ID for the availability zone.
         """
         return pulumi.get(self, "private_link_service_resource_id")
 
@@ -4314,7 +4460,7 @@ class PrivateLinkAttachmentGcp(dict):
     def __init__(__self__, *,
                  private_service_connect_service_attachment: Optional[_builtins.str] = None):
         """
-        :param _builtins.str private_service_connect_service_attachment: Id of a Private Service Connect Service Attachment in Confluent Cloud.
+        :param _builtins.str private_service_connect_service_attachment: (Required String) The ID of the GCP Private Service Connect Service Attachment on Confluent Cloud.
         """
         if private_service_connect_service_attachment is not None:
             pulumi.set(__self__, "private_service_connect_service_attachment", private_service_connect_service_attachment)
@@ -4323,11 +4469,131 @@ class PrivateLinkAttachmentGcp(dict):
     @pulumi.getter(name="privateServiceConnectServiceAttachment")
     def private_service_connect_service_attachment(self) -> Optional[_builtins.str]:
         """
-        Id of a Private Service Connect Service Attachment in Confluent Cloud.
+        (Required String) The ID of the GCP Private Service Connect Service Attachment on Confluent Cloud.
         """
         return pulumi.get(self, "private_service_connect_service_attachment")
 
 
+@pulumi.output_type
+class ProviderIntegrationAuthorizationAzure(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "customerAzureTenantId":
+            suggest = "customer_azure_tenant_id"
+        elif key == "confluentMultiTenantAppId":
+            suggest = "confluent_multi_tenant_app_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ProviderIntegrationAuthorizationAzure. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ProviderIntegrationAuthorizationAzure.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ProviderIntegrationAuthorizationAzure.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 customer_azure_tenant_id: _builtins.str,
+                 confluent_multi_tenant_app_id: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str customer_azure_tenant_id: Customer's Azure Tenant ID.
+        :param _builtins.str confluent_multi_tenant_app_id: (Computed String) Confluent Multi-Tenant App ID used to access customer Azure resources.
+        """
+        pulumi.set(__self__, "customer_azure_tenant_id", customer_azure_tenant_id)
+        if confluent_multi_tenant_app_id is not None:
+            pulumi.set(__self__, "confluent_multi_tenant_app_id", confluent_multi_tenant_app_id)
+
+    @_builtins.property
+    @pulumi.getter(name="customerAzureTenantId")
+    def customer_azure_tenant_id(self) -> _builtins.str:
+        """
+        Customer's Azure Tenant ID.
+        """
+        return pulumi.get(self, "customer_azure_tenant_id")
+
+    @_builtins.property
+    @pulumi.getter(name="confluentMultiTenantAppId")
+    def confluent_multi_tenant_app_id(self) -> Optional[_builtins.str]:
+        """
+        (Computed String) Confluent Multi-Tenant App ID used to access customer Azure resources.
+        """
+        return pulumi.get(self, "confluent_multi_tenant_app_id")
+
+
+@pulumi.output_type
+class ProviderIntegrationAuthorizationEnvironment(dict):
+    def __init__(__self__, *,
+                 id: _builtins.str):
+        """
+        :param _builtins.str id: The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
+        """
+        pulumi.set(__self__, "id", id)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
+        """
+        return pulumi.get(self, "id")
+
+
+@pulumi.output_type
+class ProviderIntegrationAuthorizationGcp(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "customerGoogleServiceAccount":
+            suggest = "customer_google_service_account"
+        elif key == "googleServiceAccount":
+            suggest = "google_service_account"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ProviderIntegrationAuthorizationGcp. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ProviderIntegrationAuthorizationGcp.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ProviderIntegrationAuthorizationGcp.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 customer_google_service_account: _builtins.str,
+                 google_service_account: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str customer_google_service_account: Customer's Google Service Account that Confluent Cloud impersonates.
+               
+               > **Note:** Exactly one of `azure` or `gcp` configuration blocks must be provided, matching the cloud provider of the associated provider integration.
+        :param _builtins.str google_service_account: (Computed String) Google Service Account that Confluent Cloud uses for impersonation.
+        """
+        pulumi.set(__self__, "customer_google_service_account", customer_google_service_account)
+        if google_service_account is not None:
+            pulumi.set(__self__, "google_service_account", google_service_account)
+
+    @_builtins.property
+    @pulumi.getter(name="customerGoogleServiceAccount")
+    def customer_google_service_account(self) -> _builtins.str:
+        """
+        Customer's Google Service Account that Confluent Cloud impersonates.
+
+        > **Note:** Exactly one of `azure` or `gcp` configuration blocks must be provided, matching the cloud provider of the associated provider integration.
+        """
+        return pulumi.get(self, "customer_google_service_account")
+
+    @_builtins.property
+    @pulumi.getter(name="googleServiceAccount")
+    def google_service_account(self) -> Optional[_builtins.str]:
+        """
+        (Computed String) Google Service Account that Confluent Cloud uses for impersonation.
+        """
+        return pulumi.get(self, "google_service_account")
+
+
 @pulumi.output_type
 class ProviderIntegrationAws(dict):
     @staticmethod
@@ -4417,6 +4683,24 @@ class ProviderIntegrationEnvironment(dict):
         return pulumi.get(self, "id")
 
 
+@pulumi.output_type
+class ProviderIntegrationSetupEnvironment(dict):
+    def __init__(__self__, *,
+                 id: _builtins.str):
+        """
+        :param _builtins.str id: The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
+        """
+        pulumi.set(__self__, "id", id)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
+        """
+        return pulumi.get(self, "id")
+
+
 @pulumi.output_type
 class SchemaCredentials(dict):
     def __init__(__self__, *,
@@ -5260,6 +5544,81 @@ class SubjectModeSchemaRegistryCluster(dict):
         return pulumi.get(self, "id")
 
 
+@pulumi.output_type
+class TableflowTopicAzureDataLakeStorageGen2(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "containerName":
+            suggest = "container_name"
+        elif key == "providerIntegrationId":
+            suggest = "provider_integration_id"
+        elif key == "storageAccountName":
+            suggest = "storage_account_name"
+        elif key == "storageRegion":
+            suggest = "storage_region"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in TableflowTopicAzureDataLakeStorageGen2. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        TableflowTopicAzureDataLakeStorageGen2.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        TableflowTopicAzureDataLakeStorageGen2.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 container_name: _builtins.str,
+                 provider_integration_id: _builtins.str,
+                 storage_account_name: _builtins.str,
+                 storage_region: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str container_name: The container name.
+        :param _builtins.str provider_integration_id: The provider integration id.
+        :param _builtins.str storage_account_name: The storage account name.
+        :param _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) -> _builtins.str:
+        """
+        The container name.
+        """
+        return pulumi.get(self, "container_name")
+
+    @_builtins.property
+    @pulumi.getter(name="providerIntegrationId")
+    def provider_integration_id(self) -> _builtins.str:
+        """
+        The provider integration id.
+        """
+        return pulumi.get(self, "provider_integration_id")
+
+    @_builtins.property
+    @pulumi.getter(name="storageAccountName")
+    def storage_account_name(self) -> _builtins.str:
+        """
+        The storage account name.
+        """
+        return pulumi.get(self, "storage_account_name")
+
+    @_builtins.property
+    @pulumi.getter(name="storageRegion")
+    def storage_region(self) -> Optional[_builtins.str]:
+        """
+        (Required String) The storage region.
+        """
+        return pulumi.get(self, "storage_region")
+
+
 @pulumi.output_type
 class TableflowTopicByobAws(dict):
     @staticmethod
@@ -5369,6 +5728,54 @@ class TableflowTopicEnvironment(dict):
         return pulumi.get(self, "id")
 
 
+@pulumi.output_type
+class TableflowTopicErrorHandling(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "logTarget":
+            suggest = "log_target"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in TableflowTopicErrorHandling. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        TableflowTopicErrorHandling.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        TableflowTopicErrorHandling.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 log_target: Optional[_builtins.str] = None,
+                 mode: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str log_target: The topic to which the bad records will be logged for error handling mode `LOG`. Creates the topic if it doesn't already exist. The default topic is "error_log" if error handling mode is `LOG`, and empty otherwise.
+        :param _builtins.str mode: The error handling mode. For `SUSPEND`, the materialization of the topic is suspended in case of record failures. For `SKIP`, bad records are skipped and the materialization continues with the next record. For `LOG`, bad records are logged to a dead-letter queue (DLQ) topic and the materialization continues with the next record. The default mode is `SUSPEND`.
+        """
+        if log_target is not None:
+            pulumi.set(__self__, "log_target", log_target)
+        if mode is not None:
+            pulumi.set(__self__, "mode", mode)
+
+    @_builtins.property
+    @pulumi.getter(name="logTarget")
+    def log_target(self) -> Optional[_builtins.str]:
+        """
+        The topic to which the bad records will be logged for error handling mode `LOG`. Creates the topic if it doesn't already exist. The default topic is "error_log" if error handling mode is `LOG`, and empty otherwise.
+        """
+        return pulumi.get(self, "log_target")
+
+    @_builtins.property
+    @pulumi.getter
+    def mode(self) -> Optional[_builtins.str]:
+        """
+        The error handling mode. For `SUSPEND`, the materialization of the topic is suspended in case of record failures. For `SKIP`, bad records are skipped and the materialization continues with the next record. For `LOG`, bad records are logged to a dead-letter queue (DLQ) topic and the materialization continues with the next record. The default mode is `SUSPEND`.
+        """
+        return pulumi.get(self, "mode")
+
+
 @pulumi.output_type
 class TableflowTopicKafkaCluster(dict):
     def __init__(__self__, *,
@@ -7047,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
@@ -7168,14 +7587,26 @@ class GetKafkaClusterEndpointResult(dict):
 
 @pulumi.output_type
 class GetKafkaClusterEnterpriseResult(dict):
-    def __init__(__self__):
-        pass
-
-
-@pulumi.output_type
-class GetKafkaClusterEnvironmentResult(dict):
     def __init__(__self__, *,
-                 id: _builtins.str):
+                 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
+class GetKafkaClusterEnvironmentResult(dict):
+    def __init__(__self__, *,
+                 id: _builtins.str):
         """
         :param _builtins.str id: The ID of the Environment that the Kafka cluster belongs to, for example, `env-xyz456`.
                
@@ -7197,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]:
@@ -7238,8 +7680,499 @@ 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
+class GetKafkaClustersClusterResult(dict):
+    def __init__(__self__, *,
+                 api_version: _builtins.str,
+                 availability: _builtins.str,
+                 bootstrap_endpoint: _builtins.str,
+                 byok_keys: Sequence['outputs.GetKafkaClustersClusterByokKeyResult'],
+                 cloud: _builtins.str,
+                 display_name: _builtins.str,
+                 endpoints: Sequence['outputs.GetKafkaClustersClusterEndpointResult'],
+                 environment: 'outputs.GetKafkaClustersClusterEnvironmentResult',
+                 id: _builtins.str,
+                 kind: _builtins.str,
+                 networks: Sequence['outputs.GetKafkaClustersClusterNetworkResult'],
+                 rbac_crn: _builtins.str,
+                 region: _builtins.str,
+                 rest_endpoint: _builtins.str,
+                 basics: Optional[Sequence['outputs.GetKafkaClustersClusterBasicResult']] = None,
+                 dedicated: Optional['outputs.GetKafkaClustersClusterDedicatedResult'] = None,
+                 enterprises: Optional[Sequence['outputs.GetKafkaClustersClusterEnterpriseResult']] = None,
+                 freights: Optional[Sequence['outputs.GetKafkaClustersClusterFreightResult']] = None,
+                 standards: Optional[Sequence['outputs.GetKafkaClustersClusterStandardResult']] = None):
+        """
+        :param _builtins.str api_version: (Required String) An API Version of the schema version of the Kafka cluster, for example, `cmk/v2`.
+        :param _builtins.str availability: (Required String) The availability zone configuration of the Kafka cluster. Accepted values are: `SINGLE_ZONE`, `MULTI_ZONE`, `LOW`, and `HIGH`.
+        :param _builtins.str bootstrap_endpoint: (Required String) The bootstrap endpoint used by Kafka clients to connect to the cluster (for example, `lkc-abc123-apfoo123.eu-west-3.aws.accesspoint.glb.confluent.cloud:9092`).
+        :param Sequence['GetKafkaClustersClusterByokKeyArgs'] byok_keys: (Optional Configuration Block) supports the following:
+        :param _builtins.str cloud: (Required String) The cloud service provider that runs the Kafka cluster. Accepted values are: `AWS`, `AZURE`, and `GCP`.
+        :param _builtins.str display_name: (Required String) The name of the Kafka cluster.
+        :param Sequence['GetKafkaClustersClusterEndpointArgs'] endpoints: (Optional List) The list of endpoints for connecting to the Kafka cluster. These endpoints provide different network access methods or regions for connecting to the cluster:
+        :param 'GetKafkaClustersClusterEnvironmentArgs' environment: (Required Object) exports the following attributes:
+        :param _builtins.str id: (Required String) The ID of the Confluent key that is used to encrypt the data in the Kafka cluster, for example, `cck-lye5m`.
+        :param _builtins.str kind: (Required String) A kind of the Kafka cluster, for example, `Cluster`.
+        :param Sequence['GetKafkaClustersClusterNetworkArgs'] networks: (Optional Configuration Block) supports the following:
+        :param _builtins.str rbac_crn: (Required String) The Confluent Resource Name of the Kafka cluster, for example, `crn://confluent.cloud/organization=1111aaaa-11aa-11aa-11aa-111111aaaaaa/environment=env-abc123/cloud-cluster=lkc-abc123`.
+        :param _builtins.str region: (Required String) The cloud service provider region where the Kafka cluster is running, for example, `us-west-2`. See [Cloud Providers and Regions](https://docs.confluent.io/cloud/current/clusters/regions.html#cloud-providers-and-regions) for a full list of options for AWS, Azure, and GCP.
+        :param _builtins.str rest_endpoint: (Required String) The REST endpoint of the Kafka cluster (for example, `https://lkc-abc123-apfoo123.eu-west-3.aws.accesspoint.glb.confluent.cloud:443`).
+        :param Sequence['GetKafkaClustersClusterBasicArgs'] basics: (Optional Configuration Block) The configuration of the Basic Kafka cluster.
+        :param 'GetKafkaClustersClusterDedicatedArgs' dedicated: (Optional Configuration Block) The configuration of the Dedicated Kafka cluster. It supports the following:
+        :param Sequence['GetKafkaClustersClusterEnterpriseArgs'] enterprises: (Optional Configuration Block) The configuration of the Enterprise Kafka cluster.
+        :param Sequence['GetKafkaClustersClusterFreightArgs'] freights: (Optional Configuration Block) The configuration of the Freight Kafka cluster.
+        :param Sequence['GetKafkaClustersClusterStandardArgs'] standards: (Optional Configuration Block) The configuration of the Standard Kafka cluster.
+        """
+        pulumi.set(__self__, "api_version", api_version)
+        pulumi.set(__self__, "availability", availability)
+        pulumi.set(__self__, "bootstrap_endpoint", bootstrap_endpoint)
+        pulumi.set(__self__, "byok_keys", byok_keys)
+        pulumi.set(__self__, "cloud", cloud)
+        pulumi.set(__self__, "display_name", display_name)
+        pulumi.set(__self__, "endpoints", endpoints)
+        pulumi.set(__self__, "environment", environment)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "kind", kind)
+        pulumi.set(__self__, "networks", networks)
+        pulumi.set(__self__, "rbac_crn", rbac_crn)
+        pulumi.set(__self__, "region", region)
+        pulumi.set(__self__, "rest_endpoint", rest_endpoint)
+        if basics is not None:
+            pulumi.set(__self__, "basics", basics)
+        if dedicated is not None:
+            pulumi.set(__self__, "dedicated", dedicated)
+        if enterprises is not None:
+            pulumi.set(__self__, "enterprises", enterprises)
+        if freights is not None:
+            pulumi.set(__self__, "freights", freights)
+        if standards is not None:
+            pulumi.set(__self__, "standards", standards)
+
+    @_builtins.property
+    @pulumi.getter(name="apiVersion")
+    def api_version(self) -> _builtins.str:
+        """
+        (Required String) An API Version of the schema version of the Kafka cluster, for example, `cmk/v2`.
+        """
+        return pulumi.get(self, "api_version")
+
+    @_builtins.property
+    @pulumi.getter
+    def availability(self) -> _builtins.str:
+        """
+        (Required String) The availability zone configuration of the Kafka cluster. Accepted values are: `SINGLE_ZONE`, `MULTI_ZONE`, `LOW`, and `HIGH`.
+        """
+        return pulumi.get(self, "availability")
+
+    @_builtins.property
+    @pulumi.getter(name="bootstrapEndpoint")
+    def bootstrap_endpoint(self) -> _builtins.str:
+        """
+        (Required String) The bootstrap endpoint used by Kafka clients to connect to the cluster (for example, `lkc-abc123-apfoo123.eu-west-3.aws.accesspoint.glb.confluent.cloud:9092`).
+        """
+        return pulumi.get(self, "bootstrap_endpoint")
+
+    @_builtins.property
+    @pulumi.getter(name="byokKeys")
+    def byok_keys(self) -> Sequence['outputs.GetKafkaClustersClusterByokKeyResult']:
+        """
+        (Optional Configuration Block) supports the following:
+        """
+        return pulumi.get(self, "byok_keys")
+
+    @_builtins.property
+    @pulumi.getter
+    def cloud(self) -> _builtins.str:
+        """
+        (Required String) The cloud service provider that runs the Kafka cluster. Accepted values are: `AWS`, `AZURE`, and `GCP`.
+        """
+        return pulumi.get(self, "cloud")
+
+    @_builtins.property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> _builtins.str:
+        """
+        (Required String) The name of the Kafka cluster.
+        """
+        return pulumi.get(self, "display_name")
+
+    @_builtins.property
+    @pulumi.getter
+    def endpoints(self) -> Sequence['outputs.GetKafkaClustersClusterEndpointResult']:
+        """
+        (Optional List) The list of endpoints for connecting to the Kafka cluster. These endpoints provide different network access methods or regions for connecting to the cluster:
+        """
+        return pulumi.get(self, "endpoints")
+
+    @_builtins.property
+    @pulumi.getter
+    def environment(self) -> 'outputs.GetKafkaClustersClusterEnvironmentResult':
+        """
+        (Required Object) exports the following attributes:
+        """
+        return pulumi.get(self, "environment")
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        (Required String) The ID of the Confluent key that is used to encrypt the data in the Kafka cluster, for example, `cck-lye5m`.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter
+    def kind(self) -> _builtins.str:
+        """
+        (Required String) A kind of the Kafka cluster, for example, `Cluster`.
+        """
+        return pulumi.get(self, "kind")
+
+    @_builtins.property
+    @pulumi.getter
+    def networks(self) -> Sequence['outputs.GetKafkaClustersClusterNetworkResult']:
+        """
+        (Optional Configuration Block) supports the following:
+        """
+        return pulumi.get(self, "networks")
+
+    @_builtins.property
+    @pulumi.getter(name="rbacCrn")
+    def rbac_crn(self) -> _builtins.str:
+        """
+        (Required String) The Confluent Resource Name of the Kafka cluster, for example, `crn://confluent.cloud/organization=1111aaaa-11aa-11aa-11aa-111111aaaaaa/environment=env-abc123/cloud-cluster=lkc-abc123`.
+        """
+        return pulumi.get(self, "rbac_crn")
+
+    @_builtins.property
+    @pulumi.getter
+    def region(self) -> _builtins.str:
+        """
+        (Required String) The cloud service provider region where the Kafka cluster is running, for example, `us-west-2`. See [Cloud Providers and Regions](https://docs.confluent.io/cloud/current/clusters/regions.html#cloud-providers-and-regions) for a full list of options for AWS, Azure, and GCP.
+        """
+        return pulumi.get(self, "region")
+
+    @_builtins.property
+    @pulumi.getter(name="restEndpoint")
+    def rest_endpoint(self) -> _builtins.str:
+        """
+        (Required String) The REST endpoint of the Kafka cluster (for example, `https://lkc-abc123-apfoo123.eu-west-3.aws.accesspoint.glb.confluent.cloud:443`).
+        """
+        return pulumi.get(self, "rest_endpoint")
+
+    @_builtins.property
+    @pulumi.getter
+    def basics(self) -> Optional[Sequence['outputs.GetKafkaClustersClusterBasicResult']]:
+        """
+        (Optional Configuration Block) The configuration of the Basic Kafka cluster.
+        """
+        return pulumi.get(self, "basics")
+
+    @_builtins.property
+    @pulumi.getter
+    def dedicated(self) -> Optional['outputs.GetKafkaClustersClusterDedicatedResult']:
+        """
+        (Optional Configuration Block) The configuration of the Dedicated Kafka cluster. It supports the following:
+        """
+        return pulumi.get(self, "dedicated")
+
+    @_builtins.property
+    @pulumi.getter
+    def enterprises(self) -> Optional[Sequence['outputs.GetKafkaClustersClusterEnterpriseResult']]:
+        """
+        (Optional Configuration Block) The configuration of the Enterprise Kafka cluster.
+        """
+        return pulumi.get(self, "enterprises")
+
+    @_builtins.property
+    @pulumi.getter
+    def freights(self) -> Optional[Sequence['outputs.GetKafkaClustersClusterFreightResult']]:
+        """
+        (Optional Configuration Block) The configuration of the Freight Kafka cluster.
+        """
+        return pulumi.get(self, "freights")
+
+    @_builtins.property
+    @pulumi.getter
+    def standards(self) -> Optional[Sequence['outputs.GetKafkaClustersClusterStandardResult']]:
+        """
+        (Optional Configuration Block) The configuration of the Standard Kafka cluster.
+        """
+        return pulumi.get(self, "standards")
+
+
+@pulumi.output_type
+class GetKafkaClustersClusterBasicResult(dict):
+    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
+class GetKafkaClustersClusterByokKeyResult(dict):
+    def __init__(__self__, *,
+                 id: _builtins.str):
+        """
+        :param _builtins.str id: (Required String) The ID of the Confluent key that is used to encrypt the data in the Kafka cluster, for example, `cck-lye5m`.
+        """
+        pulumi.set(__self__, "id", id)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        (Required String) The ID of the Confluent key that is used to encrypt the data in the Kafka cluster, for example, `cck-lye5m`.
+        """
+        return pulumi.get(self, "id")
+
+
+@pulumi.output_type
+class GetKafkaClustersClusterDedicatedResult(dict):
+    def __init__(__self__, *,
+                 cku: _builtins.int,
+                 encryption_key: _builtins.str,
+                 zones: Sequence[_builtins.str]):
+        """
+        :param _builtins.int cku: (Required Number) The number of Confluent Kafka Units (CKUs) for Dedicated cluster types. The minimum number of CKUs for `SINGLE_ZONE` dedicated clusters is `1` whereas `MULTI_ZONE` dedicated clusters must have `2` CKUs or more.
+        :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`.
+               - 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__, "cku", cku)
+        pulumi.set(__self__, "encryption_key", encryption_key)
+        pulumi.set(__self__, "zones", zones)
+
+    @_builtins.property
+    @pulumi.getter
+    def cku(self) -> _builtins.int:
+        """
+        (Required Number) The number of Confluent Kafka Units (CKUs) for Dedicated cluster types. The minimum number of CKUs for `SINGLE_ZONE` dedicated clusters is `1` whereas `MULTI_ZONE` dedicated clusters must have `2` CKUs or more.
+        """
+        return pulumi.get(self, "cku")
+
+    @_builtins.property
+    @pulumi.getter(name="encryptionKey")
+    def encryption_key(self) -> _builtins.str:
+        """
+        The ID of the encryption key that is used to encrypt the data in the Kafka cluster.
+        """
+        return pulumi.get(self, "encryption_key")
+
+    @_builtins.property
+    @pulumi.getter
+    def zones(self) -> Sequence[_builtins.str]:
+        """
+        (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.
+        """
+        return pulumi.get(self, "zones")
+
+
+@pulumi.output_type
+class GetKafkaClustersClusterEndpointResult(dict):
+    def __init__(__self__, *,
+                 access_point_id: _builtins.str,
+                 bootstrap_endpoint: _builtins.str,
+                 connection_type: _builtins.str,
+                 rest_endpoint: _builtins.str):
+        """
+        :param _builtins.str access_point_id: (Required String) The ID of the Access Point that the endpoint corresponds to. Access Point IDs `PUBLIC` and `PRIVATE_LINK` are reserved.
+        :param _builtins.str bootstrap_endpoint: (Required String) The bootstrap endpoint used by Kafka clients to connect to the cluster (for example, `lkc-abc123-apfoo123.eu-west-3.aws.accesspoint.glb.confluent.cloud:9092`).
+        :param _builtins.str connection_type: (Required String) The type of connection used for the endpoint (for example, `PRIVATE_NETWORK_INTERFACE`).
+        :param _builtins.str rest_endpoint: (Required String) The REST endpoint of the Kafka cluster (for example, `https://lkc-abc123-apfoo123.eu-west-3.aws.accesspoint.glb.confluent.cloud:443`).
+        """
+        pulumi.set(__self__, "access_point_id", access_point_id)
+        pulumi.set(__self__, "bootstrap_endpoint", bootstrap_endpoint)
+        pulumi.set(__self__, "connection_type", connection_type)
+        pulumi.set(__self__, "rest_endpoint", rest_endpoint)
+
+    @_builtins.property
+    @pulumi.getter(name="accessPointId")
+    def access_point_id(self) -> _builtins.str:
+        """
+        (Required String) The ID of the Access Point that the endpoint corresponds to. Access Point IDs `PUBLIC` and `PRIVATE_LINK` are reserved.
+        """
+        return pulumi.get(self, "access_point_id")
+
+    @_builtins.property
+    @pulumi.getter(name="bootstrapEndpoint")
+    def bootstrap_endpoint(self) -> _builtins.str:
+        """
+        (Required String) The bootstrap endpoint used by Kafka clients to connect to the cluster (for example, `lkc-abc123-apfoo123.eu-west-3.aws.accesspoint.glb.confluent.cloud:9092`).
+        """
+        return pulumi.get(self, "bootstrap_endpoint")
+
+    @_builtins.property
+    @pulumi.getter(name="connectionType")
+    def connection_type(self) -> _builtins.str:
+        """
+        (Required String) The type of connection used for the endpoint (for example, `PRIVATE_NETWORK_INTERFACE`).
+        """
+        return pulumi.get(self, "connection_type")
+
+    @_builtins.property
+    @pulumi.getter(name="restEndpoint")
+    def rest_endpoint(self) -> _builtins.str:
+        """
+        (Required String) The REST endpoint of the Kafka cluster (for example, `https://lkc-abc123-apfoo123.eu-west-3.aws.accesspoint.glb.confluent.cloud:443`).
+        """
+        return pulumi.get(self, "rest_endpoint")
+
+
+@pulumi.output_type
+class GetKafkaClustersClusterEnterpriseResult(dict):
+    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
+class GetKafkaClustersClusterEnvironmentResult(dict):
+    def __init__(__self__, *,
+                 id: _builtins.str):
+        """
+        :param _builtins.str id: The ID of the Environment that the Kafka clusters belongs to, for example, `env-xyz456`.
+        """
+        pulumi.set(__self__, "id", id)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The ID of the Environment that the Kafka clusters belongs to, for example, `env-xyz456`.
+        """
+        return pulumi.get(self, "id")
+
+
+@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]:
+        """
+        (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.
+        """
+        return pulumi.get(self, "zones")
+
+
+@pulumi.output_type
+class GetKafkaClustersClusterNetworkResult(dict):
+    def __init__(__self__, *,
+                 id: _builtins.str):
+        """
+        :param _builtins.str id: (Required String) The ID of the Confluent key that is used to encrypt the data in the Kafka cluster, for example, `cck-lye5m`.
+        """
+        pulumi.set(__self__, "id", id)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        (Required String) The ID of the Confluent key that is used to encrypt the data in the Kafka cluster, for example, `cck-lye5m`.
+        """
+        return pulumi.get(self, "id")
+
+
+@pulumi.output_type
+class GetKafkaClustersClusterStandardResult(dict):
+    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
+class GetKafkaClustersEnvironmentResult(dict):
+    def __init__(__self__, *,
+                 id: _builtins.str):
+        """
+        :param _builtins.str id: The ID of the Environment that the Kafka clusters belongs to, for example, `env-xyz456`.
+        """
+        pulumi.set(__self__, "id", id)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The ID of the Environment that the Kafka clusters belongs to, for example, `env-xyz456`.
+        """
+        return pulumi.get(self, "id")
 
 
 @pulumi.output_type
@@ -7948,8 +8881,8 @@ class GetPrivateLinkAttachmentAzureResult(dict):
                  private_link_service_alias: _builtins.str,
                  private_link_service_resource_id: _builtins.str):
         """
-        :param _builtins.str private_link_service_alias: Azure PrivateLink service alias for the availability zone.
-        :param _builtins.str private_link_service_resource_id: (Required String) Azure Private Link service resource id for the availability zone.
+        :param _builtins.str private_link_service_alias: (Required String) Azure Private Link service alias for the availability zone.
+        :param _builtins.str private_link_service_resource_id: (Required String) Azure Private Link service resource ID for the availability zone.
         """
         pulumi.set(__self__, "private_link_service_alias", private_link_service_alias)
         pulumi.set(__self__, "private_link_service_resource_id", private_link_service_resource_id)
@@ -7958,7 +8891,7 @@ class GetPrivateLinkAttachmentAzureResult(dict):
     @pulumi.getter(name="privateLinkServiceAlias")
     def private_link_service_alias(self) -> _builtins.str:
         """
-        Azure PrivateLink service alias for the availability zone.
+        (Required String) Azure Private Link service alias for the availability zone.
         """
         return pulumi.get(self, "private_link_service_alias")
 
@@ -7966,7 +8899,7 @@ class GetPrivateLinkAttachmentAzureResult(dict):
     @pulumi.getter(name="privateLinkServiceResourceId")
     def private_link_service_resource_id(self) -> _builtins.str:
         """
-        (Required String) Azure Private Link service resource id for the availability zone.
+        (Required String) Azure Private Link service resource ID for the availability zone.
         """
         return pulumi.get(self, "private_link_service_resource_id")
 
@@ -8084,7 +9017,7 @@ class GetPrivateLinkAttachmentGcpResult(dict):
     def __init__(__self__, *,
                  private_service_connect_service_attachment: _builtins.str):
         """
-        :param _builtins.str private_service_connect_service_attachment: Id of a Private Service Connect Service Attachment in Confluent Cloud.
+        :param _builtins.str private_service_connect_service_attachment: (Required String) The ID of the GCP Private Service Connect Service Attachment on Confluent Cloud.
         """
         pulumi.set(__self__, "private_service_connect_service_attachment", private_service_connect_service_attachment)
 
@@ -8092,11 +9025,87 @@ class GetPrivateLinkAttachmentGcpResult(dict):
     @pulumi.getter(name="privateServiceConnectServiceAttachment")
     def private_service_connect_service_attachment(self) -> _builtins.str:
         """
-        Id of a Private Service Connect Service Attachment in Confluent Cloud.
+        (Required String) The ID of the GCP Private Service Connect Service Attachment on Confluent Cloud.
         """
         return pulumi.get(self, "private_service_connect_service_attachment")
 
 
+@pulumi.output_type
+class GetProviderIntegrationAuthorizationAzureResult(dict):
+    def __init__(__self__, *,
+                 confluent_multi_tenant_app_id: _builtins.str,
+                 customer_azure_tenant_id: _builtins.str):
+        """
+        :param _builtins.str confluent_multi_tenant_app_id: (Computed String) Confluent Multi-Tenant App ID used to access customer Azure resources.
+        :param _builtins.str customer_azure_tenant_id: (Computed String) Customer's Azure Tenant ID.
+        """
+        pulumi.set(__self__, "confluent_multi_tenant_app_id", confluent_multi_tenant_app_id)
+        pulumi.set(__self__, "customer_azure_tenant_id", customer_azure_tenant_id)
+
+    @_builtins.property
+    @pulumi.getter(name="confluentMultiTenantAppId")
+    def confluent_multi_tenant_app_id(self) -> _builtins.str:
+        """
+        (Computed String) Confluent Multi-Tenant App ID used to access customer Azure resources.
+        """
+        return pulumi.get(self, "confluent_multi_tenant_app_id")
+
+    @_builtins.property
+    @pulumi.getter(name="customerAzureTenantId")
+    def customer_azure_tenant_id(self) -> _builtins.str:
+        """
+        (Computed String) Customer's Azure Tenant ID.
+        """
+        return pulumi.get(self, "customer_azure_tenant_id")
+
+
+@pulumi.output_type
+class GetProviderIntegrationAuthorizationEnvironmentResult(dict):
+    def __init__(__self__, *,
+                 id: _builtins.str):
+        """
+        :param _builtins.str id: The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
+        """
+        pulumi.set(__self__, "id", id)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
+        """
+        return pulumi.get(self, "id")
+
+
+@pulumi.output_type
+class GetProviderIntegrationAuthorizationGcpResult(dict):
+    def __init__(__self__, *,
+                 customer_google_service_account: _builtins.str,
+                 google_service_account: _builtins.str):
+        """
+        :param _builtins.str customer_google_service_account: (Computed String) Customer's Google Service Account that Confluent Cloud impersonates.
+        :param _builtins.str google_service_account: (Computed String) Google Service Account that Confluent Cloud uses for impersonation.
+        """
+        pulumi.set(__self__, "customer_google_service_account", customer_google_service_account)
+        pulumi.set(__self__, "google_service_account", google_service_account)
+
+    @_builtins.property
+    @pulumi.getter(name="customerGoogleServiceAccount")
+    def customer_google_service_account(self) -> _builtins.str:
+        """
+        (Computed String) Customer's Google Service Account that Confluent Cloud impersonates.
+        """
+        return pulumi.get(self, "customer_google_service_account")
+
+    @_builtins.property
+    @pulumi.getter(name="googleServiceAccount")
+    def google_service_account(self) -> _builtins.str:
+        """
+        (Computed String) Google Service Account that Confluent Cloud uses for impersonation.
+        """
+        return pulumi.get(self, "google_service_account")
+
+
 @pulumi.output_type
 class GetProviderIntegrationAwResult(dict):
     def __init__(__self__, *,
@@ -8159,6 +9168,24 @@ class GetProviderIntegrationEnvironmentResult(dict):
         return pulumi.get(self, "id")
 
 
+@pulumi.output_type
+class GetProviderIntegrationSetupEnvironmentResult(dict):
+    def __init__(__self__, *,
+                 id: _builtins.str):
+        """
+        :param _builtins.str id: The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
+        """
+        pulumi.set(__self__, "id", id)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
+        """
+        return pulumi.get(self, "id")
+
+
 @pulumi.output_type
 class GetSchemaCredentialsResult(dict):
     def __init__(__self__, *,
@@ -9310,6 +10337,68 @@ class GetSubjectModeSchemaRegistryClusterResult(dict):
         return pulumi.get(self, "id")
 
 
+@pulumi.output_type
+class GetTableflowTopicAzureDataLakeStorageGen2Result(dict):
+    def __init__(__self__, *,
+                 container_name: _builtins.str,
+                 provider_integration_id: _builtins.str,
+                 storage_account_name: _builtins.str,
+                 storage_region: _builtins.str,
+                 table_path: _builtins.str):
+        """
+        :param _builtins.str container_name: (Required String) The container name.
+        :param _builtins.str provider_integration_id: (Required String) The provider integration id.
+        :param _builtins.str storage_account_name: (Required String) The storage account name.
+        :param _builtins.str storage_region: (Required String) The storage region.
+        :param _builtins.str table_path: (Optional String) The current storage path where the data and metadata is stored for this table.
+        """
+        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)
+        pulumi.set(__self__, "storage_region", storage_region)
+        pulumi.set(__self__, "table_path", table_path)
+
+    @_builtins.property
+    @pulumi.getter(name="containerName")
+    def container_name(self) -> _builtins.str:
+        """
+        (Required String) The container name.
+        """
+        return pulumi.get(self, "container_name")
+
+    @_builtins.property
+    @pulumi.getter(name="providerIntegrationId")
+    def provider_integration_id(self) -> _builtins.str:
+        """
+        (Required String) The provider integration id.
+        """
+        return pulumi.get(self, "provider_integration_id")
+
+    @_builtins.property
+    @pulumi.getter(name="storageAccountName")
+    def storage_account_name(self) -> _builtins.str:
+        """
+        (Required String) The storage account name.
+        """
+        return pulumi.get(self, "storage_account_name")
+
+    @_builtins.property
+    @pulumi.getter(name="storageRegion")
+    def storage_region(self) -> _builtins.str:
+        """
+        (Required String) The storage region.
+        """
+        return pulumi.get(self, "storage_region")
+
+    @_builtins.property
+    @pulumi.getter(name="tablePath")
+    def table_path(self) -> _builtins.str:
+        """
+        (Optional String) The current storage path where the data and metadata is stored for this table.
+        """
+        return pulumi.get(self, "table_path")
+
+
 @pulumi.output_type
 class GetTableflowTopicByobAwResult(dict):
     def __init__(__self__, *,
@@ -9397,6 +10486,35 @@ class GetTableflowTopicEnvironmentResult(dict):
         return pulumi.get(self, "id")
 
 
+@pulumi.output_type
+class GetTableflowTopicErrorHandlingResult(dict):
+    def __init__(__self__, *,
+                 log_target: _builtins.str,
+                 mode: _builtins.str):
+        """
+        :param _builtins.str log_target: (Optional String) The topic to which the bad records will be logged for error handling mode `LOG`. The default topic is "error_log" if error handling mode is `LOG`, and empty otherwise.
+        :param _builtins.str mode: (Optional String) The error handling mode. For `SUSPEND`, the materialization of the topic is suspended in case of record failures. For `SKIP`, bad records are skipped and the materialization continues with the next record. For `LOG`, bad records are logged to a dead-letter queue (DLQ) topic and the materialization continues with the next record. The default mode is `SUSPEND`.
+        """
+        pulumi.set(__self__, "log_target", log_target)
+        pulumi.set(__self__, "mode", mode)
+
+    @_builtins.property
+    @pulumi.getter(name="logTarget")
+    def log_target(self) -> _builtins.str:
+        """
+        (Optional String) The topic to which the bad records will be logged for error handling mode `LOG`. The default topic is "error_log" if error handling mode is `LOG`, and empty otherwise.
+        """
+        return pulumi.get(self, "log_target")
+
+    @_builtins.property
+    @pulumi.getter
+    def mode(self) -> _builtins.str:
+        """
+        (Optional String) The error handling mode. For `SUSPEND`, the materialization of the topic is suspended in case of record failures. For `SKIP`, bad records are skipped and the materialization continues with the next record. For `LOG`, bad records are logged to a dead-letter queue (DLQ) topic and the materialization continues with the next record. The default mode is `SUSPEND`.
+        """
+        return pulumi.get(self, "mode")
+
+
 @pulumi.output_type
 class GetTableflowTopicKafkaClusterResult(dict):
     def __init__(__self__, *,