# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from . import _utilities
from . import outputs

__all__ = [
    'AccessPointAwsEgressPrivateLinkEndpoint',
    'AccessPointAwsPrivateNetworkInterface',
    'AccessPointAzureEgressPrivateLinkEndpoint',
    'AccessPointEnvironment',
    'AccessPointGateway',
    'AccessPointGcpEgressPrivateServiceConnectEndpoint',
    'ApiKeyManagedResource',
    'ApiKeyManagedResourceEnvironment',
    'ApiKeyOwner',
    'BusinessMetadataAttributeDefinition',
    'BusinessMetadataBindingCredentials',
    'BusinessMetadataBindingSchemaRegistryCluster',
    'BusinessMetadataCredentials',
    'BusinessMetadataSchemaRegistryCluster',
    'ByokKeyAws',
    'ByokKeyAzure',
    'ByokKeyGcp',
    'CatalogEntityAttributesCredentials',
    'CatalogEntityAttributesSchemaRegistryCluster',
    'CertificatePoolCertificateAuthority',
    'ClusterLinkDestinationKafkaCluster',
    'ClusterLinkDestinationKafkaClusterCredentials',
    'ClusterLinkLocalKafkaCluster',
    'ClusterLinkLocalKafkaClusterCredentials',
    'ClusterLinkRemoteKafkaCluster',
    'ClusterLinkRemoteKafkaClusterCredentials',
    'ClusterLinkSourceKafkaCluster',
    'ClusterLinkSourceKafkaClusterCredentials',
    'ConnectorEnvironment',
    'ConnectorKafkaCluster',
    'ConnectorOffset',
    'DnsForwarderEnvironment',
    'DnsForwarderForwardViaGcpDnsZones',
    'DnsForwarderForwardViaIp',
    'DnsForwarderGateway',
    'DnsRecordEnvironment',
    'DnsRecordGateway',
    'DnsRecordPrivateLinkAccessPoint',
    'EnvironmentStreamGovernance',
    'FlinkArtifactEnvironment',
    'FlinkArtifactVersion',
    'FlinkComputePoolEnvironment',
    'FlinkStatementComputePool',
    'FlinkStatementCredentials',
    'FlinkStatementEnvironment',
    'FlinkStatementOrganization',
    'FlinkStatementPrincipal',
    'GatewayAwsEgressPrivateLinkGateway',
    'GatewayAwsPrivateNetworkInterfaceGateway',
    'GatewayAzureEgressPrivateLinkGateway',
    'GatewayEnvironment',
    'IdentityPoolIdentityProvider',
    'InvitationCreator',
    'InvitationUser',
    'KafkaAclCredentials',
    'KafkaAclKafkaCluster',
    'KafkaClientQuotaEnvironment',
    'KafkaClientQuotaKafkaCluster',
    'KafkaClientQuotaThroughput',
    'KafkaClusterBasic',
    'KafkaClusterByokKey',
    'KafkaClusterConfigCredentials',
    'KafkaClusterConfigKafkaCluster',
    'KafkaClusterDedicated',
    'KafkaClusterEnterprise',
    'KafkaClusterEnvironment',
    'KafkaClusterFreight',
    'KafkaClusterNetwork',
    'KafkaClusterStandard',
    'KafkaMirrorTopicClusterLink',
    'KafkaMirrorTopicKafkaCluster',
    'KafkaMirrorTopicKafkaClusterCredentials',
    'KafkaMirrorTopicSourceKafkaTopic',
    'KafkaTopicCredentials',
    'KafkaTopicKafkaCluster',
    'KsqlClusterCredentialIdentity',
    'KsqlClusterEnvironment',
    'KsqlClusterKafkaCluster',
    'NetworkAw',
    'NetworkAzure',
    'NetworkDnsConfig',
    'NetworkEnvironment',
    'NetworkGateway',
    'NetworkGcp',
    'NetworkLinkEndpointEnvironment',
    'NetworkLinkEndpointNetwork',
    'NetworkLinkEndpointNetworkLinkService',
    'NetworkLinkServiceAccept',
    'NetworkLinkServiceEnvironment',
    'NetworkLinkServiceNetwork',
    'NetworkZoneInfo',
    'PeeringAws',
    'PeeringAzure',
    'PeeringEnvironment',
    'PeeringGcp',
    'PeeringNetwork',
    'PrivateLinkAccessAws',
    'PrivateLinkAccessAzure',
    'PrivateLinkAccessEnvironment',
    'PrivateLinkAccessGcp',
    'PrivateLinkAccessNetwork',
    'PrivateLinkAttachmentAw',
    'PrivateLinkAttachmentAzure',
    'PrivateLinkAttachmentConnectionAws',
    'PrivateLinkAttachmentConnectionAzure',
    'PrivateLinkAttachmentConnectionEnvironment',
    'PrivateLinkAttachmentConnectionGcp',
    'PrivateLinkAttachmentConnectionPrivateLinkAttachment',
    'PrivateLinkAttachmentEnvironment',
    'PrivateLinkAttachmentGcp',
    'ProviderIntegrationAws',
    'ProviderIntegrationEnvironment',
    'SchemaCredentials',
    'SchemaExporterCredentials',
    'SchemaExporterDestinationSchemaRegistryCluster',
    'SchemaExporterDestinationSchemaRegistryClusterCredentials',
    'SchemaExporterSchemaRegistryCluster',
    'SchemaMetadata',
    'SchemaMetadataTag',
    'SchemaRegistryClusterConfigCredentials',
    'SchemaRegistryClusterConfigSchemaRegistryCluster',
    'SchemaRegistryClusterModeCredentials',
    'SchemaRegistryClusterModeSchemaRegistryCluster',
    'SchemaRegistryDekCredentials',
    'SchemaRegistryDekSchemaRegistryCluster',
    'SchemaRegistryKekCredentials',
    'SchemaRegistryKekSchemaRegistryCluster',
    'SchemaRuleset',
    'SchemaRulesetDomainRule',
    'SchemaRulesetMigrationRule',
    'SchemaSchemaReference',
    'SchemaSchemaRegistryCluster',
    'SubjectConfigCredentials',
    'SubjectConfigSchemaRegistryCluster',
    'SubjectModeCredentials',
    'SubjectModeSchemaRegistryCluster',
    'TagBindingCredentials',
    'TagBindingSchemaRegistryCluster',
    'TagCredentials',
    'TagSchemaRegistryCluster',
    'TransitGatewayAttachmentAws',
    'TransitGatewayAttachmentEnvironment',
    'TransitGatewayAttachmentNetwork',
    'GetAccessPointAwsEgressPrivateLinkEndpointResult',
    'GetAccessPointAwsPrivateNetworkInterfaceResult',
    'GetAccessPointAzureEgressPrivateLinkEndpointResult',
    'GetAccessPointEnvironmentResult',
    'GetAccessPointGatewayResult',
    'GetAccessPointGcpEgressPrivateServiceConnectEndpointResult',
    'GetBusinessMetadataAttributeDefinitionResult',
    'GetBusinessMetadataBindingCredentialsResult',
    'GetBusinessMetadataBindingSchemaRegistryClusterResult',
    'GetBusinessMetadataCredentialsResult',
    'GetBusinessMetadataSchemaRegistryClusterResult',
    'GetByokKeyAwResult',
    'GetByokKeyAzureResult',
    'GetByokKeyGcpResult',
    'GetCertificatePoolCertificateAuthorityResult',
    'GetClusterLinkCredentialsResult',
    'GetClusterLinkKafkaClusterResult',
    'GetDnsRecordEnvironmentResult',
    'GetDnsRecordGatewayResult',
    'GetDnsRecordPrivateLinkAccessPointResult',
    'GetEnvironmentStreamGovernanceResult',
    'GetFlinkArtifactEnvironmentResult',
    'GetFlinkArtifactVersionResult',
    'GetFlinkComputePoolEnvironmentResult',
    'GetGatewayAwsEgressPrivateLinkGatewayResult',
    'GetGatewayAwsPeeringGatewayResult',
    'GetGatewayAwsPrivateNetworkInterfaceGatewayResult',
    'GetGatewayAzureEgressPrivateLinkGatewayResult',
    'GetGatewayAzurePeeringGatewayResult',
    'GetGatewayEnvironmentResult',
    'GetGatewayGcpEgressPrivateServiceConnectGatewayResult',
    'GetGatewayGcpPeeringGatewayResult',
    'GetIdentityPoolIdentityProviderResult',
    'GetInvitationCreatorResult',
    'GetInvitationUserResult',
    'GetIpAddressesFilterResult',
    'GetIpAddressesIpAddressResult',
    'GetKafkaClientQuotaEnvironmentResult',
    'GetKafkaClientQuotaKafkaClusterResult',
    'GetKafkaClientQuotaThroughputResult',
    'GetKafkaClusterBasicResult',
    'GetKafkaClusterByokKeyResult',
    'GetKafkaClusterDedicatedResult',
    'GetKafkaClusterEnterpriseResult',
    'GetKafkaClusterEnvironmentResult',
    'GetKafkaClusterFreightResult',
    'GetKafkaClusterNetworkResult',
    'GetKafkaClusterStandardResult',
    'GetKafkaTopicCredentialsResult',
    'GetKafkaTopicKafkaClusterResult',
    'GetKsqlClusterCredentialIdentityResult',
    'GetKsqlClusterEnvironmentResult',
    'GetKsqlClusterKafkaClusterResult',
    'GetNetworkAwResult',
    'GetNetworkAzureResult',
    'GetNetworkDnsConfigResult',
    'GetNetworkEnvironmentResult',
    'GetNetworkGatewayResult',
    'GetNetworkGcpResult',
    'GetNetworkLinkEndpointEnvironmentResult',
    'GetNetworkLinkEndpointNetworkResult',
    'GetNetworkLinkEndpointNetworkLinkServiceResult',
    'GetNetworkLinkServiceAcceptResult',
    'GetNetworkLinkServiceEnvironmentResult',
    'GetNetworkLinkServiceNetworkResult',
    'GetNetworkZoneInfoResult',
    'GetPeeringAwResult',
    'GetPeeringAzureResult',
    'GetPeeringEnvironmentResult',
    'GetPeeringGcpResult',
    'GetPeeringNetworkResult',
    'GetPrivateLinkAccessAwResult',
    'GetPrivateLinkAccessAzureResult',
    'GetPrivateLinkAccessEnvironmentResult',
    'GetPrivateLinkAccessGcpResult',
    'GetPrivateLinkAccessNetworkResult',
    'GetPrivateLinkAttachmentAwResult',
    'GetPrivateLinkAttachmentAzureResult',
    'GetPrivateLinkAttachmentConnectionAwResult',
    'GetPrivateLinkAttachmentConnectionAzureResult',
    'GetPrivateLinkAttachmentConnectionEnvironmentResult',
    'GetPrivateLinkAttachmentConnectionGcpResult',
    'GetPrivateLinkAttachmentConnectionPrivateLinkAttachmentResult',
    'GetPrivateLinkAttachmentEnvironmentResult',
    'GetPrivateLinkAttachmentGcpResult',
    'GetProviderIntegrationAwResult',
    'GetProviderIntegrationEnvironmentResult',
    'GetSchemaCredentialsResult',
    'GetSchemaMetadataResult',
    'GetSchemaMetadataTagResult',
    'GetSchemaRegistryClusterConfigCredentialsResult',
    'GetSchemaRegistryClusterConfigSchemaRegistryClusterResult',
    'GetSchemaRegistryClusterEnvironmentResult',
    'GetSchemaRegistryClusterModeCredentialsResult',
    'GetSchemaRegistryClusterModeSchemaRegistryClusterResult',
    'GetSchemaRegistryClustersClusterResult',
    'GetSchemaRegistryClustersClusterEnvironmentResult',
    'GetSchemaRegistryClustersEnvironmentResult',
    'GetSchemaRegistryDekCredentialsResult',
    'GetSchemaRegistryDekSchemaRegistryClusterResult',
    'GetSchemaRegistryKekCredentialsResult',
    'GetSchemaRegistryKekSchemaRegistryClusterResult',
    'GetSchemaRulesetResult',
    'GetSchemaRulesetDomainRuleResult',
    'GetSchemaRulesetMigrationRuleResult',
    'GetSchemaSchemaReferenceResult',
    'GetSchemaSchemaRegistryClusterResult',
    'GetSchemasCredentialsResult',
    'GetSchemasFilterResult',
    'GetSchemasSchemaResult',
    'GetSchemasSchemaRegistryClusterResult',
    'GetSchemasSchemaSchemaReferenceResult',
    'GetSubjectConfigCredentialsResult',
    'GetSubjectConfigSchemaRegistryClusterResult',
    'GetSubjectModeCredentialsResult',
    'GetSubjectModeSchemaRegistryClusterResult',
    'GetTagBindingCredentialsResult',
    'GetTagBindingSchemaRegistryClusterResult',
    'GetTagCredentialsResult',
    'GetTagSchemaRegistryClusterResult',
    'GetTransitGatewayAttachmentAwResult',
    'GetTransitGatewayAttachmentEnvironmentResult',
    'GetTransitGatewayAttachmentNetworkResult',
]

@pulumi.output_type
class AccessPointAwsEgressPrivateLinkEndpoint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vpcEndpointServiceName":
            suggest = "vpc_endpoint_service_name"
        elif key == "enableHighAvailability":
            suggest = "enable_high_availability"
        elif key == "vpcEndpointDnsName":
            suggest = "vpc_endpoint_dns_name"
        elif key == "vpcEndpointId":
            suggest = "vpc_endpoint_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccessPointAwsEgressPrivateLinkEndpoint. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccessPointAwsEgressPrivateLinkEndpoint.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccessPointAwsEgressPrivateLinkEndpoint.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 vpc_endpoint_service_name: str,
                 enable_high_availability: Optional[bool] = None,
                 vpc_endpoint_dns_name: Optional[str] = None,
                 vpc_endpoint_id: Optional[str] = None):
        """
        :param str vpc_endpoint_service_name: AWS VPC Endpoint Service that can be used to establish connections for all zones, for example `com.amazonaws.vpce.us-west-2.vpce-svc-0d3be37e21708ecd3`.
        :param bool enable_high_availability: Whether a resource should be provisioned with high availability. Endpoints deployed with high availability have network interfaces deployed in multiple AZs. Defaults to `false`.
        :param str vpc_endpoint_dns_name: (Required String) The DNS name of a VPC Endpoint (if any) that is connected to the VPC Endpoint service, for example, `*.vpce-00000000000000000-abcd1234.s3.us-west-2.vpce.amazonaws.com`.
        :param str vpc_endpoint_id: (Required String) The ID of a VPC Endpoint (if any) that is connected to the VPC Endpoint service, for example, `vpce-00000000000000000`.
        """
        pulumi.set(__self__, "vpc_endpoint_service_name", vpc_endpoint_service_name)
        if enable_high_availability is not None:
            pulumi.set(__self__, "enable_high_availability", enable_high_availability)
        if vpc_endpoint_dns_name is not None:
            pulumi.set(__self__, "vpc_endpoint_dns_name", vpc_endpoint_dns_name)
        if vpc_endpoint_id is not None:
            pulumi.set(__self__, "vpc_endpoint_id", vpc_endpoint_id)

    @property
    @pulumi.getter(name="vpcEndpointServiceName")
    def vpc_endpoint_service_name(self) -> str:
        """
        AWS VPC Endpoint Service that can be used to establish connections for all zones, for example `com.amazonaws.vpce.us-west-2.vpce-svc-0d3be37e21708ecd3`.
        """
        return pulumi.get(self, "vpc_endpoint_service_name")

    @property
    @pulumi.getter(name="enableHighAvailability")
    def enable_high_availability(self) -> Optional[bool]:
        """
        Whether a resource should be provisioned with high availability. Endpoints deployed with high availability have network interfaces deployed in multiple AZs. Defaults to `false`.
        """
        return pulumi.get(self, "enable_high_availability")

    @property
    @pulumi.getter(name="vpcEndpointDnsName")
    def vpc_endpoint_dns_name(self) -> Optional[str]:
        """
        (Required String) The DNS name of a VPC Endpoint (if any) that is connected to the VPC Endpoint service, for example, `*.vpce-00000000000000000-abcd1234.s3.us-west-2.vpce.amazonaws.com`.
        """
        return pulumi.get(self, "vpc_endpoint_dns_name")

    @property
    @pulumi.getter(name="vpcEndpointId")
    def vpc_endpoint_id(self) -> Optional[str]:
        """
        (Required String) The ID of a VPC Endpoint (if any) that is connected to the VPC Endpoint service, for example, `vpce-00000000000000000`.
        """
        return pulumi.get(self, "vpc_endpoint_id")


@pulumi.output_type
class AccessPointAwsPrivateNetworkInterface(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "networkInterfaces":
            suggest = "network_interfaces"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccessPointAwsPrivateNetworkInterface. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccessPointAwsPrivateNetworkInterface.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccessPointAwsPrivateNetworkInterface.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 account: str,
                 network_interfaces: Sequence[str]):
        """
        :param str account: (Required String) The AWS account ID associated with the ENIs you are using for the Confluent Private Network Interface, for example: `000000000000`.
        :param Sequence[str] network_interfaces: (Required List of Strings) List of the IDs of the Elastic Network Interfaces, for example: `["eni-00000000000000000", "eni-00000000000000001", "eni-00000000000000002", "eni-00000000000000003", "eni-00000000000000004", "eni-00000000000000005"]`
        """
        pulumi.set(__self__, "account", account)
        pulumi.set(__self__, "network_interfaces", network_interfaces)

    @property
    @pulumi.getter
    def account(self) -> str:
        """
        (Required String) The AWS account ID associated with the ENIs you are using for the Confluent Private Network Interface, for example: `000000000000`.
        """
        return pulumi.get(self, "account")

    @property
    @pulumi.getter(name="networkInterfaces")
    def network_interfaces(self) -> Sequence[str]:
        """
        (Required List of Strings) List of the IDs of the Elastic Network Interfaces, for example: `["eni-00000000000000000", "eni-00000000000000001", "eni-00000000000000002", "eni-00000000000000003", "eni-00000000000000004", "eni-00000000000000005"]`
        """
        return pulumi.get(self, "network_interfaces")


@pulumi.output_type
class AccessPointAzureEgressPrivateLinkEndpoint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateLinkServiceResourceId":
            suggest = "private_link_service_resource_id"
        elif key == "privateEndpointCustomDnsConfigDomains":
            suggest = "private_endpoint_custom_dns_config_domains"
        elif key == "privateEndpointDomain":
            suggest = "private_endpoint_domain"
        elif key == "privateEndpointIpAddress":
            suggest = "private_endpoint_ip_address"
        elif key == "privateEndpointResourceId":
            suggest = "private_endpoint_resource_id"
        elif key == "privateLinkSubresourceName":
            suggest = "private_link_subresource_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccessPointAzureEgressPrivateLinkEndpoint. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccessPointAzureEgressPrivateLinkEndpoint.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccessPointAzureEgressPrivateLinkEndpoint.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 private_link_service_resource_id: str,
                 private_endpoint_custom_dns_config_domains: Optional[Sequence[str]] = None,
                 private_endpoint_domain: Optional[str] = None,
                 private_endpoint_ip_address: Optional[str] = None,
                 private_endpoint_resource_id: Optional[str] = None,
                 private_link_subresource_name: Optional[str] = None):
        """
        :param str private_link_service_resource_id: Resource ID of the Azure Private Link service.
        :param Sequence[str] private_endpoint_custom_dns_config_domains: (Required List of Strings) Domains of the Private Endpoint (if any) based off FQDNs in Azure custom DNS configs, which are required in your private DNS setup, for example: `["dbname.database.windows.net", "dbname-region.database.windows.net"]`.
        :param str private_endpoint_domain: (Required String) Domain of the Private Endpoint (if any) that is connected to the Private Link service.
        :param str private_endpoint_ip_address: (Required String) IP address of the Private Endpoint (if any) that is connected to the Private Link service.
        :param str private_endpoint_resource_id: (Required String) Resource ID of the Private Endpoint (if any) that is connected to the Private Link service.
        :param str private_link_subresource_name: Name of the subresource for the Private Endpoint to connect to.
        """
        pulumi.set(__self__, "private_link_service_resource_id", private_link_service_resource_id)
        if private_endpoint_custom_dns_config_domains is not None:
            pulumi.set(__self__, "private_endpoint_custom_dns_config_domains", private_endpoint_custom_dns_config_domains)
        if private_endpoint_domain is not None:
            pulumi.set(__self__, "private_endpoint_domain", private_endpoint_domain)
        if private_endpoint_ip_address is not None:
            pulumi.set(__self__, "private_endpoint_ip_address", private_endpoint_ip_address)
        if private_endpoint_resource_id is not None:
            pulumi.set(__self__, "private_endpoint_resource_id", private_endpoint_resource_id)
        if private_link_subresource_name is not None:
            pulumi.set(__self__, "private_link_subresource_name", private_link_subresource_name)

    @property
    @pulumi.getter(name="privateLinkServiceResourceId")
    def private_link_service_resource_id(self) -> str:
        """
        Resource ID of the Azure Private Link service.
        """
        return pulumi.get(self, "private_link_service_resource_id")

    @property
    @pulumi.getter(name="privateEndpointCustomDnsConfigDomains")
    def private_endpoint_custom_dns_config_domains(self) -> Optional[Sequence[str]]:
        """
        (Required List of Strings) Domains of the Private Endpoint (if any) based off FQDNs in Azure custom DNS configs, which are required in your private DNS setup, for example: `["dbname.database.windows.net", "dbname-region.database.windows.net"]`.
        """
        return pulumi.get(self, "private_endpoint_custom_dns_config_domains")

    @property
    @pulumi.getter(name="privateEndpointDomain")
    def private_endpoint_domain(self) -> Optional[str]:
        """
        (Required String) Domain of the Private Endpoint (if any) that is connected to the Private Link service.
        """
        return pulumi.get(self, "private_endpoint_domain")

    @property
    @pulumi.getter(name="privateEndpointIpAddress")
    def private_endpoint_ip_address(self) -> Optional[str]:
        """
        (Required String) IP address of the Private Endpoint (if any) that is connected to the Private Link service.
        """
        return pulumi.get(self, "private_endpoint_ip_address")

    @property
    @pulumi.getter(name="privateEndpointResourceId")
    def private_endpoint_resource_id(self) -> Optional[str]:
        """
        (Required String) Resource ID of the Private Endpoint (if any) that is connected to the Private Link service.
        """
        return pulumi.get(self, "private_endpoint_resource_id")

    @property
    @pulumi.getter(name="privateLinkSubresourceName")
    def private_link_subresource_name(self) -> Optional[str]:
        """
        Name of the subresource for the Private Endpoint to connect to.
        """
        return pulumi.get(self, "private_link_subresource_name")


@pulumi.output_type
class AccessPointEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Access Point belongs to, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Access Point belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class AccessPointGateway(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the gateway to which the Access Point belongs, for example, `gw-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the gateway to which the Access Point belongs, for example, `gw-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class AccessPointGcpEgressPrivateServiceConnectEndpoint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateServiceConnectEndpointTarget":
            suggest = "private_service_connect_endpoint_target"
        elif key == "privateServiceConnectEndpointConnectionId":
            suggest = "private_service_connect_endpoint_connection_id"
        elif key == "privateServiceConnectEndpointIpAddress":
            suggest = "private_service_connect_endpoint_ip_address"
        elif key == "privateServiceConnectEndpointName":
            suggest = "private_service_connect_endpoint_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccessPointGcpEgressPrivateServiceConnectEndpoint. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccessPointGcpEgressPrivateServiceConnectEndpoint.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccessPointGcpEgressPrivateServiceConnectEndpoint.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 private_service_connect_endpoint_target: str,
                 private_service_connect_endpoint_connection_id: Optional[str] = None,
                 private_service_connect_endpoint_ip_address: Optional[str] = None,
                 private_service_connect_endpoint_name: Optional[str] = None):
        """
        :param str private_service_connect_endpoint_target: URI of the service attachment for the published service that the Private Service Connect Endpoint connects to, or "all-google-apis" for global Google APIs.
        :param str private_service_connect_endpoint_connection_id: (Required String) Connection ID of the Private Service Connect Endpoint that is connected to the endpoint target.
        :param str private_service_connect_endpoint_ip_address: (Required String) IP address of the Private Service Connect Endpoint that is connected to the endpoint target.
        :param str private_service_connect_endpoint_name: (Required String) Name of the Private Service Connect Endpoint that is connected to the endpoint target.
        """
        pulumi.set(__self__, "private_service_connect_endpoint_target", private_service_connect_endpoint_target)
        if private_service_connect_endpoint_connection_id is not None:
            pulumi.set(__self__, "private_service_connect_endpoint_connection_id", private_service_connect_endpoint_connection_id)
        if private_service_connect_endpoint_ip_address is not None:
            pulumi.set(__self__, "private_service_connect_endpoint_ip_address", private_service_connect_endpoint_ip_address)
        if private_service_connect_endpoint_name is not None:
            pulumi.set(__self__, "private_service_connect_endpoint_name", private_service_connect_endpoint_name)

    @property
    @pulumi.getter(name="privateServiceConnectEndpointTarget")
    def private_service_connect_endpoint_target(self) -> str:
        """
        URI of the service attachment for the published service that the Private Service Connect Endpoint connects to, or "all-google-apis" for global Google APIs.
        """
        return pulumi.get(self, "private_service_connect_endpoint_target")

    @property
    @pulumi.getter(name="privateServiceConnectEndpointConnectionId")
    def private_service_connect_endpoint_connection_id(self) -> Optional[str]:
        """
        (Required String) Connection ID of the Private Service Connect Endpoint that is connected to the endpoint target.
        """
        return pulumi.get(self, "private_service_connect_endpoint_connection_id")

    @property
    @pulumi.getter(name="privateServiceConnectEndpointIpAddress")
    def private_service_connect_endpoint_ip_address(self) -> Optional[str]:
        """
        (Required String) IP address of the Private Service Connect Endpoint that is connected to the endpoint target.
        """
        return pulumi.get(self, "private_service_connect_endpoint_ip_address")

    @property
    @pulumi.getter(name="privateServiceConnectEndpointName")
    def private_service_connect_endpoint_name(self) -> Optional[str]:
        """
        (Required String) Name of the Private Service Connect Endpoint that is connected to the endpoint target.
        """
        return pulumi.get(self, "private_service_connect_endpoint_name")


