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

pulumi_confluentcloud/_inputs.py

@@ -265,10 +265,18 @@ __all__ = [
     'PrivateLinkAttachmentEnvironmentArgsDict',
     'PrivateLinkAttachmentGcpArgs',
     'PrivateLinkAttachmentGcpArgsDict',
+    'ProviderIntegrationAuthorizationAzureArgs',
+    'ProviderIntegrationAuthorizationAzureArgsDict',
+    'ProviderIntegrationAuthorizationEnvironmentArgs',
+    'ProviderIntegrationAuthorizationEnvironmentArgsDict',
+    'ProviderIntegrationAuthorizationGcpArgs',
+    'ProviderIntegrationAuthorizationGcpArgsDict',
     'ProviderIntegrationAwsArgs',
     'ProviderIntegrationAwsArgsDict',
     'ProviderIntegrationEnvironmentArgs',
     'ProviderIntegrationEnvironmentArgsDict',
+    'ProviderIntegrationSetupEnvironmentArgs',
+    'ProviderIntegrationSetupEnvironmentArgsDict',
     'ProviderOauthArgs',
     'ProviderOauthArgsDict',
     'SchemaCredentialsArgs',
@@ -319,12 +327,16 @@ __all__ = [
     'SubjectModeCredentialsArgsDict',
     'SubjectModeSchemaRegistryClusterArgs',
     'SubjectModeSchemaRegistryClusterArgsDict',
+    'TableflowTopicAzureDataLakeStorageGen2Args',
+    'TableflowTopicAzureDataLakeStorageGen2ArgsDict',
     'TableflowTopicByobAwsArgs',
     'TableflowTopicByobAwsArgsDict',
     'TableflowTopicCredentialsArgs',
     'TableflowTopicCredentialsArgsDict',
     'TableflowTopicEnvironmentArgs',
     'TableflowTopicEnvironmentArgsDict',
+    'TableflowTopicErrorHandlingArgs',
+    'TableflowTopicErrorHandlingArgsDict',
     'TableflowTopicKafkaClusterArgs',
     'TableflowTopicKafkaClusterArgsDict',
     'TableflowTopicManagedStorageArgs',
@@ -405,6 +417,8 @@ __all__ = [
     'GetKafkaClusterFreightArgsDict',
     'GetKafkaClusterStandardArgs',
     'GetKafkaClusterStandardArgsDict',
+    'GetKafkaClustersEnvironmentArgs',
+    'GetKafkaClustersEnvironmentArgsDict',
     'GetKafkaTopicCredentialsArgs',
     'GetKafkaTopicCredentialsArgsDict',
     'GetKafkaTopicKafkaClusterArgs',
@@ -435,8 +449,12 @@ __all__ = [
     'GetPrivateLinkAttachmentConnectionEnvironmentArgsDict',
     'GetPrivateLinkAttachmentEnvironmentArgs',
     'GetPrivateLinkAttachmentEnvironmentArgsDict',
+    'GetProviderIntegrationAuthorizationEnvironmentArgs',
+    'GetProviderIntegrationAuthorizationEnvironmentArgsDict',
     'GetProviderIntegrationEnvironmentArgs',
     'GetProviderIntegrationEnvironmentArgsDict',
+    'GetProviderIntegrationSetupEnvironmentArgs',
+    'GetProviderIntegrationSetupEnvironmentArgsDict',
     'GetSchemaCredentialsArgs',
     'GetSchemaCredentialsArgsDict',
     'GetSchemaMetadataArgs',
@@ -3936,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:
@@ -4083,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]]
         """
@@ -4112,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`.
@@ -4135,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")
 
@@ -4262,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:
@@ -4305,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.
@@ -4316,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]]]]:
@@ -4371,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:
@@ -5841,11 +5945,11 @@ if not MYPY:
     class PrivateLinkAttachmentAzureArgsDict(TypedDict):
         private_link_service_alias: NotRequired[pulumi.Input[_builtins.str]]
         """
-        Azure PrivateLink service alias for the availability zone.
+        (Required String) Azure Private Link service alias for the availability zone.
         """
         private_link_service_resource_id: NotRequired[pulumi.Input[_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.
         """
 elif False:
     PrivateLinkAttachmentAzureArgsDict: TypeAlias = Mapping[str, Any]
@@ -5856,8 +5960,8 @@ class PrivateLinkAttachmentAzureArgs:
                  private_link_service_alias: Optional[pulumi.Input[_builtins.str]] = None,
                  private_link_service_resource_id: Optional[pulumi.Input[_builtins.str]] = None):
         """
-        :param pulumi.Input[_builtins.str] private_link_service_alias: Azure PrivateLink service alias for the availability zone.
-        :param pulumi.Input[_builtins.str] private_link_service_resource_id: (Required String) Azure Private Link service resource id for the availability zone.
+        :param pulumi.Input[_builtins.str] private_link_service_alias: (Required String) Azure Private Link service alias for the availability zone.
+        :param pulumi.Input[_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)
@@ -5868,7 +5972,7 @@ class PrivateLinkAttachmentAzureArgs:
     @pulumi.getter(name="privateLinkServiceAlias")
     def private_link_service_alias(self) -> Optional[pulumi.Input[_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")
 
@@ -5880,7 +5984,7 @@ class PrivateLinkAttachmentAzureArgs:
     @pulumi.getter(name="privateLinkServiceResourceId")
     def private_link_service_resource_id(self) -> Optional[pulumi.Input[_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")
 
@@ -6079,7 +6183,7 @@ if not MYPY:
     class PrivateLinkAttachmentGcpArgsDict(TypedDict):
         private_service_connect_service_attachment: NotRequired[pulumi.Input[_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.
         """
 elif False:
     PrivateLinkAttachmentGcpArgsDict: TypeAlias = Mapping[str, Any]
@@ -6089,7 +6193,7 @@ class PrivateLinkAttachmentGcpArgs:
     def __init__(__self__, *,
                  private_service_connect_service_attachment: Optional[pulumi.Input[_builtins.str]] = None):
         """
-        :param pulumi.Input[_builtins.str] private_service_connect_service_attachment: Id of a Private Service Connect Service Attachment in Confluent Cloud.
+        :param pulumi.Input[_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)
@@ -6098,7 +6202,7 @@ class PrivateLinkAttachmentGcpArgs:
     @pulumi.getter(name="privateServiceConnectServiceAttachment")
     def private_service_connect_service_attachment(self) -> Optional[pulumi.Input[_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")
 
@@ -6107,6 +6211,145 @@ class PrivateLinkAttachmentGcpArgs:
         pulumi.set(self, "private_service_connect_service_attachment", value)
 
 
+if not MYPY:
+    class ProviderIntegrationAuthorizationAzureArgsDict(TypedDict):
+        customer_azure_tenant_id: pulumi.Input[_builtins.str]
+        """
+        Customer's Azure Tenant ID.
+        """
+        confluent_multi_tenant_app_id: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        (Computed String) Confluent Multi-Tenant App ID used to access customer Azure resources.
+        """
+elif False:
+    ProviderIntegrationAuthorizationAzureArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ProviderIntegrationAuthorizationAzureArgs:
+    def __init__(__self__, *,
+                 customer_azure_tenant_id: pulumi.Input[_builtins.str],
+                 confluent_multi_tenant_app_id: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_builtins.str] customer_azure_tenant_id: Customer's Azure Tenant ID.
+        :param pulumi.Input[_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) -> pulumi.Input[_builtins.str]:
+        """
+        Customer's Azure Tenant ID.
+        """
+        return pulumi.get(self, "customer_azure_tenant_id")
+
+    @customer_azure_tenant_id.setter
+    def customer_azure_tenant_id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "customer_azure_tenant_id", value)
+
+    @_builtins.property
+    @pulumi.getter(name="confluentMultiTenantAppId")
+    def confluent_multi_tenant_app_id(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        (Computed String) Confluent Multi-Tenant App ID used to access customer Azure resources.
+        """
+        return pulumi.get(self, "confluent_multi_tenant_app_id")
+
+    @confluent_multi_tenant_app_id.setter
+    def confluent_multi_tenant_app_id(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "confluent_multi_tenant_app_id", value)
+
+
+if not MYPY:
+    class ProviderIntegrationAuthorizationEnvironmentArgsDict(TypedDict):
+        id: pulumi.Input[_builtins.str]
+        """
+        The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
+        """
+elif False:
+    ProviderIntegrationAuthorizationEnvironmentArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ProviderIntegrationAuthorizationEnvironmentArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[_builtins.str]):
+        """
+        :param pulumi.Input[_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) -> pulumi.Input[_builtins.str]:
+        """
+        The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "id", value)
+
+
+if not MYPY:
+    class ProviderIntegrationAuthorizationGcpArgsDict(TypedDict):
+        customer_google_service_account: pulumi.Input[_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.
+        """
+        google_service_account: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        (Computed String) Google Service Account that Confluent Cloud uses for impersonation.
+        """
+elif False:
+    ProviderIntegrationAuthorizationGcpArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ProviderIntegrationAuthorizationGcpArgs:
+    def __init__(__self__, *,
+                 customer_google_service_account: pulumi.Input[_builtins.str],
+                 google_service_account: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_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 pulumi.Input[_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) -> pulumi.Input[_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")
+
+    @customer_google_service_account.setter
+    def customer_google_service_account(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "customer_google_service_account", value)
+
+    @_builtins.property
+    @pulumi.getter(name="googleServiceAccount")
+    def google_service_account(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        (Computed String) Google Service Account that Confluent Cloud uses for impersonation.
+        """
+        return pulumi.get(self, "google_service_account")
+
+    @google_service_account.setter
+    def google_service_account(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "google_service_account", value)
+
+
 if not MYPY:
     class ProviderIntegrationAwsArgsDict(TypedDict):
         customer_role_arn: pulumi.Input[_builtins.str]
@@ -6221,6 +6464,37 @@ class ProviderIntegrationEnvironmentArgs:
         pulumi.set(self, "id", value)
 
 
+if not MYPY:
+    class ProviderIntegrationSetupEnvironmentArgsDict(TypedDict):
+        id: pulumi.Input[_builtins.str]
+        """
+        The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
+        """
+elif False:
+    ProviderIntegrationSetupEnvironmentArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ProviderIntegrationSetupEnvironmentArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[_builtins.str]):
+        """
+        :param pulumi.Input[_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) -> pulumi.Input[_builtins.str]:
+        """
+        The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "id", value)
+
+
 if not MYPY:
     class ProviderOauthArgsDict(TypedDict):
         oauth_identity_pool_id: pulumi.Input[_builtins.str]
