# 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 pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities
from . import outputs

__all__ = [
    'ApiKeyManagedResource',
    'ApiKeyManagedResourceEnvironment',
    'ApiKeyOwner',
    'ClusterLinkDestinationKafkaCluster',
    'ClusterLinkDestinationKafkaClusterCredentials',
    'ClusterLinkSourceKafkaCluster',
    'ClusterLinkSourceKafkaClusterCredentials',
    'ConnectorEnvironment',
    'ConnectorKafkaCluster',
    'IdentityPoolIdentityProvider',
    'InvitationCreator',
    'InvitationUser',
    'KafkaAclCredentials',
    'KafkaAclKafkaCluster',
    'KafkaClientQuotaEnvironment',
    'KafkaClientQuotaKafkaCluster',
    'KafkaClientQuotaThroughput',
    'KafkaClusterBasic',
    'KafkaClusterConfigCredentials',
    'KafkaClusterConfigKafkaCluster',
    'KafkaClusterDedicated',
    'KafkaClusterEnvironment',
    'KafkaClusterNetwork',
    'KafkaClusterStandard',
    'KafkaMirrorTopicClusterLink',
    'KafkaMirrorTopicKafkaCluster',
    'KafkaMirrorTopicKafkaClusterCredentials',
    'KafkaMirrorTopicSourceKafkaTopic',
    'KafkaTopicCredentials',
    'KafkaTopicKafkaCluster',
    'KsqlClusterCredentialIdentity',
    'KsqlClusterEnvironment',
    'KsqlClusterKafkaCluster',
    'NetworkAw',
    'NetworkAzure',
    'NetworkDnsConfig',
    'NetworkEnvironment',
    'NetworkGcp',
    'NetworkZoneInfo',
    'PeeringAws',
    'PeeringAzure',
    'PeeringEnvironment',
    'PeeringGcp',
    'PeeringNetwork',
    'PrivateLinkAccessAws',
    'PrivateLinkAccessAzure',
    'PrivateLinkAccessEnvironment',
    'PrivateLinkAccessGcp',
    'PrivateLinkAccessNetwork',
    'SchemaCredentials',
    'SchemaRegistryClusterConfigCredentials',
    'SchemaRegistryClusterConfigSchemaRegistryCluster',
    'SchemaRegistryClusterEnvironment',
    'SchemaRegistryClusterModeCredentials',
    'SchemaRegistryClusterModeSchemaRegistryCluster',
    'SchemaRegistryClusterRegion',
    'SchemaSchemaReference',
    'SchemaSchemaRegistryCluster',
    'SubjectConfigCredentials',
    'SubjectConfigSchemaRegistryCluster',
    'SubjectModeCredentials',
    'SubjectModeSchemaRegistryCluster',
    'TransitGatewayAttachmentAws',
    'TransitGatewayAttachmentEnvironment',
    'TransitGatewayAttachmentNetwork',
    'GetIdentityPoolIdentityProviderResult',
    'GetInvitationCreatorResult',
    'GetInvitationUserResult',
    'GetKafkaClientQuotaEnvironmentResult',
    'GetKafkaClientQuotaKafkaClusterResult',
    'GetKafkaClientQuotaThroughputResult',
    'GetKafkaClusterBasicResult',
    'GetKafkaClusterDedicatedResult',
    'GetKafkaClusterEnvironmentResult',
    'GetKafkaClusterNetworkResult',
    'GetKafkaClusterStandardResult',
    'GetKafkaTopicCredentialsResult',
    'GetKafkaTopicKafkaClusterResult',
    'GetKsqlClusterCredentialIdentityResult',
    'GetKsqlClusterEnvironmentResult',
    'GetKsqlClusterKafkaClusterResult',
    'GetNetworkAwResult',
    'GetNetworkAzureResult',
    'GetNetworkDnsConfigResult',
    'GetNetworkEnvironmentResult',
    'GetNetworkGcpResult',
    'GetNetworkZoneInfoResult',
    'GetPeeringAwResult',
    'GetPeeringAzureResult',
    'GetPeeringEnvironmentResult',
    'GetPeeringGcpResult',
    'GetPeeringNetworkResult',
    'GetPrivateLinkAccessAwResult',
    'GetPrivateLinkAccessAzureResult',
    'GetPrivateLinkAccessEnvironmentResult',
    'GetPrivateLinkAccessGcpResult',
    'GetPrivateLinkAccessNetworkResult',
    'GetSchemaCredentialsResult',
    'GetSchemaRegistryClusterConfigCredentialsResult',
    'GetSchemaRegistryClusterConfigSchemaRegistryClusterResult',
    'GetSchemaRegistryClusterEnvironmentResult',
    'GetSchemaRegistryClusterModeCredentialsResult',
    'GetSchemaRegistryClusterModeSchemaRegistryClusterResult',
    'GetSchemaRegistryClusterRegionResult',
    'GetSchemaSchemaReferenceResult',
    'GetSchemaSchemaRegistryClusterResult',
    'GetSubjectConfigCredentialsResult',
    'GetSubjectConfigSchemaRegistryClusterResult',
    'GetSubjectModeCredentialsResult',
    'GetSubjectModeSchemaRegistryClusterResult',
    'GetTransitGatewayAttachmentAwResult',
    'GetTransitGatewayAttachmentEnvironmentResult',
    'GetTransitGatewayAttachmentNetworkResult',
]

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

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

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

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

    def __init__(__self__, *,
                 api_version: str,
                 environment: 'outputs.ApiKeyManagedResourceEnvironment',
                 id: str,
                 kind: str):
        """
        :param str api_version: The API group and version of the managed resource that the API Key associated with, for example, `cmk/v2`.
        :param str id: The ID of the Environment that the managed resource belongs to, for example, `env-abc123`.
        :param str kind: The kind of the managed resource that the API Key associated with, for example, `Cluster`.
        """
        pulumi.set(__self__, "api_version", api_version)
        pulumi.set(__self__, "environment", environment)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "kind", kind)

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

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

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

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


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

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


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

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

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

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

    def __init__(__self__, *,
                 api_version: str,
                 id: str,
                 kind: str):
        """
        :param str api_version: The API group and version of the managed resource that the API Key associated with, for example, `cmk/v2`.
        :param str id: The ID of the Environment that the managed resource belongs to, for example, `env-abc123`.
        :param str kind: The kind of the managed resource that the API Key associated with, for example, `Cluster`.
        """
        pulumi.set(__self__, "api_version", api_version)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "kind", kind)

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

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

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


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

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

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

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

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

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

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

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

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


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

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

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


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

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

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

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

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

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

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

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

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


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

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

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


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

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


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

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


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

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


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

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


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

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


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

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

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


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

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


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

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


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

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


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

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

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

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

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

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

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


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


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

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

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


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

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


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

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

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

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

    def __init__(__self__, *,
                 cku: int,
                 encryption_key: Optional[str] = None,
                 zones: Optional[Sequence[str]] = None):
        """
        :param int cku: The number of Confluent Kafka Units (CKUs) for Dedicated cluster types. The minimum number of CKUs for `SINGLE_ZONE` dedicated clusters is `1` whereas `MULTI_ZONE` dedicated clusters must have more than `2` CKUs.
        :param str encryption_key: The ID of the encryption key that is used to encrypt the data in the Kafka cluster, for example, `arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab` (key Amazon Resource Name) for AWS or `projects/my-test-project/locations/global/keyRings/test-byok/cryptoKeys/test` for GCP. Append required permissions to the key policy before creating a Kafka cluster, see [Encrypt Confluent Cloud Clusters using Self-Managed Keys](https://docs.confluent.io/cloud/current/clusters/byok/index.html) for more details. At the moment, self-managed encryption keys are only available for the Dedicated clusters on AWS or GCP.
        :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)
        if encryption_key is not None:
            pulumi.set(__self__, "encryption_key", encryption_key)
        if zones is not None:
            pulumi.set(__self__, "zones", zones)

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

    @property
    @pulumi.getter(name="encryptionKey")
    def encryption_key(self) -> Optional[str]:
        """
        The ID of the encryption key that is used to encrypt the data in the Kafka cluster, for example, `arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab` (key Amazon Resource Name) for AWS or `projects/my-test-project/locations/global/keyRings/test-byok/cryptoKeys/test` for GCP. Append required permissions to the key policy before creating a Kafka cluster, see [Encrypt Confluent Cloud Clusters using Self-Managed Keys](https://docs.confluent.io/cloud/current/clusters/byok/index.html) for more details. At the moment, self-managed encryption keys are only available for the Dedicated clusters on AWS or GCP.
        """
        return pulumi.get(self, "encryption_key")

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


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

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


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

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


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


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

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

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

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

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

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


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

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

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

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

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

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

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

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


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

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

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


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

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

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

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

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

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


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

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

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


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

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


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

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


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

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


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

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


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

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

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

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

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

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

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

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


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

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

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

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

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

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


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

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


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

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


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

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

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 cidr: Optional[str] = None,
                 zone_id: Optional[str] = None):
        """
        :param str cidr: The IPv4 CIDR block to be used for the network. Must be `/27`. Required for VPC peering and AWS TransitGateway.
        :param str zone_id: Cloud provider zone ID.
        """
        if cidr is not None:
            pulumi.set(__self__, "cidr", cidr)
        if zone_id is not None:
            pulumi.set(__self__, "zone_id", zone_id)

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

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


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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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


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

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


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

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

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

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

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

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

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

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


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

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


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

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


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

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


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

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


@pulumi.output_type
class PrivateLinkAccessGcp(dict):
    def __init__(__self__, *,
                 project: str):
        """
        :param str project: The GCP project ID to allow for Private Service Connect access. You can find your Google Cloud Project ID under **Project ID** section of your [Google Cloud Console dashboard](https://console.cloud.google.com/home/dashboard).
        """
        pulumi.set(__self__, "project", project)

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


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

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


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

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

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


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

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

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


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

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


@pulumi.output_type
class SchemaRegistryClusterEnvironment(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry region that the Schema Registry cluster belongs to, for example, `sgreg-1`. See [Schema Registry Regions](https://docs.confluent.io/cloud/current/stream-governance/packages.html#stream-governance-regions) to find a corresponding region ID based on desired cloud provider region and types of the billing package.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry region that the Schema Registry cluster belongs to, for example, `sgreg-1`. See [Schema Registry Regions](https://docs.confluent.io/cloud/current/stream-governance/packages.html#stream-governance-regions) to find a corresponding region ID based on desired cloud provider region and types of the billing package.
        """
        return pulumi.get(self, "id")


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

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

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


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

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


@pulumi.output_type
class SchemaRegistryClusterRegion(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Schema Registry region that the Schema Registry cluster belongs to, for example, `sgreg-1`. See [Schema Registry Regions](https://docs.confluent.io/cloud/current/stream-governance/packages.html#stream-governance-regions) to find a corresponding region ID based on desired cloud provider region and types of the billing package.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of the Schema Registry region that the Schema Registry cluster belongs to, for example, `sgreg-1`. See [Schema Registry Regions](https://docs.confluent.io/cloud/current/stream-governance/packages.html#stream-governance-regions) to find a corresponding region ID based on desired cloud provider region and types of the billing package.
        """
        return pulumi.get(self, "id")


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

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

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

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

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

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

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

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


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

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


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

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

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


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

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


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

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

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


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

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


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

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

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

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

    def __init__(__self__, *,
                 ram_resource_share_arn: str,
                 routes: Sequence[str],
                 transit_gateway_id: str,
                 transit_gateway_attachment_id: Optional[str] = None):
        """
        :param str ram_resource_share_arn: The Amazon Resource Name (ARN) of the Resource Access Manager (RAM) Resource Share of the transit gateway your Confluent Cloud network attaches to.
        :param Sequence[str] routes: List of destination routes for traffic from Confluent VPC to customer VPC via Transit Gateway.
        :param str transit_gateway_id: The ID of the AWS Transit Gateway that you want Confluent CLoud to be attached to. Must start with `tgw-`.
        :param str transit_gateway_attachment_id: (Required String) The ID of the AWS Transit Gateway VPC Attachment that attaches Confluent VPC to Transit Gateway.
        """
        pulumi.set(__self__, "ram_resource_share_arn", ram_resource_share_arn)
        pulumi.set(__self__, "routes", routes)
        pulumi.set(__self__, "transit_gateway_id", transit_gateway_id)
        if transit_gateway_attachment_id is not None:
            pulumi.set(__self__, "transit_gateway_attachment_id", transit_gateway_attachment_id)

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

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

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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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

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


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


@pulumi.output_type
class GetKafkaClusterDedicatedResult(dict):
    def __init__(__self__, *,
                 cku: int,
                 encryption_key: str,
                 zones: Sequence[str]):
        """
        :param int cku: (Required Number) The number of Confluent Kafka Units (CKUs) for Dedicated cluster types. The minimum number of CKUs for `SINGLE_ZONE` dedicated clusters is `1` whereas `MULTI_ZONE` dedicated clusters must have more than `2` CKUs.
        :param str encryption_key: (Optional String) The ID of the encryption key that is used to encrypt the data in the Kafka cluster, for example, `arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab` (key Amazon Resource Name) for AWS or `projects/my-test-project/locations/global/keyRings/test-byok/cryptoKeys/test` for GCP. Append required permissions to the key policy before creating a Kafka cluster, see [Encrypt Confluent Cloud Clusters using Self-Managed Keys](https://docs.confluent.io/cloud/current/clusters/byok/index.html) for more details. At the moment, self-managed encryption keys are only available for the Dedicated clusters on AWS or GCP.
        :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 more than `2` CKUs.
        """
        return pulumi.get(self, "cku")

    @property
    @pulumi.getter(name="encryptionKey")
    def encryption_key(self) -> str:
        """
        (Optional String) The ID of the encryption key that is used to encrypt the data in the Kafka cluster, for example, `arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab` (key Amazon Resource Name) for AWS or `projects/my-test-project/locations/global/keyRings/test-byok/cryptoKeys/test` for GCP. Append required permissions to the key policy before creating a Kafka cluster, see [Encrypt Confluent Cloud Clusters using Self-Managed Keys](https://docs.confluent.io/cloud/current/clusters/byok/index.html) for more details. At the moment, self-managed encryption keys are only available for the Dedicated clusters on AWS or GCP.
        """
        return pulumi.get(self, "encryption_key")

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


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


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


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


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

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

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


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

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


@pulumi.output_type
class GetKsqlClusterCredentialIdentityResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the ksqlDB 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 ksqlDB cluster belongs to, for example, `env-xyz456`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetKsqlClusterEnvironmentResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the ksqlDB cluster belongs to, for example, `env-xyz456`.
        """
        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`.
        """
        return pulumi.get(self, "id")


@pulumi.output_type
class GetKsqlClusterKafkaClusterResult(dict):
    def __init__(__self__, *,
                 id: str):
        """
        :param str id: The ID of the Environment that the ksqlDB 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 ksqlDB cluster belongs to, for example, `env-xyz456`.
        """
        return pulumi.get(self, "id")


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

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

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

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


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

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


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

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


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


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

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

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

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


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

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

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


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

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

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

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

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


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

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

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

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


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


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

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

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

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


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


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

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


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

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


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


@pulumi.output_type
class GetPrivateLinkAccessGcpResult(dict):
    def __init__(__self__, *,
                 project: str):
        """
        :param str project: (Required String) The GCP project ID to allow for Private Service Connect access. You can find your Google Cloud Project ID under **Project ID** section of your [Google Cloud Console dashboard](https://console.cloud.google.com/home/dashboard).
        """
        pulumi.set(__self__, "project", project)

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


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


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

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

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


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

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

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


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

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


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

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


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

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

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


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

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


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

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


@pulumi.output_type
class GetSchemaSchemaReferenceResult(dict):
    def __init__(__self__, *,
                 name: str,
                 subject_name: str,
                 version: int):
        """
        :param str name: (Required String) The name of the subject, representing the subject under which the referenced schema is registered.
        :param str subject_name: The name of the subject (in other words, the namespace), representing the subject under which the schema will be registered, for example, `test-subject`. Schemas evolve safely, following a compatibility mode defined, under a subject name.
        :param int version: (Required Integer) The version of the Schema, for example, `4`.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "subject_name", subject_name)
        pulumi.set(__self__, "version", version)

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

    @property
    @pulumi.getter(name="subjectName")
    def subject_name(self) -> str:
        """
        The name of the subject (in other words, the namespace), representing the subject under which the schema will be registered, for example, `test-subject`. Schemas evolve safely, following a compatibility mode defined, under a subject name.
        """
        return pulumi.get(self, "subject_name")

    @property
    @pulumi.getter
    def version(self) -> int:
        """
        (Required Integer) The version of the Schema, for example, `4`.
        """
        return pulumi.get(self, "version")


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

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


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

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

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


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

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


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

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

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


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

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


@pulumi.output_type
class GetTransitGatewayAttachmentAwResult(dict):
    def __init__(__self__, *,
                 ram_resource_share_arn: str,
                 routes: Sequence[str],
                 transit_gateway_attachment_id: str,
                 transit_gateway_id: str):
        """
        :param str ram_resource_share_arn: (Required String) The Amazon Resource Name (ARN) of the Resource Access Manager (RAM) Resource Share of the transit gateway your Confluent Cloud network attaches to.
        :param Sequence[str] routes: (Required List of String) List of destination routes for traffic from Confluent VPC to customer VPC via Transit Gateway.
        :param str transit_gateway_attachment_id: (Required String) The ID of the AWS Transit Gateway VPC Attachment that attaches Confluent VPC to Transit Gateway.
        :param str transit_gateway_id: (Required String) The ID of the AWS Transit Gateway that you want Confluent CLoud to be attached to. Must start with `tgw-`.
        """
        pulumi.set(__self__, "ram_resource_share_arn", ram_resource_share_arn)
        pulumi.set(__self__, "routes", routes)
        pulumi.set(__self__, "transit_gateway_attachment_id", transit_gateway_attachment_id)
        pulumi.set(__self__, "transit_gateway_id", transit_gateway_id)

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

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

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

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


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


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