@pulumi.output_type
class ApiKeyManagedResource(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiVersion":
            suggest = "api_version"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ApiKeyManagedResource. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ApiKeyManagedResource.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ApiKeyManagedResource.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 api_version: str,
                 id: str,
                 kind: str,
                 environment: Optional['outputs.ApiKeyManagedResourceEnvironment'] = None):
        """
        :param str api_version: The API group and version of the managed resource that the API Key associated with, for example, `cmk/v2`.
        :param str id: The ID of the managed resource that the API Key associated with, for example, `lkc-abc123`.
        :param str kind: The kind of the managed resource that the API Key associated with, for example, `Cluster`.
        """
        pulumi.set(__self__, "api_version", api_version)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "kind", kind)
        if environment is not None:
            pulumi.set(__self__, "environment", environment)

    @property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> str:
        """
        The API group and version of the managed resource that the API Key associated with, for example, `cmk/v2`.
        """
        return pulumi.get(self, "api_version")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the managed resource that the API Key associated with, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def kind(self) -> str:
        """
        The kind of the managed resource that the API Key associated with, for example, `Cluster`.
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter
    def environment(self) -> Optional['outputs.ApiKeyManagedResourceEnvironment']:
        return pulumi.get(self, "environment")


@pulumi.output_type
class ApiKeyManagedResourceEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the managed resource belongs to, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the managed resource belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class ApiKeyOwner(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiVersion":
            suggest = "api_version"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ApiKeyOwner. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ApiKeyOwner.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ApiKeyOwner.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 api_version: str,
                 id: str,
                 kind: str):
        """
        :param str api_version: The API group and version of the owner that the API Key belongs to, for example, `iam/v2`.
        :param str id: The ID of the owner that the API Key belongs to, for example, `sa-abc123` or `u-abc123`.
        :param str kind: The kind of the owner that the API Key belongs to, for example, `ServiceAccount` or `User`.
        """
        pulumi.set(__self__, "api_version", api_version)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "kind", kind)

    @property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> str:
        """
        The API group and version of the owner that the API Key belongs to, for example, `iam/v2`.
        """
        return pulumi.get(self, "api_version")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the owner that the API Key belongs to, for example, `sa-abc123` or `u-abc123`.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def kind(self) -> str:
        """
        The kind of the owner that the API Key belongs to, for example, `ServiceAccount` or `User`.
        """
        return pulumi.get(self, "kind")


@pulumi.output_type
class BusinessMetadataAttributeDefinition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultValue":
            suggest = "default_value"
        elif key == "isOptional":
            suggest = "is_optional"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in BusinessMetadataAttributeDefinition. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        BusinessMetadataAttributeDefinition.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        BusinessMetadataAttributeDefinition.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 default_value: Optional[str] = None,
                 description: Optional[str] = None,
                 is_optional: Optional[bool] = None,
                 options: Optional[Mapping[str, str]] = None,
                 type: Optional[str] = None):
        """
        :param str name: The name of the attribute.
        :param str default_value: The default value of this attribute.
        :param str description: The description of this attribute.
        :param bool is_optional: An optional flag to control whether the attribute should be optional or required. The default value is `false`.
        :param Mapping[str, str] options: (Optional Map) Block for the attribute options:
               - `applicableEntityTypes` - (Optional String) The entity types that the attribute is applicable, it always returns `[\\"cf_entity\\"]`.
               - `maxStrLength` - (Optional String) The maximum length of the string value, it always returns `5000`.
        :param str type: (Required String) The type of the attribute, it always returns `string`.
        """
        pulumi.set(__self__, "name", name)
        if default_value is not None:
            pulumi.set(__self__, "default_value", default_value)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if is_optional is not None:
            pulumi.set(__self__, "is_optional", is_optional)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the attribute.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="defaultValue")
    def default_value(self) -> Optional[str]:
        """
        The default value of this attribute.
        """
        return pulumi.get(self, "default_value")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        The description of this attribute.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="isOptional")
    def is_optional(self) -> Optional[bool]:
        """
        An optional flag to control whether the attribute should be optional or required. The default value is `false`.
        """
        return pulumi.get(self, "is_optional")

    @property
    @pulumi.getter
    def options(self) -> Optional[Mapping[str, str]]:
        """
        (Optional Map) Block for the attribute options:
        - `applicableEntityTypes` - (Optional String) The entity types that the attribute is applicable, it always returns `[\\"cf_entity\\"]`.
        - `maxStrLength` - (Optional String) The maximum length of the string value, it always returns `5000`.
        """
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        (Required String) The type of the attribute, it always returns `string`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class BusinessMetadataBindingCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class BusinessMetadataBindingSchemaRegistryCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class BusinessMetadataCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Cluster API Secret for your Confluent Cloud cluster.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Cluster API Secret for your Confluent Cloud cluster.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class BusinessMetadataSchemaRegistryCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class ByokKeyAws(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyArn":
            suggest = "key_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ByokKeyAws. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ByokKeyAws.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ByokKeyAws.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 key_arn: str,
                 roles: Optional[Sequence[str]] = None):
        """
        :param str key_arn: The Amazon Resource Name (ARN) of an AWS KMS key.
        :param Sequence[str] roles: (Optional List of Strings) The Amazon Resource Names (ARNs) of IAM Roles created for this key-environment
        """
        pulumi.set(__self__, "key_arn", key_arn)
        if roles is not None:
            pulumi.set(__self__, "roles", roles)

    @property
    @pulumi.getter(name="keyArn")
    def key_arn(self) -> str:
        """
        The Amazon Resource Name (ARN) of an AWS KMS key.
        """
        return pulumi.get(self, "key_arn")

    @property
    @pulumi.getter
    def roles(self) -> Optional[Sequence[str]]:
        """
        (Optional List of Strings) The Amazon Resource Names (ARNs) of IAM Roles created for this key-environment
        """
        return pulumi.get(self, "roles")


@pulumi.output_type
class ByokKeyAzure(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyIdentifier":
            suggest = "key_identifier"
        elif key == "keyVaultId":
            suggest = "key_vault_id"
        elif key == "tenantId":
            suggest = "tenant_id"
        elif key == "applicationId":
            suggest = "application_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ByokKeyAzure. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ByokKeyAzure.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ByokKeyAzure.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 key_identifier: str,
                 key_vault_id: str,
                 tenant_id: str,
                 application_id: Optional[str] = None):
        """
        :param str key_identifier: The unique Key Object Identifier URL of an Azure Key Vault key.
        :param str key_vault_id: Key Vault ID containing the key.
        :param str tenant_id: Tenant ID (uuid) hosting the Key Vault containing the key.
        :param str application_id: (Optional String) The Application ID created for this key-environment combination.
        """
        pulumi.set(__self__, "key_identifier", key_identifier)
        pulumi.set(__self__, "key_vault_id", key_vault_id)
        pulumi.set(__self__, "tenant_id", tenant_id)
        if application_id is not None:
            pulumi.set(__self__, "application_id", application_id)

    @property
    @pulumi.getter(name="keyIdentifier")
    def key_identifier(self) -> str:
        """
        The unique Key Object Identifier URL of an Azure Key Vault key.
        """
        return pulumi.get(self, "key_identifier")

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> str:
        """
        Key Vault ID containing the key.
        """
        return pulumi.get(self, "key_vault_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        """
        Tenant ID (uuid) hosting the Key Vault containing the key.
        """
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="applicationId")
    def application_id(self) -> Optional[str]:
        """
        (Optional String) The Application ID created for this key-environment combination.
        """
        return pulumi.get(self, "application_id")


@pulumi.output_type
class ByokKeyGcp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyId":
            suggest = "key_id"
        elif key == "securityGroup":
            suggest = "security_group"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ByokKeyGcp. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ByokKeyGcp.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ByokKeyGcp.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 key_id: str,
                 security_group: Optional[str] = None):
        """
        :param str key_id: The Google Cloud Platform key ID.
        :param str security_group: (Optional String) The Google security group created for this key.
        """
        pulumi.set(__self__, "key_id", key_id)
        if security_group is not None:
            pulumi.set(__self__, "security_group", security_group)

    @property
    @pulumi.getter(name="keyId")
    def key_id(self) -> str:
        """
        The Google Cloud Platform key ID.
        """
        return pulumi.get(self, "key_id")

    @property
    @pulumi.getter(name="securityGroup")
    def security_group(self) -> Optional[str]:
        """
        (Optional String) The Google security group created for this key.
        """
        return pulumi.get(self, "security_group")


@pulumi.output_type
class CatalogEntityAttributesCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class CatalogEntityAttributesSchemaRegistryCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class CertificatePoolCertificateAuthority(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Certificate Authority for this Certificate Pool, for example, `op-123abc`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Certificate Authority for this Certificate Pool, for example, `op-123abc`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class ClusterLinkDestinationKafkaCluster(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bootstrapEndpoint":
            suggest = "bootstrap_endpoint"
        elif key == "restEndpoint":
            suggest = "rest_endpoint"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterLinkDestinationKafkaCluster. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterLinkDestinationKafkaCluster.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterLinkDestinationKafkaCluster.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 id: str,
                 bootstrap_endpoint: Optional[str] = None,
                 credentials: Optional['outputs.ClusterLinkDestinationKafkaClusterCredentials'] = None,
                 rest_endpoint: Optional[str] = None):
        """
        :param str id: The ID of the destination Kafka cluster, for example, `lkc-abc123`.
        :param str bootstrap_endpoint: The bootstrap endpoint of the destination Kafka cluster, for example, `SASL_SSL://pkc-00000.us-central1.gcp.confluent.cloud:9092` or `pkc-00000.us-central1.gcp.confluent.cloud:9092`).
        :param 'ClusterLinkDestinationKafkaClusterCredentialsArgs' credentials: The Kafka API Credentials.
        :param str rest_endpoint: The REST endpoint of the destination Kafka cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
        pulumi.set(__self__, "id", id)
        if bootstrap_endpoint is not None:
            pulumi.set(__self__, "bootstrap_endpoint", bootstrap_endpoint)
        if credentials is not None:
            pulumi.set(__self__, "credentials", credentials)
        if rest_endpoint is not None:
            pulumi.set(__self__, "rest_endpoint", rest_endpoint)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the destination Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="bootstrapEndpoint")
    def bootstrap_endpoint(self) -> Optional[str]:
        """
        The bootstrap endpoint of the destination Kafka cluster, for example, `SASL_SSL://pkc-00000.us-central1.gcp.confluent.cloud:9092` or `pkc-00000.us-central1.gcp.confluent.cloud:9092`).
        """
        return pulumi.get(self, "bootstrap_endpoint")

    @property
    @pulumi.getter
    def credentials(self) -> Optional['outputs.ClusterLinkDestinationKafkaClusterCredentials']:
        """
        The Kafka API Credentials.
        """
        return pulumi.get(self, "credentials")

    @property
    @pulumi.getter(name="restEndpoint")
    def rest_endpoint(self) -> Optional[str]:
        """
        The REST endpoint of the destination Kafka cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
        return pulumi.get(self, "rest_endpoint")


@pulumi.output_type
class ClusterLinkDestinationKafkaClusterCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Kafka API Key.
        :param str secret: The Kafka API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Kafka API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Kafka API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class ClusterLinkLocalKafkaCluster(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bootstrapEndpoint":
            suggest = "bootstrap_endpoint"
        elif key == "restEndpoint":
            suggest = "rest_endpoint"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterLinkLocalKafkaCluster. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterLinkLocalKafkaCluster.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterLinkLocalKafkaCluster.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 id: str,
                 bootstrap_endpoint: Optional[str] = None,
                 credentials: Optional['outputs.ClusterLinkLocalKafkaClusterCredentials'] = None,
                 rest_endpoint: Optional[str] = None):
        """
        :param str id: The ID of the local Kafka cluster, for example, `lkc-abc123`.
        :param str bootstrap_endpoint: The bootstrap endpoint of the local Kafka cluster, for example, `SASL_SSL://pkc-00000.us-central1.gcp.confluent.cloud:9092` or `pkc-00000.us-central1.gcp.confluent.cloud:9092`).
        :param 'ClusterLinkLocalKafkaClusterCredentialsArgs' credentials: The Kafka API Credentials.
        :param str rest_endpoint: The REST endpoint of the local Kafka cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
        pulumi.set(__self__, "id", id)
        if bootstrap_endpoint is not None:
            pulumi.set(__self__, "bootstrap_endpoint", bootstrap_endpoint)
        if credentials is not None:
            pulumi.set(__self__, "credentials", credentials)
        if rest_endpoint is not None:
            pulumi.set(__self__, "rest_endpoint", rest_endpoint)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the local Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="bootstrapEndpoint")
    def bootstrap_endpoint(self) -> Optional[str]:
        """
        The bootstrap endpoint of the local Kafka cluster, for example, `SASL_SSL://pkc-00000.us-central1.gcp.confluent.cloud:9092` or `pkc-00000.us-central1.gcp.confluent.cloud:9092`).
        """
        return pulumi.get(self, "bootstrap_endpoint")

    @property
    @pulumi.getter
    def credentials(self) -> Optional['outputs.ClusterLinkLocalKafkaClusterCredentials']:
        """
        The Kafka API Credentials.
        """
        return pulumi.get(self, "credentials")

    @property
    @pulumi.getter(name="restEndpoint")
    def rest_endpoint(self) -> Optional[str]:
        """
        The REST endpoint of the local Kafka cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
        return pulumi.get(self, "rest_endpoint")


@pulumi.output_type
class ClusterLinkLocalKafkaClusterCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Kafka API Key.
        :param str secret: The Kafka API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Kafka API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Kafka API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class ClusterLinkRemoteKafkaCluster(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bootstrapEndpoint":
            suggest = "bootstrap_endpoint"
        elif key == "restEndpoint":
            suggest = "rest_endpoint"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterLinkRemoteKafkaCluster. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterLinkRemoteKafkaCluster.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterLinkRemoteKafkaCluster.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 id: str,
                 bootstrap_endpoint: Optional[str] = None,
                 credentials: Optional['outputs.ClusterLinkRemoteKafkaClusterCredentials'] = None,
                 rest_endpoint: Optional[str] = None):
        """
        :param str id: The ID of the remote Kafka cluster, for example, `lkc-abc123`.
        :param str bootstrap_endpoint: The bootstrap endpoint of the remote Kafka cluster, for example, `SASL_SSL://pkc-00000.us-central1.gcp.confluent.cloud:9092` or `pkc-00000.us-central1.gcp.confluent.cloud:9092`).
        :param 'ClusterLinkRemoteKafkaClusterCredentialsArgs' credentials: The Kafka API Credentials.
        :param str rest_endpoint: The REST endpoint of the remote Kafka cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
        pulumi.set(__self__, "id", id)
        if bootstrap_endpoint is not None:
            pulumi.set(__self__, "bootstrap_endpoint", bootstrap_endpoint)
        if credentials is not None:
            pulumi.set(__self__, "credentials", credentials)
        if rest_endpoint is not None:
            pulumi.set(__self__, "rest_endpoint", rest_endpoint)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the remote Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="bootstrapEndpoint")
    def bootstrap_endpoint(self) -> Optional[str]:
        """
        The bootstrap endpoint of the remote Kafka cluster, for example, `SASL_SSL://pkc-00000.us-central1.gcp.confluent.cloud:9092` or `pkc-00000.us-central1.gcp.confluent.cloud:9092`).
        """
        return pulumi.get(self, "bootstrap_endpoint")

    @property
    @pulumi.getter
    def credentials(self) -> Optional['outputs.ClusterLinkRemoteKafkaClusterCredentials']:
        """
        The Kafka API Credentials.
        """
        return pulumi.get(self, "credentials")

    @property
    @pulumi.getter(name="restEndpoint")
    def rest_endpoint(self) -> Optional[str]:
        """
        The REST endpoint of the remote Kafka cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
        return pulumi.get(self, "rest_endpoint")


@pulumi.output_type
class ClusterLinkRemoteKafkaClusterCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Kafka API Key.
        :param str secret: The Kafka API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Kafka API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Kafka API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class ClusterLinkSourceKafkaCluster(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bootstrapEndpoint":
            suggest = "bootstrap_endpoint"
        elif key == "restEndpoint":
            suggest = "rest_endpoint"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterLinkSourceKafkaCluster. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterLinkSourceKafkaCluster.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterLinkSourceKafkaCluster.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 id: str,
                 bootstrap_endpoint: Optional[str] = None,
                 credentials: Optional['outputs.ClusterLinkSourceKafkaClusterCredentials'] = None,
                 rest_endpoint: Optional[str] = None):
        """
        :param str id: The ID of the source Kafka cluster, for example, `lkc-abc123`.
        :param str bootstrap_endpoint: The bootstrap endpoint of the source Kafka cluster, for example, `SASL_SSL://pkc-00000.us-central1.gcp.confluent.cloud:9092` or `pkc-00000.us-central1.gcp.confluent.cloud:9092`).
        :param 'ClusterLinkSourceKafkaClusterCredentialsArgs' credentials: The Kafka API Credentials.
        :param str rest_endpoint: The REST endpoint of the source Kafka cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
        pulumi.set(__self__, "id", id)
        if bootstrap_endpoint is not None:
            pulumi.set(__self__, "bootstrap_endpoint", bootstrap_endpoint)
        if credentials is not None:
            pulumi.set(__self__, "credentials", credentials)
        if rest_endpoint is not None:
            pulumi.set(__self__, "rest_endpoint", rest_endpoint)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the source Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="bootstrapEndpoint")
    def bootstrap_endpoint(self) -> Optional[str]:
        """
        The bootstrap endpoint of the source Kafka cluster, for example, `SASL_SSL://pkc-00000.us-central1.gcp.confluent.cloud:9092` or `pkc-00000.us-central1.gcp.confluent.cloud:9092`).
        """
        return pulumi.get(self, "bootstrap_endpoint")

    @property
    @pulumi.getter
    def credentials(self) -> Optional['outputs.ClusterLinkSourceKafkaClusterCredentials']:
        """
        The Kafka API Credentials.
        """
        return pulumi.get(self, "credentials")

    @property
    @pulumi.getter(name="restEndpoint")
    def rest_endpoint(self) -> Optional[str]:
        """
        The REST endpoint of the source Kafka cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
        return pulumi.get(self, "rest_endpoint")


@pulumi.output_type
class ClusterLinkSourceKafkaClusterCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Kafka API Key.
        :param str secret: The Kafka API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Kafka API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Kafka API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class ConnectorEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the connector belongs to, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the connector belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class ConnectorKafkaCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Kafka cluster that the connector belongs to, for example, `lkc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Kafka cluster that the connector belongs to, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class ConnectorOffset(dict):
    def __init__(__self__, *,
                 offset: Mapping[str, str],
                 partition: Mapping[str, str]):
        """
        :param Mapping[str, str] offset: Block with offset information that supports different keys depending on the connector type. For sink connectors, use `kafka_offset`. For source connectors, the applicable keys differ by kind—refer to the [Source connectors page](https://docs.confluent.io/cloud/current/connectors/offsets.html#source-connectors) for the full list of supported keys. Alternatively, use the [Manage custom offsets section](https://docs.confluent.io/cloud/current/connectors/cc-github-source.html#manage-custom-offsets) on the homepage of the target source connector.
        :param Mapping[str, str] partition: Block with partition information that supports different keys depending on the connector type. For sink connectors, use `kafka_partition` and `kafka_topic`. For source connectors, the applicable keys differ by kind—refer to the [Source connectors page](https://docs.confluent.io/cloud/current/connectors/offsets.html#source-connectors) for the full list of supported keys.
        """
        pulumi.set(__self__, "offset", offset)
        pulumi.set(__self__, "partition", partition)

    @property
    @pulumi.getter
    def offset(self) -> Mapping[str, str]:
        """
        Block with offset information that supports different keys depending on the connector type. For sink connectors, use `kafka_offset`. For source connectors, the applicable keys differ by kind—refer to the [Source connectors page](https://docs.confluent.io/cloud/current/connectors/offsets.html#source-connectors) for the full list of supported keys. Alternatively, use the [Manage custom offsets section](https://docs.confluent.io/cloud/current/connectors/cc-github-source.html#manage-custom-offsets) on the homepage of the target source connector.
        """
        return pulumi.get(self, "offset")

    @property
    @pulumi.getter
    def partition(self) -> Mapping[str, str]:
        """
        Block with partition information that supports different keys depending on the connector type. For sink connectors, use `kafka_partition` and `kafka_topic`. For source connectors, the applicable keys differ by kind—refer to the [Source connectors page](https://docs.confluent.io/cloud/current/connectors/offsets.html#source-connectors) for the full list of supported keys.
        """
        return pulumi.get(self, "partition")


@pulumi.output_type
class DnsForwarderEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the DNS Forwarder belongs to, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the DNS Forwarder belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class DnsForwarderForwardViaGcpDnsZones(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "domainMappings":
            suggest = "domain_mappings"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DnsForwarderForwardViaGcpDnsZones. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DnsForwarderForwardViaGcpDnsZones.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DnsForwarderForwardViaGcpDnsZones.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 domain_mappings: Optional[Mapping[str, str]] = None):
        """
        :param Mapping[str, str] domain_mappings: List of Maps which contains the domain to zone and project mapping.
               
               > **Note:** The `forward_via_gcp_zones` and `forward_via_ip` blocks are mutually exclusive, and one of them must be provided.
               
               > **Note:** The zone and project must be specified in the correct order, separated by a comma, to ensure accurate `domain_mappings`.
        """
        if domain_mappings is not None:
            pulumi.set(__self__, "domain_mappings", domain_mappings)

    @property
    @pulumi.getter(name="domainMappings")
    def domain_mappings(self) -> Optional[Mapping[str, str]]:
        """
        List of Maps which contains the domain to zone and project mapping.

        > **Note:** The `forward_via_gcp_zones` and `forward_via_ip` blocks are mutually exclusive, and one of them must be provided.

        > **Note:** The zone and project must be specified in the correct order, separated by a comma, to ensure accurate `domain_mappings`.
        """
        return pulumi.get(self, "domain_mappings")


@pulumi.output_type
class DnsForwarderForwardViaIp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dnsServerIps":
            suggest = "dns_server_ips"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DnsForwarderForwardViaIp. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DnsForwarderForwardViaIp.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DnsForwarderForwardViaIp.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 dns_server_ips: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] dns_server_ips: List of IP addresses of the DNS server.
        """
        if dns_server_ips is not None:
            pulumi.set(__self__, "dns_server_ips", dns_server_ips)

    @property
    @pulumi.getter(name="dnsServerIps")
    def dns_server_ips(self) -> Optional[Sequence[str]]:
        """
        List of IP addresses of the DNS server.
        """
        return pulumi.get(self, "dns_server_ips")


@pulumi.output_type
class DnsForwarderGateway(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the gateway to which the DNS Forwarder belongs, for example, `gw-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the gateway to which the DNS Forwarder belongs, for example, `gw-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class DnsRecordEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the DNS Record belongs to, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the DNS Record belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class DnsRecordGateway(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the gateway to which the DNS Record belongs, for example, `gw-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the gateway to which the DNS Record belongs, for example, `gw-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class DnsRecordPrivateLinkAccessPoint(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Private Link access point to which the DNS Record is associated, for example `ap-123abc`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Private Link access point to which the DNS Record is associated, for example `ap-123abc`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class EnvironmentStreamGovernance(dict):
    def __init__(__self__, *,
                 package: str):
        """
        :param str package: The [stream governance package](https://docs.confluent.io/cloud/current/stream-governance/packages.html#packages) for the Environment. Accepted values are: `ESSENTIALS` and `ADVANCED`.
        """
        pulumi.set(__self__, "package", package)

    @property
    @pulumi.getter
    def package(self) -> str:
        """
        The [stream governance package](https://docs.confluent.io/cloud/current/stream-governance/packages.html#packages) for the Environment. Accepted values are: `ESSENTIALS` and `ADVANCED`.
        """
        return pulumi.get(self, "package")


@pulumi.output_type
class FlinkArtifactEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Flink Artifact Pool belongs to, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Flink Artifact Pool belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class FlinkArtifactVersion(dict):
    def __init__(__self__, *,
                 version: str):
        """
        :param str version: The version of this Flink Artifact.
        """
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def version(self) -> str:
        """
        The version of this Flink Artifact.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class FlinkComputePoolEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Flink Compute Pool belongs to, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Flink Compute Pool belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class FlinkStatementComputePool(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Flink Compute Pool, for example, `lfcp-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Flink Compute Pool, for example, `lfcp-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class FlinkStatementCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Flink API Key.
        :param str secret: The Flink API Secret.
               
               > **Note:** A Flink API key consists of a key and a secret. Flink API keys are required to interact with Flink Statements in Confluent Cloud. Each Flink API key is valid for one specific Flink Region.
               
               > **Note:** Use Option #2 to simplify the key rotation process. When using Option #1, to rotate a Flink API key, create a new Flink API key, update the `credentials` block in all configuration files to use the new Flink API key, run `pulumi up -target="confluent_flink_statement.example"`, and remove the old Flink API key. Alternatively, in case the old Flink API Key was deleted already, you might need to run `pulumi preview -refresh=false -target="confluent_flink_statement.example" -out=rotate-flink-api-key` and `pulumi up rotate-flink-api-key` instead.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Flink API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Flink API Secret.

        > **Note:** A Flink API key consists of a key and a secret. Flink API keys are required to interact with Flink Statements in Confluent Cloud. Each Flink API key is valid for one specific Flink Region.

        > **Note:** Use Option #2 to simplify the key rotation process. When using Option #1, to rotate a Flink API key, create a new Flink API key, update the `credentials` block in all configuration files to use the new Flink API key, run `pulumi up -target="confluent_flink_statement.example"`, and remove the old Flink API key. Alternatively, in case the old Flink API Key was deleted already, you might need to run `pulumi preview -refresh=false -target="confluent_flink_statement.example" -out=rotate-flink-api-key` and `pulumi up rotate-flink-api-key` instead.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class FlinkStatementEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class FlinkStatementOrganization(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Organization, for example, `1111aaaa-11aa-11aa-11aa-111111aaaaaa`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Organization, for example, `1111aaaa-11aa-11aa-11aa-111111aaaaaa`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class FlinkStatementPrincipal(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Principal the Flink Statement runs as, for example, `sa-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Principal the Flink Statement runs as, for example, `sa-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GatewayAwsEgressPrivateLinkGateway(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "principalArn":
            suggest = "principal_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in GatewayAwsEgressPrivateLinkGateway. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        GatewayAwsEgressPrivateLinkGateway.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        GatewayAwsEgressPrivateLinkGateway.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 region: str,
                 principal_arn: Optional[str] = None):
        """
        :param str region: AWS region of the Gateway, for example, `us-east-1`.
        :param str principal_arn: (Required String) The principal ARN used by the AWS Egress Private Link Gateway, for example, `arn:aws:iam::123456789012:tenant-1-role`.
        """
        pulumi.set(__self__, "region", region)
        if principal_arn is not None:
            pulumi.set(__self__, "principal_arn", principal_arn)

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        AWS region of the Gateway, for example, `us-east-1`.
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="principalArn")
    def principal_arn(self) -> Optional[str]:
        """
        (Required String) The principal ARN used by the AWS Egress Private Link Gateway, for example, `arn:aws:iam::123456789012:tenant-1-role`.
        """
        return pulumi.get(self, "principal_arn")


@pulumi.output_type
class GatewayAwsPrivateNetworkInterfaceGateway(dict):
    def __init__(__self__, *,
                 region: str,
                 zones: Sequence[str],
                 account: Optional[str] = None):
        """
        :param str region: AWS region of the Private Network Interface Gateway.
        :param Sequence[str] zones: AWS availability zone ids of the Private Network Interface Gateway.
        :param str account: (Required String) The AWS account ID associated with the Private Network Interface Gateway.
        """
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "zones", zones)
        if account is not None:
            pulumi.set(__self__, "account", account)

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        AWS region of the Private Network Interface Gateway.
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def zones(self) -> Sequence[str]:
        """
        AWS availability zone ids of the Private Network Interface Gateway.
        """
        return pulumi.get(self, "zones")

    @property
    @pulumi.getter
    def account(self) -> Optional[str]:
        """
        (Required String) The AWS account ID associated with the Private Network Interface Gateway.
        """
        return pulumi.get(self, "account")


@pulumi.output_type
class GatewayAzureEgressPrivateLinkGateway(dict):
    def __init__(__self__, *,
                 region: str,
                 subscription: Optional[str] = None):
        """
        :param str region: Azure region of the Gateway, for example, `eastus`.
        :param str subscription: (Required String) The Azure Subscription ID associated with the Confluent Cloud VPC, for example, `00000000-0000-0000-0000-000000000000`.
        """
        pulumi.set(__self__, "region", region)
        if subscription is not None:
            pulumi.set(__self__, "subscription", subscription)

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        Azure region of the Gateway, for example, `eastus`.
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def subscription(self) -> Optional[str]:
        """
        (Required String) The Azure Subscription ID associated with the Confluent Cloud VPC, for example, `00000000-0000-0000-0000-000000000000`.
        """
        return pulumi.get(self, "subscription")


@pulumi.output_type
class GatewayEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Gateway belongs to, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Gateway belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class IdentityPoolIdentityProvider(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Identity Provider associated with the Identity Pool, for example, `op-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Identity Provider associated with the Identity Pool, for example, `op-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class InvitationCreator(dict):
    def __init__(__self__, *,
                 id: Optional[str] = None):
        """
        :param str id: (Required String) The id of invitation creator.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        (Required String) The id of invitation creator.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class InvitationUser(dict):
    def __init__(__self__, *,
                 id: Optional[str] = None):
        """
        :param str id: (Required String) The id of invitation creator.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        (Required String) The id of invitation creator.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class KafkaAclCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Kafka API Key.
        :param str secret: The Kafka API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Kafka API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Kafka API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class KafkaAclKafkaCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Kafka cluster, for example, `lkc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class KafkaClientQuotaEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the corresponding Kafka Cluster belongs to, for example, `env-abc123`.
               
               > **Note:** Each principal assigned to a quota receives the full amount of the quota, meaning the quota is not shared by the principals it is assigned. For example, if a 10 MBps ingress quota is applied to Principals 1 and 2, Principal 1 can produce at most 10 MBps, independently of Principal 2.
               
               > **Note:** Define a throughput maximum, but do not guarantee a throughput floor. Applications are rate-limited through the use of the Kafka throttling mechanism. Kafka asks the client to wait before sending more data and mutes the channel, which appears as latency to the client application.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the corresponding Kafka Cluster belongs to, for example, `env-abc123`.

        > **Note:** Each principal assigned to a quota receives the full amount of the quota, meaning the quota is not shared by the principals it is assigned. For example, if a 10 MBps ingress quota is applied to Principals 1 and 2, Principal 1 can produce at most 10 MBps, independently of Principal 2.

        > **Note:** Define a throughput maximum, but do not guarantee a throughput floor. Applications are rate-limited through the use of the Kafka throttling mechanism. Kafka asks the client to wait before sending more data and mutes the channel, which appears as latency to the client application.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class KafkaClientQuotaKafkaCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Kafka Cluster where the Kafka Client Quota is applied, for example, `lkc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Kafka Cluster where the Kafka Client Quota is applied, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class KafkaClientQuotaThroughput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "egressByteRate":
            suggest = "egress_byte_rate"
        elif key == "ingressByteRate":
            suggest = "ingress_byte_rate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in KafkaClientQuotaThroughput. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        KafkaClientQuotaThroughput.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        KafkaClientQuotaThroughput.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 egress_byte_rate: str,
                 ingress_byte_rate: str):
        """
        :param str egress_byte_rate: The egress throughput limit in bytes per second.
        :param str ingress_byte_rate: The ingress throughput limit in bytes per second.
        """
        pulumi.set(__self__, "egress_byte_rate", egress_byte_rate)
        pulumi.set(__self__, "ingress_byte_rate", ingress_byte_rate)

    @property
    @pulumi.getter(name="egressByteRate")
    def egress_byte_rate(self) -> str:
        """
        The egress throughput limit in bytes per second.
        """
        return pulumi.get(self, "egress_byte_rate")

    @property
    @pulumi.getter(name="ingressByteRate")
    def ingress_byte_rate(self) -> str:
        """
        The ingress throughput limit in bytes per second.
        """
        return pulumi.get(self, "ingress_byte_rate")


@pulumi.output_type
class KafkaClusterBasic(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class KafkaClusterByokKey(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Confluent key that is used to encrypt the data in the Kafka cluster, for example, `cck-lye5m`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Confluent key that is used to encrypt the data in the Kafka cluster, for example, `cck-lye5m`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class KafkaClusterConfigCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Kafka API Key.
        :param str secret: The Kafka API Secret.
               
               > **Note:** A Kafka API key consists of a key and a secret. Kafka API keys are required to interact with Kafka clusters in Confluent Cloud. Each Kafka API key is valid for one specific Kafka cluster.
               
               > **Note:** Use Option #2 to simplify the key rotation process. When using Option #1, to rotate a Kafka API key, create a new Kafka API key, update the `credentials` block in all configuration files to use the new Kafka API key, run `pulumi up -target="confluent_kafka_cluster_config.orders"`, and remove the old Kafka API key. Alternatively, in case the old Kafka API Key was deleted already, you might need to run `pulumi preview -refresh=false -target="confluent_kafka_cluster_config.orders" -out=rotate-kafka-api-key` and `pulumi up rotate-kafka-api-key` instead.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Kafka API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Kafka API Secret.

        > **Note:** A Kafka API key consists of a key and a secret. Kafka API keys are required to interact with Kafka clusters in Confluent Cloud. Each Kafka API key is valid for one specific Kafka cluster.

        > **Note:** Use Option #2 to simplify the key rotation process. When using Option #1, to rotate a Kafka API key, create a new Kafka API key, update the `credentials` block in all configuration files to use the new Kafka API key, run `pulumi up -target="confluent_kafka_cluster_config.orders"`, and remove the old Kafka API key. Alternatively, in case the old Kafka API Key was deleted already, you might need to run `pulumi preview -refresh=false -target="confluent_kafka_cluster_config.orders" -out=rotate-kafka-api-key` and `pulumi up rotate-kafka-api-key` instead.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class KafkaClusterConfigKafkaCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Dedicated Kafka cluster, for example, `lkc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Dedicated Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class KafkaClusterDedicated(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "encryptionKey":
            suggest = "encryption_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in KafkaClusterDedicated. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        KafkaClusterDedicated.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        KafkaClusterDedicated.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cku: int,
                 encryption_key: Optional[str] = None,
                 zones: Optional[Sequence[str]] = None):
        """
        :param int cku: The number of Confluent Kafka Units (CKUs) for Dedicated cluster types. The minimum number of CKUs for `SINGLE_ZONE` dedicated clusters is `1` whereas `MULTI_ZONE` dedicated clusters must have `2` CKUs or more.
               
               > **Note:** Exactly one from the `basic`, `standard`, `dedicated`, `enterprise` or `freight` configuration blocks must be specified.
               
               > **Note:** The `freight` Kafka cluster type is currently available only on AWS.
               
               > **Note:** The `enterprise` Kafka cluster type is currently available only on AWS and Azure.
               
               !> **Warning:** You can only upgrade clusters from `basic` to `standard`.
               
               > **Note:** Currently, provisioning of a Dedicated Kafka cluster takes around 25 minutes on average but might take up to 24 hours. If you can't wait for the `pulumi up` step to finish, you can exit it and import the cluster by using the `pulumi import` command once it has been provisioned. When the cluster is provisioned, you will receive an email notification, and you can also follow updates on the Target Environment web page of the Confluent Cloud website.
        :param str encryption_key: The ID of the encryption key that is used to encrypt the data in the Kafka cluster.
        :param Sequence[str] zones: (Required List of String) The list of zones the cluster is in.
               - On AWS, zones are AWS [AZ IDs](https://docs.aws.amazon.com/ram/latest/userguide/working-with-az-ids.html), for example, `use1-az3`.
        """
        pulumi.set(__self__, "cku", cku)
        if encryption_key is not None:
            pulumi.set(__self__, "encryption_key", encryption_key)
        if zones is not None:
            pulumi.set(__self__, "zones", zones)

    @property
    @pulumi.getter
    def cku(self) -> int:
        """
        The number of Confluent Kafka Units (CKUs) for Dedicated cluster types. The minimum number of CKUs for `SINGLE_ZONE` dedicated clusters is `1` whereas `MULTI_ZONE` dedicated clusters must have `2` CKUs or more.

        > **Note:** Exactly one from the `basic`, `standard`, `dedicated`, `enterprise` or `freight` configuration blocks must be specified.

        > **Note:** The `freight` Kafka cluster type is currently available only on AWS.

        > **Note:** The `enterprise` Kafka cluster type is currently available only on AWS and Azure.

        !> **Warning:** You can only upgrade clusters from `basic` to `standard`.

        > **Note:** Currently, provisioning of a Dedicated Kafka cluster takes around 25 minutes on average but might take up to 24 hours. If you can't wait for the `pulumi up` step to finish, you can exit it and import the cluster by using the `pulumi import` command once it has been provisioned. When the cluster is provisioned, you will receive an email notification, and you can also follow updates on the Target Environment web page of the Confluent Cloud website.
        """
        return pulumi.get(self, "cku")

    @property
    @pulumi.getter(name="encryptionKey")
    def encryption_key(self) -> Optional[str]:
        """
        The ID of the encryption key that is used to encrypt the data in the Kafka cluster.
        """
        return pulumi.get(self, "encryption_key")

    @property
    @pulumi.getter
    def zones(self) -> Optional[Sequence[str]]:
        """
        (Required List of String) The list of zones the cluster is in.
        - On AWS, zones are AWS [AZ IDs](https://docs.aws.amazon.com/ram/latest/userguide/working-with-az-ids.html), for example, `use1-az3`.
        """
        return pulumi.get(self, "zones")


@pulumi.output_type
class KafkaClusterEnterprise(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class KafkaClusterEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Kafka cluster belongs to, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Kafka cluster belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class KafkaClusterFreight(dict):
    def __init__(__self__, *,
                 zones: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] zones: (Required List of String) The list of zones the cluster is in.
               - On AWS, zones are AWS [AZ IDs](https://docs.aws.amazon.com/ram/latest/userguide/working-with-az-ids.html), for example, `use1-az3`.
        """
        if zones is not None:
            pulumi.set(__self__, "zones", zones)

    @property
    @pulumi.getter
    def zones(self) -> Optional[Sequence[str]]:
        """
        (Required List of String) The list of zones the cluster is in.
        - On AWS, zones are AWS [AZ IDs](https://docs.aws.amazon.com/ram/latest/userguide/working-with-az-ids.html), for example, `use1-az3`.
        """
        return pulumi.get(self, "zones")


@pulumi.output_type
class KafkaClusterNetwork(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Network that the Kafka cluster belongs to, for example, `n-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Network that the Kafka cluster belongs to, for example, `n-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class KafkaClusterStandard(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class KafkaMirrorTopicClusterLink(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "linkName":
            suggest = "link_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in KafkaMirrorTopicClusterLink. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        KafkaMirrorTopicClusterLink.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        KafkaMirrorTopicClusterLink.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 link_name: str):
        """
        :param str link_name: The name of the cluster link to attach to the mirror topic, for example, `my-cluster-link`.
        """
        pulumi.set(__self__, "link_name", link_name)

    @property
    @pulumi.getter(name="linkName")
    def link_name(self) -> str:
        """
        The name of the cluster link to attach to the mirror topic, for example, `my-cluster-link`.
        """
        return pulumi.get(self, "link_name")


@pulumi.output_type
class KafkaMirrorTopicKafkaCluster(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "restEndpoint":
            suggest = "rest_endpoint"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in KafkaMirrorTopicKafkaCluster. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        KafkaMirrorTopicKafkaCluster.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        KafkaMirrorTopicKafkaCluster.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 id: str,
                 credentials: Optional['outputs.KafkaMirrorTopicKafkaClusterCredentials'] = None,
                 rest_endpoint: Optional[str] = None):
        """
        :param str id: The ID of the destination Kafka cluster, for example, `lkc-abc123`.
        :param 'KafkaMirrorTopicKafkaClusterCredentialsArgs' credentials: The Kafka API Credentials.
        :param str rest_endpoint: The REST endpoint of the destination Kafka cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
        pulumi.set(__self__, "id", id)
        if credentials is not None:
            pulumi.set(__self__, "credentials", credentials)
        if rest_endpoint is not None:
            pulumi.set(__self__, "rest_endpoint", rest_endpoint)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the destination Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def credentials(self) -> Optional['outputs.KafkaMirrorTopicKafkaClusterCredentials']:
        """
        The Kafka API Credentials.
        """
        return pulumi.get(self, "credentials")

    @property
    @pulumi.getter(name="restEndpoint")
    def rest_endpoint(self) -> Optional[str]:
        """
        The REST endpoint of the destination Kafka cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
        return pulumi.get(self, "rest_endpoint")


@pulumi.output_type
class KafkaMirrorTopicKafkaClusterCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Kafka API Key.
        :param str secret: The Kafka API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Kafka API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Kafka API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class KafkaMirrorTopicSourceKafkaTopic(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "topicName":
            suggest = "topic_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in KafkaMirrorTopicSourceKafkaTopic. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        KafkaMirrorTopicSourceKafkaTopic.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        KafkaMirrorTopicSourceKafkaTopic.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 topic_name: str):
        """
        :param str topic_name: The name of the topic on the source cluster to be mirrored over the cluster link, for example, `orders`. A topic with the exact same name must exist on the source cluster, and no topic with this name should exist on the destination cluster.
        """
        pulumi.set(__self__, "topic_name", topic_name)

    @property
    @pulumi.getter(name="topicName")
    def topic_name(self) -> str:
        """
        The name of the topic on the source cluster to be mirrored over the cluster link, for example, `orders`. A topic with the exact same name must exist on the source cluster, and no topic with this name should exist on the destination cluster.
        """
        return pulumi.get(self, "topic_name")


@pulumi.output_type
class KafkaTopicCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Kafka API Key.
        :param str secret: The Kafka API Secret.
               
               > **Note:** A Kafka API key consists of a key and a secret. Kafka API keys are required to interact with Kafka clusters in Confluent Cloud. Each Kafka API key is valid for one specific Kafka cluster.
               
               > **Note:** Use Option #2 to simplify the key rotation process. When using Option #1, to rotate a Kafka API key, create a new Kafka API key, update the `credentials` block in all configuration files to use the new Kafka API key, run `pulumi up -target="confluent_kafka_topic.orders"`, and remove the old Kafka API key. Alternatively, in case the old Kafka API Key was deleted already, you might need to run `pulumi preview -refresh=false -target="confluent_kafka_topic.orders" -out=rotate-kafka-api-key` and `pulumi up rotate-kafka-api-key` instead.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Kafka API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Kafka API Secret.

        > **Note:** A Kafka API key consists of a key and a secret. Kafka API keys are required to interact with Kafka clusters in Confluent Cloud. Each Kafka API key is valid for one specific Kafka cluster.

        > **Note:** Use Option #2 to simplify the key rotation process. When using Option #1, to rotate a Kafka API key, create a new Kafka API key, update the `credentials` block in all configuration files to use the new Kafka API key, run `pulumi up -target="confluent_kafka_topic.orders"`, and remove the old Kafka API key. Alternatively, in case the old Kafka API Key was deleted already, you might need to run `pulumi preview -refresh=false -target="confluent_kafka_topic.orders" -out=rotate-kafka-api-key` and `pulumi up rotate-kafka-api-key` instead.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class KafkaTopicKafkaCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Kafka cluster, for example, `lkc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class KsqlClusterCredentialIdentity(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the associated service or user account, for example, `sa-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the associated service or user account, for example, `sa-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class KsqlClusterEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the associated Environment, for example, `env-xyz456`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the associated Environment, for example, `env-xyz456`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class KsqlClusterKafkaCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the associated Kafka cluster, for example, `lkc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the associated Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class NetworkAw(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateLinkEndpointService":
            suggest = "private_link_endpoint_service"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkAw. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkAw.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkAw.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 account: Optional[str] = None,
                 private_link_endpoint_service: Optional[str] = None,
                 vpc: Optional[str] = None):
        """
        :param str account: (Required String) The AWS account ID associated with the Confluent Cloud VPC.
        :param str private_link_endpoint_service: (Optional String) The endpoint service of the Confluent Cloud VPC (used for PrivateLink) if available.
        :param str vpc: (Required String) The Confluent Cloud VPC ID.
        """
        if account is not None:
            pulumi.set(__self__, "account", account)
        if private_link_endpoint_service is not None:
            pulumi.set(__self__, "private_link_endpoint_service", private_link_endpoint_service)
        if vpc is not None:
            pulumi.set(__self__, "vpc", vpc)

    @property
    @pulumi.getter
    def account(self) -> Optional[str]:
        """
        (Required String) The AWS account ID associated with the Confluent Cloud VPC.
        """
        return pulumi.get(self, "account")

    @property
    @pulumi.getter(name="privateLinkEndpointService")
    def private_link_endpoint_service(self) -> Optional[str]:
        """
        (Optional String) The endpoint service of the Confluent Cloud VPC (used for PrivateLink) if available.
        """
        return pulumi.get(self, "private_link_endpoint_service")

    @property
    @pulumi.getter
    def vpc(self) -> Optional[str]:
        """
        (Required String) The Confluent Cloud VPC ID.
        """
        return pulumi.get(self, "vpc")


@pulumi.output_type
class NetworkAzure(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateLinkServiceAliases":
            suggest = "private_link_service_aliases"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkAzure. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkAzure.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkAzure.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 private_link_service_aliases: Optional[Mapping[str, str]] = None):
        """
        :param Mapping[str, str] private_link_service_aliases: (Optional Map) The mapping of zones to Private Link Service Aliases if available. Keys are zone names, for example, `1` and values are [Azure Private Link Service Aliases](https://docs.microsoft.com/en-us/azure/private-link/private-link-service-overview#share-your-service), for example, `s-nk99e-privatelink-1.8c43dcd0-695c-1234-bc35-11fe6abb303a.centralus.azure.privatelinkservice`.
        """
        if private_link_service_aliases is not None:
            pulumi.set(__self__, "private_link_service_aliases", private_link_service_aliases)

    @property
    @pulumi.getter(name="privateLinkServiceAliases")
    def private_link_service_aliases(self) -> Optional[Mapping[str, str]]:
        """
        (Optional Map) The mapping of zones to Private Link Service Aliases if available. Keys are zone names, for example, `1` and values are [Azure Private Link Service Aliases](https://docs.microsoft.com/en-us/azure/private-link/private-link-service-overview#share-your-service), for example, `s-nk99e-privatelink-1.8c43dcd0-695c-1234-bc35-11fe6abb303a.centralus.azure.privatelinkservice`.
        """
        return pulumi.get(self, "private_link_service_aliases")


@pulumi.output_type
class NetworkDnsConfig(dict):
    def __init__(__self__, *,
                 resolution: str):
        """
        :param str resolution: Network DNS resolution.
               When resolution is `CHASED_PRIVATE`, clusters in this network require both public and private DNS to resolve cluster endpoints.
               When resolution is `PRIVATE`, clusters in this network only require private DNS to resolve cluster endpoints.
               The Confluent Cloud Console uses `resolution = PRIVATE`.
        """
        pulumi.set(__self__, "resolution", resolution)

    @property
    @pulumi.getter
    def resolution(self) -> str:
        """
        Network DNS resolution.
        When resolution is `CHASED_PRIVATE`, clusters in this network require both public and private DNS to resolve cluster endpoints.
        When resolution is `PRIVATE`, clusters in this network only require private DNS to resolve cluster endpoints.
        The Confluent Cloud Console uses `resolution = PRIVATE`.
        """
        return pulumi.get(self, "resolution")


@pulumi.output_type
class NetworkEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Network belongs to, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Network belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class NetworkGateway(dict):
    def __init__(__self__, *,
                 id: Optional[str] = None):
        """
        :param str id: (Optional String) The ID of the Gateway, for example, `gw-abc123`.
        """
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        (Optional String) The ID of the Gateway, for example, `gw-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class NetworkGcp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateServiceConnectServiceAttachments":
            suggest = "private_service_connect_service_attachments"
        elif key == "vpcNetwork":
            suggest = "vpc_network"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkGcp. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkGcp.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkGcp.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 private_service_connect_service_attachments: Optional[Mapping[str, str]] = None,
                 project: Optional[str] = None,
                 vpc_network: Optional[str] = None):
        """
        :param Mapping[str, str] private_service_connect_service_attachments: (Optional Map) The mapping of zones to Private Service Connect Service Attachments if available. Keys are zones and values are [GCP Private Service Connect service attachment](https://cloud.google.com/vpc/docs/configure-private-service-connect-producer#api_7).
        :param str project: (Required String) The GCP Project ID associated with the Confluent Cloud VPC.
        :param str vpc_network: (Required String) The network name of the Confluent Cloud VPC.
        """
        if private_service_connect_service_attachments is not None:
            pulumi.set(__self__, "private_service_connect_service_attachments", private_service_connect_service_attachments)
        if project is not None:
            pulumi.set(__self__, "project", project)
        if vpc_network is not None:
            pulumi.set(__self__, "vpc_network", vpc_network)

    @property
    @pulumi.getter(name="privateServiceConnectServiceAttachments")
    def private_service_connect_service_attachments(self) -> Optional[Mapping[str, str]]:
        """
        (Optional Map) The mapping of zones to Private Service Connect Service Attachments if available. Keys are zones and values are [GCP Private Service Connect service attachment](https://cloud.google.com/vpc/docs/configure-private-service-connect-producer#api_7).
        """
        return pulumi.get(self, "private_service_connect_service_attachments")

    @property
    @pulumi.getter
    def project(self) -> Optional[str]:
        """
        (Required String) The GCP Project ID associated with the Confluent Cloud VPC.
        """
        return pulumi.get(self, "project")

    @property
    @pulumi.getter(name="vpcNetwork")
    def vpc_network(self) -> Optional[str]:
        """
        (Required String) The network name of the Confluent Cloud VPC.
        """
        return pulumi.get(self, "vpc_network")


@pulumi.output_type
class NetworkLinkEndpointEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Network Link Endpoint belongs to, for example, `env-xyz456`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Network Link Endpoint belongs to, for example, `env-xyz456`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class NetworkLinkEndpointNetwork(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Network that the Network Link Endpoint belongs to, for example, `n-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Network that the Network Link Endpoint belongs to, for example, `n-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class NetworkLinkEndpointNetworkLinkService(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Network Link Service, for example, `nls-g3e1ox`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Network Link Service, for example, `nls-g3e1ox`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class NetworkLinkServiceAccept(dict):
    def __init__(__self__, *,
                 environments: Optional[Sequence[str]] = None,
                 networks: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] environments: List of environments ids from which connections can be accepted. All networks within the list of environment will be allowed.
        :param Sequence[str] networks: List of network ids from which connections can be accepted.
        """
        if environments is not None:
            pulumi.set(__self__, "environments", environments)
        if networks is not None:
            pulumi.set(__self__, "networks", networks)

    @property
    @pulumi.getter
    def environments(self) -> Optional[Sequence[str]]:
        """
        List of environments ids from which connections can be accepted. All networks within the list of environment will be allowed.
        """
        return pulumi.get(self, "environments")

    @property
    @pulumi.getter
    def networks(self) -> Optional[Sequence[str]]:
        """
        List of network ids from which connections can be accepted.
        """
        return pulumi.get(self, "networks")


@pulumi.output_type
class NetworkLinkServiceEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Network Link Service belongs to, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Network Link Service belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class NetworkLinkServiceNetwork(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Network that the Network Link Service belongs to, for example, `n-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Network that the Network Link Service belongs to, for example, `n-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class NetworkZoneInfo(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "zoneId":
            suggest = "zone_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NetworkZoneInfo. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NetworkZoneInfo.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NetworkZoneInfo.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cidr: Optional[str] = None,
                 zone_id: Optional[str] = None):
        """
        :param str cidr: The IPv4 CIDR block to be used for the network. Must be `/27`. Required for VPC peering and AWS TransitGateway.
               
               > **Note:** The `zone_info` configuration block and `reserved_cidr` are in a [Limited Availability lifecycle stage](https://docs.confluent.io/cloud/current/api.html#section/Versioning/API-Lifecycle-Policy), and it's available only for AWS networks with PEERING connection type.
        :param str zone_id: Cloud provider zone ID.
        """
        if cidr is not None:
            pulumi.set(__self__, "cidr", cidr)
        if zone_id is not None:
            pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter
    def cidr(self) -> Optional[str]:
        """
        The IPv4 CIDR block to be used for the network. Must be `/27`. Required for VPC peering and AWS TransitGateway.

        > **Note:** The `zone_info` configuration block and `reserved_cidr` are in a [Limited Availability lifecycle stage](https://docs.confluent.io/cloud/current/api.html#section/Versioning/API-Lifecycle-Policy), and it's available only for AWS networks with PEERING connection type.
        """
        return pulumi.get(self, "cidr")

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> Optional[str]:
        """
        Cloud provider zone ID.
        """
        return pulumi.get(self, "zone_id")


@pulumi.output_type
class PeeringAws(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customerRegion":
            suggest = "customer_region"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PeeringAws. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PeeringAws.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PeeringAws.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 account: str,
                 customer_region: str,
                 routes: Sequence[str],
                 vpc: str):
        """
        :param str account: The AWS Account ID of the peer VPC owner. You can find your AWS Account ID [here](https://console.aws.amazon.com/billing/home?#/account) under **My Account** section of the AWS Management Console. Must be a **12 character string**.
        :param str customer_region: The region of the AWS peer VPC.
        :param Sequence[str] routes: The AWS VPC CIDR blocks or subsets. This must be from the supported CIDR blocks and must not overlap with your Confluent Cloud CIDR block or any other network peering connection VPC CIDR (learn more about the requirements [here](https://docs.confluent.io/cloud/current/networking/peering/aws-peering.html#vpc-peering-on-aws)). You can find AWS VPC CIDR [here](https://console.aws.amazon.com/vpc/) under **Your VPCs > Target VPC > Details** section of the AWS Management Console.
        :param str vpc: The AWS VPC ID of the peer VPC that you're peering with Confluent Cloud. You can find your AWS VPC ID [here](https://console.aws.amazon.com/vpc/) under **Your VPCs** section of the AWS Management Console. Must start with `vpc-`.
        """
        pulumi.set(__self__, "account", account)
        pulumi.set(__self__, "customer_region", customer_region)
        pulumi.set(__self__, "routes", routes)
        pulumi.set(__self__, "vpc", vpc)

    @property
    @pulumi.getter
    def account(self) -> str:
        """
        The AWS Account ID of the peer VPC owner. You can find your AWS Account ID [here](https://console.aws.amazon.com/billing/home?#/account) under **My Account** section of the AWS Management Console. Must be a **12 character string**.
        """
        return pulumi.get(self, "account")

    @property
    @pulumi.getter(name="customerRegion")
    def customer_region(self) -> str:
        """
        The region of the AWS peer VPC.
        """
        return pulumi.get(self, "customer_region")

    @property
    @pulumi.getter
    def routes(self) -> Sequence[str]:
        """
        The AWS VPC CIDR blocks or subsets. This must be from the supported CIDR blocks and must not overlap with your Confluent Cloud CIDR block or any other network peering connection VPC CIDR (learn more about the requirements [here](https://docs.confluent.io/cloud/current/networking/peering/aws-peering.html#vpc-peering-on-aws)). You can find AWS VPC CIDR [here](https://console.aws.amazon.com/vpc/) under **Your VPCs > Target VPC > Details** section of the AWS Management Console.
        """
        return pulumi.get(self, "routes")

    @property
    @pulumi.getter
    def vpc(self) -> str:
        """
        The AWS VPC ID of the peer VPC that you're peering with Confluent Cloud. You can find your AWS VPC ID [here](https://console.aws.amazon.com/vpc/) under **Your VPCs** section of the AWS Management Console. Must start with `vpc-`.
        """
        return pulumi.get(self, "vpc")


@pulumi.output_type
class PeeringAzure(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customerRegion":
            suggest = "customer_region"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PeeringAzure. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PeeringAzure.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PeeringAzure.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 customer_region: str,
                 tenant: str,
                 vnet: str):
        """
        :param str customer_region: The region of the Azure peer VNet.
        :param str tenant: The Tenant ID that represents an organization in Azure Active Directory. You can find your Azure Tenant ID in the [Azure Portal under Azure Active Directory](https://portal.azure.com/#blade/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/Overview). Must be a valid **32 character UUID string**.
        :param str vnet: The resource (composite) ID of the peer Virtual Network that you're peering with Confluent Cloud, in the format `/subscriptions/<Subscription ID>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/virtualNetworks/<VNet name>`. You can find Subscription ID, Resource Group Name and your VNet name under **Virtual Networks > Target VNet > Essentials** section of your [Microsoft Azure Portal](https://portal.azure.com/).
        """
        pulumi.set(__self__, "customer_region", customer_region)
        pulumi.set(__self__, "tenant", tenant)
        pulumi.set(__self__, "vnet", vnet)

    @property
    @pulumi.getter(name="customerRegion")
    def customer_region(self) -> str:
        """
        The region of the Azure peer VNet.
        """
        return pulumi.get(self, "customer_region")

    @property
    @pulumi.getter
    def tenant(self) -> str:
        """
        The Tenant ID that represents an organization in Azure Active Directory. You can find your Azure Tenant ID in the [Azure Portal under Azure Active Directory](https://portal.azure.com/#blade/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/Overview). Must be a valid **32 character UUID string**.
        """
        return pulumi.get(self, "tenant")

    @property
    @pulumi.getter
    def vnet(self) -> str:
        """
        The resource (composite) ID of the peer Virtual Network that you're peering with Confluent Cloud, in the format `/subscriptions/<Subscription ID>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/virtualNetworks/<VNet name>`. You can find Subscription ID, Resource Group Name and your VNet name under **Virtual Networks > Target VNet > Essentials** section of your [Microsoft Azure Portal](https://portal.azure.com/).
        """
        return pulumi.get(self, "vnet")


@pulumi.output_type
class PeeringEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Peering belongs to, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Peering belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class PeeringGcp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vpcNetwork":
            suggest = "vpc_network"
        elif key == "importCustomRoutes":
            suggest = "import_custom_routes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PeeringGcp. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PeeringGcp.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PeeringGcp.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 project: str,
                 vpc_network: str,
                 import_custom_routes: Optional[bool] = None):
        """
        :param str project: The GCP Project ID. You can find your Google Cloud Project ID under **Project ID** section of your [Google Cloud Console dashboard](https://console.cloud.google.com/home/dashboard).
        :param str vpc_network: The VPC network name that you're peering to Confluent Cloud. You can find your VPC network name under **VPC Networks** section of your [Google Cloud Console](https://console.cloud.google.com/networking/networks/list).
        :param bool import_custom_routes: The Import Custom Routes option enables connectivity to a Confluent Cloud cluster in Google Cloud from customer premise or other clouds, such as AWS and Azure, through a customer VPC that is peered with Confluent Cloud in the same region. Defaults to `false`. Learn more about considerations / limitations of the Import Custom Routes option [here](https://docs.confluent.io/cloud/current/networking/peering/gcp-peering.html#import-custom-routes).
               
               > **Note:** Exactly one from the `aws`, `azure`, and `gcp` configuration blocks must be specified.
               
               > **Note:** Learn more about VPC Peering requirements on AWS [here](https://docs.confluent.io/cloud/current/networking/peering/aws-peering.html#vpc-peering-on-aws).
               
               > **Note:** Learn more about VNet Peering requirements on Azure [here](https://docs.confluent.io/cloud/current/networking/peering/azure-peering.html#vnet-peering-on-az).
               
               > **Note:** Learn more about VPC Peering requirements on Google Cloud Platform [here](https://docs.confluent.io/cloud/current/networking/peering/gcp-peering.html#vpc-peering-on-gcp).
        """
        pulumi.set(__self__, "project", project)
        pulumi.set(__self__, "vpc_network", vpc_network)
        if import_custom_routes is not None:
            pulumi.set(__self__, "import_custom_routes", import_custom_routes)

    @property
    @pulumi.getter
    def project(self) -> str:
        """
        The GCP Project ID. You can find your Google Cloud Project ID under **Project ID** section of your [Google Cloud Console dashboard](https://console.cloud.google.com/home/dashboard).
        """
        return pulumi.get(self, "project")

    @property
    @pulumi.getter(name="vpcNetwork")
    def vpc_network(self) -> str:
        """
        The VPC network name that you're peering to Confluent Cloud. You can find your VPC network name under **VPC Networks** section of your [Google Cloud Console](https://console.cloud.google.com/networking/networks/list).
        """
        return pulumi.get(self, "vpc_network")

    @property
    @pulumi.getter(name="importCustomRoutes")
    def import_custom_routes(self) -> Optional[bool]:
        """
        The Import Custom Routes option enables connectivity to a Confluent Cloud cluster in Google Cloud from customer premise or other clouds, such as AWS and Azure, through a customer VPC that is peered with Confluent Cloud in the same region. Defaults to `false`. Learn more about considerations / limitations of the Import Custom Routes option [here](https://docs.confluent.io/cloud/current/networking/peering/gcp-peering.html#import-custom-routes).

        > **Note:** Exactly one from the `aws`, `azure`, and `gcp` configuration blocks must be specified.

        > **Note:** Learn more about VPC Peering requirements on AWS [here](https://docs.confluent.io/cloud/current/networking/peering/aws-peering.html#vpc-peering-on-aws).

        > **Note:** Learn more about VNet Peering requirements on Azure [here](https://docs.confluent.io/cloud/current/networking/peering/azure-peering.html#vnet-peering-on-az).

        > **Note:** Learn more about VPC Peering requirements on Google Cloud Platform [here](https://docs.confluent.io/cloud/current/networking/peering/gcp-peering.html#vpc-peering-on-gcp).
        """
        return pulumi.get(self, "import_custom_routes")


@pulumi.output_type
class PeeringNetwork(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Network that the Peering belongs to, for example, `n-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Network that the Peering belongs to, for example, `n-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class PrivateLinkAccessAws(dict):
    def __init__(__self__, *,
                 account: str):
        """
        :param str account: The AWS account ID to enable for the Private Link Access. You can find your AWS account ID [here] (https://console.aws.amazon.com/billing/home?#/account) under **My Account** in your AWS Management Console. Must be a **12 character string**.
        """
        pulumi.set(__self__, "account", account)

    @property
    @pulumi.getter
    def account(self) -> str:
        """
        The AWS account ID to enable for the Private Link Access. You can find your AWS account ID [here] (https://console.aws.amazon.com/billing/home?#/account) under **My Account** in your AWS Management Console. Must be a **12 character string**.
        """
        return pulumi.get(self, "account")


@pulumi.output_type
class PrivateLinkAccessAzure(dict):
    def __init__(__self__, *,
                 subscription: str):
        """
        :param str subscription: The Azure subscription ID to enable for the Private Link Access. You can find your Azure subscription ID in the subscription section of your [Microsoft Azure Portal] (https://portal.azure.com/#blade/Microsoft_Azure_Billing/SubscriptionsBlade). Must be a valid **32 character UUID string**.
        """
        pulumi.set(__self__, "subscription", subscription)

    @property
    @pulumi.getter
    def subscription(self) -> str:
        """
        The Azure subscription ID to enable for the Private Link Access. You can find your Azure subscription ID in the subscription section of your [Microsoft Azure Portal] (https://portal.azure.com/#blade/Microsoft_Azure_Billing/SubscriptionsBlade). Must be a valid **32 character UUID string**.
        """
        return pulumi.get(self, "subscription")


@pulumi.output_type
class PrivateLinkAccessEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Private Link Access belongs to, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Private Link Access belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class PrivateLinkAccessGcp(dict):
    def __init__(__self__, *,
                 project: str):
        """
        :param str project: The GCP project ID to allow for Private Service Connect access. You can find your Google Cloud Project ID under **Project ID** section of your [Google Cloud Console dashboard](https://console.cloud.google.com/home/dashboard).
               
               > **Note:** Exactly one from the `aws`, `azure`, `gcp` configuration blocks must be specified.
               
               > **Note:** Learn more about Private Link Access limitations on AWS [here](https://docs.confluent.io/cloud/current/networking/private-links/aws-privatelink.html#limitations).
               
               > **Note:** Learn more about Private Link Access limitations on Azure [here](https://docs.confluent.io/cloud/current/networking/private-links/azure-privatelink.html#limitations).
        """
        pulumi.set(__self__, "project", project)

    @property
    @pulumi.getter
    def project(self) -> str:
        """
        The GCP project ID to allow for Private Service Connect access. You can find your Google Cloud Project ID under **Project ID** section of your [Google Cloud Console dashboard](https://console.cloud.google.com/home/dashboard).

        > **Note:** Exactly one from the `aws`, `azure`, `gcp` configuration blocks must be specified.

        > **Note:** Learn more about Private Link Access limitations on AWS [here](https://docs.confluent.io/cloud/current/networking/private-links/aws-privatelink.html#limitations).

        > **Note:** Learn more about Private Link Access limitations on Azure [here](https://docs.confluent.io/cloud/current/networking/private-links/azure-privatelink.html#limitations).
        """
        return pulumi.get(self, "project")


@pulumi.output_type
class PrivateLinkAccessNetwork(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Network that the Private Link Access belongs to, for example, `n-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Network that the Private Link Access belongs to, for example, `n-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class PrivateLinkAttachmentAw(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vpcEndpointServiceName":
            suggest = "vpc_endpoint_service_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PrivateLinkAttachmentAw. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PrivateLinkAttachmentAw.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PrivateLinkAttachmentAw.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 vpc_endpoint_service_name: Optional[str] = None):
        """
        :param str vpc_endpoint_service_name: (Required String) AWS VPC Endpoint Service that can be used to establish connections for all zones, for example `com.amazonaws.vpce.us-west-2.vpce-svc-0d3be37e21708ecd3`.
        """
        if vpc_endpoint_service_name is not None:
            pulumi.set(__self__, "vpc_endpoint_service_name", vpc_endpoint_service_name)

    @property
    @pulumi.getter(name="vpcEndpointServiceName")
    def vpc_endpoint_service_name(self) -> Optional[str]:
        """
        (Required String) AWS VPC Endpoint Service that can be used to establish connections for all zones, for example `com.amazonaws.vpce.us-west-2.vpce-svc-0d3be37e21708ecd3`.
        """
        return pulumi.get(self, "vpc_endpoint_service_name")


@pulumi.output_type
class PrivateLinkAttachmentAzure(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateLinkServiceAlias":
            suggest = "private_link_service_alias"
        elif key == "privateLinkServiceResourceId":
            suggest = "private_link_service_resource_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PrivateLinkAttachmentAzure. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PrivateLinkAttachmentAzure.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PrivateLinkAttachmentAzure.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 private_link_service_alias: Optional[str] = None,
                 private_link_service_resource_id: Optional[str] = None):
        """
        :param str private_link_service_alias: Azure PrivateLink service alias for the availability zone.
        :param str private_link_service_resource_id: (Required String) Azure Private Link service resource id for the availability zone.
        """
        if private_link_service_alias is not None:
            pulumi.set(__self__, "private_link_service_alias", private_link_service_alias)
        if private_link_service_resource_id is not None:
            pulumi.set(__self__, "private_link_service_resource_id", private_link_service_resource_id)

    @property
    @pulumi.getter(name="privateLinkServiceAlias")
    def private_link_service_alias(self) -> Optional[str]:
        """
        Azure PrivateLink service alias for the availability zone.
        """
        return pulumi.get(self, "private_link_service_alias")

    @property
    @pulumi.getter(name="privateLinkServiceResourceId")
    def private_link_service_resource_id(self) -> Optional[str]:
        """
        (Required String) Azure Private Link service resource id for the availability zone.
        """
        return pulumi.get(self, "private_link_service_resource_id")


@pulumi.output_type
class PrivateLinkAttachmentConnectionAws(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "vpcEndpointId":
            suggest = "vpc_endpoint_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PrivateLinkAttachmentConnectionAws. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PrivateLinkAttachmentConnectionAws.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PrivateLinkAttachmentConnectionAws.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 vpc_endpoint_id: str):
        """
        :param str vpc_endpoint_id: Id of a VPC Endpoint that is connected to the VPC Endpoint service.
        """
        pulumi.set(__self__, "vpc_endpoint_id", vpc_endpoint_id)

    @property
    @pulumi.getter(name="vpcEndpointId")
    def vpc_endpoint_id(self) -> str:
        """
        Id of a VPC Endpoint that is connected to the VPC Endpoint service.
        """
        return pulumi.get(self, "vpc_endpoint_id")


@pulumi.output_type
class PrivateLinkAttachmentConnectionAzure(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateEndpointResourceId":
            suggest = "private_endpoint_resource_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PrivateLinkAttachmentConnectionAzure. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PrivateLinkAttachmentConnectionAzure.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PrivateLinkAttachmentConnectionAzure.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 private_endpoint_resource_id: str):
        """
        :param str private_endpoint_resource_id: Resource ID of the Private Endpoint that is connected to the Private Link service.
        """
        pulumi.set(__self__, "private_endpoint_resource_id", private_endpoint_resource_id)

    @property
    @pulumi.getter(name="privateEndpointResourceId")
    def private_endpoint_resource_id(self) -> str:
        """
        Resource ID of the Private Endpoint that is connected to the Private Link service.
        """
        return pulumi.get(self, "private_endpoint_resource_id")


@pulumi.output_type
class PrivateLinkAttachmentConnectionEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Private Link Attachment Connection belongs to, for example `env-xyz456`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Private Link Attachment Connection belongs to, for example `env-xyz456`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class PrivateLinkAttachmentConnectionGcp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateServiceConnectConnectionId":
            suggest = "private_service_connect_connection_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PrivateLinkAttachmentConnectionGcp. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PrivateLinkAttachmentConnectionGcp.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PrivateLinkAttachmentConnectionGcp.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 private_service_connect_connection_id: str):
        """
        :param str private_service_connect_connection_id: Id of the Private Service connection.
        """
        pulumi.set(__self__, "private_service_connect_connection_id", private_service_connect_connection_id)

    @property
    @pulumi.getter(name="privateServiceConnectConnectionId")
    def private_service_connect_connection_id(self) -> str:
        """
        Id of the Private Service connection.
        """
        return pulumi.get(self, "private_service_connect_connection_id")


@pulumi.output_type
class PrivateLinkAttachmentConnectionPrivateLinkAttachment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The unique identifier for the private link attachment.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The unique identifier for the private link attachment.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class PrivateLinkAttachmentEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Private Link Attachment belongs to, for example `env-xyz456`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Private Link Attachment belongs to, for example `env-xyz456`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class PrivateLinkAttachmentGcp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateServiceConnectServiceAttachment":
            suggest = "private_service_connect_service_attachment"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PrivateLinkAttachmentGcp. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PrivateLinkAttachmentGcp.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PrivateLinkAttachmentGcp.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 private_service_connect_service_attachment: Optional[str] = None,
                 zone: Optional[str] = None):
        """
        :param str private_service_connect_service_attachment: Id of a Private Service Connect Service Attachment in Confluent Cloud.
        :param str zone: Zone associated with the PSC Service attachment.
        """
        if private_service_connect_service_attachment is not None:
            pulumi.set(__self__, "private_service_connect_service_attachment", private_service_connect_service_attachment)
        if zone is not None:
            pulumi.set(__self__, "zone", zone)

    @property
    @pulumi.getter(name="privateServiceConnectServiceAttachment")
    def private_service_connect_service_attachment(self) -> Optional[str]:
        """
        Id of a Private Service Connect Service Attachment in Confluent Cloud.
        """
        return pulumi.get(self, "private_service_connect_service_attachment")

    @property
    @pulumi.getter
    def zone(self) -> Optional[str]:
        """
        Zone associated with the PSC Service attachment.
        """
        return pulumi.get(self, "zone")


@pulumi.output_type
class ProviderIntegrationAws(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customerRoleArn":
            suggest = "customer_role_arn"
        elif key == "externalId":
            suggest = "external_id"
        elif key == "iamRoleArn":
            suggest = "iam_role_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProviderIntegrationAws. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProviderIntegrationAws.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProviderIntegrationAws.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 customer_role_arn: str,
                 external_id: Optional[str] = None,
                 iam_role_arn: Optional[str] = None):
        """
        :param str customer_role_arn: Amazon Resource Name (ARN) that identifies the AWS Identity and Access Management (IAM) role that Confluent Cloud assumes when it accesses resources in your AWS account.
               
               > **Note:** Currently only `aws` config is supported, more cloud service provider config will be supported in the short future.
               
               > **Note:** `customer_role_arn` must be unique in a given environment for creating a new Provider Integration.
        :param str external_id: (Required String) Unique external ID that Confluent Cloud uses when it assumes the IAM role in your Amazon Web Services (AWS) account.
        :param str iam_role_arn: (Required String) The IAM role ARN used in Confluent Cloud internally, bundled with `customer_role_arn`.
        """
        pulumi.set(__self__, "customer_role_arn", customer_role_arn)
        if external_id is not None:
            pulumi.set(__self__, "external_id", external_id)
        if iam_role_arn is not None:
            pulumi.set(__self__, "iam_role_arn", iam_role_arn)

    @property
    @pulumi.getter(name="customerRoleArn")
    def customer_role_arn(self) -> str:
        """
        Amazon Resource Name (ARN) that identifies the AWS Identity and Access Management (IAM) role that Confluent Cloud assumes when it accesses resources in your AWS account.

        > **Note:** Currently only `aws` config is supported, more cloud service provider config will be supported in the short future.

        > **Note:** `customer_role_arn` must be unique in a given environment for creating a new Provider Integration.
        """
        return pulumi.get(self, "customer_role_arn")

    @property
    @pulumi.getter(name="externalId")
    def external_id(self) -> Optional[str]:
        """
        (Required String) Unique external ID that Confluent Cloud uses when it assumes the IAM role in your Amazon Web Services (AWS) account.
        """
        return pulumi.get(self, "external_id")

    @property
    @pulumi.getter(name="iamRoleArn")
    def iam_role_arn(self) -> Optional[str]:
        """
        (Required String) The IAM role ARN used in Confluent Cloud internally, bundled with `customer_role_arn`.
        """
        return pulumi.get(self, "iam_role_arn")


@pulumi.output_type
class ProviderIntegrationEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class SchemaCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Cluster API Secret for your Confluent Cloud cluster.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Cluster API Secret for your Confluent Cloud cluster.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class SchemaExporterCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class SchemaExporterDestinationSchemaRegistryCluster(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "restEndpoint":
            suggest = "rest_endpoint"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SchemaExporterDestinationSchemaRegistryCluster. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SchemaExporterDestinationSchemaRegistryCluster.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SchemaExporterDestinationSchemaRegistryCluster.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 credentials: 'outputs.SchemaExporterDestinationSchemaRegistryClusterCredentials',
                 rest_endpoint: str):
        """
        :param str rest_endpoint: The REST endpoint of the destination Schema Registry cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
        pulumi.set(__self__, "credentials", credentials)
        pulumi.set(__self__, "rest_endpoint", rest_endpoint)

    @property
    @pulumi.getter
    def credentials(self) -> 'outputs.SchemaExporterDestinationSchemaRegistryClusterCredentials':
        return pulumi.get(self, "credentials")

    @property
    @pulumi.getter(name="restEndpoint")
    def rest_endpoint(self) -> str:
        """
        The REST endpoint of the destination Schema Registry cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
        return pulumi.get(self, "rest_endpoint")


@pulumi.output_type
class SchemaExporterDestinationSchemaRegistryClusterCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class SchemaExporterSchemaRegistryCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class SchemaMetadata(dict):
    def __init__(__self__, *,
                 properties: Optional[Mapping[str, str]] = None,
                 sensitives: Optional[Sequence[str]] = None,
                 tags: Optional[Sequence['outputs.SchemaMetadataTag']] = None):
        """
        :param Mapping[str, str] properties: The custom properties to set:
        :param Sequence[str] sensitives: A list of metadata properties to be encrypted.
        :param Sequence['SchemaMetadataTagArgs'] tags: The tags to which the rule applies, if any.
        """
        if properties is not None:
            pulumi.set(__self__, "properties", properties)
        if sensitives is not None:
            pulumi.set(__self__, "sensitives", sensitives)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter
    def properties(self) -> Optional[Mapping[str, str]]:
        """
        The custom properties to set:
        """
        return pulumi.get(self, "properties")

    @property
    @pulumi.getter
    def sensitives(self) -> Optional[Sequence[str]]:
        """
        A list of metadata properties to be encrypted.
        """
        return pulumi.get(self, "sensitives")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence['outputs.SchemaMetadataTag']]:
        """
        The tags to which the rule applies, if any.
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class SchemaMetadataTag(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        """
        :param str key: The setting name.
        :param Sequence[str] values: The list of tags.
        """
        if key is not None:
            pulumi.set(__self__, "key", key)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        """
        The setting name.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[str]]:
        """
        The list of tags.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class SchemaRegistryClusterConfigCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Cluster API Secret for your Confluent Cloud cluster.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Cluster API Secret for your Confluent Cloud cluster.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class SchemaRegistryClusterConfigSchemaRegistryCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class SchemaRegistryClusterModeCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Cluster API Secret for your Confluent Cloud cluster.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Cluster API Secret for your Confluent Cloud cluster.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class SchemaRegistryClusterModeSchemaRegistryCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class SchemaRegistryDekCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class SchemaRegistryDekSchemaRegistryCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class SchemaRegistryKekCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class SchemaRegistryKekSchemaRegistryCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class SchemaRuleset(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "domainRules":
            suggest = "domain_rules"
        elif key == "migrationRules":
            suggest = "migration_rules"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SchemaRuleset. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SchemaRuleset.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SchemaRuleset.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 domain_rules: Optional[Sequence['outputs.SchemaRulesetDomainRule']] = None,
                 migration_rules: Optional[Sequence['outputs.SchemaRulesetMigrationRule']] = None):
        if domain_rules is not None:
            pulumi.set(__self__, "domain_rules", domain_rules)
        if migration_rules is not None:
            pulumi.set(__self__, "migration_rules", migration_rules)

    @property
    @pulumi.getter(name="domainRules")
    def domain_rules(self) -> Optional[Sequence['outputs.SchemaRulesetDomainRule']]:
        return pulumi.get(self, "domain_rules")

    @property
    @pulumi.getter(name="migrationRules")
    def migration_rules(self) -> Optional[Sequence['outputs.SchemaRulesetMigrationRule']]:
        return pulumi.get(self, "migration_rules")


@pulumi.output_type
class SchemaRulesetDomainRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "onFailure":
            suggest = "on_failure"
        elif key == "onSuccess":
            suggest = "on_success"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SchemaRulesetDomainRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SchemaRulesetDomainRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SchemaRulesetDomainRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kind: str,
                 mode: str,
                 name: str,
                 type: str,
                 disabled: Optional[bool] = None,
                 doc: Optional[str] = None,
                 expr: Optional[str] = None,
                 on_failure: Optional[str] = None,
                 on_success: Optional[str] = None,
                 params: Optional[Mapping[str, str]] = None,
                 tags: Optional[Sequence[str]] = None):
        """
        :param str kind: The kind of the rule. Accepted values are `CONDITION` and `TRANSFORM`. `CONDITION` - validate the value of a field, `TRANSFORM` - transform the value of a field. Data quality rules use `CONDITION` kind, data transformation, encryption and migration rules use `TRANSFORM` kind.
        :param str mode: The mode of the rule. Accepted values are `UPGRADE`, `DOWNGRADE`, `UPDOWN`, `WRITE`, `READ`, and `WRITEREAD`.
        :param str name: A user-defined name that can be used to reference the rule.
        :param str type: The type of rule, which invokes a specific rule executor that that will run the rule. Google Common Expression Language (`CEL`) is used for data quality and transformation rules, Confluent `ENCRYPT` is used for data encryption rules, and `JSONata` is used for migration rules.
        :param bool disabled: The boolean flag to control whether the rule should be disabled. Defaults to `false`.
        :param str doc: An optional description of the rule. Defaults to "".
        :param str expr: The rule body. Data quality and transformation rules use `CEL` language expressions, data migration rules use `JSONata` expressions. Defaults to "".
        :param str on_failure: An optional action to execute if the rule fails, otherwise the built-in action type `ERROR` is used. For `UPDOWN` and `WRITEREAD` rules, one can specify two actions separated by commas, as mentioned above. Defaults to `ERROR,ERROR`.
        :param str on_success: An optional action to execute if the rule succeeds, otherwise the built-in action type `NONE` is used. For `UPDOWN` and `WRITEREAD` rules, one can specify two actions separated by commas, such as "NONE,ERROR" for a `WRITEREAD` rule. In this case `NONE` applies to `WRITE` and `ERROR` applies to `READ`. Defaults to `NONE,NONE`.
        :param Mapping[str, str] params: A set of static parameters for the rule, which is optional. These are key-value pairs that are passed to the rule.
               
               > **Note:** Schema rules (`ruleset`) are only available with the [Stream Governance Advanced package](https://docs.confluent.io/cloud/current/stream-governance/packages.html#packages).
        :param Sequence[str] tags: The tags to which the rule applies, if any.
        """
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if doc is not None:
            pulumi.set(__self__, "doc", doc)
        if expr is not None:
            pulumi.set(__self__, "expr", expr)
        if on_failure is not None:
            pulumi.set(__self__, "on_failure", on_failure)
        if on_success is not None:
            pulumi.set(__self__, "on_success", on_success)
        if params is not None:
            pulumi.set(__self__, "params", params)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter
    def kind(self) -> str:
        """
        The kind of the rule. Accepted values are `CONDITION` and `TRANSFORM`. `CONDITION` - validate the value of a field, `TRANSFORM` - transform the value of a field. Data quality rules use `CONDITION` kind, data transformation, encryption and migration rules use `TRANSFORM` kind.
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        The mode of the rule. Accepted values are `UPGRADE`, `DOWNGRADE`, `UPDOWN`, `WRITE`, `READ`, and `WRITEREAD`.
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        A user-defined name that can be used to reference the rule.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of rule, which invokes a specific rule executor that that will run the rule. Google Common Expression Language (`CEL`) is used for data quality and transformation rules, Confluent `ENCRYPT` is used for data encryption rules, and `JSONata` is used for migration rules.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def disabled(self) -> Optional[bool]:
        """
        The boolean flag to control whether the rule should be disabled. Defaults to `false`.
        """
        return pulumi.get(self, "disabled")

    @property
    @pulumi.getter
    def doc(self) -> Optional[str]:
        """
        An optional description of the rule. Defaults to "".
        """
        return pulumi.get(self, "doc")

    @property
    @pulumi.getter
    def expr(self) -> Optional[str]:
        """
        The rule body. Data quality and transformation rules use `CEL` language expressions, data migration rules use `JSONata` expressions. Defaults to "".
        """
        return pulumi.get(self, "expr")

    @property
    @pulumi.getter(name="onFailure")
    def on_failure(self) -> Optional[str]:
        """
        An optional action to execute if the rule fails, otherwise the built-in action type `ERROR` is used. For `UPDOWN` and `WRITEREAD` rules, one can specify two actions separated by commas, as mentioned above. Defaults to `ERROR,ERROR`.
        """
        return pulumi.get(self, "on_failure")

    @property
    @pulumi.getter(name="onSuccess")
    def on_success(self) -> Optional[str]:
        """
        An optional action to execute if the rule succeeds, otherwise the built-in action type `NONE` is used. For `UPDOWN` and `WRITEREAD` rules, one can specify two actions separated by commas, such as "NONE,ERROR" for a `WRITEREAD` rule. In this case `NONE` applies to `WRITE` and `ERROR` applies to `READ`. Defaults to `NONE,NONE`.
        """
        return pulumi.get(self, "on_success")

    @property
    @pulumi.getter
    def params(self) -> Optional[Mapping[str, str]]:
        """
        A set of static parameters for the rule, which is optional. These are key-value pairs that are passed to the rule.

        > **Note:** Schema rules (`ruleset`) are only available with the [Stream Governance Advanced package](https://docs.confluent.io/cloud/current/stream-governance/packages.html#packages).
        """
        return pulumi.get(self, "params")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence[str]]:
        """
        The tags to which the rule applies, if any.
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class SchemaRulesetMigrationRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "onFailure":
            suggest = "on_failure"
        elif key == "onSuccess":
            suggest = "on_success"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SchemaRulesetMigrationRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SchemaRulesetMigrationRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SchemaRulesetMigrationRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kind: str,
                 mode: str,
                 name: str,
                 type: str,
                 disabled: Optional[bool] = None,
                 doc: Optional[str] = None,
                 expr: Optional[str] = None,
                 on_failure: Optional[str] = None,
                 on_success: Optional[str] = None,
                 params: Optional[Mapping[str, str]] = None,
                 tags: Optional[Sequence[str]] = None):
        """
        :param str kind: The kind of the rule. Accepted values are `CONDITION` and `TRANSFORM`. `CONDITION` - validate the value of a field, `TRANSFORM` - transform the value of a field. Data quality rules use `CONDITION` kind, data transformation, encryption and migration rules use `TRANSFORM` kind.
        :param str mode: The mode of the rule. Accepted values are `UPGRADE`, `DOWNGRADE`, `UPDOWN`, `WRITE`, `READ`, and `WRITEREAD`.
        :param str type: The type of rule, which invokes a specific rule executor that that will run the rule. Google Common Expression Language (`CEL`) is used for data quality and transformation rules, Confluent `ENCRYPT` is used for data encryption rules, and `JSONata` is used for migration rules.
        :param bool disabled: The boolean flag to control whether the rule should be disabled. Defaults to `false`.
        :param str doc: An optional description of the rule. Defaults to "".
        :param str expr: The rule body. Data quality and transformation rules use `CEL` language expressions, data migration rules use `JSONata` expressions. Defaults to "".
        :param str on_failure: An optional action to execute if the rule fails, otherwise the built-in action type `ERROR` is used. For `UPDOWN` and `WRITEREAD` rules, one can specify two actions separated by commas, as mentioned above. Defaults to `ERROR,ERROR`.
        :param str on_success: An optional action to execute if the rule succeeds, otherwise the built-in action type `NONE` is used. For `UPDOWN` and `WRITEREAD` rules, one can specify two actions separated by commas, such as "NONE,ERROR" for a `WRITEREAD` rule. In this case `NONE` applies to `WRITE` and `ERROR` applies to `READ`. Defaults to `NONE,NONE`.
        :param Mapping[str, str] params: A set of static parameters for the rule, which is optional. These are key-value pairs that are passed to the rule.
               
               > **Note:** Schema rules (`ruleset`) are only available with the [Stream Governance Advanced package](https://docs.confluent.io/cloud/current/stream-governance/packages.html#packages).
        :param Sequence[str] tags: The tags to which the rule applies, if any.
        """
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if doc is not None:
            pulumi.set(__self__, "doc", doc)
        if expr is not None:
            pulumi.set(__self__, "expr", expr)
        if on_failure is not None:
            pulumi.set(__self__, "on_failure", on_failure)
        if on_success is not None:
            pulumi.set(__self__, "on_success", on_success)
        if params is not None:
            pulumi.set(__self__, "params", params)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter
    def kind(self) -> str:
        """
        The kind of the rule. Accepted values are `CONDITION` and `TRANSFORM`. `CONDITION` - validate the value of a field, `TRANSFORM` - transform the value of a field. Data quality rules use `CONDITION` kind, data transformation, encryption and migration rules use `TRANSFORM` kind.
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        The mode of the rule. Accepted values are `UPGRADE`, `DOWNGRADE`, `UPDOWN`, `WRITE`, `READ`, and `WRITEREAD`.
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter
    def name(self) -> str:
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of rule, which invokes a specific rule executor that that will run the rule. Google Common Expression Language (`CEL`) is used for data quality and transformation rules, Confluent `ENCRYPT` is used for data encryption rules, and `JSONata` is used for migration rules.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def disabled(self) -> Optional[bool]:
        """
        The boolean flag to control whether the rule should be disabled. Defaults to `false`.
        """
        return pulumi.get(self, "disabled")

    @property
    @pulumi.getter
    def doc(self) -> Optional[str]:
        """
        An optional description of the rule. Defaults to "".
        """
        return pulumi.get(self, "doc")

    @property
    @pulumi.getter
    def expr(self) -> Optional[str]:
        """
        The rule body. Data quality and transformation rules use `CEL` language expressions, data migration rules use `JSONata` expressions. Defaults to "".
        """
        return pulumi.get(self, "expr")

    @property
    @pulumi.getter(name="onFailure")
    def on_failure(self) -> Optional[str]:
        """
        An optional action to execute if the rule fails, otherwise the built-in action type `ERROR` is used. For `UPDOWN` and `WRITEREAD` rules, one can specify two actions separated by commas, as mentioned above. Defaults to `ERROR,ERROR`.
        """
        return pulumi.get(self, "on_failure")

    @property
    @pulumi.getter(name="onSuccess")
    def on_success(self) -> Optional[str]:
        """
        An optional action to execute if the rule succeeds, otherwise the built-in action type `NONE` is used. For `UPDOWN` and `WRITEREAD` rules, one can specify two actions separated by commas, such as "NONE,ERROR" for a `WRITEREAD` rule. In this case `NONE` applies to `WRITE` and `ERROR` applies to `READ`. Defaults to `NONE,NONE`.
        """
        return pulumi.get(self, "on_success")

    @property
    @pulumi.getter
    def params(self) -> Optional[Mapping[str, str]]:
        """
        A set of static parameters for the rule, which is optional. These are key-value pairs that are passed to the rule.

        > **Note:** Schema rules (`ruleset`) are only available with the [Stream Governance Advanced package](https://docs.confluent.io/cloud/current/stream-governance/packages.html#packages).
        """
        return pulumi.get(self, "params")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence[str]]:
        """
        The tags to which the rule applies, if any.
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class SchemaSchemaReference(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subjectName":
            suggest = "subject_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SchemaSchemaReference. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SchemaSchemaReference.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SchemaSchemaReference.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 subject_name: str,
                 version: int):
        """
        :param str name: The name of the subject, representing the subject under which the referenced schema is registered.
        :param str subject_name: The name for the reference. (For Avro Schema, the reference name is the fully qualified schema name, for JSON Schema it is a URL, and for Protobuf Schema, it is the name of another Protobuf file.)
        :param int version: The version, representing the exact version of the schema under the registered subject.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "subject_name", subject_name)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the subject, representing the subject under which the referenced schema is registered.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="subjectName")
    def subject_name(self) -> str:
        """
        The name for the reference. (For Avro Schema, the reference name is the fully qualified schema name, for JSON Schema it is a URL, and for Protobuf Schema, it is the name of another Protobuf file.)
        """
        return pulumi.get(self, "subject_name")

    @property
    @pulumi.getter
    def version(self) -> int:
        """
        The version, representing the exact version of the schema under the registered subject.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class SchemaSchemaRegistryCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class SubjectConfigCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Cluster API Secret for your Confluent Cloud cluster.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Cluster API Secret for your Confluent Cloud cluster.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class SubjectConfigSchemaRegistryCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class SubjectModeCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Cluster API Secret for your Confluent Cloud cluster.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Cluster API Secret for your Confluent Cloud cluster.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class SubjectModeSchemaRegistryCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class TagBindingCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class TagBindingSchemaRegistryCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class TagCredentials(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class TagSchemaRegistryCluster(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class TransitGatewayAttachmentAws(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ramResourceShareArn":
            suggest = "ram_resource_share_arn"
        elif key == "transitGatewayId":
            suggest = "transit_gateway_id"
        elif key == "transitGatewayAttachmentId":
            suggest = "transit_gateway_attachment_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransitGatewayAttachmentAws. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransitGatewayAttachmentAws.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransitGatewayAttachmentAws.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ram_resource_share_arn: str,
                 routes: Sequence[str],
                 transit_gateway_id: str,
                 transit_gateway_attachment_id: Optional[str] = None):
        """
        :param str ram_resource_share_arn: The Amazon Resource Name (ARN) of the Resource Access Manager (RAM) Resource Share of the transit gateway your Confluent Cloud network attaches to.
        :param Sequence[str] routes: List of destination routes for traffic from Confluent VPC to customer VPC via Transit Gateway.
               
               > **Note:** Learn more about Transit Gateway Attachment limitations on AWS [here](https://docs.confluent.io/cloud/current/networking/aws-transit-gateway.html#limitations).
        :param str transit_gateway_id: The ID of the AWS Transit Gateway that you want Confluent CLoud to be attached to. Must start with `tgw-`.
        :param str transit_gateway_attachment_id: (Required String) The ID of the AWS Transit Gateway VPC Attachment that attaches Confluent VPC to Transit Gateway.
        """
        pulumi.set(__self__, "ram_resource_share_arn", ram_resource_share_arn)
        pulumi.set(__self__, "routes", routes)
        pulumi.set(__self__, "transit_gateway_id", transit_gateway_id)
        if transit_gateway_attachment_id is not None:
            pulumi.set(__self__, "transit_gateway_attachment_id", transit_gateway_attachment_id)

    @property
    @pulumi.getter(name="ramResourceShareArn")
    def ram_resource_share_arn(self) -> str:
        """
        The Amazon Resource Name (ARN) of the Resource Access Manager (RAM) Resource Share of the transit gateway your Confluent Cloud network attaches to.
        """
        return pulumi.get(self, "ram_resource_share_arn")

    @property
    @pulumi.getter
    def routes(self) -> Sequence[str]:
        """
        List of destination routes for traffic from Confluent VPC to customer VPC via Transit Gateway.

        > **Note:** Learn more about Transit Gateway Attachment limitations on AWS [here](https://docs.confluent.io/cloud/current/networking/aws-transit-gateway.html#limitations).
        """
        return pulumi.get(self, "routes")

    @property
    @pulumi.getter(name="transitGatewayId")
    def transit_gateway_id(self) -> str:
        """
        The ID of the AWS Transit Gateway that you want Confluent CLoud to be attached to. Must start with `tgw-`.
        """
        return pulumi.get(self, "transit_gateway_id")

    @property
    @pulumi.getter(name="transitGatewayAttachmentId")
    def transit_gateway_attachment_id(self) -> Optional[str]:
        """
        (Required String) The ID of the AWS Transit Gateway VPC Attachment that attaches Confluent VPC to Transit Gateway.
        """
        return pulumi.get(self, "transit_gateway_attachment_id")


@pulumi.output_type
class TransitGatewayAttachmentEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Transit Gateway Attachment belongs to, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Transit Gateway Attachment belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class TransitGatewayAttachmentNetwork(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Network that the Transit Gateway Attachment belongs to, for example, `n-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Network that the Transit Gateway Attachment belongs to, for example, `n-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetAccessPointAwsEgressPrivateLinkEndpointResult(dict):
    def __init__(__self__, *,
                 enable_high_availability: bool,
                 vpc_endpoint_dns_name: str,
                 vpc_endpoint_id: str,
                 vpc_endpoint_service_name: str):
        """
        :param bool enable_high_availability: (Required Boolean) Whether a resource should be provisioned with high availability. Endpoints deployed with high availability have network interfaces deployed in multiple AZs. Defaults to `false`.
        :param str vpc_endpoint_dns_name: (Required String) The DNS name of a VPC Endpoint (if any) that is connected to the VPC Endpoint service, for example, `*.vpce-00000000000000000-abcd1234.s3.us-west-2.vpce.amazonaws.com`.
        :param str vpc_endpoint_id: (Required String) The ID of a VPC Endpoint (if any) that is connected to the VPC Endpoint service, for example, `vpce-00000000000000000`.
        :param str vpc_endpoint_service_name: (Required String) AWS VPC Endpoint Service that can be used to establish connections for all zones, for example `com.amazonaws.vpce.us-west-2.vpce-svc-0d3be37e21708ecd3`.
        """
        pulumi.set(__self__, "enable_high_availability", enable_high_availability)
        pulumi.set(__self__, "vpc_endpoint_dns_name", vpc_endpoint_dns_name)
        pulumi.set(__self__, "vpc_endpoint_id", vpc_endpoint_id)
        pulumi.set(__self__, "vpc_endpoint_service_name", vpc_endpoint_service_name)

    @property
    @pulumi.getter(name="enableHighAvailability")
    def enable_high_availability(self) -> bool:
        """
        (Required Boolean) Whether a resource should be provisioned with high availability. Endpoints deployed with high availability have network interfaces deployed in multiple AZs. Defaults to `false`.
        """
        return pulumi.get(self, "enable_high_availability")

    @property
    @pulumi.getter(name="vpcEndpointDnsName")
    def vpc_endpoint_dns_name(self) -> str:
        """
        (Required String) The DNS name of a VPC Endpoint (if any) that is connected to the VPC Endpoint service, for example, `*.vpce-00000000000000000-abcd1234.s3.us-west-2.vpce.amazonaws.com`.
        """
        return pulumi.get(self, "vpc_endpoint_dns_name")

    @property
    @pulumi.getter(name="vpcEndpointId")
    def vpc_endpoint_id(self) -> str:
        """
        (Required String) The ID of a VPC Endpoint (if any) that is connected to the VPC Endpoint service, for example, `vpce-00000000000000000`.
        """
        return pulumi.get(self, "vpc_endpoint_id")

    @property
    @pulumi.getter(name="vpcEndpointServiceName")
    def vpc_endpoint_service_name(self) -> str:
        """
        (Required String) AWS VPC Endpoint Service that can be used to establish connections for all zones, for example `com.amazonaws.vpce.us-west-2.vpce-svc-0d3be37e21708ecd3`.
        """
        return pulumi.get(self, "vpc_endpoint_service_name")


@pulumi.output_type
class GetAccessPointAwsPrivateNetworkInterfaceResult(dict):
    def __init__(__self__, *,
                 account: str,
                 network_interfaces: Sequence[str]):
        """
        :param str account: (Required String) The AWS account ID associated with the ENIs you are using for the Confluent Private Network Interface, for example: `000000000000`.
        :param Sequence[str] network_interfaces: (Required List of Strings) List of the IDs of the Elastic Network Interfaces, for example: `["eni-00000000000000000", "eni-00000000000000001", "eni-00000000000000002", "eni-00000000000000003", "eni-00000000000000004", "eni-00000000000000005"]`
        """
        pulumi.set(__self__, "account", account)
        pulumi.set(__self__, "network_interfaces", network_interfaces)

    @property
    @pulumi.getter
    def account(self) -> str:
        """
        (Required String) The AWS account ID associated with the ENIs you are using for the Confluent Private Network Interface, for example: `000000000000`.
        """
        return pulumi.get(self, "account")

    @property
    @pulumi.getter(name="networkInterfaces")
    def network_interfaces(self) -> Sequence[str]:
        """
        (Required List of Strings) List of the IDs of the Elastic Network Interfaces, for example: `["eni-00000000000000000", "eni-00000000000000001", "eni-00000000000000002", "eni-00000000000000003", "eni-00000000000000004", "eni-00000000000000005"]`
        """
        return pulumi.get(self, "network_interfaces")


@pulumi.output_type
class GetAccessPointAzureEgressPrivateLinkEndpointResult(dict):
    def __init__(__self__, *,
                 private_endpoint_custom_dns_config_domains: Sequence[str],
                 private_endpoint_domain: str,
                 private_endpoint_ip_address: str,
                 private_endpoint_resource_id: str,
                 private_link_service_resource_id: str,
                 private_link_subresource_name: str):
        """
        :param Sequence[str] private_endpoint_custom_dns_config_domains: (Required List of Strings) Domains of the Private Endpoint (if any) based off FQDNs in Azure custom DNS configs, which are required in your private DNS setup, for example: `["dbname.database.windows.net", "dbname-region.database.windows.net"]`.
        :param str private_endpoint_domain: (Required String) Domain of the Private Endpoint (if any) that is connected to the Private Link service.
        :param str private_endpoint_ip_address: (Required String) IP address of the Private Endpoint (if any) that is connected to the Private Link service.
        :param str private_endpoint_resource_id: (Required String) Resource ID of the Private Endpoint (if any) that is connected to the Private Link service.
        :param str private_link_service_resource_id: (Required String) Resource ID of the Azure Private Link service.
        :param str private_link_subresource_name: (Required String) Name of the subresource for the Private Endpoint to connect to.
        """
        pulumi.set(__self__, "private_endpoint_custom_dns_config_domains", private_endpoint_custom_dns_config_domains)
        pulumi.set(__self__, "private_endpoint_domain", private_endpoint_domain)
        pulumi.set(__self__, "private_endpoint_ip_address", private_endpoint_ip_address)
        pulumi.set(__self__, "private_endpoint_resource_id", private_endpoint_resource_id)
        pulumi.set(__self__, "private_link_service_resource_id", private_link_service_resource_id)
        pulumi.set(__self__, "private_link_subresource_name", private_link_subresource_name)

    @property
    @pulumi.getter(name="privateEndpointCustomDnsConfigDomains")
    def private_endpoint_custom_dns_config_domains(self) -> Sequence[str]:
        """
        (Required List of Strings) Domains of the Private Endpoint (if any) based off FQDNs in Azure custom DNS configs, which are required in your private DNS setup, for example: `["dbname.database.windows.net", "dbname-region.database.windows.net"]`.
        """
        return pulumi.get(self, "private_endpoint_custom_dns_config_domains")

    @property
    @pulumi.getter(name="privateEndpointDomain")
    def private_endpoint_domain(self) -> str:
        """
        (Required String) Domain of the Private Endpoint (if any) that is connected to the Private Link service.
        """
        return pulumi.get(self, "private_endpoint_domain")

    @property
    @pulumi.getter(name="privateEndpointIpAddress")
    def private_endpoint_ip_address(self) -> str:
        """
        (Required String) IP address of the Private Endpoint (if any) that is connected to the Private Link service.
        """
        return pulumi.get(self, "private_endpoint_ip_address")

    @property
    @pulumi.getter(name="privateEndpointResourceId")
    def private_endpoint_resource_id(self) -> str:
        """
        (Required String) Resource ID of the Private Endpoint (if any) that is connected to the Private Link service.
        """
        return pulumi.get(self, "private_endpoint_resource_id")

    @property
    @pulumi.getter(name="privateLinkServiceResourceId")
    def private_link_service_resource_id(self) -> str:
        """
        (Required String) Resource ID of the Azure Private Link service.
        """
        return pulumi.get(self, "private_link_service_resource_id")

    @property
    @pulumi.getter(name="privateLinkSubresourceName")
    def private_link_subresource_name(self) -> str:
        """
        (Required String) Name of the subresource for the Private Endpoint to connect to.
        """
        return pulumi.get(self, "private_link_subresource_name")


@pulumi.output_type
class GetAccessPointEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Access Point belongs to, for example, `env-123abc`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Access Point belongs to, for example, `env-123abc`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetAccessPointGatewayResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Access Point, for example, `ap-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Access Point, for example, `ap-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetAccessPointGcpEgressPrivateServiceConnectEndpointResult(dict):
    def __init__(__self__, *,
                 private_service_connect_endpoint_connection_id: str,
                 private_service_connect_endpoint_ip_address: str,
                 private_service_connect_endpoint_name: str,
                 private_service_connect_endpoint_target: str):
        """
        :param str private_service_connect_endpoint_connection_id: (Required String) Connection ID of the Private Service Connect Endpoint that is connected to the endpoint target.
        :param str private_service_connect_endpoint_ip_address: (Required String) IP address of the Private Service Connect Endpoint that is connected to the endpoint target.
        :param str private_service_connect_endpoint_name: (Required String) Name of the Private Service Connect Endpoint that is connected to the endpoint target.
        :param str private_service_connect_endpoint_target: (Required String) URI of the service attachment for the published service that the Private Service Connect Endpoint connects to, or "all-google-apis" for global Google APIs.
        """
        pulumi.set(__self__, "private_service_connect_endpoint_connection_id", private_service_connect_endpoint_connection_id)
        pulumi.set(__self__, "private_service_connect_endpoint_ip_address", private_service_connect_endpoint_ip_address)
        pulumi.set(__self__, "private_service_connect_endpoint_name", private_service_connect_endpoint_name)
        pulumi.set(__self__, "private_service_connect_endpoint_target", private_service_connect_endpoint_target)

    @property
    @pulumi.getter(name="privateServiceConnectEndpointConnectionId")
    def private_service_connect_endpoint_connection_id(self) -> str:
        """
        (Required String) Connection ID of the Private Service Connect Endpoint that is connected to the endpoint target.
        """
        return pulumi.get(self, "private_service_connect_endpoint_connection_id")

    @property
    @pulumi.getter(name="privateServiceConnectEndpointIpAddress")
    def private_service_connect_endpoint_ip_address(self) -> str:
        """
        (Required String) IP address of the Private Service Connect Endpoint that is connected to the endpoint target.
        """
        return pulumi.get(self, "private_service_connect_endpoint_ip_address")

    @property
    @pulumi.getter(name="privateServiceConnectEndpointName")
    def private_service_connect_endpoint_name(self) -> str:
        """
        (Required String) Name of the Private Service Connect Endpoint that is connected to the endpoint target.
        """
        return pulumi.get(self, "private_service_connect_endpoint_name")

    @property
    @pulumi.getter(name="privateServiceConnectEndpointTarget")
    def private_service_connect_endpoint_target(self) -> str:
        """
        (Required String) URI of the service attachment for the published service that the Private Service Connect Endpoint connects to, or "all-google-apis" for global Google APIs.
        """
        return pulumi.get(self, "private_service_connect_endpoint_target")


@pulumi.output_type
class GetBusinessMetadataAttributeDefinitionResult(dict):
    def __init__(__self__, *,
                 default_value: str,
                 description: str,
                 is_optional: bool,
                 name: str,
                 options: Mapping[str, str],
                 type: str):
        """
        :param str default_value: (Optional String) The default value of this attribute.
        :param str description: (Optional String) The description of this attribute.
        :param bool is_optional: (Optional Boolean) An optional flag to control whether the attribute should be optional or required.
        :param str name: The name of the Business Metadata, for example, `PII`. The name must not be empty and consist of a letter followed by a sequence of letter, number, space, or _ characters.
               
               > **Note:** A Schema Registry API key consists of a key and a secret. Schema Registry API keys are required to interact with Schema Registry clusters in Confluent Cloud. Each Schema Registry API key is valid for one specific Schema Registry cluster.
        :param Mapping[str, str] options: (Optional Map) Block for the attribute options:
               - `applicableEntityTypes` - (Optional String) The entity types that the attribute is applicable, it always returns `[\\"cf_entity\\"]`.
               - `maxStrLength` - (Optional String) The maximum length of the string value, it always returns `5000`.
        :param str type: (Required String) The type of the attribute, it always returns `string`.
        """
        pulumi.set(__self__, "default_value", default_value)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "is_optional", is_optional)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "options", options)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="defaultValue")
    def default_value(self) -> str:
        """
        (Optional String) The default value of this attribute.
        """
        return pulumi.get(self, "default_value")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        (Optional String) The description of this attribute.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="isOptional")
    def is_optional(self) -> bool:
        """
        (Optional Boolean) An optional flag to control whether the attribute should be optional or required.
        """
        return pulumi.get(self, "is_optional")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Business Metadata, for example, `PII`. The name must not be empty and consist of a letter followed by a sequence of letter, number, space, or _ characters.

        > **Note:** A Schema Registry API key consists of a key and a secret. Schema Registry API keys are required to interact with Schema Registry clusters in Confluent Cloud. Each Schema Registry API key is valid for one specific Schema Registry cluster.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, str]:
        """
        (Optional Map) Block for the attribute options:
        - `applicableEntityTypes` - (Optional String) The entity types that the attribute is applicable, it always returns `[\\"cf_entity\\"]`.
        - `maxStrLength` - (Optional String) The maximum length of the string value, it always returns `5000`.
        """
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        (Required String) The type of the attribute, it always returns `string`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetBusinessMetadataBindingCredentialsResult(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
               
               > **Note:** A Schema Registry API key consists of a key and a secret. Schema Registry API keys are required to interact with Schema Registry clusters in Confluent Cloud. Each Schema Registry API key is valid for one specific Schema Registry cluster.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.

        > **Note:** A Schema Registry API key consists of a key and a secret. Schema Registry API keys are required to interact with Schema Registry clusters in Confluent Cloud. Each Schema Registry API key is valid for one specific Schema Registry cluster.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetBusinessMetadataBindingSchemaRegistryClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetBusinessMetadataCredentialsResult(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetBusinessMetadataSchemaRegistryClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetByokKeyAwResult(dict):
    def __init__(__self__, *,
                 key_arn: str,
                 roles: Sequence[str]):
        """
        :param str key_arn: (Required String) The Amazon Resource Name (ARN) of an AWS KMS key.
        :param Sequence[str] roles: (Optional List of Strings) The Amazon Resource Names (ARNs) of IAM Roles created for this key-environment combination.
        """
        pulumi.set(__self__, "key_arn", key_arn)
        pulumi.set(__self__, "roles", roles)

    @property
    @pulumi.getter(name="keyArn")
    def key_arn(self) -> str:
        """
        (Required String) The Amazon Resource Name (ARN) of an AWS KMS key.
        """
        return pulumi.get(self, "key_arn")

    @property
    @pulumi.getter
    def roles(self) -> Sequence[str]:
        """
        (Optional List of Strings) The Amazon Resource Names (ARNs) of IAM Roles created for this key-environment combination.
        """
        return pulumi.get(self, "roles")


@pulumi.output_type
class GetByokKeyAzureResult(dict):
    def __init__(__self__, *,
                 application_id: str,
                 key_identifier: str,
                 key_vault_id: str,
                 tenant_id: str):
        """
        :param str application_id: (Optional String) The Application ID created for this key-environment combination.
        :param str key_identifier: (Required String) The unique Key Object Identifier URL of an Azure Key Vault key.
        :param str key_vault_id: (Required String) Key Vault ID containing the key.
        :param str tenant_id: (Required String) Tenant ID (uuid) hosting the Key Vault containing the key.
        """
        pulumi.set(__self__, "application_id", application_id)
        pulumi.set(__self__, "key_identifier", key_identifier)
        pulumi.set(__self__, "key_vault_id", key_vault_id)
        pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter(name="applicationId")
    def application_id(self) -> str:
        """
        (Optional String) The Application ID created for this key-environment combination.
        """
        return pulumi.get(self, "application_id")

    @property
    @pulumi.getter(name="keyIdentifier")
    def key_identifier(self) -> str:
        """
        (Required String) The unique Key Object Identifier URL of an Azure Key Vault key.
        """
        return pulumi.get(self, "key_identifier")

    @property
    @pulumi.getter(name="keyVaultId")
    def key_vault_id(self) -> str:
        """
        (Required String) Key Vault ID containing the key.
        """
        return pulumi.get(self, "key_vault_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        """
        (Required String) Tenant ID (uuid) hosting the Key Vault containing the key.
        """
        return pulumi.get(self, "tenant_id")


@pulumi.output_type
class GetByokKeyGcpResult(dict):
    def __init__(__self__, *,
                 key_id: str,
                 security_group: str):
        """
        :param str key_id: (Required String) The Google Cloud Platform key ID.
        :param str security_group: (Optional String) The Google security group created for this key.
        """
        pulumi.set(__self__, "key_id", key_id)
        pulumi.set(__self__, "security_group", security_group)

    @property
    @pulumi.getter(name="keyId")
    def key_id(self) -> str:
        """
        (Required String) The Google Cloud Platform key ID.
        """
        return pulumi.get(self, "key_id")

    @property
    @pulumi.getter(name="securityGroup")
    def security_group(self) -> str:
        """
        (Optional String) The Google security group created for this key.
        """
        return pulumi.get(self, "security_group")


@pulumi.output_type
class GetCertificatePoolCertificateAuthorityResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Certificate Authority for this Certificate Pool, for example, `op-123abc`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Certificate Authority for this Certificate Pool, for example, `op-123abc`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetClusterLinkCredentialsResult(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Kafka API Key.
        :param str secret: The Cluster API Secret for your Confluent Cloud cluster.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Kafka API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Cluster API Secret for your Confluent Cloud cluster.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetClusterLinkKafkaClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Kafka cluster to query for the Cluster Link, for example, `lkc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Kafka cluster to query for the Cluster Link, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetDnsRecordEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the DNS Record belongs to, for example, `env-123abc`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the DNS Record belongs to, for example, `env-123abc`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetDnsRecordGatewayResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the DNS Record, for example, `dnsrec-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the DNS Record, for example, `dnsrec-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetDnsRecordPrivateLinkAccessPointResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the DNS Record, for example, `dnsrec-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the DNS Record, for example, `dnsrec-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetEnvironmentStreamGovernanceResult(dict):
    def __init__(__self__, *,
                 package: str):
        """
        :param str package: Stream Governance Package. 'ESSENTIALS' or 'ADVANCED'
        """
        pulumi.set(__self__, "package", package)

    @property
    @pulumi.getter
    def package(self) -> str:
        """
        Stream Governance Package. 'ESSENTIALS' or 'ADVANCED'
        """
        return pulumi.get(self, "package")


@pulumi.output_type
class GetFlinkArtifactEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Flink Artifact belongs to, for example, `env-xyz456`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Flink Artifact belongs to, for example, `env-xyz456`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetFlinkArtifactVersionResult(dict):
    def __init__(__self__, *,
                 version: str):
        """
        :param str version: The version of this Flink Artifact.
        """
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def version(self) -> str:
        """
        The version of this Flink Artifact.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetFlinkComputePoolEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Flink Compute Pool belongs to, for example, `env-xyz456`.
               
               > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Flink Compute Pool belongs to, for example, `env-xyz456`.

        > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetGatewayAwsEgressPrivateLinkGatewayResult(dict):
    def __init__(__self__, *,
                 principal_arn: str,
                 region: str):
        """
        :param str principal_arn: (Required String) The principal ARN used by the AWS Egress Private Link Gateway.
        :param str region: (Required String) GCP region of the Peering Gateway.
        """
        pulumi.set(__self__, "principal_arn", principal_arn)
        pulumi.set(__self__, "region", region)

    @property
    @pulumi.getter(name="principalArn")
    def principal_arn(self) -> str:
        """
        (Required String) The principal ARN used by the AWS Egress Private Link Gateway.
        """
        return pulumi.get(self, "principal_arn")

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        (Required String) GCP region of the Peering Gateway.
        """
        return pulumi.get(self, "region")


@pulumi.output_type
class GetGatewayAwsPeeringGatewayResult(dict):
    def __init__(__self__, *,
                 region: str):
        """
        :param str region: (Required String) GCP region of the Peering Gateway.
        """
        pulumi.set(__self__, "region", region)

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        (Required String) GCP region of the Peering Gateway.
        """
        return pulumi.get(self, "region")


@pulumi.output_type
class GetGatewayAwsPrivateNetworkInterfaceGatewayResult(dict):
    def __init__(__self__, *,
                 account: str,
                 region: str,
                 zones: Sequence[str]):
        """
        :param str account: (Required String) The AWS account ID associated with the Private Network Interface Gateway.
        :param str region: (Required String) GCP region of the Peering Gateway.
        :param Sequence[str] zones: (Required List of Strings) AWS availability zone ids of the Private Network Interface Gateway.
        """
        pulumi.set(__self__, "account", account)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "zones", zones)

    @property
    @pulumi.getter
    def account(self) -> str:
        """
        (Required String) The AWS account ID associated with the Private Network Interface Gateway.
        """
        return pulumi.get(self, "account")

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        (Required String) GCP region of the Peering Gateway.
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def zones(self) -> Sequence[str]:
        """
        (Required List of Strings) AWS availability zone ids of the Private Network Interface Gateway.
        """
        return pulumi.get(self, "zones")


@pulumi.output_type
class GetGatewayAzureEgressPrivateLinkGatewayResult(dict):
    def __init__(__self__, *,
                 region: str,
                 subscription: str):
        """
        :param str region: (Required String) GCP region of the Peering Gateway.
        :param str subscription: (Required String) The Azure Subscription ID associated with the Confluent Cloud VPC.
        """
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "subscription", subscription)

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        (Required String) GCP region of the Peering Gateway.
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def subscription(self) -> str:
        """
        (Required String) The Azure Subscription ID associated with the Confluent Cloud VPC.
        """
        return pulumi.get(self, "subscription")


@pulumi.output_type
class GetGatewayAzurePeeringGatewayResult(dict):
    def __init__(__self__, *,
                 region: str):
        """
        :param str region: (Required String) GCP region of the Peering Gateway.
        """
        pulumi.set(__self__, "region", region)

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        (Required String) GCP region of the Peering Gateway.
        """
        return pulumi.get(self, "region")


@pulumi.output_type
class GetGatewayEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Gateway belongs to, for example, `env-123abc`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Gateway belongs to, for example, `env-123abc`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetGatewayGcpEgressPrivateServiceConnectGatewayResult(dict):
    def __init__(__self__, *,
                 project: str,
                 region: str):
        """
        :param str project: (Required String) The GCP project used by the GCP Private Service Connect Gateway.
        :param str region: (Required String) GCP region of the Peering Gateway.
        """
        pulumi.set(__self__, "project", project)
        pulumi.set(__self__, "region", region)

    @property
    @pulumi.getter
    def project(self) -> str:
        """
        (Required String) The GCP project used by the GCP Private Service Connect Gateway.
        """
        return pulumi.get(self, "project")

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        (Required String) GCP region of the Peering Gateway.
        """
        return pulumi.get(self, "region")


@pulumi.output_type
class GetGatewayGcpPeeringGatewayResult(dict):
    def __init__(__self__, *,
                 iam_principal: str,
                 region: str):
        """
        :param str iam_principal: (Required String) The IAM principal used by the GCP Peering Gateway.
        :param str region: (Required String) GCP region of the Peering Gateway.
        """
        pulumi.set(__self__, "iam_principal", iam_principal)
        pulumi.set(__self__, "region", region)

    @property
    @pulumi.getter(name="iamPrincipal")
    def iam_principal(self) -> str:
        """
        (Required String) The IAM principal used by the GCP Peering Gateway.
        """
        return pulumi.get(self, "iam_principal")

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        (Required String) GCP region of the Peering Gateway.
        """
        return pulumi.get(self, "region")


@pulumi.output_type
class GetIdentityPoolIdentityProviderResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Identity Provider associated with the Identity Pool, for example, `op-abc123`.
               
               > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Identity Provider associated with the Identity Pool, for example, `op-abc123`.

        > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetInvitationCreatorResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Invitation, for example, `i-zyw30`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Invitation, for example, `i-zyw30`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetInvitationUserResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Invitation, for example, `i-zyw30`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Invitation, for example, `i-zyw30`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetIpAddressesFilterResult(dict):
    def __init__(__self__, *,
                 address_types: Optional[Sequence[str]] = None,
                 clouds: Optional[Sequence[str]] = None,
                 regions: Optional[Sequence[str]] = None,
                 services: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] address_types: A list of address types to filter by. Accepted values are: `EGRESS`, `INGRESS`.
        :param Sequence[str] clouds: A list of clouds to filter by. Accepted values are: `AWS`, `AZURE`, and `GCP`.
        :param Sequence[str] regions: A list of regions to filter by.
        :param Sequence[str] services: A list of services to filter by. Accepted values are: `CONNECT`, `KAFKA`.
        """
        if address_types is not None:
            pulumi.set(__self__, "address_types", address_types)
        if clouds is not None:
            pulumi.set(__self__, "clouds", clouds)
        if regions is not None:
            pulumi.set(__self__, "regions", regions)
        if services is not None:
            pulumi.set(__self__, "services", services)

    @property
    @pulumi.getter(name="addressTypes")
    def address_types(self) -> Optional[Sequence[str]]:
        """
        A list of address types to filter by. Accepted values are: `EGRESS`, `INGRESS`.
        """
        return pulumi.get(self, "address_types")

    @property
    @pulumi.getter
    def clouds(self) -> Optional[Sequence[str]]:
        """
        A list of clouds to filter by. Accepted values are: `AWS`, `AZURE`, and `GCP`.
        """
        return pulumi.get(self, "clouds")

    @property
    @pulumi.getter
    def regions(self) -> Optional[Sequence[str]]:
        """
        A list of regions to filter by.
        """
        return pulumi.get(self, "regions")

    @property
    @pulumi.getter
    def services(self) -> Optional[Sequence[str]]:
        """
        A list of services to filter by. Accepted values are: `CONNECT`, `KAFKA`.
        """
        return pulumi.get(self, "services")


@pulumi.output_type
class GetIpAddressesIpAddressResult(dict):
    def __init__(__self__, *,
                 address_type: str,
                 api_version: str,
                 cloud: str,
                 ip_prefix: str,
                 kind: str,
                 region: str,
                 services: Sequence[str]):
        """
        :param str address_type: (Required Integer) Whether the address is used for egress or ingress.
        :param str api_version: (Required String) An API Version of the schema version of the IP Address, for example, `networking/v1`.
        :param str cloud: (Required String) The cloud service provider in which the address exists.
        :param str ip_prefix: (Required String) The IP Address range.
        :param str kind: (Required String) A kind of the Kafka cluster, for example, `IpAddress`.
        :param str region: (Required Integer) The region/location where the IP Address is in use.
        :param Sequence[str] services: (Required List of Strings) The service types that will use the address.
        """
        pulumi.set(__self__, "address_type", address_type)
        pulumi.set(__self__, "api_version", api_version)
        pulumi.set(__self__, "cloud", cloud)
        pulumi.set(__self__, "ip_prefix", ip_prefix)
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "services", services)

    @property
    @pulumi.getter(name="addressType")
    def address_type(self) -> str:
        """
        (Required Integer) Whether the address is used for egress or ingress.
        """
        return pulumi.get(self, "address_type")

    @property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> str:
        """
        (Required String) An API Version of the schema version of the IP Address, for example, `networking/v1`.
        """
        return pulumi.get(self, "api_version")

    @property
    @pulumi.getter
    def cloud(self) -> str:
        """
        (Required String) The cloud service provider in which the address exists.
        """
        return pulumi.get(self, "cloud")

    @property
    @pulumi.getter(name="ipPrefix")
    def ip_prefix(self) -> str:
        """
        (Required String) The IP Address range.
        """
        return pulumi.get(self, "ip_prefix")

    @property
    @pulumi.getter
    def kind(self) -> str:
        """
        (Required String) A kind of the Kafka cluster, for example, `IpAddress`.
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        (Required Integer) The region/location where the IP Address is in use.
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def services(self) -> Sequence[str]:
        """
        (Required List of Strings) The service types that will use the address.
        """
        return pulumi.get(self, "services")


@pulumi.output_type
class GetKafkaClientQuotaEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Kafka Client Quota (for example, `cq-abc123`).
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Kafka Client Quota (for example, `cq-abc123`).
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetKafkaClientQuotaKafkaClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Kafka Client Quota (for example, `cq-abc123`).
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Kafka Client Quota (for example, `cq-abc123`).
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetKafkaClientQuotaThroughputResult(dict):
    def __init__(__self__, *,
                 egress_byte_rate: str,
                 ingress_byte_rate: str):
        """
        :param str egress_byte_rate: (Required String) The egress throughput limit in bytes per second.
        :param str ingress_byte_rate: (Required String) The ingress throughput limit in bytes per second.
        """
        pulumi.set(__self__, "egress_byte_rate", egress_byte_rate)
        pulumi.set(__self__, "ingress_byte_rate", ingress_byte_rate)

    @property
    @pulumi.getter(name="egressByteRate")
    def egress_byte_rate(self) -> str:
        """
        (Required String) The egress throughput limit in bytes per second.
        """
        return pulumi.get(self, "egress_byte_rate")

    @property
    @pulumi.getter(name="ingressByteRate")
    def ingress_byte_rate(self) -> str:
        """
        (Required String) The ingress throughput limit in bytes per second.
        """
        return pulumi.get(self, "ingress_byte_rate")


@pulumi.output_type
class GetKafkaClusterBasicResult(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class GetKafkaClusterByokKeyResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Kafka cluster, for example, `lkc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetKafkaClusterDedicatedResult(dict):
    def __init__(__self__, *,
                 cku: int,
                 encryption_key: str,
                 zones: Sequence[str]):
        """
        :param int cku: (Required Number) The number of Confluent Kafka Units (CKUs) for Dedicated cluster types. The minimum number of CKUs for `SINGLE_ZONE` dedicated clusters is `1` whereas `MULTI_ZONE` dedicated clusters must have `2` CKUs or more.
        :param str encryption_key: The ID of the encryption key that is used to encrypt the data in the Kafka cluster.
        :param Sequence[str] zones: (Required List of String) The list of zones the cluster is in.
               - On AWS, zones are AWS [AZ IDs](https://docs.aws.amazon.com/ram/latest/userguide/working-with-az-ids.html), for example, `use1-az3`.
               - On GCP, zones are GCP [zones](https://cloud.google.com/compute/docs/regions-zones), for example, `us-central1-c`.
               - On Azure, zones are Confluent-chosen names (for example, `1`, `2`, `3`) since Azure does not have universal zone identifiers.
        """
        pulumi.set(__self__, "cku", cku)
        pulumi.set(__self__, "encryption_key", encryption_key)
        pulumi.set(__self__, "zones", zones)

    @property
    @pulumi.getter
    def cku(self) -> int:
        """
        (Required Number) The number of Confluent Kafka Units (CKUs) for Dedicated cluster types. The minimum number of CKUs for `SINGLE_ZONE` dedicated clusters is `1` whereas `MULTI_ZONE` dedicated clusters must have `2` CKUs or more.
        """
        return pulumi.get(self, "cku")

    @property
    @pulumi.getter(name="encryptionKey")
    def encryption_key(self) -> str:
        """
        The ID of the encryption key that is used to encrypt the data in the Kafka cluster.
        """
        return pulumi.get(self, "encryption_key")

    @property
    @pulumi.getter
    def zones(self) -> Sequence[str]:
        """
        (Required List of String) The list of zones the cluster is in.
        - On AWS, zones are AWS [AZ IDs](https://docs.aws.amazon.com/ram/latest/userguide/working-with-az-ids.html), for example, `use1-az3`.
        - On GCP, zones are GCP [zones](https://cloud.google.com/compute/docs/regions-zones), for example, `us-central1-c`.
        - On Azure, zones are Confluent-chosen names (for example, `1`, `2`, `3`) since Azure does not have universal zone identifiers.
        """
        return pulumi.get(self, "zones")


@pulumi.output_type
class GetKafkaClusterEnterpriseResult(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class GetKafkaClusterEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Kafka cluster belongs to, for example, `env-xyz456`.
               
               > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Kafka cluster belongs to, for example, `env-xyz456`.

        > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetKafkaClusterFreightResult(dict):
    def __init__(__self__, *,
                 zones: Sequence[str]):
        """
        :param Sequence[str] zones: (Required List of String) The list of zones the cluster is in.
               - On AWS, zones are AWS [AZ IDs](https://docs.aws.amazon.com/ram/latest/userguide/working-with-az-ids.html), for example, `use1-az3`.
               - On GCP, zones are GCP [zones](https://cloud.google.com/compute/docs/regions-zones), for example, `us-central1-c`.
               - On Azure, zones are Confluent-chosen names (for example, `1`, `2`, `3`) since Azure does not have universal zone identifiers.
        """
        pulumi.set(__self__, "zones", zones)

    @property
    @pulumi.getter
    def zones(self) -> Sequence[str]:
        """
        (Required List of String) The list of zones the cluster is in.
        - On AWS, zones are AWS [AZ IDs](https://docs.aws.amazon.com/ram/latest/userguide/working-with-az-ids.html), for example, `use1-az3`.
        - On GCP, zones are GCP [zones](https://cloud.google.com/compute/docs/regions-zones), for example, `us-central1-c`.
        - On Azure, zones are Confluent-chosen names (for example, `1`, `2`, `3`) since Azure does not have universal zone identifiers.
        """
        return pulumi.get(self, "zones")


@pulumi.output_type
class GetKafkaClusterNetworkResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Kafka cluster, for example, `lkc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetKafkaClusterStandardResult(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class GetKafkaTopicCredentialsResult(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Kafka API Key.
        :param str secret: The Cluster API Secret for your Confluent Cloud cluster.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Kafka API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Cluster API Secret for your Confluent Cloud cluster.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetKafkaTopicKafkaClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Kafka cluster, for example, `lkc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetKsqlClusterCredentialIdentityResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the ksqlDB cluster, for example, `lksqlc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the ksqlDB cluster, for example, `lksqlc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetKsqlClusterEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the ksqlDB cluster belongs to, for example, `env-xyz456`.
               
               > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the ksqlDB cluster belongs to, for example, `env-xyz456`.

        > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetKsqlClusterKafkaClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the ksqlDB cluster, for example, `lksqlc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the ksqlDB cluster, for example, `lksqlc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetNetworkAwResult(dict):
    def __init__(__self__, *,
                 account: str,
                 private_link_endpoint_service: str,
                 vpc: str):
        """
        :param str account: (Required String) The AWS account ID associated with the Confluent Cloud VPC.
        :param str private_link_endpoint_service: (Optional String) The endpoint service of the Confluent Cloud VPC (used for PrivateLink) if available.
        :param str vpc: (Required String) The Confluent Cloud VPC ID.
        """
        pulumi.set(__self__, "account", account)
        pulumi.set(__self__, "private_link_endpoint_service", private_link_endpoint_service)
        pulumi.set(__self__, "vpc", vpc)

    @property
    @pulumi.getter
    def account(self) -> str:
        """
        (Required String) The AWS account ID associated with the Confluent Cloud VPC.
        """
        return pulumi.get(self, "account")

    @property
    @pulumi.getter(name="privateLinkEndpointService")
    def private_link_endpoint_service(self) -> str:
        """
        (Optional String) The endpoint service of the Confluent Cloud VPC (used for PrivateLink) if available.
        """
        return pulumi.get(self, "private_link_endpoint_service")

    @property
    @pulumi.getter
    def vpc(self) -> str:
        """
        (Required String) The Confluent Cloud VPC ID.
        """
        return pulumi.get(self, "vpc")


@pulumi.output_type
class GetNetworkAzureResult(dict):
    def __init__(__self__, *,
                 private_link_service_aliases: Mapping[str, str]):
        """
        :param Mapping[str, str] private_link_service_aliases: (Optional Map) The mapping of zones to Private Link Service Aliases if available. Keys are zones and values are [Azure Private Link Service Aliases](https://docs.microsoft.com/en-us/azure/private-link/private-link-service-overview#share-your-service).
        """
        pulumi.set(__self__, "private_link_service_aliases", private_link_service_aliases)

    @property
    @pulumi.getter(name="privateLinkServiceAliases")
    def private_link_service_aliases(self) -> Mapping[str, str]:
        """
        (Optional Map) The mapping of zones to Private Link Service Aliases if available. Keys are zones and values are [Azure Private Link Service Aliases](https://docs.microsoft.com/en-us/azure/private-link/private-link-service-overview#share-your-service).
        """
        return pulumi.get(self, "private_link_service_aliases")


@pulumi.output_type
class GetNetworkDnsConfigResult(dict):
    def __init__(__self__, *,
                 resolution: str):
        """
        :param str resolution: (Required String) Network DNS resolution.
               When resolution is `CHASED_PRIVATE`, clusters in this network require both public and private DNS to resolve cluster endpoints.
               When resolution is `PRIVATE`, clusters in this network only require private DNS to resolve cluster endpoints.
        """
        pulumi.set(__self__, "resolution", resolution)

    @property
    @pulumi.getter
    def resolution(self) -> str:
        """
        (Required String) Network DNS resolution.
        When resolution is `CHASED_PRIVATE`, clusters in this network require both public and private DNS to resolve cluster endpoints.
        When resolution is `PRIVATE`, clusters in this network only require private DNS to resolve cluster endpoints.
        """
        return pulumi.get(self, "resolution")


@pulumi.output_type
class GetNetworkEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Network belongs to, for example, `env-xyz456`.
               
               > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Network belongs to, for example, `env-xyz456`.

        > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetNetworkGatewayResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Network, for example, `n-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Network, for example, `n-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetNetworkGcpResult(dict):
    def __init__(__self__, *,
                 private_service_connect_service_attachments: Mapping[str, str],
                 project: str,
                 vpc_network: str):
        """
        :param Mapping[str, str] private_service_connect_service_attachments: (Optional Map) The mapping of zones to Private Service Connect Service Attachments if available. Keys are zones and values are [GCP Private Service Connect service attachment](https://cloud.google.com/vpc/docs/configure-private-service-connect-producer#api_7).
        :param str project: (Required String) The GCP Project ID associated with the Confluent Cloud VPC.
        :param str vpc_network: (Required String) The network name of the Confluent Cloud VPC.
        """
        pulumi.set(__self__, "private_service_connect_service_attachments", private_service_connect_service_attachments)
        pulumi.set(__self__, "project", project)
        pulumi.set(__self__, "vpc_network", vpc_network)

    @property
    @pulumi.getter(name="privateServiceConnectServiceAttachments")
    def private_service_connect_service_attachments(self) -> Mapping[str, str]:
        """
        (Optional Map) The mapping of zones to Private Service Connect Service Attachments if available. Keys are zones and values are [GCP Private Service Connect service attachment](https://cloud.google.com/vpc/docs/configure-private-service-connect-producer#api_7).
        """
        return pulumi.get(self, "private_service_connect_service_attachments")

    @property
    @pulumi.getter
    def project(self) -> str:
        """
        (Required String) The GCP Project ID associated with the Confluent Cloud VPC.
        """
        return pulumi.get(self, "project")

    @property
    @pulumi.getter(name="vpcNetwork")
    def vpc_network(self) -> str:
        """
        (Required String) The network name of the Confluent Cloud VPC.
        """
        return pulumi.get(self, "vpc_network")


@pulumi.output_type
class GetNetworkLinkEndpointEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Network Link Endpoint belongs to, for example, `env-xyz456`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Network Link Endpoint belongs to, for example, `env-xyz456`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetNetworkLinkEndpointNetworkResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Network Link Endpoint, for example, `nle-zyw30`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Network Link Endpoint, for example, `nle-zyw30`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetNetworkLinkEndpointNetworkLinkServiceResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Network Link Endpoint, for example, `nle-zyw30`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Network Link Endpoint, for example, `nle-zyw30`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetNetworkLinkServiceAcceptResult(dict):
    def __init__(__self__, *,
                 environments: Sequence[str],
                 networks: Sequence[str]):
        """
        :param Sequence[str] environments: (Optional List of Strings) List of environments ids from which connections can be accepted. All networks within the list of environment will be allowed.
        :param Sequence[str] networks: (Optional List of Strings) List of network ids from which connections can be accepted.
        """
        pulumi.set(__self__, "environments", environments)
        pulumi.set(__self__, "networks", networks)

    @property
    @pulumi.getter
    def environments(self) -> Sequence[str]:
        """
        (Optional List of Strings) List of environments ids from which connections can be accepted. All networks within the list of environment will be allowed.
        """
        return pulumi.get(self, "environments")

    @property
    @pulumi.getter
    def networks(self) -> Sequence[str]:
        """
        (Optional List of Strings) List of network ids from which connections can be accepted.
        """
        return pulumi.get(self, "networks")


@pulumi.output_type
class GetNetworkLinkServiceEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Network Link Service belongs to, for example, `env-1234`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Network Link Service belongs to, for example, `env-1234`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetNetworkLinkServiceNetworkResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Network Link Service, for example, `nls-zyw30`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Network Link Service, for example, `nls-zyw30`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetNetworkZoneInfoResult(dict):
    def __init__(__self__, *,
                 cidr: str,
                 zone_id: str):
        """
        :param str cidr: (Required String) The IPv4 CIDR block to be used for the network. Must be `/27`. Required for VPC peering and AWS TransitGateway.
        :param str zone_id: (Required String) Cloud provider zone ID.
        """
        pulumi.set(__self__, "cidr", cidr)
        pulumi.set(__self__, "zone_id", zone_id)

    @property
    @pulumi.getter
    def cidr(self) -> str:
        """
        (Required String) The IPv4 CIDR block to be used for the network. Must be `/27`. Required for VPC peering and AWS TransitGateway.
        """
        return pulumi.get(self, "cidr")

    @property
    @pulumi.getter(name="zoneId")
    def zone_id(self) -> str:
        """
        (Required String) Cloud provider zone ID.
        """
        return pulumi.get(self, "zone_id")


@pulumi.output_type
class GetPeeringAwResult(dict):
    def __init__(__self__, *,
                 account: str,
                 customer_region: str,
                 routes: Sequence[str],
                 vpc: str):
        """
        :param str account: (Required String) The AWS Account ID of the peer VPC owner. You can find your AWS Account ID [here](https://console.aws.amazon.com/billing/home?#/account) under **My Account** section of the AWS Management Console. Must be a **12 character string**.
        :param str customer_region: (Required String) The region of the Azure peer VNet.
        :param Sequence[str] routes: (Required String) The AWS VPC CIDR blocks or subsets. This must be from the supported CIDR blocks and must not overlap with your Confluent Cloud CIDR block or any other network peering connection VPC CIDR (learn more about the requirements [here](https://docs.confluent.io/cloud/current/networking/peering/aws-peering.html#vpc-peering-on-aws)). You can find AWS VPC CIDR [here](https://console.aws.amazon.com/vpc/) under **Your VPCs > Target VPC > Details** section of the AWS Management Console.
        :param str vpc: (Required String) The AWS VPC ID of the peer VPC that you're peering with Confluent Cloud. You can find your AWS VPC ID [here](https://console.aws.amazon.com/vpc/) under **Your VPCs** section of the AWS Management Console. Must start with `vpc-`.
        """
        pulumi.set(__self__, "account", account)
        pulumi.set(__self__, "customer_region", customer_region)
        pulumi.set(__self__, "routes", routes)
        pulumi.set(__self__, "vpc", vpc)

    @property
    @pulumi.getter
    def account(self) -> str:
        """
        (Required String) The AWS Account ID of the peer VPC owner. You can find your AWS Account ID [here](https://console.aws.amazon.com/billing/home?#/account) under **My Account** section of the AWS Management Console. Must be a **12 character string**.
        """
        return pulumi.get(self, "account")

    @property
    @pulumi.getter(name="customerRegion")
    def customer_region(self) -> str:
        """
        (Required String) The region of the Azure peer VNet.
        """
        return pulumi.get(self, "customer_region")

    @property
    @pulumi.getter
    def routes(self) -> Sequence[str]:
        """
        (Required String) The AWS VPC CIDR blocks or subsets. This must be from the supported CIDR blocks and must not overlap with your Confluent Cloud CIDR block or any other network peering connection VPC CIDR (learn more about the requirements [here](https://docs.confluent.io/cloud/current/networking/peering/aws-peering.html#vpc-peering-on-aws)). You can find AWS VPC CIDR [here](https://console.aws.amazon.com/vpc/) under **Your VPCs > Target VPC > Details** section of the AWS Management Console.
        """
        return pulumi.get(self, "routes")

    @property
    @pulumi.getter
    def vpc(self) -> str:
        """
        (Required String) The AWS VPC ID of the peer VPC that you're peering with Confluent Cloud. You can find your AWS VPC ID [here](https://console.aws.amazon.com/vpc/) under **Your VPCs** section of the AWS Management Console. Must start with `vpc-`.
        """
        return pulumi.get(self, "vpc")


@pulumi.output_type
class GetPeeringAzureResult(dict):
    def __init__(__self__, *,
                 customer_region: str,
                 tenant: str,
                 vnet: str):
        """
        :param str customer_region: (Required String) The region of the Azure peer VNet.
        :param str tenant: (Required String) The Tenant ID that represents an organization in Azure Active Directory. You can find your Azure Tenant ID in the [Azure Portal under Azure Active Directory](https://portal.azure.com/#blade/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/Overview). Must be a valid **32 character UUID string**.
        :param str vnet: (Required String) The resource (composite) ID of the peer Virtual Network that you're peering with Confluent Cloud, in the format `/subscriptions/<Subscription ID>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/virtualNetworks/<VNet name>`. You can find Subscription ID, Resource Group Name and your VNet name under **Virtual Networks > Target VNet > Essentials** section of your [Microsoft Azure Portal](https://portal.azure.com/).
        """
        pulumi.set(__self__, "customer_region", customer_region)
        pulumi.set(__self__, "tenant", tenant)
        pulumi.set(__self__, "vnet", vnet)

    @property
    @pulumi.getter(name="customerRegion")
    def customer_region(self) -> str:
        """
        (Required String) The region of the Azure peer VNet.
        """
        return pulumi.get(self, "customer_region")

    @property
    @pulumi.getter
    def tenant(self) -> str:
        """
        (Required String) The Tenant ID that represents an organization in Azure Active Directory. You can find your Azure Tenant ID in the [Azure Portal under Azure Active Directory](https://portal.azure.com/#blade/Microsoft_AAD_IAM/ActiveDirectoryMenuBlade/Overview). Must be a valid **32 character UUID string**.
        """
        return pulumi.get(self, "tenant")

    @property
    @pulumi.getter
    def vnet(self) -> str:
        """
        (Required String) The resource (composite) ID of the peer Virtual Network that you're peering with Confluent Cloud, in the format `/subscriptions/<Subscription ID>/resourceGroups/<Resource Group Name>/providers/Microsoft.Network/virtualNetworks/<VNet name>`. You can find Subscription ID, Resource Group Name and your VNet name under **Virtual Networks > Target VNet > Essentials** section of your [Microsoft Azure Portal](https://portal.azure.com/).
        """
        return pulumi.get(self, "vnet")


@pulumi.output_type
class GetPeeringEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Peering belongs to, for example, `env-xyz456`.
               
               > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Peering belongs to, for example, `env-xyz456`.

        > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetPeeringGcpResult(dict):
    def __init__(__self__, *,
                 import_custom_routes: bool,
                 project: str,
                 vpc_network: str):
        """
        :param bool import_custom_routes: (Optional Boolean) The Import Custom Routes option enables connectivity to a Confluent Cloud cluster in Google Cloud from customer premise or other clouds, such as AWS and Azure, through a customer VPC that is peered with Confluent Cloud in the same region. Defaults to `false`. Learn more about considerations / limitations of the Import Custom Routes option [here](https://docs.confluent.io/cloud/current/networking/peering/gcp-peering.html#import-custom-routes).
        :param str project: (Required String) The GCP Project ID. You can find your Google Cloud Project ID under **Project ID** section of your [Google Cloud Console dashboard](https://console.cloud.google.com/home/dashboard).
        :param str vpc_network: (Required String) The VPC network name that you're peering to Confluent Cloud. You can find your VPC network name under **VPC Networks** section of your [Google Cloud Console](https://console.cloud.google.com/networking/networks/list).
        """
        pulumi.set(__self__, "import_custom_routes", import_custom_routes)
        pulumi.set(__self__, "project", project)
        pulumi.set(__self__, "vpc_network", vpc_network)

    @property
    @pulumi.getter(name="importCustomRoutes")
    def import_custom_routes(self) -> bool:
        """
        (Optional Boolean) The Import Custom Routes option enables connectivity to a Confluent Cloud cluster in Google Cloud from customer premise or other clouds, such as AWS and Azure, through a customer VPC that is peered with Confluent Cloud in the same region. Defaults to `false`. Learn more about considerations / limitations of the Import Custom Routes option [here](https://docs.confluent.io/cloud/current/networking/peering/gcp-peering.html#import-custom-routes).
        """
        return pulumi.get(self, "import_custom_routes")

    @property
    @pulumi.getter
    def project(self) -> str:
        """
        (Required String) The GCP Project ID. You can find your Google Cloud Project ID under **Project ID** section of your [Google Cloud Console dashboard](https://console.cloud.google.com/home/dashboard).
        """
        return pulumi.get(self, "project")

    @property
    @pulumi.getter(name="vpcNetwork")
    def vpc_network(self) -> str:
        """
        (Required String) The VPC network name that you're peering to Confluent Cloud. You can find your VPC network name under **VPC Networks** section of your [Google Cloud Console](https://console.cloud.google.com/networking/networks/list).
        """
        return pulumi.get(self, "vpc_network")


@pulumi.output_type
class GetPeeringNetworkResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Peering, for example, `peer-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Peering, for example, `peer-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetPrivateLinkAccessAwResult(dict):
    def __init__(__self__, *,
                 account: str):
        """
        :param str account: (Required String) The AWS account ID to enable for the Private Link Access. You can find your AWS account ID [here](https://console.aws.amazon.com/billing/home?#/account) under **My Account** in your AWS Management Console. Must be a **12 character string**.
        """
        pulumi.set(__self__, "account", account)

    @property
    @pulumi.getter
    def account(self) -> str:
        """
        (Required String) The AWS account ID to enable for the Private Link Access. You can find your AWS account ID [here](https://console.aws.amazon.com/billing/home?#/account) under **My Account** in your AWS Management Console. Must be a **12 character string**.
        """
        return pulumi.get(self, "account")


@pulumi.output_type
class GetPrivateLinkAccessAzureResult(dict):
    def __init__(__self__, *,
                 subscription: str):
        """
        :param str subscription: (Required String) The Azure subscription ID to enable for the Private Link Access. You can find your Azure subscription ID in the subscription section of your [Microsoft Azure Portal](https://portal.azure.com/#blade/Microsoft_Azure_Billing/SubscriptionsBlade). Must be a valid **32 character UUID string**.
        """
        pulumi.set(__self__, "subscription", subscription)

    @property
    @pulumi.getter
    def subscription(self) -> str:
        """
        (Required String) The Azure subscription ID to enable for the Private Link Access. You can find your Azure subscription ID in the subscription section of your [Microsoft Azure Portal](https://portal.azure.com/#blade/Microsoft_Azure_Billing/SubscriptionsBlade). Must be a valid **32 character UUID string**.
        """
        return pulumi.get(self, "subscription")


@pulumi.output_type
class GetPrivateLinkAccessEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Private Link Access belongs to, for example, `env-xyz456`.
               
               > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Private Link Access belongs to, for example, `env-xyz456`.

        > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetPrivateLinkAccessGcpResult(dict):
    def __init__(__self__, *,
                 project: str):
        """
        :param str project: (Required String) The GCP project ID to allow for Private Service Connect access. You can find your Google Cloud Project ID under **Project ID** section of your [Google Cloud Console dashboard](https://console.cloud.google.com/home/dashboard).
        """
        pulumi.set(__self__, "project", project)

    @property
    @pulumi.getter
    def project(self) -> str:
        """
        (Required String) The GCP project ID to allow for Private Service Connect access. You can find your Google Cloud Project ID under **Project ID** section of your [Google Cloud Console dashboard](https://console.cloud.google.com/home/dashboard).
        """
        return pulumi.get(self, "project")


@pulumi.output_type
class GetPrivateLinkAccessNetworkResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Private Link Access, for example, `pla-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Private Link Access, for example, `pla-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetPrivateLinkAttachmentAwResult(dict):
    def __init__(__self__, *,
                 vpc_endpoint_service_name: str):
        """
        :param str vpc_endpoint_service_name: (Required String) AWS VPC Endpoint Service that can be used to establish connections for all zones, for example `com.amazonaws.vpce.us-west-2.vpce-svc-0d3be37e21708ecd3`.
        """
        pulumi.set(__self__, "vpc_endpoint_service_name", vpc_endpoint_service_name)

    @property
    @pulumi.getter(name="vpcEndpointServiceName")
    def vpc_endpoint_service_name(self) -> str:
        """
        (Required String) AWS VPC Endpoint Service that can be used to establish connections for all zones, for example `com.amazonaws.vpce.us-west-2.vpce-svc-0d3be37e21708ecd3`.
        """
        return pulumi.get(self, "vpc_endpoint_service_name")


@pulumi.output_type
class GetPrivateLinkAttachmentAzureResult(dict):
    def __init__(__self__, *,
                 private_link_service_alias: str,
                 private_link_service_resource_id: str):
        """
        :param str private_link_service_alias: Azure PrivateLink service alias for the availability zone.
        :param str private_link_service_resource_id: (Required String) Azure Private Link service resource id for the availability zone.
        """
        pulumi.set(__self__, "private_link_service_alias", private_link_service_alias)
        pulumi.set(__self__, "private_link_service_resource_id", private_link_service_resource_id)

    @property
    @pulumi.getter(name="privateLinkServiceAlias")
    def private_link_service_alias(self) -> str:
        """
        Azure PrivateLink service alias for the availability zone.
        """
        return pulumi.get(self, "private_link_service_alias")

    @property
    @pulumi.getter(name="privateLinkServiceResourceId")
    def private_link_service_resource_id(self) -> str:
        """
        (Required String) Azure Private Link service resource id for the availability zone.
        """
        return pulumi.get(self, "private_link_service_resource_id")


@pulumi.output_type
class GetPrivateLinkAttachmentConnectionAwResult(dict):
    def __init__(__self__, *,
                 vpc_endpoint_id: str):
        """
        :param str vpc_endpoint_id: (Required String) Id of a VPC Endpoint that is connected to the VPC Endpoint service.
        """
        pulumi.set(__self__, "vpc_endpoint_id", vpc_endpoint_id)

    @property
    @pulumi.getter(name="vpcEndpointId")
    def vpc_endpoint_id(self) -> str:
        """
        (Required String) Id of a VPC Endpoint that is connected to the VPC Endpoint service.
        """
        return pulumi.get(self, "vpc_endpoint_id")


@pulumi.output_type
class GetPrivateLinkAttachmentConnectionAzureResult(dict):
    def __init__(__self__, *,
                 private_endpoint_resource_id: str):
        """
        :param str private_endpoint_resource_id: (Required String) Resource ID of the Private Endpoint that is connected to the Private Link service.
        """
        pulumi.set(__self__, "private_endpoint_resource_id", private_endpoint_resource_id)

    @property
    @pulumi.getter(name="privateEndpointResourceId")
    def private_endpoint_resource_id(self) -> str:
        """
        (Required String) Resource ID of the Private Endpoint that is connected to the Private Link service.
        """
        return pulumi.get(self, "private_endpoint_resource_id")


@pulumi.output_type
class GetPrivateLinkAttachmentConnectionEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Private Link Attachment Connection belongs to, for example `env-xyz456`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Private Link Attachment Connection belongs to, for example `env-xyz456`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetPrivateLinkAttachmentConnectionGcpResult(dict):
    def __init__(__self__, *,
                 private_service_connect_connection_id: str):
        """
        :param str private_service_connect_connection_id: Id of the Private Service connection.
        """
        pulumi.set(__self__, "private_service_connect_connection_id", private_service_connect_connection_id)

    @property
    @pulumi.getter(name="privateServiceConnectConnectionId")
    def private_service_connect_connection_id(self) -> str:
        """
        Id of the Private Service connection.
        """
        return pulumi.get(self, "private_service_connect_connection_id")


@pulumi.output_type
class GetPrivateLinkAttachmentConnectionPrivateLinkAttachmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Private Link Attachment Connection, for example, `plattc-p5j3ov`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Private Link Attachment Connection, for example, `plattc-p5j3ov`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetPrivateLinkAttachmentEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Private Link Attachment belongs to, for example `env-xyz456`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Private Link Attachment belongs to, for example `env-xyz456`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetPrivateLinkAttachmentGcpResult(dict):
    def __init__(__self__, *,
                 private_service_connect_service_attachment: str,
                 zone: str):
        """
        :param str private_service_connect_service_attachment: Id of a Private Service Connect Service Attachment in Confluent Cloud.
        :param str zone: Zone associated with the PSC Service attachment.
        """
        pulumi.set(__self__, "private_service_connect_service_attachment", private_service_connect_service_attachment)
        pulumi.set(__self__, "zone", zone)

    @property
    @pulumi.getter(name="privateServiceConnectServiceAttachment")
    def private_service_connect_service_attachment(self) -> str:
        """
        Id of a Private Service Connect Service Attachment in Confluent Cloud.
        """
        return pulumi.get(self, "private_service_connect_service_attachment")

    @property
    @pulumi.getter
    def zone(self) -> str:
        """
        Zone associated with the PSC Service attachment.
        """
        return pulumi.get(self, "zone")


@pulumi.output_type
class GetProviderIntegrationAwResult(dict):
    def __init__(__self__, *,
                 customer_role_arn: str,
                 external_id: str,
                 iam_role_arn: str):
        """
        :param str customer_role_arn: (Required String) Amazon Resource Name (ARN) that identifies the AWS Identity and Access Management (IAM) role that Confluent Cloud assumes when it accesses resources in your AWS account, and must be unique in the same environment.
        :param str external_id: (Required String) Unique external ID that Confluent Cloud uses when it assumes the IAM role in your Amazon Web Services (AWS) account.
        :param str iam_role_arn: (Required String) The IAM role ARN used in Confluent Cloud internally, bundled with `customer_role_arn`.
        """
        pulumi.set(__self__, "customer_role_arn", customer_role_arn)
        pulumi.set(__self__, "external_id", external_id)
        pulumi.set(__self__, "iam_role_arn", iam_role_arn)

    @property
    @pulumi.getter(name="customerRoleArn")
    def customer_role_arn(self) -> str:
        """
        (Required String) Amazon Resource Name (ARN) that identifies the AWS Identity and Access Management (IAM) role that Confluent Cloud assumes when it accesses resources in your AWS account, and must be unique in the same environment.
        """
        return pulumi.get(self, "customer_role_arn")

    @property
    @pulumi.getter(name="externalId")
    def external_id(self) -> str:
        """
        (Required String) Unique external ID that Confluent Cloud uses when it assumes the IAM role in your Amazon Web Services (AWS) account.
        """
        return pulumi.get(self, "external_id")

    @property
    @pulumi.getter(name="iamRoleArn")
    def iam_role_arn(self) -> str:
        """
        (Required String) The IAM role ARN used in Confluent Cloud internally, bundled with `customer_role_arn`.
        """
        return pulumi.get(self, "iam_role_arn")


@pulumi.output_type
class GetProviderIntegrationEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Provider Integration belongs to, for example, `env-xyz456`.
               
               > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Provider Integration belongs to, for example, `env-xyz456`.

        > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetSchemaCredentialsResult(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetSchemaMetadataResult(dict):
    def __init__(__self__, *,
                 properties: Mapping[str, str],
                 sensitives: Sequence[str],
                 tags: Sequence['outputs.GetSchemaMetadataTagResult']):
        """
        :param Mapping[str, str] properties: (Optional Map) The custom properties to set:
        :param Sequence[str] sensitives: (Optional List of Strings) A list of metadata properties to be encrypted.
        :param Sequence['GetSchemaMetadataTagArgs'] tags: (Optional String List) The tags to which the rule applies, if any.
        """
        pulumi.set(__self__, "properties", properties)
        pulumi.set(__self__, "sensitives", sensitives)
        pulumi.set(__self__, "tags", tags)

    @property
    @pulumi.getter
    def properties(self) -> Mapping[str, str]:
        """
        (Optional Map) The custom properties to set:
        """
        return pulumi.get(self, "properties")

    @property
    @pulumi.getter
    def sensitives(self) -> Sequence[str]:
        """
        (Optional List of Strings) A list of metadata properties to be encrypted.
        """
        return pulumi.get(self, "sensitives")

    @property
    @pulumi.getter
    def tags(self) -> Sequence['outputs.GetSchemaMetadataTagResult']:
        """
        (Optional String List) The tags to which the rule applies, if any.
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetSchemaMetadataTagResult(dict):
    def __init__(__self__, *,
                 key: str,
                 values: Sequence[str]):
        """
        :param str key: (Required String) The setting name.
        :param Sequence[str] values: (Required List of Strings) The list of tags.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        (Required String) The setting name.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def values(self) -> Sequence[str]:
        """
        (Required List of Strings) The list of tags.
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetSchemaRegistryClusterConfigCredentialsResult(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetSchemaRegistryClusterConfigSchemaRegistryClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetSchemaRegistryClusterEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Schema Registry cluster belongs to, for example, `env-xyz456`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Schema Registry cluster belongs to, for example, `env-xyz456`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetSchemaRegistryClusterModeCredentialsResult(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
               
               > **Note:** A Schema Registry API key consists of a key and a secret. Schema Registry API keys are required to interact with Schema Registry clusters in Confluent Cloud. Each Schema Registry API key is valid for one specific Schema Registry cluster.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.

        > **Note:** A Schema Registry API key consists of a key and a secret. Schema Registry API keys are required to interact with Schema Registry clusters in Confluent Cloud. Each Schema Registry API key is valid for one specific Schema Registry cluster.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetSchemaRegistryClusterModeSchemaRegistryClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetSchemaRegistryClustersClusterResult(dict):
    def __init__(__self__, *,
                 api_version: str,
                 catalog_endpoint: str,
                 cloud: str,
                 display_name: str,
                 environment: 'outputs.GetSchemaRegistryClustersClusterEnvironmentResult',
                 id: str,
                 kind: str,
                 package: str,
                 private_rest_endpoint: str,
                 region: str,
                 resource_name: str,
                 rest_endpoint: str):
        """
        :param str api_version: (Required String) An API Version of the schema version of the Schema Registry cluster, for example, `stream-governance/v2`.
        :param str catalog_endpoint: (Required String) The Catalog endpoint of the Schema Registry cluster, for example, `https://psrc-y1113.us-west-2.aws.confluent.cloud`.
        :param str cloud: (Required String) The cloud service provider that the Schema Registry cluster belongs to, for example, `AWS`.
        :param str display_name: (Required String) The name of the Schema Registry cluster, for example, `Stream Governance Package`.
        :param 'GetSchemaRegistryClustersClusterEnvironmentArgs' environment: (Required Object) exports the following attributes:
        :param str id: (Required String) The id of the environment.
        :param str kind: (Required String) A kind of the Schema Registry cluster, for example, `Cluster`.
        :param str package: (Required String) The type of the billing package. Accepted values are: `ESSENTIALS` and `ADVANCED`.
        :param str private_rest_endpoint: (Required String) The private HTTP endpoint of the Schema Registry cluster, for example, `https://lsrc.us-west-2.aws.private.stag.cpdev.cloud`.
        :param str region: (Required String) The ID of the Schema Registry region that the Schema Registry cluster belongs to, for example, `us-east4`.
        :param str resource_name: (Required String) The Confluent Resource Name of the Schema Registry cluster, for example, `crn://confluent.cloud/organization=1111aaaa-11aa-11aa-11aa-111111aaaaaa/environment=env-abc123/schema-registry=lsrc-abc123`.
        :param str rest_endpoint: (Required String) The HTTP endpoint of the Schema Registry cluster, for example, `https://psrc-00000.us-west-2.aws.confluent.cloud`.
        """
        pulumi.set(__self__, "api_version", api_version)
        pulumi.set(__self__, "catalog_endpoint", catalog_endpoint)
        pulumi.set(__self__, "cloud", cloud)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "environment", environment)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "package", package)
        pulumi.set(__self__, "private_rest_endpoint", private_rest_endpoint)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "resource_name", resource_name)
        pulumi.set(__self__, "rest_endpoint", rest_endpoint)

    @property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> str:
        """
        (Required String) An API Version of the schema version of the Schema Registry cluster, for example, `stream-governance/v2`.
        """
        return pulumi.get(self, "api_version")

    @property
    @pulumi.getter(name="catalogEndpoint")
    def catalog_endpoint(self) -> str:
        """
        (Required String) The Catalog endpoint of the Schema Registry cluster, for example, `https://psrc-y1113.us-west-2.aws.confluent.cloud`.
        """
        return pulumi.get(self, "catalog_endpoint")

    @property
    @pulumi.getter
    def cloud(self) -> str:
        """
        (Required String) The cloud service provider that the Schema Registry cluster belongs to, for example, `AWS`.
        """
        return pulumi.get(self, "cloud")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        (Required String) The name of the Schema Registry cluster, for example, `Stream Governance Package`.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter
    def environment(self) -> 'outputs.GetSchemaRegistryClustersClusterEnvironmentResult':
        """
        (Required Object) exports the following attributes:
        """
        return pulumi.get(self, "environment")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        (Required String) The id of the environment.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def kind(self) -> str:
        """
        (Required String) A kind of the Schema Registry cluster, for example, `Cluster`.
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter
    def package(self) -> str:
        """
        (Required String) The type of the billing package. Accepted values are: `ESSENTIALS` and `ADVANCED`.
        """
        return pulumi.get(self, "package")

    @property
    @pulumi.getter(name="privateRestEndpoint")
    def private_rest_endpoint(self) -> str:
        """
        (Required String) The private HTTP endpoint of the Schema Registry cluster, for example, `https://lsrc.us-west-2.aws.private.stag.cpdev.cloud`.
        """
        return pulumi.get(self, "private_rest_endpoint")

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        (Required String) The ID of the Schema Registry region that the Schema Registry cluster belongs to, for example, `us-east4`.
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="resourceName")
    def resource_name(self) -> str:
        """
        (Required String) The Confluent Resource Name of the Schema Registry cluster, for example, `crn://confluent.cloud/organization=1111aaaa-11aa-11aa-11aa-111111aaaaaa/environment=env-abc123/schema-registry=lsrc-abc123`.
        """
        return pulumi.get(self, "resource_name")

    @property
    @pulumi.getter(name="restEndpoint")
    def rest_endpoint(self) -> str:
        """
        (Required String) The HTTP endpoint of the Schema Registry cluster, for example, `https://psrc-00000.us-west-2.aws.confluent.cloud`.
        """
        return pulumi.get(self, "rest_endpoint")


@pulumi.output_type
class GetSchemaRegistryClustersClusterEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Schema Registry cluster belongs to, for example, `env-xyz456`.
               - If no environment id is specified, clusters from all environments will be displayed.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Schema Registry cluster belongs to, for example, `env-xyz456`.
        - If no environment id is specified, clusters from all environments will be displayed.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetSchemaRegistryClustersEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Schema Registry cluster belongs to, for example, `env-xyz456`.
               - If no environment id is specified, clusters from all environments will be displayed.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Schema Registry cluster belongs to, for example, `env-xyz456`.
        - If no environment id is specified, clusters from all environments will be displayed.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetSchemaRegistryDekCredentialsResult(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetSchemaRegistryDekSchemaRegistryClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetSchemaRegistryKekCredentialsResult(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetSchemaRegistryKekSchemaRegistryClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetSchemaRulesetResult(dict):
    def __init__(__self__, *,
                 domain_rules: Sequence['outputs.GetSchemaRulesetDomainRuleResult'],
                 migration_rules: Sequence['outputs.GetSchemaRulesetMigrationRuleResult']):
        """
        :param Sequence['GetSchemaRulesetDomainRuleArgs'] domain_rules: (Optional List of Blocks) supports the following:
        """
        pulumi.set(__self__, "domain_rules", domain_rules)
        pulumi.set(__self__, "migration_rules", migration_rules)

    @property
    @pulumi.getter(name="domainRules")
    def domain_rules(self) -> Sequence['outputs.GetSchemaRulesetDomainRuleResult']:
        """
        (Optional List of Blocks) supports the following:
        """
        return pulumi.get(self, "domain_rules")

    @property
    @pulumi.getter(name="migrationRules")
    def migration_rules(self) -> Sequence['outputs.GetSchemaRulesetMigrationRuleResult']:
        return pulumi.get(self, "migration_rules")


@pulumi.output_type
class GetSchemaRulesetDomainRuleResult(dict):
    def __init__(__self__, *,
                 kind: str,
                 mode: str,
                 name: str,
                 params: Mapping[str, str],
                 tags: Sequence[str],
                 type: str,
                 disabled: Optional[bool] = None,
                 doc: Optional[str] = None,
                 expr: Optional[str] = None,
                 on_failure: Optional[str] = None,
                 on_success: Optional[str] = None):
        """
        :param str kind: (Required String) The kind of the rule. Accepted values are `CONDITION` and `TRANSFORM`. `CONDITION` - validate the value of a field, `TRANSFORM` - transform the value of a field. Data quality rules use `CONDITION` kind, data transformation, encryption and migration rules use `TRANSFORM` kind.
        :param str mode: (Required String) The mode of the rule. Accepted values are `UPGRADE`, `DOWNGRADE`, `UPDOWN`, `WRITE`, `READ`, and `WRITEREAD`.
        :param str name: (Required String) A user-defined name that can be used to reference the rule.
        :param Mapping[str, str] params: (Optional Configuration Block) A set of static parameters for the rule, which is optional. These are key-value pairs that are passed to the rule.
        :param Sequence[str] tags: (Optional String List) The tags to which the rule applies, if any.
        :param str type: (Required String) The type of rule, which invokes a specific rule executor that that will run the rule. Google Common Expression Language (`CEL`) is used for data quality and transformation rules, Confluent `ENCRYPT` is used for data encryption rules, and `JSONata` is used for migration rules.
        :param bool disabled: (Optional Boolean) The boolean flag to control whether the rule should be disabled.
        :param str doc: (Optional String) An optional description of the rule.
        :param str expr: (Optional String) The rule body. Data quality and transformation rules use `CEL` language expressions, data migration rules use `JSONata` expressions. Defaults to "".
        :param str on_failure: (Optional String) An optional action to execute if the rule fails, otherwise the built-in action type `ERROR` is used. For `UPDOWN` and `WRITEREAD` rules, one can specify two actions separated by commas, as mentioned above.
        :param str on_success: (Optional String) An optional action to execute if the rule succeeds, otherwise the built-in action type `NONE` is used. For `UPDOWN` and `WRITEREAD` rules, one can specify two actions separated by commas, such as "NONE,ERROR" for a `WRITEREAD` rule. In this case `NONE` applies to `WRITE` and `ERROR` applies to `READ`.
        """
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "params", params)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "type", type)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if doc is not None:
            pulumi.set(__self__, "doc", doc)
        if expr is not None:
            pulumi.set(__self__, "expr", expr)
        if on_failure is not None:
            pulumi.set(__self__, "on_failure", on_failure)
        if on_success is not None:
            pulumi.set(__self__, "on_success", on_success)

    @property
    @pulumi.getter
    def kind(self) -> str:
        """
        (Required String) The kind of the rule. Accepted values are `CONDITION` and `TRANSFORM`. `CONDITION` - validate the value of a field, `TRANSFORM` - transform the value of a field. Data quality rules use `CONDITION` kind, data transformation, encryption and migration rules use `TRANSFORM` kind.
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        (Required String) The mode of the rule. Accepted values are `UPGRADE`, `DOWNGRADE`, `UPDOWN`, `WRITE`, `READ`, and `WRITEREAD`.
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        (Required String) A user-defined name that can be used to reference the rule.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def params(self) -> Mapping[str, str]:
        """
        (Optional Configuration Block) A set of static parameters for the rule, which is optional. These are key-value pairs that are passed to the rule.
        """
        return pulumi.get(self, "params")

    @property
    @pulumi.getter
    def tags(self) -> Sequence[str]:
        """
        (Optional String List) The tags to which the rule applies, if any.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        (Required String) The type of rule, which invokes a specific rule executor that that will run the rule. Google Common Expression Language (`CEL`) is used for data quality and transformation rules, Confluent `ENCRYPT` is used for data encryption rules, and `JSONata` is used for migration rules.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def disabled(self) -> Optional[bool]:
        """
        (Optional Boolean) The boolean flag to control whether the rule should be disabled.
        """
        return pulumi.get(self, "disabled")

    @property
    @pulumi.getter
    def doc(self) -> Optional[str]:
        """
        (Optional String) An optional description of the rule.
        """
        return pulumi.get(self, "doc")

    @property
    @pulumi.getter
    def expr(self) -> Optional[str]:
        """
        (Optional String) The rule body. Data quality and transformation rules use `CEL` language expressions, data migration rules use `JSONata` expressions. Defaults to "".
        """
        return pulumi.get(self, "expr")

    @property
    @pulumi.getter(name="onFailure")
    def on_failure(self) -> Optional[str]:
        """
        (Optional String) An optional action to execute if the rule fails, otherwise the built-in action type `ERROR` is used. For `UPDOWN` and `WRITEREAD` rules, one can specify two actions separated by commas, as mentioned above.
        """
        return pulumi.get(self, "on_failure")

    @property
    @pulumi.getter(name="onSuccess")
    def on_success(self) -> Optional[str]:
        """
        (Optional String) An optional action to execute if the rule succeeds, otherwise the built-in action type `NONE` is used. For `UPDOWN` and `WRITEREAD` rules, one can specify two actions separated by commas, such as "NONE,ERROR" for a `WRITEREAD` rule. In this case `NONE` applies to `WRITE` and `ERROR` applies to `READ`.
        """
        return pulumi.get(self, "on_success")


@pulumi.output_type
class GetSchemaRulesetMigrationRuleResult(dict):
    def __init__(__self__, *,
                 kind: str,
                 mode: str,
                 name: str,
                 params: Mapping[str, str],
                 tags: Sequence[str],
                 type: str,
                 disabled: Optional[bool] = None,
                 doc: Optional[str] = None,
                 expr: Optional[str] = None,
                 on_failure: Optional[str] = None,
                 on_success: Optional[str] = None):
        """
        :param str kind: (Required String) The kind of the rule. Accepted values are `CONDITION` and `TRANSFORM`. `CONDITION` - validate the value of a field, `TRANSFORM` - transform the value of a field. Data quality rules use `CONDITION` kind, data transformation, encryption and migration rules use `TRANSFORM` kind.
        :param str mode: (Required String) The mode of the rule. Accepted values are `UPGRADE`, `DOWNGRADE`, `UPDOWN`, `WRITE`, `READ`, and `WRITEREAD`.
        :param str name: (Required String) A user-defined name that can be used to reference the rule.
        :param Mapping[str, str] params: (Optional Configuration Block) A set of static parameters for the rule, which is optional. These are key-value pairs that are passed to the rule.
        :param Sequence[str] tags: (Optional String List) The tags to which the rule applies, if any.
        :param str type: (Required String) The type of rule, which invokes a specific rule executor that that will run the rule. Google Common Expression Language (`CEL`) is used for data quality and transformation rules, Confluent `ENCRYPT` is used for data encryption rules, and `JSONata` is used for migration rules.
        :param bool disabled: (Optional Boolean) The boolean flag to control whether the rule should be disabled.
        :param str doc: (Optional String) An optional description of the rule.
        :param str expr: (Optional String) The rule body. Data quality and transformation rules use `CEL` language expressions, data migration rules use `JSONata` expressions. Defaults to "".
        :param str on_failure: (Optional String) An optional action to execute if the rule fails, otherwise the built-in action type `ERROR` is used. For `UPDOWN` and `WRITEREAD` rules, one can specify two actions separated by commas, as mentioned above.
        :param str on_success: (Optional String) An optional action to execute if the rule succeeds, otherwise the built-in action type `NONE` is used. For `UPDOWN` and `WRITEREAD` rules, one can specify two actions separated by commas, such as "NONE,ERROR" for a `WRITEREAD` rule. In this case `NONE` applies to `WRITE` and `ERROR` applies to `READ`.
        """
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "params", params)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "type", type)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if doc is not None:
            pulumi.set(__self__, "doc", doc)
        if expr is not None:
            pulumi.set(__self__, "expr", expr)
        if on_failure is not None:
            pulumi.set(__self__, "on_failure", on_failure)
        if on_success is not None:
            pulumi.set(__self__, "on_success", on_success)

    @property
    @pulumi.getter
    def kind(self) -> str:
        """
        (Required String) The kind of the rule. Accepted values are `CONDITION` and `TRANSFORM`. `CONDITION` - validate the value of a field, `TRANSFORM` - transform the value of a field. Data quality rules use `CONDITION` kind, data transformation, encryption and migration rules use `TRANSFORM` kind.
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        (Required String) The mode of the rule. Accepted values are `UPGRADE`, `DOWNGRADE`, `UPDOWN`, `WRITE`, `READ`, and `WRITEREAD`.
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        (Required String) A user-defined name that can be used to reference the rule.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def params(self) -> Mapping[str, str]:
        """
        (Optional Configuration Block) A set of static parameters for the rule, which is optional. These are key-value pairs that are passed to the rule.
        """
        return pulumi.get(self, "params")

    @property
    @pulumi.getter
    def tags(self) -> Sequence[str]:
        """
        (Optional String List) The tags to which the rule applies, if any.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        (Required String) The type of rule, which invokes a specific rule executor that that will run the rule. Google Common Expression Language (`CEL`) is used for data quality and transformation rules, Confluent `ENCRYPT` is used for data encryption rules, and `JSONata` is used for migration rules.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def disabled(self) -> Optional[bool]:
        """
        (Optional Boolean) The boolean flag to control whether the rule should be disabled.
        """
        return pulumi.get(self, "disabled")

    @property
    @pulumi.getter
    def doc(self) -> Optional[str]:
        """
        (Optional String) An optional description of the rule.
        """
        return pulumi.get(self, "doc")

    @property
    @pulumi.getter
    def expr(self) -> Optional[str]:
        """
        (Optional String) The rule body. Data quality and transformation rules use `CEL` language expressions, data migration rules use `JSONata` expressions. Defaults to "".
        """
        return pulumi.get(self, "expr")

    @property
    @pulumi.getter(name="onFailure")
    def on_failure(self) -> Optional[str]:
        """
        (Optional String) An optional action to execute if the rule fails, otherwise the built-in action type `ERROR` is used. For `UPDOWN` and `WRITEREAD` rules, one can specify two actions separated by commas, as mentioned above.
        """
        return pulumi.get(self, "on_failure")

    @property
    @pulumi.getter(name="onSuccess")
    def on_success(self) -> Optional[str]:
        """
        (Optional String) An optional action to execute if the rule succeeds, otherwise the built-in action type `NONE` is used. For `UPDOWN` and `WRITEREAD` rules, one can specify two actions separated by commas, such as "NONE,ERROR" for a `WRITEREAD` rule. In this case `NONE` applies to `WRITE` and `ERROR` applies to `READ`.
        """
        return pulumi.get(self, "on_success")


@pulumi.output_type
class GetSchemaSchemaReferenceResult(dict):
    def __init__(__self__, *,
                 name: str,
                 subject_name: str,
                 version: int):
        """
        :param str name: (Required String) A user-defined name that can be used to reference the rule.
        :param str subject_name: The name of the subject (in other words, the namespace), representing the subject under which the schema will be registered, for example, `test-subject`. Schemas evolve safely, following a compatibility mode defined, under a subject name.
        :param int version: (Required Integer) The version of the Schema, for example, `4`.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "subject_name", subject_name)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        (Required String) A user-defined name that can be used to reference the rule.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="subjectName")
    def subject_name(self) -> str:
        """
        The name of the subject (in other words, the namespace), representing the subject under which the schema will be registered, for example, `test-subject`. Schemas evolve safely, following a compatibility mode defined, under a subject name.
        """
        return pulumi.get(self, "subject_name")

    @property
    @pulumi.getter
    def version(self) -> int:
        """
        (Required Integer) The version of the Schema, for example, `4`.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetSchemaSchemaRegistryClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetSchemasCredentialsResult(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetSchemasFilterResult(dict):
    def __init__(__self__, *,
                 deleted: Optional[bool] = None,
                 latest_only: Optional[bool] = None,
                 subject_prefix: Optional[str] = None):
        """
        :param bool deleted: The boolean flag to control whether to return soft deleted schemas. Defaults to `false`.
        :param bool latest_only: The boolean flag to control whether to return latest schema versions only for each matching subject. Defaults to `false`.
        :param str subject_prefix: The prefix of the subjects (in other words, the namespaces), representing the subjects under which the schemas are registered.
        """
        if deleted is not None:
            pulumi.set(__self__, "deleted", deleted)
        if latest_only is not None:
            pulumi.set(__self__, "latest_only", latest_only)
        if subject_prefix is not None:
            pulumi.set(__self__, "subject_prefix", subject_prefix)

    @property
    @pulumi.getter
    def deleted(self) -> Optional[bool]:
        """
        The boolean flag to control whether to return soft deleted schemas. Defaults to `false`.
        """
        return pulumi.get(self, "deleted")

    @property
    @pulumi.getter(name="latestOnly")
    def latest_only(self) -> Optional[bool]:
        """
        The boolean flag to control whether to return latest schema versions only for each matching subject. Defaults to `false`.
        """
        return pulumi.get(self, "latest_only")

    @property
    @pulumi.getter(name="subjectPrefix")
    def subject_prefix(self) -> Optional[str]:
        """
        The prefix of the subjects (in other words, the namespaces), representing the subjects under which the schemas are registered.
        """
        return pulumi.get(self, "subject_prefix")


@pulumi.output_type
class GetSchemasSchemaResult(dict):
    def __init__(__self__, *,
                 format: str,
                 schema: str,
                 schema_identifier: int,
                 schema_references: Sequence['outputs.GetSchemasSchemaSchemaReferenceResult'],
                 subject_name: str,
                 version: int):
        """
        :param str format: (Required String) The format of the schema. Accepted values are: `AVRO`, `PROTOBUF`, and `JSON`.
        :param str schema: (Required String) The schema string.
        :param int schema_identifier: (Required String) The ID of the Schema, for example: `lsrc-abc123/test-subject/100003`.
        :param Sequence['GetSchemasSchemaSchemaReferenceArgs'] schema_references: (Optional List) The list of referenced schemas (see [Schema References](https://docs.confluent.io/platform/current/schema-registry/serdes-develop/index.html#schema-references) for more details):
        :param str subject_name: (Required String) The name for the reference. (For Avro Schema, the reference name is the fully qualified schema name, for JSON Schema it is a URL, and for Protobuf Schema, it is the name of another Protobuf file.)
        :param int version: (Required Integer) The version of the Schema, for example, `4`.
        """
        pulumi.set(__self__, "format", format)
        pulumi.set(__self__, "schema", schema)
        pulumi.set(__self__, "schema_identifier", schema_identifier)
        pulumi.set(__self__, "schema_references", schema_references)
        pulumi.set(__self__, "subject_name", subject_name)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def format(self) -> str:
        """
        (Required String) The format of the schema. Accepted values are: `AVRO`, `PROTOBUF`, and `JSON`.
        """
        return pulumi.get(self, "format")

    @property
    @pulumi.getter
    def schema(self) -> str:
        """
        (Required String) The schema string.
        """
        return pulumi.get(self, "schema")

    @property
    @pulumi.getter(name="schemaIdentifier")
    def schema_identifier(self) -> int:
        """
        (Required String) The ID of the Schema, for example: `lsrc-abc123/test-subject/100003`.
        """
        return pulumi.get(self, "schema_identifier")

    @property
    @pulumi.getter(name="schemaReferences")
    def schema_references(self) -> Sequence['outputs.GetSchemasSchemaSchemaReferenceResult']:
        """
        (Optional List) The list of referenced schemas (see [Schema References](https://docs.confluent.io/platform/current/schema-registry/serdes-develop/index.html#schema-references) for more details):
        """
        return pulumi.get(self, "schema_references")

    @property
    @pulumi.getter(name="subjectName")
    def subject_name(self) -> str:
        """
        (Required String) The name for the reference. (For Avro Schema, the reference name is the fully qualified schema name, for JSON Schema it is a URL, and for Protobuf Schema, it is the name of another Protobuf file.)
        """
        return pulumi.get(self, "subject_name")

    @property
    @pulumi.getter
    def version(self) -> int:
        """
        (Required Integer) The version of the Schema, for example, `4`.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetSchemasSchemaRegistryClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetSchemasSchemaSchemaReferenceResult(dict):
    def __init__(__self__, *,
                 name: str,
                 subject_name: str,
                 version: int):
        """
        :param str name: (Required String) The name of the subject, representing the subject under which the referenced schema is registered.
        :param str subject_name: (Required String) The name for the reference. (For Avro Schema, the reference name is the fully qualified schema name, for JSON Schema it is a URL, and for Protobuf Schema, it is the name of another Protobuf file.)
        :param int version: (Required Integer) The version of the Schema, for example, `4`.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "subject_name", subject_name)
        pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        (Required String) The name of the subject, representing the subject under which the referenced schema is registered.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="subjectName")
    def subject_name(self) -> str:
        """
        (Required String) The name for the reference. (For Avro Schema, the reference name is the fully qualified schema name, for JSON Schema it is a URL, and for Protobuf Schema, it is the name of another Protobuf file.)
        """
        return pulumi.get(self, "subject_name")

    @property
    @pulumi.getter
    def version(self) -> int:
        """
        (Required Integer) The version of the Schema, for example, `4`.
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetSubjectConfigCredentialsResult(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetSubjectConfigSchemaRegistryClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetSubjectModeCredentialsResult(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetSubjectModeSchemaRegistryClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetTagBindingCredentialsResult(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetTagBindingSchemaRegistryClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetTagCredentialsResult(dict):
    def __init__(__self__, *,
                 key: str,
                 secret: str):
        """
        :param str key: The Schema Registry API Key.
        :param str secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        The Schema Registry API Secret.
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetTagSchemaRegistryClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetTransitGatewayAttachmentAwResult(dict):
    def __init__(__self__, *,
                 ram_resource_share_arn: str,
                 routes: Sequence[str],
                 transit_gateway_attachment_id: str,
                 transit_gateway_id: str):
        """
        :param str ram_resource_share_arn: (Required String) The Amazon Resource Name (ARN) of the Resource Access Manager (RAM) Resource Share of the transit gateway your Confluent Cloud network attaches to.
        :param Sequence[str] routes: (Required List of String) List of destination routes for traffic from Confluent VPC to customer VPC via Transit Gateway.
        :param str transit_gateway_attachment_id: (Required String) The ID of the AWS Transit Gateway VPC Attachment that attaches Confluent VPC to Transit Gateway.
        :param str transit_gateway_id: (Required String) The ID of the AWS Transit Gateway that you want Confluent CLoud to be attached to. Must start with `tgw-`.
        """
        pulumi.set(__self__, "ram_resource_share_arn", ram_resource_share_arn)
        pulumi.set(__self__, "routes", routes)
        pulumi.set(__self__, "transit_gateway_attachment_id", transit_gateway_attachment_id)
        pulumi.set(__self__, "transit_gateway_id", transit_gateway_id)

    @property
    @pulumi.getter(name="ramResourceShareArn")
    def ram_resource_share_arn(self) -> str:
        """
        (Required String) The Amazon Resource Name (ARN) of the Resource Access Manager (RAM) Resource Share of the transit gateway your Confluent Cloud network attaches to.
        """
        return pulumi.get(self, "ram_resource_share_arn")

    @property
    @pulumi.getter
    def routes(self) -> Sequence[str]:
        """
        (Required List of String) List of destination routes for traffic from Confluent VPC to customer VPC via Transit Gateway.
        """
        return pulumi.get(self, "routes")

    @property
    @pulumi.getter(name="transitGatewayAttachmentId")
    def transit_gateway_attachment_id(self) -> str:
        """
        (Required String) The ID of the AWS Transit Gateway VPC Attachment that attaches Confluent VPC to Transit Gateway.
        """
        return pulumi.get(self, "transit_gateway_attachment_id")

    @property
    @pulumi.getter(name="transitGatewayId")
    def transit_gateway_id(self) -> str:
        """
        (Required String) The ID of the AWS Transit Gateway that you want Confluent CLoud to be attached to. Must start with `tgw-`.
        """
        return pulumi.get(self, "transit_gateway_id")


@pulumi.output_type
class GetTransitGatewayAttachmentEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the Transit Gateway Attachment belongs to, for example, `env-xyz456`.
               
               > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Environment that the Transit Gateway Attachment belongs to, for example, `env-xyz456`.

        > **Note:** Exactly one from the `id` and `display_name` attributes must be specified.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetTransitGatewayAttachmentNetworkResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Peering, for example, `tgwa-abc123`.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Peering, for example, `tgwa-abc123`.
        """
        return pulumi.get(self, "id")


