# 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

__all__ = [
    'ClusterSchedulingArgs',
    'ClusterSchedulingOnRefreshArgs',
    'ConnectionAwsAccessKeyIdArgs',
    'ConnectionAwsAccessKeyIdSecretArgs',
    'ConnectionAwsSecretAccessKeyArgs',
    'ConnectionAwsSessionTokenArgs',
    'ConnectionAwsSessionTokenSecretArgs',
    'ConnectionConfluentSchemaRegistryAwsPrivatelinkArgs',
    'ConnectionConfluentSchemaRegistryPasswordArgs',
    'ConnectionConfluentSchemaRegistrySshTunnelArgs',
    'ConnectionConfluentSchemaRegistrySslCertificateArgs',
    'ConnectionConfluentSchemaRegistrySslCertificateAuthorityArgs',
    'ConnectionConfluentSchemaRegistrySslCertificateAuthoritySecretArgs',
    'ConnectionConfluentSchemaRegistrySslCertificateSecretArgs',
    'ConnectionConfluentSchemaRegistrySslKeyArgs',
    'ConnectionConfluentSchemaRegistryUsernameArgs',
    'ConnectionConfluentSchemaRegistryUsernameSecretArgs',
    'ConnectionKafkaAwsPrivatelinkArgs',
    'ConnectionKafkaAwsPrivatelinkPrivatelinkConnectionArgs',
    'ConnectionKafkaKafkaBrokerArgs',
    'ConnectionKafkaKafkaBrokerPrivatelinkConnectionArgs',
    'ConnectionKafkaKafkaBrokerSshTunnelArgs',
    'ConnectionKafkaSaslPasswordArgs',
    'ConnectionKafkaSaslUsernameArgs',
    'ConnectionKafkaSaslUsernameSecretArgs',
    'ConnectionKafkaSshTunnelArgs',
    'ConnectionKafkaSslCertificateArgs',
    'ConnectionKafkaSslCertificateAuthorityArgs',
    'ConnectionKafkaSslCertificateAuthoritySecretArgs',
    'ConnectionKafkaSslCertificateSecretArgs',
    'ConnectionKafkaSslKeyArgs',
    'ConnectionMysqlAwsPrivatelinkArgs',
    'ConnectionMysqlPasswordArgs',
    'ConnectionMysqlSshTunnelArgs',
    'ConnectionMysqlSslCertificateArgs',
    'ConnectionMysqlSslCertificateAuthorityArgs',
    'ConnectionMysqlSslCertificateAuthoritySecretArgs',
    'ConnectionMysqlSslCertificateSecretArgs',
    'ConnectionMysqlSslKeyArgs',
    'ConnectionMysqlUserArgs',
    'ConnectionMysqlUserSecretArgs',
    'ConnectionPostgresAwsPrivatelinkArgs',
    'ConnectionPostgresPasswordArgs',
    'ConnectionPostgresSshTunnelArgs',
    'ConnectionPostgresSslCertificateArgs',
    'ConnectionPostgresSslCertificateAuthorityArgs',
    'ConnectionPostgresSslCertificateAuthoritySecretArgs',
    'ConnectionPostgresSslCertificateSecretArgs',
    'ConnectionPostgresSslKeyArgs',
    'ConnectionPostgresUserArgs',
    'ConnectionPostgresUserSecretArgs',
    'IndexColExprArgs',
    'IndexObjNameArgs',
    'SinkKafkaEnvelopeArgs',
    'SinkKafkaFormatArgs',
    'SinkKafkaFormatAvroArgs',
    'SinkKafkaFormatAvroAvroDocColumnArgs',
    'SinkKafkaFormatAvroAvroDocColumnObjectArgs',
    'SinkKafkaFormatAvroAvroDocTypeArgs',
    'SinkKafkaFormatAvroAvroDocTypeObjectArgs',
    'SinkKafkaFormatAvroSchemaRegistryConnectionArgs',
    'SinkKafkaFromArgs',
    'SinkKafkaKafkaConnectionArgs',
    'SourceKafkaEnvelopeArgs',
    'SourceKafkaExposeProgressArgs',
    'SourceKafkaFormatArgs',
    'SourceKafkaFormatAvroArgs',
    'SourceKafkaFormatAvroSchemaRegistryConnectionArgs',
    'SourceKafkaFormatCsvArgs',
    'SourceKafkaFormatProtobufArgs',
    'SourceKafkaFormatProtobufSchemaRegistryConnectionArgs',
    'SourceKafkaKafkaConnectionArgs',
    'SourceKafkaKeyFormatArgs',
    'SourceKafkaKeyFormatAvroArgs',
    'SourceKafkaKeyFormatAvroSchemaRegistryConnectionArgs',
    'SourceKafkaKeyFormatCsvArgs',
    'SourceKafkaKeyFormatProtobufArgs',
    'SourceKafkaKeyFormatProtobufSchemaRegistryConnectionArgs',
    'SourceKafkaValueFormatArgs',
    'SourceKafkaValueFormatAvroArgs',
    'SourceKafkaValueFormatAvroSchemaRegistryConnectionArgs',
    'SourceKafkaValueFormatCsvArgs',
    'SourceKafkaValueFormatProtobufArgs',
    'SourceKafkaValueFormatProtobufSchemaRegistryConnectionArgs',
    'SourceLoadgenAuctionOptionsArgs',
    'SourceLoadgenCounterOptionsArgs',
    'SourceLoadgenExposeProgressArgs',
    'SourceLoadgenKeyValueOptionsArgs',
    'SourceLoadgenMarketingOptionsArgs',
    'SourceLoadgenTpchOptionsArgs',
    'SourceMysqlExposeProgressArgs',
    'SourceMysqlMysqlConnectionArgs',
    'SourceMysqlTableArgs',
    'SourcePostgresExposeProgressArgs',
    'SourcePostgresPostgresConnectionArgs',
    'SourcePostgresTableArgs',
    'SourceWebhookCheckOptionArgs',
    'SourceWebhookCheckOptionFieldArgs',
    'SourceWebhookCheckOptionFieldSecretArgs',
    'SourceWebhookIncludeHeaderArgs',
    'SourceWebhookIncludeHeadersArgs',
    'TableColumnArgs',
    'TypeListPropertiesArgs',
    'TypeMapPropertiesArgs',
    'TypeRowPropertyArgs',
]

@pulumi.input_type
class ClusterSchedulingArgs:
    def __init__(__self__, *,
                 on_refresh: Optional[pulumi.Input['ClusterSchedulingOnRefreshArgs']] = None):
        """
        :param pulumi.Input['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[pulumi.Input['ClusterSchedulingOnRefreshArgs']]:
        """
        Configuration for refreshing the cluster.
        """
        return pulumi.get(self, "on_refresh")

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


@pulumi.input_type
class ClusterSchedulingOnRefreshArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 rehydration_time_estimate: Optional[pulumi.Input[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[pulumi.Input[bool]]:
        return pulumi.get(self, "enabled")

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

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

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


@pulumi.input_type
class ConnectionAwsAccessKeyIdArgs:
    def __init__(__self__, *,
                 secret: Optional[pulumi.Input['ConnectionAwsAccessKeyIdSecretArgs']] = None,
                 text: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ConnectionAwsAccessKeyIdSecretArgs'] secret: The `access_key_id` secret value. Conflicts with `text` within this block.
        :param pulumi.Input[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[pulumi.Input['ConnectionAwsAccessKeyIdSecretArgs']]:
        """
        The `access_key_id` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

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

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

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


@pulumi.input_type
class ConnectionAwsAccessKeyIdSecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the connection.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the connection.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


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

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

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

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

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

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


@pulumi.input_type
class ConnectionAwsSessionTokenArgs:
    def __init__(__self__, *,
                 secret: Optional[pulumi.Input['ConnectionAwsSessionTokenSecretArgs']] = None,
                 text: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ConnectionAwsSessionTokenSecretArgs'] secret: The `session_token` secret value. Conflicts with `text` within this block.
        :param pulumi.Input[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[pulumi.Input['ConnectionAwsSessionTokenSecretArgs']]:
        """
        The `session_token` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

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

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

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


@pulumi.input_type
class ConnectionAwsSessionTokenSecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the connection.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the connection.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionConfluentSchemaRegistryAwsPrivatelinkArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The aws_privatelink name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The aws_privatelink name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionConfluentSchemaRegistryPasswordArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The password name.
        :param pulumi.Input[str] database_name: The password database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The password name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionConfluentSchemaRegistrySshTunnelArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The ssh_tunnel name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ssh_tunnel name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionConfluentSchemaRegistrySslCertificateArgs:
    def __init__(__self__, *,
                 secret: Optional[pulumi.Input['ConnectionConfluentSchemaRegistrySslCertificateSecretArgs']] = None,
                 text: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ConnectionConfluentSchemaRegistrySslCertificateSecretArgs'] secret: The `ssl_certificate` secret value. Conflicts with `text` within this block.
        :param pulumi.Input[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[pulumi.Input['ConnectionConfluentSchemaRegistrySslCertificateSecretArgs']]:
        """
        The `ssl_certificate` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

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

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

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


@pulumi.input_type
class ConnectionConfluentSchemaRegistrySslCertificateAuthorityArgs:
    def __init__(__self__, *,
                 secret: Optional[pulumi.Input['ConnectionConfluentSchemaRegistrySslCertificateAuthoritySecretArgs']] = None,
                 text: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ConnectionConfluentSchemaRegistrySslCertificateAuthoritySecretArgs'] secret: The `ssl_certificate_authority` secret value. Conflicts with `text` within this block.
        :param pulumi.Input[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[pulumi.Input['ConnectionConfluentSchemaRegistrySslCertificateAuthoritySecretArgs']]:
        """
        The `ssl_certificate_authority` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

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

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

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


@pulumi.input_type
class ConnectionConfluentSchemaRegistrySslCertificateAuthoritySecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the connection.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the connection.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionConfluentSchemaRegistrySslCertificateSecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the connection.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the connection.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionConfluentSchemaRegistrySslKeyArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The ssl_key name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ssl_key name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionConfluentSchemaRegistryUsernameArgs:
    def __init__(__self__, *,
                 secret: Optional[pulumi.Input['ConnectionConfluentSchemaRegistryUsernameSecretArgs']] = None,
                 text: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ConnectionConfluentSchemaRegistryUsernameSecretArgs'] secret: The `username` secret value. Conflicts with `text` within this block.
        :param pulumi.Input[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[pulumi.Input['ConnectionConfluentSchemaRegistryUsernameSecretArgs']]:
        """
        The `username` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

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

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

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


@pulumi.input_type
class ConnectionConfluentSchemaRegistryUsernameSecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the connection.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the connection.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionKafkaAwsPrivatelinkArgs:
    def __init__(__self__, *,
                 privatelink_connection: pulumi.Input['ConnectionKafkaAwsPrivatelinkPrivatelinkConnectionArgs'],
                 privatelink_connection_port: pulumi.Input[int]):
        """
        :param pulumi.Input['ConnectionKafkaAwsPrivatelinkPrivatelinkConnectionArgs'] privatelink_connection: The AWS PrivateLink connection name in Materialize.
        :param pulumi.Input[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) -> pulumi.Input['ConnectionKafkaAwsPrivatelinkPrivatelinkConnectionArgs']:
        """
        The AWS PrivateLink connection name in Materialize.
        """
        return pulumi.get(self, "privatelink_connection")

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

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

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


@pulumi.input_type
class ConnectionKafkaAwsPrivatelinkPrivatelinkConnectionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the connection.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the connection.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionKafkaKafkaBrokerArgs:
    def __init__(__self__, *,
                 broker: pulumi.Input[str],
                 availability_zone: Optional[pulumi.Input[str]] = None,
                 privatelink_connection: Optional[pulumi.Input['ConnectionKafkaKafkaBrokerPrivatelinkConnectionArgs']] = None,
                 ssh_tunnel: Optional[pulumi.Input['ConnectionKafkaKafkaBrokerSshTunnelArgs']] = None,
                 target_group_port: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] broker: The Kafka broker, in the form of `host:port`.
        :param pulumi.Input[str] availability_zone: The availability zone of the Kafka broker.
        :param pulumi.Input['ConnectionKafkaKafkaBrokerPrivatelinkConnectionArgs'] privatelink_connection: The AWS PrivateLink connection name in Materialize.
        :param pulumi.Input['ConnectionKafkaKafkaBrokerSshTunnelArgs'] ssh_tunnel: The name of an SSH tunnel connection to route network traffic through by default.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The Kafka broker, in the form of `host:port`.
        """
        return pulumi.get(self, "broker")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ConnectionKafkaKafkaBrokerPrivatelinkConnectionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the connection.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the connection.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionKafkaKafkaBrokerSshTunnelArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The ssh_tunnel name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ssh_tunnel name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionKafkaSaslPasswordArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The sasl_password name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The sasl_password name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionKafkaSaslUsernameArgs:
    def __init__(__self__, *,
                 secret: Optional[pulumi.Input['ConnectionKafkaSaslUsernameSecretArgs']] = None,
                 text: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ConnectionKafkaSaslUsernameSecretArgs'] secret: The `sasl_username` secret value. Conflicts with `text` within this block.
        :param pulumi.Input[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[pulumi.Input['ConnectionKafkaSaslUsernameSecretArgs']]:
        """
        The `sasl_username` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

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

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

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


@pulumi.input_type
class ConnectionKafkaSaslUsernameSecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the connection.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the connection.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionKafkaSshTunnelArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The ssh_tunnel name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ssh_tunnel name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionKafkaSslCertificateArgs:
    def __init__(__self__, *,
                 secret: Optional[pulumi.Input['ConnectionKafkaSslCertificateSecretArgs']] = None,
                 text: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ConnectionKafkaSslCertificateSecretArgs'] secret: The `ssl_certificate` secret value. Conflicts with `text` within this block.
        :param pulumi.Input[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[pulumi.Input['ConnectionKafkaSslCertificateSecretArgs']]:
        """
        The `ssl_certificate` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

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

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

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


@pulumi.input_type
class ConnectionKafkaSslCertificateAuthorityArgs:
    def __init__(__self__, *,
                 secret: Optional[pulumi.Input['ConnectionKafkaSslCertificateAuthoritySecretArgs']] = None,
                 text: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ConnectionKafkaSslCertificateAuthoritySecretArgs'] secret: The `ssl_certificate_authority` secret value. Conflicts with `text` within this block.
        :param pulumi.Input[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[pulumi.Input['ConnectionKafkaSslCertificateAuthoritySecretArgs']]:
        """
        The `ssl_certificate_authority` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

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

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

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


@pulumi.input_type
class ConnectionKafkaSslCertificateAuthoritySecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the connection.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the connection.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionKafkaSslCertificateSecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the connection.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the connection.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionKafkaSslKeyArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The ssl_key name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ssl_key name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionMysqlAwsPrivatelinkArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The aws_privatelink name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The aws_privatelink name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionMysqlPasswordArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The password name.
        :param pulumi.Input[str] database_name: The password database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The password name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionMysqlSshTunnelArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The ssh_tunnel name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ssh_tunnel name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionMysqlSslCertificateArgs:
    def __init__(__self__, *,
                 secret: Optional[pulumi.Input['ConnectionMysqlSslCertificateSecretArgs']] = None,
                 text: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ConnectionMysqlSslCertificateSecretArgs'] secret: The `ssl_certificate` secret value. Conflicts with `text` within this block.
        :param pulumi.Input[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[pulumi.Input['ConnectionMysqlSslCertificateSecretArgs']]:
        """
        The `ssl_certificate` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

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

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

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


@pulumi.input_type
class ConnectionMysqlSslCertificateAuthorityArgs:
    def __init__(__self__, *,
                 secret: Optional[pulumi.Input['ConnectionMysqlSslCertificateAuthoritySecretArgs']] = None,
                 text: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ConnectionMysqlSslCertificateAuthoritySecretArgs'] secret: The `ssl_certificate_authority` secret value. Conflicts with `text` within this block.
        :param pulumi.Input[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[pulumi.Input['ConnectionMysqlSslCertificateAuthoritySecretArgs']]:
        """
        The `ssl_certificate_authority` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

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

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

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


@pulumi.input_type
class ConnectionMysqlSslCertificateAuthoritySecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the connection.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the connection.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionMysqlSslCertificateSecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the connection.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the connection.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionMysqlSslKeyArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The ssl_key name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ssl_key name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionMysqlUserArgs:
    def __init__(__self__, *,
                 secret: Optional[pulumi.Input['ConnectionMysqlUserSecretArgs']] = None,
                 text: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ConnectionMysqlUserSecretArgs'] secret: The `user` secret value. Conflicts with `text` within this block.
        :param pulumi.Input[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[pulumi.Input['ConnectionMysqlUserSecretArgs']]:
        """
        The `user` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

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

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

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


@pulumi.input_type
class ConnectionMysqlUserSecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the connection.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the connection.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionPostgresAwsPrivatelinkArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The aws_privatelink name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The aws_privatelink name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionPostgresPasswordArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The password name.
        :param pulumi.Input[str] database_name: The password database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The password name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionPostgresSshTunnelArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The ssh_tunnel name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ssh_tunnel name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionPostgresSslCertificateArgs:
    def __init__(__self__, *,
                 secret: Optional[pulumi.Input['ConnectionPostgresSslCertificateSecretArgs']] = None,
                 text: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ConnectionPostgresSslCertificateSecretArgs'] secret: The `ssl_certificate` secret value. Conflicts with `text` within this block.
        :param pulumi.Input[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[pulumi.Input['ConnectionPostgresSslCertificateSecretArgs']]:
        """
        The `ssl_certificate` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

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

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

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


@pulumi.input_type
class ConnectionPostgresSslCertificateAuthorityArgs:
    def __init__(__self__, *,
                 secret: Optional[pulumi.Input['ConnectionPostgresSslCertificateAuthoritySecretArgs']] = None,
                 text: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ConnectionPostgresSslCertificateAuthoritySecretArgs'] secret: The `ssl_certificate_authority` secret value. Conflicts with `text` within this block.
        :param pulumi.Input[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[pulumi.Input['ConnectionPostgresSslCertificateAuthoritySecretArgs']]:
        """
        The `ssl_certificate_authority` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

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

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

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


@pulumi.input_type
class ConnectionPostgresSslCertificateAuthoritySecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the connection.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the connection.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionPostgresSslCertificateSecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the connection.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the connection.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionPostgresSslKeyArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The ssl_key name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The ssl_key name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class ConnectionPostgresUserArgs:
    def __init__(__self__, *,
                 secret: Optional[pulumi.Input['ConnectionPostgresUserSecretArgs']] = None,
                 text: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['ConnectionPostgresUserSecretArgs'] secret: The `user` secret value. Conflicts with `text` within this block.
        :param pulumi.Input[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[pulumi.Input['ConnectionPostgresUserSecretArgs']]:
        """
        The `user` secret value. Conflicts with `text` within this block.
        """
        return pulumi.get(self, "secret")

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

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

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


@pulumi.input_type
class ConnectionPostgresUserSecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the connection.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the connection.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class IndexColExprArgs:
    def __init__(__self__, *,
                 field: pulumi.Input[str]):
        """
        :param pulumi.Input[str] field: The name of the option you want to set.
        """
        pulumi.set(__self__, "field", field)

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

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


@pulumi.input_type
class IndexObjNameArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The obj_name name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The obj_name name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SinkKafkaEnvelopeArgs:
    def __init__(__self__, *,
                 debezium: Optional[pulumi.Input[bool]] = None,
                 upsert: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] debezium: The generated schemas have a Debezium-style diff envelope to capture changes in the input view or source.
        :param pulumi.Input[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[pulumi.Input[bool]]:
        """
        The generated schemas have a Debezium-style diff envelope to capture changes in the input view or source.
        """
        return pulumi.get(self, "debezium")

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

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

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


@pulumi.input_type
class SinkKafkaFormatArgs:
    def __init__(__self__, *,
                 avro: Optional[pulumi.Input['SinkKafkaFormatAvroArgs']] = None,
                 json: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input['SinkKafkaFormatAvroArgs'] avro: Avro format.
        :param pulumi.Input[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[pulumi.Input['SinkKafkaFormatAvroArgs']]:
        """
        Avro format.
        """
        return pulumi.get(self, "avro")

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

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

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


@pulumi.input_type
class SinkKafkaFormatAvroArgs:
    def __init__(__self__, *,
                 schema_registry_connection: pulumi.Input['SinkKafkaFormatAvroSchemaRegistryConnectionArgs'],
                 avro_doc_columns: Optional[pulumi.Input[Sequence[pulumi.Input['SinkKafkaFormatAvroAvroDocColumnArgs']]]] = None,
                 avro_doc_type: Optional[pulumi.Input['SinkKafkaFormatAvroAvroDocTypeArgs']] = None,
                 avro_key_fullname: Optional[pulumi.Input[str]] = None,
                 avro_value_fullname: Optional[pulumi.Input[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) -> pulumi.Input['SinkKafkaFormatAvroSchemaRegistryConnectionArgs']:
        return pulumi.get(self, "schema_registry_connection")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class SinkKafkaFormatAvroAvroDocColumnArgs:
    def __init__(__self__, *,
                 column: pulumi.Input[str],
                 doc: pulumi.Input[str],
                 object: pulumi.Input['SinkKafkaFormatAvroAvroDocColumnObjectArgs'],
                 key: Optional[pulumi.Input[bool]] = None,
                 value: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "column")

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

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

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

    @property
    @pulumi.getter
    def object(self) -> pulumi.Input['SinkKafkaFormatAvroAvroDocColumnObjectArgs']:
        return pulumi.get(self, "object")

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

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

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

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

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


@pulumi.input_type
class SinkKafkaFormatAvroAvroDocColumnObjectArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the sink.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the sink.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SinkKafkaFormatAvroAvroDocTypeArgs:
    def __init__(__self__, *,
                 doc: pulumi.Input[str],
                 object: pulumi.Input['SinkKafkaFormatAvroAvroDocTypeObjectArgs'],
                 key: Optional[pulumi.Input[bool]] = None,
                 value: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "doc")

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

    @property
    @pulumi.getter
    def object(self) -> pulumi.Input['SinkKafkaFormatAvroAvroDocTypeObjectArgs']:
        return pulumi.get(self, "object")

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

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

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

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

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


@pulumi.input_type
class SinkKafkaFormatAvroAvroDocTypeObjectArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the sink.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the sink.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SinkKafkaFormatAvroSchemaRegistryConnectionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the sink.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the sink.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SinkKafkaFromArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The from name.
        :param pulumi.Input[str] database_name: The from database name. Defaults to `MZ_DATABASE` environment variable if set or `materialize` if environment variable is not set.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The from name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SinkKafkaKafkaConnectionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The kafka_connection name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The kafka_connection name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SourceKafkaEnvelopeArgs:
    def __init__(__self__, *,
                 debezium: Optional[pulumi.Input[bool]] = None,
                 none: Optional[pulumi.Input[bool]] = None,
                 upsert: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] debezium: Use the Debezium envelope, which uses a diff envelope to handle CRUD operations.
        :param pulumi.Input[bool] none: Use an append-only envelope. This means that records will only be appended and cannot be updated or deleted.
        :param pulumi.Input[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[pulumi.Input[bool]]:
        """
        Use the Debezium envelope, which uses a diff envelope to handle CRUD operations.
        """
        return pulumi.get(self, "debezium")

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

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

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

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

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


@pulumi.input_type
class SourceKafkaExposeProgressArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The expose_progress name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The expose_progress name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SourceKafkaFormatArgs:
    def __init__(__self__, *,
                 avro: Optional[pulumi.Input['SourceKafkaFormatAvroArgs']] = None,
                 bytes: Optional[pulumi.Input[bool]] = None,
                 csvs: Optional[pulumi.Input[Sequence[pulumi.Input['SourceKafkaFormatCsvArgs']]]] = None,
                 json: Optional[pulumi.Input[bool]] = None,
                 protobuf: Optional[pulumi.Input['SourceKafkaFormatProtobufArgs']] = None,
                 text: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input['SourceKafkaFormatAvroArgs'] avro: Avro format.
        :param pulumi.Input[bool] bytes: BYTES format.
        :param pulumi.Input[Sequence[pulumi.Input['SourceKafkaFormatCsvArgs']]] csvs: CSV format.
        :param pulumi.Input[bool] json: JSON format.
        :param pulumi.Input['SourceKafkaFormatProtobufArgs'] protobuf: Protobuf format.
        :param pulumi.Input[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[pulumi.Input['SourceKafkaFormatAvroArgs']]:
        """
        Avro format.
        """
        return pulumi.get(self, "avro")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class SourceKafkaFormatAvroArgs:
    def __init__(__self__, *,
                 schema_registry_connection: pulumi.Input['SourceKafkaFormatAvroSchemaRegistryConnectionArgs'],
                 key_strategy: Optional[pulumi.Input[str]] = None,
                 value_strategy: Optional[pulumi.Input[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) -> pulumi.Input['SourceKafkaFormatAvroSchemaRegistryConnectionArgs']:
        return pulumi.get(self, "schema_registry_connection")

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

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

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

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

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


@pulumi.input_type
class SourceKafkaFormatAvroSchemaRegistryConnectionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the source.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the source.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SourceKafkaFormatCsvArgs:
    def __init__(__self__, *,
                 column: Optional[pulumi.Input[int]] = None,
                 delimited_by: Optional[pulumi.Input[str]] = None,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input[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[pulumi.Input[int]]:
        return pulumi.get(self, "column")

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

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

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

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

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


@pulumi.input_type
class SourceKafkaFormatProtobufArgs:
    def __init__(__self__, *,
                 message: pulumi.Input[str],
                 schema_registry_connection: pulumi.Input['SourceKafkaFormatProtobufSchemaRegistryConnectionArgs']):
        pulumi.set(__self__, "message", message)
        pulumi.set(__self__, "schema_registry_connection", schema_registry_connection)

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

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

    @property
    @pulumi.getter(name="schemaRegistryConnection")
    def schema_registry_connection(self) -> pulumi.Input['SourceKafkaFormatProtobufSchemaRegistryConnectionArgs']:
        return pulumi.get(self, "schema_registry_connection")

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


@pulumi.input_type
class SourceKafkaFormatProtobufSchemaRegistryConnectionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the source.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the source.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SourceKafkaKafkaConnectionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The kafka_connection name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The kafka_connection name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SourceKafkaKeyFormatArgs:
    def __init__(__self__, *,
                 avro: Optional[pulumi.Input['SourceKafkaKeyFormatAvroArgs']] = None,
                 bytes: Optional[pulumi.Input[bool]] = None,
                 csvs: Optional[pulumi.Input[Sequence[pulumi.Input['SourceKafkaKeyFormatCsvArgs']]]] = None,
                 json: Optional[pulumi.Input[bool]] = None,
                 protobuf: Optional[pulumi.Input['SourceKafkaKeyFormatProtobufArgs']] = None,
                 text: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input['SourceKafkaKeyFormatAvroArgs'] avro: Avro format.
        :param pulumi.Input[bool] bytes: BYTES format.
        :param pulumi.Input[Sequence[pulumi.Input['SourceKafkaKeyFormatCsvArgs']]] csvs: CSV format.
        :param pulumi.Input[bool] json: JSON format.
        :param pulumi.Input['SourceKafkaKeyFormatProtobufArgs'] protobuf: Protobuf format.
        :param pulumi.Input[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[pulumi.Input['SourceKafkaKeyFormatAvroArgs']]:
        """
        Avro format.
        """
        return pulumi.get(self, "avro")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class SourceKafkaKeyFormatAvroArgs:
    def __init__(__self__, *,
                 schema_registry_connection: pulumi.Input['SourceKafkaKeyFormatAvroSchemaRegistryConnectionArgs'],
                 key_strategy: Optional[pulumi.Input[str]] = None,
                 value_strategy: Optional[pulumi.Input[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) -> pulumi.Input['SourceKafkaKeyFormatAvroSchemaRegistryConnectionArgs']:
        return pulumi.get(self, "schema_registry_connection")

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

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

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

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

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


@pulumi.input_type
class SourceKafkaKeyFormatAvroSchemaRegistryConnectionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the source.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the source.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SourceKafkaKeyFormatCsvArgs:
    def __init__(__self__, *,
                 column: Optional[pulumi.Input[int]] = None,
                 delimited_by: Optional[pulumi.Input[str]] = None,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input[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[pulumi.Input[int]]:
        return pulumi.get(self, "column")

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

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

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

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

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


@pulumi.input_type
class SourceKafkaKeyFormatProtobufArgs:
    def __init__(__self__, *,
                 message: pulumi.Input[str],
                 schema_registry_connection: pulumi.Input['SourceKafkaKeyFormatProtobufSchemaRegistryConnectionArgs']):
        pulumi.set(__self__, "message", message)
        pulumi.set(__self__, "schema_registry_connection", schema_registry_connection)

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

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

    @property
    @pulumi.getter(name="schemaRegistryConnection")
    def schema_registry_connection(self) -> pulumi.Input['SourceKafkaKeyFormatProtobufSchemaRegistryConnectionArgs']:
        return pulumi.get(self, "schema_registry_connection")

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


@pulumi.input_type
class SourceKafkaKeyFormatProtobufSchemaRegistryConnectionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the source.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the source.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SourceKafkaValueFormatArgs:
    def __init__(__self__, *,
                 avro: Optional[pulumi.Input['SourceKafkaValueFormatAvroArgs']] = None,
                 bytes: Optional[pulumi.Input[bool]] = None,
                 csvs: Optional[pulumi.Input[Sequence[pulumi.Input['SourceKafkaValueFormatCsvArgs']]]] = None,
                 json: Optional[pulumi.Input[bool]] = None,
                 protobuf: Optional[pulumi.Input['SourceKafkaValueFormatProtobufArgs']] = None,
                 text: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input['SourceKafkaValueFormatAvroArgs'] avro: Avro format.
        :param pulumi.Input[bool] bytes: BYTES format.
        :param pulumi.Input[Sequence[pulumi.Input['SourceKafkaValueFormatCsvArgs']]] csvs: CSV format.
        :param pulumi.Input[bool] json: JSON format.
        :param pulumi.Input['SourceKafkaValueFormatProtobufArgs'] protobuf: Protobuf format.
        :param pulumi.Input[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[pulumi.Input['SourceKafkaValueFormatAvroArgs']]:
        """
        Avro format.
        """
        return pulumi.get(self, "avro")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class SourceKafkaValueFormatAvroArgs:
    def __init__(__self__, *,
                 schema_registry_connection: pulumi.Input['SourceKafkaValueFormatAvroSchemaRegistryConnectionArgs'],
                 key_strategy: Optional[pulumi.Input[str]] = None,
                 value_strategy: Optional[pulumi.Input[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) -> pulumi.Input['SourceKafkaValueFormatAvroSchemaRegistryConnectionArgs']:
        return pulumi.get(self, "schema_registry_connection")

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

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

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

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

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


@pulumi.input_type
class SourceKafkaValueFormatAvroSchemaRegistryConnectionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the source.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the source.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SourceKafkaValueFormatCsvArgs:
    def __init__(__self__, *,
                 column: Optional[pulumi.Input[int]] = None,
                 delimited_by: Optional[pulumi.Input[str]] = None,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input[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[pulumi.Input[int]]:
        return pulumi.get(self, "column")

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

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

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

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

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


@pulumi.input_type
class SourceKafkaValueFormatProtobufArgs:
    def __init__(__self__, *,
                 message: pulumi.Input[str],
                 schema_registry_connection: pulumi.Input['SourceKafkaValueFormatProtobufSchemaRegistryConnectionArgs']):
        pulumi.set(__self__, "message", message)
        pulumi.set(__self__, "schema_registry_connection", schema_registry_connection)

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

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

    @property
    @pulumi.getter(name="schemaRegistryConnection")
    def schema_registry_connection(self) -> pulumi.Input['SourceKafkaValueFormatProtobufSchemaRegistryConnectionArgs']:
        return pulumi.get(self, "schema_registry_connection")

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


@pulumi.input_type
class SourceKafkaValueFormatProtobufSchemaRegistryConnectionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the source.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the source.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SourceLoadgenAuctionOptionsArgs:
    def __init__(__self__, *,
                 scale_factor: Optional[pulumi.Input[float]] = None,
                 tick_interval: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[float] scale_factor: (Deprecated) The scale factor for the generator. Defaults to 0.01 (~ 10MB).
        :param pulumi.Input[str] tick_interval: The interval at which the next datum should be emitted. Defaults to one second.
        """
        if scale_factor is not None:
            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.""")
        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[pulumi.Input[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")

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

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

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


@pulumi.input_type
class SourceLoadgenCounterOptionsArgs:
    def __init__(__self__, *,
                 max_cardinality: Optional[pulumi.Input[int]] = None,
                 scale_factor: Optional[pulumi.Input[float]] = None,
                 tick_interval: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] max_cardinality: Causes the generator to delete old values to keep the collection at most a given size. Defaults to unlimited.
        :param pulumi.Input[float] scale_factor: (Deprecated) The scale factor for the generator. Defaults to 0.01 (~ 10MB).
        :param pulumi.Input[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:
            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.""")
        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[pulumi.Input[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")

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

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

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

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

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


@pulumi.input_type
class SourceLoadgenExposeProgressArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The expose_progress name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The expose_progress name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class SourceLoadgenMarketingOptionsArgs:
    def __init__(__self__, *,
                 scale_factor: Optional[pulumi.Input[float]] = None,
                 tick_interval: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[float] scale_factor: (Deprecated) The scale factor for the generator. Defaults to 0.01 (~ 10MB).
        :param pulumi.Input[str] tick_interval: The interval at which the next datum should be emitted. Defaults to one second.
        """
        if scale_factor is not None:
            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.""")
        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[pulumi.Input[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")

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

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

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


@pulumi.input_type
class SourceLoadgenTpchOptionsArgs:
    def __init__(__self__, *,
                 scale_factor: Optional[pulumi.Input[float]] = None,
                 tick_interval: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[float] scale_factor: The scale factor for the generator. Defaults to 0.01 (~ 10MB).
        :param pulumi.Input[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[pulumi.Input[float]]:
        """
        The scale factor for the generator. Defaults to 0.01 (~ 10MB).
        """
        return pulumi.get(self, "scale_factor")

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

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

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


@pulumi.input_type
class SourceMysqlExposeProgressArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The expose_progress name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The expose_progress name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SourceMysqlMysqlConnectionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The mysql_connection name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The mysql_connection name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SourceMysqlTableArgs:
    def __init__(__self__, *,
                 upstream_name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None,
                 upstream_schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] upstream_name: The name of the table in the upstream MySQL database.
        :param pulumi.Input[str] database_name: The database of the table in Materialize.
        :param pulumi.Input[str] name: The name for the table, used in Materialize.
        :param pulumi.Input[str] schema_name: The schema of the table in Materialize.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The name of the table in the upstream MySQL database.
        """
        return pulumi.get(self, "upstream_name")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class SourcePostgresExposeProgressArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The expose_progress name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The expose_progress name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SourcePostgresPostgresConnectionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The postgres_connection name.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The postgres_connection name.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SourcePostgresTableArgs:
    def __init__(__self__, *,
                 upstream_name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None,
                 upstream_schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] upstream_name: The name of the table in the upstream Postgres database.
        :param pulumi.Input[str] database_name: The database of the table in Materialize.
        :param pulumi.Input[str] name: The name of the table in Materialize.
        :param pulumi.Input[str] schema_name: The schema of the table in Materialize.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The name of the table in the upstream Postgres database.
        """
        return pulumi.get(self, "upstream_name")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class SourceWebhookCheckOptionArgs:
    def __init__(__self__, *,
                 field: pulumi.Input['SourceWebhookCheckOptionFieldArgs'],
                 alias: Optional[pulumi.Input[str]] = None,
                 bytes: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input['SourceWebhookCheckOptionFieldArgs'] field: The field for the check options.
        :param pulumi.Input[str] alias: The alias for the check options.
        :param pulumi.Input[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) -> pulumi.Input['SourceWebhookCheckOptionFieldArgs']:
        """
        The field for the check options.
        """
        return pulumi.get(self, "field")

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

    @property
    @pulumi.getter
    def alias(self) -> Optional[pulumi.Input[str]]:
        """
        The alias for the check options.
        """
        return pulumi.get(self, "alias")

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

    @property
    @pulumi.getter
    def bytes(self) -> Optional[pulumi.Input[bool]]:
        """
        Change type to `bytea`.
        """
        return pulumi.get(self, "bytes")

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


@pulumi.input_type
class SourceWebhookCheckOptionFieldArgs:
    def __init__(__self__, *,
                 body: Optional[pulumi.Input[bool]] = None,
                 headers: Optional[pulumi.Input[bool]] = None,
                 secret: Optional[pulumi.Input['SourceWebhookCheckOptionFieldSecretArgs']] = 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[pulumi.Input[bool]]:
        return pulumi.get(self, "body")

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

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

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

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

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


@pulumi.input_type
class SourceWebhookCheckOptionFieldSecretArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 database_name: Optional[pulumi.Input[str]] = None,
                 schema_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The identifier for the source.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The identifier for the source.
        """
        return pulumi.get(self, "name")

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

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

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

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

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


@pulumi.input_type
class SourceWebhookIncludeHeaderArgs:
    def __init__(__self__, *,
                 header: pulumi.Input[str],
                 alias: Optional[pulumi.Input[str]] = None,
                 bytes: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] header: The name for the header.
        :param pulumi.Input[str] alias: The alias for the header.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The name for the header.
        """
        return pulumi.get(self, "header")

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

    @property
    @pulumi.getter
    def alias(self) -> Optional[pulumi.Input[str]]:
        """
        The alias for the header.
        """
        return pulumi.get(self, "alias")

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

    @property
    @pulumi.getter
    def bytes(self) -> Optional[pulumi.Input[bool]]:
        """
        Change type to `bytea`.
        """
        return pulumi.get(self, "bytes")

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


@pulumi.input_type
class SourceWebhookIncludeHeadersArgs:
    def __init__(__self__, *,
                 all: Optional[pulumi.Input[bool]] = None,
                 nots: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 onlies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[bool] all: Include all headers.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] nots: Headers that should be excluded.
        :param pulumi.Input[Sequence[pulumi.Input[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[pulumi.Input[bool]]:
        """
        Include all headers.
        """
        return pulumi.get(self, "all")

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

    @property
    @pulumi.getter
    def nots(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Headers that should be excluded.
        """
        return pulumi.get(self, "nots")

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

    @property
    @pulumi.getter
    def onlies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Headers that should be included.
        """
        return pulumi.get(self, "onlies")

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


@pulumi.input_type
class TableColumnArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 type: pulumi.Input[str],
                 comment: Optional[pulumi.Input[str]] = None,
                 default: Optional[pulumi.Input[str]] = None,
                 nullable: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] name: The name of the column to be created in the table.
        :param pulumi.Input[str] type: The data type of the column indicated by name.
        :param pulumi.Input[str] comment: **Public Preview** Comment on an object in the database.
        :param pulumi.Input[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 pulumi.Input[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) -> pulumi.Input[str]:
        """
        The name of the column to be created in the table.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The data type of the column indicated by name.
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter
    def comment(self) -> Optional[pulumi.Input[str]]:
        """
        **Public Preview** Comment on an object in the database.
        """
        return pulumi.get(self, "comment")

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

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

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

    @property
    @pulumi.getter
    def nullable(self) -> Optional[pulumi.Input[bool]]:
        """
        Do not allow the column to contain `NULL` values. Columns without this constraint can contain `NULL` values.
        """
        return pulumi.get(self, "nullable")

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


@pulumi.input_type
class TypeListPropertiesArgs:
    def __init__(__self__, *,
                 element_type: pulumi.Input[str]):
        """
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        Creates a custom list whose elements are of `ELEMENT TYPE`
        """
        return pulumi.get(self, "element_type")

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


@pulumi.input_type
class TypeMapPropertiesArgs:
    def __init__(__self__, *,
                 key_type: pulumi.Input[str],
                 value_type: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key_type: Creates a custom map whose keys are of `KEY TYPE`. `KEY TYPE` must resolve to text.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        Creates a custom map whose keys are of `KEY TYPE`. `KEY TYPE` must resolve to text.
        """
        return pulumi.get(self, "key_type")

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

    @property
    @pulumi.getter(name="valueType")
    def value_type(self) -> pulumi.Input[str]:
        """
        Creates a custom map whose values are of `VALUE TYPE`.
        """
        return pulumi.get(self, "value_type")

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


@pulumi.input_type
class TypeRowPropertyArgs:
    def __init__(__self__, *,
                 field_name: pulumi.Input[str],
                 field_type: pulumi.Input[str]):
        """
        :param pulumi.Input[str] field_name: The name of a field in a row type.
        :param pulumi.Input[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) -> pulumi.Input[str]:
        """
        The name of a field in a row type.
        """
        return pulumi.get(self, "field_name")

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

    @property
    @pulumi.getter(name="fieldType")
    def field_type(self) -> pulumi.Input[str]:
        """
        The data type of a field indicated by `FIELD NAME`.
        """
        return pulumi.get(self, "field_type")

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


