PyPI - pulumi-azure-native - Versions diffs - 2.82.0__py3-none-any.whl → 2.82.0a1736432194__py3-none-any.whl - Mend - Supply Chain Defender

pulumi-azure-native 2.82.0py3-none-any.whl → 2.82.0a1736432194py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of pulumi-azure-native might be problematic. Click here for more details.

Files changed (940) hide show

pulumi_azure_native/confluent/outputs.py CHANGED Viewed

@@ -14,14 +14,8 @@ else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 from . import outputs
-from ._enums import *
 __all__ = [
-    'AzureBlobStorageSinkConnectorServiceInfoResponse',
-    'AzureBlobStorageSourceConnectorServiceInfoResponse',
-    'AzureCosmosDBSinkConnectorServiceInfoResponse',
-    'AzureCosmosDBSourceConnectorServiceInfoResponse',
-    'AzureSynapseAnalyticsSinkConnectorServiceInfoResponse',
     'ClusterByokEntityResponse',
     'ClusterConfigEntityResponse',
     'ClusterEnvironmentEntityResponse',
@@ -30,532 +24,20 @@ __all__ = [
     'ClusterSpecEntityResponse',
     'ClusterStatusEntityResponse',
     'ConfluentListMetadataResponse',
-    'ConnectorInfoBaseResponse',
     'EnvironmentRecordResponse',
     'InvitationRecordResponse',
-    'KafkaAzureBlobStorageSinkConnectorInfoResponse',
-    'KafkaAzureBlobStorageSourceConnectorInfoResponse',
-    'KafkaAzureCosmosDBSinkConnectorInfoResponse',
-    'KafkaAzureCosmosDBSourceConnectorInfoResponse',
-    'KafkaAzureSynapseAnalyticsSinkConnectorInfoResponse',
     'MetadataEntityResponse',
     'OfferDetailResponse',
     'RegionRecordResponse',
     'RegionSpecEntityResponse',
     'RoleBindingRecordResponse',
-    'SCClusterByokEntityResponse',
-    'SCClusterNetworkEnvironmentEntityResponse',
-    'SCClusterSpecEntityResponse',
     'SCMetadataEntityResponse',
     'ServiceAccountRecordResponse',
-    'StreamGovernanceConfigResponse',
     'SystemDataResponse',
-    'TopicMetadataEntityResponse',
-    'TopicsInputConfigResponse',
-    'TopicsRelatedLinkResponse',
     'UserDetailResponse',
     'UserRecordResponse',
 ]
-@pulumi.output_type
-class AzureBlobStorageSinkConnectorServiceInfoResponse(dict):
-    """
-    The authentication info when auth_type is azureBlobStorageSinkConnector
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "connectorServiceType":
-            suggest = "connector_service_type"
-        elif key == "storageAccountKey":
-            suggest = "storage_account_key"
-        elif key == "storageAccountName":
-            suggest = "storage_account_name"
-        elif key == "storageContainerName":
-            suggest = "storage_container_name"
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in AzureBlobStorageSinkConnectorServiceInfoResponse. Access the value via the '{suggest}' property getter instead.")
-    def __getitem__(self, key: str) -> Any:
-        AzureBlobStorageSinkConnectorServiceInfoResponse.__key_warning(key)
-        return super().__getitem__(key)
-    def get(self, key: str, default = None) -> Any:
-        AzureBlobStorageSinkConnectorServiceInfoResponse.__key_warning(key)
-        return super().get(key, default)
-    def __init__(__self__, *,
-                 connector_service_type: str,
-                 storage_account_key: Optional[str] = None,
-                 storage_account_name: Optional[str] = None,
-                 storage_container_name: Optional[str] = None):
-        """
-        The authentication info when auth_type is azureBlobStorageSinkConnector
-        :param str connector_service_type: The connector service type.
-               Expected value is 'AzureBlobStorageSinkConnector'.
-        :param str storage_account_key: Azure Blob Storage Account Key
-        :param str storage_account_name: Azure Blob Storage Account Name
-        :param 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) -> str:
-        """
-        The connector service type.
-        Expected value is 'AzureBlobStorageSinkConnector'.
-        """
-        return pulumi.get(self, "connector_service_type")
-    @property
-    @pulumi.getter(name="storageAccountKey")
-    def storage_account_key(self) -> Optional[str]:
-        """
-        Azure Blob Storage Account Key
-        """
-        return pulumi.get(self, "storage_account_key")
-    @property
-    @pulumi.getter(name="storageAccountName")
-    def storage_account_name(self) -> Optional[str]:
-        """
-        Azure Blob Storage Account Name
-        """
-        return pulumi.get(self, "storage_account_name")
-    @property
-    @pulumi.getter(name="storageContainerName")
-    def storage_container_name(self) -> Optional[str]:
-        """
-        Azure Blob Storage Account Container Name
-        """
-        return pulumi.get(self, "storage_container_name")
-@pulumi.output_type
-class AzureBlobStorageSourceConnectorServiceInfoResponse(dict):
-    """
-    The connector service type is AzureBlobStorageSourceConnector
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "connectorServiceType":
-            suggest = "connector_service_type"
-        elif key == "storageAccountKey":
-            suggest = "storage_account_key"
-        elif key == "storageAccountName":
-            suggest = "storage_account_name"
-        elif key == "storageContainerName":
-            suggest = "storage_container_name"
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in AzureBlobStorageSourceConnectorServiceInfoResponse. Access the value via the '{suggest}' property getter instead.")
-    def __getitem__(self, key: str) -> Any:
-        AzureBlobStorageSourceConnectorServiceInfoResponse.__key_warning(key)
-        return super().__getitem__(key)
-    def get(self, key: str, default = None) -> Any:
-        AzureBlobStorageSourceConnectorServiceInfoResponse.__key_warning(key)
-        return super().get(key, default)
-    def __init__(__self__, *,
-                 connector_service_type: str,
-                 storage_account_key: Optional[str] = None,
-                 storage_account_name: Optional[str] = None,
-                 storage_container_name: Optional[str] = None):
-        """
-        The connector service type is AzureBlobStorageSourceConnector
-        :param str connector_service_type: The connector service type.
-               Expected value is 'AzureBlobStorageSourceConnector'.
-        :param str storage_account_key: Azure Blob Storage Account Key
-        :param str storage_account_name: Azure Blob Storage Account Name
-        :param 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) -> str:
-        """
-        The connector service type.
-        Expected value is 'AzureBlobStorageSourceConnector'.
-        """
-        return pulumi.get(self, "connector_service_type")
-    @property
-    @pulumi.getter(name="storageAccountKey")
-    def storage_account_key(self) -> Optional[str]:
-        """
-        Azure Blob Storage Account Key
-        """
-        return pulumi.get(self, "storage_account_key")
-    @property
-    @pulumi.getter(name="storageAccountName")
-    def storage_account_name(self) -> Optional[str]:
-        """
-        Azure Blob Storage Account Name
-        """
-        return pulumi.get(self, "storage_account_name")
-    @property
-    @pulumi.getter(name="storageContainerName")
-    def storage_container_name(self) -> Optional[str]:
-        """
-        Azure Blob Storage Account Container Name
-        """
-        return pulumi.get(self, "storage_container_name")
-@pulumi.output_type
-class AzureCosmosDBSinkConnectorServiceInfoResponse(dict):
-    """
-    The authentication info when auth_type is AzureCosmosDBSinkConnector
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "connectorServiceType":
-            suggest = "connector_service_type"
-        elif key == "cosmosConnectionEndpoint":
-            suggest = "cosmos_connection_endpoint"
-        elif key == "cosmosContainersTopicMapping":
-            suggest = "cosmos_containers_topic_mapping"
-        elif key == "cosmosDatabaseName":
-            suggest = "cosmos_database_name"
-        elif key == "cosmosIdStrategy":
-            suggest = "cosmos_id_strategy"
-        elif key == "cosmosMasterKey":
-            suggest = "cosmos_master_key"
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in AzureCosmosDBSinkConnectorServiceInfoResponse. Access the value via the '{suggest}' property getter instead.")
-    def __getitem__(self, key: str) -> Any:
-        AzureCosmosDBSinkConnectorServiceInfoResponse.__key_warning(key)
-        return super().__getitem__(key)
-    def get(self, key: str, default = None) -> Any:
-        AzureCosmosDBSinkConnectorServiceInfoResponse.__key_warning(key)
-        return super().get(key, default)
-    def __init__(__self__, *,
-                 connector_service_type: str,
-                 cosmos_connection_endpoint: Optional[str] = None,
-                 cosmos_containers_topic_mapping: Optional[str] = None,
-                 cosmos_database_name: Optional[str] = None,
-                 cosmos_id_strategy: Optional[str] = None,
-                 cosmos_master_key: Optional[str] = None):
-        """
-        The authentication info when auth_type is AzureCosmosDBSinkConnector
-        :param str connector_service_type: The connector service type.
-               Expected value is 'AzureCosmosDBSinkConnector'.
-        :param str cosmos_connection_endpoint: Azure Cosmos Database Connection Endpoint
-        :param str cosmos_containers_topic_mapping: Azure Cosmos Database Containers Topic Mapping
-        :param str cosmos_database_name: Azure Cosmos Database Name
-        :param str cosmos_id_strategy: Azure Cosmos Database Id Strategy
-        :param 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) -> str:
-        """
-        The connector service type.
-        Expected value is 'AzureCosmosDBSinkConnector'.
-        """
-        return pulumi.get(self, "connector_service_type")
-    @property
-    @pulumi.getter(name="cosmosConnectionEndpoint")
-    def cosmos_connection_endpoint(self) -> Optional[str]:
-        """
-        Azure Cosmos Database Connection Endpoint
-        """
-        return pulumi.get(self, "cosmos_connection_endpoint")
-    @property
-    @pulumi.getter(name="cosmosContainersTopicMapping")
-    def cosmos_containers_topic_mapping(self) -> Optional[str]:
-        """
-        Azure Cosmos Database Containers Topic Mapping
-        """
-        return pulumi.get(self, "cosmos_containers_topic_mapping")
-    @property
-    @pulumi.getter(name="cosmosDatabaseName")
-    def cosmos_database_name(self) -> Optional[str]:
-        """
-        Azure Cosmos Database Name
-        """
-        return pulumi.get(self, "cosmos_database_name")
-    @property
-    @pulumi.getter(name="cosmosIdStrategy")
-    def cosmos_id_strategy(self) -> Optional[str]:
-        """
-        Azure Cosmos Database Id Strategy
-        """
-        return pulumi.get(self, "cosmos_id_strategy")
-    @property
-    @pulumi.getter(name="cosmosMasterKey")
-    def cosmos_master_key(self) -> Optional[str]:
-        """
-        Azure Cosmos Database Master Key
-        """
-        return pulumi.get(self, "cosmos_master_key")
-@pulumi.output_type
-class AzureCosmosDBSourceConnectorServiceInfoResponse(dict):
-    """
-    The authentication info when auth_type is AzureCosmosDBSourceConnector
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "connectorServiceType":
-            suggest = "connector_service_type"
-        elif key == "cosmosConnectionEndpoint":
-            suggest = "cosmos_connection_endpoint"
-        elif key == "cosmosContainersTopicMapping":
-            suggest = "cosmos_containers_topic_mapping"
-        elif key == "cosmosDatabaseName":
-            suggest = "cosmos_database_name"
-        elif key == "cosmosMasterKey":
-            suggest = "cosmos_master_key"
-        elif key == "cosmosMessageKeyEnabled":
-            suggest = "cosmos_message_key_enabled"
-        elif key == "cosmosMessageKeyField":
-            suggest = "cosmos_message_key_field"
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in AzureCosmosDBSourceConnectorServiceInfoResponse. Access the value via the '{suggest}' property getter instead.")
-    def __getitem__(self, key: str) -> Any:
-        AzureCosmosDBSourceConnectorServiceInfoResponse.__key_warning(key)
-        return super().__getitem__(key)
-    def get(self, key: str, default = None) -> Any:
-        AzureCosmosDBSourceConnectorServiceInfoResponse.__key_warning(key)
-        return super().get(key, default)
-    def __init__(__self__, *,
-                 connector_service_type: str,
-                 cosmos_connection_endpoint: Optional[str] = None,
-                 cosmos_containers_topic_mapping: Optional[str] = None,
-                 cosmos_database_name: Optional[str] = None,
-                 cosmos_master_key: Optional[str] = None,
-                 cosmos_message_key_enabled: Optional[bool] = None,
-                 cosmos_message_key_field: Optional[str] = None):
-        """
-        The authentication info when auth_type is AzureCosmosDBSourceConnector
-        :param str connector_service_type: The connector service type.
-               Expected value is 'AzureCosmosDBSourceConnector'.
-        :param str cosmos_connection_endpoint: Azure Cosmos Database Connection Endpoint
-        :param str cosmos_containers_topic_mapping: Azure Cosmos Database Containers Topic Mapping
-        :param str cosmos_database_name: Azure Cosmos Database Name
-        :param str cosmos_master_key: Azure Cosmos Database Master Key
-        :param bool cosmos_message_key_enabled: Azure Cosmos Database Message Key Enabled
-        :param 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) -> str:
-        """
-        The connector service type.
-        Expected value is 'AzureCosmosDBSourceConnector'.
-        """
-        return pulumi.get(self, "connector_service_type")
-    @property
-    @pulumi.getter(name="cosmosConnectionEndpoint")
-    def cosmos_connection_endpoint(self) -> Optional[str]:
-        """
-        Azure Cosmos Database Connection Endpoint
-        """
-        return pulumi.get(self, "cosmos_connection_endpoint")
-    @property
-    @pulumi.getter(name="cosmosContainersTopicMapping")
-    def cosmos_containers_topic_mapping(self) -> Optional[str]:
-        """
-        Azure Cosmos Database Containers Topic Mapping
-        """
-        return pulumi.get(self, "cosmos_containers_topic_mapping")
-    @property
-    @pulumi.getter(name="cosmosDatabaseName")
-    def cosmos_database_name(self) -> Optional[str]:
-        """
-        Azure Cosmos Database Name
-        """
-        return pulumi.get(self, "cosmos_database_name")
-    @property
-    @pulumi.getter(name="cosmosMasterKey")
-    def cosmos_master_key(self) -> Optional[str]:
-        """
-        Azure Cosmos Database Master Key
-        """
-        return pulumi.get(self, "cosmos_master_key")
-    @property
-    @pulumi.getter(name="cosmosMessageKeyEnabled")
-    def cosmos_message_key_enabled(self) -> Optional[bool]:
-        """
-        Azure Cosmos Database Message Key Enabled
-        """
-        return pulumi.get(self, "cosmos_message_key_enabled")
-    @property
-    @pulumi.getter(name="cosmosMessageKeyField")
-    def cosmos_message_key_field(self) -> Optional[str]:
-        """
-        Azure Cosmos Database Message Key Field
-        """
-        return pulumi.get(self, "cosmos_message_key_field")
-@pulumi.output_type
-class AzureSynapseAnalyticsSinkConnectorServiceInfoResponse(dict):
-    """
-    The authentication info when auth_type is AzureSynapseAnalyticsSinkConnector
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "connectorServiceType":
-            suggest = "connector_service_type"
-        elif key == "synapseSqlDatabaseName":
-            suggest = "synapse_sql_database_name"
-        elif key == "synapseSqlPassword":
-            suggest = "synapse_sql_password"
-        elif key == "synapseSqlServerName":
-            suggest = "synapse_sql_server_name"
-        elif key == "synapseSqlUser":
-            suggest = "synapse_sql_user"
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in AzureSynapseAnalyticsSinkConnectorServiceInfoResponse. Access the value via the '{suggest}' property getter instead.")
-    def __getitem__(self, key: str) -> Any:
-        AzureSynapseAnalyticsSinkConnectorServiceInfoResponse.__key_warning(key)
-        return super().__getitem__(key)
-    def get(self, key: str, default = None) -> Any:
-        AzureSynapseAnalyticsSinkConnectorServiceInfoResponse.__key_warning(key)
-        return super().get(key, default)
-    def __init__(__self__, *,
-                 connector_service_type: str,
-                 synapse_sql_database_name: Optional[str] = None,
-                 synapse_sql_password: Optional[str] = None,
-                 synapse_sql_server_name: Optional[str] = None,
-                 synapse_sql_user: Optional[str] = None):
-        """
-        The authentication info when auth_type is AzureSynapseAnalyticsSinkConnector
-        :param str connector_service_type: The connector service type.
-               Expected value is 'AzureSynapseAnalyticsSinkConnector'.
-        :param str synapse_sql_database_name: Azure Synapse Dedicated SQL Pool Database Name
-        :param str synapse_sql_password: Azure Synapse SQL login details
-        :param str synapse_sql_server_name: Azure Synapse Analytics SQL Server Name
-        :param 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) -> str:
-        """
-        The connector service type.
-        Expected value is 'AzureSynapseAnalyticsSinkConnector'.
-        """
-        return pulumi.get(self, "connector_service_type")
-    @property
-    @pulumi.getter(name="synapseSqlDatabaseName")
-    def synapse_sql_database_name(self) -> Optional[str]:
-        """
-        Azure Synapse Dedicated SQL Pool Database Name
-        """
-        return pulumi.get(self, "synapse_sql_database_name")
-    @property
-    @pulumi.getter(name="synapseSqlPassword")
-    def synapse_sql_password(self) -> Optional[str]:
-        """
-        Azure Synapse SQL login details
-        """
-        return pulumi.get(self, "synapse_sql_password")
-    @property
-    @pulumi.getter(name="synapseSqlServerName")
-    def synapse_sql_server_name(self) -> Optional[str]:
-        """
-        Azure Synapse Analytics SQL Server Name
-        """
-        return pulumi.get(self, "synapse_sql_server_name")
-    @property
-    @pulumi.getter(name="synapseSqlUser")
-    def synapse_sql_user(self) -> Optional[str]:
-        """
-        Azure Synapse SQL login details
-        """
-        return pulumi.get(self, "synapse_sql_user")
 @pulumi.output_type
 class ClusterByokEntityResponse(dict):
     """
@@ -1088,102 +570,6 @@ class ConfluentListMetadataResponse(dict):
         return pulumi.get(self, "total_size")
-@pulumi.output_type
-class ConnectorInfoBaseResponse(dict):
-    """
-    Connector Info Base properties
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "connectorClass":
-            suggest = "connector_class"
-        elif key == "connectorId":
-            suggest = "connector_id"
-        elif key == "connectorName":
-            suggest = "connector_name"
-        elif key == "connectorState":
-            suggest = "connector_state"
-        elif key == "connectorType":
-            suggest = "connector_type"
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ConnectorInfoBaseResponse. Access the value via the '{suggest}' property getter instead.")
-    def __getitem__(self, key: str) -> Any:
-        ConnectorInfoBaseResponse.__key_warning(key)
-        return super().__getitem__(key)
-    def get(self, key: str, default = None) -> Any:
-        ConnectorInfoBaseResponse.__key_warning(key)
-        return super().get(key, default)
-    def __init__(__self__, *,
-                 connector_class: Optional[str] = None,
-                 connector_id: Optional[str] = None,
-                 connector_name: Optional[str] = None,
-                 connector_state: Optional[str] = None,
-                 connector_type: Optional[str] = None):
-        """
-        Connector Info Base properties
-        :param str connector_class: Connector Class
-        :param str connector_id: Connector Id
-        :param str connector_name: Connector Name
-        :param str connector_state: Connector Status
-        :param str 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[str]:
-        """
-        Connector Class
-        """
-        return pulumi.get(self, "connector_class")
-    @property
-    @pulumi.getter(name="connectorId")
-    def connector_id(self) -> Optional[str]:
-        """
-        Connector Id
-        """
-        return pulumi.get(self, "connector_id")
-    @property
-    @pulumi.getter(name="connectorName")
-    def connector_name(self) -> Optional[str]:
-        """
-        Connector Name
-        """
-        return pulumi.get(self, "connector_name")
-    @property
-    @pulumi.getter(name="connectorState")
-    def connector_state(self) -> Optional[str]:
-        """
-        Connector Status
-        """
-        return pulumi.get(self, "connector_state")
-    @property
-    @pulumi.getter(name="connectorType")
-    def connector_type(self) -> Optional[str]:
-        """
-        Connector Type
-        """
-        return pulumi.get(self, "connector_type")
 @pulumi.output_type
 class EnvironmentRecordResponse(dict):
     """