@@ -7654,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]
@@ -7805,6 +8168,58 @@ class TableflowTopicEnvironmentArgs:
         pulumi.set(self, "id", value)
 
 
+if not MYPY:
+    class TableflowTopicErrorHandlingArgsDict(TypedDict):
+        log_target: NotRequired[pulumi.Input[_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.
+        """
+        mode: NotRequired[pulumi.Input[_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`.
+        """
+elif False:
+    TableflowTopicErrorHandlingArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class TableflowTopicErrorHandlingArgs:
+    def __init__(__self__, *,
+                 log_target: Optional[pulumi.Input[_builtins.str]] = None,
+                 mode: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        :param pulumi.Input[_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 pulumi.Input[_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[pulumi.Input[_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")
+
+    @log_target.setter
+    def log_target(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "log_target", value)
+
+    @_builtins.property
+    @pulumi.getter
+    def mode(self) -> Optional[pulumi.Input[_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")
+
+    @mode.setter
+    def mode(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "mode", value)
+
+
 if not MYPY:
     class TableflowTopicKafkaClusterArgsDict(TypedDict):
         id: pulumi.Input[_builtins.str]
@@ -9187,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:
@@ -9277,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:
@@ -9326,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.
@@ -9339,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]:
@@ -9366,14 +9838,64 @@ 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:
+    class GetKafkaClustersEnvironmentArgsDict(TypedDict):
+        id: _builtins.str
+        """
+        The ID of the Environment that the Kafka clusters belongs to, for example, `env-xyz456`.
+        """
+elif False:
+    GetKafkaClustersEnvironmentArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetKafkaClustersEnvironmentArgs:
+    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")
+
+    @id.setter
+    def id(self, value: _builtins.str):
+        pulumi.set(self, "id", value)
 
 
 if not MYPY:
@@ -9991,6 +10513,37 @@ class GetPrivateLinkAttachmentEnvironmentArgs:
         pulumi.set(self, "id", value)
 
 
+if not MYPY:
+    class GetProviderIntegrationAuthorizationEnvironmentArgsDict(TypedDict):
+        id: _builtins.str
+        """
+        The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
+        """
+elif False:
+    GetProviderIntegrationAuthorizationEnvironmentArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetProviderIntegrationAuthorizationEnvironmentArgs:
+    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")
+
+    @id.setter
+    def id(self, value: _builtins.str):
+        pulumi.set(self, "id", value)
+
+
 if not MYPY:
     class GetProviderIntegrationEnvironmentArgsDict(TypedDict):
         id: _builtins.str
@@ -10028,6 +10581,37 @@ class GetProviderIntegrationEnvironmentArgs:
         pulumi.set(self, "id", value)
 
 
+if not MYPY:
+    class GetProviderIntegrationSetupEnvironmentArgsDict(TypedDict):
+        id: _builtins.str
+        """
+        The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
+        """
+elif False:
+    GetProviderIntegrationSetupEnvironmentArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetProviderIntegrationSetupEnvironmentArgs:
+    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")
+
+    @id.setter
+    def id(self, value: _builtins.str):
+        pulumi.set(self, "id", value)
+
+
 if not MYPY:
     class GetSchemaCredentialsArgsDict(TypedDict):
         key: _builtins.str