# 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__ = [
    'ClusterScheduling',
    'ClusterSchedulingOnRefresh',
    'ConnectionAwsAccessKeyId',
    'ConnectionAwsAccessKeyIdSecret',
    'ConnectionAwsSecretAccessKey',
    'ConnectionAwsSessionToken',
    'ConnectionAwsSessionTokenSecret',
    'ConnectionConfluentSchemaRegistryAwsPrivatelink',
    'ConnectionConfluentSchemaRegistryPassword',
    'ConnectionConfluentSchemaRegistrySshTunnel',
    'ConnectionConfluentSchemaRegistrySslCertificate',
    'ConnectionConfluentSchemaRegistrySslCertificateAuthority',
    'ConnectionConfluentSchemaRegistrySslCertificateAuthoritySecret',
    'ConnectionConfluentSchemaRegistrySslCertificateSecret',
    'ConnectionConfluentSchemaRegistrySslKey',
    'ConnectionConfluentSchemaRegistryUsername',
    'ConnectionConfluentSchemaRegistryUsernameSecret',
    'ConnectionKafkaAwsPrivatelink',
    'ConnectionKafkaAwsPrivatelinkPrivatelinkConnection',
    'ConnectionKafkaKafkaBroker',
    'ConnectionKafkaKafkaBrokerPrivatelinkConnection',
    'ConnectionKafkaKafkaBrokerSshTunnel',
    'ConnectionKafkaSaslPassword',
    'ConnectionKafkaSaslUsername',
    'ConnectionKafkaSaslUsernameSecret',
    'ConnectionKafkaSshTunnel',
    'ConnectionKafkaSslCertificate',
    'ConnectionKafkaSslCertificateAuthority',
    'ConnectionKafkaSslCertificateAuthoritySecret',
    'ConnectionKafkaSslCertificateSecret',
    'ConnectionKafkaSslKey',
    'ConnectionMysqlAwsPrivatelink',
    'ConnectionMysqlPassword',
    'ConnectionMysqlSshTunnel',
    'ConnectionMysqlSslCertificate',
    'ConnectionMysqlSslCertificateAuthority',
    'ConnectionMysqlSslCertificateAuthoritySecret',
    'ConnectionMysqlSslCertificateSecret',
    'ConnectionMysqlSslKey',
    'ConnectionMysqlUser',
    'ConnectionMysqlUserSecret',
    'ConnectionPostgresAwsPrivatelink',
    'ConnectionPostgresPassword',
    'ConnectionPostgresSshTunnel',
    'ConnectionPostgresSslCertificate',
    'ConnectionPostgresSslCertificateAuthority',
    'ConnectionPostgresSslCertificateAuthoritySecret',
    'ConnectionPostgresSslCertificateSecret',
    'ConnectionPostgresSslKey',
    'ConnectionPostgresUser',
    'ConnectionPostgresUserSecret',
    'GetClusterReplicasClusterReplicaResult',
    'GetClustersClusterResult',
    'GetConnectionsConnectionResult',
    'GetDatabasesDatabaseResult',
    'GetIndexesIndexResult',
    'GetMaterializedViewsMaterializedViewResult',
    'GetRolesRoleResult',
    'GetSCIMConfigsConfigurationResult',
    'GetSCIMGroupsGroupResult',
    'GetSCIMGroupsGroupRoleResult',
    'GetSCIMGroupsGroupUserResult',
    'GetSSOConfigSsoConfigResult',
    'GetSSOConfigSsoConfigDomainResult',
    'GetSSOConfigSsoConfigGroupResult',
    'GetSchemasSchemaResult',
    'GetSecretsSecretResult',
    'GetSinksSinkResult',
    'GetSourcesSourceResult',
    'GetSystemParametersParameterResult',
    'GetTablesTableResult',
    'GetTypesTypeResult',
    'GetViewsViewResult',
    'IndexColExpr',
    'IndexObjName',
    'RegionRegionResult',
    'SinkKafkaEnvelope',
    'SinkKafkaFormat',
    'SinkKafkaFormatAvro',
    'SinkKafkaFormatAvroAvroDocColumn',
    'SinkKafkaFormatAvroAvroDocColumnObject',
    'SinkKafkaFormatAvroAvroDocType',
    'SinkKafkaFormatAvroAvroDocTypeObject',
    'SinkKafkaFormatAvroSchemaRegistryConnection',
    'SinkKafkaFrom',
    'SinkKafkaKafkaConnection',
    'SourceKafkaEnvelope',
    'SourceKafkaExposeProgress',
    'SourceKafkaFormat',
    'SourceKafkaFormatAvro',
    'SourceKafkaFormatAvroSchemaRegistryConnection',
    'SourceKafkaFormatCsv',
    'SourceKafkaFormatProtobuf',
    'SourceKafkaFormatProtobufSchemaRegistryConnection',
    'SourceKafkaKafkaConnection',
    'SourceKafkaKeyFormat',
    'SourceKafkaKeyFormatAvro',
    'SourceKafkaKeyFormatAvroSchemaRegistryConnection',
    'SourceKafkaKeyFormatCsv',
    'SourceKafkaKeyFormatProtobuf',
    'SourceKafkaKeyFormatProtobufSchemaRegistryConnection',
    'SourceKafkaValueFormat',
    'SourceKafkaValueFormatAvro',
    'SourceKafkaValueFormatAvroSchemaRegistryConnection',
    'SourceKafkaValueFormatCsv',
    'SourceKafkaValueFormatProtobuf',
    'SourceKafkaValueFormatProtobufSchemaRegistryConnection',
    'SourceLoadgenAuctionOptions',
    'SourceLoadgenCounterOptions',
    'SourceLoadgenExposeProgress',
    'SourceLoadgenKeyValueOptions',
    'SourceLoadgenMarketingOptions',
    'SourceLoadgenTpchOptions',
    'SourceMysqlExposeProgress',
    'SourceMysqlMysqlConnection',
    'SourceMysqlTable',
    'SourcePostgresExposeProgress',
    'SourcePostgresPostgresConnection',
    'SourcePostgresTable',
    'SourceWebhookCheckOption',
    'SourceWebhookCheckOptionField',
    'SourceWebhookCheckOptionFieldSecret',
    'SourceWebhookIncludeHeader',
    'SourceWebhookIncludeHeaders',
    'TableColumn',
    'TypeListProperties',
    'TypeMapProperties',
    'TypeRowProperty',
]

@pulumi.output_type
class ClusterScheduling(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "onRefresh":
            suggest = "on_refresh"

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

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

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

    def __init__(__self__, *,
                 on_refresh: Optional['outputs.ClusterSchedulingOnRefresh'] = None):
        """
        :param 'ClusterSchedulingOnRefreshArgs' on_refresh: Configuration for refreshing the cluster.
        """
        if on_refresh is not None:
            pulumi.set(__self__, "on_refresh", on_refresh)

    @property
    @pulumi.getter(name="onRefresh")
    def on_refresh(self) -> Optional['outputs.ClusterSchedulingOnRefresh']:
        """
        Configuration for refreshing the cluster.
        """
        return pulumi.get(self, "on_refresh")


@pulumi.output_type
class ClusterSchedulingOnRefresh(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rehydrationTimeEstimate":
            suggest = "rehydration_time_estimate"

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

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

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

    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 rehydration_time_estimate: Optional[str] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if rehydration_time_estimate is not None:
            pulumi.set(__self__, "rehydration_time_estimate", rehydration_time_estimate)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

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


@pulumi.output_type
class ConnectionAwsAccessKeyId(dict):
    def __init__(__self__, *,
                 secret: Optional['outputs.ConnectionAwsAccessKeyIdSecret'] = None,
                 text: Optional[str] = None):
        """
        :param 'ConnectionAwsAccessKeyIdSecretArgs' secret: The `access_key_id` secret value. Conflicts with `text` within this block.
        :param str text: The `access_key_id` text value. Conflicts with `secret` within this block
        """
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def secret(self) -> Optional['outputs.ConnectionAwsAccessKeyIdSecret']:
        """
        The `access_key_id` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        The `access_key_id` text value. Conflicts with `secret` within this block
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class ConnectionAwsAccessKeyIdSecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the connection.
        :param str database_name: The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionAwsSecretAccessKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The secret*access*key name.
        :param str database_name: The secret*access*key database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The secret*access*key schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The secret*access*key name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The secret*access*key database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The secret*access*key schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionAwsSessionToken(dict):
    def __init__(__self__, *,
                 secret: Optional['outputs.ConnectionAwsSessionTokenSecret'] = None,
                 text: Optional[str] = None):
        """
        :param 'ConnectionAwsSessionTokenSecretArgs' secret: The `session_token` secret value. Conflicts with `text` within this block.
        :param str text: The `session_token` text value. Conflicts with `secret` within this block
        """
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def secret(self) -> Optional['outputs.ConnectionAwsSessionTokenSecret']:
        """
        The `session_token` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        The `session_token` text value. Conflicts with `secret` within this block
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class ConnectionAwsSessionTokenSecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the connection.
        :param str database_name: The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionConfluentSchemaRegistryAwsPrivatelink(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The aws_privatelink name.
        :param str database_name: The aws_privatelink database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The aws_privatelink schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The aws_privatelink database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The aws_privatelink schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionConfluentSchemaRegistryPassword(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The password name.
        :param str database_name: The password database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The password schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The password database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The password schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionConfluentSchemaRegistrySshTunnel(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The ssh_tunnel name.
        :param str database_name: The ssh_tunnel database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The ssh_tunnel schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The ssh_tunnel database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The ssh_tunnel schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionConfluentSchemaRegistrySslCertificate(dict):
    def __init__(__self__, *,
                 secret: Optional['outputs.ConnectionConfluentSchemaRegistrySslCertificateSecret'] = None,
                 text: Optional[str] = None):
        """
        :param 'ConnectionConfluentSchemaRegistrySslCertificateSecretArgs' secret: The `ssl_certificate` secret value. Conflicts with `text` within this block.
        :param str text: The `ssl_certificate` text value. Conflicts with `secret` within this block
        """
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def secret(self) -> Optional['outputs.ConnectionConfluentSchemaRegistrySslCertificateSecret']:
        """
        The `ssl_certificate` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        The `ssl_certificate` text value. Conflicts with `secret` within this block
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class ConnectionConfluentSchemaRegistrySslCertificateAuthority(dict):
    def __init__(__self__, *,
                 secret: Optional['outputs.ConnectionConfluentSchemaRegistrySslCertificateAuthoritySecret'] = None,
                 text: Optional[str] = None):
        """
        :param 'ConnectionConfluentSchemaRegistrySslCertificateAuthoritySecretArgs' secret: The `ssl_certificate_authority` secret value. Conflicts with `text` within this block.
        :param str text: The `ssl_certificate_authority` text value. Conflicts with `secret` within this block
        """
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def secret(self) -> Optional['outputs.ConnectionConfluentSchemaRegistrySslCertificateAuthoritySecret']:
        """
        The `ssl_certificate_authority` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        The `ssl_certificate_authority` text value. Conflicts with `secret` within this block
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class ConnectionConfluentSchemaRegistrySslCertificateAuthoritySecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the connection.
        :param str database_name: The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionConfluentSchemaRegistrySslCertificateSecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the connection.
        :param str database_name: The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionConfluentSchemaRegistrySslKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The ssl_key name.
        :param str database_name: The ssl_key database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The ssl_key schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The ssl_key database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The ssl_key schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionConfluentSchemaRegistryUsername(dict):
    def __init__(__self__, *,
                 secret: Optional['outputs.ConnectionConfluentSchemaRegistryUsernameSecret'] = None,
                 text: Optional[str] = None):
        """
        :param 'ConnectionConfluentSchemaRegistryUsernameSecretArgs' secret: The `username` secret value. Conflicts with `text` within this block.
        :param str text: The `username` text value. Conflicts with `secret` within this block
        """
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def secret(self) -> Optional['outputs.ConnectionConfluentSchemaRegistryUsernameSecret']:
        """
        The `username` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        The `username` text value. Conflicts with `secret` within this block
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class ConnectionConfluentSchemaRegistryUsernameSecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the connection.
        :param str database_name: The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionKafkaAwsPrivatelink(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privatelinkConnection":
            suggest = "privatelink_connection"
        elif key == "privatelinkConnectionPort":
            suggest = "privatelink_connection_port"

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

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

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

    def __init__(__self__, *,
                 privatelink_connection: 'outputs.ConnectionKafkaAwsPrivatelinkPrivatelinkConnection',
                 privatelink_connection_port: int):
        """
        :param 'ConnectionKafkaAwsPrivatelinkPrivatelinkConnectionArgs' privatelink_connection: The AWS PrivateLink connection name in Materialize.
        :param int privatelink_connection_port: The port of the AWS PrivateLink connection.
        """
        pulumi.set(__self__, "privatelink_connection", privatelink_connection)
        pulumi.set(__self__, "privatelink_connection_port", privatelink_connection_port)

    @property
    @pulumi.getter(name="privatelinkConnection")
    def privatelink_connection(self) -> 'outputs.ConnectionKafkaAwsPrivatelinkPrivatelinkConnection':
        """
        The AWS PrivateLink connection name in Materialize.
        """
        return pulumi.get(self, "privatelink_connection")

    @property
    @pulumi.getter(name="privatelinkConnectionPort")
    def privatelink_connection_port(self) -> int:
        """
        The port of the AWS PrivateLink connection.
        """
        return pulumi.get(self, "privatelink_connection_port")


@pulumi.output_type
class ConnectionKafkaAwsPrivatelinkPrivatelinkConnection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the connection.
        :param str database_name: The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionKafkaKafkaBroker(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "availabilityZone":
            suggest = "availability_zone"
        elif key == "privatelinkConnection":
            suggest = "privatelink_connection"
        elif key == "sshTunnel":
            suggest = "ssh_tunnel"
        elif key == "targetGroupPort":
            suggest = "target_group_port"

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

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

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

    def __init__(__self__, *,
                 broker: str,
                 availability_zone: Optional[str] = None,
                 privatelink_connection: Optional['outputs.ConnectionKafkaKafkaBrokerPrivatelinkConnection'] = None,
                 ssh_tunnel: Optional['outputs.ConnectionKafkaKafkaBrokerSshTunnel'] = None,
                 target_group_port: Optional[int] = None):
        """
        :param str broker: The Kafka broker, in the form of `host:port`.
        :param str availability_zone: The availability zone of the Kafka broker.
        :param 'ConnectionKafkaKafkaBrokerPrivatelinkConnectionArgs' privatelink_connection: The AWS PrivateLink connection name in Materialize.
        :param 'ConnectionKafkaKafkaBrokerSshTunnelArgs' ssh_tunnel: The name of an SSH tunnel connection to route network traffic through by default.
        :param int target_group_port: The port of the target group associated with the Kafka broker.
        """
        pulumi.set(__self__, "broker", broker)
        if availability_zone is not None:
            pulumi.set(__self__, "availability_zone", availability_zone)
        if privatelink_connection is not None:
            pulumi.set(__self__, "privatelink_connection", privatelink_connection)
        if ssh_tunnel is not None:
            pulumi.set(__self__, "ssh_tunnel", ssh_tunnel)
        if target_group_port is not None:
            pulumi.set(__self__, "target_group_port", target_group_port)

    @property
    @pulumi.getter
    def broker(self) -> str:
        """
        The Kafka broker, in the form of `host:port`.
        """
        return pulumi.get(self, "broker")

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> Optional[str]:
        """
        The availability zone of the Kafka broker.
        """
        return pulumi.get(self, "availability_zone")

    @property
    @pulumi.getter(name="privatelinkConnection")
    def privatelink_connection(self) -> Optional['outputs.ConnectionKafkaKafkaBrokerPrivatelinkConnection']:
        """
        The AWS PrivateLink connection name in Materialize.
        """
        return pulumi.get(self, "privatelink_connection")

    @property
    @pulumi.getter(name="sshTunnel")
    def ssh_tunnel(self) -> Optional['outputs.ConnectionKafkaKafkaBrokerSshTunnel']:
        """
        The name of an SSH tunnel connection to route network traffic through by default.
        """
        return pulumi.get(self, "ssh_tunnel")

    @property
    @pulumi.getter(name="targetGroupPort")
    def target_group_port(self) -> Optional[int]:
        """
        The port of the target group associated with the Kafka broker.
        """
        return pulumi.get(self, "target_group_port")


@pulumi.output_type
class ConnectionKafkaKafkaBrokerPrivatelinkConnection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the connection.
        :param str database_name: The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionKafkaKafkaBrokerSshTunnel(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The ssh_tunnel name.
        :param str database_name: The ssh_tunnel database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The ssh_tunnel schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The ssh_tunnel database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The ssh_tunnel schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionKafkaSaslPassword(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The sasl_password name.
        :param str database_name: The sasl_password database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The sasl_password schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The sasl_password database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The sasl_password schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionKafkaSaslUsername(dict):
    def __init__(__self__, *,
                 secret: Optional['outputs.ConnectionKafkaSaslUsernameSecret'] = None,
                 text: Optional[str] = None):
        """
        :param 'ConnectionKafkaSaslUsernameSecretArgs' secret: The `sasl_username` secret value. Conflicts with `text` within this block.
        :param str text: The `sasl_username` text value. Conflicts with `secret` within this block
        """
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def secret(self) -> Optional['outputs.ConnectionKafkaSaslUsernameSecret']:
        """
        The `sasl_username` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        The `sasl_username` text value. Conflicts with `secret` within this block
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class ConnectionKafkaSaslUsernameSecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the connection.
        :param str database_name: The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionKafkaSshTunnel(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The ssh_tunnel name.
        :param str database_name: The ssh_tunnel database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The ssh_tunnel schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The ssh_tunnel database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The ssh_tunnel schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionKafkaSslCertificate(dict):
    def __init__(__self__, *,
                 secret: Optional['outputs.ConnectionKafkaSslCertificateSecret'] = None,
                 text: Optional[str] = None):
        """
        :param 'ConnectionKafkaSslCertificateSecretArgs' secret: The `ssl_certificate` secret value. Conflicts with `text` within this block.
        :param str text: The `ssl_certificate` text value. Conflicts with `secret` within this block
        """
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def secret(self) -> Optional['outputs.ConnectionKafkaSslCertificateSecret']:
        """
        The `ssl_certificate` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        The `ssl_certificate` text value. Conflicts with `secret` within this block
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class ConnectionKafkaSslCertificateAuthority(dict):
    def __init__(__self__, *,
                 secret: Optional['outputs.ConnectionKafkaSslCertificateAuthoritySecret'] = None,
                 text: Optional[str] = None):
        """
        :param 'ConnectionKafkaSslCertificateAuthoritySecretArgs' secret: The `ssl_certificate_authority` secret value. Conflicts with `text` within this block.
        :param str text: The `ssl_certificate_authority` text value. Conflicts with `secret` within this block
        """
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def secret(self) -> Optional['outputs.ConnectionKafkaSslCertificateAuthoritySecret']:
        """
        The `ssl_certificate_authority` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        The `ssl_certificate_authority` text value. Conflicts with `secret` within this block
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class ConnectionKafkaSslCertificateAuthoritySecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the connection.
        :param str database_name: The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionKafkaSslCertificateSecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the connection.
        :param str database_name: The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionKafkaSslKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The ssl_key name.
        :param str database_name: The ssl_key database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The ssl_key schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The ssl_key database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The ssl_key schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionMysqlAwsPrivatelink(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The aws_privatelink name.
        :param str database_name: The aws_privatelink database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The aws_privatelink schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The aws_privatelink database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The aws_privatelink schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionMysqlPassword(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The password name.
        :param str database_name: The password database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The password schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The password database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The password schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionMysqlSshTunnel(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The ssh_tunnel name.
        :param str database_name: The ssh_tunnel database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The ssh_tunnel schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The ssh_tunnel database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The ssh_tunnel schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionMysqlSslCertificate(dict):
    def __init__(__self__, *,
                 secret: Optional['outputs.ConnectionMysqlSslCertificateSecret'] = None,
                 text: Optional[str] = None):
        """
        :param 'ConnectionMysqlSslCertificateSecretArgs' secret: The `ssl_certificate` secret value. Conflicts with `text` within this block.
        :param str text: The `ssl_certificate` text value. Conflicts with `secret` within this block
        """
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def secret(self) -> Optional['outputs.ConnectionMysqlSslCertificateSecret']:
        """
        The `ssl_certificate` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        The `ssl_certificate` text value. Conflicts with `secret` within this block
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class ConnectionMysqlSslCertificateAuthority(dict):
    def __init__(__self__, *,
                 secret: Optional['outputs.ConnectionMysqlSslCertificateAuthoritySecret'] = None,
                 text: Optional[str] = None):
        """
        :param 'ConnectionMysqlSslCertificateAuthoritySecretArgs' secret: The `ssl_certificate_authority` secret value. Conflicts with `text` within this block.
        :param str text: The `ssl_certificate_authority` text value. Conflicts with `secret` within this block
        """
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def secret(self) -> Optional['outputs.ConnectionMysqlSslCertificateAuthoritySecret']:
        """
        The `ssl_certificate_authority` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        The `ssl_certificate_authority` text value. Conflicts with `secret` within this block
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class ConnectionMysqlSslCertificateAuthoritySecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the connection.
        :param str database_name: The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionMysqlSslCertificateSecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the connection.
        :param str database_name: The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionMysqlSslKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The ssl_key name.
        :param str database_name: The ssl_key database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The ssl_key schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The ssl_key database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The ssl_key schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionMysqlUser(dict):
    def __init__(__self__, *,
                 secret: Optional['outputs.ConnectionMysqlUserSecret'] = None,
                 text: Optional[str] = None):
        """
        :param 'ConnectionMysqlUserSecretArgs' secret: The `user` secret value. Conflicts with `text` within this block.
        :param str text: The `user` text value. Conflicts with `secret` within this block
        """
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def secret(self) -> Optional['outputs.ConnectionMysqlUserSecret']:
        """
        The `user` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        The `user` text value. Conflicts with `secret` within this block
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class ConnectionMysqlUserSecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the connection.
        :param str database_name: The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionPostgresAwsPrivatelink(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The aws_privatelink name.
        :param str database_name: The aws_privatelink database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The aws_privatelink schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The aws_privatelink database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The aws_privatelink schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionPostgresPassword(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The password name.
        :param str database_name: The password database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The password schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The password database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The password schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionPostgresSshTunnel(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The ssh_tunnel name.
        :param str database_name: The ssh_tunnel database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The ssh_tunnel schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The ssh_tunnel database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The ssh_tunnel schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionPostgresSslCertificate(dict):
    def __init__(__self__, *,
                 secret: Optional['outputs.ConnectionPostgresSslCertificateSecret'] = None,
                 text: Optional[str] = None):
        """
        :param 'ConnectionPostgresSslCertificateSecretArgs' secret: The `ssl_certificate` secret value. Conflicts with `text` within this block.
        :param str text: The `ssl_certificate` text value. Conflicts with `secret` within this block
        """
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def secret(self) -> Optional['outputs.ConnectionPostgresSslCertificateSecret']:
        """
        The `ssl_certificate` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        The `ssl_certificate` text value. Conflicts with `secret` within this block
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class ConnectionPostgresSslCertificateAuthority(dict):
    def __init__(__self__, *,
                 secret: Optional['outputs.ConnectionPostgresSslCertificateAuthoritySecret'] = None,
                 text: Optional[str] = None):
        """
        :param 'ConnectionPostgresSslCertificateAuthoritySecretArgs' secret: The `ssl_certificate_authority` secret value. Conflicts with `text` within this block.
        :param str text: The `ssl_certificate_authority` text value. Conflicts with `secret` within this block
        """
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def secret(self) -> Optional['outputs.ConnectionPostgresSslCertificateAuthoritySecret']:
        """
        The `ssl_certificate_authority` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        The `ssl_certificate_authority` text value. Conflicts with `secret` within this block
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class ConnectionPostgresSslCertificateAuthoritySecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the connection.
        :param str database_name: The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionPostgresSslCertificateSecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the connection.
        :param str database_name: The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionPostgresSslKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The ssl_key name.
        :param str database_name: The ssl_key database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The ssl_key schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The ssl_key database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The ssl_key schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class ConnectionPostgresUser(dict):
    def __init__(__self__, *,
                 secret: Optional['outputs.ConnectionPostgresUserSecret'] = None,
                 text: Optional[str] = None):
        """
        :param 'ConnectionPostgresUserSecretArgs' secret: The `user` secret value. Conflicts with `text` within this block.
        :param str text: The `user` text value. Conflicts with `secret` within this block
        """
        if secret is not None:
            pulumi.set(__self__, "secret", secret)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def secret(self) -> Optional['outputs.ConnectionPostgresUserSecret']:
        """
        The `user` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter
    def text(self) -> Optional[str]:
        """
        The `user` text value. Conflicts with `secret` within this block
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class ConnectionPostgresUserSecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the connection.
        :param str database_name: The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the connection database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the connection schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class GetClusterReplicasClusterReplicaResult(dict):
    def __init__(__self__, *,
                 availability_zone: str,
                 cluster: str,
                 disk: bool,
                 id: str,
                 name: str,
                 size: str):
        """
        :param str id: The ID of this resource.
        """
        pulumi.set(__self__, "availability_zone", availability_zone)
        pulumi.set(__self__, "cluster", cluster)
        pulumi.set(__self__, "disk", disk)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "size", size)

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

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

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

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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

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


@pulumi.output_type
class GetClustersClusterResult(dict):
    def __init__(__self__, *,
                 disk: bool,
                 id: str,
                 managed: bool,
                 name: str,
                 replication_factor: int,
                 size: str):
        """
        :param str id: The ID of this resource.
        """
        pulumi.set(__self__, "disk", disk)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "managed", managed)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "replication_factor", replication_factor)
        pulumi.set(__self__, "size", size)

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

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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

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

    @property
    @pulumi.getter(name="replicationFactor")
    def replication_factor(self) -> int:
        return pulumi.get(self, "replication_factor")

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


@pulumi.output_type
class GetConnectionsConnectionResult(dict):
    def __init__(__self__, *,
                 database_name: str,
                 id: str,
                 name: str,
                 schema_name: str,
                 type: str):
        """
        :param str database_name: Limit connections to a specific database
        :param str id: The ID of this resource.
        :param str schema_name: Limit connections to a specific schema within a specific database
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "schema_name", schema_name)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        Limit connections to a specific database
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> str:
        """
        Limit connections to a specific schema within a specific database
        """
        return pulumi.get(self, "schema_name")

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


@pulumi.output_type
class GetDatabasesDatabaseResult(dict):
    def __init__(__self__, *,
                 id: str,
                 name: str):
        """
        :param str id: The ID of this resource.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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


@pulumi.output_type
class GetIndexesIndexResult(dict):
    def __init__(__self__, *,
                 id: str,
                 name: str,
                 obj_database: str,
                 obj_name: str,
                 obj_schema: str):
        """
        :param str id: The ID of this resource.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "obj_database", obj_database)
        pulumi.set(__self__, "obj_name", obj_name)
        pulumi.set(__self__, "obj_schema", obj_schema)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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

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

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

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


@pulumi.output_type
class GetMaterializedViewsMaterializedViewResult(dict):
    def __init__(__self__, *,
                 database_name: str,
                 id: str,
                 name: str,
                 schema_name: str):
        """
        :param str database_name: Limit materialized views to a specific database
        :param str id: The ID of this resource.
        :param str schema_name: Limit materialized views to a specific schema within a specific database
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "schema_name", schema_name)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        Limit materialized views to a specific database
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> str:
        """
        Limit materialized views to a specific schema within a specific database
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class GetRolesRoleResult(dict):
    def __init__(__self__, *,
                 id: str,
                 name: str):
        """
        :param str id: The ID of this resource.
        """
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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


@pulumi.output_type
class GetSCIMConfigsConfigurationResult(dict):
    def __init__(__self__, *,
                 connection_name: str,
                 created_at: str,
                 id: str,
                 source: str,
                 sync_to_user_management: bool,
                 tenant_id: str):
        """
        :param str id: The ID of this resource.
        """
        pulumi.set(__self__, "connection_name", connection_name)
        pulumi.set(__self__, "created_at", created_at)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "source", source)
        pulumi.set(__self__, "sync_to_user_management", sync_to_user_management)
        pulumi.set(__self__, "tenant_id", tenant_id)

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

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

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="syncToUserManagement")
    def sync_to_user_management(self) -> bool:
        return pulumi.get(self, "sync_to_user_management")

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


@pulumi.output_type
class GetSCIMGroupsGroupResult(dict):
    def __init__(__self__, *,
                 description: str,
                 id: str,
                 managed_by: str,
                 metadata: str,
                 name: str,
                 roles: Sequence['outputs.GetSCIMGroupsGroupRoleResult'],
                 users: Sequence['outputs.GetSCIMGroupsGroupUserResult']):
        """
        :param str id: The ID of this resource.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "managed_by", managed_by)
        pulumi.set(__self__, "metadata", metadata)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "roles", roles)
        pulumi.set(__self__, "users", users)

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

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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

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

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

    @property
    @pulumi.getter
    def roles(self) -> Sequence['outputs.GetSCIMGroupsGroupRoleResult']:
        return pulumi.get(self, "roles")

    @property
    @pulumi.getter
    def users(self) -> Sequence['outputs.GetSCIMGroupsGroupUserResult']:
        return pulumi.get(self, "users")


@pulumi.output_type
class GetSCIMGroupsGroupRoleResult(dict):
    def __init__(__self__, *,
                 description: str,
                 id: str,
                 is_default: bool,
                 key: str,
                 name: str):
        """
        :param str id: The ID of this resource.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "is_default", is_default)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "name", name)

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

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="isDefault")
    def is_default(self) -> bool:
        return pulumi.get(self, "is_default")

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

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


@pulumi.output_type
class GetSCIMGroupsGroupUserResult(dict):
    def __init__(__self__, *,
                 email: str,
                 id: str,
                 name: str):
        """
        :param str id: The ID of this resource.
        """
        pulumi.set(__self__, "email", email)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

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

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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


@pulumi.output_type
class GetSSOConfigSsoConfigResult(dict):
    def __init__(__self__, *,
                 domains: Sequence['outputs.GetSSOConfigSsoConfigDomainResult'],
                 enabled: bool,
                 groups: Sequence['outputs.GetSSOConfigSsoConfigGroupResult'],
                 id: str,
                 oidc_client_id: str,
                 oidc_secret: str,
                 public_certificate: str,
                 role_ids: Sequence[str],
                 sign_request: bool,
                 sso_endpoint: str,
                 type: str):
        """
        :param str id: The ID of this resource.
        """
        pulumi.set(__self__, "domains", domains)
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "groups", groups)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "oidc_client_id", oidc_client_id)
        pulumi.set(__self__, "oidc_secret", oidc_secret)
        pulumi.set(__self__, "public_certificate", public_certificate)
        pulumi.set(__self__, "role_ids", role_ids)
        pulumi.set(__self__, "sign_request", sign_request)
        pulumi.set(__self__, "sso_endpoint", sso_endpoint)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def domains(self) -> Sequence['outputs.GetSSOConfigSsoConfigDomainResult']:
        return pulumi.get(self, "domains")

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

    @property
    @pulumi.getter
    def groups(self) -> Sequence['outputs.GetSSOConfigSsoConfigGroupResult']:
        return pulumi.get(self, "groups")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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

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

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

    @property
    @pulumi.getter(name="roleIds")
    def role_ids(self) -> Sequence[str]:
        return pulumi.get(self, "role_ids")

    @property
    @pulumi.getter(name="signRequest")
    def sign_request(self) -> bool:
        return pulumi.get(self, "sign_request")

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

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


@pulumi.output_type
class GetSSOConfigSsoConfigDomainResult(dict):
    def __init__(__self__, *,
                 domain: str,
                 id: str,
                 validated: bool):
        """
        :param str id: The ID of this resource.
        """
        pulumi.set(__self__, "domain", domain)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "validated", validated)

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

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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


@pulumi.output_type
class GetSSOConfigSsoConfigGroupResult(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 group: str,
                 id: str,
                 role_ids: Sequence[str]):
        """
        :param str id: The ID of this resource.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "group", group)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "role_ids", role_ids)

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

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

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="roleIds")
    def role_ids(self) -> Sequence[str]:
        return pulumi.get(self, "role_ids")


@pulumi.output_type
class GetSchemasSchemaResult(dict):
    def __init__(__self__, *,
                 database_name: str,
                 id: str,
                 name: str):
        """
        :param str database_name: Limit schemas to a specific database
        :param str id: The ID of this resource.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        Limit schemas to a specific database
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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


@pulumi.output_type
class GetSecretsSecretResult(dict):
    def __init__(__self__, *,
                 database_name: str,
                 id: str,
                 name: str,
                 schema_name: str):
        """
        :param str database_name: Limit secrets to a specific database
        :param str id: The ID of this resource.
        :param str schema_name: Limit secrets to a specific schema within a specific database
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "schema_name", schema_name)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        Limit secrets to a specific database
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> str:
        """
        Limit secrets to a specific schema within a specific database
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class GetSinksSinkResult(dict):
    def __init__(__self__, *,
                 cluster_name: str,
                 connection_name: str,
                 database_name: str,
                 envelope_type: str,
                 id: str,
                 name: str,
                 schema_name: str,
                 size: str,
                 type: str):
        """
        :param str database_name: Limit sinks to a specific database
        :param str id: The ID of this resource.
        :param str schema_name: Limit sinks to a specific schema within a specific database
        """
        pulumi.set(__self__, "cluster_name", cluster_name)
        pulumi.set(__self__, "connection_name", connection_name)
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "envelope_type", envelope_type)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "schema_name", schema_name)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "type", type)

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

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        Limit sinks to a specific database
        """
        return pulumi.get(self, "database_name")

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

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> str:
        """
        Limit sinks to a specific schema within a specific database
        """
        return pulumi.get(self, "schema_name")

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

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


@pulumi.output_type
class GetSourcesSourceResult(dict):
    def __init__(__self__, *,
                 cluster_name: str,
                 connection_name: str,
                 database_name: str,
                 envelope_type: str,
                 id: str,
                 name: str,
                 schema_name: str,
                 size: str,
                 type: str):
        """
        :param str database_name: Limit sources to a specific database
        :param str id: The ID of this resource.
        :param str schema_name: Limit sources to a specific schema within a specific database
        """
        pulumi.set(__self__, "cluster_name", cluster_name)
        pulumi.set(__self__, "connection_name", connection_name)
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "envelope_type", envelope_type)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "schema_name", schema_name)
        pulumi.set(__self__, "size", size)
        pulumi.set(__self__, "type", type)

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

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        Limit sources to a specific database
        """
        return pulumi.get(self, "database_name")

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

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> str:
        """
        Limit sources to a specific schema within a specific database
        """
        return pulumi.get(self, "schema_name")

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

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


@pulumi.output_type
class GetSystemParametersParameterResult(dict):
    def __init__(__self__, *,
                 description: str,
                 name: str,
                 setting: str):
        """
        :param str name: The name of the specific system parameter to fetch.
        """
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "setting", setting)

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

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the specific system parameter to fetch.
        """
        return pulumi.get(self, "name")

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


@pulumi.output_type
class GetTablesTableResult(dict):
    def __init__(__self__, *,
                 database_name: str,
                 id: str,
                 name: str,
                 schema_name: str):
        """
        :param str database_name: Limit tables to a specific database
        :param str id: The ID of this resource.
        :param str schema_name: Limit tables to a specific schema within a specific database
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "schema_name", schema_name)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        Limit tables to a specific database
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> str:
        """
        Limit tables to a specific schema within a specific database
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class GetTypesTypeResult(dict):
    def __init__(__self__, *,
                 category: str,
                 database_name: str,
                 id: str,
                 name: str,
                 schema_name: str):
        """
        :param str database_name: Limit types to a specific database
        :param str id: The ID of this resource.
        :param str schema_name: Limit types to a specific schema within a specific database
        """
        pulumi.set(__self__, "category", category)
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        Limit types to a specific database
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> str:
        """
        Limit types to a specific schema within a specific database
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class GetViewsViewResult(dict):
    def __init__(__self__, *,
                 database_name: str,
                 id: str,
                 name: str,
                 schema_name: str):
        """
        :param str database_name: Limit views to a specific database
        :param str id: The ID of this resource.
        :param str schema_name: Limit views to a specific schema within a specific database
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "schema_name", schema_name)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        Limit views to a specific database
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> str:
        """
        Limit views to a specific schema within a specific database
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class IndexColExpr(dict):
    def __init__(__self__, *,
                 field: str):
        """
        :param str field: The name of the option you want to set.
        """
        pulumi.set(__self__, "field", field)

    @property
    @pulumi.getter
    def field(self) -> str:
        """
        The name of the option you want to set.
        """
        return pulumi.get(self, "field")


@pulumi.output_type
class IndexObjName(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The obj_name name.
        :param str database_name: The obj_name database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The obj_name schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The obj_name database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The obj_name schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class RegionRegionResult(dict):
    def __init__(__self__, *,
                 cloud_provider: str,
                 host: str,
                 id: str,
                 name: str,
                 url: str):
        """
        :param str id: The ID of this resource.
        """
        pulumi.set(__self__, "cloud_provider", cloud_provider)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "url", url)

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

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

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The ID of this resource.
        """
        return pulumi.get(self, "id")

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

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


@pulumi.output_type
class SinkKafkaEnvelope(dict):
    def __init__(__self__, *,
                 debezium: Optional[bool] = None,
                 upsert: Optional[bool] = None):
        """
        :param bool debezium: The generated schemas have a Debezium-style diff envelope to capture changes in the input view or source.
        :param bool upsert: The sink emits data with upsert semantics: updates and inserts for the given key are expressed as a value, and deletes are expressed as a null value payload in Kafka.
        """
        if debezium is not None:
            pulumi.set(__self__, "debezium", debezium)
        if upsert is not None:
            pulumi.set(__self__, "upsert", upsert)

    @property
    @pulumi.getter
    def debezium(self) -> Optional[bool]:
        """
        The generated schemas have a Debezium-style diff envelope to capture changes in the input view or source.
        """
        return pulumi.get(self, "debezium")

    @property
    @pulumi.getter
    def upsert(self) -> Optional[bool]:
        """
        The sink emits data with upsert semantics: updates and inserts for the given key are expressed as a value, and deletes are expressed as a null value payload in Kafka.
        """
        return pulumi.get(self, "upsert")


@pulumi.output_type
class SinkKafkaFormat(dict):
    def __init__(__self__, *,
                 avro: Optional['outputs.SinkKafkaFormatAvro'] = None,
                 json: Optional[bool] = None):
        """
        :param 'SinkKafkaFormatAvroArgs' avro: Avro format.
        :param bool json: JSON format.
        """
        if avro is not None:
            pulumi.set(__self__, "avro", avro)
        if json is not None:
            pulumi.set(__self__, "json", json)

    @property
    @pulumi.getter
    def avro(self) -> Optional['outputs.SinkKafkaFormatAvro']:
        """
        Avro format.
        """
        return pulumi.get(self, "avro")

    @property
    @pulumi.getter
    def json(self) -> Optional[bool]:
        """
        JSON format.
        """
        return pulumi.get(self, "json")


@pulumi.output_type
class SinkKafkaFormatAvro(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "schemaRegistryConnection":
            suggest = "schema_registry_connection"
        elif key == "avroDocColumns":
            suggest = "avro_doc_columns"
        elif key == "avroDocType":
            suggest = "avro_doc_type"
        elif key == "avroKeyFullname":
            suggest = "avro_key_fullname"
        elif key == "avroValueFullname":
            suggest = "avro_value_fullname"

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

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

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

    def __init__(__self__, *,
                 schema_registry_connection: 'outputs.SinkKafkaFormatAvroSchemaRegistryConnection',
                 avro_doc_columns: Optional[Sequence['outputs.SinkKafkaFormatAvroAvroDocColumn']] = None,
                 avro_doc_type: Optional['outputs.SinkKafkaFormatAvroAvroDocType'] = None,
                 avro_key_fullname: Optional[str] = None,
                 avro_value_fullname: Optional[str] = None):
        pulumi.set(__self__, "schema_registry_connection", schema_registry_connection)
        if avro_doc_columns is not None:
            pulumi.set(__self__, "avro_doc_columns", avro_doc_columns)
        if avro_doc_type is not None:
            pulumi.set(__self__, "avro_doc_type", avro_doc_type)
        if avro_key_fullname is not None:
            pulumi.set(__self__, "avro_key_fullname", avro_key_fullname)
        if avro_value_fullname is not None:
            pulumi.set(__self__, "avro_value_fullname", avro_value_fullname)

    @property
    @pulumi.getter(name="schemaRegistryConnection")
    def schema_registry_connection(self) -> 'outputs.SinkKafkaFormatAvroSchemaRegistryConnection':
        return pulumi.get(self, "schema_registry_connection")

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

    @property
    @pulumi.getter(name="avroDocType")
    def avro_doc_type(self) -> Optional['outputs.SinkKafkaFormatAvroAvroDocType']:
        return pulumi.get(self, "avro_doc_type")

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

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


@pulumi.output_type
class SinkKafkaFormatAvroAvroDocColumn(dict):
    def __init__(__self__, *,
                 column: str,
                 doc: str,
                 object: 'outputs.SinkKafkaFormatAvroAvroDocColumnObject',
                 key: Optional[bool] = None,
                 value: Optional[bool] = None):
        """
        :param bool key: An optional list of columns to use for the Kafka key. If unspecified, the Kafka key is left unset.
        """
        pulumi.set(__self__, "column", column)
        pulumi.set(__self__, "doc", doc)
        pulumi.set(__self__, "object", object)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

    @property
    @pulumi.getter
    def key(self) -> Optional[bool]:
        """
        An optional list of columns to use for the Kafka key. If unspecified, the Kafka key is left unset.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[bool]:
        return pulumi.get(self, "value")


@pulumi.output_type
class SinkKafkaFormatAvroAvroDocColumnObject(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the sink.
        :param str database_name: The identifier for the sink database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the sink schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the sink database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the sink schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SinkKafkaFormatAvroAvroDocType(dict):
    def __init__(__self__, *,
                 doc: str,
                 object: 'outputs.SinkKafkaFormatAvroAvroDocTypeObject',
                 key: Optional[bool] = None,
                 value: Optional[bool] = None):
        """
        :param bool key: An optional list of columns to use for the Kafka key. If unspecified, the Kafka key is left unset.
        """
        pulumi.set(__self__, "doc", doc)
        pulumi.set(__self__, "object", object)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

    @property
    @pulumi.getter
    def key(self) -> Optional[bool]:
        """
        An optional list of columns to use for the Kafka key. If unspecified, the Kafka key is left unset.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> Optional[bool]:
        return pulumi.get(self, "value")


@pulumi.output_type
class SinkKafkaFormatAvroAvroDocTypeObject(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the sink.
        :param str database_name: The identifier for the sink database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the sink schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the sink database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the sink schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SinkKafkaFormatAvroSchemaRegistryConnection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the sink.
        :param str database_name: The identifier for the sink database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the sink schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the sink database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the sink schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SinkKafkaFrom(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The from name.
        :param str database_name: The from database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The from schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The from database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The from schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SinkKafkaKafkaConnection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The kafka_connection name.
        :param str database_name: The kafka_connection database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The kafka_connection schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The kafka_connection database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The kafka_connection schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SourceKafkaEnvelope(dict):
    def __init__(__self__, *,
                 debezium: Optional[bool] = None,
                 none: Optional[bool] = None,
                 upsert: Optional[bool] = None):
        """
        :param bool debezium: Use the Debezium envelope, which uses a diff envelope to handle CRUD operations.
        :param bool none: Use an append-only envelope. This means that records will only be appended and cannot be updated or deleted.
        :param bool upsert: Use the upsert envelope, which uses message keys to handle CRUD operations.
        """
        if debezium is not None:
            pulumi.set(__self__, "debezium", debezium)
        if none is not None:
            pulumi.set(__self__, "none", none)
        if upsert is not None:
            pulumi.set(__self__, "upsert", upsert)

    @property
    @pulumi.getter
    def debezium(self) -> Optional[bool]:
        """
        Use the Debezium envelope, which uses a diff envelope to handle CRUD operations.
        """
        return pulumi.get(self, "debezium")

    @property
    @pulumi.getter
    def none(self) -> Optional[bool]:
        """
        Use an append-only envelope. This means that records will only be appended and cannot be updated or deleted.
        """
        return pulumi.get(self, "none")

    @property
    @pulumi.getter
    def upsert(self) -> Optional[bool]:
        """
        Use the upsert envelope, which uses message keys to handle CRUD operations.
        """
        return pulumi.get(self, "upsert")


@pulumi.output_type
class SourceKafkaExposeProgress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The expose_progress name.
        :param str database_name: The expose_progress database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The expose_progress schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The expose_progress database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The expose_progress schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SourceKafkaFormat(dict):
    def __init__(__self__, *,
                 avro: Optional['outputs.SourceKafkaFormatAvro'] = None,
                 bytes: Optional[bool] = None,
                 csvs: Optional[Sequence['outputs.SourceKafkaFormatCsv']] = None,
                 json: Optional[bool] = None,
                 protobuf: Optional['outputs.SourceKafkaFormatProtobuf'] = None,
                 text: Optional[bool] = None):
        """
        :param 'SourceKafkaFormatAvroArgs' avro: Avro format.
        :param bool bytes: BYTES format.
        :param Sequence['SourceKafkaFormatCsvArgs'] csvs: CSV format.
        :param bool json: JSON format.
        :param 'SourceKafkaFormatProtobufArgs' protobuf: Protobuf format.
        :param bool text: Text format.
        """
        if avro is not None:
            pulumi.set(__self__, "avro", avro)
        if bytes is not None:
            pulumi.set(__self__, "bytes", bytes)
        if csvs is not None:
            pulumi.set(__self__, "csvs", csvs)
        if json is not None:
            pulumi.set(__self__, "json", json)
        if protobuf is not None:
            pulumi.set(__self__, "protobuf", protobuf)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def avro(self) -> Optional['outputs.SourceKafkaFormatAvro']:
        """
        Avro format.
        """
        return pulumi.get(self, "avro")

    @property
    @pulumi.getter
    def bytes(self) -> Optional[bool]:
        """
        BYTES format.
        """
        return pulumi.get(self, "bytes")

    @property
    @pulumi.getter
    def csvs(self) -> Optional[Sequence['outputs.SourceKafkaFormatCsv']]:
        """
        CSV format.
        """
        return pulumi.get(self, "csvs")

    @property
    @pulumi.getter
    def json(self) -> Optional[bool]:
        """
        JSON format.
        """
        return pulumi.get(self, "json")

    @property
    @pulumi.getter
    def protobuf(self) -> Optional['outputs.SourceKafkaFormatProtobuf']:
        """
        Protobuf format.
        """
        return pulumi.get(self, "protobuf")

    @property
    @pulumi.getter
    def text(self) -> Optional[bool]:
        """
        Text format.
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class SourceKafkaFormatAvro(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "schemaRegistryConnection":
            suggest = "schema_registry_connection"
        elif key == "keyStrategy":
            suggest = "key_strategy"
        elif key == "valueStrategy":
            suggest = "value_strategy"

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

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

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

    def __init__(__self__, *,
                 schema_registry_connection: 'outputs.SourceKafkaFormatAvroSchemaRegistryConnection',
                 key_strategy: Optional[str] = None,
                 value_strategy: Optional[str] = None):
        pulumi.set(__self__, "schema_registry_connection", schema_registry_connection)
        if key_strategy is not None:
            pulumi.set(__self__, "key_strategy", key_strategy)
        if value_strategy is not None:
            pulumi.set(__self__, "value_strategy", value_strategy)

    @property
    @pulumi.getter(name="schemaRegistryConnection")
    def schema_registry_connection(self) -> 'outputs.SourceKafkaFormatAvroSchemaRegistryConnection':
        return pulumi.get(self, "schema_registry_connection")

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

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


@pulumi.output_type
class SourceKafkaFormatAvroSchemaRegistryConnection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the source.
        :param str database_name: The identifier for the source database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the source schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the source database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the source schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SourceKafkaFormatCsv(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "delimitedBy":
            suggest = "delimited_by"

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

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

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

    def __init__(__self__, *,
                 column: Optional[int] = None,
                 delimited_by: Optional[str] = None,
                 headers: Optional[Sequence[str]] = None):
        if column is not None:
            pulumi.set(__self__, "column", column)
        if delimited_by is not None:
            pulumi.set(__self__, "delimited_by", delimited_by)
        if headers is not None:
            pulumi.set(__self__, "headers", headers)

    @property
    @pulumi.getter
    def column(self) -> Optional[int]:
        return pulumi.get(self, "column")

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

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


@pulumi.output_type
class SourceKafkaFormatProtobuf(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "schemaRegistryConnection":
            suggest = "schema_registry_connection"

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

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

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

    def __init__(__self__, *,
                 message: str,
                 schema_registry_connection: 'outputs.SourceKafkaFormatProtobufSchemaRegistryConnection'):
        pulumi.set(__self__, "message", message)
        pulumi.set(__self__, "schema_registry_connection", schema_registry_connection)

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

    @property
    @pulumi.getter(name="schemaRegistryConnection")
    def schema_registry_connection(self) -> 'outputs.SourceKafkaFormatProtobufSchemaRegistryConnection':
        return pulumi.get(self, "schema_registry_connection")


@pulumi.output_type
class SourceKafkaFormatProtobufSchemaRegistryConnection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the source.
        :param str database_name: The identifier for the source database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the source schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the source database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the source schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SourceKafkaKafkaConnection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The kafka_connection name.
        :param str database_name: The kafka_connection database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The kafka_connection schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The kafka_connection database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The kafka_connection schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SourceKafkaKeyFormat(dict):
    def __init__(__self__, *,
                 avro: Optional['outputs.SourceKafkaKeyFormatAvro'] = None,
                 bytes: Optional[bool] = None,
                 csvs: Optional[Sequence['outputs.SourceKafkaKeyFormatCsv']] = None,
                 json: Optional[bool] = None,
                 protobuf: Optional['outputs.SourceKafkaKeyFormatProtobuf'] = None,
                 text: Optional[bool] = None):
        """
        :param 'SourceKafkaKeyFormatAvroArgs' avro: Avro format.
        :param bool bytes: BYTES format.
        :param Sequence['SourceKafkaKeyFormatCsvArgs'] csvs: CSV format.
        :param bool json: JSON format.
        :param 'SourceKafkaKeyFormatProtobufArgs' protobuf: Protobuf format.
        :param bool text: Text format.
        """
        if avro is not None:
            pulumi.set(__self__, "avro", avro)
        if bytes is not None:
            pulumi.set(__self__, "bytes", bytes)
        if csvs is not None:
            pulumi.set(__self__, "csvs", csvs)
        if json is not None:
            pulumi.set(__self__, "json", json)
        if protobuf is not None:
            pulumi.set(__self__, "protobuf", protobuf)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def avro(self) -> Optional['outputs.SourceKafkaKeyFormatAvro']:
        """
        Avro format.
        """
        return pulumi.get(self, "avro")

    @property
    @pulumi.getter
    def bytes(self) -> Optional[bool]:
        """
        BYTES format.
        """
        return pulumi.get(self, "bytes")

    @property
    @pulumi.getter
    def csvs(self) -> Optional[Sequence['outputs.SourceKafkaKeyFormatCsv']]:
        """
        CSV format.
        """
        return pulumi.get(self, "csvs")

    @property
    @pulumi.getter
    def json(self) -> Optional[bool]:
        """
        JSON format.
        """
        return pulumi.get(self, "json")

    @property
    @pulumi.getter
    def protobuf(self) -> Optional['outputs.SourceKafkaKeyFormatProtobuf']:
        """
        Protobuf format.
        """
        return pulumi.get(self, "protobuf")

    @property
    @pulumi.getter
    def text(self) -> Optional[bool]:
        """
        Text format.
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class SourceKafkaKeyFormatAvro(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "schemaRegistryConnection":
            suggest = "schema_registry_connection"
        elif key == "keyStrategy":
            suggest = "key_strategy"
        elif key == "valueStrategy":
            suggest = "value_strategy"

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

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

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

    def __init__(__self__, *,
                 schema_registry_connection: 'outputs.SourceKafkaKeyFormatAvroSchemaRegistryConnection',
                 key_strategy: Optional[str] = None,
                 value_strategy: Optional[str] = None):
        pulumi.set(__self__, "schema_registry_connection", schema_registry_connection)
        if key_strategy is not None:
            pulumi.set(__self__, "key_strategy", key_strategy)
        if value_strategy is not None:
            pulumi.set(__self__, "value_strategy", value_strategy)

    @property
    @pulumi.getter(name="schemaRegistryConnection")
    def schema_registry_connection(self) -> 'outputs.SourceKafkaKeyFormatAvroSchemaRegistryConnection':
        return pulumi.get(self, "schema_registry_connection")

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

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


@pulumi.output_type
class SourceKafkaKeyFormatAvroSchemaRegistryConnection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the source.
        :param str database_name: The identifier for the source database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the source schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the source database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the source schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SourceKafkaKeyFormatCsv(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "delimitedBy":
            suggest = "delimited_by"

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

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

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

    def __init__(__self__, *,
                 column: Optional[int] = None,
                 delimited_by: Optional[str] = None,
                 headers: Optional[Sequence[str]] = None):
        if column is not None:
            pulumi.set(__self__, "column", column)
        if delimited_by is not None:
            pulumi.set(__self__, "delimited_by", delimited_by)
        if headers is not None:
            pulumi.set(__self__, "headers", headers)

    @property
    @pulumi.getter
    def column(self) -> Optional[int]:
        return pulumi.get(self, "column")

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

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


@pulumi.output_type
class SourceKafkaKeyFormatProtobuf(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "schemaRegistryConnection":
            suggest = "schema_registry_connection"

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

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

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

    def __init__(__self__, *,
                 message: str,
                 schema_registry_connection: 'outputs.SourceKafkaKeyFormatProtobufSchemaRegistryConnection'):
        pulumi.set(__self__, "message", message)
        pulumi.set(__self__, "schema_registry_connection", schema_registry_connection)

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

    @property
    @pulumi.getter(name="schemaRegistryConnection")
    def schema_registry_connection(self) -> 'outputs.SourceKafkaKeyFormatProtobufSchemaRegistryConnection':
        return pulumi.get(self, "schema_registry_connection")


@pulumi.output_type
class SourceKafkaKeyFormatProtobufSchemaRegistryConnection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the source.
        :param str database_name: The identifier for the source database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the source schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the source database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the source schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SourceKafkaValueFormat(dict):
    def __init__(__self__, *,
                 avro: Optional['outputs.SourceKafkaValueFormatAvro'] = None,
                 bytes: Optional[bool] = None,
                 csvs: Optional[Sequence['outputs.SourceKafkaValueFormatCsv']] = None,
                 json: Optional[bool] = None,
                 protobuf: Optional['outputs.SourceKafkaValueFormatProtobuf'] = None,
                 text: Optional[bool] = None):
        """
        :param 'SourceKafkaValueFormatAvroArgs' avro: Avro format.
        :param bool bytes: BYTES format.
        :param Sequence['SourceKafkaValueFormatCsvArgs'] csvs: CSV format.
        :param bool json: JSON format.
        :param 'SourceKafkaValueFormatProtobufArgs' protobuf: Protobuf format.
        :param bool text: Text format.
        """
        if avro is not None:
            pulumi.set(__self__, "avro", avro)
        if bytes is not None:
            pulumi.set(__self__, "bytes", bytes)
        if csvs is not None:
            pulumi.set(__self__, "csvs", csvs)
        if json is not None:
            pulumi.set(__self__, "json", json)
        if protobuf is not None:
            pulumi.set(__self__, "protobuf", protobuf)
        if text is not None:
            pulumi.set(__self__, "text", text)

    @property
    @pulumi.getter
    def avro(self) -> Optional['outputs.SourceKafkaValueFormatAvro']:
        """
        Avro format.
        """
        return pulumi.get(self, "avro")

    @property
    @pulumi.getter
    def bytes(self) -> Optional[bool]:
        """
        BYTES format.
        """
        return pulumi.get(self, "bytes")

    @property
    @pulumi.getter
    def csvs(self) -> Optional[Sequence['outputs.SourceKafkaValueFormatCsv']]:
        """
        CSV format.
        """
        return pulumi.get(self, "csvs")

    @property
    @pulumi.getter
    def json(self) -> Optional[bool]:
        """
        JSON format.
        """
        return pulumi.get(self, "json")

    @property
    @pulumi.getter
    def protobuf(self) -> Optional['outputs.SourceKafkaValueFormatProtobuf']:
        """
        Protobuf format.
        """
        return pulumi.get(self, "protobuf")

    @property
    @pulumi.getter
    def text(self) -> Optional[bool]:
        """
        Text format.
        """
        return pulumi.get(self, "text")


@pulumi.output_type
class SourceKafkaValueFormatAvro(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "schemaRegistryConnection":
            suggest = "schema_registry_connection"
        elif key == "keyStrategy":
            suggest = "key_strategy"
        elif key == "valueStrategy":
            suggest = "value_strategy"

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

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

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

    def __init__(__self__, *,
                 schema_registry_connection: 'outputs.SourceKafkaValueFormatAvroSchemaRegistryConnection',
                 key_strategy: Optional[str] = None,
                 value_strategy: Optional[str] = None):
        pulumi.set(__self__, "schema_registry_connection", schema_registry_connection)
        if key_strategy is not None:
            pulumi.set(__self__, "key_strategy", key_strategy)
        if value_strategy is not None:
            pulumi.set(__self__, "value_strategy", value_strategy)

    @property
    @pulumi.getter(name="schemaRegistryConnection")
    def schema_registry_connection(self) -> 'outputs.SourceKafkaValueFormatAvroSchemaRegistryConnection':
        return pulumi.get(self, "schema_registry_connection")

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

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


@pulumi.output_type
class SourceKafkaValueFormatAvroSchemaRegistryConnection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the source.
        :param str database_name: The identifier for the source database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the source schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the source database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the source schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SourceKafkaValueFormatCsv(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "delimitedBy":
            suggest = "delimited_by"

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

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

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

    def __init__(__self__, *,
                 column: Optional[int] = None,
                 delimited_by: Optional[str] = None,
                 headers: Optional[Sequence[str]] = None):
        if column is not None:
            pulumi.set(__self__, "column", column)
        if delimited_by is not None:
            pulumi.set(__self__, "delimited_by", delimited_by)
        if headers is not None:
            pulumi.set(__self__, "headers", headers)

    @property
    @pulumi.getter
    def column(self) -> Optional[int]:
        return pulumi.get(self, "column")

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

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


@pulumi.output_type
class SourceKafkaValueFormatProtobuf(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "schemaRegistryConnection":
            suggest = "schema_registry_connection"

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

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

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

    def __init__(__self__, *,
                 message: str,
                 schema_registry_connection: 'outputs.SourceKafkaValueFormatProtobufSchemaRegistryConnection'):
        pulumi.set(__self__, "message", message)
        pulumi.set(__self__, "schema_registry_connection", schema_registry_connection)

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

    @property
    @pulumi.getter(name="schemaRegistryConnection")
    def schema_registry_connection(self) -> 'outputs.SourceKafkaValueFormatProtobufSchemaRegistryConnection':
        return pulumi.get(self, "schema_registry_connection")


@pulumi.output_type
class SourceKafkaValueFormatProtobufSchemaRegistryConnection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the source.
        :param str database_name: The identifier for the source database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the source schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the source database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the source schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SourceLoadgenAuctionOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "scaleFactor":
            suggest = "scale_factor"
        elif key == "tickInterval":
            suggest = "tick_interval"

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

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

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

    def __init__(__self__, *,
                 scale_factor: Optional[float] = None,
                 tick_interval: Optional[str] = None):
        """
        :param float scale_factor: (Deprecated) The scale factor for the generator. Defaults to 0.01 (~ 10MB).
        :param str tick_interval: The interval at which the next datum should be emitted. Defaults to one second.
        """
        if scale_factor is not None:
            pulumi.set(__self__, "scale_factor", scale_factor)
        if tick_interval is not None:
            pulumi.set(__self__, "tick_interval", tick_interval)

    @property
    @pulumi.getter(name="scaleFactor")
    def scale_factor(self) -> Optional[float]:
        """
        (Deprecated) The scale factor for the generator. Defaults to 0.01 (~ 10MB).
        """
        warnings.warn("""Scale factor is deprecated and will be removed in a future release.""", DeprecationWarning)
        pulumi.log.warn("""scale_factor is deprecated: Scale factor is deprecated and will be removed in a future release.""")

        return pulumi.get(self, "scale_factor")

    @property
    @pulumi.getter(name="tickInterval")
    def tick_interval(self) -> Optional[str]:
        """
        The interval at which the next datum should be emitted. Defaults to one second.
        """
        return pulumi.get(self, "tick_interval")


@pulumi.output_type
class SourceLoadgenCounterOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxCardinality":
            suggest = "max_cardinality"
        elif key == "scaleFactor":
            suggest = "scale_factor"
        elif key == "tickInterval":
            suggest = "tick_interval"

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

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

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

    def __init__(__self__, *,
                 max_cardinality: Optional[int] = None,
                 scale_factor: Optional[float] = None,
                 tick_interval: Optional[str] = None):
        """
        :param int max_cardinality: Causes the generator to delete old values to keep the collection at most a given size. Defaults to unlimited.
        :param float scale_factor: (Deprecated) The scale factor for the generator. Defaults to 0.01 (~ 10MB).
        :param str tick_interval: The interval at which the next datum should be emitted. Defaults to one second.
        """
        if max_cardinality is not None:
            pulumi.set(__self__, "max_cardinality", max_cardinality)
        if scale_factor is not None:
            pulumi.set(__self__, "scale_factor", scale_factor)
        if tick_interval is not None:
            pulumi.set(__self__, "tick_interval", tick_interval)

    @property
    @pulumi.getter(name="maxCardinality")
    def max_cardinality(self) -> Optional[int]:
        """
        Causes the generator to delete old values to keep the collection at most a given size. Defaults to unlimited.
        """
        return pulumi.get(self, "max_cardinality")

    @property
    @pulumi.getter(name="scaleFactor")
    def scale_factor(self) -> Optional[float]:
        """
        (Deprecated) The scale factor for the generator. Defaults to 0.01 (~ 10MB).
        """
        warnings.warn("""Scale factor is deprecated and will be removed in a future release.""", DeprecationWarning)
        pulumi.log.warn("""scale_factor is deprecated: Scale factor is deprecated and will be removed in a future release.""")

        return pulumi.get(self, "scale_factor")

    @property
    @pulumi.getter(name="tickInterval")
    def tick_interval(self) -> Optional[str]:
        """
        The interval at which the next datum should be emitted. Defaults to one second.
        """
        return pulumi.get(self, "tick_interval")


@pulumi.output_type
class SourceLoadgenExposeProgress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The expose_progress name.
        :param str database_name: The expose_progress database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The expose_progress schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The expose_progress database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The expose_progress schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SourceLoadgenKeyValueOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "batchSize":
            suggest = "batch_size"
        elif key == "snapshotRounds":
            suggest = "snapshot_rounds"
        elif key == "tickInterval":
            suggest = "tick_interval"
        elif key == "transactionalSnapshot":
            suggest = "transactional_snapshot"
        elif key == "valueSize":
            suggest = "value_size"

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

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

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

    def __init__(__self__, *,
                 keys: int,
                 batch_size: Optional[int] = None,
                 partitions: Optional[int] = None,
                 seed: Optional[int] = None,
                 snapshot_rounds: Optional[int] = None,
                 tick_interval: Optional[str] = None,
                 transactional_snapshot: Optional[bool] = None,
                 value_size: Optional[int] = None):
        """
        :param int keys: The number of keys in the source. This must be divisible by the product of 'partitions' and 'batch_size'.
        :param int batch_size: The number of keys per partition to produce in each update.
        :param int partitions: The number of partitions to spread the keys across.
        :param int seed: A per-source seed for seeding the random data.
        :param int snapshot_rounds: The number of rounds of data to produce as the source starts up.
        :param str tick_interval: The interval at which the next datum should be emitted. Defaults to one second.
        :param bool transactional_snapshot: Whether to emit the snapshot as a singular transaction.
        :param int value_size: The number of bytes in each value.
        """
        pulumi.set(__self__, "keys", keys)
        if batch_size is not None:
            pulumi.set(__self__, "batch_size", batch_size)
        if partitions is not None:
            pulumi.set(__self__, "partitions", partitions)
        if seed is not None:
            pulumi.set(__self__, "seed", seed)
        if snapshot_rounds is not None:
            pulumi.set(__self__, "snapshot_rounds", snapshot_rounds)
        if tick_interval is not None:
            pulumi.set(__self__, "tick_interval", tick_interval)
        if transactional_snapshot is not None:
            pulumi.set(__self__, "transactional_snapshot", transactional_snapshot)
        if value_size is not None:
            pulumi.set(__self__, "value_size", value_size)

    @property
    @pulumi.getter
    def keys(self) -> int:
        """
        The number of keys in the source. This must be divisible by the product of 'partitions' and 'batch_size'.
        """
        return pulumi.get(self, "keys")

    @property
    @pulumi.getter(name="batchSize")
    def batch_size(self) -> Optional[int]:
        """
        The number of keys per partition to produce in each update.
        """
        return pulumi.get(self, "batch_size")

    @property
    @pulumi.getter
    def partitions(self) -> Optional[int]:
        """
        The number of partitions to spread the keys across.
        """
        return pulumi.get(self, "partitions")

    @property
    @pulumi.getter
    def seed(self) -> Optional[int]:
        """
        A per-source seed for seeding the random data.
        """
        return pulumi.get(self, "seed")

    @property
    @pulumi.getter(name="snapshotRounds")
    def snapshot_rounds(self) -> Optional[int]:
        """
        The number of rounds of data to produce as the source starts up.
        """
        return pulumi.get(self, "snapshot_rounds")

    @property
    @pulumi.getter(name="tickInterval")
    def tick_interval(self) -> Optional[str]:
        """
        The interval at which the next datum should be emitted. Defaults to one second.
        """
        return pulumi.get(self, "tick_interval")

    @property
    @pulumi.getter(name="transactionalSnapshot")
    def transactional_snapshot(self) -> Optional[bool]:
        """
        Whether to emit the snapshot as a singular transaction.
        """
        return pulumi.get(self, "transactional_snapshot")

    @property
    @pulumi.getter(name="valueSize")
    def value_size(self) -> Optional[int]:
        """
        The number of bytes in each value.
        """
        return pulumi.get(self, "value_size")


@pulumi.output_type
class SourceLoadgenMarketingOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "scaleFactor":
            suggest = "scale_factor"
        elif key == "tickInterval":
            suggest = "tick_interval"

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

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

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

    def __init__(__self__, *,
                 scale_factor: Optional[float] = None,
                 tick_interval: Optional[str] = None):
        """
        :param float scale_factor: (Deprecated) The scale factor for the generator. Defaults to 0.01 (~ 10MB).
        :param str tick_interval: The interval at which the next datum should be emitted. Defaults to one second.
        """
        if scale_factor is not None:
            pulumi.set(__self__, "scale_factor", scale_factor)
        if tick_interval is not None:
            pulumi.set(__self__, "tick_interval", tick_interval)

    @property
    @pulumi.getter(name="scaleFactor")
    def scale_factor(self) -> Optional[float]:
        """
        (Deprecated) The scale factor for the generator. Defaults to 0.01 (~ 10MB).
        """
        warnings.warn("""Scale factor is deprecated and will be removed in a future release.""", DeprecationWarning)
        pulumi.log.warn("""scale_factor is deprecated: Scale factor is deprecated and will be removed in a future release.""")

        return pulumi.get(self, "scale_factor")

    @property
    @pulumi.getter(name="tickInterval")
    def tick_interval(self) -> Optional[str]:
        """
        The interval at which the next datum should be emitted. Defaults to one second.
        """
        return pulumi.get(self, "tick_interval")


@pulumi.output_type
class SourceLoadgenTpchOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "scaleFactor":
            suggest = "scale_factor"
        elif key == "tickInterval":
            suggest = "tick_interval"

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

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

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

    def __init__(__self__, *,
                 scale_factor: Optional[float] = None,
                 tick_interval: Optional[str] = None):
        """
        :param float scale_factor: The scale factor for the generator. Defaults to 0.01 (~ 10MB).
        :param str tick_interval: The interval at which the next datum should be emitted. Defaults to one second.
        """
        if scale_factor is not None:
            pulumi.set(__self__, "scale_factor", scale_factor)
        if tick_interval is not None:
            pulumi.set(__self__, "tick_interval", tick_interval)

    @property
    @pulumi.getter(name="scaleFactor")
    def scale_factor(self) -> Optional[float]:
        """
        The scale factor for the generator. Defaults to 0.01 (~ 10MB).
        """
        return pulumi.get(self, "scale_factor")

    @property
    @pulumi.getter(name="tickInterval")
    def tick_interval(self) -> Optional[str]:
        """
        The interval at which the next datum should be emitted. Defaults to one second.
        """
        return pulumi.get(self, "tick_interval")


@pulumi.output_type
class SourceMysqlExposeProgress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The expose_progress name.
        :param str database_name: The expose_progress database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The expose_progress schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The expose_progress database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The expose_progress schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SourceMysqlMysqlConnection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The mysql_connection name.
        :param str database_name: The mysql_connection database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The mysql_connection schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The mysql_connection database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The mysql_connection schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SourceMysqlTable(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "upstreamName":
            suggest = "upstream_name"
        elif key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"
        elif key == "upstreamSchemaName":
            suggest = "upstream_schema_name"

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

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

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

    def __init__(__self__, *,
                 upstream_name: str,
                 database_name: Optional[str] = None,
                 name: Optional[str] = None,
                 schema_name: Optional[str] = None,
                 upstream_schema_name: Optional[str] = None):
        """
        :param str upstream_name: The name of the table in the upstream MySQL database.
        :param str database_name: The database of the table in Materialize.
        :param str name: The name for the table, used in Materialize.
        :param str schema_name: The schema of the table in Materialize.
        :param str upstream_schema_name: The schema of the table in the upstream MySQL database.
        """
        pulumi.set(__self__, "upstream_name", upstream_name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)
        if upstream_schema_name is not None:
            pulumi.set(__self__, "upstream_schema_name", upstream_schema_name)

    @property
    @pulumi.getter(name="upstreamName")
    def upstream_name(self) -> str:
        """
        The name of the table in the upstream MySQL database.
        """
        return pulumi.get(self, "upstream_name")

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The database of the table in Materialize.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        The name for the table, used in Materialize.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The schema of the table in Materialize.
        """
        return pulumi.get(self, "schema_name")

    @property
    @pulumi.getter(name="upstreamSchemaName")
    def upstream_schema_name(self) -> Optional[str]:
        """
        The schema of the table in the upstream MySQL database.
        """
        return pulumi.get(self, "upstream_schema_name")


@pulumi.output_type
class SourcePostgresExposeProgress(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The expose_progress name.
        :param str database_name: The expose_progress database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The expose_progress schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The expose_progress database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The expose_progress schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SourcePostgresPostgresConnection(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The postgres_connection name.
        :param str database_name: The postgres_connection database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The postgres_connection schema name. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The postgres_connection database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The postgres_connection schema name. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SourcePostgresTable(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "upstreamName":
            suggest = "upstream_name"
        elif key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"
        elif key == "upstreamSchemaName":
            suggest = "upstream_schema_name"

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

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

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

    def __init__(__self__, *,
                 upstream_name: str,
                 database_name: Optional[str] = None,
                 name: Optional[str] = None,
                 schema_name: Optional[str] = None,
                 upstream_schema_name: Optional[str] = None):
        """
        :param str upstream_name: The name of the table in the upstream Postgres database.
        :param str database_name: The database of the table in Materialize.
        :param str name: The name of the table in Materialize.
        :param str schema_name: The schema of the table in Materialize.
        :param str upstream_schema_name: The schema of the table in the upstream Postgres database.
        """
        pulumi.set(__self__, "upstream_name", upstream_name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)
        if upstream_schema_name is not None:
            pulumi.set(__self__, "upstream_schema_name", upstream_schema_name)

    @property
    @pulumi.getter(name="upstreamName")
    def upstream_name(self) -> str:
        """
        The name of the table in the upstream Postgres database.
        """
        return pulumi.get(self, "upstream_name")

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The database of the table in Materialize.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        The name of the table in Materialize.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The schema of the table in Materialize.
        """
        return pulumi.get(self, "schema_name")

    @property
    @pulumi.getter(name="upstreamSchemaName")
    def upstream_schema_name(self) -> Optional[str]:
        """
        The schema of the table in the upstream Postgres database.
        """
        return pulumi.get(self, "upstream_schema_name")


@pulumi.output_type
class SourceWebhookCheckOption(dict):
    def __init__(__self__, *,
                 field: 'outputs.SourceWebhookCheckOptionField',
                 alias: Optional[str] = None,
                 bytes: Optional[bool] = None):
        """
        :param 'SourceWebhookCheckOptionFieldArgs' field: The field for the check options.
        :param str alias: The alias for the check options.
        :param bool bytes: Change type to `bytea`.
        """
        pulumi.set(__self__, "field", field)
        if alias is not None:
            pulumi.set(__self__, "alias", alias)
        if bytes is not None:
            pulumi.set(__self__, "bytes", bytes)

    @property
    @pulumi.getter
    def field(self) -> 'outputs.SourceWebhookCheckOptionField':
        """
        The field for the check options.
        """
        return pulumi.get(self, "field")

    @property
    @pulumi.getter
    def alias(self) -> Optional[str]:
        """
        The alias for the check options.
        """
        return pulumi.get(self, "alias")

    @property
    @pulumi.getter
    def bytes(self) -> Optional[bool]:
        """
        Change type to `bytea`.
        """
        return pulumi.get(self, "bytes")


@pulumi.output_type
class SourceWebhookCheckOptionField(dict):
    def __init__(__self__, *,
                 body: Optional[bool] = None,
                 headers: Optional[bool] = None,
                 secret: Optional['outputs.SourceWebhookCheckOptionFieldSecret'] = None):
        if body is not None:
            pulumi.set(__self__, "body", body)
        if headers is not None:
            pulumi.set(__self__, "headers", headers)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def body(self) -> Optional[bool]:
        return pulumi.get(self, "body")

    @property
    @pulumi.getter
    def headers(self) -> Optional[bool]:
        return pulumi.get(self, "headers")

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


@pulumi.output_type
class SourceWebhookCheckOptionFieldSecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "schemaName":
            suggest = "schema_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 database_name: Optional[str] = None,
                 schema_name: Optional[str] = None):
        """
        :param str name: The identifier for the source.
        :param str database_name: The identifier for the source database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param str schema_name: The identifier for the source schema in Materialize. Defaults to `public`.
        """
        pulumi.set(__self__, "name", name)
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if schema_name is not None:
            pulumi.set(__self__, "schema_name", schema_name)

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

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[str]:
        """
        The identifier for the source database in Materialize. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter(name="schemaName")
    def schema_name(self) -> Optional[str]:
        """
        The identifier for the source schema in Materialize. Defaults to `public`.
        """
        return pulumi.get(self, "schema_name")


@pulumi.output_type
class SourceWebhookIncludeHeader(dict):
    def __init__(__self__, *,
                 header: str,
                 alias: Optional[str] = None,
                 bytes: Optional[bool] = None):
        """
        :param str header: The name for the header.
        :param str alias: The alias for the header.
        :param bool bytes: Change type to `bytea`.
        """
        pulumi.set(__self__, "header", header)
        if alias is not None:
            pulumi.set(__self__, "alias", alias)
        if bytes is not None:
            pulumi.set(__self__, "bytes", bytes)

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

    @property
    @pulumi.getter
    def alias(self) -> Optional[str]:
        """
        The alias for the header.
        """
        return pulumi.get(self, "alias")

    @property
    @pulumi.getter
    def bytes(self) -> Optional[bool]:
        """
        Change type to `bytea`.
        """
        return pulumi.get(self, "bytes")


@pulumi.output_type
class SourceWebhookIncludeHeaders(dict):
    def __init__(__self__, *,
                 all: Optional[bool] = None,
                 nots: Optional[Sequence[str]] = None,
                 onlies: Optional[Sequence[str]] = None):
        """
        :param bool all: Include all headers.
        :param Sequence[str] nots: Headers that should be excluded.
        :param Sequence[str] onlies: Headers that should be included.
        """
        if all is not None:
            pulumi.set(__self__, "all", all)
        if nots is not None:
            pulumi.set(__self__, "nots", nots)
        if onlies is not None:
            pulumi.set(__self__, "onlies", onlies)

    @property
    @pulumi.getter
    def all(self) -> Optional[bool]:
        """
        Include all headers.
        """
        return pulumi.get(self, "all")

    @property
    @pulumi.getter
    def nots(self) -> Optional[Sequence[str]]:
        """
        Headers that should be excluded.
        """
        return pulumi.get(self, "nots")

    @property
    @pulumi.getter
    def onlies(self) -> Optional[Sequence[str]]:
        """
        Headers that should be included.
        """
        return pulumi.get(self, "onlies")


@pulumi.output_type
class TableColumn(dict):
    def __init__(__self__, *,
                 name: str,
                 type: str,
                 comment: Optional[str] = None,
                 default: Optional[str] = None,
                 nullable: Optional[bool] = None):
        """
        :param str name: The name of the column to be created in the table.
        :param str type: The data type of the column indicated by name.
        :param str comment: **Public Preview** Comment on an object in the database.
        :param str default: A default value to use for the column in an INSERT statement if an explicit value is not provided. If not specified, `NULL` is assumed..
        :param bool nullable: Do not allow the column to contain `NULL` values. Columns without this constraint can contain `NULL` values.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if comment is not None:
            pulumi.set(__self__, "comment", comment)
        if default is not None:
            pulumi.set(__self__, "default", default)
        if nullable is not None:
            pulumi.set(__self__, "nullable", nullable)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the column to be created in the table.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The data type of the column indicated by name.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def comment(self) -> Optional[str]:
        """
        **Public Preview** Comment on an object in the database.
        """
        return pulumi.get(self, "comment")

    @property
    @pulumi.getter
    def default(self) -> Optional[str]:
        """
        A default value to use for the column in an INSERT statement if an explicit value is not provided. If not specified, `NULL` is assumed..
        """
        return pulumi.get(self, "default")

    @property
    @pulumi.getter
    def nullable(self) -> Optional[bool]:
        """
        Do not allow the column to contain `NULL` values. Columns without this constraint can contain `NULL` values.
        """
        return pulumi.get(self, "nullable")


@pulumi.output_type
class TypeListProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "elementType":
            suggest = "element_type"

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

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

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

    def __init__(__self__, *,
                 element_type: str):
        """
        :param str element_type: Creates a custom list whose elements are of `ELEMENT TYPE`
        """
        pulumi.set(__self__, "element_type", element_type)

    @property
    @pulumi.getter(name="elementType")
    def element_type(self) -> str:
        """
        Creates a custom list whose elements are of `ELEMENT TYPE`
        """
        return pulumi.get(self, "element_type")


@pulumi.output_type
class TypeMapProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyType":
            suggest = "key_type"
        elif key == "valueType":
            suggest = "value_type"

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

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

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

    def __init__(__self__, *,
                 key_type: str,
                 value_type: str):
        """
        :param str key_type: Creates a custom map whose keys are of `KEY TYPE`. `KEY TYPE` must resolve to text.
        :param str value_type: Creates a custom map whose values are of `VALUE TYPE`.
        """
        pulumi.set(__self__, "key_type", key_type)
        pulumi.set(__self__, "value_type", value_type)

    @property
    @pulumi.getter(name="keyType")
    def key_type(self) -> str:
        """
        Creates a custom map whose keys are of `KEY TYPE`. `KEY TYPE` must resolve to text.
        """
        return pulumi.get(self, "key_type")

    @property
    @pulumi.getter(name="valueType")
    def value_type(self) -> str:
        """
        Creates a custom map whose values are of `VALUE TYPE`.
        """
        return pulumi.get(self, "value_type")


@pulumi.output_type
class TypeRowProperty(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fieldName":
            suggest = "field_name"
        elif key == "fieldType":
            suggest = "field_type"

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

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

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

    def __init__(__self__, *,
                 field_name: str,
                 field_type: str):
        """
        :param str field_name: The name of a field in a row type.
        :param str field_type: The data type of a field indicated by `FIELD NAME`.
        """
        pulumi.set(__self__, "field_name", field_name)
        pulumi.set(__self__, "field_type", field_type)

    @property
    @pulumi.getter(name="fieldName")
    def field_name(self) -> str:
        """
        The name of a field in a row type.
        """
        return pulumi.get(self, "field_name")

    @property
    @pulumi.getter(name="fieldType")
    def field_type(self) -> str:
        """
        The data type of a field indicated by `FIELD NAME`.
        """
        return pulumi.get(self, "field_type")