@@ -1351,1612 +737,371 @@ class InvitationRecordResponse(dict):
 @pulumi.output_type
-class KafkaAzureBlobStorageSinkConnectorInfoResponse(dict):
+class MetadataEntityResponse(dict):
     """
-    The partner connector type is KafkaAzureBlobStorageSink
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "partnerConnectorType":
-            suggest = "partner_connector_type"
-        elif key == "apiKey":
-            suggest = "api_key"
-        elif key == "apiSecret":
-            suggest = "api_secret"
-        elif key == "authType":
-            suggest = "auth_type"
-        elif key == "flushSize":
-            suggest = "flush_size"
-        elif key == "inputFormat":
-            suggest = "input_format"
-        elif key == "maxTasks":
-            suggest = "max_tasks"
-        elif key == "outputFormat":
-            suggest = "output_format"
-        elif key == "serviceAccountId":
-            suggest = "service_account_id"
-        elif key == "timeInterval":
-            suggest = "time_interval"
-        elif key == "topicsDir":
-            suggest = "topics_dir"
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in KafkaAzureBlobStorageSinkConnectorInfoResponse. Access the value via the '{suggest}' property getter instead.")
-    def __getitem__(self, key: str) -> Any:
-        KafkaAzureBlobStorageSinkConnectorInfoResponse.__key_warning(key)
-        return super().__getitem__(key)
-    def get(self, key: str, default = None) -> Any:
-        KafkaAzureBlobStorageSinkConnectorInfoResponse.__key_warning(key)
-        return super().get(key, default)
-    def __init__(__self__, *,
-                 partner_connector_type: str,
-                 api_key: Optional[str] = None,
-                 api_secret: Optional[str] = None,
-                 auth_type: Optional[str] = None,
-                 flush_size: Optional[str] = None,
-                 input_format: Optional[str] = None,
-                 max_tasks: Optional[str] = None,
-                 output_format: Optional[str] = None,
-                 service_account_id: Optional[str] = None,
-                 time_interval: Optional[str] = None,
-                 topics: Optional[Sequence[str]] = None,
-                 topics_dir: Optional[str] = None):
-        """
-        The partner connector type is KafkaAzureBlobStorageSink
-        :param str partner_connector_type: Partner Connector type.
-               Expected value is 'KafkaAzureBlobStorageSink'.
-        :param str api_key: Kafka API Key
-        :param str api_secret: Kafka API Key Secret
-        :param str auth_type: Kafka Auth Type
-        :param str flush_size: Flush size
-        :param str input_format: Kafka Input Data Format Type
-        :param str max_tasks: Maximum Tasks
-        :param str output_format: Kafka Output Data Format Type
-        :param str service_account_id: Kafka Service Account Id
-        :param str time_interval: Time Interval
-        :param Sequence[str] topics: Kafka topics list
-        :param 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) -> str:
-        """
-        Partner Connector type.
-        Expected value is 'KafkaAzureBlobStorageSink'.
-        """
-        return pulumi.get(self, "partner_connector_type")
-    @property
-    @pulumi.getter(name="apiKey")
-    def api_key(self) -> Optional[str]:
-        """
-        Kafka API Key
-        """
-        return pulumi.get(self, "api_key")
-    @property
-    @pulumi.getter(name="apiSecret")
-    def api_secret(self) -> Optional[str]:
-        """
-        Kafka API Key Secret
-        """
-        return pulumi.get(self, "api_secret")
-    @property
-    @pulumi.getter(name="authType")
-    def auth_type(self) -> Optional[str]:
-        """
-        Kafka Auth Type
-        """
-        return pulumi.get(self, "auth_type")
-    @property
-    @pulumi.getter(name="flushSize")
-    def flush_size(self) -> Optional[str]:
-        """
-        Flush size
-        """
-        return pulumi.get(self, "flush_size")
-    @property
-    @pulumi.getter(name="inputFormat")
-    def input_format(self) -> Optional[str]:
-        """
-        Kafka Input Data Format Type
-        """
-        return pulumi.get(self, "input_format")
-    @property
-    @pulumi.getter(name="maxTasks")
-    def max_tasks(self) -> Optional[str]:
-        """
-        Maximum Tasks
-        """
-        return pulumi.get(self, "max_tasks")
-    @property
-    @pulumi.getter(name="outputFormat")
-    def output_format(self) -> Optional[str]:
-        """
-        Kafka Output Data Format Type
-        """
-        return pulumi.get(self, "output_format")
-    @property
-    @pulumi.getter(name="serviceAccountId")
-    def service_account_id(self) -> Optional[str]:
-        """
-        Kafka Service Account Id
-        """
-        return pulumi.get(self, "service_account_id")
-    @property
-    @pulumi.getter(name="timeInterval")
-    def time_interval(self) -> Optional[str]:
-        """
-        Time Interval
-        """
-        return pulumi.get(self, "time_interval")
-    @property
-    @pulumi.getter
-    def topics(self) -> Optional[Sequence[str]]:
-        """
-        Kafka topics list
-        """
-        return pulumi.get(self, "topics")
-    @property
-    @pulumi.getter(name="topicsDir")
-    def topics_dir(self) -> Optional[str]:
-        """
-        Kafka topics directory
-        """
-        return pulumi.get(self, "topics_dir")
-@pulumi.output_type
-class KafkaAzureBlobStorageSourceConnectorInfoResponse(dict):
-    """
-    The partner connector type is KafkaAzureBlobStorageSource
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "partnerConnectorType":
-            suggest = "partner_connector_type"
-        elif key == "apiKey":
-            suggest = "api_key"
-        elif key == "apiSecret":
-            suggest = "api_secret"
-        elif key == "authType":
-            suggest = "auth_type"
-        elif key == "inputFormat":
-            suggest = "input_format"
-        elif key == "maxTasks":
-            suggest = "max_tasks"
-        elif key == "outputFormat":
-            suggest = "output_format"
-        elif key == "serviceAccountId":
-            suggest = "service_account_id"
-        elif key == "topicRegex":
-            suggest = "topic_regex"
-        elif key == "topicsDir":
-            suggest = "topics_dir"
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in KafkaAzureBlobStorageSourceConnectorInfoResponse. Access the value via the '{suggest}' property getter instead.")
-    def __getitem__(self, key: str) -> Any:
-        KafkaAzureBlobStorageSourceConnectorInfoResponse.__key_warning(key)
-        return super().__getitem__(key)
-    def get(self, key: str, default = None) -> Any:
-        KafkaAzureBlobStorageSourceConnectorInfoResponse.__key_warning(key)
-        return super().get(key, default)
-    def __init__(__self__, *,
-                 partner_connector_type: str,
-                 api_key: Optional[str] = None,
-                 api_secret: Optional[str] = None,
-                 auth_type: Optional[str] = None,
-                 input_format: Optional[str] = None,
-                 max_tasks: Optional[str] = None,
-                 output_format: Optional[str] = None,
-                 service_account_id: Optional[str] = None,
-                 topic_regex: Optional[str] = None,
-                 topics_dir: Optional[str] = None):
-        """
-        The partner connector type is KafkaAzureBlobStorageSource
-        :param str partner_connector_type: Partner Connector type.
-               Expected value is 'KafkaAzureBlobStorageSource'.
-        :param str api_key: Kafka API Key
-        :param str api_secret: Kafka API Secret
-        :param str auth_type: Kafka Auth Type
-        :param str input_format: Kafka Input Data Format Type
-        :param str max_tasks: Maximum Tasks
-        :param str output_format: Kafka Output Data Format Type
-        :param str service_account_id: Kafka Service Account Id
-        :param str topic_regex: Kafka topics Regex pattern
-        :param 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) -> str:
-        """
-        Partner Connector type.
-        Expected value is 'KafkaAzureBlobStorageSource'.
-        """
-        return pulumi.get(self, "partner_connector_type")
-    @property
-    @pulumi.getter(name="apiKey")
-    def api_key(self) -> Optional[str]:
-        """
-        Kafka API Key
-        """
-        return pulumi.get(self, "api_key")
-    @property
-    @pulumi.getter(name="apiSecret")
-    def api_secret(self) -> Optional[str]:
-        """
-        Kafka API Secret
-        """
-        return pulumi.get(self, "api_secret")
-    @property
-    @pulumi.getter(name="authType")
-    def auth_type(self) -> Optional[str]:
-        """
-        Kafka Auth Type
-        """
-        return pulumi.get(self, "auth_type")
-    @property
-    @pulumi.getter(name="inputFormat")
-    def input_format(self) -> Optional[str]:
-        """
-        Kafka Input Data Format Type
-        """
-        return pulumi.get(self, "input_format")
-    @property
-    @pulumi.getter(name="maxTasks")
-    def max_tasks(self) -> Optional[str]:
-        """
-        Maximum Tasks
-        """
-        return pulumi.get(self, "max_tasks")
-    @property
-    @pulumi.getter(name="outputFormat")
-    def output_format(self) -> Optional[str]:
-        """
-        Kafka Output Data Format Type
-        """
-        return pulumi.get(self, "output_format")
-    @property
-    @pulumi.getter(name="serviceAccountId")
-    def service_account_id(self) -> Optional[str]:
-        """
-        Kafka Service Account Id
-        """
-        return pulumi.get(self, "service_account_id")
-    @property
-    @pulumi.getter(name="topicRegex")
-    def topic_regex(self) -> Optional[str]:
-        """
-        Kafka topics Regex pattern
-        """
-        return pulumi.get(self, "topic_regex")
-    @property
-    @pulumi.getter(name="topicsDir")
-    def topics_dir(self) -> Optional[str]:
-        """
-        Kafka topics directory
-        """
-        return pulumi.get(self, "topics_dir")
-@pulumi.output_type
-class KafkaAzureCosmosDBSinkConnectorInfoResponse(dict):
-    """
-    The partner connector type is KafkaAzureCosmosDBSink
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "partnerConnectorType":
-            suggest = "partner_connector_type"
-        elif key == "apiKey":
-            suggest = "api_key"
-        elif key == "apiSecret":
-            suggest = "api_secret"
-        elif key == "authType":
-            suggest = "auth_type"
-        elif key == "flushSize":
-            suggest = "flush_size"
-        elif key == "inputFormat":
-            suggest = "input_format"
-        elif key == "maxTasks":
-            suggest = "max_tasks"
-        elif key == "outputFormat":
-            suggest = "output_format"
-        elif key == "serviceAccountId":
-            suggest = "service_account_id"
-        elif key == "timeInterval":
-            suggest = "time_interval"
-        elif key == "topicsDir":
-            suggest = "topics_dir"
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in KafkaAzureCosmosDBSinkConnectorInfoResponse. Access the value via the '{suggest}' property getter instead.")
-    def __getitem__(self, key: str) -> Any:
-        KafkaAzureCosmosDBSinkConnectorInfoResponse.__key_warning(key)
-        return super().__getitem__(key)
-    def get(self, key: str, default = None) -> Any:
-        KafkaAzureCosmosDBSinkConnectorInfoResponse.__key_warning(key)
-        return super().get(key, default)
-    def __init__(__self__, *,
-                 partner_connector_type: str,
-                 api_key: Optional[str] = None,
-                 api_secret: Optional[str] = None,
-                 auth_type: Optional[str] = None,
-                 flush_size: Optional[str] = None,
-                 input_format: Optional[str] = None,
-                 max_tasks: Optional[str] = None,
-                 output_format: Optional[str] = None,
-                 service_account_id: Optional[str] = None,
-                 time_interval: Optional[str] = None,
-                 topics: Optional[Sequence[str]] = None,
-                 topics_dir: Optional[str] = None):
-        """
-        The partner connector type is KafkaAzureCosmosDBSink
-        :param str partner_connector_type: Partner Connector type.
-               Expected value is 'KafkaAzureCosmosDBSink'.
-        :param str api_key: Kafka API Key
-        :param str api_secret: Kafka API Key Secret
-        :param str auth_type: Kafka Auth Type
-        :param str flush_size: Flush size
-        :param str input_format: Kafka Input Data Format Type
-        :param str max_tasks: Maximum Tasks
-        :param str output_format: Kafka Output Data Format Type
-        :param str service_account_id: Kafka Service Account Id
-        :param str time_interval: Time Interval
-        :param Sequence[str] topics: Kafka topics list
-        :param 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) -> str:
-        """
-        Partner Connector type.
-        Expected value is 'KafkaAzureCosmosDBSink'.
-        """
-        return pulumi.get(self, "partner_connector_type")
-    @property
-    @pulumi.getter(name="apiKey")
-    def api_key(self) -> Optional[str]:
-        """
-        Kafka API Key
-        """
-        return pulumi.get(self, "api_key")
-    @property
-    @pulumi.getter(name="apiSecret")
-    def api_secret(self) -> Optional[str]:
-        """
-        Kafka API Key Secret
-        """
-        return pulumi.get(self, "api_secret")
-    @property
-    @pulumi.getter(name="authType")
-    def auth_type(self) -> Optional[str]:
-        """
-        Kafka Auth Type
-        """
-        return pulumi.get(self, "auth_type")
-    @property
-    @pulumi.getter(name="flushSize")
-    def flush_size(self) -> Optional[str]:
-        """
-        Flush size
-        """
-        return pulumi.get(self, "flush_size")
-    @property
-    @pulumi.getter(name="inputFormat")
-    def input_format(self) -> Optional[str]:
-        """
-        Kafka Input Data Format Type
-        """
-        return pulumi.get(self, "input_format")
-    @property
-    @pulumi.getter(name="maxTasks")
-    def max_tasks(self) -> Optional[str]:
-        """
-        Maximum Tasks
-        """
-        return pulumi.get(self, "max_tasks")
-    @property
-    @pulumi.getter(name="outputFormat")
-    def output_format(self) -> Optional[str]:
-        """
-        Kafka Output Data Format Type
-        """
-        return pulumi.get(self, "output_format")
-    @property
-    @pulumi.getter(name="serviceAccountId")
-    def service_account_id(self) -> Optional[str]:
-        """
-        Kafka Service Account Id
-        """
-        return pulumi.get(self, "service_account_id")
-    @property
-    @pulumi.getter(name="timeInterval")
-    def time_interval(self) -> Optional[str]:
-        """
-        Time Interval
-        """
-        return pulumi.get(self, "time_interval")
-    @property
-    @pulumi.getter
-    def topics(self) -> Optional[Sequence[str]]:
-        """
-        Kafka topics list
-        """
-        return pulumi.get(self, "topics")
-    @property
-    @pulumi.getter(name="topicsDir")
-    def topics_dir(self) -> Optional[str]:
-        """
-        Kafka topics directory
-        """
-        return pulumi.get(self, "topics_dir")
-@pulumi.output_type
-class KafkaAzureCosmosDBSourceConnectorInfoResponse(dict):
-    """
-    The partner connector type is KafkaAzureCosmosDBSource
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "partnerConnectorType":
-            suggest = "partner_connector_type"
-        elif key == "apiKey":
-            suggest = "api_key"
-        elif key == "apiSecret":
-            suggest = "api_secret"
-        elif key == "authType":
-            suggest = "auth_type"
-        elif key == "inputFormat":
-            suggest = "input_format"
-        elif key == "maxTasks":
-            suggest = "max_tasks"
-        elif key == "outputFormat":
-            suggest = "output_format"
-        elif key == "serviceAccountId":
-            suggest = "service_account_id"
-        elif key == "topicRegex":
-            suggest = "topic_regex"
-        elif key == "topicsDir":
-            suggest = "topics_dir"
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in KafkaAzureCosmosDBSourceConnectorInfoResponse. Access the value via the '{suggest}' property getter instead.")
-    def __getitem__(self, key: str) -> Any:
-        KafkaAzureCosmosDBSourceConnectorInfoResponse.__key_warning(key)
-        return super().__getitem__(key)
-    def get(self, key: str, default = None) -> Any:
-        KafkaAzureCosmosDBSourceConnectorInfoResponse.__key_warning(key)
-        return super().get(key, default)
-    def __init__(__self__, *,
-                 partner_connector_type: str,
-                 api_key: Optional[str] = None,
-                 api_secret: Optional[str] = None,
-                 auth_type: Optional[str] = None,
-                 input_format: Optional[str] = None,
-                 max_tasks: Optional[str] = None,
-                 output_format: Optional[str] = None,
-                 service_account_id: Optional[str] = None,
-                 topic_regex: Optional[str] = None,
-                 topics_dir: Optional[str] = None):
-        """
-        The partner connector type is KafkaAzureCosmosDBSource
-        :param str partner_connector_type: Partner Connector type.
-               Expected value is 'KafkaAzureCosmosDBSource'.
-        :param str api_key: Kafka API Key
-        :param str api_secret: Kafka API Secret
-        :param str auth_type: Kafka Auth Type
-        :param str input_format: Kafka Input Data Format Type
-        :param str max_tasks: Maximum Tasks
-        :param str output_format: Kafka Output Data Format Type
-        :param str service_account_id: Kafka Service Account Id
-        :param str topic_regex: Kafka topics Regex pattern
-        :param 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) -> str:
-        """
-        Partner Connector type.
-        Expected value is 'KafkaAzureCosmosDBSource'.
-        """
-        return pulumi.get(self, "partner_connector_type")
-    @property
-    @pulumi.getter(name="apiKey")
-    def api_key(self) -> Optional[str]:
-        """
-        Kafka API Key
-        """
-        return pulumi.get(self, "api_key")
-    @property
-    @pulumi.getter(name="apiSecret")
-    def api_secret(self) -> Optional[str]:
-        """
-        Kafka API Secret
-        """
-        return pulumi.get(self, "api_secret")
-    @property
-    @pulumi.getter(name="authType")
-    def auth_type(self) -> Optional[str]:
-        """
-        Kafka Auth Type
-        """
-        return pulumi.get(self, "auth_type")
-    @property
-    @pulumi.getter(name="inputFormat")
-    def input_format(self) -> Optional[str]:
-        """
-        Kafka Input Data Format Type
-        """
-        return pulumi.get(self, "input_format")
-    @property
-    @pulumi.getter(name="maxTasks")
-    def max_tasks(self) -> Optional[str]:
-        """
-        Maximum Tasks
-        """
-        return pulumi.get(self, "max_tasks")
-    @property
-    @pulumi.getter(name="outputFormat")
-    def output_format(self) -> Optional[str]:
-        """
-        Kafka Output Data Format Type
-        """
-        return pulumi.get(self, "output_format")
-    @property
-    @pulumi.getter(name="serviceAccountId")
-    def service_account_id(self) -> Optional[str]:
-        """
-        Kafka Service Account Id
-        """
-        return pulumi.get(self, "service_account_id")
-    @property
-    @pulumi.getter(name="topicRegex")
-    def topic_regex(self) -> Optional[str]:
-        """
-        Kafka topics Regex pattern
-        """
-        return pulumi.get(self, "topic_regex")
-    @property
-    @pulumi.getter(name="topicsDir")
-    def topics_dir(self) -> Optional[str]:
-        """
-        Kafka topics directory
-        """
-        return pulumi.get(self, "topics_dir")
-@pulumi.output_type
-class KafkaAzureSynapseAnalyticsSinkConnectorInfoResponse(dict):
-    """
-    The partner connector type is KafkaAzureSynapseAnalyticsSink
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "partnerConnectorType":
-            suggest = "partner_connector_type"
-        elif key == "apiKey":
-            suggest = "api_key"
-        elif key == "apiSecret":
-            suggest = "api_secret"
-        elif key == "authType":
-            suggest = "auth_type"
-        elif key == "flushSize":
-            suggest = "flush_size"
-        elif key == "inputFormat":
-            suggest = "input_format"
-        elif key == "maxTasks":
-            suggest = "max_tasks"
-        elif key == "outputFormat":
-            suggest = "output_format"
-        elif key == "serviceAccountId":
-            suggest = "service_account_id"
-        elif key == "timeInterval":
-            suggest = "time_interval"
-        elif key == "topicsDir":
-            suggest = "topics_dir"
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in KafkaAzureSynapseAnalyticsSinkConnectorInfoResponse. Access the value via the '{suggest}' property getter instead.")
-    def __getitem__(self, key: str) -> Any:
-        KafkaAzureSynapseAnalyticsSinkConnectorInfoResponse.__key_warning(key)
-        return super().__getitem__(key)
-    def get(self, key: str, default = None) -> Any:
-        KafkaAzureSynapseAnalyticsSinkConnectorInfoResponse.__key_warning(key)
-        return super().get(key, default)
-    def __init__(__self__, *,
-                 partner_connector_type: str,
-                 api_key: Optional[str] = None,
-                 api_secret: Optional[str] = None,
-                 auth_type: Optional[str] = None,
-                 flush_size: Optional[str] = None,
-                 input_format: Optional[str] = None,
-                 max_tasks: Optional[str] = None,
-                 output_format: Optional[str] = None,
-                 service_account_id: Optional[str] = None,
-                 time_interval: Optional[str] = None,
-                 topics: Optional[Sequence[str]] = None,
-                 topics_dir: Optional[str] = None):
-        """
-        The partner connector type is KafkaAzureSynapseAnalyticsSink
-        :param str partner_connector_type: Partner Connector type.
-               Expected value is 'KafkaAzureSynapseAnalyticsSink'.
-        :param str api_key: Kafka API Key
-        :param str api_secret: Kafka API Key Secret
-        :param str auth_type: Kafka Auth Type
-        :param str flush_size: Flush size
-        :param str input_format: Kafka Input Data Format Type
-        :param str max_tasks: Maximum Tasks
-        :param str output_format: Kafka Output Data Format Type
-        :param str service_account_id: Kafka Service Account Id
-        :param str time_interval: Time Interval
-        :param Sequence[str] topics: Kafka topics list
-        :param 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) -> str:
-        """
-        Partner Connector type.
-        Expected value is 'KafkaAzureSynapseAnalyticsSink'.
-        """
-        return pulumi.get(self, "partner_connector_type")
-    @property
-    @pulumi.getter(name="apiKey")
-    def api_key(self) -> Optional[str]:
-        """
-        Kafka API Key
-        """
-        return pulumi.get(self, "api_key")
-    @property
-    @pulumi.getter(name="apiSecret")
-    def api_secret(self) -> Optional[str]:
-        """
-        Kafka API Key Secret
-        """
-        return pulumi.get(self, "api_secret")
-    @property
-    @pulumi.getter(name="authType")
-    def auth_type(self) -> Optional[str]:
-        """
-        Kafka Auth Type
-        """
-        return pulumi.get(self, "auth_type")
-    @property
-    @pulumi.getter(name="flushSize")
-    def flush_size(self) -> Optional[str]:
-        """
-        Flush size
-        """
-        return pulumi.get(self, "flush_size")
-    @property
-    @pulumi.getter(name="inputFormat")
-    def input_format(self) -> Optional[str]:
-        """
-        Kafka Input Data Format Type
-        """
-        return pulumi.get(self, "input_format")
-    @property
-    @pulumi.getter(name="maxTasks")
-    def max_tasks(self) -> Optional[str]:
-        """
-        Maximum Tasks
-        """
-        return pulumi.get(self, "max_tasks")
-    @property
-    @pulumi.getter(name="outputFormat")
-    def output_format(self) -> Optional[str]:
-        """
-        Kafka Output Data Format Type
-        """
-        return pulumi.get(self, "output_format")
-    @property
-    @pulumi.getter(name="serviceAccountId")
-    def service_account_id(self) -> Optional[str]:
-        """
-        Kafka Service Account Id
-        """
-        return pulumi.get(self, "service_account_id")
-    @property
-    @pulumi.getter(name="timeInterval")
-    def time_interval(self) -> Optional[str]:
-        """
-        Time Interval
-        """
-        return pulumi.get(self, "time_interval")
-    @property
-    @pulumi.getter
-    def topics(self) -> Optional[Sequence[str]]:
-        """
-        Kafka topics list
-        """
-        return pulumi.get(self, "topics")
-    @property
-    @pulumi.getter(name="topicsDir")
-    def topics_dir(self) -> Optional[str]:
-        """
-        Kafka topics directory
-        """
-        return pulumi.get(self, "topics_dir")
-@pulumi.output_type
-class MetadataEntityResponse(dict):
-    """
-    Metadata of the data record
-    """
-    def __init__(__self__, *,
-                 created_at: Optional[str] = None,
-                 deleted_at: Optional[str] = None,
-                 resource_name: Optional[str] = None,
-                 self: Optional[str] = None,
-                 updated_at: Optional[str] = None):
-        """
-        Metadata of the data record
-        :param str created_at: Created Date Time
-        :param str deleted_at: Deleted Date time
-        :param str resource_name: Resource name of the record
-        :param str self: Self lookup url
-        :param str updated_at: Updated Date time
-        """
-        if created_at is not None:
-            pulumi.set(__self__, "created_at", created_at)
-        if deleted_at is not None:
-            pulumi.set(__self__, "deleted_at", deleted_at)
-        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_at is not None:
-            pulumi.set(__self__, "updated_at", updated_at)
-    @property
-    @pulumi.getter(name="createdAt")
-    def created_at(self) -> Optional[str]:
-        """
-        Created Date Time
-        """
-        return pulumi.get(self, "created_at")
-    @property
-    @pulumi.getter(name="deletedAt")
-    def deleted_at(self) -> Optional[str]:
-        """
-        Deleted Date time
-        """
-        return pulumi.get(self, "deleted_at")
-    @property
-    @pulumi.getter(name="resourceName")
-    def resource_name(self) -> Optional[str]:
-        """
-        Resource name of the record
-        """
-        return pulumi.get(self, "resource_name")
-    @property
-    @pulumi.getter
-    def self(self) -> Optional[str]:
-        """
-        Self lookup url
-        """
-        return pulumi.get(self, "self")
-    @property
-    @pulumi.getter(name="updatedAt")
-    def updated_at(self) -> Optional[str]:
-        """
-        Updated Date time
-        """
-        return pulumi.get(self, "updated_at")
-@pulumi.output_type
-class OfferDetailResponse(dict):
-    """
-    Confluent Offer detail
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "planId":
-            suggest = "plan_id"
-        elif key == "planName":
-            suggest = "plan_name"
-        elif key == "publisherId":
-            suggest = "publisher_id"
-        elif key == "termUnit":
-            suggest = "term_unit"
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in OfferDetailResponse. Access the value via the '{suggest}' property getter instead.")
-    def __getitem__(self, key: str) -> Any:
-        OfferDetailResponse.__key_warning(key)
-        return super().__getitem__(key)
-    def get(self, key: str, default = None) -> Any:
-        OfferDetailResponse.__key_warning(key)
-        return super().get(key, default)
-    def __init__(__self__, *,
-                 id: str,
-                 plan_id: str,
-                 plan_name: str,
-                 publisher_id: str,
-                 status: str,
-                 term_unit: str):
-        """
-        Confluent Offer detail
-        :param str id: Offer Id
-        :param str plan_id: Offer Plan Id
-        :param str plan_name: Offer Plan Name
-        :param str publisher_id: Publisher Id
-        :param str status: SaaS Offer Status
-        :param 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__, "status", status)
-        pulumi.set(__self__, "term_unit", term_unit)
-    @property
-    @pulumi.getter
-    def id(self) -> str:
-        """
-        Offer Id
-        """
-        return pulumi.get(self, "id")
-    @property
-    @pulumi.getter(name="planId")
-    def plan_id(self) -> str:
-        """
-        Offer Plan Id
-        """
-        return pulumi.get(self, "plan_id")
-    @property
-    @pulumi.getter(name="planName")
-    def plan_name(self) -> str:
-        """
-        Offer Plan Name
-        """
-        return pulumi.get(self, "plan_name")
-    @property
-    @pulumi.getter(name="publisherId")
-    def publisher_id(self) -> str:
-        """
-        Publisher Id
-        """
-        return pulumi.get(self, "publisher_id")
-    @property
-    @pulumi.getter
-    def status(self) -> str:
-        """
-        SaaS Offer Status
-        """
-        return pulumi.get(self, "status")
-    @property
-    @pulumi.getter(name="termUnit")
-    def term_unit(self) -> str:
-        """
-        Offer Plan Term unit
-        """
-        return pulumi.get(self, "term_unit")
-@pulumi.output_type
-class RegionRecordResponse(dict):
-    """
-    Details of region record
-    """
-    def __init__(__self__, *,
-                 id: Optional[str] = None,
-                 kind: Optional[str] = None,
-                 metadata: Optional['outputs.SCMetadataEntityResponse'] = None,
-                 spec: Optional['outputs.RegionSpecEntityResponse'] = None):
-        """
-        Details of region record
-        :param str id: Id of the cluster
-        :param str kind: Kind of the cluster
-        :param 'SCMetadataEntityResponse' metadata: Metadata of the record
-        :param 'RegionSpecEntityResponse' spec: Specification of the region
-        """
-        if id is not None:
-            pulumi.set(__self__, "id", id)
-        if kind is not None:
-            pulumi.set(__self__, "kind", kind)
-        if metadata is not None:
-            pulumi.set(__self__, "metadata", metadata)
-        if spec is not None:
-            pulumi.set(__self__, "spec", spec)
-    @property
-    @pulumi.getter
-    def id(self) -> Optional[str]:
-        """
-        Id of the cluster
-        """
-        return pulumi.get(self, "id")
-    @property
-    @pulumi.getter
-    def kind(self) -> Optional[str]:
-        """
-        Kind of the cluster
-        """
-        return pulumi.get(self, "kind")
-    @property
-    @pulumi.getter
-    def metadata(self) -> Optional['outputs.SCMetadataEntityResponse']:
-        """
-        Metadata of the record
-        """
-        return pulumi.get(self, "metadata")
-    @property
-    @pulumi.getter
-    def spec(self) -> Optional['outputs.RegionSpecEntityResponse']:
-        """
-        Specification of the region
-        """
-        return pulumi.get(self, "spec")
-@pulumi.output_type
-class RegionSpecEntityResponse(dict):
-    """
-    Region spec details
-    """
-    def __init__(__self__, *,
-                 cloud: Optional[str] = None,
-                 name: Optional[str] = None,
-                 packages: Optional[Sequence[str]] = None,
-                 region_name: Optional[str] = None):
-        """
-        Region spec details
-        :param str cloud: Cloud provider name
-        :param str name: Display Name of the region
-        :param str region_name: Region name
-        """
-        if cloud is not None:
-            pulumi.set(__self__, "cloud", cloud)
-        if name is not None:
-            pulumi.set(__self__, "name", name)
-        if packages is not None:
-            pulumi.set(__self__, "packages", packages)
-        if region_name is not None:
-            pulumi.set(__self__, "region_name", region_name)
-    @property
-    @pulumi.getter
-    def cloud(self) -> Optional[str]:
-        """
-        Cloud provider name
-        """
-        return pulumi.get(self, "cloud")
-    @property
-    @pulumi.getter
-    def name(self) -> Optional[str]:
-        """
-        Display Name of the region
-        """
-        return pulumi.get(self, "name")
-    @property
-    @pulumi.getter
-    def packages(self) -> Optional[Sequence[str]]:
-        return pulumi.get(self, "packages")
-    @property
-    @pulumi.getter(name="regionName")
-    def region_name(self) -> Optional[str]:
-        """
-        Region name
-        """
-        return pulumi.get(self, "region_name")
-@pulumi.output_type
-class RoleBindingRecordResponse(dict):
-    """
-    Record of the environment
+    Metadata of the data record
     """
     def __init__(__self__, *,
-                 crn_pattern: Optional[str] = None,
-                 id: Optional[str] = None,
-                 kind: Optional[str] = None,
-                 metadata: Optional['outputs.MetadataEntityResponse'] = None,
-                 principal: Optional[str] = None,
-                 role_name: Optional[str] = None):
-        """
-        Record of the environment
-        :param str crn_pattern: A CRN that specifies the scope and resource patterns necessary for the role to bind
-        :param str id: Id of the role
-        :param str kind: The type of the resource.
-        :param 'MetadataEntityResponse' metadata: Metadata of the record
-        :param str principal: The principal User or Group to bind the role to
-        :param str role_name: The name of the role to bind to the principal
-        """
-        if crn_pattern is not None:
-            pulumi.set(__self__, "crn_pattern", crn_pattern)
-        if id is not None:
-            pulumi.set(__self__, "id", id)
-        if kind is not None:
-            pulumi.set(__self__, "kind", kind)
-        if metadata is not None:
-            pulumi.set(__self__, "metadata", metadata)
-        if principal is not None:
-            pulumi.set(__self__, "principal", principal)
-        if role_name is not None:
-            pulumi.set(__self__, "role_name", role_name)
-    @property
-    @pulumi.getter(name="crnPattern")
-    def crn_pattern(self) -> Optional[str]:
+                 created_at: Optional[str] = None,
+                 deleted_at: Optional[str] = None,
+                 resource_name: Optional[str] = None,
+                 self: Optional[str] = None,
+                 updated_at: Optional[str] = None):
         """
-        A CRN that specifies the scope and resource patterns necessary for the role to bind
+        Metadata of the data record
+        :param str created_at: Created Date Time
+        :param str deleted_at: Deleted Date time
+        :param str resource_name: Resource name of the record
+        :param str self: Self lookup url
+        :param str updated_at: Updated Date time
         """
