# 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

__all__ = [
    'AccessPointAwsEgressPrivateLinkEndpointArgs',
    'AccessPointAwsEgressPrivateLinkEndpointArgsDict',
    'AccessPointAzureEgressPrivateLinkEndpointArgs',
    'AccessPointAzureEgressPrivateLinkEndpointArgsDict',
    'AccessPointEnvironmentArgs',
    'AccessPointEnvironmentArgsDict',
    'AccessPointGatewayArgs',
    'AccessPointGatewayArgsDict',
    'ApiKeyManagedResourceArgs',
    'ApiKeyManagedResourceArgsDict',
    'ApiKeyManagedResourceEnvironmentArgs',
    'ApiKeyManagedResourceEnvironmentArgsDict',
    'ApiKeyOwnerArgs',
    'ApiKeyOwnerArgsDict',
    'BusinessMetadataAttributeDefinitionArgs',
    'BusinessMetadataAttributeDefinitionArgsDict',
    'BusinessMetadataBindingCredentialsArgs',
    'BusinessMetadataBindingCredentialsArgsDict',
    'BusinessMetadataBindingSchemaRegistryClusterArgs',
    'BusinessMetadataBindingSchemaRegistryClusterArgsDict',
    'BusinessMetadataCredentialsArgs',
    'BusinessMetadataCredentialsArgsDict',
    'BusinessMetadataSchemaRegistryClusterArgs',
    'BusinessMetadataSchemaRegistryClusterArgsDict',
    'ByokKeyAwsArgs',
    'ByokKeyAwsArgsDict',
    'ByokKeyAzureArgs',
    'ByokKeyAzureArgsDict',
    'ByokKeyGcpArgs',
    'ByokKeyGcpArgsDict',
    'CatalogEntityAttributesCredentialsArgs',
    'CatalogEntityAttributesCredentialsArgsDict',
    'CatalogEntityAttributesSchemaRegistryClusterArgs',
    'CatalogEntityAttributesSchemaRegistryClusterArgsDict',
    'CertificatePoolCertificateAuthorityArgs',
    'CertificatePoolCertificateAuthorityArgsDict',
    'ClusterLinkDestinationKafkaClusterArgs',
    'ClusterLinkDestinationKafkaClusterArgsDict',
    'ClusterLinkDestinationKafkaClusterCredentialsArgs',
    'ClusterLinkDestinationKafkaClusterCredentialsArgsDict',
    'ClusterLinkLocalKafkaClusterArgs',
    'ClusterLinkLocalKafkaClusterArgsDict',
    'ClusterLinkLocalKafkaClusterCredentialsArgs',
    'ClusterLinkLocalKafkaClusterCredentialsArgsDict',
    'ClusterLinkRemoteKafkaClusterArgs',
    'ClusterLinkRemoteKafkaClusterArgsDict',
    'ClusterLinkRemoteKafkaClusterCredentialsArgs',
    'ClusterLinkRemoteKafkaClusterCredentialsArgsDict',
    'ClusterLinkSourceKafkaClusterArgs',
    'ClusterLinkSourceKafkaClusterArgsDict',
    'ClusterLinkSourceKafkaClusterCredentialsArgs',
    'ClusterLinkSourceKafkaClusterCredentialsArgsDict',
    'ConnectorEnvironmentArgs',
    'ConnectorEnvironmentArgsDict',
    'ConnectorKafkaClusterArgs',
    'ConnectorKafkaClusterArgsDict',
    'DnsForwarderEnvironmentArgs',
    'DnsForwarderEnvironmentArgsDict',
    'DnsForwarderForwardViaIpArgs',
    'DnsForwarderForwardViaIpArgsDict',
    'DnsForwarderGatewayArgs',
    'DnsForwarderGatewayArgsDict',
    'DnsRecordEnvironmentArgs',
    'DnsRecordEnvironmentArgsDict',
    'DnsRecordGatewayArgs',
    'DnsRecordGatewayArgsDict',
    'DnsRecordPrivateLinkAccessPointArgs',
    'DnsRecordPrivateLinkAccessPointArgsDict',
    'EnvironmentStreamGovernanceArgs',
    'EnvironmentStreamGovernanceArgsDict',
    'FlinkComputePoolEnvironmentArgs',
    'FlinkComputePoolEnvironmentArgsDict',
    'FlinkStatementComputePoolArgs',
    'FlinkStatementComputePoolArgsDict',
    'FlinkStatementCredentialsArgs',
    'FlinkStatementCredentialsArgsDict',
    'FlinkStatementEnvironmentArgs',
    'FlinkStatementEnvironmentArgsDict',
    'FlinkStatementOrganizationArgs',
    'FlinkStatementOrganizationArgsDict',
    'FlinkStatementPrincipalArgs',
    'FlinkStatementPrincipalArgsDict',
    'IdentityPoolIdentityProviderArgs',
    'IdentityPoolIdentityProviderArgsDict',
    'InvitationCreatorArgs',
    'InvitationCreatorArgsDict',
    'InvitationUserArgs',
    'InvitationUserArgsDict',
    'KafkaAclCredentialsArgs',
    'KafkaAclCredentialsArgsDict',
    'KafkaAclKafkaClusterArgs',
    'KafkaAclKafkaClusterArgsDict',
    'KafkaClientQuotaEnvironmentArgs',
    'KafkaClientQuotaEnvironmentArgsDict',
    'KafkaClientQuotaKafkaClusterArgs',
    'KafkaClientQuotaKafkaClusterArgsDict',
    'KafkaClientQuotaThroughputArgs',
    'KafkaClientQuotaThroughputArgsDict',
    'KafkaClusterBasicArgs',
    'KafkaClusterBasicArgsDict',
    'KafkaClusterByokKeyArgs',
    'KafkaClusterByokKeyArgsDict',
    'KafkaClusterConfigCredentialsArgs',
    'KafkaClusterConfigCredentialsArgsDict',
    'KafkaClusterConfigKafkaClusterArgs',
    'KafkaClusterConfigKafkaClusterArgsDict',
    'KafkaClusterDedicatedArgs',
    'KafkaClusterDedicatedArgsDict',
    'KafkaClusterEnterpriseArgs',
    'KafkaClusterEnterpriseArgsDict',
    'KafkaClusterEnvironmentArgs',
    'KafkaClusterEnvironmentArgsDict',
    'KafkaClusterFreightArgs',
    'KafkaClusterFreightArgsDict',
    'KafkaClusterNetworkArgs',
    'KafkaClusterNetworkArgsDict',
    'KafkaClusterStandardArgs',
    'KafkaClusterStandardArgsDict',
    'KafkaMirrorTopicClusterLinkArgs',
    'KafkaMirrorTopicClusterLinkArgsDict',
    'KafkaMirrorTopicKafkaClusterArgs',
    'KafkaMirrorTopicKafkaClusterArgsDict',
    'KafkaMirrorTopicKafkaClusterCredentialsArgs',
    'KafkaMirrorTopicKafkaClusterCredentialsArgsDict',
    'KafkaMirrorTopicSourceKafkaTopicArgs',
    'KafkaMirrorTopicSourceKafkaTopicArgsDict',
    'KafkaTopicCredentialsArgs',
    'KafkaTopicCredentialsArgsDict',
    'KafkaTopicKafkaClusterArgs',
    'KafkaTopicKafkaClusterArgsDict',
    'KsqlClusterCredentialIdentityArgs',
    'KsqlClusterCredentialIdentityArgsDict',
    'KsqlClusterEnvironmentArgs',
    'KsqlClusterEnvironmentArgsDict',
    'KsqlClusterKafkaClusterArgs',
    'KsqlClusterKafkaClusterArgsDict',
    'NetworkAwArgs',
    'NetworkAwArgsDict',
    'NetworkAzureArgs',
    'NetworkAzureArgsDict',
    'NetworkDnsConfigArgs',
    'NetworkDnsConfigArgsDict',
    'NetworkEnvironmentArgs',
    'NetworkEnvironmentArgsDict',
    'NetworkGatewayArgs',
    'NetworkGatewayArgsDict',
    'NetworkGcpArgs',
    'NetworkGcpArgsDict',
    'NetworkLinkEndpointEnvironmentArgs',
    'NetworkLinkEndpointEnvironmentArgsDict',
    'NetworkLinkEndpointNetworkArgs',
    'NetworkLinkEndpointNetworkArgsDict',
    'NetworkLinkEndpointNetworkLinkServiceArgs',
    'NetworkLinkEndpointNetworkLinkServiceArgsDict',
    'NetworkLinkServiceAcceptArgs',
    'NetworkLinkServiceAcceptArgsDict',
    'NetworkLinkServiceEnvironmentArgs',
    'NetworkLinkServiceEnvironmentArgsDict',
    'NetworkLinkServiceNetworkArgs',
    'NetworkLinkServiceNetworkArgsDict',
    'NetworkZoneInfoArgs',
    'NetworkZoneInfoArgsDict',
    'PeeringAwsArgs',
    'PeeringAwsArgsDict',
    'PeeringAzureArgs',
    'PeeringAzureArgsDict',
    'PeeringEnvironmentArgs',
    'PeeringEnvironmentArgsDict',
    'PeeringGcpArgs',
    'PeeringGcpArgsDict',
    'PeeringNetworkArgs',
    'PeeringNetworkArgsDict',
    'PrivateLinkAccessAwsArgs',
    'PrivateLinkAccessAwsArgsDict',
    'PrivateLinkAccessAzureArgs',
    'PrivateLinkAccessAzureArgsDict',
    'PrivateLinkAccessEnvironmentArgs',
    'PrivateLinkAccessEnvironmentArgsDict',
    'PrivateLinkAccessGcpArgs',
    'PrivateLinkAccessGcpArgsDict',
    'PrivateLinkAccessNetworkArgs',
    'PrivateLinkAccessNetworkArgsDict',
    'PrivateLinkAttachmentAwArgs',
    'PrivateLinkAttachmentAwArgsDict',
    'PrivateLinkAttachmentAzureArgs',
    'PrivateLinkAttachmentAzureArgsDict',
    'PrivateLinkAttachmentConnectionAwsArgs',
    'PrivateLinkAttachmentConnectionAwsArgsDict',
    'PrivateLinkAttachmentConnectionAzureArgs',
    'PrivateLinkAttachmentConnectionAzureArgsDict',
    'PrivateLinkAttachmentConnectionEnvironmentArgs',
    'PrivateLinkAttachmentConnectionEnvironmentArgsDict',
    'PrivateLinkAttachmentConnectionGcpArgs',
    'PrivateLinkAttachmentConnectionGcpArgsDict',
    'PrivateLinkAttachmentConnectionPrivateLinkAttachmentArgs',
    'PrivateLinkAttachmentConnectionPrivateLinkAttachmentArgsDict',
    'PrivateLinkAttachmentEnvironmentArgs',
    'PrivateLinkAttachmentEnvironmentArgsDict',
    'PrivateLinkAttachmentGcpArgs',
    'PrivateLinkAttachmentGcpArgsDict',
    'ProviderIntegrationAwsArgs',
    'ProviderIntegrationAwsArgsDict',
    'ProviderIntegrationEnvironmentArgs',
    'ProviderIntegrationEnvironmentArgsDict',
    'SchemaCredentialsArgs',
    'SchemaCredentialsArgsDict',
    'SchemaExporterCredentialsArgs',
    'SchemaExporterCredentialsArgsDict',
    'SchemaExporterDestinationSchemaRegistryClusterArgs',
    'SchemaExporterDestinationSchemaRegistryClusterArgsDict',
    'SchemaExporterDestinationSchemaRegistryClusterCredentialsArgs',
    'SchemaExporterDestinationSchemaRegistryClusterCredentialsArgsDict',
    'SchemaExporterSchemaRegistryClusterArgs',
    'SchemaExporterSchemaRegistryClusterArgsDict',
    'SchemaMetadataArgs',
    'SchemaMetadataArgsDict',
    'SchemaMetadataTagArgs',
    'SchemaMetadataTagArgsDict',
    'SchemaRegistryClusterConfigCredentialsArgs',
    'SchemaRegistryClusterConfigCredentialsArgsDict',
    'SchemaRegistryClusterConfigSchemaRegistryClusterArgs',
    'SchemaRegistryClusterConfigSchemaRegistryClusterArgsDict',
    'SchemaRegistryClusterModeCredentialsArgs',
    'SchemaRegistryClusterModeCredentialsArgsDict',
    'SchemaRegistryClusterModeSchemaRegistryClusterArgs',
    'SchemaRegistryClusterModeSchemaRegistryClusterArgsDict',
    'SchemaRegistryDekCredentialsArgs',
    'SchemaRegistryDekCredentialsArgsDict',
    'SchemaRegistryDekSchemaRegistryClusterArgs',
    'SchemaRegistryDekSchemaRegistryClusterArgsDict',
    'SchemaRegistryKekCredentialsArgs',
    'SchemaRegistryKekCredentialsArgsDict',
    'SchemaRegistryKekSchemaRegistryClusterArgs',
    'SchemaRegistryKekSchemaRegistryClusterArgsDict',
    'SchemaRulesetArgs',
    'SchemaRulesetArgsDict',
    'SchemaRulesetDomainRuleArgs',
    'SchemaRulesetDomainRuleArgsDict',
    'SchemaRulesetMigrationRuleArgs',
    'SchemaRulesetMigrationRuleArgsDict',
    'SchemaSchemaReferenceArgs',
    'SchemaSchemaReferenceArgsDict',
    'SchemaSchemaRegistryClusterArgs',
    'SchemaSchemaRegistryClusterArgsDict',
    'SubjectConfigCredentialsArgs',
    'SubjectConfigCredentialsArgsDict',
    'SubjectConfigSchemaRegistryClusterArgs',
    'SubjectConfigSchemaRegistryClusterArgsDict',
    'SubjectModeCredentialsArgs',
    'SubjectModeCredentialsArgsDict',
    'SubjectModeSchemaRegistryClusterArgs',
    'SubjectModeSchemaRegistryClusterArgsDict',
    'TagBindingCredentialsArgs',
    'TagBindingCredentialsArgsDict',
    'TagBindingSchemaRegistryClusterArgs',
    'TagBindingSchemaRegistryClusterArgsDict',
    'TagCredentialsArgs',
    'TagCredentialsArgsDict',
    'TagSchemaRegistryClusterArgs',
    'TagSchemaRegistryClusterArgsDict',
    'TransitGatewayAttachmentAwsArgs',
    'TransitGatewayAttachmentAwsArgsDict',
    'TransitGatewayAttachmentEnvironmentArgs',
    'TransitGatewayAttachmentEnvironmentArgsDict',
    'TransitGatewayAttachmentNetworkArgs',
    'TransitGatewayAttachmentNetworkArgsDict',
    'GetAccessPointEnvironmentArgs',
    'GetAccessPointEnvironmentArgsDict',
    'GetBusinessMetadataBindingCredentialsArgs',
    'GetBusinessMetadataBindingCredentialsArgsDict',
    'GetBusinessMetadataBindingSchemaRegistryClusterArgs',
    'GetBusinessMetadataBindingSchemaRegistryClusterArgsDict',
    'GetBusinessMetadataCredentialsArgs',
    'GetBusinessMetadataCredentialsArgsDict',
    'GetBusinessMetadataSchemaRegistryClusterArgs',
    'GetBusinessMetadataSchemaRegistryClusterArgsDict',
    'GetCertificatePoolCertificateAuthorityArgs',
    'GetCertificatePoolCertificateAuthorityArgsDict',
    'GetDnsRecordEnvironmentArgs',
    'GetDnsRecordEnvironmentArgsDict',
    'GetEnvironmentStreamGovernanceArgs',
    'GetEnvironmentStreamGovernanceArgsDict',
    'GetFlinkComputePoolEnvironmentArgs',
    'GetFlinkComputePoolEnvironmentArgsDict',
    'GetGatewayEnvironmentArgs',
    'GetGatewayEnvironmentArgsDict',
    'GetIdentityPoolIdentityProviderArgs',
    'GetIdentityPoolIdentityProviderArgsDict',
    'GetIpAddressesFilterArgs',
    'GetIpAddressesFilterArgsDict',
    'GetKafkaClusterBasicArgs',
    'GetKafkaClusterBasicArgsDict',
    'GetKafkaClusterDedicatedArgs',
    'GetKafkaClusterDedicatedArgsDict',
    'GetKafkaClusterEnterpriseArgs',
    'GetKafkaClusterEnterpriseArgsDict',
    'GetKafkaClusterEnvironmentArgs',
    'GetKafkaClusterEnvironmentArgsDict',
    'GetKafkaClusterFreightArgs',
    'GetKafkaClusterFreightArgsDict',
    'GetKafkaClusterStandardArgs',
    'GetKafkaClusterStandardArgsDict',
    'GetKafkaTopicCredentialsArgs',
    'GetKafkaTopicCredentialsArgsDict',
    'GetKafkaTopicKafkaClusterArgs',
    'GetKafkaTopicKafkaClusterArgsDict',
    'GetKsqlClusterEnvironmentArgs',
    'GetKsqlClusterEnvironmentArgsDict',
    'GetNetworkAwArgs',
    'GetNetworkAwArgsDict',
    'GetNetworkAzureArgs',
    'GetNetworkAzureArgsDict',
    'GetNetworkDnsConfigArgs',
    'GetNetworkDnsConfigArgsDict',
    'GetNetworkEnvironmentArgs',
    'GetNetworkEnvironmentArgsDict',
    'GetNetworkGcpArgs',
    'GetNetworkGcpArgsDict',
    'GetNetworkLinkEndpointEnvironmentArgs',
    'GetNetworkLinkEndpointEnvironmentArgsDict',
    'GetNetworkLinkServiceAcceptArgs',
    'GetNetworkLinkServiceAcceptArgsDict',
    'GetNetworkLinkServiceEnvironmentArgs',
    'GetNetworkLinkServiceEnvironmentArgsDict',
    'GetPeeringEnvironmentArgs',
    'GetPeeringEnvironmentArgsDict',
    'GetPrivateLinkAccessEnvironmentArgs',
    'GetPrivateLinkAccessEnvironmentArgsDict',
    'GetPrivateLinkAttachmentConnectionEnvironmentArgs',
    'GetPrivateLinkAttachmentConnectionEnvironmentArgsDict',
    'GetPrivateLinkAttachmentEnvironmentArgs',
    'GetPrivateLinkAttachmentEnvironmentArgsDict',
    'GetProviderIntegrationEnvironmentArgs',
    'GetProviderIntegrationEnvironmentArgsDict',
    'GetSchemaCredentialsArgs',
    'GetSchemaCredentialsArgsDict',
    'GetSchemaMetadataArgs',
    'GetSchemaMetadataArgsDict',
    'GetSchemaMetadataTagArgs',
    'GetSchemaMetadataTagArgsDict',
    'GetSchemaRegistryClusterConfigCredentialsArgs',
    'GetSchemaRegistryClusterConfigCredentialsArgsDict',
    'GetSchemaRegistryClusterConfigSchemaRegistryClusterArgs',
    'GetSchemaRegistryClusterConfigSchemaRegistryClusterArgsDict',
    'GetSchemaRegistryClusterEnvironmentArgs',
    'GetSchemaRegistryClusterEnvironmentArgsDict',
    'GetSchemaRegistryClusterModeCredentialsArgs',
    'GetSchemaRegistryClusterModeCredentialsArgsDict',
    'GetSchemaRegistryClusterModeSchemaRegistryClusterArgs',
    'GetSchemaRegistryClusterModeSchemaRegistryClusterArgsDict',
    'GetSchemaRegistryClustersEnvironmentArgs',
    'GetSchemaRegistryClustersEnvironmentArgsDict',
    'GetSchemaRegistryDekCredentialsArgs',
    'GetSchemaRegistryDekCredentialsArgsDict',
    'GetSchemaRegistryDekSchemaRegistryClusterArgs',
    'GetSchemaRegistryDekSchemaRegistryClusterArgsDict',
    'GetSchemaRegistryKekCredentialsArgs',
    'GetSchemaRegistryKekCredentialsArgsDict',
    'GetSchemaRegistryKekSchemaRegistryClusterArgs',
    'GetSchemaRegistryKekSchemaRegistryClusterArgsDict',
    'GetSchemaRulesetArgs',
    'GetSchemaRulesetArgsDict',
    'GetSchemaRulesetDomainRuleArgs',
    'GetSchemaRulesetDomainRuleArgsDict',
    'GetSchemaRulesetMigrationRuleArgs',
    'GetSchemaRulesetMigrationRuleArgsDict',
    'GetSchemaSchemaRegistryClusterArgs',
    'GetSchemaSchemaRegistryClusterArgsDict',
    'GetSchemasCredentialsArgs',
    'GetSchemasCredentialsArgsDict',
    'GetSchemasFilterArgs',
    'GetSchemasFilterArgsDict',
    'GetSchemasSchemaRegistryClusterArgs',
    'GetSchemasSchemaRegistryClusterArgsDict',
    'GetSubjectConfigCredentialsArgs',
    'GetSubjectConfigCredentialsArgsDict',
    'GetSubjectConfigSchemaRegistryClusterArgs',
    'GetSubjectConfigSchemaRegistryClusterArgsDict',
    'GetSubjectModeCredentialsArgs',
    'GetSubjectModeCredentialsArgsDict',
    'GetSubjectModeSchemaRegistryClusterArgs',
    'GetSubjectModeSchemaRegistryClusterArgsDict',
    'GetTagBindingCredentialsArgs',
    'GetTagBindingCredentialsArgsDict',
    'GetTagBindingSchemaRegistryClusterArgs',
    'GetTagBindingSchemaRegistryClusterArgsDict',
    'GetTagCredentialsArgs',
    'GetTagCredentialsArgsDict',
    'GetTagSchemaRegistryClusterArgs',
    'GetTagSchemaRegistryClusterArgsDict',
    'GetTransitGatewayAttachmentEnvironmentArgs',
    'GetTransitGatewayAttachmentEnvironmentArgsDict',
]

