pulumi-azure-native 2.81.0a1736233463__py3-none-any.whl → 2.82.0__py3-none-any.whl

pulumi_azure_native/confluent/_inputs.py

@@ -13,125 +13,2944 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
+from ._enums import *
 
 __all__ = [
+    'AzureBlobStorageSinkConnectorServiceInfoArgs',
+    'AzureBlobStorageSinkConnectorServiceInfoArgsDict',
+    'AzureBlobStorageSourceConnectorServiceInfoArgs',
+    'AzureBlobStorageSourceConnectorServiceInfoArgsDict',
+    'AzureCosmosDBSinkConnectorServiceInfoArgs',
+    'AzureCosmosDBSinkConnectorServiceInfoArgsDict',
+    'AzureCosmosDBSourceConnectorServiceInfoArgs',
+    'AzureCosmosDBSourceConnectorServiceInfoArgsDict',
+    'AzureSynapseAnalyticsSinkConnectorServiceInfoArgs',
+    'AzureSynapseAnalyticsSinkConnectorServiceInfoArgsDict',
+    'ClusterConfigEntityArgs',
+    'ClusterConfigEntityArgsDict',
+    'ClusterStatusEntityArgs',
+    'ClusterStatusEntityArgsDict',
+    'ConnectorInfoBaseArgs',
+    'ConnectorInfoBaseArgsDict',
+    'KafkaAzureBlobStorageSinkConnectorInfoArgs',
+    'KafkaAzureBlobStorageSinkConnectorInfoArgsDict',
+    'KafkaAzureBlobStorageSourceConnectorInfoArgs',
+    'KafkaAzureBlobStorageSourceConnectorInfoArgsDict',
+    'KafkaAzureCosmosDBSinkConnectorInfoArgs',
+    'KafkaAzureCosmosDBSinkConnectorInfoArgsDict',
+    'KafkaAzureCosmosDBSourceConnectorInfoArgs',
+    'KafkaAzureCosmosDBSourceConnectorInfoArgsDict',
+    'KafkaAzureSynapseAnalyticsSinkConnectorInfoArgs',
+    'KafkaAzureSynapseAnalyticsSinkConnectorInfoArgsDict',
     'OfferDetailArgs',
     'OfferDetailArgsDict',
+    'SCClusterByokEntityArgs',
+    'SCClusterByokEntityArgsDict',
+    'SCClusterNetworkEnvironmentEntityArgs',
+    'SCClusterNetworkEnvironmentEntityArgsDict',
+    'SCClusterSpecEntityArgs',
+    'SCClusterSpecEntityArgsDict',
+    'SCMetadataEntityArgs',
+    'SCMetadataEntityArgsDict',
+    'StreamGovernanceConfigArgs',
+    'StreamGovernanceConfigArgsDict',
+    'TopicMetadataEntityArgs',
+    'TopicMetadataEntityArgsDict',
+    'TopicsInputConfigArgs',
+    'TopicsInputConfigArgsDict',
+    'TopicsRelatedLinkArgs',
+    'TopicsRelatedLinkArgsDict',
     'UserDetailArgs',
     'UserDetailArgsDict',
 ]
 
 MYPY = False
 