-        return pulumi.get(self, "crn_pattern")
+        if created_at is not None:
+            pulumi.set(__self__, "created_at", created_at)
+        if deleted_at is not None:
+            pulumi.set(__self__, "deleted_at", deleted_at)
+        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_at is not None:
+            pulumi.set(__self__, "updated_at", updated_at)
     @property
-    @pulumi.getter
-    def id(self) -> Optional[str]:
+    @pulumi.getter(name="createdAt")
+    def created_at(self) -> Optional[str]:
         """
-        Id of the role
+        Created Date Time
         """
-        return pulumi.get(self, "id")
+        return pulumi.get(self, "created_at")
     @property
-    @pulumi.getter
-    def kind(self) -> Optional[str]:
+    @pulumi.getter(name="deletedAt")
+    def deleted_at(self) -> Optional[str]:
         """
-        The type of the resource.
+        Deleted Date time
         """
-        return pulumi.get(self, "kind")
+        return pulumi.get(self, "deleted_at")
     @property
-    @pulumi.getter
-    def metadata(self) -> Optional['outputs.MetadataEntityResponse']:
+    @pulumi.getter(name="resourceName")
+    def resource_name(self) -> Optional[str]:
         """
-        Metadata of the record
+        Resource name of the record
         """
-        return pulumi.get(self, "metadata")
+        return pulumi.get(self, "resource_name")
     @property
     @pulumi.getter