MYPY = False

if not MYPY:
    class AccessPointAwsEgressPrivateLinkEndpointArgsDict(TypedDict):
        vpc_endpoint_service_name: pulumi.Input[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`.
        """
        enable_high_availability: NotRequired[pulumi.Input[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`.
        """
        vpc_endpoint_dns_name: NotRequired[pulumi.Input[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`.
        """
        vpc_endpoint_id: NotRequired[pulumi.Input[str]]
        """
        (Required String) The ID of a VPC Endpoint (if any) that is connected to the VPC Endpoint service, for example, `vpce-00000000000000000`.
        """
elif False:
    AccessPointAwsEgressPrivateLinkEndpointArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccessPointAwsEgressPrivateLinkEndpointArgs:
    def __init__(__self__, *,
                 vpc_endpoint_service_name: pulumi.Input[str],
                 enable_high_availability: Optional[pulumi.Input[bool]] = None,
                 vpc_endpoint_dns_name: Optional[pulumi.Input[str]] = None,
                 vpc_endpoint_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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 pulumi.Input[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 pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[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")

    @vpc_endpoint_service_name.setter
    def vpc_endpoint_service_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "vpc_endpoint_service_name", value)

    @property
    @pulumi.getter(name="enableHighAvailability")
    def enable_high_availability(self) -> Optional[pulumi.Input[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")

    @enable_high_availability.setter
    def enable_high_availability(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_high_availability", value)

    @property
    @pulumi.getter(name="vpcEndpointDnsName")
    def vpc_endpoint_dns_name(self) -> Optional[pulumi.Input[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")

    @vpc_endpoint_dns_name.setter
    def vpc_endpoint_dns_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vpc_endpoint_dns_name", value)

    @property
    @pulumi.getter(name="vpcEndpointId")
    def vpc_endpoint_id(self) -> Optional[pulumi.Input[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")

    @vpc_endpoint_id.setter
    def vpc_endpoint_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vpc_endpoint_id", value)


if not MYPY:
    class AccessPointAzureEgressPrivateLinkEndpointArgsDict(TypedDict):
        private_link_service_resource_id: pulumi.Input[str]
        """
        Resource ID of the Azure Private Link service.
        """
        private_endpoint_custom_dns_config_domains: NotRequired[pulumi.Input[Sequence[pulumi.Input[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"]`.
        """
        private_endpoint_domain: NotRequired[pulumi.Input[str]]
        """
        (Required String) Domain of the Private Endpoint (if any) that is connected to the Private Link service.
        """
        private_endpoint_ip_address: NotRequired[pulumi.Input[str]]
        """
        (Required String) IP address of the Private Endpoint (if any) that is connected to the Private Link service.
        """
        private_endpoint_resource_id: NotRequired[pulumi.Input[str]]
        """
        (Required String) Resource ID of the Private Endpoint (if any) that is connected to the Private Link service.
        """
        private_link_subresource_name: NotRequired[pulumi.Input[str]]
        """
        Name of the subresource for the Private Endpoint to connect to.
        """
elif False:
    AccessPointAzureEgressPrivateLinkEndpointArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccessPointAzureEgressPrivateLinkEndpointArgs:
    def __init__(__self__, *,
                 private_link_service_resource_id: pulumi.Input[str],
                 private_endpoint_custom_dns_config_domains: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 private_endpoint_domain: Optional[pulumi.Input[str]] = None,
                 private_endpoint_ip_address: Optional[pulumi.Input[str]] = None,
                 private_endpoint_resource_id: Optional[pulumi.Input[str]] = None,
                 private_link_subresource_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] private_link_service_resource_id: Resource ID of the Azure Private Link service.
        :param pulumi.Input[Sequence[pulumi.Input[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 pulumi.Input[str] private_endpoint_domain: (Required String) Domain of the Private Endpoint (if any) that is connected to the Private Link service.
        :param pulumi.Input[str] private_endpoint_ip_address: (Required String) IP address of the Private Endpoint (if any) that is connected to the Private Link service.
        :param pulumi.Input[str] private_endpoint_resource_id: (Required String) Resource ID of the Private Endpoint (if any) that is connected to the Private Link service.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        Resource ID of the Azure Private Link service.
        """
        return pulumi.get(self, "private_link_service_resource_id")

    @private_link_service_resource_id.setter
    def private_link_service_resource_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "private_link_service_resource_id", value)

    @property
    @pulumi.getter(name="privateEndpointCustomDnsConfigDomains")
    def private_endpoint_custom_dns_config_domains(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[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")

    @private_endpoint_custom_dns_config_domains.setter
    def private_endpoint_custom_dns_config_domains(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "private_endpoint_custom_dns_config_domains", value)

    @property
    @pulumi.getter(name="privateEndpointDomain")
    def private_endpoint_domain(self) -> Optional[pulumi.Input[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")

    @private_endpoint_domain.setter
    def private_endpoint_domain(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "private_endpoint_domain", value)

    @property
    @pulumi.getter(name="privateEndpointIpAddress")
    def private_endpoint_ip_address(self) -> Optional[pulumi.Input[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")

    @private_endpoint_ip_address.setter
    def private_endpoint_ip_address(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "private_endpoint_ip_address", value)

    @property
    @pulumi.getter(name="privateEndpointResourceId")
    def private_endpoint_resource_id(self) -> Optional[pulumi.Input[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")

    @private_endpoint_resource_id.setter
    def private_endpoint_resource_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "private_endpoint_resource_id", value)

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

    @private_link_subresource_name.setter
    def private_link_subresource_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "private_link_subresource_name", value)


if not MYPY:
    class AccessPointEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment that the Access Point belongs to, for example, `env-abc123`.
        """
elif False:
    AccessPointEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccessPointEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Environment that the Access Point belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class AccessPointGatewayArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the gateway to which the Access Point belongs, for example, `gw-abc123`.
        """
elif False:
    AccessPointGatewayArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccessPointGatewayArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the gateway to which the Access Point belongs, for example, `gw-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class ApiKeyManagedResourceArgsDict(TypedDict):
        api_version: pulumi.Input[str]
        """
        The API group and version of the managed resource that the API Key associated with, for example, `cmk/v2`.
        """
        environment: pulumi.Input['ApiKeyManagedResourceEnvironmentArgsDict']
        """
        Environment objects represent an isolated namespace for your Confluent resources for organizational purposes.
        """
        id: pulumi.Input[str]
        """
        The ID of the managed resource that the API Key associated with, for example, `lkc-abc123`.
        """
        kind: pulumi.Input[str]
        """
        The kind of the managed resource that the API Key associated with, for example, `Cluster`.
        """
elif False:
    ApiKeyManagedResourceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ApiKeyManagedResourceArgs:
    def __init__(__self__, *,
                 api_version: pulumi.Input[str],
                 environment: pulumi.Input['ApiKeyManagedResourceEnvironmentArgs'],
                 id: pulumi.Input[str],
                 kind: pulumi.Input[str]):
        """
        :param pulumi.Input[str] api_version: The API group and version of the managed resource that the API Key associated with, for example, `cmk/v2`.
        :param pulumi.Input['ApiKeyManagedResourceEnvironmentArgs'] environment: Environment objects represent an isolated namespace for your Confluent resources for organizational purposes.
        :param pulumi.Input[str] id: The ID of the managed resource that the API Key associated with, for example, `lkc-abc123`.
        :param pulumi.Input[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__, "environment", environment)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "kind", kind)

    @property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> pulumi.Input[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")

    @api_version.setter
    def api_version(self, value: pulumi.Input[str]):
        pulumi.set(self, "api_version", value)

    @property
    @pulumi.getter
    def environment(self) -> pulumi.Input['ApiKeyManagedResourceEnvironmentArgs']:
        """
        Environment objects represent an isolated namespace for your Confluent resources for organizational purposes.
        """
        return pulumi.get(self, "environment")

    @environment.setter
    def environment(self, value: pulumi.Input['ApiKeyManagedResourceEnvironmentArgs']):
        pulumi.set(self, "environment", value)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)

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

    @kind.setter
    def kind(self, value: pulumi.Input[str]):
        pulumi.set(self, "kind", value)


if not MYPY:
    class ApiKeyManagedResourceEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment that the managed resource belongs to, for example, `env-abc123`.
        """
elif False:
    ApiKeyManagedResourceEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ApiKeyManagedResourceEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Environment that the managed resource belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class ApiKeyOwnerArgsDict(TypedDict):
        api_version: pulumi.Input[str]
        """
        The API group and version of the owner that the API Key belongs to, for example, `iam/v2`.
        """
        id: pulumi.Input[str]
        """
        The ID of the owner that the API Key belongs to, for example, `sa-abc123` or `u-abc123`.
        """
        kind: pulumi.Input[str]
        """
        The kind of the owner that the API Key belongs to, for example, `ServiceAccount` or `User`.
        """
elif False:
    ApiKeyOwnerArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ApiKeyOwnerArgs:
    def __init__(__self__, *,
                 api_version: pulumi.Input[str],
                 id: pulumi.Input[str],
                 kind: pulumi.Input[str]):
        """
        :param pulumi.Input[str] api_version: The API group and version of the owner that the API Key belongs to, for example, `iam/v2`.
        :param pulumi.Input[str] id: The ID of the owner that the API Key belongs to, for example, `sa-abc123` or `u-abc123`.
        :param pulumi.Input[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) -> pulumi.Input[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")

    @api_version.setter
    def api_version(self, value: pulumi.Input[str]):
        pulumi.set(self, "api_version", value)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)

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

    @kind.setter
    def kind(self, value: pulumi.Input[str]):
        pulumi.set(self, "kind", value)


if not MYPY:
    class BusinessMetadataAttributeDefinitionArgsDict(TypedDict):
        name: pulumi.Input[str]
        """
        The name of the attribute.
        """
        default_value: NotRequired[pulumi.Input[str]]
        """
        The default value of this attribute.
        """
        description: NotRequired[pulumi.Input[str]]
        """
        The description of this attribute.
        """
        is_optional: NotRequired[pulumi.Input[bool]]
        """
        An optional flag to control whether the attribute should be optional or required. The default value is `false`.
        """
        options: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[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`.
        """
        type: NotRequired[pulumi.Input[str]]
        """
        (Required String) The type of the attribute, it always returns `string`.
        """
elif False:
    BusinessMetadataAttributeDefinitionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class BusinessMetadataAttributeDefinitionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 default_value: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 is_optional: Optional[pulumi.Input[bool]] = None,
                 options: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The name of the attribute.
        :param pulumi.Input[str] default_value: The default value of this attribute.
        :param pulumi.Input[str] description: The description of this attribute.
        :param pulumi.Input[bool] is_optional: An optional flag to control whether the attribute should be optional or required. The default value is `false`.
        :param pulumi.Input[Mapping[str, pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The name of the attribute.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

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

    @default_value.setter
    def default_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "default_value", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter(name="isOptional")
    def is_optional(self) -> Optional[pulumi.Input[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")

    @is_optional.setter
    def is_optional(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "is_optional", value)

    @property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[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")

    @options.setter
    def options(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "options", value)

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

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


if not MYPY:
    class BusinessMetadataBindingCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Schema Registry API Key.
        """
        secret: pulumi.Input[str]
        """
        The Schema Registry API Secret.
        """
elif False:
    BusinessMetadataBindingCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class BusinessMetadataBindingCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Schema Registry API Key.
        :param pulumi.Input[str] secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class BusinessMetadataBindingSchemaRegistryClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    BusinessMetadataBindingSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class BusinessMetadataBindingSchemaRegistryClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class BusinessMetadataCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Schema Registry API Key.
        """
        secret: pulumi.Input[str]
        """
        The Cluster API Secret for your Confluent Cloud cluster.
        """
elif False:
    BusinessMetadataCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class BusinessMetadataCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Schema Registry API Key.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class BusinessMetadataSchemaRegistryClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    BusinessMetadataSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class BusinessMetadataSchemaRegistryClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class ByokKeyAwsArgsDict(TypedDict):
        key_arn: pulumi.Input[str]
        """
        The Amazon Resource Name (ARN) of an AWS KMS key.
        """
        roles: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        (Optional List of Strings) The Amazon Resource Names (ARNs) of IAM Roles created for this key-environment
        """
elif False:
    ByokKeyAwsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ByokKeyAwsArgs:
    def __init__(__self__, *,
                 key_arn: pulumi.Input[str],
                 roles: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] key_arn: The Amazon Resource Name (ARN) of an AWS KMS key.
        :param pulumi.Input[Sequence[pulumi.Input[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) -> pulumi.Input[str]:
        """
        The Amazon Resource Name (ARN) of an AWS KMS key.
        """
        return pulumi.get(self, "key_arn")

    @key_arn.setter
    def key_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "key_arn", value)

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

    @roles.setter
    def roles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "roles", value)


if not MYPY:
    class ByokKeyAzureArgsDict(TypedDict):
        key_identifier: pulumi.Input[str]
        """
        The unique Key Object Identifier URL of an Azure Key Vault key.
        """
        key_vault_id: pulumi.Input[str]
        """
        Key Vault ID containing the key.
        """
        tenant_id: pulumi.Input[str]
        """
        Tenant ID (uuid) hosting the Key Vault containing the key.
        """
        application_id: NotRequired[pulumi.Input[str]]
        """
        (Optional String) The Application ID created for this key-environment combination.
        """
elif False:
    ByokKeyAzureArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ByokKeyAzureArgs:
    def __init__(__self__, *,
                 key_identifier: pulumi.Input[str],
                 key_vault_id: pulumi.Input[str],
                 tenant_id: pulumi.Input[str],
                 application_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] key_identifier: The unique Key Object Identifier URL of an Azure Key Vault key.
        :param pulumi.Input[str] key_vault_id: Key Vault ID containing the key.
        :param pulumi.Input[str] tenant_id: Tenant ID (uuid) hosting the Key Vault containing the key.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The unique Key Object Identifier URL of an Azure Key Vault key.
        """
        return pulumi.get(self, "key_identifier")

    @key_identifier.setter
    def key_identifier(self, value: pulumi.Input[str]):
        pulumi.set(self, "key_identifier", value)

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

    @key_vault_id.setter
    def key_vault_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "key_vault_id", value)

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

    @tenant_id.setter
    def tenant_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "tenant_id", value)

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

    @application_id.setter
    def application_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "application_id", value)


if not MYPY:
    class ByokKeyGcpArgsDict(TypedDict):
        key_id: pulumi.Input[str]
        """
        The Google Cloud Platform key ID.
        """
        security_group: NotRequired[pulumi.Input[str]]
        """
        (Optional String) The Google security group created for this key.
        """
elif False:
    ByokKeyGcpArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ByokKeyGcpArgs:
    def __init__(__self__, *,
                 key_id: pulumi.Input[str],
                 security_group: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] key_id: The Google Cloud Platform key ID.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The Google Cloud Platform key ID.
        """
        return pulumi.get(self, "key_id")

    @key_id.setter
    def key_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "key_id", value)

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

    @security_group.setter
    def security_group(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "security_group", value)


if not MYPY:
    class CatalogEntityAttributesCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Schema Registry API Key.
        """
        secret: pulumi.Input[str]
        """
        The Schema Registry API Secret.
        """
elif False:
    CatalogEntityAttributesCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CatalogEntityAttributesCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Schema Registry API Key.
        :param pulumi.Input[str] secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class CatalogEntityAttributesSchemaRegistryClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    CatalogEntityAttributesSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CatalogEntityAttributesSchemaRegistryClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class CertificatePoolCertificateAuthorityArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Certificate Authority for this Certificate Pool, for example, `op-123abc`.
        """
elif False:
    CertificatePoolCertificateAuthorityArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CertificatePoolCertificateAuthorityArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Certificate Authority for this Certificate Pool, for example, `op-123abc`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class ClusterLinkDestinationKafkaClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the destination Kafka cluster, for example, `lkc-abc123`.
        """
        bootstrap_endpoint: NotRequired[pulumi.Input[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`).
        """
        credentials: NotRequired[pulumi.Input['ClusterLinkDestinationKafkaClusterCredentialsArgsDict']]
        """
        The Kafka API Credentials.
        """
        rest_endpoint: NotRequired[pulumi.Input[str]]
        """
        The REST endpoint of the destination Kafka cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
elif False:
    ClusterLinkDestinationKafkaClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterLinkDestinationKafkaClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 bootstrap_endpoint: Optional[pulumi.Input[str]] = None,
                 credentials: Optional[pulumi.Input['ClusterLinkDestinationKafkaClusterCredentialsArgs']] = None,
                 rest_endpoint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] id: The ID of the destination Kafka cluster, for example, `lkc-abc123`.
        :param pulumi.Input[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 pulumi.Input['ClusterLinkDestinationKafkaClusterCredentialsArgs'] credentials: The Kafka API Credentials.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the destination Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="bootstrapEndpoint")
    def bootstrap_endpoint(self) -> Optional[pulumi.Input[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")

    @bootstrap_endpoint.setter
    def bootstrap_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "bootstrap_endpoint", value)

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

    @credentials.setter
    def credentials(self, value: Optional[pulumi.Input['ClusterLinkDestinationKafkaClusterCredentialsArgs']]):
        pulumi.set(self, "credentials", value)

    @property
    @pulumi.getter(name="restEndpoint")
    def rest_endpoint(self) -> Optional[pulumi.Input[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")

    @rest_endpoint.setter
    def rest_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "rest_endpoint", value)


if not MYPY:
    class ClusterLinkDestinationKafkaClusterCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Kafka API Key.
        """
        secret: pulumi.Input[str]
        """
        The Kafka API Secret.
        """
elif False:
    ClusterLinkDestinationKafkaClusterCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterLinkDestinationKafkaClusterCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Kafka API Key.
        :param pulumi.Input[str] secret: The Kafka API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class ClusterLinkLocalKafkaClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the local Kafka cluster, for example, `lkc-abc123`.
        """
        bootstrap_endpoint: NotRequired[pulumi.Input[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`).
        """
        credentials: NotRequired[pulumi.Input['ClusterLinkLocalKafkaClusterCredentialsArgsDict']]
        """
        The Kafka API Credentials.
        """
        rest_endpoint: NotRequired[pulumi.Input[str]]
        """
        The REST endpoint of the local Kafka cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
elif False:
    ClusterLinkLocalKafkaClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterLinkLocalKafkaClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 bootstrap_endpoint: Optional[pulumi.Input[str]] = None,
                 credentials: Optional[pulumi.Input['ClusterLinkLocalKafkaClusterCredentialsArgs']] = None,
                 rest_endpoint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] id: The ID of the local Kafka cluster, for example, `lkc-abc123`.
        :param pulumi.Input[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 pulumi.Input['ClusterLinkLocalKafkaClusterCredentialsArgs'] credentials: The Kafka API Credentials.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the local Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="bootstrapEndpoint")
    def bootstrap_endpoint(self) -> Optional[pulumi.Input[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")

    @bootstrap_endpoint.setter
    def bootstrap_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "bootstrap_endpoint", value)

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

    @credentials.setter
    def credentials(self, value: Optional[pulumi.Input['ClusterLinkLocalKafkaClusterCredentialsArgs']]):
        pulumi.set(self, "credentials", value)

    @property
    @pulumi.getter(name="restEndpoint")
    def rest_endpoint(self) -> Optional[pulumi.Input[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")

    @rest_endpoint.setter
    def rest_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "rest_endpoint", value)


if not MYPY:
    class ClusterLinkLocalKafkaClusterCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Kafka API Key.
        """
        secret: pulumi.Input[str]
        """
        The Kafka API Secret.
        """
elif False:
    ClusterLinkLocalKafkaClusterCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterLinkLocalKafkaClusterCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Kafka API Key.
        :param pulumi.Input[str] secret: The Kafka API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class ClusterLinkRemoteKafkaClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the remote Kafka cluster, for example, `lkc-abc123`.
        """
        bootstrap_endpoint: NotRequired[pulumi.Input[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`).
        """
        credentials: NotRequired[pulumi.Input['ClusterLinkRemoteKafkaClusterCredentialsArgsDict']]
        """
        The Kafka API Credentials.
        """
        rest_endpoint: NotRequired[pulumi.Input[str]]
        """
        The REST endpoint of the remote Kafka cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
elif False:
    ClusterLinkRemoteKafkaClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterLinkRemoteKafkaClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 bootstrap_endpoint: Optional[pulumi.Input[str]] = None,
                 credentials: Optional[pulumi.Input['ClusterLinkRemoteKafkaClusterCredentialsArgs']] = None,
                 rest_endpoint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] id: The ID of the remote Kafka cluster, for example, `lkc-abc123`.
        :param pulumi.Input[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 pulumi.Input['ClusterLinkRemoteKafkaClusterCredentialsArgs'] credentials: The Kafka API Credentials.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the remote Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="bootstrapEndpoint")
    def bootstrap_endpoint(self) -> Optional[pulumi.Input[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")

    @bootstrap_endpoint.setter
    def bootstrap_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "bootstrap_endpoint", value)

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

    @credentials.setter
    def credentials(self, value: Optional[pulumi.Input['ClusterLinkRemoteKafkaClusterCredentialsArgs']]):
        pulumi.set(self, "credentials", value)

    @property
    @pulumi.getter(name="restEndpoint")
    def rest_endpoint(self) -> Optional[pulumi.Input[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")

    @rest_endpoint.setter
    def rest_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "rest_endpoint", value)


if not MYPY:
    class ClusterLinkRemoteKafkaClusterCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Kafka API Key.
        """
        secret: pulumi.Input[str]
        """
        The Kafka API Secret.
        """
elif False:
    ClusterLinkRemoteKafkaClusterCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterLinkRemoteKafkaClusterCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Kafka API Key.
        :param pulumi.Input[str] secret: The Kafka API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class ClusterLinkSourceKafkaClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the source Kafka cluster, for example, `lkc-abc123`.
        """
        bootstrap_endpoint: NotRequired[pulumi.Input[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`).
        """
        credentials: NotRequired[pulumi.Input['ClusterLinkSourceKafkaClusterCredentialsArgsDict']]
        """
        The Kafka API Credentials.
        """
        rest_endpoint: NotRequired[pulumi.Input[str]]
        """
        The REST endpoint of the source Kafka cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
elif False:
    ClusterLinkSourceKafkaClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterLinkSourceKafkaClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 bootstrap_endpoint: Optional[pulumi.Input[str]] = None,
                 credentials: Optional[pulumi.Input['ClusterLinkSourceKafkaClusterCredentialsArgs']] = None,
                 rest_endpoint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] id: The ID of the source Kafka cluster, for example, `lkc-abc123`.
        :param pulumi.Input[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 pulumi.Input['ClusterLinkSourceKafkaClusterCredentialsArgs'] credentials: The Kafka API Credentials.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the source Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="bootstrapEndpoint")
    def bootstrap_endpoint(self) -> Optional[pulumi.Input[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")

    @bootstrap_endpoint.setter
    def bootstrap_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "bootstrap_endpoint", value)

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

    @credentials.setter
    def credentials(self, value: Optional[pulumi.Input['ClusterLinkSourceKafkaClusterCredentialsArgs']]):
        pulumi.set(self, "credentials", value)

    @property
    @pulumi.getter(name="restEndpoint")
    def rest_endpoint(self) -> Optional[pulumi.Input[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")

    @rest_endpoint.setter
    def rest_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "rest_endpoint", value)


if not MYPY:
    class ClusterLinkSourceKafkaClusterCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Kafka API Key.
        """
        secret: pulumi.Input[str]
        """
        The Kafka API Secret.
        """
elif False:
    ClusterLinkSourceKafkaClusterCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClusterLinkSourceKafkaClusterCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Kafka API Key.
        :param pulumi.Input[str] secret: The Kafka API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class ConnectorEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment that the connector belongs to, for example, `env-abc123`.
        """
elif False:
    ConnectorEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ConnectorEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Environment that the connector belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class ConnectorKafkaClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Kafka cluster that the connector belongs to, for example, `lkc-abc123`.
        """
elif False:
    ConnectorKafkaClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ConnectorKafkaClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Kafka cluster that the connector belongs to, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class DnsForwarderEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment that the DNS Forwarder belongs to, for example, `env-abc123`.
        """
elif False:
    DnsForwarderEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DnsForwarderEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Environment that the DNS Forwarder belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class DnsForwarderForwardViaIpArgsDict(TypedDict):
        dns_server_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        List of IP addresses of the DNS server.
        """
elif False:
    DnsForwarderForwardViaIpArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DnsForwarderForwardViaIpArgs:
    def __init__(__self__, *,
                 dns_server_ips: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[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[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of IP addresses of the DNS server.
        """
        return pulumi.get(self, "dns_server_ips")

    @dns_server_ips.setter
    def dns_server_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "dns_server_ips", value)


if not MYPY:
    class DnsForwarderGatewayArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the gateway to which the DNS Forwarder belongs, for example, `gw-abc123`.
        """
elif False:
    DnsForwarderGatewayArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DnsForwarderGatewayArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the gateway to which the DNS Forwarder belongs, for example, `gw-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class DnsRecordEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment that the DNS Record belongs to, for example, `env-abc123`.
        """
elif False:
    DnsRecordEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DnsRecordEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Environment that the DNS Record belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class DnsRecordGatewayArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the gateway to which the DNS Record belongs, for example, `gw-abc123`.
        """
elif False:
    DnsRecordGatewayArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DnsRecordGatewayArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the gateway to which the DNS Record belongs, for example, `gw-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class DnsRecordPrivateLinkAccessPointArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Private Link access point to which the DNS Record is associated, for example `ap-123abc`.
        """
elif False:
    DnsRecordPrivateLinkAccessPointArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DnsRecordPrivateLinkAccessPointArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[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")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class EnvironmentStreamGovernanceArgsDict(TypedDict):
        package: pulumi.Input[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`.
        """
elif False:
    EnvironmentStreamGovernanceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class EnvironmentStreamGovernanceArgs:
    def __init__(__self__, *,
                 package: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[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")

    @package.setter
    def package(self, value: pulumi.Input[str]):
        pulumi.set(self, "package", value)


if not MYPY:
    class FlinkComputePoolEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment that the Flink Compute Pool belongs to, for example, `env-abc123`.
        """
elif False:
    FlinkComputePoolEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkComputePoolEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Environment that the Flink Compute Pool belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class FlinkStatementComputePoolArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Flink Compute Pool, for example, `lfcp-abc123`.
        """
elif False:
    FlinkStatementComputePoolArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkStatementComputePoolArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Flink Compute Pool, for example, `lfcp-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class FlinkStatementCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Flink API Key.
        """
        secret: pulumi.Input[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.
        """
elif False:
    FlinkStatementCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkStatementCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Flink API Key.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The Flink API Key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def secret(self) -> pulumi.Input[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")

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class FlinkStatementEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment, for example, `env-abc123`.
        """
elif False:
    FlinkStatementEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkStatementEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Environment, for example, `env-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class FlinkStatementOrganizationArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Organization, for example, `1111aaaa-11aa-11aa-11aa-111111aaaaaa`.
        """
elif False:
    FlinkStatementOrganizationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkStatementOrganizationArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Organization, for example, `1111aaaa-11aa-11aa-11aa-111111aaaaaa`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class FlinkStatementPrincipalArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Principal the Flink Statement runs as, for example, `sa-abc123`.
        """
elif False:
    FlinkStatementPrincipalArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkStatementPrincipalArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Principal the Flink Statement runs as, for example, `sa-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class IdentityPoolIdentityProviderArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Identity Provider associated with the Identity Pool, for example, `op-abc123`.
        """
elif False:
    IdentityPoolIdentityProviderArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class IdentityPoolIdentityProviderArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Identity Provider associated with the Identity Pool, for example, `op-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class InvitationCreatorArgsDict(TypedDict):
        id: NotRequired[pulumi.Input[str]]
        """
        (Required String) The id of invitation creator.
        """
elif False:
    InvitationCreatorArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InvitationCreatorArgs:
    def __init__(__self__, *,
                 id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        (Required String) The id of invitation creator.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "id", value)


if not MYPY:
    class InvitationUserArgsDict(TypedDict):
        id: NotRequired[pulumi.Input[str]]
        """
        (Required String) The id of invitation creator.
        """
elif False:
    InvitationUserArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InvitationUserArgs:
    def __init__(__self__, *,
                 id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        (Required String) The id of invitation creator.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "id", value)


if not MYPY:
    class KafkaAclCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Kafka API Key.
        """
        secret: pulumi.Input[str]
        """
        The Kafka API Secret.
        """
elif False:
    KafkaAclCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaAclCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Kafka API Key.
        :param pulumi.Input[str] secret: The Kafka API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class KafkaAclKafkaClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Kafka cluster, for example, `lkc-abc123`.
        """
elif False:
    KafkaAclKafkaClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaAclKafkaClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Kafka cluster, for example, `lkc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class KafkaClientQuotaEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[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.
        """
elif False:
    KafkaClientQuotaEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaClientQuotaEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[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")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class KafkaClientQuotaKafkaClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Kafka Cluster where the Kafka Client Quota is applied, for example, `lkc-abc123`.
        """
elif False:
    KafkaClientQuotaKafkaClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaClientQuotaKafkaClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Kafka Cluster where the Kafka Client Quota is applied, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class KafkaClientQuotaThroughputArgsDict(TypedDict):
        egress_byte_rate: pulumi.Input[str]
        """
        The egress throughput limit in bytes per second.
        """
        ingress_byte_rate: pulumi.Input[str]
        """
        The ingress throughput limit in bytes per second.
        """
elif False:
    KafkaClientQuotaThroughputArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaClientQuotaThroughputArgs:
    def __init__(__self__, *,
                 egress_byte_rate: pulumi.Input[str],
                 ingress_byte_rate: pulumi.Input[str]):
        """
        :param pulumi.Input[str] egress_byte_rate: The egress throughput limit in bytes per second.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The egress throughput limit in bytes per second.
        """
        return pulumi.get(self, "egress_byte_rate")

    @egress_byte_rate.setter
    def egress_byte_rate(self, value: pulumi.Input[str]):
        pulumi.set(self, "egress_byte_rate", value)

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

    @ingress_byte_rate.setter
    def ingress_byte_rate(self, value: pulumi.Input[str]):
        pulumi.set(self, "ingress_byte_rate", value)


if not MYPY:
    class KafkaClusterBasicArgsDict(TypedDict):
        pass
elif False:
    KafkaClusterBasicArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaClusterBasicArgs:
    def __init__(__self__):
        pass


if not MYPY:
    class KafkaClusterByokKeyArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Confluent key that is used to encrypt the data in the Kafka cluster, for example, `cck-lye5m`.
        """
elif False:
    KafkaClusterByokKeyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaClusterByokKeyArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[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")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class KafkaClusterConfigCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Kafka API Key.
        """
        secret: pulumi.Input[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.
        """
elif False:
    KafkaClusterConfigCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaClusterConfigCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Kafka API Key.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The Kafka API Key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def secret(self) -> pulumi.Input[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")

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class KafkaClusterConfigKafkaClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Dedicated Kafka cluster, for example, `lkc-abc123`.
        """
elif False:
    KafkaClusterConfigKafkaClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaClusterConfigKafkaClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Dedicated Kafka cluster, for example, `lkc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class KafkaClusterDedicatedArgsDict(TypedDict):
        cku: pulumi.Input[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` block is in an [Early Access lifecycle stage](https://docs.confluent.io/cloud/current/api.html#section/Versioning/API-Lifecycle-Policy).

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

        !> **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.
        """
        encryption_key: NotRequired[pulumi.Input[str]]
        """
        The ID of the encryption key that is used to encrypt the data in the Kafka cluster.
        """
        zones: NotRequired[pulumi.Input[Sequence[pulumi.Input[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`.
        """
elif False:
    KafkaClusterDedicatedArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaClusterDedicatedArgs:
    def __init__(__self__, *,
                 cku: pulumi.Input[int],
                 encryption_key: Optional[pulumi.Input[str]] = None,
                 zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[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` block is in an [Early Access lifecycle stage](https://docs.confluent.io/cloud/current/api.html#section/Versioning/API-Lifecycle-Policy).
               
               > **Note:** The `freight` Kafka cluster type is only available in AWS currently.
               
               !> **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 pulumi.Input[str] encryption_key: The ID of the encryption key that is used to encrypt the data in the Kafka cluster.
        :param pulumi.Input[Sequence[pulumi.Input[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) -> pulumi.Input[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` block is in an [Early Access lifecycle stage](https://docs.confluent.io/cloud/current/api.html#section/Versioning/API-Lifecycle-Policy).

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

        !> **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")

    @cku.setter
    def cku(self, value: pulumi.Input[int]):
        pulumi.set(self, "cku", value)

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

    @encryption_key.setter
    def encryption_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "encryption_key", value)

    @property
    @pulumi.getter
    def zones(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[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")

    @zones.setter
    def zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "zones", value)


if not MYPY:
    class KafkaClusterEnterpriseArgsDict(TypedDict):
        pass
elif False:
    KafkaClusterEnterpriseArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaClusterEnterpriseArgs:
    def __init__(__self__):
        pass


if not MYPY:
    class KafkaClusterEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment that the Kafka cluster belongs to, for example, `env-abc123`.
        """
elif False:
    KafkaClusterEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaClusterEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Environment that the Kafka cluster belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class KafkaClusterFreightArgsDict(TypedDict):
        zones: NotRequired[pulumi.Input[Sequence[pulumi.Input[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`.
        """
elif False:
    KafkaClusterFreightArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaClusterFreightArgs:
    def __init__(__self__, *,
                 zones: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[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[pulumi.Input[Sequence[pulumi.Input[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")

    @zones.setter
    def zones(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "zones", value)


if not MYPY:
    class KafkaClusterNetworkArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Network that the Kafka cluster belongs to, for example, `n-abc123`.
        """
elif False:
    KafkaClusterNetworkArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaClusterNetworkArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Network that the Kafka cluster belongs to, for example, `n-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class KafkaClusterStandardArgsDict(TypedDict):
        pass
elif False:
    KafkaClusterStandardArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaClusterStandardArgs:
    def __init__(__self__):
        pass


if not MYPY:
    class KafkaMirrorTopicClusterLinkArgsDict(TypedDict):
        link_name: pulumi.Input[str]
        """
        The name of the cluster link to attach to the mirror topic, for example, `my-cluster-link`.
        """
elif False:
    KafkaMirrorTopicClusterLinkArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaMirrorTopicClusterLinkArgs:
    def __init__(__self__, *,
                 link_name: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The name of the cluster link to attach to the mirror topic, for example, `my-cluster-link`.
        """
        return pulumi.get(self, "link_name")

    @link_name.setter
    def link_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "link_name", value)


if not MYPY:
    class KafkaMirrorTopicKafkaClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the destination Kafka cluster, for example, `lkc-abc123`.
        """
        credentials: NotRequired[pulumi.Input['KafkaMirrorTopicKafkaClusterCredentialsArgsDict']]
        """
        The Kafka API Credentials.
        """
        rest_endpoint: NotRequired[pulumi.Input[str]]
        """
        The REST endpoint of the destination Kafka cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
elif False:
    KafkaMirrorTopicKafkaClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaMirrorTopicKafkaClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 credentials: Optional[pulumi.Input['KafkaMirrorTopicKafkaClusterCredentialsArgs']] = None,
                 rest_endpoint: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] id: The ID of the destination Kafka cluster, for example, `lkc-abc123`.
        :param pulumi.Input['KafkaMirrorTopicKafkaClusterCredentialsArgs'] credentials: The Kafka API Credentials.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the destination Kafka cluster, for example, `lkc-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)

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

    @credentials.setter
    def credentials(self, value: Optional[pulumi.Input['KafkaMirrorTopicKafkaClusterCredentialsArgs']]):
        pulumi.set(self, "credentials", value)

    @property
    @pulumi.getter(name="restEndpoint")
    def rest_endpoint(self) -> Optional[pulumi.Input[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")

    @rest_endpoint.setter
    def rest_endpoint(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "rest_endpoint", value)


if not MYPY:
    class KafkaMirrorTopicKafkaClusterCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Kafka API Key.
        """
        secret: pulumi.Input[str]
        """
        The Kafka API Secret.
        """
elif False:
    KafkaMirrorTopicKafkaClusterCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaMirrorTopicKafkaClusterCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Kafka API Key.
        :param pulumi.Input[str] secret: The Kafka API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class KafkaMirrorTopicSourceKafkaTopicArgsDict(TypedDict):
        topic_name: pulumi.Input[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.
        """
elif False:
    KafkaMirrorTopicSourceKafkaTopicArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaMirrorTopicSourceKafkaTopicArgs:
    def __init__(__self__, *,
                 topic_name: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[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")

    @topic_name.setter
    def topic_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "topic_name", value)


if not MYPY:
    class KafkaTopicCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Kafka API Key.
        """
        secret: pulumi.Input[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.
        """
elif False:
    KafkaTopicCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaTopicCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Kafka API Key.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The Kafka API Key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def secret(self) -> pulumi.Input[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")

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class KafkaTopicKafkaClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Kafka cluster, for example, `lkc-abc123`.
        """
elif False:
    KafkaTopicKafkaClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaTopicKafkaClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Kafka cluster, for example, `lkc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class KsqlClusterCredentialIdentityArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the associated service or user account, for example, `sa-abc123`.
        """
elif False:
    KsqlClusterCredentialIdentityArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KsqlClusterCredentialIdentityArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the associated service or user account, for example, `sa-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class KsqlClusterEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the associated Environment, for example, `env-xyz456`.
        """
elif False:
    KsqlClusterEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KsqlClusterEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the associated Environment, for example, `env-xyz456`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class KsqlClusterKafkaClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the associated Kafka cluster, for example, `lkc-abc123`.
        """
elif False:
    KsqlClusterKafkaClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KsqlClusterKafkaClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the associated Kafka cluster, for example, `lkc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class NetworkAwArgsDict(TypedDict):
        account: NotRequired[pulumi.Input[str]]
        """
        (Required String) The AWS account ID associated with the Confluent Cloud VPC.
        """
        private_link_endpoint_service: NotRequired[pulumi.Input[str]]
        """
        (Optional String) The endpoint service of the Confluent Cloud VPC (used for PrivateLink) if available.
        """
        vpc: NotRequired[pulumi.Input[str]]
        """
        (Required String) The Confluent Cloud VPC ID.
        """
elif False:
    NetworkAwArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NetworkAwArgs:
    def __init__(__self__, *,
                 account: Optional[pulumi.Input[str]] = None,
                 private_link_endpoint_service: Optional[pulumi.Input[str]] = None,
                 vpc: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] account: (Required String) The AWS account ID associated with the Confluent Cloud VPC.
        :param pulumi.Input[str] private_link_endpoint_service: (Optional String) The endpoint service of the Confluent Cloud VPC (used for PrivateLink) if available.
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        (Required String) The AWS account ID associated with the Confluent Cloud VPC.
        """
        return pulumi.get(self, "account")

    @account.setter
    def account(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "account", value)

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

    @private_link_endpoint_service.setter
    def private_link_endpoint_service(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "private_link_endpoint_service", value)

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

    @vpc.setter
    def vpc(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vpc", value)


if not MYPY:
    class NetworkAzureArgsDict(TypedDict):
        private_link_service_aliases: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[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`.
        """
elif False:
    NetworkAzureArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NetworkAzureArgs:
    def __init__(__self__, *,
                 private_link_service_aliases: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Mapping[str, pulumi.Input[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[pulumi.Input[Mapping[str, pulumi.Input[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")

    @private_link_service_aliases.setter
    def private_link_service_aliases(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "private_link_service_aliases", value)


if not MYPY:
    class NetworkDnsConfigArgsDict(TypedDict):
        resolution: pulumi.Input[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`.
        """
elif False:
    NetworkDnsConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NetworkDnsConfigArgs:
    def __init__(__self__, *,
                 resolution: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[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")

    @resolution.setter
    def resolution(self, value: pulumi.Input[str]):
        pulumi.set(self, "resolution", value)


if not MYPY:
    class NetworkEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment that the Network belongs to, for example, `env-abc123`.
        """
elif False:
    NetworkEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NetworkEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Environment that the Network belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class NetworkGatewayArgsDict(TypedDict):
        id: NotRequired[pulumi.Input[str]]
        """
        (Optional String) The ID of the Gateway, for example, `gw-abc123`.
        """
elif False:
    NetworkGatewayArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NetworkGatewayArgs:
    def __init__(__self__, *,
                 id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        (Optional String) The ID of the Gateway, for example, `gw-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "id", value)


if not MYPY:
    class NetworkGcpArgsDict(TypedDict):
        private_service_connect_service_attachments: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[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).
        """
        project: NotRequired[pulumi.Input[str]]
        """
        (Required String) The GCP Project ID associated with the Confluent Cloud VPC.
        """
        vpc_network: NotRequired[pulumi.Input[str]]
        """
        (Required String) The network name of the Confluent Cloud VPC.
        """
elif False:
    NetworkGcpArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NetworkGcpArgs:
    def __init__(__self__, *,
                 private_service_connect_service_attachments: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 project: Optional[pulumi.Input[str]] = None,
                 vpc_network: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Mapping[str, pulumi.Input[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 pulumi.Input[str] project: (Required String) The GCP Project ID associated with the Confluent Cloud VPC.
        :param pulumi.Input[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[pulumi.Input[Mapping[str, pulumi.Input[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")

    @private_service_connect_service_attachments.setter
    def private_service_connect_service_attachments(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "private_service_connect_service_attachments", value)

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

    @project.setter
    def project(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project", value)

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

    @vpc_network.setter
    def vpc_network(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vpc_network", value)


if not MYPY:
    class NetworkLinkEndpointEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment that the Network Link Endpoint belongs to, for example, `env-xyz456`.
        """
elif False:
    NetworkLinkEndpointEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NetworkLinkEndpointEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Environment that the Network Link Endpoint belongs to, for example, `env-xyz456`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class NetworkLinkEndpointNetworkArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Network that the Network Link Endpoint belongs to, for example, `n-abc123`.
        """
elif False:
    NetworkLinkEndpointNetworkArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NetworkLinkEndpointNetworkArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Network that the Network Link Endpoint belongs to, for example, `n-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class NetworkLinkEndpointNetworkLinkServiceArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Network Link Service, for example, `nls-g3e1ox`.
        """
elif False:
    NetworkLinkEndpointNetworkLinkServiceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NetworkLinkEndpointNetworkLinkServiceArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Network Link Service, for example, `nls-g3e1ox`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class NetworkLinkServiceAcceptArgsDict(TypedDict):
        environments: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        List of environments ids from which connections can be accepted. All networks within the list of environment will be allowed.
        """
        networks: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        List of network ids from which connections can be accepted.
        """
elif False:
    NetworkLinkServiceAcceptArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NetworkLinkServiceAcceptArgs:
    def __init__(__self__, *,
                 environments: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 networks: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] environments: List of environments ids from which connections can be accepted. All networks within the list of environment will be allowed.
        :param pulumi.Input[Sequence[pulumi.Input[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[pulumi.Input[Sequence[pulumi.Input[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")

    @environments.setter
    def environments(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "environments", value)

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

    @networks.setter
    def networks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "networks", value)


if not MYPY:
    class NetworkLinkServiceEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment that the Network Link Service belongs to, for example, `env-abc123`.
        """
elif False:
    NetworkLinkServiceEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NetworkLinkServiceEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Environment that the Network Link Service belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class NetworkLinkServiceNetworkArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Network that the Network Link Service belongs to, for example, `n-abc123`.
        """
elif False:
    NetworkLinkServiceNetworkArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NetworkLinkServiceNetworkArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Network that the Network Link Service belongs to, for example, `n-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class NetworkZoneInfoArgsDict(TypedDict):
        cidr: NotRequired[pulumi.Input[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.
        """
        zone_id: NotRequired[pulumi.Input[str]]
        """
        Cloud provider zone ID.
        """
elif False:
    NetworkZoneInfoArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class NetworkZoneInfoArgs:
    def __init__(__self__, *,
                 cidr: Optional[pulumi.Input[str]] = None,
                 zone_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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 pulumi.Input[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[pulumi.Input[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")

    @cidr.setter
    def cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cidr", value)

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

    @zone_id.setter
    def zone_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "zone_id", value)


if not MYPY:
    class PeeringAwsArgsDict(TypedDict):
        account: pulumi.Input[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**.
        """
        customer_region: pulumi.Input[str]
        """
        The region of the AWS peer VPC.
        """
        routes: pulumi.Input[Sequence[pulumi.Input[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.
        """
        vpc: pulumi.Input[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-`.
        """
elif False:
    PeeringAwsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PeeringAwsArgs:
    def __init__(__self__, *,
                 account: pulumi.Input[str],
                 customer_region: pulumi.Input[str],
                 routes: pulumi.Input[Sequence[pulumi.Input[str]]],
                 vpc: pulumi.Input[str]):
        """
        :param pulumi.Input[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 pulumi.Input[str] customer_region: The region of the AWS peer VPC.
        :param pulumi.Input[Sequence[pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[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")

    @account.setter
    def account(self, value: pulumi.Input[str]):
        pulumi.set(self, "account", value)

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

    @customer_region.setter
    def customer_region(self, value: pulumi.Input[str]):
        pulumi.set(self, "customer_region", value)

    @property
    @pulumi.getter
    def routes(self) -> pulumi.Input[Sequence[pulumi.Input[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")

    @routes.setter
    def routes(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "routes", value)

    @property
    @pulumi.getter
    def vpc(self) -> pulumi.Input[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")

    @vpc.setter
    def vpc(self, value: pulumi.Input[str]):
        pulumi.set(self, "vpc", value)


if not MYPY:
    class PeeringAzureArgsDict(TypedDict):
        customer_region: pulumi.Input[str]
        """
        The region of the Azure peer VNet.
        """
        tenant: pulumi.Input[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**.
        """
        vnet: pulumi.Input[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/).
        """
elif False:
    PeeringAzureArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PeeringAzureArgs:
    def __init__(__self__, *,
                 customer_region: pulumi.Input[str],
                 tenant: pulumi.Input[str],
                 vnet: pulumi.Input[str]):
        """
        :param pulumi.Input[str] customer_region: The region of the Azure peer VNet.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The region of the Azure peer VNet.
        """
        return pulumi.get(self, "customer_region")

    @customer_region.setter
    def customer_region(self, value: pulumi.Input[str]):
        pulumi.set(self, "customer_region", value)

    @property
    @pulumi.getter
    def tenant(self) -> pulumi.Input[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")

    @tenant.setter
    def tenant(self, value: pulumi.Input[str]):
        pulumi.set(self, "tenant", value)

    @property
    @pulumi.getter
    def vnet(self) -> pulumi.Input[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")

    @vnet.setter
    def vnet(self, value: pulumi.Input[str]):
        pulumi.set(self, "vnet", value)


if not MYPY:
    class PeeringEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment that the Peering belongs to, for example, `env-abc123`.
        """
elif False:
    PeeringEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PeeringEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Environment that the Peering belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class PeeringGcpArgsDict(TypedDict):
        project: pulumi.Input[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).
        """
        vpc_network: pulumi.Input[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).
        """
        import_custom_routes: NotRequired[pulumi.Input[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).
        """
elif False:
    PeeringGcpArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PeeringGcpArgs:
    def __init__(__self__, *,
                 project: pulumi.Input[str],
                 vpc_network: pulumi.Input[str],
                 import_custom_routes: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[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 pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[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")

    @project.setter
    def project(self, value: pulumi.Input[str]):
        pulumi.set(self, "project", value)

    @property
    @pulumi.getter(name="vpcNetwork")
    def vpc_network(self) -> pulumi.Input[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")

    @vpc_network.setter
    def vpc_network(self, value: pulumi.Input[str]):
        pulumi.set(self, "vpc_network", value)

    @property
    @pulumi.getter(name="importCustomRoutes")
    def import_custom_routes(self) -> Optional[pulumi.Input[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")

    @import_custom_routes.setter
    def import_custom_routes(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "import_custom_routes", value)


if not MYPY:
    class PeeringNetworkArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Network that the Peering belongs to, for example, `n-abc123`.
        """
elif False:
    PeeringNetworkArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PeeringNetworkArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Network that the Peering belongs to, for example, `n-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class PrivateLinkAccessAwsArgsDict(TypedDict):
        account: pulumi.Input[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**.
        """
elif False:
    PrivateLinkAccessAwsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PrivateLinkAccessAwsArgs:
    def __init__(__self__, *,
                 account: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[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")

    @account.setter
    def account(self, value: pulumi.Input[str]):
        pulumi.set(self, "account", value)


if not MYPY:
    class PrivateLinkAccessAzureArgsDict(TypedDict):
        subscription: pulumi.Input[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**.
        """
elif False:
    PrivateLinkAccessAzureArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PrivateLinkAccessAzureArgs:
    def __init__(__self__, *,
                 subscription: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[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")

    @subscription.setter
    def subscription(self, value: pulumi.Input[str]):
        pulumi.set(self, "subscription", value)


if not MYPY:
    class PrivateLinkAccessEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment that the Private Link Access belongs to, for example, `env-abc123`.
        """
elif False:
    PrivateLinkAccessEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PrivateLinkAccessEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Environment that the Private Link Access belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class PrivateLinkAccessGcpArgsDict(TypedDict):
        project: pulumi.Input[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).
        """
elif False:
    PrivateLinkAccessGcpArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PrivateLinkAccessGcpArgs:
    def __init__(__self__, *,
                 project: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[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")

    @project.setter
    def project(self, value: pulumi.Input[str]):
        pulumi.set(self, "project", value)


if not MYPY:
    class PrivateLinkAccessNetworkArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Network that the Private Link Access belongs to, for example, `n-abc123`.
        """
elif False:
    PrivateLinkAccessNetworkArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PrivateLinkAccessNetworkArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Network that the Private Link Access belongs to, for example, `n-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class PrivateLinkAttachmentAwArgsDict(TypedDict):
        vpc_endpoint_service_name: NotRequired[pulumi.Input[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`.
        """
elif False:
    PrivateLinkAttachmentAwArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PrivateLinkAttachmentAwArgs:
    def __init__(__self__, *,
                 vpc_endpoint_service_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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[pulumi.Input[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")

    @vpc_endpoint_service_name.setter
    def vpc_endpoint_service_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vpc_endpoint_service_name", value)


if not MYPY:
    class PrivateLinkAttachmentAzureArgsDict(TypedDict):
        private_link_service_alias: NotRequired[pulumi.Input[str]]
        """
        Azure PrivateLink service alias for the availability zone.
        """
        private_link_service_resource_id: NotRequired[pulumi.Input[str]]
        """
        (Required String) Azure Private Link service resource id for the availability zone.
        """
elif False:
    PrivateLinkAttachmentAzureArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PrivateLinkAttachmentAzureArgs:
    def __init__(__self__, *,
                 private_link_service_alias: Optional[pulumi.Input[str]] = None,
                 private_link_service_resource_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] private_link_service_alias: Azure PrivateLink service alias for the availability zone.
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        Azure PrivateLink service alias for the availability zone.
        """
        return pulumi.get(self, "private_link_service_alias")

    @private_link_service_alias.setter
    def private_link_service_alias(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "private_link_service_alias", value)

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

    @private_link_service_resource_id.setter
    def private_link_service_resource_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "private_link_service_resource_id", value)


if not MYPY:
    class PrivateLinkAttachmentConnectionAwsArgsDict(TypedDict):
        vpc_endpoint_id: pulumi.Input[str]
        """
        Id of a VPC Endpoint that is connected to the VPC Endpoint service.
        """
elif False:
    PrivateLinkAttachmentConnectionAwsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PrivateLinkAttachmentConnectionAwsArgs:
    def __init__(__self__, *,
                 vpc_endpoint_id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        Id of a VPC Endpoint that is connected to the VPC Endpoint service.
        """
        return pulumi.get(self, "vpc_endpoint_id")

    @vpc_endpoint_id.setter
    def vpc_endpoint_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "vpc_endpoint_id", value)


if not MYPY:
    class PrivateLinkAttachmentConnectionAzureArgsDict(TypedDict):
        private_endpoint_resource_id: pulumi.Input[str]
        """
        Resource ID of the Private Endpoint that is connected to the Private Link service.
        """
elif False:
    PrivateLinkAttachmentConnectionAzureArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PrivateLinkAttachmentConnectionAzureArgs:
    def __init__(__self__, *,
                 private_endpoint_resource_id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        Resource ID of the Private Endpoint that is connected to the Private Link service.
        """
        return pulumi.get(self, "private_endpoint_resource_id")

    @private_endpoint_resource_id.setter
    def private_endpoint_resource_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "private_endpoint_resource_id", value)


if not MYPY:
    class PrivateLinkAttachmentConnectionEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment that the Private Link Attachment Connection belongs to, for example `env-xyz456`.
        """
elif False:
    PrivateLinkAttachmentConnectionEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PrivateLinkAttachmentConnectionEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Environment that the Private Link Attachment Connection belongs to, for example `env-xyz456`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class PrivateLinkAttachmentConnectionGcpArgsDict(TypedDict):
        private_service_connect_connection_id: pulumi.Input[str]
        """
        Id of the Private Service connection.
        """
elif False:
    PrivateLinkAttachmentConnectionGcpArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PrivateLinkAttachmentConnectionGcpArgs:
    def __init__(__self__, *,
                 private_service_connect_connection_id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        Id of the Private Service connection.
        """
        return pulumi.get(self, "private_service_connect_connection_id")

    @private_service_connect_connection_id.setter
    def private_service_connect_connection_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "private_service_connect_connection_id", value)


if not MYPY:
    class PrivateLinkAttachmentConnectionPrivateLinkAttachmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The unique identifier for the private link attachment.
        """
elif False:
    PrivateLinkAttachmentConnectionPrivateLinkAttachmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PrivateLinkAttachmentConnectionPrivateLinkAttachmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The unique identifier for the private link attachment.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class PrivateLinkAttachmentEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment that the Private Link Attachment belongs to, for example `env-xyz456`.
        """
elif False:
    PrivateLinkAttachmentEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PrivateLinkAttachmentEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Environment that the Private Link Attachment belongs to, for example `env-xyz456`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class PrivateLinkAttachmentGcpArgsDict(TypedDict):
        private_service_connect_service_attachment: NotRequired[pulumi.Input[str]]
        """
        Id of a Private Service Connect Service Attachment in Confluent Cloud.
        """
        zone: NotRequired[pulumi.Input[str]]
        """
        Zone associated with the PSC Service attachment.
        """
elif False:
    PrivateLinkAttachmentGcpArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PrivateLinkAttachmentGcpArgs:
    def __init__(__self__, *,
                 private_service_connect_service_attachment: Optional[pulumi.Input[str]] = None,
                 zone: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] private_service_connect_service_attachment: Id of a Private Service Connect Service Attachment in Confluent Cloud.
        :param pulumi.Input[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[pulumi.Input[str]]:
        """
        Id of a Private Service Connect Service Attachment in Confluent Cloud.
        """
        return pulumi.get(self, "private_service_connect_service_attachment")

    @private_service_connect_service_attachment.setter
    def private_service_connect_service_attachment(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "private_service_connect_service_attachment", value)

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

    @zone.setter
    def zone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "zone", value)


if not MYPY:
    class ProviderIntegrationAwsArgsDict(TypedDict):
        customer_role_arn: pulumi.Input[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.
        """
        external_id: NotRequired[pulumi.Input[str]]
        """
        (Required String) Unique external ID that Confluent Cloud uses when it assumes the IAM role in your Amazon Web Services (AWS) account.
        """
        iam_role_arn: NotRequired[pulumi.Input[str]]
        """
        (Required String) The IAM role ARN used in Confluent Cloud internally, bundled with `customer_role_arn`.
        """
elif False:
    ProviderIntegrationAwsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ProviderIntegrationAwsArgs:
    def __init__(__self__, *,
                 customer_role_arn: pulumi.Input[str],
                 external_id: Optional[pulumi.Input[str]] = None,
                 iam_role_arn: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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 pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[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")

    @customer_role_arn.setter
    def customer_role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "customer_role_arn", value)

    @property
    @pulumi.getter(name="externalId")
    def external_id(self) -> Optional[pulumi.Input[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")

    @external_id.setter
    def external_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "external_id", value)

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

    @iam_role_arn.setter
    def iam_role_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "iam_role_arn", value)


if not MYPY:
    class ProviderIntegrationEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
        """
elif False:
    ProviderIntegrationEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ProviderIntegrationEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Environment that the Provider Integration belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class SchemaCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Schema Registry API Key.
        """
        secret: pulumi.Input[str]
        """
        The Cluster API Secret for your Confluent Cloud cluster.
        """
elif False:
    SchemaCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Schema Registry API Key.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class SchemaExporterCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Schema Registry API Key.
        """
        secret: pulumi.Input[str]
        """
        The Schema Registry API Secret.
        """
elif False:
    SchemaExporterCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaExporterCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Schema Registry API Key.
        :param pulumi.Input[str] secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class SchemaExporterDestinationSchemaRegistryClusterArgsDict(TypedDict):
        credentials: pulumi.Input['SchemaExporterDestinationSchemaRegistryClusterCredentialsArgsDict']
        rest_endpoint: pulumi.Input[str]
        """
        The REST endpoint of the destination Schema Registry cluster, for example, `https://pkc-00000.us-central1.gcp.confluent.cloud:443`).
        """
elif False:
    SchemaExporterDestinationSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaExporterDestinationSchemaRegistryClusterArgs:
    def __init__(__self__, *,
                 credentials: pulumi.Input['SchemaExporterDestinationSchemaRegistryClusterCredentialsArgs'],
                 rest_endpoint: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input['SchemaExporterDestinationSchemaRegistryClusterCredentialsArgs']:
        return pulumi.get(self, "credentials")

    @credentials.setter
    def credentials(self, value: pulumi.Input['SchemaExporterDestinationSchemaRegistryClusterCredentialsArgs']):
        pulumi.set(self, "credentials", value)

    @property
    @pulumi.getter(name="restEndpoint")
    def rest_endpoint(self) -> pulumi.Input[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")

    @rest_endpoint.setter
    def rest_endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "rest_endpoint", value)


if not MYPY:
    class SchemaExporterDestinationSchemaRegistryClusterCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Schema Registry API Key.
        """
        secret: pulumi.Input[str]
        """
        The Schema Registry API Secret.
        """
elif False:
    SchemaExporterDestinationSchemaRegistryClusterCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaExporterDestinationSchemaRegistryClusterCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Schema Registry API Key.
        :param pulumi.Input[str] secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class SchemaExporterSchemaRegistryClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    SchemaExporterSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaExporterSchemaRegistryClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class SchemaMetadataArgsDict(TypedDict):
        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
        """
        The custom properties to set:
        """
        sensitives: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        A list of metadata properties to be encrypted.
        """
        tags: NotRequired[pulumi.Input[Sequence[pulumi.Input['SchemaMetadataTagArgsDict']]]]
        """
        The tags to which the rule applies, if any.
        """
elif False:
    SchemaMetadataArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaMetadataArgs:
    def __init__(__self__, *,
                 properties: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 sensitives: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input['SchemaMetadataTagArgs']]]] = None):
        """
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] properties: The custom properties to set:
        :param pulumi.Input[Sequence[pulumi.Input[str]]] sensitives: A list of metadata properties to be encrypted.
        :param pulumi.Input[Sequence[pulumi.Input['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[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        The custom properties to set:
        """
        return pulumi.get(self, "properties")

    @properties.setter
    def properties(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "properties", value)

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

    @sensitives.setter
    def sensitives(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "sensitives", value)

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

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SchemaMetadataTagArgs']]]]):
        pulumi.set(self, "tags", value)


if not MYPY:
    class SchemaMetadataTagArgsDict(TypedDict):
        key: NotRequired[pulumi.Input[str]]
        """
        The setting name.
        """
        values: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        The list of tags.
        """
elif False:
    SchemaMetadataTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaMetadataTagArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] key: The setting name.
        :param pulumi.Input[Sequence[pulumi.Input[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[pulumi.Input[str]]:
        """
        The setting name.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @values.setter
    def values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "values", value)


if not MYPY:
    class SchemaRegistryClusterConfigCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Schema Registry API Key.
        """
        secret: pulumi.Input[str]
        """
        The Cluster API Secret for your Confluent Cloud cluster.
        """
elif False:
    SchemaRegistryClusterConfigCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaRegistryClusterConfigCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Schema Registry API Key.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class SchemaRegistryClusterConfigSchemaRegistryClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    SchemaRegistryClusterConfigSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaRegistryClusterConfigSchemaRegistryClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class SchemaRegistryClusterModeCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Schema Registry API Key.
        """
        secret: pulumi.Input[str]
        """
        The Cluster API Secret for your Confluent Cloud cluster.
        """
elif False:
    SchemaRegistryClusterModeCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaRegistryClusterModeCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Schema Registry API Key.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class SchemaRegistryClusterModeSchemaRegistryClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    SchemaRegistryClusterModeSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaRegistryClusterModeSchemaRegistryClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class SchemaRegistryDekCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Schema Registry API Key.
        """
        secret: pulumi.Input[str]
        """
        The Schema Registry API Secret.
        """
elif False:
    SchemaRegistryDekCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaRegistryDekCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Schema Registry API Key.
        :param pulumi.Input[str] secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class SchemaRegistryDekSchemaRegistryClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    SchemaRegistryDekSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaRegistryDekSchemaRegistryClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class SchemaRegistryKekCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Schema Registry API Key.
        """
        secret: pulumi.Input[str]
        """
        The Schema Registry API Secret.
        """
elif False:
    SchemaRegistryKekCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaRegistryKekCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Schema Registry API Key.
        :param pulumi.Input[str] secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class SchemaRegistryKekSchemaRegistryClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    SchemaRegistryKekSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaRegistryKekSchemaRegistryClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class SchemaRulesetArgsDict(TypedDict):
        domain_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['SchemaRulesetDomainRuleArgsDict']]]]
        migration_rules: NotRequired[pulumi.Input[Sequence[pulumi.Input['SchemaRulesetMigrationRuleArgsDict']]]]
elif False:
    SchemaRulesetArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaRulesetArgs:
    def __init__(__self__, *,
                 domain_rules: Optional[pulumi.Input[Sequence[pulumi.Input['SchemaRulesetDomainRuleArgs']]]] = None,
                 migration_rules: Optional[pulumi.Input[Sequence[pulumi.Input['SchemaRulesetMigrationRuleArgs']]]] = 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[pulumi.Input[Sequence[pulumi.Input['SchemaRulesetDomainRuleArgs']]]]:
        return pulumi.get(self, "domain_rules")

    @domain_rules.setter
    def domain_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SchemaRulesetDomainRuleArgs']]]]):
        pulumi.set(self, "domain_rules", value)

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

    @migration_rules.setter
    def migration_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SchemaRulesetMigrationRuleArgs']]]]):
        pulumi.set(self, "migration_rules", value)


if not MYPY:
    class SchemaRulesetDomainRuleArgsDict(TypedDict):
        doc: NotRequired[pulumi.Input[str]]
        """
        An optional description of the rule.
        """
        expr: NotRequired[pulumi.Input[str]]
        """
        The body of the rule, which is optional.
        """
        kind: NotRequired[pulumi.Input[str]]
        """
        The kind of the rule. Accepted values are `CONDITION` and `TRANSFORM`.
        """
        mode: NotRequired[pulumi.Input[str]]
        """
        The mode of the rule. Accepted values are `UPGRADE`, `DOWNGRADE`, `UPDOWN`, `WRITE`, `READ`, and `WRITEREAD`.
        """
        name: NotRequired[pulumi.Input[str]]
        """
        A user-defined name that can be used to reference the rule.
        """
        on_failure: NotRequired[pulumi.Input[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.
        """
        on_success: NotRequired[pulumi.Input[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`.
        """
        params: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[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).

        > **Note:** `ruleset` and `metadata` attributes are available in **Preview** for early adopters. Preview features are introduced to gather customer feedback. This feature should be used only for evaluation and non-production testing purposes or to provide feedback to Confluent, particularly as it becomes more widely available in follow-on editions.
        **Preview** features are intended for evaluation use in development and testing environments only, and not for production use. The warranty, SLA, and Support Services provisions of your agreement with Confluent do not apply to Preview features. Preview features are considered to be a Proof of Concept as defined in the Confluent Cloud Terms of Service. Confluent may discontinue providing preview releases of the Preview features at any time in Confluent’s sole discretion.
        """
        tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        The tags to which the rule applies, if any.
        """
        type: NotRequired[pulumi.Input[str]]
        """
        The type of rule, which invokes a specific rule executor, such as Google Common Expression Language (CEL) or JSONata.
        """
elif False:
    SchemaRulesetDomainRuleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaRulesetDomainRuleArgs:
    def __init__(__self__, *,
                 doc: Optional[pulumi.Input[str]] = None,
                 expr: Optional[pulumi.Input[str]] = None,
                 kind: Optional[pulumi.Input[str]] = None,
                 mode: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 on_failure: Optional[pulumi.Input[str]] = None,
                 on_success: Optional[pulumi.Input[str]] = None,
                 params: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] doc: An optional description of the rule.
        :param pulumi.Input[str] expr: The body of the rule, which is optional.
        :param pulumi.Input[str] kind: The kind of the rule. Accepted values are `CONDITION` and `TRANSFORM`.
        :param pulumi.Input[str] mode: The mode of the rule. Accepted values are `UPGRADE`, `DOWNGRADE`, `UPDOWN`, `WRITE`, `READ`, and `WRITEREAD`.
        :param pulumi.Input[str] name: A user-defined name that can be used to reference the rule.
        :param pulumi.Input[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.
        :param pulumi.Input[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`.
        :param pulumi.Input[Mapping[str, pulumi.Input[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).
               
               > **Note:** `ruleset` and `metadata` attributes are available in **Preview** for early adopters. Preview features are introduced to gather customer feedback. This feature should be used only for evaluation and non-production testing purposes or to provide feedback to Confluent, particularly as it becomes more widely available in follow-on editions.
               **Preview** features are intended for evaluation use in development and testing environments only, and not for production use. The warranty, SLA, and Support Services provisions of your agreement with Confluent do not apply to Preview features. Preview features are considered to be a Proof of Concept as defined in the Confluent Cloud Terms of Service. Confluent may discontinue providing preview releases of the Preview features at any time in Confluent’s sole discretion.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The tags to which the rule applies, if any.
        :param pulumi.Input[str] type: The type of rule, which invokes a specific rule executor, such as Google Common Expression Language (CEL) or JSONata.
        """
        if doc is not None:
            pulumi.set(__self__, "doc", doc)
        if expr is not None:
            pulumi.set(__self__, "expr", expr)
        if kind is not None:
            pulumi.set(__self__, "kind", kind)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if name is not None:
            pulumi.set(__self__, "name", name)
        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)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

    @doc.setter
    def doc(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "doc", value)

    @property
    @pulumi.getter
    def expr(self) -> Optional[pulumi.Input[str]]:
        """
        The body of the rule, which is optional.
        """
        return pulumi.get(self, "expr")

    @expr.setter
    def expr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "expr", value)

    @property
    @pulumi.getter
    def kind(self) -> Optional[pulumi.Input[str]]:
        """
        The kind of the rule. Accepted values are `CONDITION` and `TRANSFORM`.
        """
        return pulumi.get(self, "kind")

    @kind.setter
    def kind(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kind", value)

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

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="onFailure")
    def on_failure(self) -> Optional[pulumi.Input[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.
        """
        return pulumi.get(self, "on_failure")

    @on_failure.setter
    def on_failure(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "on_failure", value)

    @property
    @pulumi.getter(name="onSuccess")
    def on_success(self) -> Optional[pulumi.Input[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`.
        """
        return pulumi.get(self, "on_success")

    @on_success.setter
    def on_success(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "on_success", value)

    @property
    @pulumi.getter
    def params(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[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).

        > **Note:** `ruleset` and `metadata` attributes are available in **Preview** for early adopters. Preview features are introduced to gather customer feedback. This feature should be used only for evaluation and non-production testing purposes or to provide feedback to Confluent, particularly as it becomes more widely available in follow-on editions.
        **Preview** features are intended for evaluation use in development and testing environments only, and not for production use. The warranty, SLA, and Support Services provisions of your agreement with Confluent do not apply to Preview features. Preview features are considered to be a Proof of Concept as defined in the Confluent Cloud Terms of Service. Confluent may discontinue providing preview releases of the Preview features at any time in Confluent’s sole discretion.
        """
        return pulumi.get(self, "params")

    @params.setter
    def params(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "params", value)

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

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "tags", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        The type of rule, which invokes a specific rule executor, such as Google Common Expression Language (CEL) or JSONata.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


if not MYPY:
    class SchemaRulesetMigrationRuleArgsDict(TypedDict):
        doc: NotRequired[pulumi.Input[str]]
        """
        An optional description of the rule.
        """
        expr: NotRequired[pulumi.Input[str]]
        """
        The body of the rule, which is optional.
        """
        kind: NotRequired[pulumi.Input[str]]
        """
        The kind of the rule. Accepted values are `CONDITION` and `TRANSFORM`.
        """
        mode: NotRequired[pulumi.Input[str]]
        """
        The mode of the rule. Accepted values are `UPGRADE`, `DOWNGRADE`, `UPDOWN`, `WRITE`, `READ`, and `WRITEREAD`.
        """
        name: NotRequired[pulumi.Input[str]]
        on_failure: NotRequired[pulumi.Input[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.
        """
        on_success: NotRequired[pulumi.Input[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`.
        """
        params: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[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).

        > **Note:** `ruleset` and `metadata` attributes are available in **Preview** for early adopters. Preview features are introduced to gather customer feedback. This feature should be used only for evaluation and non-production testing purposes or to provide feedback to Confluent, particularly as it becomes more widely available in follow-on editions.
        **Preview** features are intended for evaluation use in development and testing environments only, and not for production use. The warranty, SLA, and Support Services provisions of your agreement with Confluent do not apply to Preview features. Preview features are considered to be a Proof of Concept as defined in the Confluent Cloud Terms of Service. Confluent may discontinue providing preview releases of the Preview features at any time in Confluent’s sole discretion.
        """
        tags: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
        """
        The tags to which the rule applies, if any.
        """
        type: NotRequired[pulumi.Input[str]]
        """
        The type of rule, which invokes a specific rule executor, such as Google Common Expression Language (CEL) or JSONata.
        """
elif False:
    SchemaRulesetMigrationRuleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaRulesetMigrationRuleArgs:
    def __init__(__self__, *,
                 doc: Optional[pulumi.Input[str]] = None,
                 expr: Optional[pulumi.Input[str]] = None,
                 kind: Optional[pulumi.Input[str]] = None,
                 mode: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 on_failure: Optional[pulumi.Input[str]] = None,
                 on_success: Optional[pulumi.Input[str]] = None,
                 params: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] doc: An optional description of the rule.
        :param pulumi.Input[str] expr: The body of the rule, which is optional.
        :param pulumi.Input[str] kind: The kind of the rule. Accepted values are `CONDITION` and `TRANSFORM`.
        :param pulumi.Input[str] mode: The mode of the rule. Accepted values are `UPGRADE`, `DOWNGRADE`, `UPDOWN`, `WRITE`, `READ`, and `WRITEREAD`.
        :param pulumi.Input[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.
        :param pulumi.Input[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`.
        :param pulumi.Input[Mapping[str, pulumi.Input[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).
               
               > **Note:** `ruleset` and `metadata` attributes are available in **Preview** for early adopters. Preview features are introduced to gather customer feedback. This feature should be used only for evaluation and non-production testing purposes or to provide feedback to Confluent, particularly as it becomes more widely available in follow-on editions.
               **Preview** features are intended for evaluation use in development and testing environments only, and not for production use. The warranty, SLA, and Support Services provisions of your agreement with Confluent do not apply to Preview features. Preview features are considered to be a Proof of Concept as defined in the Confluent Cloud Terms of Service. Confluent may discontinue providing preview releases of the Preview features at any time in Confluent’s sole discretion.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] tags: The tags to which the rule applies, if any.
        :param pulumi.Input[str] type: The type of rule, which invokes a specific rule executor, such as Google Common Expression Language (CEL) or JSONata.
        """
        if doc is not None:
            pulumi.set(__self__, "doc", doc)
        if expr is not None:
            pulumi.set(__self__, "expr", expr)
        if kind is not None:
            pulumi.set(__self__, "kind", kind)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if name is not None:
            pulumi.set(__self__, "name", name)
        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)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

    @doc.setter
    def doc(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "doc", value)

    @property
    @pulumi.getter
    def expr(self) -> Optional[pulumi.Input[str]]:
        """
        The body of the rule, which is optional.
        """
        return pulumi.get(self, "expr")

    @expr.setter
    def expr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "expr", value)

    @property
    @pulumi.getter
    def kind(self) -> Optional[pulumi.Input[str]]:
        """
        The kind of the rule. Accepted values are `CONDITION` and `TRANSFORM`.
        """
        return pulumi.get(self, "kind")

    @kind.setter
    def kind(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kind", value)

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

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="onFailure")
    def on_failure(self) -> Optional[pulumi.Input[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.
        """
        return pulumi.get(self, "on_failure")

    @on_failure.setter
    def on_failure(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "on_failure", value)

    @property
    @pulumi.getter(name="onSuccess")
    def on_success(self) -> Optional[pulumi.Input[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`.
        """
        return pulumi.get(self, "on_success")

    @on_success.setter
    def on_success(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "on_success", value)

    @property
    @pulumi.getter
    def params(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[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).

        > **Note:** `ruleset` and `metadata` attributes are available in **Preview** for early adopters. Preview features are introduced to gather customer feedback. This feature should be used only for evaluation and non-production testing purposes or to provide feedback to Confluent, particularly as it becomes more widely available in follow-on editions.
        **Preview** features are intended for evaluation use in development and testing environments only, and not for production use. The warranty, SLA, and Support Services provisions of your agreement with Confluent do not apply to Preview features. Preview features are considered to be a Proof of Concept as defined in the Confluent Cloud Terms of Service. Confluent may discontinue providing preview releases of the Preview features at any time in Confluent’s sole discretion.
        """
        return pulumi.get(self, "params")

    @params.setter
    def params(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
        pulumi.set(self, "params", value)

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

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "tags", value)

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        The type of rule, which invokes a specific rule executor, such as Google Common Expression Language (CEL) or JSONata.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "type", value)


if not MYPY:
    class SchemaSchemaReferenceArgsDict(TypedDict):
        name: pulumi.Input[str]
        """
        The name of the subject, representing the subject under which the referenced schema is registered.
        """
        subject_name: pulumi.Input[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.)
        """
        version: pulumi.Input[int]
        """
        The version, representing the exact version of the schema under the registered subject.
        """
elif False:
    SchemaSchemaReferenceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaSchemaReferenceArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 subject_name: pulumi.Input[str],
                 version: pulumi.Input[int]):
        """
        :param pulumi.Input[str] name: The name of the subject, representing the subject under which the referenced schema is registered.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The name of the subject, representing the subject under which the referenced schema is registered.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="subjectName")
    def subject_name(self) -> pulumi.Input[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")

    @subject_name.setter
    def subject_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "subject_name", value)

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

    @version.setter
    def version(self, value: pulumi.Input[int]):
        pulumi.set(self, "version", value)


if not MYPY:
    class SchemaSchemaRegistryClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    SchemaSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SchemaSchemaRegistryClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class SubjectConfigCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Schema Registry API Key.
        """
        secret: pulumi.Input[str]
        """
        The Cluster API Secret for your Confluent Cloud cluster.
        """
elif False:
    SubjectConfigCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SubjectConfigCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Schema Registry API Key.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class SubjectConfigSchemaRegistryClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    SubjectConfigSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SubjectConfigSchemaRegistryClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class SubjectModeCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Schema Registry API Key.
        """
        secret: pulumi.Input[str]
        """
        The Cluster API Secret for your Confluent Cloud cluster.
        """
elif False:
    SubjectModeCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SubjectModeCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Schema Registry API Key.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The Schema Registry API Key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class SubjectModeSchemaRegistryClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    SubjectModeSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class SubjectModeSchemaRegistryClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class TagBindingCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Schema Registry API Key.
        """
        secret: pulumi.Input[str]
        """
        The Schema Registry API Secret.
        """
elif False:
    TagBindingCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class TagBindingCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Schema Registry API Key.
        :param pulumi.Input[str] secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class TagBindingSchemaRegistryClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    TagBindingSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class TagBindingSchemaRegistryClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class TagCredentialsArgsDict(TypedDict):
        key: pulumi.Input[str]
        """
        The Schema Registry API Key.
        """
        secret: pulumi.Input[str]
        """
        The Schema Registry API Secret.
        """
elif False:
    TagCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class TagCredentialsArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 secret: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: The Schema Registry API Key.
        :param pulumi.Input[str] secret: The Schema Registry API Secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "secret", secret)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret", value)


if not MYPY:
    class TagSchemaRegistryClusterArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    TagSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class TagSchemaRegistryClusterArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[str] id: The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
        pulumi.set(__self__, "id", id)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class TransitGatewayAttachmentAwsArgsDict(TypedDict):
        ram_resource_share_arn: pulumi.Input[str]
        """
        The Amazon Resource Name (ARN) of the Resource Access Manager (RAM) Resource Share of the transit gateway your Confluent Cloud network attaches to.
        """
        routes: pulumi.Input[Sequence[pulumi.Input[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).
        """
        transit_gateway_id: pulumi.Input[str]
        """
        The ID of the AWS Transit Gateway that you want Confluent CLoud to be attached to. Must start with `tgw-`.
        """
        transit_gateway_attachment_id: NotRequired[pulumi.Input[str]]
        """
        (Required String) The ID of the AWS Transit Gateway VPC Attachment that attaches Confluent VPC to Transit Gateway.
        """
elif False:
    TransitGatewayAttachmentAwsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class TransitGatewayAttachmentAwsArgs:
    def __init__(__self__, *,
                 ram_resource_share_arn: pulumi.Input[str],
                 routes: pulumi.Input[Sequence[pulumi.Input[str]]],
                 transit_gateway_id: pulumi.Input[str],
                 transit_gateway_attachment_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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 pulumi.Input[Sequence[pulumi.Input[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 pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[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")

    @ram_resource_share_arn.setter
    def ram_resource_share_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "ram_resource_share_arn", value)

    @property
    @pulumi.getter
    def routes(self) -> pulumi.Input[Sequence[pulumi.Input[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")

    @routes.setter
    def routes(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "routes", value)

    @property
    @pulumi.getter(name="transitGatewayId")
    def transit_gateway_id(self) -> pulumi.Input[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")

    @transit_gateway_id.setter
    def transit_gateway_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "transit_gateway_id", value)

    @property
    @pulumi.getter(name="transitGatewayAttachmentId")
    def transit_gateway_attachment_id(self) -> Optional[pulumi.Input[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")

    @transit_gateway_attachment_id.setter
    def transit_gateway_attachment_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "transit_gateway_attachment_id", value)


if not MYPY:
    class TransitGatewayAttachmentEnvironmentArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Environment that the Transit Gateway Attachment belongs to, for example, `env-abc123`.
        """
elif False:
    TransitGatewayAttachmentEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class TransitGatewayAttachmentEnvironmentArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Environment that the Transit Gateway Attachment belongs to, for example, `env-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class TransitGatewayAttachmentNetworkArgsDict(TypedDict):
        id: pulumi.Input[str]
        """
        The ID of the Network that the Transit Gateway Attachment belongs to, for example, `n-abc123`.
        """
elif False:
    TransitGatewayAttachmentNetworkArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class TransitGatewayAttachmentNetworkArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ID of the Network that the Transit Gateway Attachment belongs to, for example, `n-abc123`.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetAccessPointEnvironmentArgsDict(TypedDict):
        id: str
        """
        The ID of the Environment that the Access Point belongs to, for example, `env-123abc`.
        """
elif False:
    GetAccessPointEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetAccessPointEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetBusinessMetadataBindingCredentialsArgsDict(TypedDict):
        key: str
        """
        The Schema Registry API Key.
        """
        secret: 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.
        """
elif False:
    GetBusinessMetadataBindingCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetBusinessMetadataBindingCredentialsArgs:
    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")

    @key.setter
    def key(self, value: str):
        pulumi.set(self, "key", value)

    @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")

    @secret.setter
    def secret(self, value: str):
        pulumi.set(self, "secret", value)


if not MYPY:
    class GetBusinessMetadataBindingSchemaRegistryClusterArgsDict(TypedDict):
        id: str
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    GetBusinessMetadataBindingSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetBusinessMetadataBindingSchemaRegistryClusterArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetBusinessMetadataCredentialsArgsDict(TypedDict):
        key: str
        """
        The Schema Registry API Key.
        """
        secret: str
        """
        The Schema Registry API Secret.
        """
elif False:
    GetBusinessMetadataCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetBusinessMetadataCredentialsArgs:
    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")

    @key.setter
    def key(self, value: str):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: str):
        pulumi.set(self, "secret", value)


if not MYPY:
    class GetBusinessMetadataSchemaRegistryClusterArgsDict(TypedDict):
        id: str
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    GetBusinessMetadataSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetBusinessMetadataSchemaRegistryClusterArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetCertificatePoolCertificateAuthorityArgsDict(TypedDict):
        id: str
        """
        The ID of the Certificate Authority for this Certificate Pool, for example, `op-123abc`.
        """
elif False:
    GetCertificatePoolCertificateAuthorityArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetCertificatePoolCertificateAuthorityArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetDnsRecordEnvironmentArgsDict(TypedDict):
        id: str
        """
        The ID of the Environment that the DNS Record belongs to, for example, `env-123abc`.
        """
elif False:
    GetDnsRecordEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetDnsRecordEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetEnvironmentStreamGovernanceArgsDict(TypedDict):
        package: str
        """
        Stream Governance Package. 'ESSENTIALS' or 'ADVANCED'
        """
elif False:
    GetEnvironmentStreamGovernanceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetEnvironmentStreamGovernanceArgs:
    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")

    @package.setter
    def package(self, value: str):
        pulumi.set(self, "package", value)


if not MYPY:
    class GetFlinkComputePoolEnvironmentArgsDict(TypedDict):
        id: 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.
        """
elif False:
    GetFlinkComputePoolEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetFlinkComputePoolEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetGatewayEnvironmentArgsDict(TypedDict):
        id: str
        """
        The ID of the Environment that the Gateway belongs to, for example, `env-123abc`.
        """
elif False:
    GetGatewayEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetGatewayEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetIdentityPoolIdentityProviderArgsDict(TypedDict):
        id: 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.
        """
elif False:
    GetIdentityPoolIdentityProviderArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetIdentityPoolIdentityProviderArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetIpAddressesFilterArgsDict(TypedDict):
        address_types: NotRequired[Sequence[str]]
        """
        A list of address types to filter by. Accepted values are: `EGRESS`, `INGRESS`.
        """
        clouds: NotRequired[Sequence[str]]
        """
        A list of clouds to filter by. Accepted values are: `AWS`, `AZURE`, and `GCP`.
        """
        regions: NotRequired[Sequence[str]]
        """
        A list of regions to filter by.
        """
        services: NotRequired[Sequence[str]]
        """
        A list of services to filter by. Accepted values are: `CONNECT`, `KAFKA`.
        """
elif False:
    GetIpAddressesFilterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetIpAddressesFilterArgs:
    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")

    @address_types.setter
    def address_types(self, value: Optional[Sequence[str]]):
        pulumi.set(self, "address_types", value)

    @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")

    @clouds.setter
    def clouds(self, value: Optional[Sequence[str]]):
        pulumi.set(self, "clouds", value)

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

    @regions.setter
    def regions(self, value: Optional[Sequence[str]]):
        pulumi.set(self, "regions", value)

    @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")

    @services.setter
    def services(self, value: Optional[Sequence[str]]):
        pulumi.set(self, "services", value)


if not MYPY:
    class GetKafkaClusterBasicArgsDict(TypedDict):
        pass
elif False:
    GetKafkaClusterBasicArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetKafkaClusterBasicArgs:
    def __init__(__self__):
        pass


if not MYPY:
    class GetKafkaClusterDedicatedArgsDict(TypedDict):
        cku: 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.
        """
        encryption_key: str
        """
        The ID of the encryption key that is used to encrypt the data in the Kafka cluster.
        """
        zones: 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.
        """
elif False:
    GetKafkaClusterDedicatedArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetKafkaClusterDedicatedArgs:
    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")

    @cku.setter
    def cku(self, value: int):
        pulumi.set(self, "cku", value)

    @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")

    @encryption_key.setter
    def encryption_key(self, value: str):
        pulumi.set(self, "encryption_key", value)

    @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")

    @zones.setter
    def zones(self, value: Sequence[str]):
        pulumi.set(self, "zones", value)


if not MYPY:
    class GetKafkaClusterEnterpriseArgsDict(TypedDict):
        pass
elif False:
    GetKafkaClusterEnterpriseArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetKafkaClusterEnterpriseArgs:
    def __init__(__self__):
        pass


if not MYPY:
    class GetKafkaClusterEnvironmentArgsDict(TypedDict):
        id: 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.
        """
elif False:
    GetKafkaClusterEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetKafkaClusterEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetKafkaClusterFreightArgsDict(TypedDict):
        zones: 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.
        """
elif False:
    GetKafkaClusterFreightArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetKafkaClusterFreightArgs:
    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")

    @zones.setter
    def zones(self, value: Sequence[str]):
        pulumi.set(self, "zones", value)


if not MYPY:
    class GetKafkaClusterStandardArgsDict(TypedDict):
        pass
elif False:
    GetKafkaClusterStandardArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetKafkaClusterStandardArgs:
    def __init__(__self__):
        pass


if not MYPY:
    class GetKafkaTopicCredentialsArgsDict(TypedDict):
        key: str
        """
        The Kafka API Key.
        """
        secret: str
        """
        The Cluster API Secret for your Confluent Cloud cluster.
        """
elif False:
    GetKafkaTopicCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetKafkaTopicCredentialsArgs:
    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")

    @key.setter
    def key(self, value: str):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: str):
        pulumi.set(self, "secret", value)


if not MYPY:
    class GetKafkaTopicKafkaClusterArgsDict(TypedDict):
        id: str
        """
        The ID of the Kafka cluster, for example, `lkc-abc123`.
        """
elif False:
    GetKafkaTopicKafkaClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetKafkaTopicKafkaClusterArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetKsqlClusterEnvironmentArgsDict(TypedDict):
        id: 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.
        """
elif False:
    GetKsqlClusterEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetKsqlClusterEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetNetworkAwArgsDict(TypedDict):
        account: str
        """
        (Required String) The AWS account ID associated with the Confluent Cloud VPC.
        """
        private_link_endpoint_service: str
        """
        (Optional String) The endpoint service of the Confluent Cloud VPC (used for PrivateLink) if available.
        """
        vpc: str
        """
        (Required String) The Confluent Cloud VPC ID.
        """
elif False:
    GetNetworkAwArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetNetworkAwArgs:
    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")

    @account.setter
    def account(self, value: str):
        pulumi.set(self, "account", value)

    @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")

    @private_link_endpoint_service.setter
    def private_link_endpoint_service(self, value: str):
        pulumi.set(self, "private_link_endpoint_service", value)

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

    @vpc.setter
    def vpc(self, value: str):
        pulumi.set(self, "vpc", value)


if not MYPY:
    class GetNetworkAzureArgsDict(TypedDict):
        private_link_service_aliases: 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).
        """
elif False:
    GetNetworkAzureArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetNetworkAzureArgs:
    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")

    @private_link_service_aliases.setter
    def private_link_service_aliases(self, value: Mapping[str, str]):
        pulumi.set(self, "private_link_service_aliases", value)


if not MYPY:
    class GetNetworkDnsConfigArgsDict(TypedDict):
        resolution: 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.
        """
elif False:
    GetNetworkDnsConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetNetworkDnsConfigArgs:
    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")

    @resolution.setter
    def resolution(self, value: str):
        pulumi.set(self, "resolution", value)


if not MYPY:
    class GetNetworkEnvironmentArgsDict(TypedDict):
        id: 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.
        """
elif False:
    GetNetworkEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetNetworkEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetNetworkGcpArgsDict(TypedDict):
        private_service_connect_service_attachments: 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).
        """
        project: str
        """
        (Required String) The GCP Project ID associated with the Confluent Cloud VPC.
        """
        vpc_network: str
        """
        (Required String) The network name of the Confluent Cloud VPC.
        """
elif False:
    GetNetworkGcpArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetNetworkGcpArgs:
    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")

    @private_service_connect_service_attachments.setter
    def private_service_connect_service_attachments(self, value: Mapping[str, str]):
        pulumi.set(self, "private_service_connect_service_attachments", value)

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

    @project.setter
    def project(self, value: str):
        pulumi.set(self, "project", value)

    @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")

    @vpc_network.setter
    def vpc_network(self, value: str):
        pulumi.set(self, "vpc_network", value)


if not MYPY:
    class GetNetworkLinkEndpointEnvironmentArgsDict(TypedDict):
        id: str
        """
        The ID of the Environment that the Network Link Endpoint belongs to, for example, `env-xyz456`.
        """
elif False:
    GetNetworkLinkEndpointEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetNetworkLinkEndpointEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetNetworkLinkServiceAcceptArgsDict(TypedDict):
        environments: 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.
        """
        networks: Sequence[str]
        """
        (Optional List of Strings) List of network ids from which connections can be accepted.
        """
elif False:
    GetNetworkLinkServiceAcceptArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetNetworkLinkServiceAcceptArgs:
    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")

    @environments.setter
    def environments(self, value: Sequence[str]):
        pulumi.set(self, "environments", value)

    @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")

    @networks.setter
    def networks(self, value: Sequence[str]):
        pulumi.set(self, "networks", value)


if not MYPY:
    class GetNetworkLinkServiceEnvironmentArgsDict(TypedDict):
        id: str
        """
        The ID of the Environment that the Network Link Service belongs to, for example, `env-1234`.
        """
elif False:
    GetNetworkLinkServiceEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetNetworkLinkServiceEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetPeeringEnvironmentArgsDict(TypedDict):
        id: 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.
        """
elif False:
    GetPeeringEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetPeeringEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetPrivateLinkAccessEnvironmentArgsDict(TypedDict):
        id: 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.
        """
elif False:
    GetPrivateLinkAccessEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetPrivateLinkAccessEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetPrivateLinkAttachmentConnectionEnvironmentArgsDict(TypedDict):
        id: str
        """
        The ID of the Environment that the Private Link Attachment Connection belongs to, for example `env-xyz456`.
        """
elif False:
    GetPrivateLinkAttachmentConnectionEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetPrivateLinkAttachmentConnectionEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetPrivateLinkAttachmentEnvironmentArgsDict(TypedDict):
        id: str
        """
        The ID of the Environment that the Private Link Attachment belongs to, for example `env-xyz456`.
        """
elif False:
    GetPrivateLinkAttachmentEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetPrivateLinkAttachmentEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetProviderIntegrationEnvironmentArgsDict(TypedDict):
        id: 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.
        """
elif False:
    GetProviderIntegrationEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetProviderIntegrationEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetSchemaCredentialsArgsDict(TypedDict):
        key: str
        """
        The Schema Registry API Key.
        """
        secret: str
        """
        The Schema Registry API Secret.
        """
elif False:
    GetSchemaCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaCredentialsArgs:
    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")

    @key.setter
    def key(self, value: str):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: str):
        pulumi.set(self, "secret", value)


if not MYPY:
    class GetSchemaMetadataArgsDict(TypedDict):
        properties: Mapping[str, str]
        """
        (Optional Map) The custom properties to set:
        """
        sensitives: Sequence[str]
        """
        (Optional List of Strings) A list of metadata properties to be encrypted.
        """
        tags: Sequence['GetSchemaMetadataTagArgsDict']
        """
        (Optional String List) The tags to which the rule applies, if any.
        """
elif False:
    GetSchemaMetadataArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaMetadataArgs:
    def __init__(__self__, *,
                 properties: Mapping[str, str],
                 sensitives: Sequence[str],
                 tags: Sequence['GetSchemaMetadataTagArgs']):
        """
        :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")

    @properties.setter
    def properties(self, value: Mapping[str, str]):
        pulumi.set(self, "properties", value)

    @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")

    @sensitives.setter
    def sensitives(self, value: Sequence[str]):
        pulumi.set(self, "sensitives", value)

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

    @tags.setter
    def tags(self, value: Sequence['GetSchemaMetadataTagArgs']):
        pulumi.set(self, "tags", value)


if not MYPY:
    class GetSchemaMetadataTagArgsDict(TypedDict):
        key: str
        """
        (Required String) The setting name.
        """
        values: Sequence[str]
        """
        (Required List of Strings) The list of tags.
        """
elif False:
    GetSchemaMetadataTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaMetadataTagArgs:
    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")

    @key.setter
    def key(self, value: str):
        pulumi.set(self, "key", value)

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

    @values.setter
    def values(self, value: Sequence[str]):
        pulumi.set(self, "values", value)


if not MYPY:
    class GetSchemaRegistryClusterConfigCredentialsArgsDict(TypedDict):
        key: str
        """
        The Schema Registry API Key.
        """
        secret: str
        """
        The Schema Registry API Secret.
        """
elif False:
    GetSchemaRegistryClusterConfigCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaRegistryClusterConfigCredentialsArgs:
    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")

    @key.setter
    def key(self, value: str):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: str):
        pulumi.set(self, "secret", value)


if not MYPY:
    class GetSchemaRegistryClusterConfigSchemaRegistryClusterArgsDict(TypedDict):
        id: str
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    GetSchemaRegistryClusterConfigSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaRegistryClusterConfigSchemaRegistryClusterArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetSchemaRegistryClusterEnvironmentArgsDict(TypedDict):
        id: str
        """
        The ID of the Environment that the Schema Registry cluster belongs to, for example, `env-xyz456`.
        """
elif False:
    GetSchemaRegistryClusterEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaRegistryClusterEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetSchemaRegistryClusterModeCredentialsArgsDict(TypedDict):
        key: str
        """
        The Schema Registry API Key.
        """
        secret: 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.
        """
elif False:
    GetSchemaRegistryClusterModeCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaRegistryClusterModeCredentialsArgs:
    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")

    @key.setter
    def key(self, value: str):
        pulumi.set(self, "key", value)

    @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")

    @secret.setter
    def secret(self, value: str):
        pulumi.set(self, "secret", value)


if not MYPY:
    class GetSchemaRegistryClusterModeSchemaRegistryClusterArgsDict(TypedDict):
        id: str
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    GetSchemaRegistryClusterModeSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaRegistryClusterModeSchemaRegistryClusterArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetSchemaRegistryClustersEnvironmentArgsDict(TypedDict):
        id: 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.
        """
elif False:
    GetSchemaRegistryClustersEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaRegistryClustersEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetSchemaRegistryDekCredentialsArgsDict(TypedDict):
        key: str
        """
        The Schema Registry API Key.
        """
        secret: str
        """
        The Schema Registry API Secret.
        """
elif False:
    GetSchemaRegistryDekCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaRegistryDekCredentialsArgs:
    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")

    @key.setter
    def key(self, value: str):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: str):
        pulumi.set(self, "secret", value)


if not MYPY:
    class GetSchemaRegistryDekSchemaRegistryClusterArgsDict(TypedDict):
        id: str
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    GetSchemaRegistryDekSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaRegistryDekSchemaRegistryClusterArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetSchemaRegistryKekCredentialsArgsDict(TypedDict):
        key: str
        """
        The Schema Registry API Key.
        """
        secret: str
        """
        The Schema Registry API Secret.
        """
elif False:
    GetSchemaRegistryKekCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaRegistryKekCredentialsArgs:
    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")

    @key.setter
    def key(self, value: str):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: str):
        pulumi.set(self, "secret", value)


if not MYPY:
    class GetSchemaRegistryKekSchemaRegistryClusterArgsDict(TypedDict):
        id: str
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    GetSchemaRegistryKekSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaRegistryKekSchemaRegistryClusterArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetSchemaRulesetArgsDict(TypedDict):
        domain_rules: Sequence['GetSchemaRulesetDomainRuleArgsDict']
        """
        (Optional List of Blocks) supports the following:
        """
        migration_rules: Sequence['GetSchemaRulesetMigrationRuleArgsDict']
elif False:
    GetSchemaRulesetArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaRulesetArgs:
    def __init__(__self__, *,
                 domain_rules: Sequence['GetSchemaRulesetDomainRuleArgs'],
                 migration_rules: Sequence['GetSchemaRulesetMigrationRuleArgs']):
        """
        :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['GetSchemaRulesetDomainRuleArgs']:
        """
        (Optional List of Blocks) supports the following:
        """
        return pulumi.get(self, "domain_rules")

    @domain_rules.setter
    def domain_rules(self, value: Sequence['GetSchemaRulesetDomainRuleArgs']):
        pulumi.set(self, "domain_rules", value)

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

    @migration_rules.setter
    def migration_rules(self, value: Sequence['GetSchemaRulesetMigrationRuleArgs']):
        pulumi.set(self, "migration_rules", value)


if not MYPY:
    class GetSchemaRulesetDomainRuleArgsDict(TypedDict):
        doc: str
        """
        (Optional String) An optional description.
        """
        expr: str
        """
        (Optional String) The body of the rule, which is optional.
        """
        kind: str
        """
        (Optional String) Either `CONDITION` or `TRANSFORM`.
        """
        mode: str
        """
        (Optional String) The mode of the rule.
        """
        name: str
        """
        (Optional String) A user-defined name that can be used to reference the rule.
        """
        on_failure: 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.
        """
        on_success: 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.
        """
        params: 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.
        """
        tags: Sequence[str]
        """
        (Optional String List) The tags to which the rule applies, if any.
        """
        type: str
        """
        (Optional String) The type of rule, which invokes a specific rule executor, such as Google Common Expression Language (CEL) or JSONata.
        """
elif False:
    GetSchemaRulesetDomainRuleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaRulesetDomainRuleArgs:
    def __init__(__self__, *,
                 doc: str,
                 expr: str,
                 kind: str,
                 mode: str,
                 name: str,
                 on_failure: str,
                 on_success: str,
                 params: Mapping[str, str],
                 tags: Sequence[str],
                 type: str):
        """
        :param str doc: (Optional String) An optional description.
        :param str expr: (Optional String) The body of the rule, which is optional.
        :param str kind: (Optional String) Either `CONDITION` or `TRANSFORM`.
        :param str mode: (Optional String) The mode of the rule.
        :param str name: (Optional String) A user-defined name that can be used to reference the rule.
        :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.
        :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: (Optional String) The type of rule, which invokes a specific rule executor, such as Google Common Expression Language (CEL) or JSONata.
        """
        pulumi.set(__self__, "doc", doc)
        pulumi.set(__self__, "expr", expr)
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "on_failure", on_failure)
        pulumi.set(__self__, "on_success", on_success)
        pulumi.set(__self__, "params", params)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def doc(self) -> str:
        """
        (Optional String) An optional description.
        """
        return pulumi.get(self, "doc")

    @doc.setter
    def doc(self, value: str):
        pulumi.set(self, "doc", value)

    @property
    @pulumi.getter
    def expr(self) -> str:
        """
        (Optional String) The body of the rule, which is optional.
        """
        return pulumi.get(self, "expr")

    @expr.setter
    def expr(self, value: str):
        pulumi.set(self, "expr", value)

    @property
    @pulumi.getter
    def kind(self) -> str:
        """
        (Optional String) Either `CONDITION` or `TRANSFORM`.
        """
        return pulumi.get(self, "kind")

    @kind.setter
    def kind(self, value: str):
        pulumi.set(self, "kind", value)

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        (Optional String) The mode of the rule.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: str):
        pulumi.set(self, "mode", value)

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

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="onFailure")
    def on_failure(self) -> 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")

    @on_failure.setter
    def on_failure(self, value: str):
        pulumi.set(self, "on_failure", value)

    @property
    @pulumi.getter(name="onSuccess")
    def on_success(self) -> 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")

    @on_success.setter
    def on_success(self, value: str):
        pulumi.set(self, "on_success", value)

    @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")

    @params.setter
    def params(self, value: Mapping[str, str]):
        pulumi.set(self, "params", value)

    @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")

    @tags.setter
    def tags(self, value: Sequence[str]):
        pulumi.set(self, "tags", value)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        (Optional String) The type of rule, which invokes a specific rule executor, such as Google Common Expression Language (CEL) or JSONata.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: str):
        pulumi.set(self, "type", value)


if not MYPY:
    class GetSchemaRulesetMigrationRuleArgsDict(TypedDict):
        doc: str
        """
        (Optional String) An optional description.
        """
        expr: str
        """
        (Optional String) The body of the rule, which is optional.
        """
        kind: str
        """
        (Optional String) Either `CONDITION` or `TRANSFORM`.
        """
        mode: str
        """
        (Optional String) The mode of the rule.
        """
        name: str
        """
        (Optional String) A user-defined name that can be used to reference the rule.
        """
        on_failure: 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.
        """
        on_success: 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.
        """
        params: 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.
        """
        tags: Sequence[str]
        """
        (Optional String List) The tags to which the rule applies, if any.
        """
        type: str
        """
        (Optional String) The type of rule, which invokes a specific rule executor, such as Google Common Expression Language (CEL) or JSONata.
        """
elif False:
    GetSchemaRulesetMigrationRuleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaRulesetMigrationRuleArgs:
    def __init__(__self__, *,
                 doc: str,
                 expr: str,
                 kind: str,
                 mode: str,
                 name: str,
                 on_failure: str,
                 on_success: str,
                 params: Mapping[str, str],
                 tags: Sequence[str],
                 type: str):
        """
        :param str doc: (Optional String) An optional description.
        :param str expr: (Optional String) The body of the rule, which is optional.
        :param str kind: (Optional String) Either `CONDITION` or `TRANSFORM`.
        :param str mode: (Optional String) The mode of the rule.
        :param str name: (Optional String) A user-defined name that can be used to reference the rule.
        :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.
        :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: (Optional String) The type of rule, which invokes a specific rule executor, such as Google Common Expression Language (CEL) or JSONata.
        """
        pulumi.set(__self__, "doc", doc)
        pulumi.set(__self__, "expr", expr)
        pulumi.set(__self__, "kind", kind)
        pulumi.set(__self__, "mode", mode)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "on_failure", on_failure)
        pulumi.set(__self__, "on_success", on_success)
        pulumi.set(__self__, "params", params)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def doc(self) -> str:
        """
        (Optional String) An optional description.
        """
        return pulumi.get(self, "doc")

    @doc.setter
    def doc(self, value: str):
        pulumi.set(self, "doc", value)

    @property
    @pulumi.getter
    def expr(self) -> str:
        """
        (Optional String) The body of the rule, which is optional.
        """
        return pulumi.get(self, "expr")

    @expr.setter
    def expr(self, value: str):
        pulumi.set(self, "expr", value)

    @property
    @pulumi.getter
    def kind(self) -> str:
        """
        (Optional String) Either `CONDITION` or `TRANSFORM`.
        """
        return pulumi.get(self, "kind")

    @kind.setter
    def kind(self, value: str):
        pulumi.set(self, "kind", value)

    @property
    @pulumi.getter
    def mode(self) -> str:
        """
        (Optional String) The mode of the rule.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: str):
        pulumi.set(self, "mode", value)

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

    @name.setter
    def name(self, value: str):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="onFailure")
    def on_failure(self) -> 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")

    @on_failure.setter
    def on_failure(self, value: str):
        pulumi.set(self, "on_failure", value)

    @property
    @pulumi.getter(name="onSuccess")
    def on_success(self) -> 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")

    @on_success.setter
    def on_success(self, value: str):
        pulumi.set(self, "on_success", value)

    @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")

    @params.setter
    def params(self, value: Mapping[str, str]):
        pulumi.set(self, "params", value)

    @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")

    @tags.setter
    def tags(self, value: Sequence[str]):
        pulumi.set(self, "tags", value)

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        (Optional String) The type of rule, which invokes a specific rule executor, such as Google Common Expression Language (CEL) or JSONata.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: str):
        pulumi.set(self, "type", value)


if not MYPY:
    class GetSchemaSchemaRegistryClusterArgsDict(TypedDict):
        id: str
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    GetSchemaSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemaSchemaRegistryClusterArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetSchemasCredentialsArgsDict(TypedDict):
        key: str
        """
        The Schema Registry API Key.
        """
        secret: str
        """
        The Schema Registry API Secret.
        """
elif False:
    GetSchemasCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemasCredentialsArgs:
    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")

    @key.setter
    def key(self, value: str):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: str):
        pulumi.set(self, "secret", value)


if not MYPY:
    class GetSchemasFilterArgsDict(TypedDict):
        deleted: NotRequired[bool]
        """
        The boolean flag to control whether to return soft deleted schemas. Defaults to `false`.
        """
        latest_only: NotRequired[bool]
        """
        The boolean flag to control whether to return latest schema versions only for each matching subject. Defaults to `false`.
        """
        subject_prefix: NotRequired[str]
        """
        The prefix of the subjects (in other words, the namespaces), representing the subjects under which the schemas are registered.
        """
elif False:
    GetSchemasFilterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemasFilterArgs:
    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")

    @deleted.setter
    def deleted(self, value: Optional[bool]):
        pulumi.set(self, "deleted", value)

    @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")

    @latest_only.setter
    def latest_only(self, value: Optional[bool]):
        pulumi.set(self, "latest_only", value)

    @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")

    @subject_prefix.setter
    def subject_prefix(self, value: Optional[str]):
        pulumi.set(self, "subject_prefix", value)


if not MYPY:
    class GetSchemasSchemaRegistryClusterArgsDict(TypedDict):
        id: str
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    GetSchemasSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSchemasSchemaRegistryClusterArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetSubjectConfigCredentialsArgsDict(TypedDict):
        key: str
        """
        The Schema Registry API Key.
        """
        secret: str
        """
        The Schema Registry API Secret.
        """
elif False:
    GetSubjectConfigCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSubjectConfigCredentialsArgs:
    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")

    @key.setter
    def key(self, value: str):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: str):
        pulumi.set(self, "secret", value)


if not MYPY:
    class GetSubjectConfigSchemaRegistryClusterArgsDict(TypedDict):
        id: str
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    GetSubjectConfigSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSubjectConfigSchemaRegistryClusterArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetSubjectModeCredentialsArgsDict(TypedDict):
        key: str
        """
        The Schema Registry API Key.
        """
        secret: str
        """
        The Schema Registry API Secret.
        """
elif False:
    GetSubjectModeCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSubjectModeCredentialsArgs:
    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")

    @key.setter
    def key(self, value: str):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: str):
        pulumi.set(self, "secret", value)


if not MYPY:
    class GetSubjectModeSchemaRegistryClusterArgsDict(TypedDict):
        id: str
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    GetSubjectModeSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetSubjectModeSchemaRegistryClusterArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetTagBindingCredentialsArgsDict(TypedDict):
        key: str
        """
        The Schema Registry API Key.
        """
        secret: str
        """
        The Schema Registry API Secret.
        """
elif False:
    GetTagBindingCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetTagBindingCredentialsArgs:
    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")

    @key.setter
    def key(self, value: str):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: str):
        pulumi.set(self, "secret", value)


if not MYPY:
    class GetTagBindingSchemaRegistryClusterArgsDict(TypedDict):
        id: str
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    GetTagBindingSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetTagBindingSchemaRegistryClusterArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetTagCredentialsArgsDict(TypedDict):
        key: str
        """
        The Schema Registry API Key.
        """
        secret: str
        """
        The Schema Registry API Secret.
        """
elif False:
    GetTagCredentialsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetTagCredentialsArgs:
    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")

    @key.setter
    def key(self, value: str):
        pulumi.set(self, "key", value)

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

    @secret.setter
    def secret(self, value: str):
        pulumi.set(self, "secret", value)


if not MYPY:
    class GetTagSchemaRegistryClusterArgsDict(TypedDict):
        id: str
        """
        The ID of the Schema Registry cluster, for example, `lsrc-abc123`.
        """
elif False:
    GetTagSchemaRegistryClusterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetTagSchemaRegistryClusterArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


if not MYPY:
    class GetTransitGatewayAttachmentEnvironmentArgsDict(TypedDict):
        id: 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.
        """
elif False:
    GetTransitGatewayAttachmentEnvironmentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetTransitGatewayAttachmentEnvironmentArgs:
    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")

    @id.setter
    def id(self, value: str):
        pulumi.set(self, "id", value)


