pulumi-gcp 7.30.0__py3-none-any.whl → 7.30.0a1719470057__py3-none-any.whl

pulumi_gcp/datastream/_inputs.py

@@ -4,212 +4,96 @@
 
 import copy
 import warnings
-import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
-if sys.version_info >= (3, 11):
-    from typing import NotRequired, TypedDict, TypeAlias
-else:
-    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 
 __all__ = [
     'ConnectionProfileBigqueryProfileArgs',
-    'ConnectionProfileBigqueryProfileArgsDict',
     'ConnectionProfileForwardSshConnectivityArgs',
-    'ConnectionProfileForwardSshConnectivityArgsDict',
     'ConnectionProfileGcsProfileArgs',
-    'ConnectionProfileGcsProfileArgsDict',
     'ConnectionProfileMysqlProfileArgs',
-    'ConnectionProfileMysqlProfileArgsDict',
     'ConnectionProfileMysqlProfileSslConfigArgs',
-    'ConnectionProfileMysqlProfileSslConfigArgsDict',
     'ConnectionProfileOracleProfileArgs',
-    'ConnectionProfileOracleProfileArgsDict',
     'ConnectionProfilePostgresqlProfileArgs',
-    'ConnectionProfilePostgresqlProfileArgsDict',
     'ConnectionProfilePrivateConnectivityArgs',
-    'ConnectionProfilePrivateConnectivityArgsDict',
     'ConnectionProfileSqlServerProfileArgs',
-    'ConnectionProfileSqlServerProfileArgsDict',
     'PrivateConnectionErrorArgs',
-    'PrivateConnectionErrorArgsDict',
     'PrivateConnectionVpcPeeringConfigArgs',
-    'PrivateConnectionVpcPeeringConfigArgsDict',
     'StreamBackfillAllArgs',
-    'StreamBackfillAllArgsDict',
     'StreamBackfillAllMysqlExcludedObjectsArgs',
-    'StreamBackfillAllMysqlExcludedObjectsArgsDict',
     'StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseArgs',
-    'StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseArgsDict',
     'StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableArgs',
-    'StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableArgsDict',
     'StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableMysqlColumnArgs',
-    'StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableMysqlColumnArgsDict',
     'StreamBackfillAllOracleExcludedObjectsArgs',
-    'StreamBackfillAllOracleExcludedObjectsArgsDict',
     'StreamBackfillAllOracleExcludedObjectsOracleSchemaArgs',
-    'StreamBackfillAllOracleExcludedObjectsOracleSchemaArgsDict',
     'StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableArgs',
-    'StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableArgsDict',
     'StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnArgs',
-    'StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnArgsDict',
     'StreamBackfillAllPostgresqlExcludedObjectsArgs',
-    'StreamBackfillAllPostgresqlExcludedObjectsArgsDict',
     'StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArgs',
-    'StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArgsDict',
     'StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableArgs',
-    'StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableArgsDict',
     'StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs',
-    'StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgsDict',
     'StreamBackfillAllSqlServerExcludedObjectsArgs',
-    'StreamBackfillAllSqlServerExcludedObjectsArgsDict',
     'StreamBackfillAllSqlServerExcludedObjectsSchemaArgs',
-    'StreamBackfillAllSqlServerExcludedObjectsSchemaArgsDict',
     'StreamBackfillAllSqlServerExcludedObjectsSchemaTableArgs',
-    'StreamBackfillAllSqlServerExcludedObjectsSchemaTableArgsDict',
     'StreamBackfillAllSqlServerExcludedObjectsSchemaTableColumnArgs',
-    'StreamBackfillAllSqlServerExcludedObjectsSchemaTableColumnArgsDict',
     'StreamBackfillNoneArgs',
-    'StreamBackfillNoneArgsDict',
     'StreamDestinationConfigArgs',
-    'StreamDestinationConfigArgsDict',
     'StreamDestinationConfigBigqueryDestinationConfigArgs',
-    'StreamDestinationConfigBigqueryDestinationConfigArgsDict',
     'StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs',
-    'StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgsDict',
     'StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs',
-    'StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgsDict',
     'StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs',
-    'StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgsDict',
     'StreamDestinationConfigGcsDestinationConfigArgs',
-    'StreamDestinationConfigGcsDestinationConfigArgsDict',
     'StreamDestinationConfigGcsDestinationConfigAvroFileFormatArgs',
-    'StreamDestinationConfigGcsDestinationConfigAvroFileFormatArgsDict',
     'StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs',
-    'StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgsDict',
     'StreamSourceConfigArgs',
-    'StreamSourceConfigArgsDict',
     'StreamSourceConfigMysqlSourceConfigArgs',
-    'StreamSourceConfigMysqlSourceConfigArgsDict',
     'StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs',
-    'StreamSourceConfigMysqlSourceConfigExcludeObjectsArgsDict',
     'StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs',
-    'StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgsDict',
     'StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs',
-    'StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgsDict',
     'StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs',
-    'StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgsDict',
     'StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs',
-    'StreamSourceConfigMysqlSourceConfigIncludeObjectsArgsDict',
     'StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs',
-    'StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgsDict',
     'StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs',
-    'StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgsDict',
     'StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs',
-    'StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgsDict',
     'StreamSourceConfigOracleSourceConfigArgs',
-    'StreamSourceConfigOracleSourceConfigArgsDict',
     'StreamSourceConfigOracleSourceConfigDropLargeObjectsArgs',
-    'StreamSourceConfigOracleSourceConfigDropLargeObjectsArgsDict',
     'StreamSourceConfigOracleSourceConfigExcludeObjectsArgs',
-    'StreamSourceConfigOracleSourceConfigExcludeObjectsArgsDict',
     'StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs',
-    'StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgsDict',
     'StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs',
-    'StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgsDict',
     'StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs',
-    'StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgsDict',
     'StreamSourceConfigOracleSourceConfigIncludeObjectsArgs',
-    'StreamSourceConfigOracleSourceConfigIncludeObjectsArgsDict',
     'StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs',
-    'StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgsDict',
     'StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs',
-    'StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgsDict',
     'StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs',
-    'StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgsDict',
     'StreamSourceConfigOracleSourceConfigStreamLargeObjectsArgs',
-    'StreamSourceConfigOracleSourceConfigStreamLargeObjectsArgsDict',
     'StreamSourceConfigPostgresqlSourceConfigArgs',
-    'StreamSourceConfigPostgresqlSourceConfigArgsDict',
     'StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs',
-    'StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgsDict',
     'StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs',
-    'StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgsDict',
     'StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs',
-    'StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgsDict',
     'StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs',
-    'StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgsDict',
     'StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs',
-    'StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgsDict',
     'StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs',
-    'StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgsDict',
     'StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs',
-    'StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgsDict',
     'StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs',
-    'StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgsDict',
     'StreamSourceConfigSqlServerSourceConfigArgs',
-    'StreamSourceConfigSqlServerSourceConfigArgsDict',
     'StreamSourceConfigSqlServerSourceConfigExcludeObjectsArgs',
-    'StreamSourceConfigSqlServerSourceConfigExcludeObjectsArgsDict',
     'StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgs',
-    'StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgsDict',
     'StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgs',
-    'StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgsDict',
     'StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs',
-    'StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgsDict',
     'StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs',
-    'StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgsDict',
     'StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs',
-    'StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgsDict',
     'StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs',
-    'StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgsDict',
     'StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgs',
-    'StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgsDict',
 ]
 
-MYPY = False
-
-if not MYPY:
-    class ConnectionProfileBigqueryProfileArgsDict(TypedDict):
-        pass
-elif False:
-    ConnectionProfileBigqueryProfileArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ConnectionProfileBigqueryProfileArgs:
     def __init__(__self__):
         pass
 
 