-    def principal(self) -> Optional[str]:
+    def self(self) -> Optional[str]:
         """
-        The principal User or Group to bind the role to
+        Self lookup url
         """
-        return pulumi.get(self, "principal")
+        return pulumi.get(self, "self")
     @property
-    @pulumi.getter(name="roleName")
-    def role_name(self) -> Optional[str]:
+    @pulumi.getter(name="updatedAt")
+    def updated_at(self) -> Optional[str]:
         """
-        The name of the role to bind to the principal
+        Updated Date time
         """
-        return pulumi.get(self, "role_name")
+        return pulumi.get(self, "updated_at")
 @pulumi.output_type
-class SCClusterByokEntityResponse(dict):
+class OfferDetailResponse(dict):
     """
-    The network associated with this object
+    Confluent Offer detail
     """
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "resourceName":
-            suggest = "resource_name"
+        if key == "planId":
+            suggest = "plan_id"
+        elif key == "planName":
+            suggest = "plan_name"
+        elif key == "publisherId":
+            suggest = "publisher_id"
+        elif key == "termUnit":
+            suggest = "term_unit"
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in SCClusterByokEntityResponse. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in OfferDetailResponse. Access the value via the '{suggest}' property getter instead.")
     def __getitem__(self, key: str) -> Any:
-        SCClusterByokEntityResponse.__key_warning(key)
+        OfferDetailResponse.__key_warning(key)
         return super().__getitem__(key)
     def get(self, key: str, default = None) -> Any:
-        SCClusterByokEntityResponse.__key_warning(key)
+        OfferDetailResponse.__key_warning(key)
         return super().get(key, default)
     def __init__(__self__, *,
-                 id: Optional[str] = None,
-                 related: Optional[str] = None,
-                 resource_name: Optional[str] = None):
+                 id: str,
+                 plan_id: str,
+                 plan_name: str,
+                 publisher_id: str,
+                 status: str,
+                 term_unit: str):
         """
-        The network associated with this object
-        :param str id: ID of the referred resource
-        :param str related: API URL for accessing or modifying the referred object
-        :param str resource_name: CRN reference to the referred resource
+        Confluent Offer detail
+        :param str id: Offer Id
+        :param str plan_id: Offer Plan Id
+        :param str plan_name: Offer Plan Name
+        :param str publisher_id: Publisher Id
+        :param str status: SaaS Offer Status
+        :param str term_unit: Offer Plan Term unit
         """
-        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)
+        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__, "status", status)
+        pulumi.set(__self__, "term_unit", term_unit)
     @property
     @pulumi.getter
-    def id(self) -> Optional[str]:
+    def id(self) -> str:
         """
-        ID of the referred resource
+        Offer Id
         """
         return pulumi.get(self, "id")
     @property
-    @pulumi.getter
-    def related(self) -> Optional[str]:
-        """
-        API URL for accessing or modifying the referred object
-        """
-        return pulumi.get(self, "related")
-    @property
-    @pulumi.getter(name="resourceName")
-    def resource_name(self) -> Optional[str]:
-        """
-        CRN reference to the referred resource
-        """
-        return pulumi.get(self, "resource_name")
-@pulumi.output_type
-class SCClusterNetworkEnvironmentEntityResponse(dict):
-    """
-    The environment or the network to which cluster belongs
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "resourceName":
-            suggest = "resource_name"
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in SCClusterNetworkEnvironmentEntityResponse. Access the value via the '{suggest}' property getter instead.")
-    def __getitem__(self, key: str) -> Any:
-        SCClusterNetworkEnvironmentEntityResponse.__key_warning(key)
-        return super().__getitem__(key)
-    def get(self, key: str, default = None) -> Any:
-        SCClusterNetworkEnvironmentEntityResponse.__key_warning(key)
-        return super().get(key, default)
-    def __init__(__self__, *,
-                 environment: Optional[str] = None,
-                 id: Optional[str] = None,
-                 related: Optional[str] = None,
-                 resource_name: Optional[str] = None):
+    @pulumi.getter(name="planId")
+    def plan_id(self) -> str:
         """
-        The environment or the network to which cluster belongs
-        :param str environment: Environment of the referred resource
-        :param str id: ID of the referred resource
-        :param str related: API URL for accessing or modifying the referred object
-        :param str resource_name: CRN reference to the referred resource
+        Offer Plan Id
         """
-        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)
+        return pulumi.get(self, "plan_id")
     @property
-    @pulumi.getter
-    def environment(self) -> Optional[str]:
+    @pulumi.getter(name="planName")
+    def plan_name(self) -> str:
         """
-        Environment of the referred resource
+        Offer Plan Name
         """
-        return pulumi.get(self, "environment")
+        return pulumi.get(self, "plan_name")
     @property
-    @pulumi.getter
-    def id(self) -> Optional[str]:
+    @pulumi.getter(name="publisherId")
+    def publisher_id(self) -> str:
         """
-        ID of the referred resource
+        Publisher Id
         """
-        return pulumi.get(self, "id")
+        return pulumi.get(self, "publisher_id")
     @property
     @pulumi.getter
-    def related(self) -> Optional[str]:
+    def status(self) -> str:
         """
-        API URL for accessing or modifying the referred object
+        SaaS Offer Status
         """
-        return pulumi.get(self, "related")
+        return pulumi.get(self, "status")
     @property
-    @pulumi.getter(name="resourceName")
-    def resource_name(self) -> Optional[str]:
+    @pulumi.getter(name="termUnit")
+    def term_unit(self) -> str:
         """
-        CRN reference to the referred resource
+        Offer Plan Term unit
         """
-        return pulumi.get(self, "resource_name")
+        return pulumi.get(self, "term_unit")
 @pulumi.output_type
-class SCClusterSpecEntityResponse(dict):
+class RegionRecordResponse(dict):
     """
-    Spec of the cluster record
+    Details of region record
     """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "apiEndpoint":
-            suggest = "api_endpoint"
-        elif key == "httpEndpoint":
-            suggest = "http_endpoint"
-        elif key == "kafkaBootstrapEndpoint":
-            suggest = "kafka_bootstrap_endpoint"
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in SCClusterSpecEntityResponse. Access the value via the '{suggest}' property getter instead.")
-    def __getitem__(self, key: str) -> Any:
-        SCClusterSpecEntityResponse.__key_warning(key)
-        return super().__getitem__(key)
-    def get(self, key: str, default = None) -> Any:
-        SCClusterSpecEntityResponse.__key_warning(key)
-        return super().get(key, default)
     def __init__(__self__, *,
-                 api_endpoint: Optional[str] = None,
-                 availability: Optional[str] = None,
-                 byok: Optional['outputs.SCClusterByokEntityResponse'] = None,
-                 cloud: Optional[str] = None,
-                 config: Optional['outputs.ClusterConfigEntityResponse'] = None,
-                 environment: Optional['outputs.SCClusterNetworkEnvironmentEntityResponse'] = None,
-                 http_endpoint: Optional[str] = None,
-                 kafka_bootstrap_endpoint: Optional[str] = None,
-                 name: Optional[str] = None,
-                 network: Optional['outputs.SCClusterNetworkEnvironmentEntityResponse'] = None,
-                 package: Optional[str] = None,
-                 region: Optional[str] = None,
-                 zone: Optional[str] = None):
+                 id: Optional[str] = None,
+                 kind: Optional[str] = None,
+                 metadata: Optional['outputs.SCMetadataEntityResponse'] = None,
+                 spec: Optional['outputs.RegionSpecEntityResponse'] = None):
         """
-        Spec of the cluster record
-        :param str api_endpoint: The Kafka API cluster endpoint
-        :param str availability: The availability zone configuration of the cluster
-        :param 'SCClusterByokEntityResponse' byok: Specification of the cluster byok
-        :param str cloud: The cloud service provider
-        :param 'ClusterConfigEntityResponse' config: Specification of the cluster configuration
-        :param 'SCClusterNetworkEnvironmentEntityResponse' environment: Specification of the cluster environment
-        :param str http_endpoint: The cluster HTTP request URL.
-        :param str kafka_bootstrap_endpoint: The bootstrap endpoint used by Kafka clients to connect to the cluster
-        :param str name: The name of the cluster
-        :param 'SCClusterNetworkEnvironmentEntityResponse' network: Specification of the cluster network
-        :param str package: Stream governance configuration
-        :param str region: The cloud service provider region
-        :param str zone: type of zone availability
+        Details of region record
+        :param str id: Id of the cluster
+        :param str kind: Kind of the cluster
+        :param 'SCMetadataEntityResponse' metadata: Metadata of the record
+        :param 'RegionSpecEntityResponse' spec: Specification of the region
         """
-        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)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if kind is not None:
+            pulumi.set(__self__, "kind", kind)
+        if metadata is not None:
+            pulumi.set(__self__, "metadata", metadata)
+        if spec is not None:
+            pulumi.set(__self__, "spec", spec)
     @property
-    @pulumi.getter(name="apiEndpoint")
-    def api_endpoint(self) -> Optional[str]:
+    @pulumi.getter
+    def id(self) -> Optional[str]:
         """
-        The Kafka API cluster endpoint
+        Id of the cluster
         """
-        return pulumi.get(self, "api_endpoint")
+        return pulumi.get(self, "id")
     @property
     @pulumi.getter
-    def availability(self) -> Optional[str]:
+    def kind(self) -> Optional[str]:
         """
-        The availability zone configuration of the cluster
+        Kind of the cluster
         """
-        return pulumi.get(self, "availability")
+        return pulumi.get(self, "kind")
     @property
     @pulumi.getter
-    def byok(self) -> Optional['outputs.SCClusterByokEntityResponse']:
+    def metadata(self) -> Optional['outputs.SCMetadataEntityResponse']:
         """