+if not MYPY:
+    class AzureBlobStorageSinkConnectorServiceInfoArgsDict(TypedDict):
+        """
+        The authentication info when auth_type is azureBlobStorageSinkConnector
+        """
+        connector_service_type: pulumi.Input[str]
+        """
+        The connector service type.
+        Expected value is 'AzureBlobStorageSinkConnector'.
+        """
+        storage_account_key: NotRequired[pulumi.Input[str]]
+        """
+        Azure Blob Storage Account Key
+        """
+        storage_account_name: NotRequired[pulumi.Input[str]]
+        """
+        Azure Blob Storage Account Name
+        """
+        storage_container_name: NotRequired[pulumi.Input[str]]
+        """
+        Azure Blob Storage Account Container Name
+        """
+elif False:
+    AzureBlobStorageSinkConnectorServiceInfoArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AzureBlobStorageSinkConnectorServiceInfoArgs:
+    def __init__(__self__, *,
+                 connector_service_type: pulumi.Input[str],
+                 storage_account_key: Optional[pulumi.Input[str]] = None,
+                 storage_account_name: Optional[pulumi.Input[str]] = None,
+                 storage_container_name: Optional[pulumi.Input[str]] = None):
+        """
+        The authentication info when auth_type is azureBlobStorageSinkConnector
+        :param pulumi.Input[str] connector_service_type: The connector service type.
+               Expected value is 'AzureBlobStorageSinkConnector'.
+        :param pulumi.Input[str] storage_account_key: Azure Blob Storage Account Key
+        :param pulumi.Input[str] storage_account_name: Azure Blob Storage Account Name
+        :param pulumi.Input[str] storage_container_name: Azure Blob Storage Account Container Name
+        """
+        pulumi.set(__self__, "connector_service_type", 'AzureBlobStorageSinkConnector')
+        if storage_account_key is not None:
+            pulumi.set(__self__, "storage_account_key", storage_account_key)
+        if storage_account_name is not None:
+            pulumi.set(__self__, "storage_account_name", storage_account_name)
+        if storage_container_name is not None:
+            pulumi.set(__self__, "storage_container_name", storage_container_name)
+
+    @property
+    @pulumi.getter(name="connectorServiceType")
+    def connector_service_type(self) -> pulumi.Input[str]:
+        """
+        The connector service type.
+        Expected value is 'AzureBlobStorageSinkConnector'.
+        """
+        return pulumi.get(self, "connector_service_type")
+
+    @connector_service_type.setter
+    def connector_service_type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "connector_service_type", value)
+
+    @property
+    @pulumi.getter(name="storageAccountKey")
+    def storage_account_key(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Blob Storage Account Key
+        """
+        return pulumi.get(self, "storage_account_key")
+
+    @storage_account_key.setter
+    def storage_account_key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "storage_account_key", value)
+
+    @property
+    @pulumi.getter(name="storageAccountName")
+    def storage_account_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Blob Storage Account Name
+        """
+        return pulumi.get(self, "storage_account_name")
+
+    @storage_account_name.setter
+    def storage_account_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "storage_account_name", value)
+
+    @property
+    @pulumi.getter(name="storageContainerName")
+    def storage_container_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Blob Storage Account Container Name
+        """
+        return pulumi.get(self, "storage_container_name")
+
+    @storage_container_name.setter
+    def storage_container_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "storage_container_name", value)
+
+
+if not MYPY:
+    class AzureBlobStorageSourceConnectorServiceInfoArgsDict(TypedDict):
+        """
+        The connector service type is AzureBlobStorageSourceConnector
+        """
+        connector_service_type: pulumi.Input[str]
+        """
+        The connector service type.
+        Expected value is 'AzureBlobStorageSourceConnector'.
+        """
+        storage_account_key: NotRequired[pulumi.Input[str]]
+        """
+        Azure Blob Storage Account Key
+        """
+        storage_account_name: NotRequired[pulumi.Input[str]]
+        """
+        Azure Blob Storage Account Name
+        """
+        storage_container_name: NotRequired[pulumi.Input[str]]
+        """
+        Azure Blob Storage Account Container Name
+        """
+elif False:
+    AzureBlobStorageSourceConnectorServiceInfoArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AzureBlobStorageSourceConnectorServiceInfoArgs:
+    def __init__(__self__, *,
+                 connector_service_type: pulumi.Input[str],
+                 storage_account_key: Optional[pulumi.Input[str]] = None,
+                 storage_account_name: Optional[pulumi.Input[str]] = None,
+                 storage_container_name: Optional[pulumi.Input[str]] = None):
+        """
+        The connector service type is AzureBlobStorageSourceConnector
+        :param pulumi.Input[str] connector_service_type: The connector service type.
+               Expected value is 'AzureBlobStorageSourceConnector'.
+        :param pulumi.Input[str] storage_account_key: Azure Blob Storage Account Key
+        :param pulumi.Input[str] storage_account_name: Azure Blob Storage Account Name
+        :param pulumi.Input[str] storage_container_name: Azure Blob Storage Account Container Name
+        """
+        pulumi.set(__self__, "connector_service_type", 'AzureBlobStorageSourceConnector')
+        if storage_account_key is not None:
+            pulumi.set(__self__, "storage_account_key", storage_account_key)
+        if storage_account_name is not None:
+            pulumi.set(__self__, "storage_account_name", storage_account_name)
+        if storage_container_name is not None:
+            pulumi.set(__self__, "storage_container_name", storage_container_name)
+
+    @property
+    @pulumi.getter(name="connectorServiceType")
+    def connector_service_type(self) -> pulumi.Input[str]:
+        """
+        The connector service type.
+        Expected value is 'AzureBlobStorageSourceConnector'.
+        """
+        return pulumi.get(self, "connector_service_type")
+
+    @connector_service_type.setter
+    def connector_service_type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "connector_service_type", value)
+
+    @property
+    @pulumi.getter(name="storageAccountKey")
+    def storage_account_key(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Blob Storage Account Key
+        """
+        return pulumi.get(self, "storage_account_key")
+
+    @storage_account_key.setter
+    def storage_account_key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "storage_account_key", value)
+
+    @property
+    @pulumi.getter(name="storageAccountName")
+    def storage_account_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Blob Storage Account Name
+        """
+        return pulumi.get(self, "storage_account_name")
+
+    @storage_account_name.setter
+    def storage_account_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "storage_account_name", value)
+
+    @property
+    @pulumi.getter(name="storageContainerName")
+    def storage_container_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Blob Storage Account Container Name
+        """
+        return pulumi.get(self, "storage_container_name")
+
+    @storage_container_name.setter
+    def storage_container_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "storage_container_name", value)
+
+
+if not MYPY:
+    class AzureCosmosDBSinkConnectorServiceInfoArgsDict(TypedDict):
+        """
+        The authentication info when auth_type is AzureCosmosDBSinkConnector
+        """
+        connector_service_type: pulumi.Input[str]
+        """
+        The connector service type.
+        Expected value is 'AzureCosmosDBSinkConnector'.
+        """
+        cosmos_connection_endpoint: NotRequired[pulumi.Input[str]]
+        """
+        Azure Cosmos Database Connection Endpoint
+        """
+        cosmos_containers_topic_mapping: NotRequired[pulumi.Input[str]]
+        """
+        Azure Cosmos Database Containers Topic Mapping
+        """
+        cosmos_database_name: NotRequired[pulumi.Input[str]]
+        """
+        Azure Cosmos Database Name
+        """
+        cosmos_id_strategy: NotRequired[pulumi.Input[str]]
+        """
+        Azure Cosmos Database Id Strategy
+        """
+        cosmos_master_key: NotRequired[pulumi.Input[str]]
+        """
+        Azure Cosmos Database Master Key
+        """
+elif False:
+    AzureCosmosDBSinkConnectorServiceInfoArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AzureCosmosDBSinkConnectorServiceInfoArgs:
+    def __init__(__self__, *,
+                 connector_service_type: pulumi.Input[str],
+                 cosmos_connection_endpoint: Optional[pulumi.Input[str]] = None,
+                 cosmos_containers_topic_mapping: Optional[pulumi.Input[str]] = None,
+                 cosmos_database_name: Optional[pulumi.Input[str]] = None,
+                 cosmos_id_strategy: Optional[pulumi.Input[str]] = None,
+                 cosmos_master_key: Optional[pulumi.Input[str]] = None):
+        """
+        The authentication info when auth_type is AzureCosmosDBSinkConnector
+        :param pulumi.Input[str] connector_service_type: The connector service type.
+               Expected value is 'AzureCosmosDBSinkConnector'.
+        :param pulumi.Input[str] cosmos_connection_endpoint: Azure Cosmos Database Connection Endpoint
+        :param pulumi.Input[str] cosmos_containers_topic_mapping: Azure Cosmos Database Containers Topic Mapping
+        :param pulumi.Input[str] cosmos_database_name: Azure Cosmos Database Name
+        :param pulumi.Input[str] cosmos_id_strategy: Azure Cosmos Database Id Strategy
+        :param pulumi.Input[str] cosmos_master_key: Azure Cosmos Database Master Key
+        """
+        pulumi.set(__self__, "connector_service_type", 'AzureCosmosDBSinkConnector')
+        if cosmos_connection_endpoint is not None:
+            pulumi.set(__self__, "cosmos_connection_endpoint", cosmos_connection_endpoint)
+        if cosmos_containers_topic_mapping is not None:
+            pulumi.set(__self__, "cosmos_containers_topic_mapping", cosmos_containers_topic_mapping)
+        if cosmos_database_name is not None:
+            pulumi.set(__self__, "cosmos_database_name", cosmos_database_name)
+        if cosmos_id_strategy is not None:
+            pulumi.set(__self__, "cosmos_id_strategy", cosmos_id_strategy)
+        if cosmos_master_key is not None:
+            pulumi.set(__self__, "cosmos_master_key", cosmos_master_key)
+
+    @property
+    @pulumi.getter(name="connectorServiceType")
+    def connector_service_type(self) -> pulumi.Input[str]:
+        """
+        The connector service type.
+        Expected value is 'AzureCosmosDBSinkConnector'.
+        """
+        return pulumi.get(self, "connector_service_type")
+
+    @connector_service_type.setter
+    def connector_service_type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "connector_service_type", value)
+
+    @property
+    @pulumi.getter(name="cosmosConnectionEndpoint")
+    def cosmos_connection_endpoint(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Cosmos Database Connection Endpoint
+        """
+        return pulumi.get(self, "cosmos_connection_endpoint")
+
+    @cosmos_connection_endpoint.setter
+    def cosmos_connection_endpoint(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "cosmos_connection_endpoint", value)
+
+    @property
+    @pulumi.getter(name="cosmosContainersTopicMapping")
+    def cosmos_containers_topic_mapping(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Cosmos Database Containers Topic Mapping
+        """
+        return pulumi.get(self, "cosmos_containers_topic_mapping")
+
+    @cosmos_containers_topic_mapping.setter
+    def cosmos_containers_topic_mapping(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "cosmos_containers_topic_mapping", value)
+
+    @property
+    @pulumi.getter(name="cosmosDatabaseName")
+    def cosmos_database_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Cosmos Database Name
+        """
+        return pulumi.get(self, "cosmos_database_name")
+
+    @cosmos_database_name.setter
+    def cosmos_database_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "cosmos_database_name", value)
+
+    @property
+    @pulumi.getter(name="cosmosIdStrategy")
+    def cosmos_id_strategy(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Cosmos Database Id Strategy
+        """
+        return pulumi.get(self, "cosmos_id_strategy")
+
+    @cosmos_id_strategy.setter
+    def cosmos_id_strategy(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "cosmos_id_strategy", value)
+
+    @property
+    @pulumi.getter(name="cosmosMasterKey")
+    def cosmos_master_key(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Cosmos Database Master Key
+        """
+        return pulumi.get(self, "cosmos_master_key")
+
+    @cosmos_master_key.setter
+    def cosmos_master_key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "cosmos_master_key", value)
+
+
+if not MYPY:
+    class AzureCosmosDBSourceConnectorServiceInfoArgsDict(TypedDict):
+        """
+        The authentication info when auth_type is AzureCosmosDBSourceConnector
+        """
+        connector_service_type: pulumi.Input[str]
+        """
+        The connector service type.
+        Expected value is 'AzureCosmosDBSourceConnector'.
+        """
+        cosmos_connection_endpoint: NotRequired[pulumi.Input[str]]
+        """
+        Azure Cosmos Database Connection Endpoint
+        """
+        cosmos_containers_topic_mapping: NotRequired[pulumi.Input[str]]
+        """
+        Azure Cosmos Database Containers Topic Mapping
+        """
+        cosmos_database_name: NotRequired[pulumi.Input[str]]
+        """
+        Azure Cosmos Database Name
+        """
+        cosmos_master_key: NotRequired[pulumi.Input[str]]
+        """
+        Azure Cosmos Database Master Key
+        """
+        cosmos_message_key_enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Azure Cosmos Database Message Key Enabled
+        """
+        cosmos_message_key_field: NotRequired[pulumi.Input[str]]
+        """
+        Azure Cosmos Database Message Key Field
+        """
+elif False:
+    AzureCosmosDBSourceConnectorServiceInfoArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AzureCosmosDBSourceConnectorServiceInfoArgs:
+    def __init__(__self__, *,
+                 connector_service_type: pulumi.Input[str],
+                 cosmos_connection_endpoint: Optional[pulumi.Input[str]] = None,
+                 cosmos_containers_topic_mapping: Optional[pulumi.Input[str]] = None,
+                 cosmos_database_name: Optional[pulumi.Input[str]] = None,
+                 cosmos_master_key: Optional[pulumi.Input[str]] = None,
+                 cosmos_message_key_enabled: Optional[pulumi.Input[bool]] = None,
+                 cosmos_message_key_field: Optional[pulumi.Input[str]] = None):
+        """
+        The authentication info when auth_type is AzureCosmosDBSourceConnector
+        :param pulumi.Input[str] connector_service_type: The connector service type.
+               Expected value is 'AzureCosmosDBSourceConnector'.
+        :param pulumi.Input[str] cosmos_connection_endpoint: Azure Cosmos Database Connection Endpoint
+        :param pulumi.Input[str] cosmos_containers_topic_mapping: Azure Cosmos Database Containers Topic Mapping
+        :param pulumi.Input[str] cosmos_database_name: Azure Cosmos Database Name
+        :param pulumi.Input[str] cosmos_master_key: Azure Cosmos Database Master Key
+        :param pulumi.Input[bool] cosmos_message_key_enabled: Azure Cosmos Database Message Key Enabled
+        :param pulumi.Input[str] cosmos_message_key_field: Azure Cosmos Database Message Key Field
+        """
+        pulumi.set(__self__, "connector_service_type", 'AzureCosmosDBSourceConnector')
+        if cosmos_connection_endpoint is not None:
+            pulumi.set(__self__, "cosmos_connection_endpoint", cosmos_connection_endpoint)
+        if cosmos_containers_topic_mapping is not None:
+            pulumi.set(__self__, "cosmos_containers_topic_mapping", cosmos_containers_topic_mapping)
+        if cosmos_database_name is not None:
+            pulumi.set(__self__, "cosmos_database_name", cosmos_database_name)
+        if cosmos_master_key is not None:
+            pulumi.set(__self__, "cosmos_master_key", cosmos_master_key)
+        if cosmos_message_key_enabled is not None:
+            pulumi.set(__self__, "cosmos_message_key_enabled", cosmos_message_key_enabled)
+        if cosmos_message_key_field is not None:
+            pulumi.set(__self__, "cosmos_message_key_field", cosmos_message_key_field)
+
+    @property
+    @pulumi.getter(name="connectorServiceType")
+    def connector_service_type(self) -> pulumi.Input[str]:
+        """
+        The connector service type.
+        Expected value is 'AzureCosmosDBSourceConnector'.
+        """
+        return pulumi.get(self, "connector_service_type")
+
+    @connector_service_type.setter
+    def connector_service_type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "connector_service_type", value)
+
+    @property
+    @pulumi.getter(name="cosmosConnectionEndpoint")
+    def cosmos_connection_endpoint(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Cosmos Database Connection Endpoint
+        """
+        return pulumi.get(self, "cosmos_connection_endpoint")
+
+    @cosmos_connection_endpoint.setter
+    def cosmos_connection_endpoint(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "cosmos_connection_endpoint", value)
+
+    @property
+    @pulumi.getter(name="cosmosContainersTopicMapping")
+    def cosmos_containers_topic_mapping(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Cosmos Database Containers Topic Mapping
+        """
+        return pulumi.get(self, "cosmos_containers_topic_mapping")
+
+    @cosmos_containers_topic_mapping.setter
+    def cosmos_containers_topic_mapping(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "cosmos_containers_topic_mapping", value)
+
+    @property
+    @pulumi.getter(name="cosmosDatabaseName")
+    def cosmos_database_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Cosmos Database Name
+        """
+        return pulumi.get(self, "cosmos_database_name")
+
+    @cosmos_database_name.setter
+    def cosmos_database_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "cosmos_database_name", value)
+
+    @property
+    @pulumi.getter(name="cosmosMasterKey")
+    def cosmos_master_key(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Cosmos Database Master Key
+        """
+        return pulumi.get(self, "cosmos_master_key")
+
+    @cosmos_master_key.setter
+    def cosmos_master_key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "cosmos_master_key", value)
+
+    @property
+    @pulumi.getter(name="cosmosMessageKeyEnabled")
+    def cosmos_message_key_enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Azure Cosmos Database Message Key Enabled
+        """
+        return pulumi.get(self, "cosmos_message_key_enabled")
+
+    @cosmos_message_key_enabled.setter
+    def cosmos_message_key_enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "cosmos_message_key_enabled", value)
+
+    @property
+    @pulumi.getter(name="cosmosMessageKeyField")
+    def cosmos_message_key_field(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Cosmos Database Message Key Field
+        """
+        return pulumi.get(self, "cosmos_message_key_field")
+
+    @cosmos_message_key_field.setter
+    def cosmos_message_key_field(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "cosmos_message_key_field", value)
+
+
+if not MYPY:
+    class AzureSynapseAnalyticsSinkConnectorServiceInfoArgsDict(TypedDict):
+        """
+        The authentication info when auth_type is AzureSynapseAnalyticsSinkConnector
+        """
+        connector_service_type: pulumi.Input[str]
+        """
+        The connector service type.
+        Expected value is 'AzureSynapseAnalyticsSinkConnector'.
+        """
+        synapse_sql_database_name: NotRequired[pulumi.Input[str]]
+        """
+        Azure Synapse Dedicated SQL Pool Database Name
+        """
+        synapse_sql_password: NotRequired[pulumi.Input[str]]
+        """
+        Azure Synapse SQL login details
+        """
+        synapse_sql_server_name: NotRequired[pulumi.Input[str]]
+        """
+        Azure Synapse Analytics SQL Server Name
+        """
+        synapse_sql_user: NotRequired[pulumi.Input[str]]
+        """
+        Azure Synapse SQL login details
+        """
+elif False:
+    AzureSynapseAnalyticsSinkConnectorServiceInfoArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AzureSynapseAnalyticsSinkConnectorServiceInfoArgs:
+    def __init__(__self__, *,
+                 connector_service_type: pulumi.Input[str],
+                 synapse_sql_database_name: Optional[pulumi.Input[str]] = None,
+                 synapse_sql_password: Optional[pulumi.Input[str]] = None,
+                 synapse_sql_server_name: Optional[pulumi.Input[str]] = None,
+                 synapse_sql_user: Optional[pulumi.Input[str]] = None):
+        """
+        The authentication info when auth_type is AzureSynapseAnalyticsSinkConnector
+        :param pulumi.Input[str] connector_service_type: The connector service type.
+               Expected value is 'AzureSynapseAnalyticsSinkConnector'.
+        :param pulumi.Input[str] synapse_sql_database_name: Azure Synapse Dedicated SQL Pool Database Name
+        :param pulumi.Input[str] synapse_sql_password: Azure Synapse SQL login details
+        :param pulumi.Input[str] synapse_sql_server_name: Azure Synapse Analytics SQL Server Name
+        :param pulumi.Input[str] synapse_sql_user: Azure Synapse SQL login details
+        """
+        pulumi.set(__self__, "connector_service_type", 'AzureSynapseAnalyticsSinkConnector')
+        if synapse_sql_database_name is not None:
+            pulumi.set(__self__, "synapse_sql_database_name", synapse_sql_database_name)
+        if synapse_sql_password is not None:
+            pulumi.set(__self__, "synapse_sql_password", synapse_sql_password)
+        if synapse_sql_server_name is not None:
+            pulumi.set(__self__, "synapse_sql_server_name", synapse_sql_server_name)
+        if synapse_sql_user is not None:
+            pulumi.set(__self__, "synapse_sql_user", synapse_sql_user)
+
+    @property
+    @pulumi.getter(name="connectorServiceType")
+    def connector_service_type(self) -> pulumi.Input[str]:
+        """
+        The connector service type.
+        Expected value is 'AzureSynapseAnalyticsSinkConnector'.
+        """
+        return pulumi.get(self, "connector_service_type")
+
+    @connector_service_type.setter
+    def connector_service_type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "connector_service_type", value)
+
+    @property
+    @pulumi.getter(name="synapseSqlDatabaseName")
+    def synapse_sql_database_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Synapse Dedicated SQL Pool Database Name
+        """
+        return pulumi.get(self, "synapse_sql_database_name")
+
+    @synapse_sql_database_name.setter
+    def synapse_sql_database_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "synapse_sql_database_name", value)
+
+    @property
+    @pulumi.getter(name="synapseSqlPassword")
+    def synapse_sql_password(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Synapse SQL login details
+        """
+        return pulumi.get(self, "synapse_sql_password")
+
+    @synapse_sql_password.setter
+    def synapse_sql_password(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "synapse_sql_password", value)
+
+    @property
+    @pulumi.getter(name="synapseSqlServerName")
+    def synapse_sql_server_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Synapse Analytics SQL Server Name
+        """
+        return pulumi.get(self, "synapse_sql_server_name")
+
+    @synapse_sql_server_name.setter
+    def synapse_sql_server_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "synapse_sql_server_name", value)
+
+    @property
+    @pulumi.getter(name="synapseSqlUser")
+    def synapse_sql_user(self) -> Optional[pulumi.Input[str]]:
+        """
+        Azure Synapse SQL login details
+        """
+        return pulumi.get(self, "synapse_sql_user")
+
+    @synapse_sql_user.setter
+    def synapse_sql_user(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "synapse_sql_user", value)
+
+
+if not MYPY:
+    class ClusterConfigEntityArgsDict(TypedDict):
+        """
+        The configuration of the Kafka cluster
+        """
+        kind: NotRequired[pulumi.Input[str]]
+        """
+        The lifecycle phase of the cluster
+        """
+elif False:
+    ClusterConfigEntityArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ClusterConfigEntityArgs:
+    def __init__(__self__, *,
+                 kind: Optional[pulumi.Input[str]] = None):
+        """
+        The configuration of the Kafka cluster
+        :param pulumi.Input[str] kind: The lifecycle phase of the cluster
+        """
+        if kind is not None:
+            pulumi.set(__self__, "kind", kind)
+
+    @property
+    @pulumi.getter
+    def kind(self) -> Optional[pulumi.Input[str]]:
+        """
+        The lifecycle phase of the cluster
+        """
+        return pulumi.get(self, "kind")
+
+    @kind.setter
+    def kind(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "kind", value)
+
+
+if not MYPY:
+    class ClusterStatusEntityArgsDict(TypedDict):
+        """
+        Status of the cluster record
+        """
+        cku: NotRequired[pulumi.Input[int]]
+        """
+        The number of Confluent Kafka Units 
+        """
+        phase: NotRequired[pulumi.Input[str]]
+        """
+        The lifecycle phase of the cluster
+        """
+elif False:
+    ClusterStatusEntityArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ClusterStatusEntityArgs:
+    def __init__(__self__, *,
+                 cku: Optional[pulumi.Input[int]] = None,
+                 phase: Optional[pulumi.Input[str]] = None):
+        """
+        Status of the cluster record
+        :param pulumi.Input[int] cku: The number of Confluent Kafka Units 
+        :param pulumi.Input[str] phase: The lifecycle phase of the cluster
+        """
+        if cku is not None:
+            pulumi.set(__self__, "cku", cku)
+        if phase is not None:
+            pulumi.set(__self__, "phase", phase)
+
+    @property
+    @pulumi.getter
+    def cku(self) -> Optional[pulumi.Input[int]]:
+        """
+        The number of Confluent Kafka Units 
+        """
+        return pulumi.get(self, "cku")
+
+    @cku.setter
+    def cku(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "cku", value)
+
+    @property
+    @pulumi.getter
+    def phase(self) -> Optional[pulumi.Input[str]]:
+        """
+        The lifecycle phase of the cluster
+        """
+        return pulumi.get(self, "phase")
+
+    @phase.setter
+    def phase(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "phase", value)
+
+
+if not MYPY:
+    class ConnectorInfoBaseArgsDict(TypedDict):
+        """
+        Connector Info Base properties
+        """
+        connector_class: NotRequired[pulumi.Input[Union[str, 'ConnectorClass']]]
+        """
+        Connector Class
+        """
+        connector_id: NotRequired[pulumi.Input[str]]
+        """
+        Connector Id
+        """
+        connector_name: NotRequired[pulumi.Input[str]]
+        """
+        Connector Name
+        """
+        connector_state: NotRequired[pulumi.Input[Union[str, 'ConnectorStatus']]]
+        """
+        Connector Status
+        """
+        connector_type: NotRequired[pulumi.Input[Union[str, 'ConnectorType']]]
+        """
+        Connector Type
+        """
+elif False:
+    ConnectorInfoBaseArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ConnectorInfoBaseArgs:
+    def __init__(__self__, *,
+                 connector_class: Optional[pulumi.Input[Union[str, 'ConnectorClass']]] = None,
+                 connector_id: Optional[pulumi.Input[str]] = None,
+                 connector_name: Optional[pulumi.Input[str]] = None,
+                 connector_state: Optional[pulumi.Input[Union[str, 'ConnectorStatus']]] = None,
+                 connector_type: Optional[pulumi.Input[Union[str, 'ConnectorType']]] = None):
+        """
+        Connector Info Base properties
+        :param pulumi.Input[Union[str, 'ConnectorClass']] connector_class: Connector Class
+        :param pulumi.Input[str] connector_id: Connector Id
+        :param pulumi.Input[str] connector_name: Connector Name
+        :param pulumi.Input[Union[str, 'ConnectorStatus']] connector_state: Connector Status
+        :param pulumi.Input[Union[str, 'ConnectorType']] connector_type: Connector Type
+        """
+        if connector_class is not None:
+            pulumi.set(__self__, "connector_class", connector_class)
+        if connector_id is not None:
+            pulumi.set(__self__, "connector_id", connector_id)
+        if connector_name is not None:
+            pulumi.set(__self__, "connector_name", connector_name)
+        if connector_state is not None:
+            pulumi.set(__self__, "connector_state", connector_state)
+        if connector_type is not None:
+            pulumi.set(__self__, "connector_type", connector_type)
+
+    @property
+    @pulumi.getter(name="connectorClass")
+    def connector_class(self) -> Optional[pulumi.Input[Union[str, 'ConnectorClass']]]:
+        """
+        Connector Class
+        """
+        return pulumi.get(self, "connector_class")
+
+    @connector_class.setter
+    def connector_class(self, value: Optional[pulumi.Input[Union[str, 'ConnectorClass']]]):
+        pulumi.set(self, "connector_class", value)
+
+    @property
+    @pulumi.getter(name="connectorId")
+    def connector_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Connector Id
+        """
+        return pulumi.get(self, "connector_id")
+
+    @connector_id.setter
+    def connector_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "connector_id", value)
+
+    @property
+    @pulumi.getter(name="connectorName")
+    def connector_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Connector Name
+        """
+        return pulumi.get(self, "connector_name")
+
+    @connector_name.setter
+    def connector_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "connector_name", value)
+
+    @property
+    @pulumi.getter(name="connectorState")
+    def connector_state(self) -> Optional[pulumi.Input[Union[str, 'ConnectorStatus']]]:
+        """
+        Connector Status
+        """
+        return pulumi.get(self, "connector_state")
+
+    @connector_state.setter
+    def connector_state(self, value: Optional[pulumi.Input[Union[str, 'ConnectorStatus']]]):
+        pulumi.set(self, "connector_state", value)
+
+    @property
+    @pulumi.getter(name="connectorType")
+    def connector_type(self) -> Optional[pulumi.Input[Union[str, 'ConnectorType']]]:
+        """
+        Connector Type
+        """
+        return pulumi.get(self, "connector_type")
+
+    @connector_type.setter
+    def connector_type(self, value: Optional[pulumi.Input[Union[str, 'ConnectorType']]]):
+        pulumi.set(self, "connector_type", value)
+
+
+if not MYPY:
+    class KafkaAzureBlobStorageSinkConnectorInfoArgsDict(TypedDict):
+        """
+        The partner connector type is KafkaAzureBlobStorageSink
+        """
+        partner_connector_type: pulumi.Input[str]
+        """
+        Partner Connector type.
+        Expected value is 'KafkaAzureBlobStorageSink'.
+        """
+        api_key: NotRequired[pulumi.Input[str]]
+        """
+        Kafka API Key
+        """
+        api_secret: NotRequired[pulumi.Input[str]]
+        """
+        Kafka API Key Secret
+        """
+        auth_type: NotRequired[pulumi.Input[Union[str, 'AuthType']]]
+        """
+        Kafka Auth Type
+        """
+        flush_size: NotRequired[pulumi.Input[str]]
+        """
+        Flush size
+        """
+        input_format: NotRequired[pulumi.Input[Union[str, 'DataFormatType']]]
+        """
+        Kafka Input Data Format Type
+        """
+        max_tasks: NotRequired[pulumi.Input[str]]
+        """
+        Maximum Tasks
+        """
+        output_format: NotRequired[pulumi.Input[Union[str, 'DataFormatType']]]
+        """
+        Kafka Output Data Format Type
+        """
+        service_account_id: NotRequired[pulumi.Input[str]]
+        """
+        Kafka Service Account Id
+        """
+        time_interval: NotRequired[pulumi.Input[str]]
+        """
+        Time Interval
+        """
+        topics: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Kafka topics list
+        """
+        topics_dir: NotRequired[pulumi.Input[str]]
+        """
+        Kafka topics directory
+        """
+elif False:
+    KafkaAzureBlobStorageSinkConnectorInfoArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class KafkaAzureBlobStorageSinkConnectorInfoArgs:
+    def __init__(__self__, *,
+                 partner_connector_type: pulumi.Input[str],
+                 api_key: Optional[pulumi.Input[str]] = None,
+                 api_secret: Optional[pulumi.Input[str]] = None,
+                 auth_type: Optional[pulumi.Input[Union[str, 'AuthType']]] = None,
+                 flush_size: Optional[pulumi.Input[str]] = None,
+                 input_format: Optional[pulumi.Input[Union[str, 'DataFormatType']]] = None,
+                 max_tasks: Optional[pulumi.Input[str]] = None,
+                 output_format: Optional[pulumi.Input[Union[str, 'DataFormatType']]] = None,
+                 service_account_id: Optional[pulumi.Input[str]] = None,
+                 time_interval: Optional[pulumi.Input[str]] = None,
+                 topics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 topics_dir: Optional[pulumi.Input[str]] = None):
+        """
+        The partner connector type is KafkaAzureBlobStorageSink
+        :param pulumi.Input[str] partner_connector_type: Partner Connector type.
+               Expected value is 'KafkaAzureBlobStorageSink'.
+        :param pulumi.Input[str] api_key: Kafka API Key
+        :param pulumi.Input[str] api_secret: Kafka API Key Secret
+        :param pulumi.Input[Union[str, 'AuthType']] auth_type: Kafka Auth Type
+        :param pulumi.Input[str] flush_size: Flush size
+        :param pulumi.Input[Union[str, 'DataFormatType']] input_format: Kafka Input Data Format Type
+        :param pulumi.Input[str] max_tasks: Maximum Tasks
+        :param pulumi.Input[Union[str, 'DataFormatType']] output_format: Kafka Output Data Format Type
+        :param pulumi.Input[str] service_account_id: Kafka Service Account Id
+        :param pulumi.Input[str] time_interval: Time Interval
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] topics: Kafka topics list
+        :param pulumi.Input[str] topics_dir: Kafka topics directory
+        """
+        pulumi.set(__self__, "partner_connector_type", 'KafkaAzureBlobStorageSink')
+        if api_key is not None:
+            pulumi.set(__self__, "api_key", api_key)
+        if api_secret is not None:
+            pulumi.set(__self__, "api_secret", api_secret)
+        if auth_type is not None:
+            pulumi.set(__self__, "auth_type", auth_type)
+        if flush_size is not None:
+            pulumi.set(__self__, "flush_size", flush_size)
+        if input_format is not None:
+            pulumi.set(__self__, "input_format", input_format)
+        if max_tasks is not None:
+            pulumi.set(__self__, "max_tasks", max_tasks)
+        if output_format is not None:
+            pulumi.set(__self__, "output_format", output_format)
+        if service_account_id is not None:
+            pulumi.set(__self__, "service_account_id", service_account_id)
+        if time_interval is not None:
+            pulumi.set(__self__, "time_interval", time_interval)
+        if topics is not None:
+            pulumi.set(__self__, "topics", topics)
+        if topics_dir is not None:
+            pulumi.set(__self__, "topics_dir", topics_dir)
+
+    @property
+    @pulumi.getter(name="partnerConnectorType")
+    def partner_connector_type(self) -> pulumi.Input[str]:
+        """
+        Partner Connector type.
+        Expected value is 'KafkaAzureBlobStorageSink'.
+        """
+        return pulumi.get(self, "partner_connector_type")
+
+    @partner_connector_type.setter
+    def partner_connector_type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "partner_connector_type", value)
+
+    @property
+    @pulumi.getter(name="apiKey")
+    def api_key(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka API Key
+        """
+        return pulumi.get(self, "api_key")
+
+    @api_key.setter
+    def api_key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_key", value)
+
+    @property
+    @pulumi.getter(name="apiSecret")
+    def api_secret(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka API Key Secret
+        """
+        return pulumi.get(self, "api_secret")
+
+    @api_secret.setter
+    def api_secret(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_secret", value)
+
+    @property
+    @pulumi.getter(name="authType")
+    def auth_type(self) -> Optional[pulumi.Input[Union[str, 'AuthType']]]:
+        """
+        Kafka Auth Type
+        """
+        return pulumi.get(self, "auth_type")
+
+    @auth_type.setter
+    def auth_type(self, value: Optional[pulumi.Input[Union[str, 'AuthType']]]):
+        pulumi.set(self, "auth_type", value)
+
+    @property
+    @pulumi.getter(name="flushSize")
+    def flush_size(self) -> Optional[pulumi.Input[str]]:
+        """
+        Flush size
+        """
+        return pulumi.get(self, "flush_size")
+
+    @flush_size.setter
+    def flush_size(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "flush_size", value)
+
+    @property
+    @pulumi.getter(name="inputFormat")
+    def input_format(self) -> Optional[pulumi.Input[Union[str, 'DataFormatType']]]:
+        """
+        Kafka Input Data Format Type
+        """
+        return pulumi.get(self, "input_format")
+
+    @input_format.setter
+    def input_format(self, value: Optional[pulumi.Input[Union[str, 'DataFormatType']]]):
+        pulumi.set(self, "input_format", value)
+
+    @property
+    @pulumi.getter(name="maxTasks")
+    def max_tasks(self) -> Optional[pulumi.Input[str]]:
+        """
+        Maximum Tasks
+        """
+        return pulumi.get(self, "max_tasks")
+
+    @max_tasks.setter
+    def max_tasks(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "max_tasks", value)
+
+    @property
+    @pulumi.getter(name="outputFormat")
+    def output_format(self) -> Optional[pulumi.Input[Union[str, 'DataFormatType']]]:
+        """
+        Kafka Output Data Format Type
+        """
+        return pulumi.get(self, "output_format")
+
+    @output_format.setter
+    def output_format(self, value: Optional[pulumi.Input[Union[str, 'DataFormatType']]]):
+        pulumi.set(self, "output_format", value)
+
+    @property
+    @pulumi.getter(name="serviceAccountId")
+    def service_account_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka Service Account Id
+        """
+        return pulumi.get(self, "service_account_id")
+
+    @service_account_id.setter
+    def service_account_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "service_account_id", value)
+
+    @property
+    @pulumi.getter(name="timeInterval")
+    def time_interval(self) -> Optional[pulumi.Input[str]]:
+        """
+        Time Interval
+        """
+        return pulumi.get(self, "time_interval")
+
+    @time_interval.setter
+    def time_interval(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_interval", value)
+
+    @property
+    @pulumi.getter
+    def topics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Kafka topics list
+        """
+        return pulumi.get(self, "topics")
+
+    @topics.setter
+    def topics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "topics", value)
+
+    @property
+    @pulumi.getter(name="topicsDir")
+    def topics_dir(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka topics directory
+        """
+        return pulumi.get(self, "topics_dir")
+
+    @topics_dir.setter
+    def topics_dir(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "topics_dir", value)
+
+
+if not MYPY:
+    class KafkaAzureBlobStorageSourceConnectorInfoArgsDict(TypedDict):
+        """
+        The partner connector type is KafkaAzureBlobStorageSource
+        """
+        partner_connector_type: pulumi.Input[str]
+        """
+        Partner Connector type.
+        Expected value is 'KafkaAzureBlobStorageSource'.
+        """
+        api_key: NotRequired[pulumi.Input[str]]
+        """
+        Kafka API Key
+        """
+        api_secret: NotRequired[pulumi.Input[str]]
+        """
+        Kafka API Secret
+        """
+        auth_type: NotRequired[pulumi.Input[Union[str, 'AuthType']]]
+        """
+        Kafka Auth Type
+        """
+        input_format: NotRequired[pulumi.Input[Union[str, 'DataFormatType']]]
+        """
+        Kafka Input Data Format Type
+        """
+        max_tasks: NotRequired[pulumi.Input[str]]
+        """
+        Maximum Tasks
+        """
+        output_format: NotRequired[pulumi.Input[Union[str, 'DataFormatType']]]
+        """
+        Kafka Output Data Format Type
+        """
+        service_account_id: NotRequired[pulumi.Input[str]]
+        """
+        Kafka Service Account Id
+        """
+        topic_regex: NotRequired[pulumi.Input[str]]
+        """
+        Kafka topics Regex pattern
+        """
+        topics_dir: NotRequired[pulumi.Input[str]]
+        """
+        Kafka topics directory
+        """
+elif False:
+    KafkaAzureBlobStorageSourceConnectorInfoArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class KafkaAzureBlobStorageSourceConnectorInfoArgs:
+    def __init__(__self__, *,
+                 partner_connector_type: pulumi.Input[str],
+                 api_key: Optional[pulumi.Input[str]] = None,
+                 api_secret: Optional[pulumi.Input[str]] = None,
+                 auth_type: Optional[pulumi.Input[Union[str, 'AuthType']]] = None,
+                 input_format: Optional[pulumi.Input[Union[str, 'DataFormatType']]] = None,
+                 max_tasks: Optional[pulumi.Input[str]] = None,
+                 output_format: Optional[pulumi.Input[Union[str, 'DataFormatType']]] = None,
+                 service_account_id: Optional[pulumi.Input[str]] = None,
+                 topic_regex: Optional[pulumi.Input[str]] = None,
+                 topics_dir: Optional[pulumi.Input[str]] = None):
+        """
+        The partner connector type is KafkaAzureBlobStorageSource
+        :param pulumi.Input[str] partner_connector_type: Partner Connector type.
+               Expected value is 'KafkaAzureBlobStorageSource'.
+        :param pulumi.Input[str] api_key: Kafka API Key
+        :param pulumi.Input[str] api_secret: Kafka API Secret
+        :param pulumi.Input[Union[str, 'AuthType']] auth_type: Kafka Auth Type
+        :param pulumi.Input[Union[str, 'DataFormatType']] input_format: Kafka Input Data Format Type
+        :param pulumi.Input[str] max_tasks: Maximum Tasks
+        :param pulumi.Input[Union[str, 'DataFormatType']] output_format: Kafka Output Data Format Type
+        :param pulumi.Input[str] service_account_id: Kafka Service Account Id
+        :param pulumi.Input[str] topic_regex: Kafka topics Regex pattern
+        :param pulumi.Input[str] topics_dir: Kafka topics directory
+        """
+        pulumi.set(__self__, "partner_connector_type", 'KafkaAzureBlobStorageSource')
+        if api_key is not None:
+            pulumi.set(__self__, "api_key", api_key)
+        if api_secret is not None:
+            pulumi.set(__self__, "api_secret", api_secret)
+        if auth_type is not None:
+            pulumi.set(__self__, "auth_type", auth_type)
+        if input_format is not None:
+            pulumi.set(__self__, "input_format", input_format)
+        if max_tasks is not None:
+            pulumi.set(__self__, "max_tasks", max_tasks)
+        if output_format is not None:
+            pulumi.set(__self__, "output_format", output_format)
+        if service_account_id is not None:
+            pulumi.set(__self__, "service_account_id", service_account_id)
+        if topic_regex is not None:
+            pulumi.set(__self__, "topic_regex", topic_regex)
+        if topics_dir is not None:
+            pulumi.set(__self__, "topics_dir", topics_dir)
+
+    @property
+    @pulumi.getter(name="partnerConnectorType")
+    def partner_connector_type(self) -> pulumi.Input[str]:
+        """
+        Partner Connector type.
+        Expected value is 'KafkaAzureBlobStorageSource'.
+        """
+        return pulumi.get(self, "partner_connector_type")
+
+    @partner_connector_type.setter
+    def partner_connector_type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "partner_connector_type", value)
+
+    @property
+    @pulumi.getter(name="apiKey")
+    def api_key(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka API Key
+        """
+        return pulumi.get(self, "api_key")
+
+    @api_key.setter
+    def api_key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_key", value)
+
+    @property
+    @pulumi.getter(name="apiSecret")
+    def api_secret(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka API Secret
+        """
+        return pulumi.get(self, "api_secret")
+
+    @api_secret.setter
+    def api_secret(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_secret", value)
+
+    @property
+    @pulumi.getter(name="authType")
+    def auth_type(self) -> Optional[pulumi.Input[Union[str, 'AuthType']]]:
+        """
+        Kafka Auth Type
+        """
+        return pulumi.get(self, "auth_type")
+
+    @auth_type.setter
+    def auth_type(self, value: Optional[pulumi.Input[Union[str, 'AuthType']]]):
+        pulumi.set(self, "auth_type", value)
+
+    @property
+    @pulumi.getter(name="inputFormat")
+    def input_format(self) -> Optional[pulumi.Input[Union[str, 'DataFormatType']]]:
+        """
+        Kafka Input Data Format Type
+        """
+        return pulumi.get(self, "input_format")
+
+    @input_format.setter
+    def input_format(self, value: Optional[pulumi.Input[Union[str, 'DataFormatType']]]):
+        pulumi.set(self, "input_format", value)
+
+    @property
+    @pulumi.getter(name="maxTasks")
+    def max_tasks(self) -> Optional[pulumi.Input[str]]:
+        """
+        Maximum Tasks
+        """
+        return pulumi.get(self, "max_tasks")
+
+    @max_tasks.setter
+    def max_tasks(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "max_tasks", value)
+
+    @property
+    @pulumi.getter(name="outputFormat")
+    def output_format(self) -> Optional[pulumi.Input[Union[str, 'DataFormatType']]]:
+        """
+        Kafka Output Data Format Type
+        """
+        return pulumi.get(self, "output_format")
+
+    @output_format.setter
+    def output_format(self, value: Optional[pulumi.Input[Union[str, 'DataFormatType']]]):
+        pulumi.set(self, "output_format", value)
+
+    @property
+    @pulumi.getter(name="serviceAccountId")
+    def service_account_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka Service Account Id
+        """
+        return pulumi.get(self, "service_account_id")
+
+    @service_account_id.setter
+    def service_account_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "service_account_id", value)
+
+    @property
+    @pulumi.getter(name="topicRegex")
+    def topic_regex(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka topics Regex pattern
+        """
+        return pulumi.get(self, "topic_regex")
+
+    @topic_regex.setter
+    def topic_regex(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "topic_regex", value)
+
+    @property
+    @pulumi.getter(name="topicsDir")
+    def topics_dir(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka topics directory
+        """
+        return pulumi.get(self, "topics_dir")
+
+    @topics_dir.setter
+    def topics_dir(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "topics_dir", value)
+
+
+if not MYPY:
+    class KafkaAzureCosmosDBSinkConnectorInfoArgsDict(TypedDict):
+        """
+        The partner connector type is KafkaAzureCosmosDBSink
+        """
+        partner_connector_type: pulumi.Input[str]
+        """
+        Partner Connector type.
+        Expected value is 'KafkaAzureCosmosDBSink'.
+        """
+        api_key: NotRequired[pulumi.Input[str]]
+        """
+        Kafka API Key
+        """
+        api_secret: NotRequired[pulumi.Input[str]]
+        """
+        Kafka API Key Secret
+        """
+        auth_type: NotRequired[pulumi.Input[Union[str, 'AuthType']]]
+        """
+        Kafka Auth Type
+        """
+        flush_size: NotRequired[pulumi.Input[str]]
+        """
+        Flush size
+        """
+        input_format: NotRequired[pulumi.Input[Union[str, 'DataFormatType']]]
+        """
+        Kafka Input Data Format Type
+        """
+        max_tasks: NotRequired[pulumi.Input[str]]
+        """
+        Maximum Tasks
+        """
+        output_format: NotRequired[pulumi.Input[Union[str, 'DataFormatType']]]
+        """
+        Kafka Output Data Format Type
+        """
+        service_account_id: NotRequired[pulumi.Input[str]]
+        """
+        Kafka Service Account Id
+        """
+        time_interval: NotRequired[pulumi.Input[str]]
+        """
+        Time Interval
+        """
+        topics: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Kafka topics list
+        """
+        topics_dir: NotRequired[pulumi.Input[str]]
+        """
+        Kafka topics directory
+        """
+elif False:
+    KafkaAzureCosmosDBSinkConnectorInfoArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class KafkaAzureCosmosDBSinkConnectorInfoArgs:
+    def __init__(__self__, *,
+                 partner_connector_type: pulumi.Input[str],
+                 api_key: Optional[pulumi.Input[str]] = None,
+                 api_secret: Optional[pulumi.Input[str]] = None,
+                 auth_type: Optional[pulumi.Input[Union[str, 'AuthType']]] = None,
+                 flush_size: Optional[pulumi.Input[str]] = None,
+                 input_format: Optional[pulumi.Input[Union[str, 'DataFormatType']]] = None,
+                 max_tasks: Optional[pulumi.Input[str]] = None,
+                 output_format: Optional[pulumi.Input[Union[str, 'DataFormatType']]] = None,
+                 service_account_id: Optional[pulumi.Input[str]] = None,
+                 time_interval: Optional[pulumi.Input[str]] = None,
+                 topics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 topics_dir: Optional[pulumi.Input[str]] = None):
+        """
+        The partner connector type is KafkaAzureCosmosDBSink
+        :param pulumi.Input[str] partner_connector_type: Partner Connector type.
+               Expected value is 'KafkaAzureCosmosDBSink'.
+        :param pulumi.Input[str] api_key: Kafka API Key
+        :param pulumi.Input[str] api_secret: Kafka API Key Secret
+        :param pulumi.Input[Union[str, 'AuthType']] auth_type: Kafka Auth Type
+        :param pulumi.Input[str] flush_size: Flush size
+        :param pulumi.Input[Union[str, 'DataFormatType']] input_format: Kafka Input Data Format Type
+        :param pulumi.Input[str] max_tasks: Maximum Tasks
+        :param pulumi.Input[Union[str, 'DataFormatType']] output_format: Kafka Output Data Format Type
+        :param pulumi.Input[str] service_account_id: Kafka Service Account Id
+        :param pulumi.Input[str] time_interval: Time Interval
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] topics: Kafka topics list
+        :param pulumi.Input[str] topics_dir: Kafka topics directory
+        """
+        pulumi.set(__self__, "partner_connector_type", 'KafkaAzureCosmosDBSink')
+        if api_key is not None:
+            pulumi.set(__self__, "api_key", api_key)
+        if api_secret is not None:
+            pulumi.set(__self__, "api_secret", api_secret)
+        if auth_type is not None:
+            pulumi.set(__self__, "auth_type", auth_type)
+        if flush_size is not None:
+            pulumi.set(__self__, "flush_size", flush_size)
+        if input_format is not None:
+            pulumi.set(__self__, "input_format", input_format)
+        if max_tasks is not None:
+            pulumi.set(__self__, "max_tasks", max_tasks)
+        if output_format is not None:
+            pulumi.set(__self__, "output_format", output_format)
+        if service_account_id is not None:
+            pulumi.set(__self__, "service_account_id", service_account_id)
+        if time_interval is not None:
+            pulumi.set(__self__, "time_interval", time_interval)
+        if topics is not None:
+            pulumi.set(__self__, "topics", topics)
+        if topics_dir is not None:
+            pulumi.set(__self__, "topics_dir", topics_dir)
+
+    @property
+    @pulumi.getter(name="partnerConnectorType")
+    def partner_connector_type(self) -> pulumi.Input[str]:
+        """
+        Partner Connector type.
+        Expected value is 'KafkaAzureCosmosDBSink'.
+        """
+        return pulumi.get(self, "partner_connector_type")
+
+    @partner_connector_type.setter
+    def partner_connector_type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "partner_connector_type", value)
+
+    @property
+    @pulumi.getter(name="apiKey")
+    def api_key(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka API Key
+        """
+        return pulumi.get(self, "api_key")
+
+    @api_key.setter
+    def api_key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_key", value)
+
+    @property
+    @pulumi.getter(name="apiSecret")
+    def api_secret(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka API Key Secret
+        """
+        return pulumi.get(self, "api_secret")
+
+    @api_secret.setter
+    def api_secret(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_secret", value)
+
+    @property
+    @pulumi.getter(name="authType")
+    def auth_type(self) -> Optional[pulumi.Input[Union[str, 'AuthType']]]:
+        """
+        Kafka Auth Type
+        """
+        return pulumi.get(self, "auth_type")
+
+    @auth_type.setter
+    def auth_type(self, value: Optional[pulumi.Input[Union[str, 'AuthType']]]):
+        pulumi.set(self, "auth_type", value)
+
+    @property
+    @pulumi.getter(name="flushSize")
+    def flush_size(self) -> Optional[pulumi.Input[str]]:
+        """
+        Flush size
+        """
+        return pulumi.get(self, "flush_size")
+
+    @flush_size.setter
+    def flush_size(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "flush_size", value)
+
+    @property
+    @pulumi.getter(name="inputFormat")
+    def input_format(self) -> Optional[pulumi.Input[Union[str, 'DataFormatType']]]:
+        """
+        Kafka Input Data Format Type
+        """
+        return pulumi.get(self, "input_format")
+
+    @input_format.setter
+    def input_format(self, value: Optional[pulumi.Input[Union[str, 'DataFormatType']]]):
+        pulumi.set(self, "input_format", value)
+
+    @property
+    @pulumi.getter(name="maxTasks")
+    def max_tasks(self) -> Optional[pulumi.Input[str]]:
+        """
+        Maximum Tasks
+        """
+        return pulumi.get(self, "max_tasks")
+
+    @max_tasks.setter
+    def max_tasks(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "max_tasks", value)
+
+    @property
+    @pulumi.getter(name="outputFormat")
+    def output_format(self) -> Optional[pulumi.Input[Union[str, 'DataFormatType']]]:
+        """
+        Kafka Output Data Format Type
+        """
+        return pulumi.get(self, "output_format")
+
+    @output_format.setter
+    def output_format(self, value: Optional[pulumi.Input[Union[str, 'DataFormatType']]]):
+        pulumi.set(self, "output_format", value)
+
+    @property
+    @pulumi.getter(name="serviceAccountId")
+    def service_account_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka Service Account Id
+        """
+        return pulumi.get(self, "service_account_id")
+
+    @service_account_id.setter
+    def service_account_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "service_account_id", value)
+
+    @property
+    @pulumi.getter(name="timeInterval")
+    def time_interval(self) -> Optional[pulumi.Input[str]]:
+        """
+        Time Interval
+        """
+        return pulumi.get(self, "time_interval")
+
+    @time_interval.setter
+    def time_interval(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_interval", value)
+
+    @property
+    @pulumi.getter
+    def topics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Kafka topics list
+        """
+        return pulumi.get(self, "topics")
+
+    @topics.setter
+    def topics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "topics", value)
+
+    @property
+    @pulumi.getter(name="topicsDir")
+    def topics_dir(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka topics directory
+        """
+        return pulumi.get(self, "topics_dir")
+
+    @topics_dir.setter
+    def topics_dir(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "topics_dir", value)
+
+
+if not MYPY:
+    class KafkaAzureCosmosDBSourceConnectorInfoArgsDict(TypedDict):
+        """
+        The partner connector type is KafkaAzureCosmosDBSource
+        """
+        partner_connector_type: pulumi.Input[str]
+        """
+        Partner Connector type.
+        Expected value is 'KafkaAzureCosmosDBSource'.
+        """
+        api_key: NotRequired[pulumi.Input[str]]
+        """
+        Kafka API Key
+        """
+        api_secret: NotRequired[pulumi.Input[str]]
+        """
+        Kafka API Secret
+        """
+        auth_type: NotRequired[pulumi.Input[Union[str, 'AuthType']]]
+        """
+        Kafka Auth Type
+        """
+        input_format: NotRequired[pulumi.Input[Union[str, 'DataFormatType']]]
+        """
+        Kafka Input Data Format Type
+        """
+        max_tasks: NotRequired[pulumi.Input[str]]
+        """
+        Maximum Tasks
+        """
+        output_format: NotRequired[pulumi.Input[Union[str, 'DataFormatType']]]
+        """
+        Kafka Output Data Format Type
+        """
+        service_account_id: NotRequired[pulumi.Input[str]]
+        """
+        Kafka Service Account Id
+        """
+        topic_regex: NotRequired[pulumi.Input[str]]
+        """
+        Kafka topics Regex pattern
+        """
+        topics_dir: NotRequired[pulumi.Input[str]]
+        """
+        Kafka topics directory
+        """
+elif False:
+    KafkaAzureCosmosDBSourceConnectorInfoArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class KafkaAzureCosmosDBSourceConnectorInfoArgs:
+    def __init__(__self__, *,
+                 partner_connector_type: pulumi.Input[str],
+                 api_key: Optional[pulumi.Input[str]] = None,
+                 api_secret: Optional[pulumi.Input[str]] = None,
+                 auth_type: Optional[pulumi.Input[Union[str, 'AuthType']]] = None,
+                 input_format: Optional[pulumi.Input[Union[str, 'DataFormatType']]] = None,
+                 max_tasks: Optional[pulumi.Input[str]] = None,
+                 output_format: Optional[pulumi.Input[Union[str, 'DataFormatType']]] = None,
+                 service_account_id: Optional[pulumi.Input[str]] = None,
+                 topic_regex: Optional[pulumi.Input[str]] = None,
+                 topics_dir: Optional[pulumi.Input[str]] = None):
+        """
+        The partner connector type is KafkaAzureCosmosDBSource
+        :param pulumi.Input[str] partner_connector_type: Partner Connector type.
+               Expected value is 'KafkaAzureCosmosDBSource'.
+        :param pulumi.Input[str] api_key: Kafka API Key
+        :param pulumi.Input[str] api_secret: Kafka API Secret
+        :param pulumi.Input[Union[str, 'AuthType']] auth_type: Kafka Auth Type
+        :param pulumi.Input[Union[str, 'DataFormatType']] input_format: Kafka Input Data Format Type
+        :param pulumi.Input[str] max_tasks: Maximum Tasks
+        :param pulumi.Input[Union[str, 'DataFormatType']] output_format: Kafka Output Data Format Type
+        :param pulumi.Input[str] service_account_id: Kafka Service Account Id
+        :param pulumi.Input[str] topic_regex: Kafka topics Regex pattern
+        :param pulumi.Input[str] topics_dir: Kafka topics directory
+        """
+        pulumi.set(__self__, "partner_connector_type", 'KafkaAzureCosmosDBSource')
+        if api_key is not None:
+            pulumi.set(__self__, "api_key", api_key)
+        if api_secret is not None:
+            pulumi.set(__self__, "api_secret", api_secret)
+        if auth_type is not None:
+            pulumi.set(__self__, "auth_type", auth_type)
+        if input_format is not None:
+            pulumi.set(__self__, "input_format", input_format)
+        if max_tasks is not None:
+            pulumi.set(__self__, "max_tasks", max_tasks)
+        if output_format is not None:
+            pulumi.set(__self__, "output_format", output_format)
+        if service_account_id is not None:
+            pulumi.set(__self__, "service_account_id", service_account_id)
+        if topic_regex is not None:
+            pulumi.set(__self__, "topic_regex", topic_regex)
+        if topics_dir is not None:
+            pulumi.set(__self__, "topics_dir", topics_dir)
+
+    @property
+    @pulumi.getter(name="partnerConnectorType")
+    def partner_connector_type(self) -> pulumi.Input[str]:
+        """
+        Partner Connector type.
+        Expected value is 'KafkaAzureCosmosDBSource'.
+        """
+        return pulumi.get(self, "partner_connector_type")
+
+    @partner_connector_type.setter
+    def partner_connector_type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "partner_connector_type", value)
+
+    @property
+    @pulumi.getter(name="apiKey")
+    def api_key(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka API Key
+        """
+        return pulumi.get(self, "api_key")
+
+    @api_key.setter
+    def api_key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_key", value)
+
+    @property
+    @pulumi.getter(name="apiSecret")
+    def api_secret(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka API Secret
+        """
+        return pulumi.get(self, "api_secret")
+
+    @api_secret.setter
+    def api_secret(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_secret", value)
+
+    @property
+    @pulumi.getter(name="authType")
+    def auth_type(self) -> Optional[pulumi.Input[Union[str, 'AuthType']]]:
+        """
+        Kafka Auth Type
+        """
+        return pulumi.get(self, "auth_type")
+
+    @auth_type.setter
+    def auth_type(self, value: Optional[pulumi.Input[Union[str, 'AuthType']]]):
+        pulumi.set(self, "auth_type", value)
+
+    @property
+    @pulumi.getter(name="inputFormat")
+    def input_format(self) -> Optional[pulumi.Input[Union[str, 'DataFormatType']]]:
+        """
+        Kafka Input Data Format Type
+        """
+        return pulumi.get(self, "input_format")
+
+    @input_format.setter
+    def input_format(self, value: Optional[pulumi.Input[Union[str, 'DataFormatType']]]):
+        pulumi.set(self, "input_format", value)
+
+    @property
+    @pulumi.getter(name="maxTasks")
+    def max_tasks(self) -> Optional[pulumi.Input[str]]:
+        """
+        Maximum Tasks
+        """
+        return pulumi.get(self, "max_tasks")
+
+    @max_tasks.setter
+    def max_tasks(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "max_tasks", value)
+
+    @property
+    @pulumi.getter(name="outputFormat")
+    def output_format(self) -> Optional[pulumi.Input[Union[str, 'DataFormatType']]]:
+        """
+        Kafka Output Data Format Type
+        """
+        return pulumi.get(self, "output_format")
+
+    @output_format.setter
+    def output_format(self, value: Optional[pulumi.Input[Union[str, 'DataFormatType']]]):
+        pulumi.set(self, "output_format", value)
+
+    @property
+    @pulumi.getter(name="serviceAccountId")
+    def service_account_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka Service Account Id
+        """
+        return pulumi.get(self, "service_account_id")
+
+    @service_account_id.setter
+    def service_account_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "service_account_id", value)
+
+    @property
+    @pulumi.getter(name="topicRegex")
+    def topic_regex(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka topics Regex pattern
+        """
+        return pulumi.get(self, "topic_regex")
+
+    @topic_regex.setter
+    def topic_regex(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "topic_regex", value)
+
+    @property
+    @pulumi.getter(name="topicsDir")
+    def topics_dir(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka topics directory
+        """
+        return pulumi.get(self, "topics_dir")
+
+    @topics_dir.setter
+    def topics_dir(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "topics_dir", value)
+
+
+if not MYPY:
+    class KafkaAzureSynapseAnalyticsSinkConnectorInfoArgsDict(TypedDict):
+        """
+        The partner connector type is KafkaAzureSynapseAnalyticsSink
+        """
+        partner_connector_type: pulumi.Input[str]
+        """
+        Partner Connector type.
+        Expected value is 'KafkaAzureSynapseAnalyticsSink'.
+        """
+        api_key: NotRequired[pulumi.Input[str]]
+        """
+        Kafka API Key
+        """
+        api_secret: NotRequired[pulumi.Input[str]]
+        """
+        Kafka API Key Secret
+        """
+        auth_type: NotRequired[pulumi.Input[Union[str, 'AuthType']]]
+        """
+        Kafka Auth Type
+        """
+        flush_size: NotRequired[pulumi.Input[str]]
+        """
+        Flush size
+        """
+        input_format: NotRequired[pulumi.Input[Union[str, 'DataFormatType']]]
+        """
+        Kafka Input Data Format Type
+        """
+        max_tasks: NotRequired[pulumi.Input[str]]
+        """
+        Maximum Tasks
+        """
+        output_format: NotRequired[pulumi.Input[Union[str, 'DataFormatType']]]
+        """
+        Kafka Output Data Format Type
+        """
+        service_account_id: NotRequired[pulumi.Input[str]]
+        """
+        Kafka Service Account Id
+        """
+        time_interval: NotRequired[pulumi.Input[str]]
+        """
+        Time Interval
+        """
+        topics: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Kafka topics list
+        """
+        topics_dir: NotRequired[pulumi.Input[str]]
+        """
+        Kafka topics directory
+        """
+elif False:
+    KafkaAzureSynapseAnalyticsSinkConnectorInfoArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class KafkaAzureSynapseAnalyticsSinkConnectorInfoArgs:
+    def __init__(__self__, *,
+                 partner_connector_type: pulumi.Input[str],
+                 api_key: Optional[pulumi.Input[str]] = None,
+                 api_secret: Optional[pulumi.Input[str]] = None,
+                 auth_type: Optional[pulumi.Input[Union[str, 'AuthType']]] = None,
+                 flush_size: Optional[pulumi.Input[str]] = None,
+                 input_format: Optional[pulumi.Input[Union[str, 'DataFormatType']]] = None,
+                 max_tasks: Optional[pulumi.Input[str]] = None,
+                 output_format: Optional[pulumi.Input[Union[str, 'DataFormatType']]] = None,
+                 service_account_id: Optional[pulumi.Input[str]] = None,
+                 time_interval: Optional[pulumi.Input[str]] = None,
+                 topics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 topics_dir: Optional[pulumi.Input[str]] = None):
+        """
+        The partner connector type is KafkaAzureSynapseAnalyticsSink
+        :param pulumi.Input[str] partner_connector_type: Partner Connector type.
+               Expected value is 'KafkaAzureSynapseAnalyticsSink'.
+        :param pulumi.Input[str] api_key: Kafka API Key
+        :param pulumi.Input[str] api_secret: Kafka API Key Secret
+        :param pulumi.Input[Union[str, 'AuthType']] auth_type: Kafka Auth Type
+        :param pulumi.Input[str] flush_size: Flush size
+        :param pulumi.Input[Union[str, 'DataFormatType']] input_format: Kafka Input Data Format Type
+        :param pulumi.Input[str] max_tasks: Maximum Tasks
+        :param pulumi.Input[Union[str, 'DataFormatType']] output_format: Kafka Output Data Format Type
+        :param pulumi.Input[str] service_account_id: Kafka Service Account Id
+        :param pulumi.Input[str] time_interval: Time Interval
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] topics: Kafka topics list
+        :param pulumi.Input[str] topics_dir: Kafka topics directory
+        """
+        pulumi.set(__self__, "partner_connector_type", 'KafkaAzureSynapseAnalyticsSink')
+        if api_key is not None:
+            pulumi.set(__self__, "api_key", api_key)
+        if api_secret is not None:
+            pulumi.set(__self__, "api_secret", api_secret)
+        if auth_type is not None:
+            pulumi.set(__self__, "auth_type", auth_type)
+        if flush_size is not None:
+            pulumi.set(__self__, "flush_size", flush_size)
+        if input_format is not None:
+            pulumi.set(__self__, "input_format", input_format)
+        if max_tasks is not None:
+            pulumi.set(__self__, "max_tasks", max_tasks)
+        if output_format is not None:
+            pulumi.set(__self__, "output_format", output_format)
+        if service_account_id is not None:
+            pulumi.set(__self__, "service_account_id", service_account_id)
+        if time_interval is not None:
+            pulumi.set(__self__, "time_interval", time_interval)
+        if topics is not None:
+            pulumi.set(__self__, "topics", topics)
+        if topics_dir is not None:
+            pulumi.set(__self__, "topics_dir", topics_dir)
+
+    @property
+    @pulumi.getter(name="partnerConnectorType")
+    def partner_connector_type(self) -> pulumi.Input[str]:
+        """
+        Partner Connector type.
+        Expected value is 'KafkaAzureSynapseAnalyticsSink'.
+        """
+        return pulumi.get(self, "partner_connector_type")
+
+    @partner_connector_type.setter
+    def partner_connector_type(self, value: pulumi.Input[str]):
+        pulumi.set(self, "partner_connector_type", value)
+
+    @property
+    @pulumi.getter(name="apiKey")
+    def api_key(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka API Key
+        """
+        return pulumi.get(self, "api_key")
+
+    @api_key.setter
+    def api_key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_key", value)
+
+    @property
+    @pulumi.getter(name="apiSecret")
+    def api_secret(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka API Key Secret
+        """
+        return pulumi.get(self, "api_secret")
+
+    @api_secret.setter
+    def api_secret(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_secret", value)
+
+    @property
+    @pulumi.getter(name="authType")
+    def auth_type(self) -> Optional[pulumi.Input[Union[str, 'AuthType']]]:
+        """
+        Kafka Auth Type
+        """
+        return pulumi.get(self, "auth_type")
+
+    @auth_type.setter
+    def auth_type(self, value: Optional[pulumi.Input[Union[str, 'AuthType']]]):
+        pulumi.set(self, "auth_type", value)
+
+    @property
+    @pulumi.getter(name="flushSize")
+    def flush_size(self) -> Optional[pulumi.Input[str]]:
+        """
+        Flush size
+        """
+        return pulumi.get(self, "flush_size")
+
+    @flush_size.setter
+    def flush_size(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "flush_size", value)
+
+    @property
+    @pulumi.getter(name="inputFormat")
+    def input_format(self) -> Optional[pulumi.Input[Union[str, 'DataFormatType']]]:
+        """
+        Kafka Input Data Format Type
+        """
+        return pulumi.get(self, "input_format")
+
+    @input_format.setter
+    def input_format(self, value: Optional[pulumi.Input[Union[str, 'DataFormatType']]]):
+        pulumi.set(self, "input_format", value)
+
+    @property
+    @pulumi.getter(name="maxTasks")
+    def max_tasks(self) -> Optional[pulumi.Input[str]]:
+        """
+        Maximum Tasks
+        """
+        return pulumi.get(self, "max_tasks")
+
+    @max_tasks.setter
+    def max_tasks(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "max_tasks", value)
+
+    @property
+    @pulumi.getter(name="outputFormat")
+    def output_format(self) -> Optional[pulumi.Input[Union[str, 'DataFormatType']]]:
+        """
+        Kafka Output Data Format Type
+        """
+        return pulumi.get(self, "output_format")
+
+    @output_format.setter
+    def output_format(self, value: Optional[pulumi.Input[Union[str, 'DataFormatType']]]):
+        pulumi.set(self, "output_format", value)
+
+    @property
+    @pulumi.getter(name="serviceAccountId")
+    def service_account_id(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka Service Account Id
+        """
+        return pulumi.get(self, "service_account_id")
+
+    @service_account_id.setter
+    def service_account_id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "service_account_id", value)
+
+    @property
+    @pulumi.getter(name="timeInterval")
+    def time_interval(self) -> Optional[pulumi.Input[str]]:
+        """
+        Time Interval
+        """
+        return pulumi.get(self, "time_interval")
+
+    @time_interval.setter
+    def time_interval(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "time_interval", value)
+
+    @property
+    @pulumi.getter
+    def topics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Kafka topics list
+        """
+        return pulumi.get(self, "topics")
+
+    @topics.setter
+    def topics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "topics", value)
+
+    @property
+    @pulumi.getter(name="topicsDir")
+    def topics_dir(self) -> Optional[pulumi.Input[str]]:
+        """
+        Kafka topics directory
+        """
+        return pulumi.get(self, "topics_dir")
+
+    @topics_dir.setter
+    def topics_dir(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "topics_dir", value)
+
+
 if not MYPY:
     class OfferDetailArgsDict(TypedDict):
         """
-        Confluent Offer detail
+        Confluent Offer detail
+        """
+        id: pulumi.Input[str]
+        """
+        Offer Id
+        """
+        plan_id: pulumi.Input[str]
+        """
+        Offer Plan Id
+        """
+        plan_name: pulumi.Input[str]
+        """
+        Offer Plan Name
+        """
+        publisher_id: pulumi.Input[str]
+        """
+        Publisher Id
+        """
+        term_unit: pulumi.Input[str]
+        """
+        Offer Plan Term unit
+        """
+elif False:
+    OfferDetailArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class OfferDetailArgs:
+    def __init__(__self__, *,
+                 id: pulumi.Input[str],
+                 plan_id: pulumi.Input[str],
+                 plan_name: pulumi.Input[str],
+                 publisher_id: pulumi.Input[str],
+                 term_unit: pulumi.Input[str]):
+        """
+        Confluent Offer detail
+        :param pulumi.Input[str] id: Offer Id
+        :param pulumi.Input[str] plan_id: Offer Plan Id
+        :param pulumi.Input[str] plan_name: Offer Plan Name
+        :param pulumi.Input[str] publisher_id: Publisher Id
+        :param pulumi.Input[str] term_unit: Offer Plan Term unit
+        """
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "plan_id", plan_id)
+        pulumi.set(__self__, "plan_name", plan_name)
+        pulumi.set(__self__, "publisher_id", publisher_id)
+        pulumi.set(__self__, "term_unit", term_unit)
+
+    @property
+    @pulumi.getter
+    def id(self) -> pulumi.Input[str]:
+        """
+        Offer Id
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter(name="planId")
+    def plan_id(self) -> pulumi.Input[str]:
+        """
+        Offer Plan Id
+        """
+        return pulumi.get(self, "plan_id")
+
+    @plan_id.setter
+    def plan_id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "plan_id", value)
+
+    @property
+    @pulumi.getter(name="planName")
+    def plan_name(self) -> pulumi.Input[str]:
+        """
+        Offer Plan Name
+        """
+        return pulumi.get(self, "plan_name")
+
+    @plan_name.setter
+    def plan_name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "plan_name", value)
+
+    @property
+    @pulumi.getter(name="publisherId")
+    def publisher_id(self) -> pulumi.Input[str]:
+        """
+        Publisher Id
+        """
+        return pulumi.get(self, "publisher_id")
+
+    @publisher_id.setter
+    def publisher_id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "publisher_id", value)
+
+    @property
+    @pulumi.getter(name="termUnit")
+    def term_unit(self) -> pulumi.Input[str]:
+        """
+        Offer Plan Term unit
+        """
+        return pulumi.get(self, "term_unit")
+
+    @term_unit.setter
+    def term_unit(self, value: pulumi.Input[str]):
+        pulumi.set(self, "term_unit", value)
+
+
+if not MYPY:
+    class SCClusterByokEntityArgsDict(TypedDict):
+        """
+        The network associated with this object
+        """
+        id: NotRequired[pulumi.Input[str]]
+        """
+        ID of the referred resource
+        """
+        related: NotRequired[pulumi.Input[str]]
+        """
+        API URL for accessing or modifying the referred object
+        """
+        resource_name: NotRequired[pulumi.Input[str]]
+        """
+        CRN reference to the referred resource
+        """
+elif False:
+    SCClusterByokEntityArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SCClusterByokEntityArgs:
+    def __init__(__self__, *,
+                 id: Optional[pulumi.Input[str]] = None,
+                 related: Optional[pulumi.Input[str]] = None,
+                 resource_name: Optional[pulumi.Input[str]] = None):
+        """
+        The network associated with this object
+        :param pulumi.Input[str] id: ID of the referred resource
+        :param pulumi.Input[str] related: API URL for accessing or modifying the referred object
+        :param pulumi.Input[str] resource_name: CRN reference to the referred resource
+        """
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if related is not None:
+            pulumi.set(__self__, "related", related)
+        if resource_name is not None:
+            pulumi.set(__self__, "resource_name", resource_name)
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[pulumi.Input[str]]:
+        """
+        ID of the referred resource
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter
+    def related(self) -> Optional[pulumi.Input[str]]:
+        """
+        API URL for accessing or modifying the referred object
+        """
+        return pulumi.get(self, "related")
+
+    @related.setter
+    def related(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "related", value)
+
+    @property
+    @pulumi.getter(name="resourceName")
+    def resource_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        CRN reference to the referred resource
+        """
+        return pulumi.get(self, "resource_name")
+
+    @resource_name.setter
+    def resource_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "resource_name", value)
+
+
+if not MYPY:
+    class SCClusterNetworkEnvironmentEntityArgsDict(TypedDict):
+        """
+        The environment or the network to which cluster belongs
+        """
+        environment: NotRequired[pulumi.Input[str]]
+        """
+        Environment of the referred resource
+        """
+        id: NotRequired[pulumi.Input[str]]
+        """
+        ID of the referred resource
+        """
+        related: NotRequired[pulumi.Input[str]]
+        """
+        API URL for accessing or modifying the referred object
+        """
+        resource_name: NotRequired[pulumi.Input[str]]
+        """
+        CRN reference to the referred resource
+        """
+elif False:
+    SCClusterNetworkEnvironmentEntityArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SCClusterNetworkEnvironmentEntityArgs:
+    def __init__(__self__, *,
+                 environment: Optional[pulumi.Input[str]] = None,
+                 id: Optional[pulumi.Input[str]] = None,
+                 related: Optional[pulumi.Input[str]] = None,
+                 resource_name: Optional[pulumi.Input[str]] = None):
+        """
+        The environment or the network to which cluster belongs
+        :param pulumi.Input[str] environment: Environment of the referred resource
+        :param pulumi.Input[str] id: ID of the referred resource
+        :param pulumi.Input[str] related: API URL for accessing or modifying the referred object
+        :param pulumi.Input[str] resource_name: CRN reference to the referred resource
+        """
+        if environment is not None:
+            pulumi.set(__self__, "environment", environment)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if related is not None:
+            pulumi.set(__self__, "related", related)
+        if resource_name is not None:
+            pulumi.set(__self__, "resource_name", resource_name)
+
+    @property
+    @pulumi.getter
+    def environment(self) -> Optional[pulumi.Input[str]]:
+        """
+        Environment of the referred resource
+        """
+        return pulumi.get(self, "environment")
+
+    @environment.setter
+    def environment(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "environment", value)
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[pulumi.Input[str]]:
+        """
+        ID of the referred resource
+        """
+        return pulumi.get(self, "id")
+
+    @id.setter
+    def id(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "id", value)
+
+    @property
+    @pulumi.getter
+    def related(self) -> Optional[pulumi.Input[str]]:
+        """
+        API URL for accessing or modifying the referred object
+        """
+        return pulumi.get(self, "related")
+
+    @related.setter
+    def related(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "related", value)
+
+    @property
+    @pulumi.getter(name="resourceName")
+    def resource_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        CRN reference to the referred resource
+        """
+        return pulumi.get(self, "resource_name")
+
+    @resource_name.setter
+    def resource_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "resource_name", value)
+
+
+if not MYPY:
+    class SCClusterSpecEntityArgsDict(TypedDict):
+        """
+        Spec of the cluster record
+        """
+        api_endpoint: NotRequired[pulumi.Input[str]]
+        """
+        The Kafka API cluster endpoint
+        """
+        availability: NotRequired[pulumi.Input[str]]
+        """
+        The availability zone configuration of the cluster
+        """
+        byok: NotRequired[pulumi.Input['SCClusterByokEntityArgsDict']]
+        """
+        Specification of the cluster byok
+        """
+        cloud: NotRequired[pulumi.Input[str]]
+        """
+        The cloud service provider 
+        """
+        config: NotRequired[pulumi.Input['ClusterConfigEntityArgsDict']]
+        """
+        Specification of the cluster configuration
         """
-        id: pulumi.Input[str]
+        environment: NotRequired[pulumi.Input['SCClusterNetworkEnvironmentEntityArgsDict']]
         """
-        Offer Id
+        Specification of the cluster environment
         """
-        plan_id: pulumi.Input[str]
+        http_endpoint: NotRequired[pulumi.Input[str]]
         """
-        Offer Plan Id
+        The cluster HTTP request URL.
         """
-        plan_name: pulumi.Input[str]
+        kafka_bootstrap_endpoint: NotRequired[pulumi.Input[str]]
         """
-        Offer Plan Name
+        The bootstrap endpoint used by Kafka clients to connect to the cluster
         """
-        publisher_id: pulumi.Input[str]
+        name: NotRequired[pulumi.Input[str]]
         """
-        Publisher Id
+        The name of the cluster
         """
-        term_unit: pulumi.Input[str]
+        network: NotRequired[pulumi.Input['SCClusterNetworkEnvironmentEntityArgsDict']]
         """
-        Offer Plan Term unit
+        Specification of the cluster network
+        """
+        package: NotRequired[pulumi.Input[Union[str, 'Package']]]
+        """
+        Stream governance configuration
+        """
+        region: NotRequired[pulumi.Input[str]]
+        """
+        The cloud service provider region
+        """
+        zone: NotRequired[pulumi.Input[str]]
+        """
+        type of zone availability
         """
 elif False:
-    OfferDetailArgsDict: TypeAlias = Mapping[str, Any]
+    SCClusterSpecEntityArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
-class OfferDetailArgs:
+class SCClusterSpecEntityArgs:
     def __init__(__self__, *,
-                 id: pulumi.Input[str],
-                 plan_id: pulumi.Input[str],
-                 plan_name: pulumi.Input[str],
-                 publisher_id: pulumi.Input[str],
-                 term_unit: pulumi.Input[str]):
+                 api_endpoint: Optional[pulumi.Input[str]] = None,
+                 availability: Optional[pulumi.Input[str]] = None,
+                 byok: Optional[pulumi.Input['SCClusterByokEntityArgs']] = None,
+                 cloud: Optional[pulumi.Input[str]] = None,
+                 config: Optional[pulumi.Input['ClusterConfigEntityArgs']] = None,
+                 environment: Optional[pulumi.Input['SCClusterNetworkEnvironmentEntityArgs']] = None,
+                 http_endpoint: Optional[pulumi.Input[str]] = None,
+                 kafka_bootstrap_endpoint: Optional[pulumi.Input[str]] = None,
+                 name: Optional[pulumi.Input[str]] = None,
+                 network: Optional[pulumi.Input['SCClusterNetworkEnvironmentEntityArgs']] = None,
+                 package: Optional[pulumi.Input[Union[str, 'Package']]] = None,
+                 region: Optional[pulumi.Input[str]] = None,
+                 zone: Optional[pulumi.Input[str]] = None):
         """
-        Confluent Offer detail
-        :param pulumi.Input[str] id: Offer Id
-        :param pulumi.Input[str] plan_id: Offer Plan Id
-        :param pulumi.Input[str] plan_name: Offer Plan Name
-        :param pulumi.Input[str] publisher_id: Publisher Id
-        :param pulumi.Input[str] term_unit: Offer Plan Term unit
+        Spec of the cluster record
+        :param pulumi.Input[str] api_endpoint: The Kafka API cluster endpoint
+        :param pulumi.Input[str] availability: The availability zone configuration of the cluster
+        :param pulumi.Input['SCClusterByokEntityArgs'] byok: Specification of the cluster byok
+        :param pulumi.Input[str] cloud: The cloud service provider 
+        :param pulumi.Input['ClusterConfigEntityArgs'] config: Specification of the cluster configuration
+        :param pulumi.Input['SCClusterNetworkEnvironmentEntityArgs'] environment: Specification of the cluster environment
+        :param pulumi.Input[str] http_endpoint: The cluster HTTP request URL.
+        :param pulumi.Input[str] kafka_bootstrap_endpoint: The bootstrap endpoint used by Kafka clients to connect to the cluster
+        :param pulumi.Input[str] name: The name of the cluster
+        :param pulumi.Input['SCClusterNetworkEnvironmentEntityArgs'] network: Specification of the cluster network
+        :param pulumi.Input[Union[str, 'Package']] package: Stream governance configuration
+        :param pulumi.Input[str] region: The cloud service provider region
+        :param pulumi.Input[str] zone: type of zone availability
         """
-        pulumi.set(__self__, "id", id)
-        pulumi.set(__self__, "plan_id", plan_id)
-        pulumi.set(__self__, "plan_name", plan_name)
-        pulumi.set(__self__, "publisher_id", publisher_id)
-        pulumi.set(__self__, "term_unit", term_unit)
+        if api_endpoint is not None:
+            pulumi.set(__self__, "api_endpoint", api_endpoint)
+        if availability is not None:
+            pulumi.set(__self__, "availability", availability)
+        if byok is not None:
+            pulumi.set(__self__, "byok", byok)
+        if cloud is not None:
+            pulumi.set(__self__, "cloud", cloud)
+        if config is not None:
+            pulumi.set(__self__, "config", config)
+        if environment is not None:
+            pulumi.set(__self__, "environment", environment)
+        if http_endpoint is not None:
+            pulumi.set(__self__, "http_endpoint", http_endpoint)
+        if kafka_bootstrap_endpoint is not None:
+            pulumi.set(__self__, "kafka_bootstrap_endpoint", kafka_bootstrap_endpoint)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if network is not None:
+            pulumi.set(__self__, "network", network)
+        if package is not None:
+            pulumi.set(__self__, "package", package)
+        if region is not None:
+            pulumi.set(__self__, "region", region)
+        if zone is not None:
+            pulumi.set(__self__, "zone", zone)
+
+    @property
+    @pulumi.getter(name="apiEndpoint")
+    def api_endpoint(self) -> Optional[pulumi.Input[str]]:
+        """
+        The Kafka API cluster endpoint
+        """
+        return pulumi.get(self, "api_endpoint")
+
+    @api_endpoint.setter
+    def api_endpoint(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "api_endpoint", value)
 
     @property
     @pulumi.getter
-    def id(self) -> pulumi.Input[str]:
+    def availability(self) -> Optional[pulumi.Input[str]]:
         """
-        Offer Id
+        The availability zone configuration of the cluster
         """
-        return pulumi.get(self, "id")
+        return pulumi.get(self, "availability")
 
-    @id.setter
-    def id(self, value: pulumi.Input[str]):
-        pulumi.set(self, "id", value)
+    @availability.setter
+    def availability(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "availability", value)
 
     @property
-    @pulumi.getter(name="planId")
-    def plan_id(self) -> pulumi.Input[str]:
+    @pulumi.getter
+    def byok(self) -> Optional[pulumi.Input['SCClusterByokEntityArgs']]:
         """
-        Offer Plan Id
+        Specification of the cluster byok
         """
-        return pulumi.get(self, "plan_id")
+        return pulumi.get(self, "byok")
 
-    @plan_id.setter
-    def plan_id(self, value: pulumi.Input[str]):
-        pulumi.set(self, "plan_id", value)
+    @byok.setter
+    def byok(self, value: Optional[pulumi.Input['SCClusterByokEntityArgs']]):
+        pulumi.set(self, "byok", value)
 
     @property
-    @pulumi.getter(name="planName")
-    def plan_name(self) -> pulumi.Input[str]:
+    @pulumi.getter
+    def cloud(self) -> Optional[pulumi.Input[str]]:
         """
-        Offer Plan Name
+        The cloud service provider 
         """
-        return pulumi.get(self, "plan_name")
+        return pulumi.get(self, "cloud")
 
-    @plan_name.setter
-    def plan_name(self, value: pulumi.Input[str]):
-        pulumi.set(self, "plan_name", value)
+    @cloud.setter
+    def cloud(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "cloud", value)
 
     @property
-    @pulumi.getter(name="publisherId")
-    def publisher_id(self) -> pulumi.Input[str]:
+    @pulumi.getter
+    def config(self) -> Optional[pulumi.Input['ClusterConfigEntityArgs']]:
         """
-        Publisher Id
+        Specification of the cluster configuration
         """
-        return pulumi.get(self, "publisher_id")
+        return pulumi.get(self, "config")
 
-    @publisher_id.setter
-    def publisher_id(self, value: pulumi.Input[str]):
-        pulumi.set(self, "publisher_id", value)
+    @config.setter
+    def config(self, value: Optional[pulumi.Input['ClusterConfigEntityArgs']]):
+        pulumi.set(self, "config", value)
 
     @property
-    @pulumi.getter(name="termUnit")
-    def term_unit(self) -> pulumi.Input[str]:
+    @pulumi.getter
+    def environment(self) -> Optional[pulumi.Input['SCClusterNetworkEnvironmentEntityArgs']]:
         """
-        Offer Plan Term unit
+        Specification of the cluster environment
         """
-        return pulumi.get(self, "term_unit")
+        return pulumi.get(self, "environment")
 
-    @term_unit.setter
-    def term_unit(self, value: pulumi.Input[str]):
-        pulumi.set(self, "term_unit", value)
+    @environment.setter
+    def environment(self, value: Optional[pulumi.Input['SCClusterNetworkEnvironmentEntityArgs']]):
+        pulumi.set(self, "environment", value)
+
+    @property
+    @pulumi.getter(name="httpEndpoint")
+    def http_endpoint(self) -> Optional[pulumi.Input[str]]:
+        """
+        The cluster HTTP request URL.
+        """
+        return pulumi.get(self, "http_endpoint")
+
+    @http_endpoint.setter
+    def http_endpoint(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "http_endpoint", value)
+
+    @property
+    @pulumi.getter(name="kafkaBootstrapEndpoint")
+    def kafka_bootstrap_endpoint(self) -> Optional[pulumi.Input[str]]:
+        """
+        The bootstrap endpoint used by Kafka clients to connect to the cluster
+        """
+        return pulumi.get(self, "kafka_bootstrap_endpoint")
+
+    @kafka_bootstrap_endpoint.setter
+    def kafka_bootstrap_endpoint(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "kafka_bootstrap_endpoint", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        The name of the cluster
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def network(self) -> Optional[pulumi.Input['SCClusterNetworkEnvironmentEntityArgs']]:
+        """
+        Specification of the cluster network
+        """
+        return pulumi.get(self, "network")
+
+    @network.setter
+    def network(self, value: Optional[pulumi.Input['SCClusterNetworkEnvironmentEntityArgs']]):
+        pulumi.set(self, "network", value)
+
+    @property
+    @pulumi.getter
+    def package(self) -> Optional[pulumi.Input[Union[str, 'Package']]]:
+        """
+        Stream governance configuration
+        """
+        return pulumi.get(self, "package")
+
+    @package.setter
+    def package(self, value: Optional[pulumi.Input[Union[str, 'Package']]]):
+        pulumi.set(self, "package", value)
+
+    @property
+    @pulumi.getter
+    def region(self) -> Optional[pulumi.Input[str]]:
+        """
+        The cloud service provider region
+        """
+        return pulumi.get(self, "region")
+
+    @region.setter
+    def region(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "region", value)
+
+    @property
+    @pulumi.getter
+    def zone(self) -> Optional[pulumi.Input[str]]:
+        """
+        type of zone availability
+        """
+        return pulumi.get(self, "zone")
+
+    @zone.setter
+    def zone(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "zone", value)
+
+
+if not MYPY:
+    class SCMetadataEntityArgsDict(TypedDict):
+        """
+        Metadata of the data record
+        """
+        created_timestamp: NotRequired[pulumi.Input[str]]
+        """
+        Created Date Time
+        """
+        deleted_timestamp: NotRequired[pulumi.Input[str]]
+        """
+        Deleted Date time
+        """
+        resource_name: NotRequired[pulumi.Input[str]]
+        """
+        Resource name of the record
+        """
+        self: NotRequired[pulumi.Input[str]]
+        """
+        Self lookup url
+        """
+        updated_timestamp: NotRequired[pulumi.Input[str]]
+        """
+        Updated Date time
+        """
+elif False:
+    SCMetadataEntityArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SCMetadataEntityArgs:
+    def __init__(__self__, *,
+                 created_timestamp: Optional[pulumi.Input[str]] = None,
+                 deleted_timestamp: Optional[pulumi.Input[str]] = None,
+                 resource_name: Optional[pulumi.Input[str]] = None,
+                 self: Optional[pulumi.Input[str]] = None,
+                 updated_timestamp: Optional[pulumi.Input[str]] = None):
+        """
+        Metadata of the data record
+        :param pulumi.Input[str] created_timestamp: Created Date Time
+        :param pulumi.Input[str] deleted_timestamp: Deleted Date time
+        :param pulumi.Input[str] resource_name: Resource name of the record
+        :param pulumi.Input[str] self: Self lookup url
+        :param pulumi.Input[str] updated_timestamp: Updated Date time
+        """
+        if created_timestamp is not None:
+            pulumi.set(__self__, "created_timestamp", created_timestamp)
+        if deleted_timestamp is not None:
+            pulumi.set(__self__, "deleted_timestamp", deleted_timestamp)
+        if resource_name is not None:
+            pulumi.set(__self__, "resource_name", resource_name)
+        if self is not None:
+            pulumi.set(__self__, "self", self)
+        if updated_timestamp is not None:
+            pulumi.set(__self__, "updated_timestamp", updated_timestamp)
+
+    @property
+    @pulumi.getter(name="createdTimestamp")
+    def created_timestamp(self) -> Optional[pulumi.Input[str]]:
+        """
+        Created Date Time
+        """
+        return pulumi.get(self, "created_timestamp")
+
+    @created_timestamp.setter
+    def created_timestamp(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "created_timestamp", value)
+
+    @property
+    @pulumi.getter(name="deletedTimestamp")
+    def deleted_timestamp(self) -> Optional[pulumi.Input[str]]:
+        """
+        Deleted Date time
+        """
+        return pulumi.get(self, "deleted_timestamp")
+
+    @deleted_timestamp.setter
+    def deleted_timestamp(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "deleted_timestamp", value)
+
+    @property
+    @pulumi.getter(name="resourceName")
+    def resource_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Resource name of the record
+        """
+        return pulumi.get(self, "resource_name")
+
+    @resource_name.setter
+    def resource_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "resource_name", value)
+
+    @property
+    @pulumi.getter
+    def self(self) -> Optional[pulumi.Input[str]]:
+        """
+        Self lookup url
+        """
+        return pulumi.get(self, "self")
+
+    @self.setter
+    def self(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "self", value)
+
+    @property
+    @pulumi.getter(name="updatedTimestamp")
+    def updated_timestamp(self) -> Optional[pulumi.Input[str]]:
+        """
+        Updated Date time
+        """
+        return pulumi.get(self, "updated_timestamp")
+
+    @updated_timestamp.setter
+    def updated_timestamp(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "updated_timestamp", value)
+
+
+if not MYPY:
+    class StreamGovernanceConfigArgsDict(TypedDict):
+        """
+        Stream governance configuration
+        """
+        package: NotRequired[pulumi.Input[Union[str, 'Package']]]
+        """
+        Stream governance configuration
+        """
+elif False:
+    StreamGovernanceConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class StreamGovernanceConfigArgs:
+    def __init__(__self__, *,
+                 package: Optional[pulumi.Input[Union[str, 'Package']]] = None):
+        """
+        Stream governance configuration
+        :param pulumi.Input[Union[str, 'Package']] package: Stream governance configuration
+        """
+        if package is not None:
+            pulumi.set(__self__, "package", package)
+
+    @property
+    @pulumi.getter
+    def package(self) -> Optional[pulumi.Input[Union[str, 'Package']]]:
+        """
+        Stream governance configuration
+        """
+        return pulumi.get(self, "package")
+
+    @package.setter
+    def package(self, value: Optional[pulumi.Input[Union[str, 'Package']]]):
+        pulumi.set(self, "package", value)
+
+
+if not MYPY:
+    class TopicMetadataEntityArgsDict(TypedDict):
+        """
+        Metadata of the data record
+        """
+        resource_name: NotRequired[pulumi.Input[str]]
+        """
+        Resource name of the record
+        """
+        self: NotRequired[pulumi.Input[str]]
+        """
+        Self lookup url
+        """
+elif False:
+    TopicMetadataEntityArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class TopicMetadataEntityArgs:
+    def __init__(__self__, *,
+                 resource_name: Optional[pulumi.Input[str]] = None,
+                 self: Optional[pulumi.Input[str]] = None):
+        """
+        Metadata of the data record
+        :param pulumi.Input[str] resource_name: Resource name of the record
+        :param pulumi.Input[str] self: Self lookup url
+        """
+        if resource_name is not None:
+            pulumi.set(__self__, "resource_name", resource_name)
+        if self is not None:
+            pulumi.set(__self__, "self", self)
+
+    @property
+    @pulumi.getter(name="resourceName")
+    def resource_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Resource name of the record
+        """
+        return pulumi.get(self, "resource_name")
+
+    @resource_name.setter
+    def resource_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "resource_name", value)
+
+    @property
+    @pulumi.getter
+    def self(self) -> Optional[pulumi.Input[str]]:
+        """
+        Self lookup url
+        """
+        return pulumi.get(self, "self")
+
+    @self.setter
+    def self(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "self", value)
+
+
+if not MYPY:
+    class TopicsInputConfigArgsDict(TypedDict):
+        """
+        Topics input config
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        Name of the topic input config
+        """
+        value: NotRequired[pulumi.Input[str]]
+        """
+        Value of the topic input config
+        """
+elif False:
+    TopicsInputConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class TopicsInputConfigArgs:
+    def __init__(__self__, *,
+                 name: Optional[pulumi.Input[str]] = None,
+                 value: Optional[pulumi.Input[str]] = None):
+        """
+        Topics input config
+        :param pulumi.Input[str] name: Name of the topic input config
+        :param pulumi.Input[str] value: Value of the topic input config
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Name of the topic input config
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter
+    def value(self) -> Optional[pulumi.Input[str]]:
+        """
+        Value of the topic input config
+        """
+        return pulumi.get(self, "value")
+
+    @value.setter
+    def value(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "value", value)
+
+
+if not MYPY:
+    class TopicsRelatedLinkArgsDict(TypedDict):
+        """
+        Partition Config spec of the topic record
+        """
+        related: NotRequired[pulumi.Input[str]]
+        """
+        Relationship of the topic
+        """
+elif False:
+    TopicsRelatedLinkArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class TopicsRelatedLinkArgs:
+    def __init__(__self__, *,
+                 related: Optional[pulumi.Input[str]] = None):
+        """
+        Partition Config spec of the topic record
+        :param pulumi.Input[str] related: Relationship of the topic
+        """
+        if related is not None:
+            pulumi.set(__self__, "related", related)
+
+    @property
+    @pulumi.getter
+    def related(self) -> Optional[pulumi.Input[str]]:
+        """
+        Relationship of the topic
+        """
+        return pulumi.get(self, "related")
+
+    @related.setter
+    def related(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "related", value)
 
 
 if not MYPY: