text: # coding=utf-8
  # *** WARNING: this file was generated by the Pulumi SDK Generator. ***
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
  
  import warnings
  import pulumi
  import pulumi.runtime
  from typing import Any, Mapping, Optional, Sequence, Union, overload
  from ... import _utilities
  from ._enums import *
  
  __all__ = [
      'AvroFileFormatArgs',
      'BackfillAllStrategyArgs',
      'BackfillNoneStrategyArgs',
      'DestinationConfigArgs',
      'ForwardSshTunnelConnectivityArgs',
      'GcsDestinationConfigArgs',
      'GcsProfileArgs',
      'JsonFileFormatArgs',
      'MysqlColumnArgs',
      'MysqlDatabaseArgs',
      'MysqlProfileArgs',
      'MysqlRdbmsArgs',
      'MysqlSourceConfigArgs',
      'MysqlSslConfigArgs',
      'MysqlTableArgs',
      'NoConnectivitySettingsArgs',
      'OracleColumnArgs',
      'OracleProfileArgs',
      'OracleRdbmsArgs',
      'OracleSchemaArgs',
      'OracleSourceConfigArgs',
      'OracleTableArgs',
      'PrivateConnectivityArgs',
      'SourceConfigArgs',
      'StaticServiceIpConnectivityArgs',
      'VpcPeeringConfigArgs',
  ]
  
  @pulumi.input_type
  class AvroFileFormatArgs:
      def __init__(__self__):
          """
          AVRO file format configuration.
          """
          pass
  
  
  @pulumi.input_type
  class BackfillAllStrategyArgs:
      def __init__(__self__, *,
                   mysql_excluded_objects: Optional[pulumi.Input['MysqlRdbmsArgs']] = None,
                   oracle_excluded_objects: Optional[pulumi.Input['OracleRdbmsArgs']] = None):
          """
          Backfill strategy to automatically backfill the Stream's objects. Specific objects can be excluded.
          :param pulumi.Input['MysqlRdbmsArgs'] mysql_excluded_objects: MySQL data source objects to avoid backfilling.
          :param pulumi.Input['OracleRdbmsArgs'] oracle_excluded_objects: Oracle data source objects to avoid backfilling.
          """
          if mysql_excluded_objects is not None:
              pulumi.set(__self__, "mysql_excluded_objects", mysql_excluded_objects)
          if oracle_excluded_objects is not None:
              pulumi.set(__self__, "oracle_excluded_objects", oracle_excluded_objects)
  
      @property
      @pulumi.getter(name="mysqlExcludedObjects")
      def mysql_excluded_objects(self) -> Optional[pulumi.Input['MysqlRdbmsArgs']]:
          """
          MySQL data source objects to avoid backfilling.
          """
          return pulumi.get(self, "mysql_excluded_objects")
  
      @mysql_excluded_objects.setter
      def mysql_excluded_objects(self, value: Optional[pulumi.Input['MysqlRdbmsArgs']]):
          pulumi.set(self, "mysql_excluded_objects", value)
  
      @property
      @pulumi.getter(name="oracleExcludedObjects")
      def oracle_excluded_objects(self) -> Optional[pulumi.Input['OracleRdbmsArgs']]:
          """
          Oracle data source objects to avoid backfilling.
          """
          return pulumi.get(self, "oracle_excluded_objects")
  
      @oracle_excluded_objects.setter
      def oracle_excluded_objects(self, value: Optional[pulumi.Input['OracleRdbmsArgs']]):
          pulumi.set(self, "oracle_excluded_objects", value)
  
  
  @pulumi.input_type
  class BackfillNoneStrategyArgs:
      def __init__(__self__):
          """
          Backfill strategy to disable automatic backfill for the Stream's objects.
          """
          pass
  
  
  @pulumi.input_type
  class DestinationConfigArgs:
      def __init__(__self__, *,
                   destination_connection_profile_name: pulumi.Input[str],
                   gcs_destination_config: Optional[pulumi.Input['GcsDestinationConfigArgs']] = None):
          """
          The configuration of the stream destination.
          :param pulumi.Input[str] destination_connection_profile_name: Destination connection profile identifier.
          """
          pulumi.set(__self__, "destination_connection_profile_name", destination_connection_profile_name)
          if gcs_destination_config is not None:
              pulumi.set(__self__, "gcs_destination_config", gcs_destination_config)
  
      @property
      @pulumi.getter(name="destinationConnectionProfileName")
      def destination_connection_profile_name(self) -> pulumi.Input[str]:
          """
          Destination connection profile identifier.
          """
          return pulumi.get(self, "destination_connection_profile_name")
  
      @destination_connection_profile_name.setter
      def destination_connection_profile_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "destination_connection_profile_name", value)
  
      @property
      @pulumi.getter(name="gcsDestinationConfig")
      def gcs_destination_config(self) -> Optional[pulumi.Input['GcsDestinationConfigArgs']]:
          return pulumi.get(self, "gcs_destination_config")
  
      @gcs_destination_config.setter
      def gcs_destination_config(self, value: Optional[pulumi.Input['GcsDestinationConfigArgs']]):
          pulumi.set(self, "gcs_destination_config", value)
  
  
  @pulumi.input_type
  class ForwardSshTunnelConnectivityArgs:
      def __init__(__self__, *,
                   hostname: pulumi.Input[str],
                   username: pulumi.Input[str],
                   password: Optional[pulumi.Input[str]] = None,
                   port: Optional[pulumi.Input[int]] = None,
                   private_key: Optional[pulumi.Input[str]] = None):
          """
          Forward SSH Tunnel connectivity.
          :param pulumi.Input[str] hostname: Hostname for the SSH tunnel.
          :param pulumi.Input[str] username: Username for the SSH tunnel.
          :param pulumi.Input[str] password: Input only. SSH password.
          :param pulumi.Input[int] port: Port for the SSH tunnel, default value is 22.
          :param pulumi.Input[str] private_key: Input only. SSH private key.
          """
          pulumi.set(__self__, "hostname", hostname)
          pulumi.set(__self__, "username", username)
          if password is not None:
              pulumi.set(__self__, "password", password)
          if port is not None:
              pulumi.set(__self__, "port", port)
          if private_key is not None:
              pulumi.set(__self__, "private_key", private_key)
  
      @property
      @pulumi.getter
      def hostname(self) -> pulumi.Input[str]:
          """
          Hostname for the SSH tunnel.
          """
          return pulumi.get(self, "hostname")
  
      @hostname.setter
      def hostname(self, value: pulumi.Input[str]):
          pulumi.set(self, "hostname", value)
  
      @property
      @pulumi.getter
      def username(self) -> pulumi.Input[str]:
          """
          Username for the SSH tunnel.
          """
          return pulumi.get(self, "username")
  
      @username.setter
      def username(self, value: pulumi.Input[str]):
          pulumi.set(self, "username", value)
  
      @property
      @pulumi.getter
      def password(self) -> Optional[pulumi.Input[str]]:
          """
          Input only. SSH password.
          """
          return pulumi.get(self, "password")
  
      @password.setter
      def password(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "password", value)
  
      @property
      @pulumi.getter
      def port(self) -> Optional[pulumi.Input[int]]:
          """
          Port for the SSH tunnel, default value is 22.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter(name="privateKey")
      def private_key(self) -> Optional[pulumi.Input[str]]:
          """
          Input only. SSH private key.
          """
          return pulumi.get(self, "private_key")
  
      @private_key.setter
      def private_key(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "private_key", value)
  
  
  @pulumi.input_type
  class GcsDestinationConfigArgs:
      def __init__(__self__, *,
                   avro_file_format: Optional[pulumi.Input['AvroFileFormatArgs']] = None,
                   file_rotation_interval: Optional[pulumi.Input[str]] = None,
                   file_rotation_mb: Optional[pulumi.Input[int]] = None,
                   json_file_format: Optional[pulumi.Input['JsonFileFormatArgs']] = None,
                   path: Optional[pulumi.Input[str]] = None):
          """
          Google Cloud Storage destination configuration
          :param pulumi.Input['AvroFileFormatArgs'] avro_file_format: AVRO file format configuration.
          :param pulumi.Input[str] file_rotation_interval: The maximum duration for which new events are added before a file is closed and a new file is created.
          :param pulumi.Input[int] file_rotation_mb: The maximum file size to be saved in the bucket.
          :param pulumi.Input['JsonFileFormatArgs'] json_file_format: JSON file format configuration.
          :param pulumi.Input[str] path: Path inside the Cloud Storage bucket to write data to.
          """
          if avro_file_format is not None:
              pulumi.set(__self__, "avro_file_format", avro_file_format)
          if file_rotation_interval is not None:
              pulumi.set(__self__, "file_rotation_interval", file_rotation_interval)
          if file_rotation_mb is not None:
              pulumi.set(__self__, "file_rotation_mb", file_rotation_mb)
          if json_file_format is not None:
              pulumi.set(__self__, "json_file_format", json_file_format)
          if path is not None:
              pulumi.set(__self__, "path", path)
  
      @property
      @pulumi.getter(name="avroFileFormat")
      def avro_file_format(self) -> Optional[pulumi.Input['AvroFileFormatArgs']]:
          """
          AVRO file format configuration.
          """
          return pulumi.get(self, "avro_file_format")
  
      @avro_file_format.setter
      def avro_file_format(self, value: Optional[pulumi.Input['AvroFileFormatArgs']]):
          pulumi.set(self, "avro_file_format", value)
  
      @property
      @pulumi.getter(name="fileRotationInterval")
      def file_rotation_interval(self) -> Optional[pulumi.Input[str]]:
          """
          The maximum duration for which new events are added before a file is closed and a new file is created.
          """
          return pulumi.get(self, "file_rotation_interval")
  
      @file_rotation_interval.setter
      def file_rotation_interval(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "file_rotation_interval", value)
  
      @property
      @pulumi.getter(name="fileRotationMb")
      def file_rotation_mb(self) -> Optional[pulumi.Input[int]]:
          """
          The maximum file size to be saved in the bucket.
          """
          return pulumi.get(self, "file_rotation_mb")
  
      @file_rotation_mb.setter
      def file_rotation_mb(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "file_rotation_mb", value)
  
      @property
      @pulumi.getter(name="jsonFileFormat")
      def json_file_format(self) -> Optional[pulumi.Input['JsonFileFormatArgs']]:
          """
          JSON file format configuration.
          """
          return pulumi.get(self, "json_file_format")
  
      @json_file_format.setter
      def json_file_format(self, value: Optional[pulumi.Input['JsonFileFormatArgs']]):
          pulumi.set(self, "json_file_format", value)
  
      @property
      @pulumi.getter
      def path(self) -> Optional[pulumi.Input[str]]:
          """
          Path inside the Cloud Storage bucket to write data to.
          """
          return pulumi.get(self, "path")
  
      @path.setter
      def path(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "path", value)
  
  
  @pulumi.input_type
  class GcsProfileArgs:
      def __init__(__self__, *,
                   bucket_name: pulumi.Input[str],
                   root_path: Optional[pulumi.Input[str]] = None):
          """
          Cloud Storage bucket profile.
          :param pulumi.Input[str] bucket_name: The full project and resource path for Cloud Storage bucket including the name.
          :param pulumi.Input[str] root_path: The root path inside the Cloud Storage bucket.
          """
          pulumi.set(__self__, "bucket_name", bucket_name)
          if root_path is not None:
              pulumi.set(__self__, "root_path", root_path)
  
      @property
      @pulumi.getter(name="bucketName")
      def bucket_name(self) -> pulumi.Input[str]:
          """
          The full project and resource path for Cloud Storage bucket including the name.
          """
          return pulumi.get(self, "bucket_name")
  
      @bucket_name.setter
      def bucket_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "bucket_name", value)
  
      @property
      @pulumi.getter(name="rootPath")
      def root_path(self) -> Optional[pulumi.Input[str]]:
          """
          The root path inside the Cloud Storage bucket.
          """
          return pulumi.get(self, "root_path")
  
      @root_path.setter
      def root_path(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "root_path", value)
  
  
  @pulumi.input_type
  class JsonFileFormatArgs:
      def __init__(__self__, *,
                   compression: Optional[pulumi.Input['JsonFileFormatCompression']] = None,
                   schema_file_format: Optional[pulumi.Input['JsonFileFormatSchemaFileFormat']] = None):
          """
          JSON file format configuration.
          :param pulumi.Input['JsonFileFormatCompression'] compression: Compression of the loaded JSON file.
          :param pulumi.Input['JsonFileFormatSchemaFileFormat'] schema_file_format: The schema file format along JSON data files.
          """
          if compression is not None:
              pulumi.set(__self__, "compression", compression)
          if schema_file_format is not None:
              pulumi.set(__self__, "schema_file_format", schema_file_format)
  
      @property
      @pulumi.getter
      def compression(self) -> Optional[pulumi.Input['JsonFileFormatCompression']]:
          """
          Compression of the loaded JSON file.
          """
          return pulumi.get(self, "compression")
  
      @compression.setter
      def compression(self, value: Optional[pulumi.Input['JsonFileFormatCompression']]):
          pulumi.set(self, "compression", value)
  
      @property
      @pulumi.getter(name="schemaFileFormat")
      def schema_file_format(self) -> Optional[pulumi.Input['JsonFileFormatSchemaFileFormat']]:
          """
          The schema file format along JSON data files.
          """
          return pulumi.get(self, "schema_file_format")
  
      @schema_file_format.setter
      def schema_file_format(self, value: Optional[pulumi.Input['JsonFileFormatSchemaFileFormat']]):
          pulumi.set(self, "schema_file_format", value)
  
  
  @pulumi.input_type
  class MysqlColumnArgs:
      def __init__(__self__, *,
                   collation: Optional[pulumi.Input[str]] = None,
                   column_name: Optional[pulumi.Input[str]] = None,
                   data_type: Optional[pulumi.Input[str]] = None,
                   length: Optional[pulumi.Input[int]] = None,
                   nullable: Optional[pulumi.Input[bool]] = None,
                   ordinal_position: Optional[pulumi.Input[int]] = None,
                   primary_key: Optional[pulumi.Input[bool]] = None):
          """
          MySQL Column.
          :param pulumi.Input[str] collation: Column collation.
          :param pulumi.Input[str] column_name: Column name.
          :param pulumi.Input[str] data_type: The MySQL data type. Full data types list can be found here: https://dev.mysql.com/doc/refman/8.0/en/data-types.html
          :param pulumi.Input[int] length: Column length.
          :param pulumi.Input[bool] nullable: Whether or not the column can accept a null value.
          :param pulumi.Input[int] ordinal_position: The ordinal position of the column in the table.
          :param pulumi.Input[bool] primary_key: Whether or not the column represents a primary key.
          """
          if collation is not None:
              pulumi.set(__self__, "collation", collation)
          if column_name is not None:
              pulumi.set(__self__, "column_name", column_name)
          if data_type is not None:
              pulumi.set(__self__, "data_type", data_type)
          if length is not None:
              pulumi.set(__self__, "length", length)
          if nullable is not None:
              pulumi.set(__self__, "nullable", nullable)
          if ordinal_position is not None:
              pulumi.set(__self__, "ordinal_position", ordinal_position)
          if primary_key is not None:
              pulumi.set(__self__, "primary_key", primary_key)
  
      @property
      @pulumi.getter
      def collation(self) -> Optional[pulumi.Input[str]]:
          """
          Column collation.
          """
          return pulumi.get(self, "collation")
  
      @collation.setter
      def collation(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "collation", value)
  
      @property
      @pulumi.getter(name="columnName")
      def column_name(self) -> Optional[pulumi.Input[str]]:
          """
          Column name.
          """
          return pulumi.get(self, "column_name")
  
      @column_name.setter
      def column_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "column_name", value)
  
      @property
      @pulumi.getter(name="dataType")
      def data_type(self) -> Optional[pulumi.Input[str]]:
          """
          The MySQL data type. Full data types list can be found here: https://dev.mysql.com/doc/refman/8.0/en/data-types.html
          """
          return pulumi.get(self, "data_type")
  
      @data_type.setter
      def data_type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "data_type", value)
  
      @property
      @pulumi.getter
      def length(self) -> Optional[pulumi.Input[int]]:
          """
          Column length.
          """
          return pulumi.get(self, "length")
  
      @length.setter
      def length(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "length", value)
  
      @property
      @pulumi.getter
      def nullable(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether or not the column can accept a null value.
          """
          return pulumi.get(self, "nullable")
  
      @nullable.setter
      def nullable(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "nullable", value)
  
      @property
      @pulumi.getter(name="ordinalPosition")
      def ordinal_position(self) -> Optional[pulumi.Input[int]]:
          """
          The ordinal position of the column in the table.
          """
          return pulumi.get(self, "ordinal_position")
  
      @ordinal_position.setter
      def ordinal_position(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "ordinal_position", value)
  
      @property
      @pulumi.getter(name="primaryKey")
      def primary_key(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether or not the column represents a primary key.
          """
          return pulumi.get(self, "primary_key")
  
      @primary_key.setter
      def primary_key(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "primary_key", value)
  
  
  @pulumi.input_type
  class MysqlDatabaseArgs:
      def __init__(__self__, *,
                   database_name: Optional[pulumi.Input[str]] = None,
                   mysql_tables: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlTableArgs']]]] = None):
          """
          MySQL database.
          :param pulumi.Input[str] database_name: Database name.
          :param pulumi.Input[Sequence[pulumi.Input['MysqlTableArgs']]] mysql_tables: Tables in the database.
          """
          if database_name is not None:
              pulumi.set(__self__, "database_name", database_name)
          if mysql_tables is not None:
              pulumi.set(__self__, "mysql_tables", mysql_tables)
  
      @property
      @pulumi.getter(name="databaseName")
      def database_name(self) -> Optional[pulumi.Input[str]]:
          """
          Database name.
          """
          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="mysqlTables")
      def mysql_tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MysqlTableArgs']]]]:
          """
          Tables in the database.
          """
          return pulumi.get(self, "mysql_tables")
  
      @mysql_tables.setter
      def mysql_tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlTableArgs']]]]):
          pulumi.set(self, "mysql_tables", value)
  
  
  @pulumi.input_type
  class MysqlProfileArgs:
      def __init__(__self__, *,
                   hostname: pulumi.Input[str],
                   password: pulumi.Input[str],
                   username: pulumi.Input[str],
                   port: Optional[pulumi.Input[int]] = None,
                   ssl_config: Optional[pulumi.Input['MysqlSslConfigArgs']] = None):
          """
          MySQL database profile.
          :param pulumi.Input[str] hostname: Hostname for the MySQL connection.
          :param pulumi.Input[str] password: Input only. Password for the MySQL connection.
          :param pulumi.Input[str] username: Username for the MySQL connection.
          :param pulumi.Input[int] port: Port for the MySQL connection, default value is 3306.
          :param pulumi.Input['MysqlSslConfigArgs'] ssl_config: SSL configuration for the MySQL connection.
          """
          pulumi.set(__self__, "hostname", hostname)
          pulumi.set(__self__, "password", password)
          pulumi.set(__self__, "username", username)
          if port is not None:
              pulumi.set(__self__, "port", port)
          if ssl_config is not None:
              pulumi.set(__self__, "ssl_config", ssl_config)
  
      @property
      @pulumi.getter
      def hostname(self) -> pulumi.Input[str]:
          """
          Hostname for the MySQL connection.
          """
          return pulumi.get(self, "hostname")
  
      @hostname.setter
      def hostname(self, value: pulumi.Input[str]):
          pulumi.set(self, "hostname", value)
  
      @property
      @pulumi.getter
      def password(self) -> pulumi.Input[str]:
          """
          Input only. Password for the MySQL connection.
          """
          return pulumi.get(self, "password")
  
      @password.setter
      def password(self, value: pulumi.Input[str]):
          pulumi.set(self, "password", value)
  
      @property
      @pulumi.getter
      def username(self) -> pulumi.Input[str]:
          """
          Username for the MySQL connection.
          """
          return pulumi.get(self, "username")
  
      @username.setter
      def username(self, value: pulumi.Input[str]):
          pulumi.set(self, "username", value)
  
      @property
      @pulumi.getter
      def port(self) -> Optional[pulumi.Input[int]]:
          """
          Port for the MySQL connection, default value is 3306.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter(name="sslConfig")
      def ssl_config(self) -> Optional[pulumi.Input['MysqlSslConfigArgs']]:
          """
          SSL configuration for the MySQL connection.
          """
          return pulumi.get(self, "ssl_config")
  
      @ssl_config.setter
      def ssl_config(self, value: Optional[pulumi.Input['MysqlSslConfigArgs']]):
          pulumi.set(self, "ssl_config", value)
  
  
  @pulumi.input_type
  class MysqlRdbmsArgs:
      def __init__(__self__, *,
                   mysql_databases: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlDatabaseArgs']]]] = None):
          """
          MySQL database structure
          :param pulumi.Input[Sequence[pulumi.Input['MysqlDatabaseArgs']]] mysql_databases: Mysql databases on the server
          """
          if mysql_databases is not None:
              pulumi.set(__self__, "mysql_databases", mysql_databases)
  
      @property
      @pulumi.getter(name="mysqlDatabases")
      def mysql_databases(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MysqlDatabaseArgs']]]]:
          """
          Mysql databases on the server
          """
          return pulumi.get(self, "mysql_databases")
  
      @mysql_databases.setter
      def mysql_databases(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlDatabaseArgs']]]]):
          pulumi.set(self, "mysql_databases", value)
  
  
  @pulumi.input_type
  class MysqlSourceConfigArgs:
      def __init__(__self__, *,
                   allowlist: Optional[pulumi.Input['MysqlRdbmsArgs']] = None,
                   rejectlist: Optional[pulumi.Input['MysqlRdbmsArgs']] = None):
          """
          MySQL source configuration
          :param pulumi.Input['MysqlRdbmsArgs'] allowlist: MySQL objects to retrieve from the source.
          :param pulumi.Input['MysqlRdbmsArgs'] rejectlist: MySQL objects to exclude from the stream.
          """
          if allowlist is not None:
              pulumi.set(__self__, "allowlist", allowlist)
          if rejectlist is not None:
              pulumi.set(__self__, "rejectlist", rejectlist)
  
      @property
      @pulumi.getter
      def allowlist(self) -> Optional[pulumi.Input['MysqlRdbmsArgs']]:
          """
          MySQL objects to retrieve from the source.
          """
          return pulumi.get(self, "allowlist")
  
      @allowlist.setter
      def allowlist(self, value: Optional[pulumi.Input['MysqlRdbmsArgs']]):
          pulumi.set(self, "allowlist", value)
  
      @property
      @pulumi.getter
      def rejectlist(self) -> Optional[pulumi.Input['MysqlRdbmsArgs']]:
          """
          MySQL objects to exclude from the stream.
          """
          return pulumi.get(self, "rejectlist")
  
      @rejectlist.setter
      def rejectlist(self, value: Optional[pulumi.Input['MysqlRdbmsArgs']]):
          pulumi.set(self, "rejectlist", value)
  
  
  @pulumi.input_type
  class MysqlSslConfigArgs:
      def __init__(__self__, *,
                   ca_certificate: Optional[pulumi.Input[str]] = None,
                   client_certificate: Optional[pulumi.Input[str]] = None,
                   client_key: Optional[pulumi.Input[str]] = None):
          """
          MySQL SSL configuration information.
          :param pulumi.Input[str] ca_certificate: Input only. PEM-encoded certificate of the CA that signed the source database server's certificate.
          :param pulumi.Input[str] client_certificate: Input only. PEM-encoded certificate that will be used by the replica to authenticate against the source database server. If this field is used then the 'client_key' and the 'ca_certificate' fields are mandatory.
          :param pulumi.Input[str] client_key: Input only. PEM-encoded private key associated with the Client Certificate. If this field is used then the 'client_certificate' and the 'ca_certificate' fields are mandatory.
          """
          if ca_certificate is not None:
              pulumi.set(__self__, "ca_certificate", ca_certificate)
          if client_certificate is not None:
              pulumi.set(__self__, "client_certificate", client_certificate)
          if client_key is not None:
              pulumi.set(__self__, "client_key", client_key)
  
      @property
      @pulumi.getter(name="caCertificate")
      def ca_certificate(self) -> Optional[pulumi.Input[str]]:
          """
          Input only. PEM-encoded certificate of the CA that signed the source database server's certificate.
          """
          return pulumi.get(self, "ca_certificate")
  
      @ca_certificate.setter
      def ca_certificate(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "ca_certificate", value)
  
      @property
      @pulumi.getter(name="clientCertificate")
      def client_certificate(self) -> Optional[pulumi.Input[str]]:
          """
          Input only. PEM-encoded certificate that will be used by the replica to authenticate against the source database server. If this field is used then the 'client_key' and the 'ca_certificate' fields are mandatory.
          """
          return pulumi.get(self, "client_certificate")
  
      @client_certificate.setter
      def client_certificate(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "client_certificate", value)
  
      @property
      @pulumi.getter(name="clientKey")
      def client_key(self) -> Optional[pulumi.Input[str]]:
          """
          Input only. PEM-encoded private key associated with the Client Certificate. If this field is used then the 'client_certificate' and the 'ca_certificate' fields are mandatory.
          """
          return pulumi.get(self, "client_key")
  
      @client_key.setter
      def client_key(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "client_key", value)
  
  
  @pulumi.input_type
  class MysqlTableArgs:
      def __init__(__self__, *,
                   mysql_columns: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlColumnArgs']]]] = None,
                   table_name: Optional[pulumi.Input[str]] = None):
          """
          MySQL table.
          :param pulumi.Input[Sequence[pulumi.Input['MysqlColumnArgs']]] mysql_columns: MySQL columns in the database. When unspecified as part of include/exclude lists, includes/excludes everything.
          :param pulumi.Input[str] table_name: Table name.
          """
          if mysql_columns is not None:
              pulumi.set(__self__, "mysql_columns", mysql_columns)
          if table_name is not None:
              pulumi.set(__self__, "table_name", table_name)
  
      @property
      @pulumi.getter(name="mysqlColumns")
      def mysql_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MysqlColumnArgs']]]]:
          """
          MySQL columns in the database. When unspecified as part of include/exclude lists, includes/excludes everything.
          """
          return pulumi.get(self, "mysql_columns")
  
      @mysql_columns.setter
      def mysql_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MysqlColumnArgs']]]]):
          pulumi.set(self, "mysql_columns", value)
  
      @property
      @pulumi.getter(name="tableName")
      def table_name(self) -> Optional[pulumi.Input[str]]:
          """
          Table name.
          """
          return pulumi.get(self, "table_name")
  
      @table_name.setter
      def table_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "table_name", value)
  
  
  @pulumi.input_type
  class NoConnectivitySettingsArgs:
      def __init__(__self__):
          """
          No connectivity settings.
          """
          pass
  
  
  @pulumi.input_type
  class OracleColumnArgs:
      def __init__(__self__, *,
                   column_name: Optional[pulumi.Input[str]] = None,
                   data_type: Optional[pulumi.Input[str]] = None,
                   encoding: Optional[pulumi.Input[str]] = None,
                   length: Optional[pulumi.Input[int]] = None,
                   nullable: Optional[pulumi.Input[bool]] = None,
                   ordinal_position: Optional[pulumi.Input[int]] = None,
                   precision: Optional[pulumi.Input[int]] = None,
                   primary_key: Optional[pulumi.Input[bool]] = None,
                   scale: Optional[pulumi.Input[int]] = None):
          """
          Oracle Column.
          :param pulumi.Input[str] column_name: Column name.
          :param pulumi.Input[str] data_type: The Oracle data type.
          :param pulumi.Input[str] encoding: Column encoding.
          :param pulumi.Input[int] length: Column length.
          :param pulumi.Input[bool] nullable: Whether or not the column can accept a null value.
          :param pulumi.Input[int] ordinal_position: The ordinal position of the column in the table.
          :param pulumi.Input[int] precision: Column precision.
          :param pulumi.Input[bool] primary_key: Whether or not the column represents a primary key.
          :param pulumi.Input[int] scale: Column scale.
          """
          if column_name is not None:
              pulumi.set(__self__, "column_name", column_name)
          if data_type is not None:
              pulumi.set(__self__, "data_type", data_type)
          if encoding is not None:
              pulumi.set(__self__, "encoding", encoding)
          if length is not None:
              pulumi.set(__self__, "length", length)
          if nullable is not None:
              pulumi.set(__self__, "nullable", nullable)
          if ordinal_position is not None:
              pulumi.set(__self__, "ordinal_position", ordinal_position)
          if precision is not None:
              pulumi.set(__self__, "precision", precision)
          if primary_key is not None:
              pulumi.set(__self__, "primary_key", primary_key)
          if scale is not None:
              pulumi.set(__self__, "scale", scale)
  
      @property
      @pulumi.getter(name="columnName")
      def column_name(self) -> Optional[pulumi.Input[str]]:
          """
          Column name.
          """
          return pulumi.get(self, "column_name")
  
      @column_name.setter
      def column_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "column_name", value)
  
      @property
      @pulumi.getter(name="dataType")
      def data_type(self) -> Optional[pulumi.Input[str]]:
          """
          The Oracle data type.
          """
          return pulumi.get(self, "data_type")
  
      @data_type.setter
      def data_type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "data_type", value)
  
      @property
      @pulumi.getter
      def encoding(self) -> Optional[pulumi.Input[str]]:
          """
          Column encoding.
          """
          return pulumi.get(self, "encoding")
  
      @encoding.setter
      def encoding(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "encoding", value)
  
      @property
      @pulumi.getter
      def length(self) -> Optional[pulumi.Input[int]]:
          """
          Column length.
          """
          return pulumi.get(self, "length")
  
      @length.setter
      def length(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "length", value)
  
      @property
      @pulumi.getter
      def nullable(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether or not the column can accept a null value.
          """
          return pulumi.get(self, "nullable")
  
      @nullable.setter
      def nullable(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "nullable", value)
  
      @property
      @pulumi.getter(name="ordinalPosition")
      def ordinal_position(self) -> Optional[pulumi.Input[int]]:
          """
          The ordinal position of the column in the table.
          """
          return pulumi.get(self, "ordinal_position")
  
      @ordinal_position.setter
      def ordinal_position(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "ordinal_position", value)
  
      @property
      @pulumi.getter
      def precision(self) -> Optional[pulumi.Input[int]]:
          """
          Column precision.
          """
          return pulumi.get(self, "precision")
  
      @precision.setter
      def precision(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "precision", value)
  
      @property
      @pulumi.getter(name="primaryKey")
      def primary_key(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether or not the column represents a primary key.
          """
          return pulumi.get(self, "primary_key")
  
      @primary_key.setter
      def primary_key(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "primary_key", value)
  
      @property
      @pulumi.getter
      def scale(self) -> Optional[pulumi.Input[int]]:
          """
          Column scale.
          """
          return pulumi.get(self, "scale")
  
      @scale.setter
      def scale(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "scale", value)
  
  
  @pulumi.input_type
  class OracleProfileArgs:
      def __init__(__self__, *,
                   database_service: pulumi.Input[str],
                   hostname: pulumi.Input[str],
                   password: pulumi.Input[str],
                   username: pulumi.Input[str],
                   connection_attributes: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   port: Optional[pulumi.Input[int]] = None):
          """
          Oracle database profile.
          :param pulumi.Input[str] database_service: Database for the Oracle connection.
          :param pulumi.Input[str] hostname: Hostname for the Oracle connection.
          :param pulumi.Input[str] password: Password for the Oracle connection.
          :param pulumi.Input[str] username: Username for the Oracle connection.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] connection_attributes: Connection string attributes
          :param pulumi.Input[int] port: Port for the Oracle connection, default value is 1521.
          """
          pulumi.set(__self__, "database_service", database_service)
          pulumi.set(__self__, "hostname", hostname)
          pulumi.set(__self__, "password", password)
          pulumi.set(__self__, "username", username)
          if connection_attributes is not None:
              pulumi.set(__self__, "connection_attributes", connection_attributes)
          if port is not None:
              pulumi.set(__self__, "port", port)
  
      @property
      @pulumi.getter(name="databaseService")
      def database_service(self) -> pulumi.Input[str]:
          """
          Database for the Oracle connection.
          """
          return pulumi.get(self, "database_service")
  
      @database_service.setter
      def database_service(self, value: pulumi.Input[str]):
          pulumi.set(self, "database_service", value)
  
      @property
      @pulumi.getter
      def hostname(self) -> pulumi.Input[str]:
          """
          Hostname for the Oracle connection.
          """
          return pulumi.get(self, "hostname")
  
      @hostname.setter
      def hostname(self, value: pulumi.Input[str]):
          pulumi.set(self, "hostname", value)
  
      @property
      @pulumi.getter
      def password(self) -> pulumi.Input[str]:
          """
          Password for the Oracle connection.
          """
          return pulumi.get(self, "password")
  
      @password.setter
      def password(self, value: pulumi.Input[str]):
          pulumi.set(self, "password", value)
  
      @property
      @pulumi.getter
      def username(self) -> pulumi.Input[str]:
          """
          Username for the Oracle connection.
          """
          return pulumi.get(self, "username")
  
      @username.setter
      def username(self, value: pulumi.Input[str]):
          pulumi.set(self, "username", value)
  
      @property
      @pulumi.getter(name="connectionAttributes")
      def connection_attributes(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Connection string attributes
          """
          return pulumi.get(self, "connection_attributes")
  
      @connection_attributes.setter
      def connection_attributes(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "connection_attributes", value)
  
      @property
      @pulumi.getter
      def port(self) -> Optional[pulumi.Input[int]]:
          """
          Port for the Oracle connection, default value is 1521.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "port", value)
  
  
  @pulumi.input_type
  class OracleRdbmsArgs:
      def __init__(__self__, *,
                   oracle_schemas: Optional[pulumi.Input[Sequence[pulumi.Input['OracleSchemaArgs']]]] = None):
          """
          Oracle database structure.
          :param pulumi.Input[Sequence[pulumi.Input['OracleSchemaArgs']]] oracle_schemas: Oracle schemas/databases in the database server.
          """
          if oracle_schemas is not None:
              pulumi.set(__self__, "oracle_schemas", oracle_schemas)
  
      @property
      @pulumi.getter(name="oracleSchemas")
      def oracle_schemas(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OracleSchemaArgs']]]]:
          """
          Oracle schemas/databases in the database server.
          """
          return pulumi.get(self, "oracle_schemas")
  
      @oracle_schemas.setter
      def oracle_schemas(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OracleSchemaArgs']]]]):
          pulumi.set(self, "oracle_schemas", value)
  
  
  @pulumi.input_type
  class OracleSchemaArgs:
      def __init__(__self__, *,
                   oracle_tables: Optional[pulumi.Input[Sequence[pulumi.Input['OracleTableArgs']]]] = None,
                   schema_name: Optional[pulumi.Input[str]] = None):
          """
          Oracle schema.
          :param pulumi.Input[Sequence[pulumi.Input['OracleTableArgs']]] oracle_tables: Tables in the schema.
          :param pulumi.Input[str] schema_name: Schema name.
          """
          if oracle_tables is not None:
              pulumi.set(__self__, "oracle_tables", oracle_tables)
          if schema_name is not None:
              pulumi.set(__self__, "schema_name", schema_name)
  
      @property
      @pulumi.getter(name="oracleTables")
      def oracle_tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OracleTableArgs']]]]:
          """
          Tables in the schema.
          """
          return pulumi.get(self, "oracle_tables")
  
      @oracle_tables.setter
      def oracle_tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OracleTableArgs']]]]):
          pulumi.set(self, "oracle_tables", value)
  
      @property
      @pulumi.getter(name="schemaName")
      def schema_name(self) -> Optional[pulumi.Input[str]]:
          """
          Schema name.
          """
          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 OracleSourceConfigArgs:
      def __init__(__self__, *,
                   allowlist: Optional[pulumi.Input['OracleRdbmsArgs']] = None,
                   rejectlist: Optional[pulumi.Input['OracleRdbmsArgs']] = None):
          """
          Oracle data source configuration
          :param pulumi.Input['OracleRdbmsArgs'] allowlist: Oracle objects to include in the stream.
          :param pulumi.Input['OracleRdbmsArgs'] rejectlist: Oracle objects to exclude from the stream.
          """
          if allowlist is not None:
              pulumi.set(__self__, "allowlist", allowlist)
          if rejectlist is not None:
              pulumi.set(__self__, "rejectlist", rejectlist)
  
      @property
      @pulumi.getter
      def allowlist(self) -> Optional[pulumi.Input['OracleRdbmsArgs']]:
          """
          Oracle objects to include in the stream.
          """
          return pulumi.get(self, "allowlist")
  
      @allowlist.setter
      def allowlist(self, value: Optional[pulumi.Input['OracleRdbmsArgs']]):
          pulumi.set(self, "allowlist", value)
  
      @property
      @pulumi.getter
      def rejectlist(self) -> Optional[pulumi.Input['OracleRdbmsArgs']]:
          """
          Oracle objects to exclude from the stream.
          """
          return pulumi.get(self, "rejectlist")
  
      @rejectlist.setter
      def rejectlist(self, value: Optional[pulumi.Input['OracleRdbmsArgs']]):
          pulumi.set(self, "rejectlist", value)
  
  
  @pulumi.input_type
  class OracleTableArgs:
      def __init__(__self__, *,
                   oracle_columns: Optional[pulumi.Input[Sequence[pulumi.Input['OracleColumnArgs']]]] = None,
                   table_name: Optional[pulumi.Input[str]] = None):
          """
          Oracle table.
          :param pulumi.Input[Sequence[pulumi.Input['OracleColumnArgs']]] oracle_columns: Oracle columns in the schema. When unspecified as part of inclue/exclude lists, includes/excludes everything.
          :param pulumi.Input[str] table_name: Table name.
          """
          if oracle_columns is not None:
              pulumi.set(__self__, "oracle_columns", oracle_columns)
          if table_name is not None:
              pulumi.set(__self__, "table_name", table_name)
  
      @property
      @pulumi.getter(name="oracleColumns")
      def oracle_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OracleColumnArgs']]]]:
          """
          Oracle columns in the schema. When unspecified as part of inclue/exclude lists, includes/excludes everything.
          """
          return pulumi.get(self, "oracle_columns")
  
      @oracle_columns.setter
      def oracle_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OracleColumnArgs']]]]):
          pulumi.set(self, "oracle_columns", value)
  
      @property
      @pulumi.getter(name="tableName")
      def table_name(self) -> Optional[pulumi.Input[str]]:
          """
          Table name.
          """
          return pulumi.get(self, "table_name")
  
      @table_name.setter
      def table_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "table_name", value)
  
  
  @pulumi.input_type
  class PrivateConnectivityArgs:
      def __init__(__self__, *,
                   private_connection_name: Optional[pulumi.Input[str]] = None):
          """
          Private Connectivity
          """
          if private_connection_name is not None:
              pulumi.set(__self__, "private_connection_name", private_connection_name)
  
      @property
      @pulumi.getter(name="privateConnectionName")
      def private_connection_name(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "private_connection_name")
  
      @private_connection_name.setter
      def private_connection_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "private_connection_name", value)
  
  
  @pulumi.input_type
  class SourceConfigArgs:
      def __init__(__self__, *,
                   source_connection_profile_name: pulumi.Input[str],
                   mysql_source_config: Optional[pulumi.Input['MysqlSourceConfigArgs']] = None,
                   oracle_source_config: Optional[pulumi.Input['OracleSourceConfigArgs']] = None):
          """
          The configuration of the stream source.
          :param pulumi.Input[str] source_connection_profile_name: Source connection profile identifier.
          :param pulumi.Input['MysqlSourceConfigArgs'] mysql_source_config: MySQL data source configuration
          :param pulumi.Input['OracleSourceConfigArgs'] oracle_source_config: Oracle data source configuration
          """
          pulumi.set(__self__, "source_connection_profile_name", source_connection_profile_name)
          if mysql_source_config is not None:
              pulumi.set(__self__, "mysql_source_config", mysql_source_config)
          if oracle_source_config is not None:
              pulumi.set(__self__, "oracle_source_config", oracle_source_config)
  
      @property
      @pulumi.getter(name="sourceConnectionProfileName")
      def source_connection_profile_name(self) -> pulumi.Input[str]:
          """
          Source connection profile identifier.
          """
          return pulumi.get(self, "source_connection_profile_name")
  
      @source_connection_profile_name.setter
      def source_connection_profile_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "source_connection_profile_name", value)
  
      @property
      @pulumi.getter(name="mysqlSourceConfig")
      def mysql_source_config(self) -> Optional[pulumi.Input['MysqlSourceConfigArgs']]:
          """
          MySQL data source configuration
          """
          return pulumi.get(self, "mysql_source_config")
  
      @mysql_source_config.setter
      def mysql_source_config(self, value: Optional[pulumi.Input['MysqlSourceConfigArgs']]):
          pulumi.set(self, "mysql_source_config", value)
  
      @property
      @pulumi.getter(name="oracleSourceConfig")
      def oracle_source_config(self) -> Optional[pulumi.Input['OracleSourceConfigArgs']]:
          """
          Oracle data source configuration
          """
          return pulumi.get(self, "oracle_source_config")
  
      @oracle_source_config.setter
      def oracle_source_config(self, value: Optional[pulumi.Input['OracleSourceConfigArgs']]):
          pulumi.set(self, "oracle_source_config", value)
  
  
  @pulumi.input_type
  class StaticServiceIpConnectivityArgs:
      def __init__(__self__):
          """
          Static IP address connectivity.
          """
          pass
  
  
  @pulumi.input_type
  class VpcPeeringConfigArgs:
      def __init__(__self__, *,
                   subnet: pulumi.Input[str],
                   vpc_name: pulumi.Input[str]):
          """
          The VPC Peering configuration is used to create VPC peering between Datastream and the consumer's VPC.
          :param pulumi.Input[str] subnet: A free subnet for peering. (CIDR of /29) TODO(b/172995841) add validators.
          :param pulumi.Input[str] vpc_name: fully qualified name of the VPC Datastream will peer to.
          """
          pulumi.set(__self__, "subnet", subnet)
          pulumi.set(__self__, "vpc_name", vpc_name)
  
      @property
      @pulumi.getter
      def subnet(self) -> pulumi.Input[str]:
          """
          A free subnet for peering. (CIDR of /29) TODO(b/172995841) add validators.
          """
          return pulumi.get(self, "subnet")
  
      @subnet.setter
      def subnet(self, value: pulumi.Input[str]):
          pulumi.set(self, "subnet", value)
  
      @property
      @pulumi.getter(name="vpcName")
      def vpc_name(self) -> pulumi.Input[str]:
          """
          fully qualified name of the VPC Datastream will peer to.
          """
          return pulumi.get(self, "vpc_name")
  
      @vpc_name.setter
      def vpc_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "vpc_name", value)
  
  
  