-        Specification of the cluster byok
+        Metadata of the record
         """
-        return pulumi.get(self, "byok")
+        return pulumi.get(self, "metadata")
+    @property
+    @pulumi.getter
+    def spec(self) -> Optional['outputs.RegionSpecEntityResponse']:
+        """
+        Specification of the region
+        """
+        return pulumi.get(self, "spec")
+@pulumi.output_type
+class RegionSpecEntityResponse(dict):
+    """
+    Region spec details
+    """
+    def __init__(__self__, *,
+                 cloud: Optional[str] = None,
+                 name: Optional[str] = None,
+                 packages: Optional[Sequence[str]] = None,
+                 region_name: Optional[str] = None):
+        """
+        Region spec details
+        :param str cloud: Cloud provider name
+        :param str name: Display Name of the region
+        :param str region_name: Region name
+        """
+        if cloud is not None:
+            pulumi.set(__self__, "cloud", cloud)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if packages is not None:
+            pulumi.set(__self__, "packages", packages)
+        if region_name is not None:
+            pulumi.set(__self__, "region_name", region_name)
     @property
     @pulumi.getter
     def cloud(self) -> Optional[str]:
         """
-        The cloud service provider
+        Cloud provider name
         """
         return pulumi.get(self, "cloud")
     @property
     @pulumi.getter
-    def config(self) -> Optional['outputs.ClusterConfigEntityResponse']:
+    def name(self) -> Optional[str]:
         """
-        Specification of the cluster configuration
+        Display Name of the region
         """
-        return pulumi.get(self, "config")
+        return pulumi.get(self, "name")
     @property
     @pulumi.getter
-    def environment(self) -> Optional['outputs.SCClusterNetworkEnvironmentEntityResponse']:
+    def packages(self) -> Optional[Sequence[str]]:
+        return pulumi.get(self, "packages")
+    @property
+    @pulumi.getter(name="regionName")
+    def region_name(self) -> Optional[str]:
         """
-        Specification of the cluster environment
+        Region name
         """
-        return pulumi.get(self, "environment")
+        return pulumi.get(self, "region_name")
-    @property
-    @pulumi.getter(name="httpEndpoint")
-    def http_endpoint(self) -> Optional[str]:
+@pulumi.output_type
+class RoleBindingRecordResponse(dict):
+    """
+    Record of the environment
+    """
+    def __init__(__self__, *,
+                 crn_pattern: Optional[str] = None,
+                 id: Optional[str] = None,
+                 kind: Optional[str] = None,
+                 metadata: Optional['outputs.MetadataEntityResponse'] = None,
+                 principal: Optional[str] = None,
+                 role_name: Optional[str] = None):
         """
-        The cluster HTTP request URL.
+        Record of the environment
+        :param str crn_pattern: A CRN that specifies the scope and resource patterns necessary for the role to bind
+        :param str id: Id of the role
+        :param str kind: The type of the resource.
+        :param 'MetadataEntityResponse' metadata: Metadata of the record
+        :param str principal: The principal User or Group to bind the role to
+        :param str role_name: The name of the role to bind to the principal
         """
-        return pulumi.get(self, "http_endpoint")
+        if crn_pattern is not None:
+            pulumi.set(__self__, "crn_pattern", crn_pattern)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if kind is not None:
+            pulumi.set(__self__, "kind", kind)
+        if metadata is not None:
+            pulumi.set(__self__, "metadata", metadata)
+        if principal is not None:
+            pulumi.set(__self__, "principal", principal)
+        if role_name is not None:
+            pulumi.set(__self__, "role_name", role_name)
     @property
-    @pulumi.getter(name="kafkaBootstrapEndpoint")
-    def kafka_bootstrap_endpoint(self) -> Optional[str]:
+    @pulumi.getter(name="crnPattern")
+    def crn_pattern(self) -> Optional[str]:
         """
-        The bootstrap endpoint used by Kafka clients to connect to the cluster
+        A CRN that specifies the scope and resource patterns necessary for the role to bind
         """
-        return pulumi.get(self, "kafka_bootstrap_endpoint")
+        return pulumi.get(self, "crn_pattern")
     @property
     @pulumi.getter
-    def name(self) -> Optional[str]:
+    def id(self) -> Optional[str]:
         """
-        The name of the cluster
+        Id of the role
         """
-        return pulumi.get(self, "name")
+        return pulumi.get(self, "id")
     @property
     @pulumi.getter
-    def network(self) -> Optional['outputs.SCClusterNetworkEnvironmentEntityResponse']:
+    def kind(self) -> Optional[str]:
         """
-        Specification of the cluster network
+        The type of the resource.
         """
-        return pulumi.get(self, "network")
+        return pulumi.get(self, "kind")
     @property
     @pulumi.getter
-    def package(self) -> Optional[str]:
+    def metadata(self) -> Optional['outputs.MetadataEntityResponse']:
         """
-        Stream governance configuration
+        Metadata of the record
         """
-        return pulumi.get(self, "package")
+        return pulumi.get(self, "metadata")
     @property
     @pulumi.getter
-    def region(self) -> Optional[str]:
+    def principal(self) -> Optional[str]:
         """
-        The cloud service provider region
+        The principal User or Group to bind the role to
         """
-        return pulumi.get(self, "region")
+        return pulumi.get(self, "principal")
     @property
-    @pulumi.getter
-    def zone(self) -> Optional[str]:
+    @pulumi.getter(name="roleName")
+    def role_name(self) -> Optional[str]:
         """
-        type of zone availability
+        The name of the role to bind to the principal
         """
-        return pulumi.get(self, "zone")
+        return pulumi.get(self, "role_name")
 @pulumi.output_type
@@ -2964,29 +1109,6 @@ class SCMetadataEntityResponse(dict):
     """
     Metadata of the data record
     """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "createdTimestamp":
-            suggest = "created_timestamp"
-        elif key == "deletedTimestamp":
-            suggest = "deleted_timestamp"
-        elif key == "resourceName":
-            suggest = "resource_name"
-        elif key == "updatedTimestamp":
-            suggest = "updated_timestamp"
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in SCMetadataEntityResponse. Access the value via the '{suggest}' property getter instead.")
-    def __getitem__(self, key: str) -> Any:
-        SCMetadataEntityResponse.__key_warning(key)
-        return super().__getitem__(key)
-    def get(self, key: str, default = None) -> Any:
-        SCMetadataEntityResponse.__key_warning(key)
-        return super().get(key, default)
     def __init__(__self__, *,
                  created_timestamp: Optional[str] = None,
                  deleted_timestamp: Optional[str] = None,
@@ -3124,29 +1246,6 @@ class ServiceAccountRecordResponse(dict):
         return pulumi.get(self, "metadata")
-@pulumi.output_type
-class StreamGovernanceConfigResponse(dict):
-    """
-    Stream governance configuration
-    """
-    def __init__(__self__, *,
-                 package: Optional[str] = None):
-        """
-        Stream governance configuration
-        :param str package: Stream governance configuration
-        """
-        if package is not None:
-            pulumi.set(__self__, "package", package)
-    @property
-    @pulumi.getter
-    def package(self) -> Optional[str]:
-        """
-        Stream governance configuration
-        """
-        return pulumi.get(self, "package")
 @pulumi.output_type
 class SystemDataResponse(dict):
     """
@@ -3257,116 +1356,6 @@ class SystemDataResponse(dict):
         return pulumi.get(self, "last_modified_by_type")
-@pulumi.output_type
-class TopicMetadataEntityResponse(dict):
-    """
-    Metadata of the data record
-    """
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "resourceName":
-            suggest = "resource_name"
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in TopicMetadataEntityResponse. Access the value via the '{suggest}' property getter instead.")
-    def __getitem__(self, key: str) -> Any:
-        TopicMetadataEntityResponse.__key_warning(key)
-        return super().__getitem__(key)
-    def get(self, key: str, default = None) -> Any:
-        TopicMetadataEntityResponse.__key_warning(key)
-        return super().get(key, default)
-    def __init__(__self__, *,
-                 resource_name: Optional[str] = None,
-                 self: Optional[str] = None):
-        """
-        Metadata of the data record
-        :param str resource_name: Resource name of the record
-        :param 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[str]:
-        """
-        Resource name of the record
-        """
-        return pulumi.get(self, "resource_name")
-    @property
-    @pulumi.getter
-    def self(self) -> Optional[str]:
-        """
-        Self lookup url
-        """
-        return pulumi.get(self, "self")
-@pulumi.output_type
-class TopicsInputConfigResponse(dict):
-    """
-    Topics input config
-    """
-    def __init__(__self__, *,
-                 name: Optional[str] = None,
-                 value: Optional[str] = None):
-        """
-        Topics input config
-        :param str name: Name of the topic input config
-        :param 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[str]:
-        """
-        Name of the topic input config
-        """
-        return pulumi.get(self, "name")
-    @property
-    @pulumi.getter
-    def value(self) -> Optional[str]:
-        """
-        Value of the topic input config
-        """
-        return pulumi.get(self, "value")
-@pulumi.output_type
-class TopicsRelatedLinkResponse(dict):
-    """
-    Partition Config spec of the topic record
-    """
-    def __init__(__self__, *,
-                 related: Optional[str] = None):
-        """
-        Partition Config spec of the topic record
-        :param str related: Relationship of the topic
-        """
-        if related is not None:
-            pulumi.set(__self__, "related", related)
-    @property
-    @pulumi.getter
-    def related(self) -> Optional[str]:
-        """
-        Relationship of the topic
-        """
-        return pulumi.get(self, "related")
 @pulumi.output_type
 class UserDetailResponse(dict):
     """