pulumi-gcp 7.24.0__py3-none-any.whl → 7.24.0a1716510380__py3-none-any.whl

pulumi_gcp/datastream/_inputs.py

@@ -18,7 +18,6 @@ __all__ = [
     'ConnectionProfileOracleProfileArgs',
     'ConnectionProfilePostgresqlProfileArgs',
     'ConnectionProfilePrivateConnectivityArgs',
-    'ConnectionProfileSqlServerProfileArgs',
     'PrivateConnectionErrorArgs',
     'PrivateConnectionVpcPeeringConfigArgs',
     'StreamBackfillAllArgs',
@@ -34,10 +33,6 @@ __all__ = [
     'StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArgs',
     'StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableArgs',
     'StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs',
-    'StreamBackfillAllSqlServerExcludedObjectsArgs',
-    'StreamBackfillAllSqlServerExcludedObjectsSchemaArgs',
-    'StreamBackfillAllSqlServerExcludedObjectsSchemaTableArgs',
-    'StreamBackfillAllSqlServerExcludedObjectsSchemaTableColumnArgs',
     'StreamBackfillNoneArgs',
     'StreamDestinationConfigArgs',
     'StreamDestinationConfigBigqueryDestinationConfigArgs',
@@ -77,15 +72,6 @@ __all__ = [
     'StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs',
     'StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs',
     'StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs',
-    'StreamSourceConfigSqlServerSourceConfigArgs',
-    'StreamSourceConfigSqlServerSourceConfigExcludeObjectsArgs',
-    'StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgs',
-    'StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgs',
-    'StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs',
-    'StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs',
-    'StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs',
-    'StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs',
-    'StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgs',
 ]
 
 @pulumi.input_type
@@ -644,91 +630,6 @@ class ConnectionProfilePrivateConnectivityArgs:
         pulumi.set(self, "private_connection", value)
 
 
-@pulumi.input_type
-class ConnectionProfileSqlServerProfileArgs:
-    def __init__(__self__, *,
-                 database: pulumi.Input[str],
-                 hostname: pulumi.Input[str],
-                 password: pulumi.Input[str],
-                 username: pulumi.Input[str],
-                 port: Optional[pulumi.Input[int]] = None):
-        """
-        :param pulumi.Input[str] database: Database for the SQL Server connection.
-        :param pulumi.Input[str] hostname: Hostname for the SQL Server connection.
-        :param pulumi.Input[str] password: Password for the SQL Server connection.
-               **Note**: This property is sensitive and will not be displayed in the plan.
-        :param pulumi.Input[str] username: Username for the SQL Server connection.
-        :param pulumi.Input[int] port: Port for the SQL Server connection.
-        """
-        pulumi.set(__self__, "database", database)
-        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)
-
-    @property
-    @pulumi.getter
-    def database(self) -> pulumi.Input[str]:
-        """
-        Database for the SQL Server connection.
-        """
-        return pulumi.get(self, "database")
-
-    @database.setter
-    def database(self, value: pulumi.Input[str]):
-        pulumi.set(self, "database", value)
-
-    @property
-    @pulumi.getter
-    def hostname(self) -> pulumi.Input[str]:
-        """
-        Hostname for the SQL Server 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 SQL Server connection.
-        **Note**: This property is sensitive and will not be displayed in the plan.
-        """
-        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 SQL Server 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 SQL Server connection.
-        """
-        return pulumi.get(self, "port")
-
-    @port.setter
-    def port(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "port", value)
-
-
 @pulumi.input_type
 class PrivateConnectionErrorArgs:
     def __init__(__self__, *,
@@ -816,8 +717,7 @@ class StreamBackfillAllArgs:
     def __init__(__self__, *,
                  mysql_excluded_objects: Optional[pulumi.Input['StreamBackfillAllMysqlExcludedObjectsArgs']] = None,
                  oracle_excluded_objects: Optional[pulumi.Input['StreamBackfillAllOracleExcludedObjectsArgs']] = None,
-                 postgresql_excluded_objects: Optional[pulumi.Input['StreamBackfillAllPostgresqlExcludedObjectsArgs']] = None,
-                 sql_server_excluded_objects: Optional[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsArgs']] = None):
+                 postgresql_excluded_objects: Optional[pulumi.Input['StreamBackfillAllPostgresqlExcludedObjectsArgs']] = None):
         """
         :param pulumi.Input['StreamBackfillAllMysqlExcludedObjectsArgs'] mysql_excluded_objects: MySQL data source objects to avoid backfilling.
                Structure is documented below.
@@ -825,8 +725,6 @@ class StreamBackfillAllArgs:
                Structure is documented below.
         :param pulumi.Input['StreamBackfillAllPostgresqlExcludedObjectsArgs'] postgresql_excluded_objects: PostgreSQL data source objects to avoid backfilling.
                Structure is documented below.
-        :param pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsArgs'] sql_server_excluded_objects: SQL Server data source objects to avoid backfilling.
-               Structure is documented below.
         """
         if mysql_excluded_objects is not None:
             pulumi.set(__self__, "mysql_excluded_objects", mysql_excluded_objects)
@@ -834,8 +732,6 @@ class StreamBackfillAllArgs:
             pulumi.set(__self__, "oracle_excluded_objects", oracle_excluded_objects)
         if postgresql_excluded_objects is not None:
             pulumi.set(__self__, "postgresql_excluded_objects", postgresql_excluded_objects)
-        if sql_server_excluded_objects is not None:
-            pulumi.set(__self__, "sql_server_excluded_objects", sql_server_excluded_objects)
 
     @property
     @pulumi.getter(name="mysqlExcludedObjects")
@@ -876,19 +772,6 @@ class StreamBackfillAllArgs:
     def postgresql_excluded_objects(self, value: Optional[pulumi.Input['StreamBackfillAllPostgresqlExcludedObjectsArgs']]):
         pulumi.set(self, "postgresql_excluded_objects", value)
 
-    @property
-    @pulumi.getter(name="sqlServerExcludedObjects")
-    def sql_server_excluded_objects(self) -> Optional[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsArgs']]:
-        """
-        SQL Server data source objects to avoid backfilling.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "sql_server_excluded_objects")
-
-    @sql_server_excluded_objects.setter
-    def sql_server_excluded_objects(self, value: Optional[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsArgs']]):
-        pulumi.set(self, "sql_server_excluded_objects", value)
-
 
 @pulumi.input_type
 class StreamBackfillAllMysqlExcludedObjectsArgs:
@@ -1636,1293 +1519,483 @@ class StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableP
 
 
 @pulumi.input_type
-class StreamBackfillAllSqlServerExcludedObjectsArgs:
+class StreamBackfillNoneArgs:
+    def __init__(__self__):
+        pass
+
+
+@pulumi.input_type
+class StreamDestinationConfigArgs:
     def __init__(__self__, *,
-                 schemas: pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsSchemaArgs']]]):
+                 destination_connection_profile: pulumi.Input[str],
+                 bigquery_destination_config: Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigArgs']] = None,
+                 gcs_destination_config: Optional[pulumi.Input['StreamDestinationConfigGcsDestinationConfigArgs']] = None):
         """
-        :param pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsSchemaArgs']]] schemas: SQL Server schemas/databases in the database server
+        :param pulumi.Input[str] destination_connection_profile: Destination connection profile resource. Format: projects/{project}/locations/{location}/connectionProfiles/{name}
+        :param pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigArgs'] bigquery_destination_config: A configuration for how data should be loaded to Cloud Storage.
+               Structure is documented below.
+        :param pulumi.Input['StreamDestinationConfigGcsDestinationConfigArgs'] gcs_destination_config: A configuration for how data should be loaded to Cloud Storage.
                Structure is documented below.
         """
-        pulumi.set(__self__, "schemas", schemas)
+        pulumi.set(__self__, "destination_connection_profile", destination_connection_profile)
+        if bigquery_destination_config is not None:
+            pulumi.set(__self__, "bigquery_destination_config", bigquery_destination_config)
+        if gcs_destination_config is not None:
+            pulumi.set(__self__, "gcs_destination_config", gcs_destination_config)
+
+    @property
+    @pulumi.getter(name="destinationConnectionProfile")
+    def destination_connection_profile(self) -> pulumi.Input[str]:
+        """
+        Destination connection profile resource. Format: projects/{project}/locations/{location}/connectionProfiles/{name}
+        """
+        return pulumi.get(self, "destination_connection_profile")
+
+    @destination_connection_profile.setter
+    def destination_connection_profile(self, value: pulumi.Input[str]):
+        pulumi.set(self, "destination_connection_profile", value)
+
+    @property
+    @pulumi.getter(name="bigqueryDestinationConfig")
+    def bigquery_destination_config(self) -> Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigArgs']]:
+        """
+        A configuration for how data should be loaded to Cloud Storage.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "bigquery_destination_config")
+
+    @bigquery_destination_config.setter
+    def bigquery_destination_config(self, value: Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigArgs']]):
+        pulumi.set(self, "bigquery_destination_config", value)
 
     @property
-    @pulumi.getter
-    def schemas(self) -> pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsSchemaArgs']]]:
+    @pulumi.getter(name="gcsDestinationConfig")
+    def gcs_destination_config(self) -> Optional[pulumi.Input['StreamDestinationConfigGcsDestinationConfigArgs']]:
         """
-        SQL Server schemas/databases in the database server
+        A configuration for how data should be loaded to Cloud Storage.
         Structure is documented below.
         """
-        return pulumi.get(self, "schemas")
+        return pulumi.get(self, "gcs_destination_config")
 
-    @schemas.setter
-    def schemas(self, value: pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsSchemaArgs']]]):
-        pulumi.set(self, "schemas", value)
+    @gcs_destination_config.setter
+    def gcs_destination_config(self, value: Optional[pulumi.Input['StreamDestinationConfigGcsDestinationConfigArgs']]):
+        pulumi.set(self, "gcs_destination_config", value)
 
 
 @pulumi.input_type
-class StreamBackfillAllSqlServerExcludedObjectsSchemaArgs:
+class StreamDestinationConfigBigqueryDestinationConfigArgs:
     def __init__(__self__, *,
-                 schema: pulumi.Input[str],
-                 tables: Optional[pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsSchemaTableArgs']]]] = None):
+                 data_freshness: Optional[pulumi.Input[str]] = None,
+                 single_target_dataset: Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs']] = None,
+                 source_hierarchy_datasets: Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs']] = None):
         """
-        :param pulumi.Input[str] schema: Schema name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsSchemaTableArgs']]] tables: Tables in the database.
+        :param pulumi.Input[str] data_freshness: The guaranteed data freshness (in seconds) when querying tables created by the stream.
+               Editing this field will only affect new tables created in the future, but existing tables
+               will not be impacted. Lower values mean that queries will return fresher data, but may result in higher cost.
+               A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s". Defaults to 900s.
+        :param pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs'] single_target_dataset: A single target dataset to which all data will be streamed.
+               Structure is documented below.
+        :param pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs'] source_hierarchy_datasets: Destination datasets are created so that hierarchy of the destination data objects matches the source hierarchy.
                Structure is documented below.
         """
-        pulumi.set(__self__, "schema", schema)
-        if tables is not None:
-            pulumi.set(__self__, "tables", tables)
+        if data_freshness is not None:
+            pulumi.set(__self__, "data_freshness", data_freshness)
+        if single_target_dataset is not None:
+            pulumi.set(__self__, "single_target_dataset", single_target_dataset)
+        if source_hierarchy_datasets is not None:
+            pulumi.set(__self__, "source_hierarchy_datasets", source_hierarchy_datasets)
 
     @property
-    @pulumi.getter
-    def schema(self) -> pulumi.Input[str]:
+    @pulumi.getter(name="dataFreshness")
+    def data_freshness(self) -> Optional[pulumi.Input[str]]:
         """
-        Schema name.
+        The guaranteed data freshness (in seconds) when querying tables created by the stream.
+        Editing this field will only affect new tables created in the future, but existing tables
+        will not be impacted. Lower values mean that queries will return fresher data, but may result in higher cost.
+        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s". Defaults to 900s.
         """
-        return pulumi.get(self, "schema")
+        return pulumi.get(self, "data_freshness")
 
-    @schema.setter
-    def schema(self, value: pulumi.Input[str]):
-        pulumi.set(self, "schema", value)
+    @data_freshness.setter
+    def data_freshness(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "data_freshness", value)
 
     @property
-    @pulumi.getter
-    def tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsSchemaTableArgs']]]]:
+    @pulumi.getter(name="singleTargetDataset")
+    def single_target_dataset(self) -> Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs']]:
         """
-        Tables in the database.
+        A single target dataset to which all data will be streamed.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "single_target_dataset")
+
+    @single_target_dataset.setter
+    def single_target_dataset(self, value: Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs']]):
+        pulumi.set(self, "single_target_dataset", value)
+
+    @property
+    @pulumi.getter(name="sourceHierarchyDatasets")
+    def source_hierarchy_datasets(self) -> Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs']]:
+        """
+        Destination datasets are created so that hierarchy of the destination data objects matches the source hierarchy.
         Structure is documented below.
         """
-        return pulumi.get(self, "tables")
+        return pulumi.get(self, "source_hierarchy_datasets")
 
-    @tables.setter
-    def tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsSchemaTableArgs']]]]):
-        pulumi.set(self, "tables", value)
+    @source_hierarchy_datasets.setter
+    def source_hierarchy_datasets(self, value: Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs']]):
+        pulumi.set(self, "source_hierarchy_datasets", value)
 
 
 @pulumi.input_type
-class StreamBackfillAllSqlServerExcludedObjectsSchemaTableArgs:
+class StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs:
     def __init__(__self__, *,
-                 table: pulumi.Input[str],
-                 columns: Optional[pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsSchemaTableColumnArgs']]]] = None):
+                 dataset_id: pulumi.Input[str]):
         """
-        :param pulumi.Input[str] table: Table name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsSchemaTableColumnArgs']]] columns: SQL Server columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
-               Structure is documented below.
+        :param pulumi.Input[str] dataset_id: Dataset ID in the format projects/{project}/datasets/{dataset_id} or
+               {project}:{dataset_id}
         """
-        pulumi.set(__self__, "table", table)
-        if columns is not None:
-            pulumi.set(__self__, "columns", columns)
+        pulumi.set(__self__, "dataset_id", dataset_id)
 
     @property
-    @pulumi.getter
-    def table(self) -> pulumi.Input[str]:
+    @pulumi.getter(name="datasetId")
+    def dataset_id(self) -> pulumi.Input[str]:
         """
-        Table name.
+        Dataset ID in the format projects/{project}/datasets/{dataset_id} or
+        {project}:{dataset_id}
         """
-        return pulumi.get(self, "table")
+        return pulumi.get(self, "dataset_id")
 
-    @table.setter
-    def table(self, value: pulumi.Input[str]):
-        pulumi.set(self, "table", value)
+    @dataset_id.setter
+    def dataset_id(self, value: pulumi.Input[str]):
+        pulumi.set(self, "dataset_id", value)
+
+
+@pulumi.input_type
+class StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs:
+    def __init__(__self__, *,
+                 dataset_template: pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs']):
+        """
+        :param pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs'] dataset_template: Dataset template used for dynamic dataset creation.
+               Structure is documented below.
+        """
+        pulumi.set(__self__, "dataset_template", dataset_template)
 
     @property
-    @pulumi.getter
-    def columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsSchemaTableColumnArgs']]]]:
+    @pulumi.getter(name="datasetTemplate")
+    def dataset_template(self) -> pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs']:
         """
-        SQL Server columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
+        Dataset template used for dynamic dataset creation.
         Structure is documented below.
         """
-        return pulumi.get(self, "columns")
+        return pulumi.get(self, "dataset_template")
 
-    @columns.setter
-    def columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsSchemaTableColumnArgs']]]]):
-        pulumi.set(self, "columns", value)
+    @dataset_template.setter
+    def dataset_template(self, value: pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs']):
+        pulumi.set(self, "dataset_template", value)
 
 
 @pulumi.input_type
-class StreamBackfillAllSqlServerExcludedObjectsSchemaTableColumnArgs:
+class StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs:
     def __init__(__self__, *,
-                 column: 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,
-                 precision: Optional[pulumi.Input[int]] = None,
-                 primary_key: Optional[pulumi.Input[bool]] = None,
-                 scale: Optional[pulumi.Input[int]] = None):
+                 location: pulumi.Input[str],
+                 dataset_id_prefix: Optional[pulumi.Input[str]] = None,
+                 kms_key_name: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] column: Column name.
-        :param pulumi.Input[str] data_type: The SQL Server data type. Full data types list can be found here:
-               https://learn.microsoft.com/en-us/sql/t-sql/data-types/data-types-transact-sql?view=sql-server-ver16
-        :param pulumi.Input[int] length: (Output)
-               Column length.
-        :param pulumi.Input[bool] nullable: (Output)
-               Whether or not the column can accept a null value.
-        :param pulumi.Input[int] ordinal_position: (Output)
-               The ordinal position of the column in the table.
-        :param pulumi.Input[int] precision: (Output)
-               Column precision.
-        :param pulumi.Input[bool] primary_key: (Output)
-               Whether or not the column represents a primary key.
-        :param pulumi.Input[int] scale: (Output)
-               Column scale.
+        :param pulumi.Input[str] location: The geographic location where the dataset should reside.
+               See https://cloud.google.com/bigquery/docs/locations for supported locations.
+        :param pulumi.Input[str] dataset_id_prefix: If supplied, every created dataset will have its name prefixed by the provided value.
+               The prefix and name will be separated by an underscore. i.e. _.
+        :param pulumi.Input[str] kms_key_name: Describes the Cloud KMS encryption key that will be used to protect destination BigQuery
+               table. The BigQuery Service Account associated with your project requires access to this
+               encryption key. i.e. projects/{project}/locations/{location}/keyRings/{key_ring}/cryptoKeys/{cryptoKey}.
+               See https://cloud.google.com/bigquery/docs/customer-managed-encryption for more information.
+               
+               - - -
         """
-        if column is not None:
-            pulumi.set(__self__, "column", column)
-        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 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)
+        pulumi.set(__self__, "location", location)
+        if dataset_id_prefix is not None:
+            pulumi.set(__self__, "dataset_id_prefix", dataset_id_prefix)
+        if kms_key_name is not None:
+            pulumi.set(__self__, "kms_key_name", kms_key_name)
 
     @property
     @pulumi.getter
-    def column(self) -> Optional[pulumi.Input[str]]:
+    def location(self) -> pulumi.Input[str]:
         """
-        Column name.
+        The geographic location where the dataset should reside.
+        See https://cloud.google.com/bigquery/docs/locations for supported locations.
         """
-        return pulumi.get(self, "column")
+        return pulumi.get(self, "location")
 
-    @column.setter
-    def column(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "column", value)
+    @location.setter
+    def location(self, value: pulumi.Input[str]):
+        pulumi.set(self, "location", value)
 
     @property
-    @pulumi.getter(name="dataType")
-    def data_type(self) -> Optional[pulumi.Input[str]]:
+    @pulumi.getter(name="datasetIdPrefix")
+    def dataset_id_prefix(self) -> Optional[pulumi.Input[str]]:
         """
-        The SQL Server data type. Full data types list can be found here:
-        https://learn.microsoft.com/en-us/sql/t-sql/data-types/data-types-transact-sql?view=sql-server-ver16
+        If supplied, every created dataset will have its name prefixed by the provided value.
+        The prefix and name will be separated by an underscore. i.e. _.
         """
-        return pulumi.get(self, "data_type")
+        return pulumi.get(self, "dataset_id_prefix")
 
-    @data_type.setter
-    def data_type(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "data_type", value)
+    @dataset_id_prefix.setter
+    def dataset_id_prefix(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "dataset_id_prefix", value)
 
     @property
-    @pulumi.getter
-    def length(self) -> Optional[pulumi.Input[int]]:
+    @pulumi.getter(name="kmsKeyName")
+    def kms_key_name(self) -> Optional[pulumi.Input[str]]:
         """
-        (Output)
-        Column length.
+        Describes the Cloud KMS encryption key that will be used to protect destination BigQuery
+        table. The BigQuery Service Account associated with your project requires access to this
+        encryption key. i.e. projects/{project}/locations/{location}/keyRings/{key_ring}/cryptoKeys/{cryptoKey}.
+        See https://cloud.google.com/bigquery/docs/customer-managed-encryption for more information.
+
+        - - -
         """
-        return pulumi.get(self, "length")
+        return pulumi.get(self, "kms_key_name")
 
-    @length.setter
-    def length(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "length", value)
+    @kms_key_name.setter
+    def kms_key_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "kms_key_name", value)
+
+
+@pulumi.input_type
+class StreamDestinationConfigGcsDestinationConfigArgs:
+    def __init__(__self__, *,
+                 avro_file_format: Optional[pulumi.Input['StreamDestinationConfigGcsDestinationConfigAvroFileFormatArgs']] = None,
+                 file_rotation_interval: Optional[pulumi.Input[str]] = None,
+                 file_rotation_mb: Optional[pulumi.Input[int]] = None,
+                 json_file_format: Optional[pulumi.Input['StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs']] = None,
+                 path: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input['StreamDestinationConfigGcsDestinationConfigAvroFileFormatArgs'] 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.
+               A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s". Defaults to 900s.
+        :param pulumi.Input[int] file_rotation_mb: The maximum file size to be saved in the bucket.
+        :param pulumi.Input['StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs'] json_file_format: JSON file format configuration.
+               Structure is documented below.
+        :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
-    def nullable(self) -> Optional[pulumi.Input[bool]]:
+    @pulumi.getter(name="avroFileFormat")
+    def avro_file_format(self) -> Optional[pulumi.Input['StreamDestinationConfigGcsDestinationConfigAvroFileFormatArgs']]:
         """
-        (Output)
-        Whether or not the column can accept a null value.
+        AVRO file format configuration.
         """
-        return pulumi.get(self, "nullable")
+        return pulumi.get(self, "avro_file_format")
 
-    @nullable.setter
-    def nullable(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "nullable", value)
+    @avro_file_format.setter
+    def avro_file_format(self, value: Optional[pulumi.Input['StreamDestinationConfigGcsDestinationConfigAvroFileFormatArgs']]):
+        pulumi.set(self, "avro_file_format", value)
 
     @property
-    @pulumi.getter(name="ordinalPosition")
-    def ordinal_position(self) -> Optional[pulumi.Input[int]]:
+    @pulumi.getter(name="fileRotationInterval")
+    def file_rotation_interval(self) -> Optional[pulumi.Input[str]]:
         """
-        (Output)
-        The ordinal position of the column in the table.
+        The maximum duration for which new events are added before a file is closed and a new file is created.
+        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s". Defaults to 900s.
         """
-        return pulumi.get(self, "ordinal_position")
+        return pulumi.get(self, "file_rotation_interval")
 
-    @ordinal_position.setter
-    def ordinal_position(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "ordinal_position", value)
+    @file_rotation_interval.setter
+    def file_rotation_interval(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "file_rotation_interval", value)
 
     @property
-    @pulumi.getter
-    def precision(self) -> Optional[pulumi.Input[int]]:
+    @pulumi.getter(name="fileRotationMb")
+    def file_rotation_mb(self) -> Optional[pulumi.Input[int]]:
         """
-        (Output)
-        Column precision.
+        The maximum file size to be saved in the bucket.
         """
-        return pulumi.get(self, "precision")
+        return pulumi.get(self, "file_rotation_mb")
 
-    @precision.setter
-    def precision(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "precision", value)
+    @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="primaryKey")
-    def primary_key(self) -> Optional[pulumi.Input[bool]]:
+    @pulumi.getter(name="jsonFileFormat")
+    def json_file_format(self) -> Optional[pulumi.Input['StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs']]:
         """
-        (Output)
-        Whether or not the column represents a primary key.
+        JSON file format configuration.
+        Structure is documented below.
         """
-        return pulumi.get(self, "primary_key")
+        return pulumi.get(self, "json_file_format")
 
-    @primary_key.setter
-    def primary_key(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "primary_key", value)
+    @json_file_format.setter
+    def json_file_format(self, value: Optional[pulumi.Input['StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs']]):
+        pulumi.set(self, "json_file_format", value)
 
     @property
     @pulumi.getter
-    def scale(self) -> Optional[pulumi.Input[int]]:
+    def path(self) -> Optional[pulumi.Input[str]]:
         """
-        (Output)
-        Column scale.
+        Path inside the Cloud Storage bucket to write data to.
         """
-        return pulumi.get(self, "scale")
+        return pulumi.get(self, "path")
 
-    @scale.setter
-    def scale(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "scale", value)
+    @path.setter
+    def path(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "path", value)
 
 
 @pulumi.input_type
-class StreamBackfillNoneArgs:
+class StreamDestinationConfigGcsDestinationConfigAvroFileFormatArgs:
     def __init__(__self__):
         pass
 
 
 @pulumi.input_type
-class StreamDestinationConfigArgs:
+class StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs:
     def __init__(__self__, *,
-                 destination_connection_profile: pulumi.Input[str],
-                 bigquery_destination_config: Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigArgs']] = None,
-                 gcs_destination_config: Optional[pulumi.Input['StreamDestinationConfigGcsDestinationConfigArgs']] = None):
+                 compression: Optional[pulumi.Input[str]] = None,
+                 schema_file_format: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] destination_connection_profile: Destination connection profile resource. Format: projects/{project}/locations/{location}/connectionProfiles/{name}
-        :param pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigArgs'] bigquery_destination_config: A configuration for how data should be loaded to Cloud Storage.
-               Structure is documented below.
-        :param pulumi.Input['StreamDestinationConfigGcsDestinationConfigArgs'] gcs_destination_config: A configuration for how data should be loaded to Cloud Storage.
-               Structure is documented below.
+        :param pulumi.Input[str] compression: Compression of the loaded JSON file.
+               Possible values are: `NO_COMPRESSION`, `GZIP`.
+        :param pulumi.Input[str] schema_file_format: The schema file format along JSON data files.
+               Possible values are: `NO_SCHEMA_FILE`, `AVRO_SCHEMA_FILE`.
         """
-        pulumi.set(__self__, "destination_connection_profile", destination_connection_profile)
-        if bigquery_destination_config is not None:
-            pulumi.set(__self__, "bigquery_destination_config", bigquery_destination_config)
-        if gcs_destination_config is not None:
-            pulumi.set(__self__, "gcs_destination_config", gcs_destination_config)
+        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(name="destinationConnectionProfile")
-    def destination_connection_profile(self) -> pulumi.Input[str]:
+    @pulumi.getter
+    def compression(self) -> Optional[pulumi.Input[str]]:
         """
-        Destination connection profile resource. Format: projects/{project}/locations/{location}/connectionProfiles/{name}
+        Compression of the loaded JSON file.
+        Possible values are: `NO_COMPRESSION`, `GZIP`.
         """
-        return pulumi.get(self, "destination_connection_profile")
+        return pulumi.get(self, "compression")
 
-    @destination_connection_profile.setter
-    def destination_connection_profile(self, value: pulumi.Input[str]):
-        pulumi.set(self, "destination_connection_profile", value)
+    @compression.setter
+    def compression(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "compression", value)
 
     @property
-    @pulumi.getter(name="bigqueryDestinationConfig")
-    def bigquery_destination_config(self) -> Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigArgs']]:
+    @pulumi.getter(name="schemaFileFormat")
+    def schema_file_format(self) -> Optional[pulumi.Input[str]]:
         """
-        A configuration for how data should be loaded to Cloud Storage.
-        Structure is documented below.
+        The schema file format along JSON data files.
+        Possible values are: `NO_SCHEMA_FILE`, `AVRO_SCHEMA_FILE`.
         """
-        return pulumi.get(self, "bigquery_destination_config")
-
-    @bigquery_destination_config.setter
-    def bigquery_destination_config(self, value: Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigArgs']]):
-        pulumi.set(self, "bigquery_destination_config", value)
+        return pulumi.get(self, "schema_file_format")
 
-    @property
-    @pulumi.getter(name="gcsDestinationConfig")
-    def gcs_destination_config(self) -> Optional[pulumi.Input['StreamDestinationConfigGcsDestinationConfigArgs']]:
-        """
-        A configuration for how data should be loaded to Cloud Storage.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "gcs_destination_config")
-
-    @gcs_destination_config.setter
-    def gcs_destination_config(self, value: Optional[pulumi.Input['StreamDestinationConfigGcsDestinationConfigArgs']]):
-        pulumi.set(self, "gcs_destination_config", value)
-
-
-@pulumi.input_type
-class StreamDestinationConfigBigqueryDestinationConfigArgs:
-    def __init__(__self__, *,
-                 data_freshness: Optional[pulumi.Input[str]] = None,
-                 single_target_dataset: Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs']] = None,
-                 source_hierarchy_datasets: Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs']] = None):
-        """
-        :param pulumi.Input[str] data_freshness: The guaranteed data freshness (in seconds) when querying tables created by the stream.
-               Editing this field will only affect new tables created in the future, but existing tables
-               will not be impacted. Lower values mean that queries will return fresher data, but may result in higher cost.
-               A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s". Defaults to 900s.
-        :param pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs'] single_target_dataset: A single target dataset to which all data will be streamed.
-               Structure is documented below.
-        :param pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs'] source_hierarchy_datasets: Destination datasets are created so that hierarchy of the destination data objects matches the source hierarchy.
-               Structure is documented below.
-        """
-        if data_freshness is not None:
-            pulumi.set(__self__, "data_freshness", data_freshness)
-        if single_target_dataset is not None:
-            pulumi.set(__self__, "single_target_dataset", single_target_dataset)
-        if source_hierarchy_datasets is not None:
-            pulumi.set(__self__, "source_hierarchy_datasets", source_hierarchy_datasets)
-
-    @property
-    @pulumi.getter(name="dataFreshness")
-    def data_freshness(self) -> Optional[pulumi.Input[str]]:
-        """
-        The guaranteed data freshness (in seconds) when querying tables created by the stream.
-        Editing this field will only affect new tables created in the future, but existing tables
-        will not be impacted. Lower values mean that queries will return fresher data, but may result in higher cost.
-        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s". Defaults to 900s.
-        """
-        return pulumi.get(self, "data_freshness")
-
-    @data_freshness.setter
-    def data_freshness(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "data_freshness", value)
-
-    @property
-    @pulumi.getter(name="singleTargetDataset")
-    def single_target_dataset(self) -> Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs']]:
-        """
-        A single target dataset to which all data will be streamed.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "single_target_dataset")
-
-    @single_target_dataset.setter
-    def single_target_dataset(self, value: Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs']]):
-        pulumi.set(self, "single_target_dataset", value)
-
-    @property
-    @pulumi.getter(name="sourceHierarchyDatasets")
-    def source_hierarchy_datasets(self) -> Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs']]:
-        """
-        Destination datasets are created so that hierarchy of the destination data objects matches the source hierarchy.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "source_hierarchy_datasets")
-
-    @source_hierarchy_datasets.setter
-    def source_hierarchy_datasets(self, value: Optional[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs']]):
-        pulumi.set(self, "source_hierarchy_datasets", value)
-
-
-@pulumi.input_type
-class StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs:
-    def __init__(__self__, *,
-                 dataset_id: pulumi.Input[str]):
-        """
-        :param pulumi.Input[str] dataset_id: Dataset ID in the format projects/{project}/datasets/{dataset_id} or
-               {project}:{dataset_id}
-        """
-        pulumi.set(__self__, "dataset_id", dataset_id)
-
-    @property
-    @pulumi.getter(name="datasetId")
-    def dataset_id(self) -> pulumi.Input[str]:
-        """
-        Dataset ID in the format projects/{project}/datasets/{dataset_id} or
-        {project}:{dataset_id}
-        """
-        return pulumi.get(self, "dataset_id")
-
-    @dataset_id.setter
-    def dataset_id(self, value: pulumi.Input[str]):
-        pulumi.set(self, "dataset_id", value)
-
-
-@pulumi.input_type
-class StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs:
-    def __init__(__self__, *,
-                 dataset_template: pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs']):
-        """
-        :param pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs'] dataset_template: Dataset template used for dynamic dataset creation.
-               Structure is documented below.
-        """
-        pulumi.set(__self__, "dataset_template", dataset_template)
-
-    @property
-    @pulumi.getter(name="datasetTemplate")
-    def dataset_template(self) -> pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs']:
-        """
-        Dataset template used for dynamic dataset creation.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "dataset_template")
-
-    @dataset_template.setter
-    def dataset_template(self, value: pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs']):
-        pulumi.set(self, "dataset_template", value)
-
-
-@pulumi.input_type
-class StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs:
-    def __init__(__self__, *,
-                 location: pulumi.Input[str],
-                 dataset_id_prefix: Optional[pulumi.Input[str]] = None,
-                 kms_key_name: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input[str] location: The geographic location where the dataset should reside.
-               See https://cloud.google.com/bigquery/docs/locations for supported locations.
-        :param pulumi.Input[str] dataset_id_prefix: If supplied, every created dataset will have its name prefixed by the provided value.
-               The prefix and name will be separated by an underscore. i.e. _.
-        :param pulumi.Input[str] kms_key_name: Describes the Cloud KMS encryption key that will be used to protect destination BigQuery
-               table. The BigQuery Service Account associated with your project requires access to this
-               encryption key. i.e. projects/{project}/locations/{location}/keyRings/{key_ring}/cryptoKeys/{cryptoKey}.
-               See https://cloud.google.com/bigquery/docs/customer-managed-encryption for more information.
-               
-               - - -
-        """
-        pulumi.set(__self__, "location", location)
-        if dataset_id_prefix is not None:
-            pulumi.set(__self__, "dataset_id_prefix", dataset_id_prefix)
-        if kms_key_name is not None:
-            pulumi.set(__self__, "kms_key_name", kms_key_name)
-
-    @property
-    @pulumi.getter
-    def location(self) -> pulumi.Input[str]:
-        """
-        The geographic location where the dataset should reside.
-        See https://cloud.google.com/bigquery/docs/locations for supported locations.
-        """
-        return pulumi.get(self, "location")
-
-    @location.setter
-    def location(self, value: pulumi.Input[str]):
-        pulumi.set(self, "location", value)
-
-    @property
-    @pulumi.getter(name="datasetIdPrefix")
-    def dataset_id_prefix(self) -> Optional[pulumi.Input[str]]:
-        """
-        If supplied, every created dataset will have its name prefixed by the provided value.
-        The prefix and name will be separated by an underscore. i.e. _.
-        """
-        return pulumi.get(self, "dataset_id_prefix")
-
-    @dataset_id_prefix.setter
-    def dataset_id_prefix(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "dataset_id_prefix", value)
-
-    @property
-    @pulumi.getter(name="kmsKeyName")
-    def kms_key_name(self) -> Optional[pulumi.Input[str]]:
-        """
-        Describes the Cloud KMS encryption key that will be used to protect destination BigQuery
-        table. The BigQuery Service Account associated with your project requires access to this
-        encryption key. i.e. projects/{project}/locations/{location}/keyRings/{key_ring}/cryptoKeys/{cryptoKey}.
-        See https://cloud.google.com/bigquery/docs/customer-managed-encryption for more information.
-
-        - - -
-        """
-        return pulumi.get(self, "kms_key_name")
-
-    @kms_key_name.setter
-    def kms_key_name(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "kms_key_name", value)
-
-
-@pulumi.input_type
-class StreamDestinationConfigGcsDestinationConfigArgs:
-    def __init__(__self__, *,
-                 avro_file_format: Optional[pulumi.Input['StreamDestinationConfigGcsDestinationConfigAvroFileFormatArgs']] = None,
-                 file_rotation_interval: Optional[pulumi.Input[str]] = None,
-                 file_rotation_mb: Optional[pulumi.Input[int]] = None,
-                 json_file_format: Optional[pulumi.Input['StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs']] = None,
-                 path: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input['StreamDestinationConfigGcsDestinationConfigAvroFileFormatArgs'] 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.
-               A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s". Defaults to 900s.
-        :param pulumi.Input[int] file_rotation_mb: The maximum file size to be saved in the bucket.
-        :param pulumi.Input['StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs'] json_file_format: JSON file format configuration.
-               Structure is documented below.
-        :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['StreamDestinationConfigGcsDestinationConfigAvroFileFormatArgs']]:
-        """
-        AVRO file format configuration.
-        """
-        return pulumi.get(self, "avro_file_format")
-
-    @avro_file_format.setter
-    def avro_file_format(self, value: Optional[pulumi.Input['StreamDestinationConfigGcsDestinationConfigAvroFileFormatArgs']]):
-        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.
-        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s". Defaults to 900s.
-        """
-        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['StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs']]:
-        """
-        JSON file format configuration.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "json_file_format")
-
-    @json_file_format.setter
-    def json_file_format(self, value: Optional[pulumi.Input['StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs']]):
-        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 StreamDestinationConfigGcsDestinationConfigAvroFileFormatArgs:
-    def __init__(__self__):
-        pass
-
-
-@pulumi.input_type
-class StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs:
-    def __init__(__self__, *,
-                 compression: Optional[pulumi.Input[str]] = None,
-                 schema_file_format: Optional[pulumi.Input[str]] = None):
-        """
-        :param pulumi.Input[str] compression: Compression of the loaded JSON file.
-               Possible values are: `NO_COMPRESSION`, `GZIP`.
-        :param pulumi.Input[str] schema_file_format: The schema file format along JSON data files.
-               Possible values are: `NO_SCHEMA_FILE`, `AVRO_SCHEMA_FILE`.
-        """
-        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[str]]:
-        """
-        Compression of the loaded JSON file.
-        Possible values are: `NO_COMPRESSION`, `GZIP`.
-        """
-        return pulumi.get(self, "compression")
-
-    @compression.setter
-    def compression(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "compression", value)
-
-    @property
-    @pulumi.getter(name="schemaFileFormat")
-    def schema_file_format(self) -> Optional[pulumi.Input[str]]:
-        """
-        The schema file format along JSON data files.
-        Possible values are: `NO_SCHEMA_FILE`, `AVRO_SCHEMA_FILE`.
-        """
-        return pulumi.get(self, "schema_file_format")
-
-    @schema_file_format.setter
-    def schema_file_format(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "schema_file_format", value)
-
-
-@pulumi.input_type
-class StreamSourceConfigArgs:
-    def __init__(__self__, *,
-                 source_connection_profile: pulumi.Input[str],
-                 mysql_source_config: Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigArgs']] = None,
-                 oracle_source_config: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigArgs']] = None,
-                 postgresql_source_config: Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigArgs']] = None,
-                 sql_server_source_config: Optional[pulumi.Input['StreamSourceConfigSqlServerSourceConfigArgs']] = None):
-        """
-        :param pulumi.Input[str] source_connection_profile: Source connection profile resource. Format: projects/{project}/locations/{location}/connectionProfiles/{name}
-        :param pulumi.Input['StreamSourceConfigMysqlSourceConfigArgs'] mysql_source_config: MySQL data source configuration.
-               Structure is documented below.
-        :param pulumi.Input['StreamSourceConfigOracleSourceConfigArgs'] oracle_source_config: MySQL data source configuration.
-               Structure is documented below.
-        :param pulumi.Input['StreamSourceConfigPostgresqlSourceConfigArgs'] postgresql_source_config: PostgreSQL data source configuration.
-               Structure is documented below.
-        :param pulumi.Input['StreamSourceConfigSqlServerSourceConfigArgs'] sql_server_source_config: SQL Server data source configuration.
-               Structure is documented below.
-        """
-        pulumi.set(__self__, "source_connection_profile", source_connection_profile)
-        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)
-        if postgresql_source_config is not None:
-            pulumi.set(__self__, "postgresql_source_config", postgresql_source_config)
-        if sql_server_source_config is not None:
-            pulumi.set(__self__, "sql_server_source_config", sql_server_source_config)
-
-    @property
-    @pulumi.getter(name="sourceConnectionProfile")
-    def source_connection_profile(self) -> pulumi.Input[str]:
-        """
-        Source connection profile resource. Format: projects/{project}/locations/{location}/connectionProfiles/{name}
-        """
-        return pulumi.get(self, "source_connection_profile")
-
-    @source_connection_profile.setter
-    def source_connection_profile(self, value: pulumi.Input[str]):
-        pulumi.set(self, "source_connection_profile", value)
-
-    @property
-    @pulumi.getter(name="mysqlSourceConfig")
-    def mysql_source_config(self) -> Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigArgs']]:
-        """
-        MySQL data source configuration.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "mysql_source_config")
-
-    @mysql_source_config.setter
-    def mysql_source_config(self, value: Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigArgs']]):
-        pulumi.set(self, "mysql_source_config", value)
-
-    @property
-    @pulumi.getter(name="oracleSourceConfig")
-    def oracle_source_config(self) -> Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigArgs']]:
-        """
-        MySQL data source configuration.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "oracle_source_config")
-
-    @oracle_source_config.setter
-    def oracle_source_config(self, value: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigArgs']]):
-        pulumi.set(self, "oracle_source_config", value)
-
-    @property
-    @pulumi.getter(name="postgresqlSourceConfig")
-    def postgresql_source_config(self) -> Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigArgs']]:
-        """
-        PostgreSQL data source configuration.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "postgresql_source_config")
-
-    @postgresql_source_config.setter
-    def postgresql_source_config(self, value: Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigArgs']]):
-        pulumi.set(self, "postgresql_source_config", value)
-
-    @property
-    @pulumi.getter(name="sqlServerSourceConfig")
-    def sql_server_source_config(self) -> Optional[pulumi.Input['StreamSourceConfigSqlServerSourceConfigArgs']]:
-        """
-        SQL Server data source configuration.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "sql_server_source_config")
-
-    @sql_server_source_config.setter
-    def sql_server_source_config(self, value: Optional[pulumi.Input['StreamSourceConfigSqlServerSourceConfigArgs']]):
-        pulumi.set(self, "sql_server_source_config", value)
-
-
-@pulumi.input_type
-class StreamSourceConfigMysqlSourceConfigArgs:
-    def __init__(__self__, *,
-                 exclude_objects: Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs']] = None,
-                 include_objects: Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs']] = None,
-                 max_concurrent_backfill_tasks: Optional[pulumi.Input[int]] = None,
-                 max_concurrent_cdc_tasks: Optional[pulumi.Input[int]] = None):
-        """
-        :param pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs'] exclude_objects: MySQL objects to exclude from the stream.
-               Structure is documented below.
-        :param pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs'] include_objects: MySQL objects to retrieve from the source.
-               Structure is documented below.
-        :param pulumi.Input[int] max_concurrent_backfill_tasks: Maximum number of concurrent backfill tasks. The number should be non negative.
-               If not set (or set to 0), the system's default value will be used.
-        :param pulumi.Input[int] max_concurrent_cdc_tasks: Maximum number of concurrent CDC tasks. The number should be non negative.
-               If not set (or set to 0), the system's default value will be used.
-        """
-        if exclude_objects is not None:
-            pulumi.set(__self__, "exclude_objects", exclude_objects)
-        if include_objects is not None:
-            pulumi.set(__self__, "include_objects", include_objects)
-        if max_concurrent_backfill_tasks is not None:
-            pulumi.set(__self__, "max_concurrent_backfill_tasks", max_concurrent_backfill_tasks)
-        if max_concurrent_cdc_tasks is not None:
-            pulumi.set(__self__, "max_concurrent_cdc_tasks", max_concurrent_cdc_tasks)
-
-    @property
-    @pulumi.getter(name="excludeObjects")
-    def exclude_objects(self) -> Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs']]:
-        """
-        MySQL objects to exclude from the stream.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "exclude_objects")
-
-    @exclude_objects.setter
-    def exclude_objects(self, value: Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs']]):
-        pulumi.set(self, "exclude_objects", value)
-
-    @property
-    @pulumi.getter(name="includeObjects")
-    def include_objects(self) -> Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs']]:
-        """
-        MySQL objects to retrieve from the source.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "include_objects")
-
-    @include_objects.setter
-    def include_objects(self, value: Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs']]):
-        pulumi.set(self, "include_objects", value)
-
-    @property
-    @pulumi.getter(name="maxConcurrentBackfillTasks")
-    def max_concurrent_backfill_tasks(self) -> Optional[pulumi.Input[int]]:
-        """
-        Maximum number of concurrent backfill tasks. The number should be non negative.
-        If not set (or set to 0), the system's default value will be used.
-        """
-        return pulumi.get(self, "max_concurrent_backfill_tasks")
-
-    @max_concurrent_backfill_tasks.setter
-    def max_concurrent_backfill_tasks(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "max_concurrent_backfill_tasks", value)
-
-    @property
-    @pulumi.getter(name="maxConcurrentCdcTasks")
-    def max_concurrent_cdc_tasks(self) -> Optional[pulumi.Input[int]]:
-        """
-        Maximum number of concurrent CDC tasks. The number should be non negative.
-        If not set (or set to 0), the system's default value will be used.
-        """
-        return pulumi.get(self, "max_concurrent_cdc_tasks")
-
-    @max_concurrent_cdc_tasks.setter
-    def max_concurrent_cdc_tasks(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "max_concurrent_cdc_tasks", value)
-
-
-@pulumi.input_type
-class StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs:
-    def __init__(__self__, *,
-                 mysql_databases: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs']]]):
-        """
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs']]] mysql_databases: MySQL databases on the server
-               Structure is documented below.
-        """
-        pulumi.set(__self__, "mysql_databases", mysql_databases)
-
-    @property
-    @pulumi.getter(name="mysqlDatabases")
-    def mysql_databases(self) -> pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs']]]:
-        """
-        MySQL databases on the server
-        Structure is documented below.
-        """
-        return pulumi.get(self, "mysql_databases")
-
-    @mysql_databases.setter
-    def mysql_databases(self, value: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs']]]):
-        pulumi.set(self, "mysql_databases", value)
-
-
-@pulumi.input_type
-class StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs:
-    def __init__(__self__, *,
-                 database: pulumi.Input[str],
-                 mysql_tables: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs']]]] = None):
-        """
-        :param pulumi.Input[str] database: Database name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs']]] mysql_tables: Tables in the database.
-               Structure is documented below.
-        """
-        pulumi.set(__self__, "database", database)
-        if mysql_tables is not None:
-            pulumi.set(__self__, "mysql_tables", mysql_tables)
-
-    @property
-    @pulumi.getter
-    def database(self) -> pulumi.Input[str]:
-        """
-        Database name.
-        """
-        return pulumi.get(self, "database")
-
-    @database.setter
-    def database(self, value: pulumi.Input[str]):
-        pulumi.set(self, "database", value)
-
-    @property
-    @pulumi.getter(name="mysqlTables")
-    def mysql_tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs']]]]:
-        """
-        Tables in the database.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "mysql_tables")
-
-    @mysql_tables.setter
-    def mysql_tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs']]]]):
-        pulumi.set(self, "mysql_tables", value)
-
-
-@pulumi.input_type
-class StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs:
-    def __init__(__self__, *,
-                 table: pulumi.Input[str],
-                 mysql_columns: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs']]]] = None):
-        """
-        :param pulumi.Input[str] table: Table name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs']]] mysql_columns: MySQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
-               Structure is documented below.
-        """
-        pulumi.set(__self__, "table", table)
-        if mysql_columns is not None:
-            pulumi.set(__self__, "mysql_columns", mysql_columns)
-
-    @property
-    @pulumi.getter
-    def table(self) -> pulumi.Input[str]:
-        """
-        Table name.
-        """
-        return pulumi.get(self, "table")
-
-    @table.setter
-    def table(self, value: pulumi.Input[str]):
-        pulumi.set(self, "table", value)
-
-    @property
-    @pulumi.getter(name="mysqlColumns")
-    def mysql_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs']]]]:
-        """
-        MySQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "mysql_columns")
-
-    @mysql_columns.setter
-    def mysql_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs']]]]):
-        pulumi.set(self, "mysql_columns", value)
-
-
-@pulumi.input_type
-class StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs:
-    def __init__(__self__, *,
-                 collation: Optional[pulumi.Input[str]] = None,
-                 column: 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):
-        """
-        :param pulumi.Input[str] collation: Column collation.
-        :param pulumi.Input[str] column: 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: (Output)
-               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 is not None:
-            pulumi.set(__self__, "column", column)
-        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
-    def column(self) -> Optional[pulumi.Input[str]]:
-        """
-        Column name.
-        """
-        return pulumi.get(self, "column")
-
-    @column.setter
-    def column(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "column", 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]]:
-        """
-        (Output)
-        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)
+    @schema_file_format.setter
+    def schema_file_format(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "schema_file_format", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs:
+class StreamSourceConfigArgs:
     def __init__(__self__, *,
-                 mysql_databases: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs']]]):
+                 source_connection_profile: pulumi.Input[str],
+                 mysql_source_config: Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigArgs']] = None,
+                 oracle_source_config: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigArgs']] = None,
+                 postgresql_source_config: Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigArgs']] = None):
         """
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs']]] mysql_databases: MySQL databases on the server
+        :param pulumi.Input[str] source_connection_profile: Source connection profile resource. Format: projects/{project}/locations/{location}/connectionProfiles/{name}
+        :param pulumi.Input['StreamSourceConfigMysqlSourceConfigArgs'] mysql_source_config: MySQL data source configuration.
                Structure is documented below.
-        """
-        pulumi.set(__self__, "mysql_databases", mysql_databases)
-
-    @property
-    @pulumi.getter(name="mysqlDatabases")
-    def mysql_databases(self) -> pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs']]]:
-        """
-        MySQL databases on the server
-        Structure is documented below.
-        """
-        return pulumi.get(self, "mysql_databases")
-
-    @mysql_databases.setter
-    def mysql_databases(self, value: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs']]]):
-        pulumi.set(self, "mysql_databases", value)
-
-
-@pulumi.input_type
-class StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs:
-    def __init__(__self__, *,
-                 database: pulumi.Input[str],
-                 mysql_tables: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs']]]] = None):
-        """
-        :param pulumi.Input[str] database: Database name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs']]] mysql_tables: Tables in the database.
+        :param pulumi.Input['StreamSourceConfigOracleSourceConfigArgs'] oracle_source_config: MySQL data source configuration.
                Structure is documented below.
-        """
-        pulumi.set(__self__, "database", database)
-        if mysql_tables is not None:
-            pulumi.set(__self__, "mysql_tables", mysql_tables)
-
-    @property
-    @pulumi.getter
-    def database(self) -> pulumi.Input[str]:
-        """
-        Database name.
-        """
-        return pulumi.get(self, "database")
-
-    @database.setter
-    def database(self, value: pulumi.Input[str]):
-        pulumi.set(self, "database", value)
-
-    @property
-    @pulumi.getter(name="mysqlTables")
-    def mysql_tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs']]]]:
-        """
-        Tables in the database.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "mysql_tables")
-
-    @mysql_tables.setter
-    def mysql_tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs']]]]):
-        pulumi.set(self, "mysql_tables", value)
-
-
-@pulumi.input_type
-class StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs:
-    def __init__(__self__, *,
-                 table: pulumi.Input[str],
-                 mysql_columns: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs']]]] = None):
-        """
-        :param pulumi.Input[str] table: Table name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs']]] mysql_columns: MySQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
+        :param pulumi.Input['StreamSourceConfigPostgresqlSourceConfigArgs'] postgresql_source_config: PostgreSQL data source configuration.
                Structure is documented below.
         """
-        pulumi.set(__self__, "table", table)
-        if mysql_columns is not None:
-            pulumi.set(__self__, "mysql_columns", mysql_columns)
-
-    @property
-    @pulumi.getter
-    def table(self) -> pulumi.Input[str]:
-        """
-        Table name.
-        """
-        return pulumi.get(self, "table")
-
-    @table.setter
-    def table(self, value: pulumi.Input[str]):
-        pulumi.set(self, "table", value)
-
-    @property
-    @pulumi.getter(name="mysqlColumns")
-    def mysql_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs']]]]:
-        """
-        MySQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "mysql_columns")
-
-    @mysql_columns.setter
-    def mysql_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs']]]]):
-        pulumi.set(self, "mysql_columns", value)
-
-
-@pulumi.input_type
-class StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs:
-    def __init__(__self__, *,
-                 collation: Optional[pulumi.Input[str]] = None,
-                 column: 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):
-        """
-        :param pulumi.Input[str] collation: Column collation.
-        :param pulumi.Input[str] column: 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: (Output)
-               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 is not None:
-            pulumi.set(__self__, "column", column)
-        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
-    def column(self) -> Optional[pulumi.Input[str]]:
-        """
-        Column name.
-        """
-        return pulumi.get(self, "column")
-
-    @column.setter
-    def column(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "column", 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)
+        pulumi.set(__self__, "source_connection_profile", source_connection_profile)
+        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)
+        if postgresql_source_config is not None:
+            pulumi.set(__self__, "postgresql_source_config", postgresql_source_config)
 
     @property
-    @pulumi.getter
-    def length(self) -> Optional[pulumi.Input[int]]:
+    @pulumi.getter(name="sourceConnectionProfile")
+    def source_connection_profile(self) -> pulumi.Input[str]:
         """
-        (Output)
-        Column length.
+        Source connection profile resource. Format: projects/{project}/locations/{location}/connectionProfiles/{name}
         """
-        return pulumi.get(self, "length")
+        return pulumi.get(self, "source_connection_profile")
 
-    @length.setter
-    def length(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "length", value)
+    @source_connection_profile.setter
+    def source_connection_profile(self, value: pulumi.Input[str]):
+        pulumi.set(self, "source_connection_profile", value)
 
     @property
-    @pulumi.getter
-    def nullable(self) -> Optional[pulumi.Input[bool]]:
+    @pulumi.getter(name="mysqlSourceConfig")
+    def mysql_source_config(self) -> Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigArgs']]:
         """
-        Whether or not the column can accept a null value.
+        MySQL data source configuration.
+        Structure is documented below.
         """
-        return pulumi.get(self, "nullable")
+        return pulumi.get(self, "mysql_source_config")
 
-    @nullable.setter
-    def nullable(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "nullable", value)
+    @mysql_source_config.setter
+    def mysql_source_config(self, value: Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigArgs']]):
+        pulumi.set(self, "mysql_source_config", value)
 
     @property
-    @pulumi.getter(name="ordinalPosition")
-    def ordinal_position(self) -> Optional[pulumi.Input[int]]:
+    @pulumi.getter(name="oracleSourceConfig")
+    def oracle_source_config(self) -> Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigArgs']]:
         """
-        The ordinal position of the column in the table.
+        MySQL data source configuration.
+        Structure is documented below.
         """
-        return pulumi.get(self, "ordinal_position")
+        return pulumi.get(self, "oracle_source_config")
 
-    @ordinal_position.setter
-    def ordinal_position(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "ordinal_position", value)
+    @oracle_source_config.setter
+    def oracle_source_config(self, value: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigArgs']]):
+        pulumi.set(self, "oracle_source_config", value)
 
     @property
-    @pulumi.getter(name="primaryKey")
-    def primary_key(self) -> Optional[pulumi.Input[bool]]:
+    @pulumi.getter(name="postgresqlSourceConfig")
+    def postgresql_source_config(self) -> Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigArgs']]:
         """
-        Whether or not the column represents a primary key.
+        PostgreSQL data source configuration.
+        Structure is documented below.
         """
-        return pulumi.get(self, "primary_key")
+        return pulumi.get(self, "postgresql_source_config")
 
-    @primary_key.setter
-    def primary_key(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "primary_key", value)
+    @postgresql_source_config.setter
+    def postgresql_source_config(self, value: Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigArgs']]):
+        pulumi.set(self, "postgresql_source_config", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigOracleSourceConfigArgs:
+class StreamSourceConfigMysqlSourceConfigArgs:
     def __init__(__self__, *,
-                 drop_large_objects: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigDropLargeObjectsArgs']] = None,
-                 exclude_objects: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsArgs']] = None,
-                 include_objects: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsArgs']] = None,
+                 exclude_objects: Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs']] = None,
+                 include_objects: Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs']] = None,
                  max_concurrent_backfill_tasks: Optional[pulumi.Input[int]] = None,
-                 max_concurrent_cdc_tasks: Optional[pulumi.Input[int]] = None,
-                 stream_large_objects: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigStreamLargeObjectsArgs']] = None):
+                 max_concurrent_cdc_tasks: Optional[pulumi.Input[int]] = None):
         """
-        :param pulumi.Input['StreamSourceConfigOracleSourceConfigDropLargeObjectsArgs'] drop_large_objects: Configuration to drop large object values.
-        :param pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsArgs'] exclude_objects: Oracle objects to exclude from the stream.
+        :param pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs'] exclude_objects: MySQL objects to exclude from the stream.
                Structure is documented below.
-        :param pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsArgs'] include_objects: Oracle objects to retrieve from the source.
+        :param pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs'] include_objects: MySQL objects to retrieve from the source.
                Structure is documented below.
         :param pulumi.Input[int] max_concurrent_backfill_tasks: Maximum number of concurrent backfill tasks. The number should be non negative.
                If not set (or set to 0), the system's default value will be used.
         :param pulumi.Input[int] max_concurrent_cdc_tasks: Maximum number of concurrent CDC tasks. The number should be non negative.
                If not set (or set to 0), the system's default value will be used.
-        :param pulumi.Input['StreamSourceConfigOracleSourceConfigStreamLargeObjectsArgs'] stream_large_objects: Configuration to drop large object values.
         """
-        if drop_large_objects is not None:
-            pulumi.set(__self__, "drop_large_objects", drop_large_objects)
         if exclude_objects is not None:
             pulumi.set(__self__, "exclude_objects", exclude_objects)
         if include_objects is not None:
@@ -2931,45 +2004,31 @@ class StreamSourceConfigOracleSourceConfigArgs:
             pulumi.set(__self__, "max_concurrent_backfill_tasks", max_concurrent_backfill_tasks)
         if max_concurrent_cdc_tasks is not None:
             pulumi.set(__self__, "max_concurrent_cdc_tasks", max_concurrent_cdc_tasks)
-        if stream_large_objects is not None:
-            pulumi.set(__self__, "stream_large_objects", stream_large_objects)
-
-    @property
-    @pulumi.getter(name="dropLargeObjects")
-    def drop_large_objects(self) -> Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigDropLargeObjectsArgs']]:
-        """
-        Configuration to drop large object values.
-        """
-        return pulumi.get(self, "drop_large_objects")
-
-    @drop_large_objects.setter
-    def drop_large_objects(self, value: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigDropLargeObjectsArgs']]):
-        pulumi.set(self, "drop_large_objects", value)
 
     @property
     @pulumi.getter(name="excludeObjects")
-    def exclude_objects(self) -> Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsArgs']]:
+    def exclude_objects(self) -> Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs']]:
         """
-        Oracle objects to exclude from the stream.
+        MySQL objects to exclude from the stream.
         Structure is documented below.
         """
         return pulumi.get(self, "exclude_objects")
 
     @exclude_objects.setter
-    def exclude_objects(self, value: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsArgs']]):
+    def exclude_objects(self, value: Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs']]):
         pulumi.set(self, "exclude_objects", value)
 
     @property
     @pulumi.getter(name="includeObjects")
-    def include_objects(self) -> Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsArgs']]:
+    def include_objects(self) -> Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs']]:
         """
-        Oracle objects to retrieve from the source.
+        MySQL objects to retrieve from the source.
         Structure is documented below.
         """
         return pulumi.get(self, "include_objects")
 
     @include_objects.setter
-    def include_objects(self, value: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsArgs']]):
+    def include_objects(self, value: Optional[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs']]):
         pulumi.set(self, "include_objects", value)
 
     @property
@@ -2998,102 +2057,84 @@ class StreamSourceConfigOracleSourceConfigArgs:
     def max_concurrent_cdc_tasks(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "max_concurrent_cdc_tasks", value)
 
-    @property
-    @pulumi.getter(name="streamLargeObjects")
-    def stream_large_objects(self) -> Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigStreamLargeObjectsArgs']]:
-        """
-        Configuration to drop large object values.
-        """
-        return pulumi.get(self, "stream_large_objects")
-
-    @stream_large_objects.setter
-    def stream_large_objects(self, value: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigStreamLargeObjectsArgs']]):
-        pulumi.set(self, "stream_large_objects", value)
-
-
-@pulumi.input_type
-class StreamSourceConfigOracleSourceConfigDropLargeObjectsArgs:
-    def __init__(__self__):
-        pass
-
 
 @pulumi.input_type
-class StreamSourceConfigOracleSourceConfigExcludeObjectsArgs:
+class StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs:
     def __init__(__self__, *,
-                 oracle_schemas: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs']]]):
+                 mysql_databases: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs']]]):
         """
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs']]] oracle_schemas: Oracle schemas/databases in the database server
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs']]] mysql_databases: MySQL databases on the server
                Structure is documented below.
         """
-        pulumi.set(__self__, "oracle_schemas", oracle_schemas)
+        pulumi.set(__self__, "mysql_databases", mysql_databases)
 
     @property
-    @pulumi.getter(name="oracleSchemas")
-    def oracle_schemas(self) -> pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs']]]:
+    @pulumi.getter(name="mysqlDatabases")
+    def mysql_databases(self) -> pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs']]]:
         """
-        Oracle schemas/databases in the database server
+        MySQL databases on the server
         Structure is documented below.
         """
-        return pulumi.get(self, "oracle_schemas")
+        return pulumi.get(self, "mysql_databases")
 
-    @oracle_schemas.setter
-    def oracle_schemas(self, value: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs']]]):
-        pulumi.set(self, "oracle_schemas", value)
+    @mysql_databases.setter
+    def mysql_databases(self, value: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs']]]):
+        pulumi.set(self, "mysql_databases", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs:
+class StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs:
     def __init__(__self__, *,
-                 schema: pulumi.Input[str],
-                 oracle_tables: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs']]]] = None):
+                 database: pulumi.Input[str],
+                 mysql_tables: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs']]]] = None):
         """
-        :param pulumi.Input[str] schema: Schema name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs']]] oracle_tables: Tables in the database.
+        :param pulumi.Input[str] database: Database name.
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs']]] mysql_tables: Tables in the database.
                Structure is documented below.
         """
-        pulumi.set(__self__, "schema", schema)
-        if oracle_tables is not None:
-            pulumi.set(__self__, "oracle_tables", oracle_tables)
+        pulumi.set(__self__, "database", database)
+        if mysql_tables is not None:
+            pulumi.set(__self__, "mysql_tables", mysql_tables)
 
     @property
     @pulumi.getter
-    def schema(self) -> pulumi.Input[str]:
+    def database(self) -> pulumi.Input[str]:
         """
-        Schema name.
+        Database name.
         """
-        return pulumi.get(self, "schema")
+        return pulumi.get(self, "database")
 
-    @schema.setter
-    def schema(self, value: pulumi.Input[str]):
-        pulumi.set(self, "schema", value)
+    @database.setter
+    def database(self, value: pulumi.Input[str]):
+        pulumi.set(self, "database", value)
 
     @property
-    @pulumi.getter(name="oracleTables")
-    def oracle_tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs']]]]:
+    @pulumi.getter(name="mysqlTables")
+    def mysql_tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs']]]]:
         """
         Tables in the database.
         Structure is documented below.
         """
-        return pulumi.get(self, "oracle_tables")
+        return pulumi.get(self, "mysql_tables")
 
-    @oracle_tables.setter
-    def oracle_tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs']]]]):
-        pulumi.set(self, "oracle_tables", value)
+    @mysql_tables.setter
+    def mysql_tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs']]]]):
+        pulumi.set(self, "mysql_tables", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs:
+class StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs:
     def __init__(__self__, *,
                  table: pulumi.Input[str],
-                 oracle_columns: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs']]]] = None):
+                 mysql_columns: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs']]]] = None):
         """
         :param pulumi.Input[str] table: Table name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs']]] oracle_columns: Oracle columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs']]] mysql_columns: MySQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
                Structure is documented below.
         """
         pulumi.set(__self__, "table", table)
-        if oracle_columns is not None:
-            pulumi.set(__self__, "oracle_columns", oracle_columns)
+        if mysql_columns is not None:
+            pulumi.set(__self__, "mysql_columns", mysql_columns)
 
     @property
     @pulumi.getter
@@ -3108,68 +2149,66 @@ class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableA
         pulumi.set(self, "table", value)
 
     @property
-    @pulumi.getter(name="oracleColumns")
-    def oracle_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs']]]]:
+    @pulumi.getter(name="mysqlColumns")
+    def mysql_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs']]]]:
         """
-        Oracle columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
+        MySQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
         Structure is documented below.
         """
-        return pulumi.get(self, "oracle_columns")
+        return pulumi.get(self, "mysql_columns")
 
-    @oracle_columns.setter
-    def oracle_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs']]]]):
-        pulumi.set(self, "oracle_columns", value)
+    @mysql_columns.setter
+    def mysql_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs']]]]):
+        pulumi.set(self, "mysql_columns", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs:
+class StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs:
     def __init__(__self__, *,
+                 collation: Optional[pulumi.Input[str]] = None,
                  column: 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):
+                 primary_key: Optional[pulumi.Input[bool]] = None):
         """
+        :param pulumi.Input[str] collation: Column collation.
         :param pulumi.Input[str] column: Column name.
-        :param pulumi.Input[str] data_type: The Oracle data type. Full data types list can be found here:
-               https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Data-Types.html
-        :param pulumi.Input[str] encoding: (Output)
-               Column encoding.
+        :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: (Output)
                Column length.
-        :param pulumi.Input[bool] nullable: (Output)
-               Whether or not the column can accept a null value.
-        :param pulumi.Input[int] ordinal_position: (Output)
-               The ordinal position of the column in the table.
-        :param pulumi.Input[int] precision: (Output)
-               Column precision.
-        :param pulumi.Input[bool] primary_key: (Output)
-               Whether or not the column represents a primary key.
-        :param pulumi.Input[int] scale: (Output)
-               Column scale.
+        :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 is not None:
             pulumi.set(__self__, "column", column)
         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
+    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
@@ -3187,8 +2226,8 @@ class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableO
     @pulumi.getter(name="dataType")
     def data_type(self) -> Optional[pulumi.Input[str]]:
         """
-        The Oracle data type. Full data types list can be found here:
-        https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Data-Types.html
+        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")
 
@@ -3196,19 +2235,6 @@ class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableO
     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]]:
-        """
-        (Output)
-        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]]:
@@ -3226,7 +2252,6 @@ class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableO
     @pulumi.getter
     def nullable(self) -> Optional[pulumi.Input[bool]]:
         """
-        (Output)
         Whether or not the column can accept a null value.
         """
         return pulumi.get(self, "nullable")
@@ -3239,7 +2264,6 @@ class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableO
     @pulumi.getter(name="ordinalPosition")
     def ordinal_position(self) -> Optional[pulumi.Input[int]]:
         """
-        (Output)
         The ordinal position of the column in the table.
         """
         return pulumi.get(self, "ordinal_position")
@@ -3248,24 +2272,10 @@ class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableO
     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]]:
-        """
-        (Output)
-        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]]:
         """
-        (Output)
         Whether or not the column represents a primary key.
         """
         return pulumi.get(self, "primary_key")
@@ -3274,97 +2284,84 @@ class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableO
     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]]:
-        """
-        (Output)
-        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 StreamSourceConfigOracleSourceConfigIncludeObjectsArgs:
+class StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs:
     def __init__(__self__, *,
-                 oracle_schemas: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs']]]):
+                 mysql_databases: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs']]]):
         """
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs']]] oracle_schemas: Oracle schemas/databases in the database server
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs']]] mysql_databases: MySQL databases on the server
                Structure is documented below.
         """
-        pulumi.set(__self__, "oracle_schemas", oracle_schemas)
+        pulumi.set(__self__, "mysql_databases", mysql_databases)
 
     @property
-    @pulumi.getter(name="oracleSchemas")
-    def oracle_schemas(self) -> pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs']]]:
+    @pulumi.getter(name="mysqlDatabases")
+    def mysql_databases(self) -> pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs']]]:
         """
-        Oracle schemas/databases in the database server
+        MySQL databases on the server
         Structure is documented below.
         """
-        return pulumi.get(self, "oracle_schemas")
+        return pulumi.get(self, "mysql_databases")
 
-    @oracle_schemas.setter
-    def oracle_schemas(self, value: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs']]]):
-        pulumi.set(self, "oracle_schemas", value)
+    @mysql_databases.setter
+    def mysql_databases(self, value: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs']]]):
+        pulumi.set(self, "mysql_databases", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs:
+class StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs:
     def __init__(__self__, *,
-                 schema: pulumi.Input[str],
-                 oracle_tables: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs']]]] = None):
+                 database: pulumi.Input[str],
+                 mysql_tables: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs']]]] = None):
         """
-        :param pulumi.Input[str] schema: Schema name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs']]] oracle_tables: Tables in the database.
+        :param pulumi.Input[str] database: Database name.
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs']]] mysql_tables: Tables in the database.
                Structure is documented below.
         """
-        pulumi.set(__self__, "schema", schema)
-        if oracle_tables is not None:
-            pulumi.set(__self__, "oracle_tables", oracle_tables)
+        pulumi.set(__self__, "database", database)
+        if mysql_tables is not None:
+            pulumi.set(__self__, "mysql_tables", mysql_tables)
 
     @property
     @pulumi.getter
-    def schema(self) -> pulumi.Input[str]:
+    def database(self) -> pulumi.Input[str]:
         """
-        Schema name.
+        Database name.
         """
-        return pulumi.get(self, "schema")
+        return pulumi.get(self, "database")
 
-    @schema.setter
-    def schema(self, value: pulumi.Input[str]):
-        pulumi.set(self, "schema", value)
+    @database.setter
+    def database(self, value: pulumi.Input[str]):
+        pulumi.set(self, "database", value)
 
     @property
-    @pulumi.getter(name="oracleTables")
-    def oracle_tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs']]]]:
+    @pulumi.getter(name="mysqlTables")
+    def mysql_tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs']]]]:
         """
         Tables in the database.
         Structure is documented below.
         """
-        return pulumi.get(self, "oracle_tables")
+        return pulumi.get(self, "mysql_tables")
 
-    @oracle_tables.setter
-    def oracle_tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs']]]]):
-        pulumi.set(self, "oracle_tables", value)
+    @mysql_tables.setter
+    def mysql_tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs']]]]):
+        pulumi.set(self, "mysql_tables", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs:
+class StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs:
     def __init__(__self__, *,
                  table: pulumi.Input[str],
-                 oracle_columns: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs']]]] = None):
+                 mysql_columns: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs']]]] = None):
         """
         :param pulumi.Input[str] table: Table name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs']]] oracle_columns: Oracle columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs']]] mysql_columns: MySQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
                Structure is documented below.
         """
         pulumi.set(__self__, "table", table)
-        if oracle_columns is not None:
-            pulumi.set(__self__, "oracle_columns", oracle_columns)
+        if mysql_columns is not None:
+            pulumi.set(__self__, "mysql_columns", mysql_columns)
 
     @property
     @pulumi.getter
@@ -3379,68 +2376,66 @@ class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableA
         pulumi.set(self, "table", value)
 
     @property
-    @pulumi.getter(name="oracleColumns")
-    def oracle_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs']]]]:
+    @pulumi.getter(name="mysqlColumns")
+    def mysql_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs']]]]:
         """
-        Oracle columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
+        MySQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
         Structure is documented below.
         """
-        return pulumi.get(self, "oracle_columns")
+        return pulumi.get(self, "mysql_columns")
 
-    @oracle_columns.setter
-    def oracle_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs']]]]):
-        pulumi.set(self, "oracle_columns", value)
+    @mysql_columns.setter
+    def mysql_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs']]]]):
+        pulumi.set(self, "mysql_columns", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs:
+class StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs:
     def __init__(__self__, *,
+                 collation: Optional[pulumi.Input[str]] = None,
                  column: 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):
+                 primary_key: Optional[pulumi.Input[bool]] = None):
         """
+        :param pulumi.Input[str] collation: Column collation.
         :param pulumi.Input[str] column: Column name.
-        :param pulumi.Input[str] data_type: The Oracle data type. Full data types list can be found here:
-               https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Data-Types.html
-        :param pulumi.Input[str] encoding: (Output)
-               Column encoding.
+        :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: (Output)
                Column length.
-        :param pulumi.Input[bool] nullable: (Output)
-               Whether or not the column can accept a null value.
-        :param pulumi.Input[int] ordinal_position: (Output)
-               The ordinal position of the column in the table.
-        :param pulumi.Input[int] precision: (Output)
-               Column precision.
-        :param pulumi.Input[bool] primary_key: (Output)
-               Whether or not the column represents a primary key.
-        :param pulumi.Input[int] scale: (Output)
-               Column scale.
+        :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 is not None:
             pulumi.set(__self__, "column", column)
         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
+    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
@@ -3458,8 +2453,8 @@ class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableO
     @pulumi.getter(name="dataType")
     def data_type(self) -> Optional[pulumi.Input[str]]:
         """
-        The Oracle data type. Full data types list can be found here:
-        https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Data-Types.html
+        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")
 
@@ -3467,19 +2462,6 @@ class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableO
     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]]:
-        """
-        (Output)
-        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]]:
@@ -3497,7 +2479,6 @@ class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableO
     @pulumi.getter
     def nullable(self) -> Optional[pulumi.Input[bool]]:
         """
-        (Output)
         Whether or not the column can accept a null value.
         """
         return pulumi.get(self, "nullable")
@@ -3510,7 +2491,6 @@ class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableO
     @pulumi.getter(name="ordinalPosition")
     def ordinal_position(self) -> Optional[pulumi.Input[int]]:
         """
-        (Output)
         The ordinal position of the column in the table.
         """
         return pulumi.get(self, "ordinal_position")
@@ -3519,24 +2499,10 @@ class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableO
     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]]:
-        """
-        (Output)
-        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]]:
         """
-        (Output)
         Whether or not the column represents a primary key.
         """
         return pulumi.get(self, "primary_key")
@@ -3545,113 +2511,85 @@ class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableO
     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]]:
-        """
-        (Output)
-        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 StreamSourceConfigOracleSourceConfigStreamLargeObjectsArgs:
-    def __init__(__self__):
-        pass
-
 
 @pulumi.input_type
-class StreamSourceConfigPostgresqlSourceConfigArgs:
+class StreamSourceConfigOracleSourceConfigArgs:
     def __init__(__self__, *,
-                 publication: pulumi.Input[str],
-                 replication_slot: pulumi.Input[str],
-                 exclude_objects: Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs']] = None,
-                 include_objects: Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs']] = None,
-                 max_concurrent_backfill_tasks: Optional[pulumi.Input[int]] = None):
+                 drop_large_objects: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigDropLargeObjectsArgs']] = None,
+                 exclude_objects: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsArgs']] = None,
+                 include_objects: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsArgs']] = None,
+                 max_concurrent_backfill_tasks: Optional[pulumi.Input[int]] = None,
+                 max_concurrent_cdc_tasks: Optional[pulumi.Input[int]] = None,
+                 stream_large_objects: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigStreamLargeObjectsArgs']] = None):
         """
-        :param pulumi.Input[str] publication: The name of the publication that includes the set of all tables
-               that are defined in the stream's include_objects.
-        :param pulumi.Input[str] replication_slot: The name of the logical replication slot that's configured with
-               the pgoutput plugin.
-        :param pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs'] exclude_objects: PostgreSQL objects to exclude from the stream.
+        :param pulumi.Input['StreamSourceConfigOracleSourceConfigDropLargeObjectsArgs'] drop_large_objects: Configuration to drop large object values.
+        :param pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsArgs'] exclude_objects: Oracle objects to exclude from the stream.
                Structure is documented below.
-        :param pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs'] include_objects: PostgreSQL objects to retrieve from the source.
+        :param pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsArgs'] include_objects: Oracle objects to retrieve from the source.
                Structure is documented below.
-        :param pulumi.Input[int] max_concurrent_backfill_tasks: Maximum number of concurrent backfill tasks. The number should be non
-               negative. If not set (or set to 0), the system's default value will be used.
+        :param pulumi.Input[int] max_concurrent_backfill_tasks: Maximum number of concurrent backfill tasks. The number should be non negative.
+               If not set (or set to 0), the system's default value will be used.
+        :param pulumi.Input[int] max_concurrent_cdc_tasks: Maximum number of concurrent CDC tasks. The number should be non negative.
+               If not set (or set to 0), the system's default value will be used.
+        :param pulumi.Input['StreamSourceConfigOracleSourceConfigStreamLargeObjectsArgs'] stream_large_objects: Configuration to drop large object values.
         """
-        pulumi.set(__self__, "publication", publication)
-        pulumi.set(__self__, "replication_slot", replication_slot)
+        if drop_large_objects is not None:
+            pulumi.set(__self__, "drop_large_objects", drop_large_objects)
         if exclude_objects is not None:
             pulumi.set(__self__, "exclude_objects", exclude_objects)
         if include_objects is not None:
             pulumi.set(__self__, "include_objects", include_objects)
         if max_concurrent_backfill_tasks is not None:
             pulumi.set(__self__, "max_concurrent_backfill_tasks", max_concurrent_backfill_tasks)
+        if max_concurrent_cdc_tasks is not None:
+            pulumi.set(__self__, "max_concurrent_cdc_tasks", max_concurrent_cdc_tasks)
+        if stream_large_objects is not None:
+            pulumi.set(__self__, "stream_large_objects", stream_large_objects)
 
     @property
-    @pulumi.getter
-    def publication(self) -> pulumi.Input[str]:
-        """
-        The name of the publication that includes the set of all tables
-        that are defined in the stream's include_objects.
-        """
-        return pulumi.get(self, "publication")
-
-    @publication.setter
-    def publication(self, value: pulumi.Input[str]):
-        pulumi.set(self, "publication", value)
-
-    @property
-    @pulumi.getter(name="replicationSlot")
-    def replication_slot(self) -> pulumi.Input[str]:
+    @pulumi.getter(name="dropLargeObjects")
+    def drop_large_objects(self) -> Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigDropLargeObjectsArgs']]:
         """
-        The name of the logical replication slot that's configured with
-        the pgoutput plugin.
+        Configuration to drop large object values.
         """
-        return pulumi.get(self, "replication_slot")
+        return pulumi.get(self, "drop_large_objects")
 
-    @replication_slot.setter
-    def replication_slot(self, value: pulumi.Input[str]):
-        pulumi.set(self, "replication_slot", value)
+    @drop_large_objects.setter
+    def drop_large_objects(self, value: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigDropLargeObjectsArgs']]):
+        pulumi.set(self, "drop_large_objects", value)
 
     @property
     @pulumi.getter(name="excludeObjects")
-    def exclude_objects(self) -> Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs']]:
+    def exclude_objects(self) -> Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsArgs']]:
         """
-        PostgreSQL objects to exclude from the stream.
+        Oracle objects to exclude from the stream.
         Structure is documented below.
         """
         return pulumi.get(self, "exclude_objects")
 
     @exclude_objects.setter
-    def exclude_objects(self, value: Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs']]):
+    def exclude_objects(self, value: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsArgs']]):
         pulumi.set(self, "exclude_objects", value)
 
     @property
     @pulumi.getter(name="includeObjects")
-    def include_objects(self) -> Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs']]:
+    def include_objects(self) -> Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsArgs']]:
         """
-        PostgreSQL objects to retrieve from the source.
+        Oracle objects to retrieve from the source.
         Structure is documented below.
         """
         return pulumi.get(self, "include_objects")
 
     @include_objects.setter
-    def include_objects(self, value: Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs']]):
+    def include_objects(self, value: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsArgs']]):
         pulumi.set(self, "include_objects", value)
 
     @property
     @pulumi.getter(name="maxConcurrentBackfillTasks")
     def max_concurrent_backfill_tasks(self) -> Optional[pulumi.Input[int]]:
         """
-        Maximum number of concurrent backfill tasks. The number should be non
-        negative. If not set (or set to 0), the system's default value will be used.
+        Maximum number of concurrent backfill tasks. The number should be non negative.
+        If not set (or set to 0), the system's default value will be used.
         """
         return pulumi.get(self, "max_concurrent_backfill_tasks")
 
@@ -3659,50 +2597,81 @@ class StreamSourceConfigPostgresqlSourceConfigArgs:
     def max_concurrent_backfill_tasks(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "max_concurrent_backfill_tasks", value)
 
+    @property
+    @pulumi.getter(name="maxConcurrentCdcTasks")
+    def max_concurrent_cdc_tasks(self) -> Optional[pulumi.Input[int]]:
+        """
+        Maximum number of concurrent CDC tasks. The number should be non negative.
+        If not set (or set to 0), the system's default value will be used.
+        """
+        return pulumi.get(self, "max_concurrent_cdc_tasks")
+
+    @max_concurrent_cdc_tasks.setter
+    def max_concurrent_cdc_tasks(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_concurrent_cdc_tasks", value)
+
+    @property
+    @pulumi.getter(name="streamLargeObjects")
+    def stream_large_objects(self) -> Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigStreamLargeObjectsArgs']]:
+        """
+        Configuration to drop large object values.
+        """
+        return pulumi.get(self, "stream_large_objects")
+
+    @stream_large_objects.setter
+    def stream_large_objects(self, value: Optional[pulumi.Input['StreamSourceConfigOracleSourceConfigStreamLargeObjectsArgs']]):
+        pulumi.set(self, "stream_large_objects", value)
+
 
 @pulumi.input_type
-class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs:
+class StreamSourceConfigOracleSourceConfigDropLargeObjectsArgs:
+    def __init__(__self__):
+        pass
+
+
+@pulumi.input_type
+class StreamSourceConfigOracleSourceConfigExcludeObjectsArgs:
     def __init__(__self__, *,
-                 postgresql_schemas: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs']]]):
+                 oracle_schemas: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs']]]):
         """
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs']]] postgresql_schemas: PostgreSQL schemas on the server
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs']]] oracle_schemas: Oracle schemas/databases in the database server
                Structure is documented below.
         """
-        pulumi.set(__self__, "postgresql_schemas", postgresql_schemas)
+        pulumi.set(__self__, "oracle_schemas", oracle_schemas)
 
     @property
-    @pulumi.getter(name="postgresqlSchemas")
-    def postgresql_schemas(self) -> pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs']]]:
+    @pulumi.getter(name="oracleSchemas")
+    def oracle_schemas(self) -> pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs']]]:
         """
-        PostgreSQL schemas on the server
+        Oracle schemas/databases in the database server
         Structure is documented below.
         """
-        return pulumi.get(self, "postgresql_schemas")
+        return pulumi.get(self, "oracle_schemas")
 
-    @postgresql_schemas.setter
-    def postgresql_schemas(self, value: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs']]]):
-        pulumi.set(self, "postgresql_schemas", value)
+    @oracle_schemas.setter
+    def oracle_schemas(self, value: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs']]]):
+        pulumi.set(self, "oracle_schemas", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs:
+class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs:
     def __init__(__self__, *,
                  schema: pulumi.Input[str],
-                 postgresql_tables: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs']]]] = None):
+                 oracle_tables: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs']]]] = None):
         """
-        :param pulumi.Input[str] schema: Database name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs']]] postgresql_tables: Tables in the schema.
+        :param pulumi.Input[str] schema: Schema name.
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs']]] oracle_tables: Tables in the database.
                Structure is documented below.
         """
         pulumi.set(__self__, "schema", schema)
-        if postgresql_tables is not None:
-            pulumi.set(__self__, "postgresql_tables", postgresql_tables)
+        if oracle_tables is not None:
+            pulumi.set(__self__, "oracle_tables", oracle_tables)
 
     @property
     @pulumi.getter
     def schema(self) -> pulumi.Input[str]:
         """
-        Database name.
+        Schema name.
         """
         return pulumi.get(self, "schema")
 
@@ -3711,32 +2680,32 @@ class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs
         pulumi.set(self, "schema", value)
 
     @property
-    @pulumi.getter(name="postgresqlTables")
-    def postgresql_tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs']]]]:
+    @pulumi.getter(name="oracleTables")
+    def oracle_tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs']]]]:
         """
-        Tables in the schema.
+        Tables in the database.
         Structure is documented below.
         """
-        return pulumi.get(self, "postgresql_tables")
+        return pulumi.get(self, "oracle_tables")
 
-    @postgresql_tables.setter
-    def postgresql_tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs']]]]):
-        pulumi.set(self, "postgresql_tables", value)
+    @oracle_tables.setter
+    def oracle_tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs']]]]):
+        pulumi.set(self, "oracle_tables", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs:
+class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs:
     def __init__(__self__, *,
                  table: pulumi.Input[str],
-                 postgresql_columns: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs']]]] = None):
+                 oracle_columns: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs']]]] = None):
         """
         :param pulumi.Input[str] table: Table name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs']]] postgresql_columns: PostgreSQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs']]] oracle_columns: Oracle columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
                Structure is documented below.
         """
         pulumi.set(__self__, "table", table)
-        if postgresql_columns is not None:
-            pulumi.set(__self__, "postgresql_columns", postgresql_columns)
+        if oracle_columns is not None:
+            pulumi.set(__self__, "oracle_columns", oracle_columns)
 
     @property
     @pulumi.getter
@@ -3751,24 +2720,25 @@ class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPost
         pulumi.set(self, "table", value)
 
     @property
-    @pulumi.getter(name="postgresqlColumns")
-    def postgresql_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs']]]]:
+    @pulumi.getter(name="oracleColumns")
+    def oracle_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs']]]]:
         """
-        PostgreSQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
+        Oracle columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
         Structure is documented below.
         """
-        return pulumi.get(self, "postgresql_columns")
+        return pulumi.get(self, "oracle_columns")
 
-    @postgresql_columns.setter
-    def postgresql_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs']]]]):
-        pulumi.set(self, "postgresql_columns", value)
+    @oracle_columns.setter
+    def oracle_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs']]]]):
+        pulumi.set(self, "oracle_columns", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs:
+class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs:
     def __init__(__self__, *,
                  column: 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,
@@ -3777,15 +2747,20 @@ class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPost
                  scale: Optional[pulumi.Input[int]] = None):
         """
         :param pulumi.Input[str] column: Column name.
-        :param pulumi.Input[str] data_type: The PostgreSQL data type. Full data types list can be found here:
-               https://www.postgresql.org/docs/current/datatype.html
+        :param pulumi.Input[str] data_type: The Oracle data type. Full data types list can be found here:
+               https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Data-Types.html
+        :param pulumi.Input[str] encoding: (Output)
+               Column encoding.
         :param pulumi.Input[int] length: (Output)
                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] nullable: (Output)
+               Whether or not the column can accept a null value.
+        :param pulumi.Input[int] ordinal_position: (Output)
+               The ordinal position of the column in the table.
         :param pulumi.Input[int] precision: (Output)
                Column precision.
-        :param pulumi.Input[bool] primary_key: Whether or not the column represents a primary key.
+        :param pulumi.Input[bool] primary_key: (Output)
+               Whether or not the column represents a primary key.
         :param pulumi.Input[int] scale: (Output)
                Column scale.
         """
@@ -3793,6 +2768,8 @@ class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPost
             pulumi.set(__self__, "column", column)
         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:
@@ -3822,8 +2799,8 @@ class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPost
     @pulumi.getter(name="dataType")
     def data_type(self) -> Optional[pulumi.Input[str]]:
         """
-        The PostgreSQL data type. Full data types list can be found here:
-        https://www.postgresql.org/docs/current/datatype.html
+        The Oracle data type. Full data types list can be found here:
+        https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Data-Types.html
         """
         return pulumi.get(self, "data_type")
 
@@ -3831,6 +2808,19 @@ class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPost
     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]]:
+        """
+        (Output)
+        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]]:
@@ -3848,6 +2838,7 @@ class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPost
     @pulumi.getter
     def nullable(self) -> Optional[pulumi.Input[bool]]:
         """
+        (Output)
         Whether or not the column can accept a null value.
         """
         return pulumi.get(self, "nullable")
@@ -3860,6 +2851,7 @@ class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPost
     @pulumi.getter(name="ordinalPosition")
     def ordinal_position(self) -> Optional[pulumi.Input[int]]:
         """
+        (Output)
         The ordinal position of the column in the table.
         """
         return pulumi.get(self, "ordinal_position")
@@ -3885,6 +2877,7 @@ class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPost
     @pulumi.getter(name="primaryKey")
     def primary_key(self) -> Optional[pulumi.Input[bool]]:
         """
+        (Output)
         Whether or not the column represents a primary key.
         """
         return pulumi.get(self, "primary_key")
@@ -3908,48 +2901,48 @@ class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPost
 
 
 @pulumi.input_type
-class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs:
+class StreamSourceConfigOracleSourceConfigIncludeObjectsArgs:
     def __init__(__self__, *,
-                 postgresql_schemas: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs']]]):
+                 oracle_schemas: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs']]]):
         """
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs']]] postgresql_schemas: PostgreSQL schemas on the server
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs']]] oracle_schemas: Oracle schemas/databases in the database server
                Structure is documented below.
         """
-        pulumi.set(__self__, "postgresql_schemas", postgresql_schemas)
+        pulumi.set(__self__, "oracle_schemas", oracle_schemas)
 
     @property
-    @pulumi.getter(name="postgresqlSchemas")
-    def postgresql_schemas(self) -> pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs']]]:
+    @pulumi.getter(name="oracleSchemas")
+    def oracle_schemas(self) -> pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs']]]:
         """
-        PostgreSQL schemas on the server
+        Oracle schemas/databases in the database server
         Structure is documented below.
         """
-        return pulumi.get(self, "postgresql_schemas")
+        return pulumi.get(self, "oracle_schemas")
 
-    @postgresql_schemas.setter
-    def postgresql_schemas(self, value: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs']]]):
-        pulumi.set(self, "postgresql_schemas", value)
+    @oracle_schemas.setter
+    def oracle_schemas(self, value: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs']]]):
+        pulumi.set(self, "oracle_schemas", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs:
+class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs:
     def __init__(__self__, *,
                  schema: pulumi.Input[str],
-                 postgresql_tables: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs']]]] = None):
+                 oracle_tables: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs']]]] = None):
         """
-        :param pulumi.Input[str] schema: Database name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs']]] postgresql_tables: Tables in the schema.
+        :param pulumi.Input[str] schema: Schema name.
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs']]] oracle_tables: Tables in the database.
                Structure is documented below.
         """
         pulumi.set(__self__, "schema", schema)
-        if postgresql_tables is not None:
-            pulumi.set(__self__, "postgresql_tables", postgresql_tables)
+        if oracle_tables is not None:
+            pulumi.set(__self__, "oracle_tables", oracle_tables)
 
     @property
     @pulumi.getter
     def schema(self) -> pulumi.Input[str]:
         """
-        Database name.
+        Schema name.
         """
         return pulumi.get(self, "schema")
 
@@ -3958,32 +2951,32 @@ class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs
         pulumi.set(self, "schema", value)
 
     @property
-    @pulumi.getter(name="postgresqlTables")
-    def postgresql_tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs']]]]:
+    @pulumi.getter(name="oracleTables")
+    def oracle_tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs']]]]:
         """
-        Tables in the schema.
+        Tables in the database.
         Structure is documented below.
         """
-        return pulumi.get(self, "postgresql_tables")
+        return pulumi.get(self, "oracle_tables")
 
-    @postgresql_tables.setter
-    def postgresql_tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs']]]]):
-        pulumi.set(self, "postgresql_tables", value)
+    @oracle_tables.setter
+    def oracle_tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs']]]]):
+        pulumi.set(self, "oracle_tables", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs:
+class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs:
     def __init__(__self__, *,
                  table: pulumi.Input[str],
-                 postgresql_columns: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs']]]] = None):
+                 oracle_columns: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs']]]] = None):
         """
         :param pulumi.Input[str] table: Table name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs']]] postgresql_columns: PostgreSQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs']]] oracle_columns: Oracle columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
                Structure is documented below.
         """
         pulumi.set(__self__, "table", table)
-        if postgresql_columns is not None:
-            pulumi.set(__self__, "postgresql_columns", postgresql_columns)
+        if oracle_columns is not None:
+            pulumi.set(__self__, "oracle_columns", oracle_columns)
 
     @property
     @pulumi.getter
@@ -3998,24 +2991,25 @@ class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPost
         pulumi.set(self, "table", value)
 
     @property
-    @pulumi.getter(name="postgresqlColumns")
-    def postgresql_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs']]]]:
+    @pulumi.getter(name="oracleColumns")
+    def oracle_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs']]]]:
         """
-        PostgreSQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
+        Oracle columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
         Structure is documented below.
         """
-        return pulumi.get(self, "postgresql_columns")
+        return pulumi.get(self, "oracle_columns")
 
-    @postgresql_columns.setter
-    def postgresql_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs']]]]):
-        pulumi.set(self, "postgresql_columns", value)
+    @oracle_columns.setter
+    def oracle_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs']]]]):
+        pulumi.set(self, "oracle_columns", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs:
+class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs:
     def __init__(__self__, *,
                  column: 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,
@@ -4024,15 +3018,20 @@ class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPost
                  scale: Optional[pulumi.Input[int]] = None):
         """
         :param pulumi.Input[str] column: Column name.
-        :param pulumi.Input[str] data_type: The PostgreSQL data type. Full data types list can be found here:
-               https://www.postgresql.org/docs/current/datatype.html
+        :param pulumi.Input[str] data_type: The Oracle data type. Full data types list can be found here:
+               https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Data-Types.html
+        :param pulumi.Input[str] encoding: (Output)
+               Column encoding.
         :param pulumi.Input[int] length: (Output)
                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] nullable: (Output)
+               Whether or not the column can accept a null value.
+        :param pulumi.Input[int] ordinal_position: (Output)
+               The ordinal position of the column in the table.
         :param pulumi.Input[int] precision: (Output)
                Column precision.
-        :param pulumi.Input[bool] primary_key: Whether or not the column represents a primary key.
+        :param pulumi.Input[bool] primary_key: (Output)
+               Whether or not the column represents a primary key.
         :param pulumi.Input[int] scale: (Output)
                Column scale.
         """
@@ -4040,6 +3039,8 @@ class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPost
             pulumi.set(__self__, "column", column)
         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:
@@ -4069,8 +3070,8 @@ class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPost
     @pulumi.getter(name="dataType")
     def data_type(self) -> Optional[pulumi.Input[str]]:
         """
-        The PostgreSQL data type. Full data types list can be found here:
-        https://www.postgresql.org/docs/current/datatype.html
+        The Oracle data type. Full data types list can be found here:
+        https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/Data-Types.html
         """
         return pulumi.get(self, "data_type")
 
@@ -4078,6 +3079,19 @@ class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPost
     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]]:
+        """
+        (Output)
+        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]]:
@@ -4095,6 +3109,7 @@ class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPost
     @pulumi.getter
     def nullable(self) -> Optional[pulumi.Input[bool]]:
         """
+        (Output)
         Whether or not the column can accept a null value.
         """
         return pulumi.get(self, "nullable")
@@ -4107,6 +3122,7 @@ class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPost
     @pulumi.getter(name="ordinalPosition")
     def ordinal_position(self) -> Optional[pulumi.Input[int]]:
         """
+        (Output)
         The ordinal position of the column in the table.
         """
         return pulumi.get(self, "ordinal_position")
@@ -4132,6 +3148,7 @@ class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPost
     @pulumi.getter(name="primaryKey")
     def primary_key(self) -> Optional[pulumi.Input[bool]]:
         """
+        (Output)
         Whether or not the column represents a primary key.
         """
         return pulumi.get(self, "primary_key")
@@ -4155,60 +3172,98 @@ class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPost
 
 
 @pulumi.input_type
-class StreamSourceConfigSqlServerSourceConfigArgs:
+class StreamSourceConfigOracleSourceConfigStreamLargeObjectsArgs:
+    def __init__(__self__):
+        pass
+
+
+@pulumi.input_type
+class StreamSourceConfigPostgresqlSourceConfigArgs:
     def __init__(__self__, *,
-                 exclude_objects: Optional[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsArgs']] = None,
-                 include_objects: Optional[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs']] = None,
-                 max_concurrent_backfill_tasks: Optional[pulumi.Input[int]] = None,
-                 max_concurrent_cdc_tasks: Optional[pulumi.Input[int]] = None):
+                 publication: pulumi.Input[str],
+                 replication_slot: pulumi.Input[str],
+                 exclude_objects: Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs']] = None,
+                 include_objects: Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs']] = None,
+                 max_concurrent_backfill_tasks: Optional[pulumi.Input[int]] = None):
         """
-        :param pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsArgs'] exclude_objects: SQL Server objects to exclude from the stream.
+        :param pulumi.Input[str] publication: The name of the publication that includes the set of all tables
+               that are defined in the stream's include_objects.
+        :param pulumi.Input[str] replication_slot: The name of the logical replication slot that's configured with
+               the pgoutput plugin.
+        :param pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs'] exclude_objects: PostgreSQL objects to exclude from the stream.
                Structure is documented below.
-        :param pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs'] include_objects: SQL Server objects to retrieve from the source.
+        :param pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs'] include_objects: PostgreSQL objects to retrieve from the source.
                Structure is documented below.
-        :param pulumi.Input[int] max_concurrent_backfill_tasks: Max concurrent backfill tasks.
-        :param pulumi.Input[int] max_concurrent_cdc_tasks: Max concurrent CDC tasks.
+        :param pulumi.Input[int] max_concurrent_backfill_tasks: Maximum number of concurrent backfill tasks. The number should be non
+               negative. If not set (or set to 0), the system's default value will be used.
         """
+        pulumi.set(__self__, "publication", publication)
+        pulumi.set(__self__, "replication_slot", replication_slot)
         if exclude_objects is not None:
             pulumi.set(__self__, "exclude_objects", exclude_objects)
         if include_objects is not None:
             pulumi.set(__self__, "include_objects", include_objects)
         if max_concurrent_backfill_tasks is not None:
             pulumi.set(__self__, "max_concurrent_backfill_tasks", max_concurrent_backfill_tasks)
-        if max_concurrent_cdc_tasks is not None:
-            pulumi.set(__self__, "max_concurrent_cdc_tasks", max_concurrent_cdc_tasks)
+
+    @property
+    @pulumi.getter
+    def publication(self) -> pulumi.Input[str]:
+        """
+        The name of the publication that includes the set of all tables
+        that are defined in the stream's include_objects.
+        """
+        return pulumi.get(self, "publication")
+
+    @publication.setter
+    def publication(self, value: pulumi.Input[str]):
+        pulumi.set(self, "publication", value)
+
+    @property
+    @pulumi.getter(name="replicationSlot")
+    def replication_slot(self) -> pulumi.Input[str]:
+        """
+        The name of the logical replication slot that's configured with
+        the pgoutput plugin.
+        """
+        return pulumi.get(self, "replication_slot")
+
+    @replication_slot.setter
+    def replication_slot(self, value: pulumi.Input[str]):
+        pulumi.set(self, "replication_slot", value)
 
     @property
     @pulumi.getter(name="excludeObjects")
-    def exclude_objects(self) -> Optional[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsArgs']]:
+    def exclude_objects(self) -> Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs']]:
         """
-        SQL Server objects to exclude from the stream.
+        PostgreSQL objects to exclude from the stream.
         Structure is documented below.
         """
         return pulumi.get(self, "exclude_objects")
 
     @exclude_objects.setter
-    def exclude_objects(self, value: Optional[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsArgs']]):
+    def exclude_objects(self, value: Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs']]):
         pulumi.set(self, "exclude_objects", value)
 
     @property
     @pulumi.getter(name="includeObjects")
-    def include_objects(self) -> Optional[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs']]:
+    def include_objects(self) -> Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs']]:
         """
-        SQL Server objects to retrieve from the source.
+        PostgreSQL objects to retrieve from the source.
         Structure is documented below.
         """
         return pulumi.get(self, "include_objects")
 
     @include_objects.setter
-    def include_objects(self, value: Optional[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs']]):
+    def include_objects(self, value: Optional[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs']]):
         pulumi.set(self, "include_objects", value)
 
     @property
     @pulumi.getter(name="maxConcurrentBackfillTasks")
     def max_concurrent_backfill_tasks(self) -> Optional[pulumi.Input[int]]:
         """
-        Max concurrent backfill tasks.
+        Maximum number of concurrent backfill tasks. The number should be non
+        negative. If not set (or set to 0), the system's default value will be used.
         """
         return pulumi.get(self, "max_concurrent_backfill_tasks")
 
@@ -4216,62 +3271,50 @@ class StreamSourceConfigSqlServerSourceConfigArgs:
     def max_concurrent_backfill_tasks(self, value: Optional[pulumi.Input[int]]):
         pulumi.set(self, "max_concurrent_backfill_tasks", value)
 
-    @property
-    @pulumi.getter(name="maxConcurrentCdcTasks")
-    def max_concurrent_cdc_tasks(self) -> Optional[pulumi.Input[int]]:
-        """
-        Max concurrent CDC tasks.
-        """
-        return pulumi.get(self, "max_concurrent_cdc_tasks")
-
-    @max_concurrent_cdc_tasks.setter
-    def max_concurrent_cdc_tasks(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "max_concurrent_cdc_tasks", value)
-
 
 @pulumi.input_type
-class StreamSourceConfigSqlServerSourceConfigExcludeObjectsArgs:
+class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs:
     def __init__(__self__, *,
-                 schemas: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgs']]]):
+                 postgresql_schemas: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs']]]):
         """
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgs']]] schemas: SQL Server schemas/databases in the database server
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs']]] postgresql_schemas: PostgreSQL schemas on the server
                Structure is documented below.
         """
-        pulumi.set(__self__, "schemas", schemas)
+        pulumi.set(__self__, "postgresql_schemas", postgresql_schemas)
 
     @property
-    @pulumi.getter
-    def schemas(self) -> pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgs']]]:
+    @pulumi.getter(name="postgresqlSchemas")
+    def postgresql_schemas(self) -> pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs']]]:
         """
-        SQL Server schemas/databases in the database server
+        PostgreSQL schemas on the server
         Structure is documented below.
         """
-        return pulumi.get(self, "schemas")
+        return pulumi.get(self, "postgresql_schemas")
 
-    @schemas.setter
-    def schemas(self, value: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgs']]]):
-        pulumi.set(self, "schemas", value)
+    @postgresql_schemas.setter
+    def postgresql_schemas(self, value: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs']]]):
+        pulumi.set(self, "postgresql_schemas", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgs:
+class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs:
     def __init__(__self__, *,
                  schema: pulumi.Input[str],
-                 tables: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgs']]]] = None):
+                 postgresql_tables: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs']]]] = None):
         """
-        :param pulumi.Input[str] schema: Schema name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgs']]] tables: Tables in the database.
+        :param pulumi.Input[str] schema: Database name.
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs']]] postgresql_tables: Tables in the schema.
                Structure is documented below.
         """
         pulumi.set(__self__, "schema", schema)
-        if tables is not None:
-            pulumi.set(__self__, "tables", tables)
+        if postgresql_tables is not None:
+            pulumi.set(__self__, "postgresql_tables", postgresql_tables)
 
     @property
     @pulumi.getter
     def schema(self) -> pulumi.Input[str]:
         """
-        Schema name.
+        Database name.
         """
         return pulumi.get(self, "schema")
 
@@ -4280,32 +3323,32 @@ class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgs:
         pulumi.set(self, "schema", value)
 
     @property
-    @pulumi.getter
-    def tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgs']]]]:
+    @pulumi.getter(name="postgresqlTables")
+    def postgresql_tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs']]]]:
         """
-        Tables in the database.
+        Tables in the schema.
         Structure is documented below.
         """
-        return pulumi.get(self, "tables")
+        return pulumi.get(self, "postgresql_tables")
 
-    @tables.setter
-    def tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgs']]]]):
-        pulumi.set(self, "tables", value)
+    @postgresql_tables.setter
+    def postgresql_tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs']]]]):
+        pulumi.set(self, "postgresql_tables", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgs:
+class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs:
     def __init__(__self__, *,
                  table: pulumi.Input[str],
-                 columns: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs']]]] = None):
+                 postgresql_columns: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs']]]] = None):
         """
         :param pulumi.Input[str] table: Table name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs']]] columns: SQL Server columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs']]] postgresql_columns: PostgreSQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
                Structure is documented below.
         """
         pulumi.set(__self__, "table", table)
-        if columns is not None:
-            pulumi.set(__self__, "columns", columns)
+        if postgresql_columns is not None:
+            pulumi.set(__self__, "postgresql_columns", postgresql_columns)
 
     @property
     @pulumi.getter
@@ -4320,21 +3363,21 @@ class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgs:
         pulumi.set(self, "table", value)
 
     @property
-    @pulumi.getter
-    def columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs']]]]:
+    @pulumi.getter(name="postgresqlColumns")
+    def postgresql_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs']]]]:
         """
-        SQL Server columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
+        PostgreSQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
         Structure is documented below.
         """
-        return pulumi.get(self, "columns")
+        return pulumi.get(self, "postgresql_columns")
 
-    @columns.setter
-    def columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs']]]]):
-        pulumi.set(self, "columns", value)
+    @postgresql_columns.setter
+    def postgresql_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs']]]]):
+        pulumi.set(self, "postgresql_columns", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs:
+class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs:
     def __init__(__self__, *,
                  column: Optional[pulumi.Input[str]] = None,
                  data_type: Optional[pulumi.Input[str]] = None,
@@ -4346,18 +3389,15 @@ class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs
                  scale: Optional[pulumi.Input[int]] = None):
         """
         :param pulumi.Input[str] column: Column name.
-        :param pulumi.Input[str] data_type: The SQL Server data type. Full data types list can be found here:
-               https://learn.microsoft.com/en-us/sql/t-sql/data-types/data-types-transact-sql?view=sql-server-ver16
+        :param pulumi.Input[str] data_type: The PostgreSQL data type. Full data types list can be found here:
+               https://www.postgresql.org/docs/current/datatype.html
         :param pulumi.Input[int] length: (Output)
                Column length.
-        :param pulumi.Input[bool] nullable: (Output)
-               Whether or not the column can accept a null value.
-        :param pulumi.Input[int] ordinal_position: (Output)
-               The ordinal position of the column in the table.
+        :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: (Output)
                Column precision.
-        :param pulumi.Input[bool] primary_key: (Output)
-               Whether or not the column represents a primary key.
+        :param pulumi.Input[bool] primary_key: Whether or not the column represents a primary key.
         :param pulumi.Input[int] scale: (Output)
                Column scale.
         """
@@ -4394,8 +3434,8 @@ class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs
     @pulumi.getter(name="dataType")
     def data_type(self) -> Optional[pulumi.Input[str]]:
         """
-        The SQL Server data type. Full data types list can be found here:
-        https://learn.microsoft.com/en-us/sql/t-sql/data-types/data-types-transact-sql?view=sql-server-ver16
+        The PostgreSQL data type. Full data types list can be found here:
+        https://www.postgresql.org/docs/current/datatype.html
         """
         return pulumi.get(self, "data_type")
 
@@ -4420,7 +3460,6 @@ class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs
     @pulumi.getter
     def nullable(self) -> Optional[pulumi.Input[bool]]:
         """
-        (Output)
         Whether or not the column can accept a null value.
         """
         return pulumi.get(self, "nullable")
@@ -4433,7 +3472,6 @@ class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs
     @pulumi.getter(name="ordinalPosition")
     def ordinal_position(self) -> Optional[pulumi.Input[int]]:
         """
-        (Output)
         The ordinal position of the column in the table.
         """
         return pulumi.get(self, "ordinal_position")
@@ -4459,7 +3497,6 @@ class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs
     @pulumi.getter(name="primaryKey")
     def primary_key(self) -> Optional[pulumi.Input[bool]]:
         """
-        (Output)
         Whether or not the column represents a primary key.
         """
         return pulumi.get(self, "primary_key")
@@ -4483,48 +3520,48 @@ class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs
 
 
 @pulumi.input_type
-class StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs:
+class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs:
     def __init__(__self__, *,
-                 schemas: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs']]]):
+                 postgresql_schemas: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs']]]):
         """
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs']]] schemas: SQL Server schemas/databases in the database server
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs']]] postgresql_schemas: PostgreSQL schemas on the server
                Structure is documented below.
         """
-        pulumi.set(__self__, "schemas", schemas)
+        pulumi.set(__self__, "postgresql_schemas", postgresql_schemas)
 
     @property
-    @pulumi.getter
-    def schemas(self) -> pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs']]]:
+    @pulumi.getter(name="postgresqlSchemas")
+    def postgresql_schemas(self) -> pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs']]]:
         """
-        SQL Server schemas/databases in the database server
+        PostgreSQL schemas on the server
         Structure is documented below.
         """
-        return pulumi.get(self, "schemas")
+        return pulumi.get(self, "postgresql_schemas")
 
-    @schemas.setter
-    def schemas(self, value: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs']]]):
-        pulumi.set(self, "schemas", value)
+    @postgresql_schemas.setter
+    def postgresql_schemas(self, value: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs']]]):
+        pulumi.set(self, "postgresql_schemas", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs:
+class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs:
     def __init__(__self__, *,
                  schema: pulumi.Input[str],
-                 tables: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs']]]] = None):
+                 postgresql_tables: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs']]]] = None):
         """
-        :param pulumi.Input[str] schema: Schema name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs']]] tables: Tables in the database.
+        :param pulumi.Input[str] schema: Database name.
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs']]] postgresql_tables: Tables in the schema.
                Structure is documented below.
         """
         pulumi.set(__self__, "schema", schema)
-        if tables is not None:
-            pulumi.set(__self__, "tables", tables)
+        if postgresql_tables is not None:
+            pulumi.set(__self__, "postgresql_tables", postgresql_tables)
 
     @property
     @pulumi.getter
     def schema(self) -> pulumi.Input[str]:
         """
-        Schema name.
+        Database name.
         """
         return pulumi.get(self, "schema")
 
@@ -4533,32 +3570,32 @@ class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs:
         pulumi.set(self, "schema", value)
 
     @property
-    @pulumi.getter
-    def tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs']]]]:
+    @pulumi.getter(name="postgresqlTables")
+    def postgresql_tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs']]]]:
         """
-        Tables in the database.
+        Tables in the schema.
         Structure is documented below.
         """
-        return pulumi.get(self, "tables")
+        return pulumi.get(self, "postgresql_tables")
 
-    @tables.setter
-    def tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs']]]]):
-        pulumi.set(self, "tables", value)
+    @postgresql_tables.setter
+    def postgresql_tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs']]]]):
+        pulumi.set(self, "postgresql_tables", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs:
+class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs:
     def __init__(__self__, *,
                  table: pulumi.Input[str],
-                 columns: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgs']]]] = None):
+                 postgresql_columns: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs']]]] = None):
         """
         :param pulumi.Input[str] table: Table name.
-        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgs']]] columns: SQL Server columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
+        :param pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs']]] postgresql_columns: PostgreSQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
                Structure is documented below.
         """
         pulumi.set(__self__, "table", table)
-        if columns is not None:
-            pulumi.set(__self__, "columns", columns)
+        if postgresql_columns is not None:
+            pulumi.set(__self__, "postgresql_columns", postgresql_columns)
 
     @property
     @pulumi.getter
@@ -4573,21 +3610,21 @@ class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs:
         pulumi.set(self, "table", value)
 
     @property
-    @pulumi.getter
-    def columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgs']]]]:
+    @pulumi.getter(name="postgresqlColumns")
+    def postgresql_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs']]]]:
         """
-        SQL Server columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
+        PostgreSQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
         Structure is documented below.
         """
-        return pulumi.get(self, "columns")
+        return pulumi.get(self, "postgresql_columns")
 
-    @columns.setter
-    def columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgs']]]]):
-        pulumi.set(self, "columns", value)
+    @postgresql_columns.setter
+    def postgresql_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs']]]]):
+        pulumi.set(self, "postgresql_columns", value)
 
 
 @pulumi.input_type
-class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgs:
+class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs:
     def __init__(__self__, *,
                  column: Optional[pulumi.Input[str]] = None,
                  data_type: Optional[pulumi.Input[str]] = None,
@@ -4599,18 +3636,15 @@ class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgs
                  scale: Optional[pulumi.Input[int]] = None):
         """
         :param pulumi.Input[str] column: Column name.
-        :param pulumi.Input[str] data_type: The SQL Server data type. Full data types list can be found here:
-               https://learn.microsoft.com/en-us/sql/t-sql/data-types/data-types-transact-sql?view=sql-server-ver16
+        :param pulumi.Input[str] data_type: The PostgreSQL data type. Full data types list can be found here:
+               https://www.postgresql.org/docs/current/datatype.html
         :param pulumi.Input[int] length: (Output)
                Column length.
-        :param pulumi.Input[bool] nullable: (Output)
-               Whether or not the column can accept a null value.
-        :param pulumi.Input[int] ordinal_position: (Output)
-               The ordinal position of the column in the table.
+        :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: (Output)
                Column precision.
-        :param pulumi.Input[bool] primary_key: (Output)
-               Whether or not the column represents a primary key.
+        :param pulumi.Input[bool] primary_key: Whether or not the column represents a primary key.
         :param pulumi.Input[int] scale: (Output)
                Column scale.
         """
@@ -4647,8 +3681,8 @@ class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgs
     @pulumi.getter(name="dataType")
     def data_type(self) -> Optional[pulumi.Input[str]]:
         """
-        The SQL Server data type. Full data types list can be found here:
-        https://learn.microsoft.com/en-us/sql/t-sql/data-types/data-types-transact-sql?view=sql-server-ver16
+        The PostgreSQL data type. Full data types list can be found here:
+        https://www.postgresql.org/docs/current/datatype.html
         """
         return pulumi.get(self, "data_type")
 
@@ -4673,7 +3707,6 @@ class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgs
     @pulumi.getter
     def nullable(self) -> Optional[pulumi.Input[bool]]:
         """
-        (Output)
         Whether or not the column can accept a null value.
         """
         return pulumi.get(self, "nullable")
@@ -4686,7 +3719,6 @@ class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgs
     @pulumi.getter(name="ordinalPosition")
     def ordinal_position(self) -> Optional[pulumi.Input[int]]:
         """
-        (Output)
         The ordinal position of the column in the table.
         """
         return pulumi.get(self, "ordinal_position")
@@ -4712,7 +3744,6 @@ class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgs
     @pulumi.getter(name="primaryKey")
     def primary_key(self) -> Optional[pulumi.Input[bool]]:
         """
-        (Output)
         Whether or not the column represents a primary key.
         """
         return pulumi.get(self, "primary_key")