-if not MYPY:
-    class ConnectionProfileForwardSshConnectivityArgsDict(TypedDict):
-        hostname: pulumi.Input[str]
-        """
-        Hostname for the SSH tunnel.
-        """
-        username: pulumi.Input[str]
-        """
-        Username for the SSH tunnel.
-        """
-        password: NotRequired[pulumi.Input[str]]
-        """
-        SSH password.
-        **Note**: This property is sensitive and will not be displayed in the plan.
-        """
-        port: NotRequired[pulumi.Input[int]]
-        """
-        Port for the SSH tunnel.
-        """
-        private_key: NotRequired[pulumi.Input[str]]
-        """
-        SSH private key.
-        **Note**: This property is sensitive and will not be displayed in the plan.
-        """
-elif False:
-    ConnectionProfileForwardSshConnectivityArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ConnectionProfileForwardSshConnectivityArgs:
     def __init__(__self__, *,
@@ -299,19 +183,6 @@ class ConnectionProfileForwardSshConnectivityArgs:
         pulumi.set(self, "private_key", value)
 
 
-if not MYPY:
-    class ConnectionProfileGcsProfileArgsDict(TypedDict):
-        bucket: pulumi.Input[str]
-        """
-        The Cloud Storage bucket name.
-        """
-        root_path: NotRequired[pulumi.Input[str]]
-        """
-        The root path inside the Cloud Storage bucket.
-        """
-elif False:
-    ConnectionProfileGcsProfileArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ConnectionProfileGcsProfileArgs:
     def __init__(__self__, *,
@@ -350,33 +221,6 @@ class ConnectionProfileGcsProfileArgs:
         pulumi.set(self, "root_path", value)
 
 
-if not MYPY:
-    class ConnectionProfileMysqlProfileArgsDict(TypedDict):
-        hostname: pulumi.Input[str]
-        """
-        Hostname for the MySQL connection.
-        """
-        password: pulumi.Input[str]
-        """
-        Password for the MySQL connection.
-        **Note**: This property is sensitive and will not be displayed in the plan.
-        """
-        username: pulumi.Input[str]
-        """
-        Username for the MySQL connection.
-        """
-        port: NotRequired[pulumi.Input[int]]
-        """
-        Port for the MySQL connection.
-        """
-        ssl_config: NotRequired[pulumi.Input['ConnectionProfileMysqlProfileSslConfigArgsDict']]
-        """
-        SSL configuration for the MySQL connection.
-        Structure is documented below.
-        """
-elif False:
-    ConnectionProfileMysqlProfileArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ConnectionProfileMysqlProfileArgs:
     def __init__(__self__, *,
@@ -465,47 +309,6 @@ class ConnectionProfileMysqlProfileArgs:
         pulumi.set(self, "ssl_config", value)
 
 
-if not MYPY:
-    class ConnectionProfileMysqlProfileSslConfigArgsDict(TypedDict):
-        ca_certificate: NotRequired[pulumi.Input[str]]
-        """
-        PEM-encoded certificate of the CA that signed the source database
-        server's certificate.
-        **Note**: This property is sensitive and will not be displayed in the plan.
-        """
-        ca_certificate_set: NotRequired[pulumi.Input[bool]]
-        """
-        (Output)
-        Indicates whether the clientKey field is set.
-        """
-        client_certificate: NotRequired[pulumi.Input[str]]
-        """
-        PEM-encoded certificate that will be used by the replica to
-        authenticate against the source database server. If this field
-        is used then the 'clientKey' and the 'caCertificate' fields are
-        mandatory.
-        **Note**: This property is sensitive and will not be displayed in the plan.
-        """
-        client_certificate_set: NotRequired[pulumi.Input[bool]]
-        """
-        (Output)
-        Indicates whether the clientCertificate field is set.
-        """
-        client_key: NotRequired[pulumi.Input[str]]
-        """
-        PEM-encoded private key associated with the Client Certificate.
-        If this field is used then the 'client_certificate' and the
-        'ca_certificate' fields are mandatory.
-        **Note**: This property is sensitive and will not be displayed in the plan.
-        """
-        client_key_set: NotRequired[pulumi.Input[bool]]
-        """
-        (Output)
-        Indicates whether the clientKey field is set.
-        """
-elif False:
-    ConnectionProfileMysqlProfileSslConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ConnectionProfileMysqlProfileSslConfigArgs:
     def __init__(__self__, *,
@@ -633,36 +436,6 @@ class ConnectionProfileMysqlProfileSslConfigArgs:
         pulumi.set(self, "client_key_set", value)
 
 
-if not MYPY:
-    class ConnectionProfileOracleProfileArgsDict(TypedDict):
-        database_service: pulumi.Input[str]
-        """
-        Database for the Oracle connection.
-        """
-        hostname: pulumi.Input[str]
-        """
-        Hostname for the Oracle connection.
-        """
-        password: pulumi.Input[str]
-        """
-        Password for the Oracle connection.
-        **Note**: This property is sensitive and will not be displayed in the plan.
-        """
-        username: pulumi.Input[str]
-        """
-        Username for the Oracle connection.
-        """
-        connection_attributes: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        """
-        Connection string attributes
-        """
-        port: NotRequired[pulumi.Input[int]]
-        """
-        Port for the Oracle connection.
-        """
-elif False:
-    ConnectionProfileOracleProfileArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ConnectionProfileOracleProfileArgs:
     def __init__(__self__, *,
@@ -764,32 +537,6 @@ class ConnectionProfileOracleProfileArgs:
         pulumi.set(self, "port", value)
 
 
-if not MYPY:
-    class ConnectionProfilePostgresqlProfileArgsDict(TypedDict):
-        database: pulumi.Input[str]
-        """
-        Database for the PostgreSQL connection.
-        """
-        hostname: pulumi.Input[str]
-        """
-        Hostname for the PostgreSQL connection.
-        """
-        password: pulumi.Input[str]
-        """
-        Password for the PostgreSQL connection.
-        **Note**: This property is sensitive and will not be displayed in the plan.
-        """
-        username: pulumi.Input[str]
-        """
-        Username for the PostgreSQL connection.
-        """
-        port: NotRequired[pulumi.Input[int]]
-        """
-        Port for the PostgreSQL connection.
-        """
-elif False:
-    ConnectionProfilePostgresqlProfileArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ConnectionProfilePostgresqlProfileArgs:
     def __init__(__self__, *,
@@ -875,15 +622,6 @@ class ConnectionProfilePostgresqlProfileArgs:
         pulumi.set(self, "port", value)
 
 
-if not MYPY:
-    class ConnectionProfilePrivateConnectivityArgsDict(TypedDict):
-        private_connection: pulumi.Input[str]
-        """
-        A reference to a private connection resource. Format: `projects/{project}/locations/{location}/privateConnections/{name}`
-        """
-elif False:
-    ConnectionProfilePrivateConnectivityArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ConnectionProfilePrivateConnectivityArgs:
     def __init__(__self__, *,
@@ -906,32 +644,6 @@ class ConnectionProfilePrivateConnectivityArgs:
         pulumi.set(self, "private_connection", value)
 
 
-if not MYPY:
-    class ConnectionProfileSqlServerProfileArgsDict(TypedDict):
-        database: pulumi.Input[str]
-        """
-        Database for the SQL Server connection.
-        """
-        hostname: pulumi.Input[str]
-        """
-        Hostname for the SQL Server connection.
-        """
-        password: pulumi.Input[str]
-        """
-        Password for the SQL Server connection.
-        **Note**: This property is sensitive and will not be displayed in the plan.
-        """
-        username: pulumi.Input[str]
-        """
-        Username for the SQL Server connection.
-        """
-        port: NotRequired[pulumi.Input[int]]
-        """
-        Port for the SQL Server connection.
-        """
-elif False:
-    ConnectionProfileSqlServerProfileArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class ConnectionProfileSqlServerProfileArgs:
     def __init__(__self__, *,
@@ -1017,19 +729,6 @@ class ConnectionProfileSqlServerProfileArgs:
         pulumi.set(self, "port", value)
 
 
-if not MYPY:
-    class PrivateConnectionErrorArgsDict(TypedDict):
-        details: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
-        """
-        A list of messages that carry the error details.
-        """
-        message: NotRequired[pulumi.Input[str]]
-        """
-        A message containing more information about the error that occurred.
-        """
-elif False:
-    PrivateConnectionErrorArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class PrivateConnectionErrorArgs:
     def __init__(__self__, *,
@@ -1069,22 +768,6 @@ class PrivateConnectionErrorArgs:
         pulumi.set(self, "message", value)
 
 
-if not MYPY:
-    class PrivateConnectionVpcPeeringConfigArgsDict(TypedDict):
-        subnet: pulumi.Input[str]
-        """
-        A free subnet for peering. (CIDR of /29)
-
-        - - -
-        """
-        vpc: pulumi.Input[str]
-        """
-        Fully qualified name of the VPC that Datastream will peer to.
-        Format: projects/{project}/global/{networks}/{name}
-        """
-elif False:
-    PrivateConnectionVpcPeeringConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class PrivateConnectionVpcPeeringConfigArgs:
     def __init__(__self__, *,
@@ -1128,31 +811,6 @@ class PrivateConnectionVpcPeeringConfigArgs:
         pulumi.set(self, "vpc", value)
 
 
-if not MYPY:
-    class StreamBackfillAllArgsDict(TypedDict):
-        mysql_excluded_objects: NotRequired[pulumi.Input['StreamBackfillAllMysqlExcludedObjectsArgsDict']]
-        """
-        MySQL data source objects to avoid backfilling.
-        Structure is documented below.
-        """
-        oracle_excluded_objects: NotRequired[pulumi.Input['StreamBackfillAllOracleExcludedObjectsArgsDict']]
-        """
-        PostgreSQL data source objects to avoid backfilling.
-        Structure is documented below.
-        """
-        postgresql_excluded_objects: NotRequired[pulumi.Input['StreamBackfillAllPostgresqlExcludedObjectsArgsDict']]
-        """
-        PostgreSQL data source objects to avoid backfilling.
-        Structure is documented below.
-        """
-        sql_server_excluded_objects: NotRequired[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsArgsDict']]
-        """
-        SQL Server data source objects to avoid backfilling.
-        Structure is documented below.
-        """
-elif False:
-    StreamBackfillAllArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillAllArgs:
     def __init__(__self__, *,
@@ -1232,16 +890,6 @@ class StreamBackfillAllArgs:
         pulumi.set(self, "sql_server_excluded_objects", value)
 
 
-if not MYPY:
-    class StreamBackfillAllMysqlExcludedObjectsArgsDict(TypedDict):
-        mysql_databases: pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseArgsDict']]]
-        """
-        MySQL databases on the server
-        Structure is documented below.
-        """
-elif False:
-    StreamBackfillAllMysqlExcludedObjectsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillAllMysqlExcludedObjectsArgs:
     def __init__(__self__, *,
@@ -1266,20 +914,6 @@ class StreamBackfillAllMysqlExcludedObjectsArgs:
         pulumi.set(self, "mysql_databases", value)
 
 
-if not MYPY:
-    class StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseArgsDict(TypedDict):
-        database: pulumi.Input[str]
-        """
-        Database name.
-        """
-        mysql_tables: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableArgsDict']]]]
-        """
-        Tables in the database.
-        Structure is documented below.
-        """
-elif False:
-    StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseArgs:
     def __init__(__self__, *,
@@ -1320,20 +954,6 @@ class StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseArgs:
         pulumi.set(self, "mysql_tables", value)
 
 
-if not MYPY:
-    class StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableArgsDict(TypedDict):
-        table: pulumi.Input[str]
-        """
-        Table name.
-        """
-        mysql_columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableMysqlColumnArgsDict']]]]
-        """
-        MySQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
-        Structure is documented below.
-        """
-elif False:
-    StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableArgs:
     def __init__(__self__, *,
@@ -1374,41 +994,6 @@ class StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableArgs:
         pulumi.set(self, "mysql_columns", value)
 
 
-if not MYPY:
-    class StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableMysqlColumnArgsDict(TypedDict):
-        collation: NotRequired[pulumi.Input[str]]
-        """
-        Column collation.
-        """
-        column: NotRequired[pulumi.Input[str]]
-        """
-        Column name.
-        """
-        data_type: NotRequired[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
-        """
-        length: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column length.
-        """
-        nullable: NotRequired[pulumi.Input[bool]]
-        """
-        Whether or not the column can accept a null value.
-        """
-        ordinal_position: NotRequired[pulumi.Input[int]]
-        """
-        The ordinal position of the column in the table.
-        """
-        primary_key: NotRequired[pulumi.Input[bool]]
-        """
-        Whether or not the column represents a primary key.
-        """
-elif False:
-    StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableMysqlColumnArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableMysqlColumnArgs:
     def __init__(__self__, *,
@@ -1532,16 +1117,6 @@ class StreamBackfillAllMysqlExcludedObjectsMysqlDatabaseMysqlTableMysqlColumnArg
         pulumi.set(self, "primary_key", value)
 
 
-if not MYPY:
-    class StreamBackfillAllOracleExcludedObjectsArgsDict(TypedDict):
-        oracle_schemas: pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllOracleExcludedObjectsOracleSchemaArgsDict']]]
-        """
-        Oracle schemas/databases in the database server
-        Structure is documented below.
-        """
-elif False:
-    StreamBackfillAllOracleExcludedObjectsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillAllOracleExcludedObjectsArgs:
     def __init__(__self__, *,
@@ -1566,20 +1141,6 @@ class StreamBackfillAllOracleExcludedObjectsArgs:
         pulumi.set(self, "oracle_schemas", value)
 
 
-if not MYPY:
-    class StreamBackfillAllOracleExcludedObjectsOracleSchemaArgsDict(TypedDict):
-        schema: pulumi.Input[str]
-        """
-        Schema name.
-        """
-        oracle_tables: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableArgsDict']]]]
-        """
-        Tables in the database.
-        Structure is documented below.
-        """
-elif False:
-    StreamBackfillAllOracleExcludedObjectsOracleSchemaArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillAllOracleExcludedObjectsOracleSchemaArgs:
     def __init__(__self__, *,
@@ -1620,20 +1181,6 @@ class StreamBackfillAllOracleExcludedObjectsOracleSchemaArgs:
         pulumi.set(self, "oracle_tables", value)
 
 
-if not MYPY:
-    class StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableArgsDict(TypedDict):
-        table: pulumi.Input[str]
-        """
-        Table name.
-        """
-        oracle_columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnArgsDict']]]]
-        """
-        Oracle columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
-        Structure is documented below.
-        """
-elif False:
-    StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableArgs:
     def __init__(__self__, *,
@@ -1674,67 +1221,18 @@ class StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableArgs:
         pulumi.set(self, "oracle_columns", value)
 
 
-if not MYPY:
-    class StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnArgsDict(TypedDict):
-        column: NotRequired[pulumi.Input[str]]
-        """
-        Column name.
-        """
-        data_type: NotRequired[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
-        """
-        encoding: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        Column encoding.
-        """
-        length: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column length.
-        """
-        nullable: NotRequired[pulumi.Input[bool]]
-        """
-        (Output)
-        Whether or not the column can accept a null value.
-        """
-        ordinal_position: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        The ordinal position of the column in the table.
-        """
-        precision: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column precision.
-        """
-        primary_key: NotRequired[pulumi.Input[bool]]
-        """
-        (Output)
-        Whether or not the column represents a primary key.
-        """
-        scale: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column scale.
-        """
-elif False:
-    StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnArgsDict: TypeAlias = Mapping[str, Any]
-
-@pulumi.input_type
-class StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnArgs:
-    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,
-                 precision: Optional[pulumi.Input[int]] = None,
-                 primary_key: Optional[pulumi.Input[bool]] = None,
-                 scale: Optional[pulumi.Input[int]] = None):
+@pulumi.input_type
+class StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnArgs:
+    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,
+                 precision: Optional[pulumi.Input[int]] = None,
+                 primary_key: Optional[pulumi.Input[bool]] = None,
+                 scale: Optional[pulumi.Input[int]] = None):
         """
         :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:
@@ -1890,16 +1388,6 @@ class StreamBackfillAllOracleExcludedObjectsOracleSchemaOracleTableOracleColumnA
         pulumi.set(self, "scale", value)
 
 
-if not MYPY:
-    class StreamBackfillAllPostgresqlExcludedObjectsArgsDict(TypedDict):
-        postgresql_schemas: pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArgsDict']]]
-        """
-        PostgreSQL schemas on the server
-        Structure is documented below.
-        """
-elif False:
-    StreamBackfillAllPostgresqlExcludedObjectsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillAllPostgresqlExcludedObjectsArgs:
     def __init__(__self__, *,
@@ -1924,20 +1412,6 @@ class StreamBackfillAllPostgresqlExcludedObjectsArgs:
         pulumi.set(self, "postgresql_schemas", value)
 
 
-if not MYPY:
-    class StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArgsDict(TypedDict):
-        schema: pulumi.Input[str]
-        """
-        Database name.
-        """
-        postgresql_tables: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableArgsDict']]]]
-        """
-        Tables in the schema.
-        Structure is documented below.
-        """
-elif False:
-    StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArgs:
     def __init__(__self__, *,
@@ -1978,20 +1452,6 @@ class StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaArgs:
         pulumi.set(self, "postgresql_tables", value)
 
 
-if not MYPY:
-    class StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableArgsDict(TypedDict):
-        table: pulumi.Input[str]
-        """
-        Table name.
-        """
-        postgresql_columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgsDict']]]]
-        """
-        PostgreSQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
-        Structure is documented below.
-        """
-elif False:
-    StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableArgs:
     def __init__(__self__, *,
@@ -2032,47 +1492,6 @@ class StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableA
         pulumi.set(self, "postgresql_columns", value)
 
 
-if not MYPY:
-    class StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgsDict(TypedDict):
-        column: NotRequired[pulumi.Input[str]]
-        """
-        Column name.
-        """
-        data_type: NotRequired[pulumi.Input[str]]
-        """
-        The PostgreSQL data type. Full data types list can be found here:
-        https://www.postgresql.org/docs/current/datatype.html
-        """
-        length: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column length.
-        """
-        nullable: NotRequired[pulumi.Input[bool]]
-        """
-        Whether or not the column can accept a null value.
-        """
-        ordinal_position: NotRequired[pulumi.Input[int]]
-        """
-        The ordinal position of the column in the table.
-        """
-        precision: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column precision.
-        """
-        primary_key: NotRequired[pulumi.Input[bool]]
-        """
-        Whether or not the column represents a primary key.
-        """
-        scale: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column scale.
-        """
-elif False:
-    StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs:
     def __init__(__self__, *,
@@ -2216,16 +1635,6 @@ class StreamBackfillAllPostgresqlExcludedObjectsPostgresqlSchemaPostgresqlTableP
         pulumi.set(self, "scale", value)
 
 
-if not MYPY:
-    class StreamBackfillAllSqlServerExcludedObjectsArgsDict(TypedDict):
-        schemas: pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsSchemaArgsDict']]]
-        """
-        SQL Server schemas/databases in the database server
-        Structure is documented below.
-        """
-elif False:
-    StreamBackfillAllSqlServerExcludedObjectsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillAllSqlServerExcludedObjectsArgs:
     def __init__(__self__, *,
@@ -2250,20 +1659,6 @@ class StreamBackfillAllSqlServerExcludedObjectsArgs:
         pulumi.set(self, "schemas", value)
 
 
-if not MYPY:
-    class StreamBackfillAllSqlServerExcludedObjectsSchemaArgsDict(TypedDict):
-        schema: pulumi.Input[str]
-        """
-        Schema name.
-        """
-        tables: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsSchemaTableArgsDict']]]]
-        """
-        Tables in the database.
-        Structure is documented below.
-        """
-elif False:
-    StreamBackfillAllSqlServerExcludedObjectsSchemaArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillAllSqlServerExcludedObjectsSchemaArgs:
     def __init__(__self__, *,
@@ -2304,20 +1699,6 @@ class StreamBackfillAllSqlServerExcludedObjectsSchemaArgs:
         pulumi.set(self, "tables", value)
 
 
-if not MYPY:
-    class StreamBackfillAllSqlServerExcludedObjectsSchemaTableArgsDict(TypedDict):
-        table: pulumi.Input[str]
-        """
-        Table name.
-        """
-        columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamBackfillAllSqlServerExcludedObjectsSchemaTableColumnArgsDict']]]]
-        """
-        SQL Server columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
-        Structure is documented below.
-        """
-elif False:
-    StreamBackfillAllSqlServerExcludedObjectsSchemaTableArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillAllSqlServerExcludedObjectsSchemaTableArgs:
     def __init__(__self__, *,
@@ -2358,50 +1739,6 @@ class StreamBackfillAllSqlServerExcludedObjectsSchemaTableArgs:
         pulumi.set(self, "columns", value)
 
 
-if not MYPY:
-    class StreamBackfillAllSqlServerExcludedObjectsSchemaTableColumnArgsDict(TypedDict):
-        column: NotRequired[pulumi.Input[str]]
-        """
-        Column name.
-        """
-        data_type: NotRequired[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
-        """
-        length: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column length.
-        """
-        nullable: NotRequired[pulumi.Input[bool]]
-        """
-        (Output)
-        Whether or not the column can accept a null value.
-        """
-        ordinal_position: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        The ordinal position of the column in the table.
-        """
-        precision: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column precision.
-        """
-        primary_key: NotRequired[pulumi.Input[bool]]
-        """
-        (Output)
-        Whether or not the column represents a primary key.
-        """
-        scale: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column scale.
-        """
-elif False:
-    StreamBackfillAllSqlServerExcludedObjectsSchemaTableColumnArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillAllSqlServerExcludedObjectsSchemaTableColumnArgs:
     def __init__(__self__, *,
@@ -2551,37 +1888,12 @@ class StreamBackfillAllSqlServerExcludedObjectsSchemaTableColumnArgs:
         pulumi.set(self, "scale", value)
 
 
-if not MYPY:
-    class StreamBackfillNoneArgsDict(TypedDict):
-        pass
-elif False:
-    StreamBackfillNoneArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamBackfillNoneArgs:
     def __init__(__self__):
         pass
 
 
-if not MYPY:
-    class StreamDestinationConfigArgsDict(TypedDict):
-        destination_connection_profile: pulumi.Input[str]
-        """
-        Destination connection profile resource. Format: projects/{project}/locations/{location}/connectionProfiles/{name}
-        """
-        bigquery_destination_config: NotRequired[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigArgsDict']]
-        """
-        A configuration for how data should be loaded to Cloud Storage.
-        Structure is documented below.
-        """
-        gcs_destination_config: NotRequired[pulumi.Input['StreamDestinationConfigGcsDestinationConfigArgsDict']]
-        """
-        A configuration for how data should be loaded to Cloud Storage.
-        Structure is documented below.
-        """
-elif False:
-    StreamDestinationConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamDestinationConfigArgs:
     def __init__(__self__, *,
@@ -2640,28 +1952,6 @@ class StreamDestinationConfigArgs:
         pulumi.set(self, "gcs_destination_config", value)
 
 
-if not MYPY:
-    class StreamDestinationConfigBigqueryDestinationConfigArgsDict(TypedDict):
-        data_freshness: NotRequired[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.
-        """
-        single_target_dataset: NotRequired[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgsDict']]
-        """
-        A single target dataset to which all data will be streamed.
-        Structure is documented below.
-        """
-        source_hierarchy_datasets: NotRequired[pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgsDict']]
-        """
-        Destination datasets are created so that hierarchy of the destination data objects matches the source hierarchy.
-        Structure is documented below.
-        """
-elif False:
-    StreamDestinationConfigBigqueryDestinationConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamDestinationConfigBigqueryDestinationConfigArgs:
     def __init__(__self__, *,
@@ -2727,16 +2017,6 @@ class StreamDestinationConfigBigqueryDestinationConfigArgs:
         pulumi.set(self, "source_hierarchy_datasets", value)
 
 
-if not MYPY:
-    class StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgsDict(TypedDict):
-        dataset_id: pulumi.Input[str]
-        """
-        Dataset ID in the format projects/{project}/datasets/{dataset_id} or
-        {project}:{dataset_id}
-        """
-elif False:
-    StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs:
     def __init__(__self__, *,
@@ -2761,16 +2041,6 @@ class StreamDestinationConfigBigqueryDestinationConfigSingleTargetDatasetArgs:
         pulumi.set(self, "dataset_id", value)
 
 
-if not MYPY:
-    class StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgsDict(TypedDict):
-        dataset_template: pulumi.Input['StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgsDict']
-        """
-        Dataset template used for dynamic dataset creation.
-        Structure is documented below.
-        """
-elif False:
-    StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArgs:
     def __init__(__self__, *,
@@ -2795,30 +2065,6 @@ class StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsArg
         pulumi.set(self, "dataset_template", value)
 
 
-if not MYPY:
-    class StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgsDict(TypedDict):
-        location: pulumi.Input[str]
-        """
-        The geographic location where the dataset should reside.
-        See https://cloud.google.com/bigquery/docs/locations for supported locations.
-        """
-        dataset_id_prefix: NotRequired[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. _.
-        """
-        kms_key_name: NotRequired[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.
-
-        - - -
-        """
-elif False:
-    StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDatasetTemplateArgs:
     def __init__(__self__, *,
@@ -2887,33 +2133,6 @@ class StreamDestinationConfigBigqueryDestinationConfigSourceHierarchyDatasetsDat
         pulumi.set(self, "kms_key_name", value)
 
 
-if not MYPY:
-    class StreamDestinationConfigGcsDestinationConfigArgsDict(TypedDict):
-        avro_file_format: NotRequired[pulumi.Input['StreamDestinationConfigGcsDestinationConfigAvroFileFormatArgsDict']]
-        """
-        AVRO file format configuration.
-        """
-        file_rotation_interval: NotRequired[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.
-        """
-        file_rotation_mb: NotRequired[pulumi.Input[int]]
-        """
-        The maximum file size to be saved in the bucket.
-        """
-        json_file_format: NotRequired[pulumi.Input['StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgsDict']]
-        """
-        JSON file format configuration.
-        Structure is documented below.
-        """
-        path: NotRequired[pulumi.Input[str]]
-        """
-        Path inside the Cloud Storage bucket to write data to.
-        """
-elif False:
-    StreamDestinationConfigGcsDestinationConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamDestinationConfigGcsDestinationConfigArgs:
     def __init__(__self__, *,
@@ -3005,33 +2224,12 @@ class StreamDestinationConfigGcsDestinationConfigArgs:
         pulumi.set(self, "path", value)
 
 
-if not MYPY:
-    class StreamDestinationConfigGcsDestinationConfigAvroFileFormatArgsDict(TypedDict):
-        pass
-elif False:
-    StreamDestinationConfigGcsDestinationConfigAvroFileFormatArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamDestinationConfigGcsDestinationConfigAvroFileFormatArgs:
     def __init__(__self__):
         pass
 
 
-if not MYPY:
-    class StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgsDict(TypedDict):
-        compression: NotRequired[pulumi.Input[str]]
-        """
-        Compression of the loaded JSON file.
-        Possible values are: `NO_COMPRESSION`, `GZIP`.
-        """
-        schema_file_format: NotRequired[pulumi.Input[str]]
-        """
-        The schema file format along JSON data files.
-        Possible values are: `NO_SCHEMA_FILE`, `AVRO_SCHEMA_FILE`.
-        """
-elif False:
-    StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs:
     def __init__(__self__, *,
@@ -3075,35 +2273,6 @@ class StreamDestinationConfigGcsDestinationConfigJsonFileFormatArgs:
         pulumi.set(self, "schema_file_format", value)
 
 
-if not MYPY:
-    class StreamSourceConfigArgsDict(TypedDict):
-        source_connection_profile: pulumi.Input[str]
-        """
-        Source connection profile resource. Format: projects/{project}/locations/{location}/connectionProfiles/{name}
-        """
-        mysql_source_config: NotRequired[pulumi.Input['StreamSourceConfigMysqlSourceConfigArgsDict']]
-        """
-        MySQL data source configuration.
-        Structure is documented below.
-        """
-        oracle_source_config: NotRequired[pulumi.Input['StreamSourceConfigOracleSourceConfigArgsDict']]
-        """
-        MySQL data source configuration.
-        Structure is documented below.
-        """
-        postgresql_source_config: NotRequired[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigArgsDict']]
-        """
-        PostgreSQL data source configuration.
-        Structure is documented below.
-        """
-        sql_server_source_config: NotRequired[pulumi.Input['StreamSourceConfigSqlServerSourceConfigArgsDict']]
-        """
-        SQL Server data source configuration.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigArgs:
     def __init__(__self__, *,
@@ -3198,31 +2367,6 @@ class StreamSourceConfigArgs:
         pulumi.set(self, "sql_server_source_config", value)
 
 
-if not MYPY:
-    class StreamSourceConfigMysqlSourceConfigArgsDict(TypedDict):
-        exclude_objects: NotRequired[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsArgsDict']]
-        """
-        MySQL objects to exclude from the stream.
-        Structure is documented below.
-        """
-        include_objects: NotRequired[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsArgsDict']]
-        """
-        MySQL objects to retrieve from the source.
-        Structure is documented below.
-        """
-        max_concurrent_backfill_tasks: NotRequired[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.
-        """
-        max_concurrent_cdc_tasks: NotRequired[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.
-        """
-elif False:
-    StreamSourceConfigMysqlSourceConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigMysqlSourceConfigArgs:
     def __init__(__self__, *,
@@ -3302,16 +2446,6 @@ class StreamSourceConfigMysqlSourceConfigArgs:
         pulumi.set(self, "max_concurrent_cdc_tasks", value)
 
 
-if not MYPY:
-    class StreamSourceConfigMysqlSourceConfigExcludeObjectsArgsDict(TypedDict):
-        mysql_databases: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgsDict']]]
-        """
-        MySQL databases on the server
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigMysqlSourceConfigExcludeObjectsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs:
     def __init__(__self__, *,
@@ -3336,20 +2470,6 @@ class StreamSourceConfigMysqlSourceConfigExcludeObjectsArgs:
         pulumi.set(self, "mysql_databases", value)
 
 
-if not MYPY:
-    class StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgsDict(TypedDict):
-        database: pulumi.Input[str]
-        """
-        Database name.
-        """
-        mysql_tables: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgsDict']]]]
-        """
-        Tables in the database.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs:
     def __init__(__self__, *,
@@ -3390,20 +2510,6 @@ class StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseArgs:
         pulumi.set(self, "mysql_tables", value)
 
 
-if not MYPY:
-    class StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgsDict(TypedDict):
-        table: pulumi.Input[str]
-        """
-        Table name.
-        """
-        mysql_columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgsDict']]]]
-        """
-        MySQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableArgs:
     def __init__(__self__, *,
@@ -3444,41 +2550,6 @@ class StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableAr
         pulumi.set(self, "mysql_columns", value)
 
 
-if not MYPY:
-    class StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgsDict(TypedDict):
-        collation: NotRequired[pulumi.Input[str]]
-        """
-        Column collation.
-        """
-        column: NotRequired[pulumi.Input[str]]
-        """
-        Column name.
-        """
-        data_type: NotRequired[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
-        """
-        length: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column length.
-        """
-        nullable: NotRequired[pulumi.Input[bool]]
-        """
-        Whether or not the column can accept a null value.
-        """
-        ordinal_position: NotRequired[pulumi.Input[int]]
-        """
-        The ordinal position of the column in the table.
-        """
-        primary_key: NotRequired[pulumi.Input[bool]]
-        """
-        Whether or not the column represents a primary key.
-        """
-elif False:
-    StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs:
     def __init__(__self__, *,
@@ -3602,16 +2673,6 @@ class StreamSourceConfigMysqlSourceConfigExcludeObjectsMysqlDatabaseMysqlTableMy
         pulumi.set(self, "primary_key", value)
 
 
-if not MYPY:
-    class StreamSourceConfigMysqlSourceConfigIncludeObjectsArgsDict(TypedDict):
-        mysql_databases: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgsDict']]]
-        """
-        MySQL databases on the server
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigMysqlSourceConfigIncludeObjectsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs:
     def __init__(__self__, *,
@@ -3636,20 +2697,6 @@ class StreamSourceConfigMysqlSourceConfigIncludeObjectsArgs:
         pulumi.set(self, "mysql_databases", value)
 
 
-if not MYPY:
-    class StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgsDict(TypedDict):
-        database: pulumi.Input[str]
-        """
-        Database name.
-        """
-        mysql_tables: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgsDict']]]]
-        """
-        Tables in the database.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs:
     def __init__(__self__, *,
@@ -3690,20 +2737,6 @@ class StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseArgs:
         pulumi.set(self, "mysql_tables", value)
 
 
-if not MYPY:
-    class StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgsDict(TypedDict):
-        table: pulumi.Input[str]
-        """
-        Table name.
-        """
-        mysql_columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgsDict']]]]
-        """
-        MySQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableArgs:
     def __init__(__self__, *,
@@ -3744,41 +2777,6 @@ class StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableAr
         pulumi.set(self, "mysql_columns", value)
 
 
-if not MYPY:
-    class StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgsDict(TypedDict):
-        collation: NotRequired[pulumi.Input[str]]
-        """
-        Column collation.
-        """
-        column: NotRequired[pulumi.Input[str]]
-        """
-        Column name.
-        """
-        data_type: NotRequired[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
-        """
-        length: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column length.
-        """
-        nullable: NotRequired[pulumi.Input[bool]]
-        """
-        Whether or not the column can accept a null value.
-        """
-        ordinal_position: NotRequired[pulumi.Input[int]]
-        """
-        The ordinal position of the column in the table.
-        """
-        primary_key: NotRequired[pulumi.Input[bool]]
-        """
-        Whether or not the column represents a primary key.
-        """
-elif False:
-    StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMysqlColumnArgs:
     def __init__(__self__, *,
@@ -3902,39 +2900,6 @@ class StreamSourceConfigMysqlSourceConfigIncludeObjectsMysqlDatabaseMysqlTableMy
         pulumi.set(self, "primary_key", value)
 
 
-if not MYPY:
-    class StreamSourceConfigOracleSourceConfigArgsDict(TypedDict):
-        drop_large_objects: NotRequired[pulumi.Input['StreamSourceConfigOracleSourceConfigDropLargeObjectsArgsDict']]
-        """
-        Configuration to drop large object values.
-        """
-        exclude_objects: NotRequired[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsArgsDict']]
-        """
-        Oracle objects to exclude from the stream.
-        Structure is documented below.
-        """
-        include_objects: NotRequired[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsArgsDict']]
-        """
-        Oracle objects to retrieve from the source.
-        Structure is documented below.
-        """
-        max_concurrent_backfill_tasks: NotRequired[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.
-        """
-        max_concurrent_cdc_tasks: NotRequired[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.
-        """
-        stream_large_objects: NotRequired[pulumi.Input['StreamSourceConfigOracleSourceConfigStreamLargeObjectsArgsDict']]
-        """
-        Configuration to drop large object values.
-        """
-elif False:
-    StreamSourceConfigOracleSourceConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigOracleSourceConfigArgs:
     def __init__(__self__, *,
@@ -4046,28 +3011,12 @@ class StreamSourceConfigOracleSourceConfigArgs:
         pulumi.set(self, "stream_large_objects", value)
 
 
-if not MYPY:
-    class StreamSourceConfigOracleSourceConfigDropLargeObjectsArgsDict(TypedDict):
-        pass
-elif False:
-    StreamSourceConfigOracleSourceConfigDropLargeObjectsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigOracleSourceConfigDropLargeObjectsArgs:
     def __init__(__self__):
         pass
 
 
-if not MYPY:
-    class StreamSourceConfigOracleSourceConfigExcludeObjectsArgsDict(TypedDict):
-        oracle_schemas: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgsDict']]]
-        """
-        Oracle schemas/databases in the database server
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigOracleSourceConfigExcludeObjectsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigOracleSourceConfigExcludeObjectsArgs:
     def __init__(__self__, *,
@@ -4092,20 +3041,6 @@ class StreamSourceConfigOracleSourceConfigExcludeObjectsArgs:
         pulumi.set(self, "oracle_schemas", value)
 
 
-if not MYPY:
-    class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgsDict(TypedDict):
-        schema: pulumi.Input[str]
-        """
-        Schema name.
-        """
-        oracle_tables: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgsDict']]]]
-        """
-        Tables in the database.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs:
     def __init__(__self__, *,
@@ -4146,20 +3081,6 @@ class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaArgs:
         pulumi.set(self, "oracle_tables", value)
 
 
-if not MYPY:
-    class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgsDict(TypedDict):
-        table: pulumi.Input[str]
-        """
-        Table name.
-        """
-        oracle_columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgsDict']]]]
-        """
-        Oracle columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableArgs:
     def __init__(__self__, *,
@@ -4200,55 +3121,6 @@ class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableA
         pulumi.set(self, "oracle_columns", value)
 
 
-if not MYPY:
-    class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgsDict(TypedDict):
-        column: NotRequired[pulumi.Input[str]]
-        """
-        Column name.
-        """
-        data_type: NotRequired[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
-        """
-        encoding: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        Column encoding.
-        """
-        length: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column length.
-        """
-        nullable: NotRequired[pulumi.Input[bool]]
-        """
-        (Output)
-        Whether or not the column can accept a null value.
-        """
-        ordinal_position: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        The ordinal position of the column in the table.
-        """
-        precision: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column precision.
-        """
-        primary_key: NotRequired[pulumi.Input[bool]]
-        """
-        (Output)
-        Whether or not the column represents a primary key.
-        """
-        scale: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column scale.
-        """
-elif False:
-    StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableOracleColumnArgs:
     def __init__(__self__, *,
@@ -4416,16 +3288,6 @@ class StreamSourceConfigOracleSourceConfigExcludeObjectsOracleSchemaOracleTableO
         pulumi.set(self, "scale", value)
 
 
-if not MYPY:
-    class StreamSourceConfigOracleSourceConfigIncludeObjectsArgsDict(TypedDict):
-        oracle_schemas: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgsDict']]]
-        """
-        Oracle schemas/databases in the database server
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigOracleSourceConfigIncludeObjectsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigOracleSourceConfigIncludeObjectsArgs:
     def __init__(__self__, *,
@@ -4450,20 +3312,6 @@ class StreamSourceConfigOracleSourceConfigIncludeObjectsArgs:
         pulumi.set(self, "oracle_schemas", value)
 
 
-if not MYPY:
-    class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgsDict(TypedDict):
-        schema: pulumi.Input[str]
-        """
-        Schema name.
-        """
-        oracle_tables: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgsDict']]]]
-        """
-        Tables in the database.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs:
     def __init__(__self__, *,
@@ -4504,20 +3352,6 @@ class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaArgs:
         pulumi.set(self, "oracle_tables", value)
 
 
-if not MYPY:
-    class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgsDict(TypedDict):
-        table: pulumi.Input[str]
-        """
-        Table name.
-        """
-        oracle_columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgsDict']]]]
-        """
-        Oracle columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableArgs:
     def __init__(__self__, *,
@@ -4545,67 +3379,18 @@ class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableA
         pulumi.set(self, "table", value)
 
     @property
-    @pulumi.getter(name="oracleColumns")
-    def oracle_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs']]]]:
-        """
-        Oracle 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")
-
-    @oracle_columns.setter
-    def oracle_columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs']]]]):
-        pulumi.set(self, "oracle_columns", value)
-
-
-if not MYPY:
-    class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgsDict(TypedDict):
-        column: NotRequired[pulumi.Input[str]]
-        """
-        Column name.
-        """
-        data_type: NotRequired[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
-        """
-        encoding: NotRequired[pulumi.Input[str]]
-        """
-        (Output)
-        Column encoding.
-        """
-        length: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column length.
-        """
-        nullable: NotRequired[pulumi.Input[bool]]
-        """
-        (Output)
-        Whether or not the column can accept a null value.
-        """
-        ordinal_position: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        The ordinal position of the column in the table.
-        """
-        precision: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column precision.
-        """
-        primary_key: NotRequired[pulumi.Input[bool]]
-        """
-        (Output)
-        Whether or not the column represents a primary key.
-        """
-        scale: NotRequired[pulumi.Input[int]]
+    @pulumi.getter(name="oracleColumns")
+    def oracle_columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs']]]]:
         """
-        (Output)
-        Column scale.
+        Oracle columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
+        Structure is documented below.
         """
-elif False:
-    StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgsDict: TypeAlias = Mapping[str, Any]
+        return pulumi.get(self, "oracle_columns")
+
+    @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 StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableOracleColumnArgs:
@@ -4774,48 +3559,12 @@ class StreamSourceConfigOracleSourceConfigIncludeObjectsOracleSchemaOracleTableO
         pulumi.set(self, "scale", value)
 
 
-if not MYPY:
-    class StreamSourceConfigOracleSourceConfigStreamLargeObjectsArgsDict(TypedDict):
-        pass
-elif False:
-    StreamSourceConfigOracleSourceConfigStreamLargeObjectsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigOracleSourceConfigStreamLargeObjectsArgs:
     def __init__(__self__):
         pass
 
 
-if not MYPY:
-    class StreamSourceConfigPostgresqlSourceConfigArgsDict(TypedDict):
-        publication: pulumi.Input[str]
-        """
-        The name of the publication that includes the set of all tables
-        that are defined in the stream's include_objects.
-        """
-        replication_slot: pulumi.Input[str]
-        """
-        The name of the logical replication slot that's configured with
-        the pgoutput plugin.
-        """
-        exclude_objects: NotRequired[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgsDict']]
-        """
-        PostgreSQL objects to exclude from the stream.
-        Structure is documented below.
-        """
-        include_objects: NotRequired[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgsDict']]
-        """
-        PostgreSQL objects to retrieve from the source.
-        Structure is documented below.
-        """
-        max_concurrent_backfill_tasks: NotRequired[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.
-        """
-elif False:
-    StreamSourceConfigPostgresqlSourceConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigPostgresqlSourceConfigArgs:
     def __init__(__self__, *,
@@ -4911,16 +3660,6 @@ class StreamSourceConfigPostgresqlSourceConfigArgs:
         pulumi.set(self, "max_concurrent_backfill_tasks", value)
 
 
-if not MYPY:
-    class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgsDict(TypedDict):
-        postgresql_schemas: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgsDict']]]
-        """
-        PostgreSQL schemas on the server
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs:
     def __init__(__self__, *,
@@ -4945,20 +3684,6 @@ class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsArgs:
         pulumi.set(self, "postgresql_schemas", value)
 
 
-if not MYPY:
-    class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgsDict(TypedDict):
-        schema: pulumi.Input[str]
-        """
-        Database name.
-        """
-        postgresql_tables: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgsDict']]]]
-        """
-        Tables in the schema.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs:
     def __init__(__self__, *,
@@ -4999,20 +3724,6 @@ class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaArgs
         pulumi.set(self, "postgresql_tables", value)
 
 
-if not MYPY:
-    class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgsDict(TypedDict):
-        table: pulumi.Input[str]
-        """
-        Table name.
-        """
-        postgresql_columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgsDict']]]]
-        """
-        PostgreSQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTableArgs:
     def __init__(__self__, *,
@@ -5053,47 +3764,6 @@ class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPost
         pulumi.set(self, "postgresql_columns", value)
 
 
-if not MYPY:
-    class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgsDict(TypedDict):
-        column: NotRequired[pulumi.Input[str]]
-        """
-        Column name.
-        """
-        data_type: NotRequired[pulumi.Input[str]]
-        """
-        The PostgreSQL data type. Full data types list can be found here:
-        https://www.postgresql.org/docs/current/datatype.html
-        """
-        length: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column length.
-        """
-        nullable: NotRequired[pulumi.Input[bool]]
-        """
-        Whether or not the column can accept a null value.
-        """
-        ordinal_position: NotRequired[pulumi.Input[int]]
-        """
-        The ordinal position of the column in the table.
-        """
-        precision: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column precision.
-        """
-        primary_key: NotRequired[pulumi.Input[bool]]
-        """
-        Whether or not the column represents a primary key.
-        """
-        scale: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column scale.
-        """
-elif False:
-    StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs:
     def __init__(__self__, *,
@@ -5237,16 +3907,6 @@ class StreamSourceConfigPostgresqlSourceConfigExcludeObjectsPostgresqlSchemaPost
         pulumi.set(self, "scale", value)
 
 
-if not MYPY:
-    class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgsDict(TypedDict):
-        postgresql_schemas: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgsDict']]]
-        """
-        PostgreSQL schemas on the server
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs:
     def __init__(__self__, *,
@@ -5271,20 +3931,6 @@ class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsArgs:
         pulumi.set(self, "postgresql_schemas", value)
 
 
-if not MYPY:
-    class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgsDict(TypedDict):
-        schema: pulumi.Input[str]
-        """
-        Database name.
-        """
-        postgresql_tables: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgsDict']]]]
-        """
-        Tables in the schema.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs:
     def __init__(__self__, *,
@@ -5325,20 +3971,6 @@ class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaArgs
         pulumi.set(self, "postgresql_tables", value)
 
 
-if not MYPY:
-    class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgsDict(TypedDict):
-        table: pulumi.Input[str]
-        """
-        Table name.
-        """
-        postgresql_columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgsDict']]]]
-        """
-        PostgreSQL columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTableArgs:
     def __init__(__self__, *,
@@ -5379,47 +4011,6 @@ class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPost
         pulumi.set(self, "postgresql_columns", value)
 
 
-if not MYPY:
-    class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgsDict(TypedDict):
-        column: NotRequired[pulumi.Input[str]]
-        """
-        Column name.
-        """
-        data_type: NotRequired[pulumi.Input[str]]
-        """
-        The PostgreSQL data type. Full data types list can be found here:
-        https://www.postgresql.org/docs/current/datatype.html
-        """
-        length: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column length.
-        """
-        nullable: NotRequired[pulumi.Input[bool]]
-        """
-        Whether or not the column can accept a null value.
-        """
-        ordinal_position: NotRequired[pulumi.Input[int]]
-        """
-        The ordinal position of the column in the table.
-        """
-        precision: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column precision.
-        """
-        primary_key: NotRequired[pulumi.Input[bool]]
-        """
-        Whether or not the column represents a primary key.
-        """
-        scale: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column scale.
-        """
-elif False:
-    StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPostgresqlTablePostgresqlColumnArgs:
     def __init__(__self__, *,
@@ -5563,29 +4154,6 @@ class StreamSourceConfigPostgresqlSourceConfigIncludeObjectsPostgresqlSchemaPost
         pulumi.set(self, "scale", value)
 
 
-if not MYPY:
-    class StreamSourceConfigSqlServerSourceConfigArgsDict(TypedDict):
-        exclude_objects: NotRequired[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsArgsDict']]
-        """
-        SQL Server objects to exclude from the stream.
-        Structure is documented below.
-        """
-        include_objects: NotRequired[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgsDict']]
-        """
-        SQL Server objects to retrieve from the source.
-        Structure is documented below.
-        """
-        max_concurrent_backfill_tasks: NotRequired[pulumi.Input[int]]
-        """
-        Max concurrent backfill tasks.
-        """
-        max_concurrent_cdc_tasks: NotRequired[pulumi.Input[int]]
-        """
-        Max concurrent CDC tasks.
-        """
-elif False:
-    StreamSourceConfigSqlServerSourceConfigArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigSqlServerSourceConfigArgs:
     def __init__(__self__, *,
@@ -5661,16 +4229,6 @@ class StreamSourceConfigSqlServerSourceConfigArgs:
         pulumi.set(self, "max_concurrent_cdc_tasks", value)
 
 
-if not MYPY:
-    class StreamSourceConfigSqlServerSourceConfigExcludeObjectsArgsDict(TypedDict):
-        schemas: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgsDict']]]
-        """
-        SQL Server schemas/databases in the database server
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigSqlServerSourceConfigExcludeObjectsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigSqlServerSourceConfigExcludeObjectsArgs:
     def __init__(__self__, *,
@@ -5695,20 +4253,6 @@ class StreamSourceConfigSqlServerSourceConfigExcludeObjectsArgs:
         pulumi.set(self, "schemas", value)
 
 
-if not MYPY:
-    class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgsDict(TypedDict):
-        schema: pulumi.Input[str]
-        """
-        Schema name.
-        """
-        tables: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgsDict']]]]
-        """
-        Tables in the database.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgs:
     def __init__(__self__, *,
@@ -5749,20 +4293,6 @@ class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaArgs:
         pulumi.set(self, "tables", value)
 
 
-if not MYPY:
-    class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgsDict(TypedDict):
-        table: pulumi.Input[str]
-        """
-        Table name.
-        """
-        columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgsDict']]]]
-        """
-        SQL Server columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgs:
     def __init__(__self__, *,
@@ -5803,50 +4333,6 @@ class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableArgs:
         pulumi.set(self, "columns", value)
 
 
-if not MYPY:
-    class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgsDict(TypedDict):
-        column: NotRequired[pulumi.Input[str]]
-        """
-        Column name.
-        """
-        data_type: NotRequired[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
-        """
-        length: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column length.
-        """
-        nullable: NotRequired[pulumi.Input[bool]]
-        """
-        (Output)
-        Whether or not the column can accept a null value.
-        """
-        ordinal_position: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        The ordinal position of the column in the table.
-        """
-        precision: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column precision.
-        """
-        primary_key: NotRequired[pulumi.Input[bool]]
-        """
-        (Output)
-        Whether or not the column represents a primary key.
-        """
-        scale: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column scale.
-        """
-elif False:
-    StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs:
     def __init__(__self__, *,
@@ -5996,16 +4482,6 @@ class StreamSourceConfigSqlServerSourceConfigExcludeObjectsSchemaTableColumnArgs
         pulumi.set(self, "scale", value)
 
 
-if not MYPY:
-    class StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgsDict(TypedDict):
-        schemas: pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgsDict']]]
-        """
-        SQL Server schemas/databases in the database server
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs:
     def __init__(__self__, *,
@@ -6030,20 +4506,6 @@ class StreamSourceConfigSqlServerSourceConfigIncludeObjectsArgs:
         pulumi.set(self, "schemas", value)
 
 
-if not MYPY:
-    class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgsDict(TypedDict):
-        schema: pulumi.Input[str]
-        """
-        Schema name.
-        """
-        tables: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgsDict']]]]
-        """
-        Tables in the database.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs:
     def __init__(__self__, *,
@@ -6084,20 +4546,6 @@ class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaArgs:
         pulumi.set(self, "tables", value)
 
 
-if not MYPY:
-    class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgsDict(TypedDict):
-        table: pulumi.Input[str]
-        """
-        Table name.
-        """
-        columns: NotRequired[pulumi.Input[Sequence[pulumi.Input['StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgsDict']]]]
-        """
-        SQL Server columns in the schema. When unspecified as part of include/exclude objects, includes/excludes everything.
-        Structure is documented below.
-        """
-elif False:
-    StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs:
     def __init__(__self__, *,
@@ -6138,50 +4586,6 @@ class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableArgs:
         pulumi.set(self, "columns", value)
 
 
-if not MYPY:
-    class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgsDict(TypedDict):
-        column: NotRequired[pulumi.Input[str]]
-        """
-        Column name.
-        """
-        data_type: NotRequired[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
-        """
-        length: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column length.
-        """
-        nullable: NotRequired[pulumi.Input[bool]]
-        """
-        (Output)
-        Whether or not the column can accept a null value.
-        """
-        ordinal_position: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        The ordinal position of the column in the table.
-        """
-        precision: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column precision.
-        """
-        primary_key: NotRequired[pulumi.Input[bool]]
-        """
-        (Output)
-        Whether or not the column represents a primary key.
-        """
-        scale: NotRequired[pulumi.Input[int]]
-        """
-        (Output)
-        Column scale.
-        """
-elif False:
-    StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgsDict: TypeAlias = Mapping[str, Any]
-
 @pulumi.input_type
 class StreamSourceConfigSqlServerSourceConfigIncludeObjectsSchemaTableColumnArgs:
     def __init__(__self__, *,