@aws-sdk/client-glue 3.85.0 → 3.93.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -39,6 +39,49 @@ export declare namespace Action {
     
     const filterSensitiveLog: (obj: Action) => any;
 }
+export declare enum AggFunction {
+    avg = "avg",
+    count = "count",
+    countDistinct = "countDistinct",
+    first = "first",
+    kurtosis = "kurtosis",
+    last = "last",
+    max = "max",
+    min = "min",
+    skewness = "skewness",
+    stddev_pop = "stddev_pop",
+    stddev_samp = "stddev_samp",
+    sum = "sum",
+    sumDistinct = "sumDistinct",
+    var_pop = "var_pop",
+    var_samp = "var_samp"
+}
+
+export interface AggregateOperation {
+    
+    Column: string[] | undefined;
+    
+    AggFunc: AggFunction | string | undefined;
+}
+export declare namespace AggregateOperation {
+    
+    const filterSensitiveLog: (obj: AggregateOperation) => any;
+}
+
+export interface Aggregate {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    Groups: string[][] | undefined;
+    
+    Aggs: AggregateOperation[] | undefined;
+}
+export declare namespace Aggregate {
+    
+    const filterSensitiveLog: (obj: Aggregate) => any;
+}
 
 export declare class AlreadyExistsException extends __BaseException {
     readonly name: "AlreadyExistsException";
@@ -49,6 +92,47 @@ export declare class AlreadyExistsException extends __BaseException {
     constructor(opts: __ExceptionOptionType<AlreadyExistsException, __BaseException>);
 }
 
+export interface GlueStudioSchemaColumn {
+    
+    Name: string | undefined;
+    
+    Type?: string;
+}
+export declare namespace GlueStudioSchemaColumn {
+    
+    const filterSensitiveLog: (obj: GlueStudioSchemaColumn) => any;
+}
+
+export interface GlueSchema {
+    
+    Columns?: GlueStudioSchemaColumn[];
+}
+export declare namespace GlueSchema {
+    
+    const filterSensitiveLog: (obj: GlueSchema) => any;
+}
+
+export interface AthenaConnectorSource {
+    
+    Name: string | undefined;
+    
+    ConnectionName: string | undefined;
+    
+    ConnectorName: string | undefined;
+    
+    ConnectionType: string | undefined;
+    
+    ConnectionTable?: string;
+    
+    SchemaName: string | undefined;
+    
+    OutputSchemas?: GlueSchema[];
+}
+export declare namespace AthenaConnectorSource {
+    
+    const filterSensitiveLog: (obj: AthenaConnectorSource) => any;
+}
+
 export interface AuditContext {
     
     AdditionalAuditContext?: string;
@@ -889,96 +973,1258 @@ export declare namespace BatchGetJobsRequest {
     const filterSensitiveLog: (obj: BatchGetJobsRequest) => any;
 }
 
-export interface JobCommand {
+export interface StreamingDataPreviewOptions {
     
-    Name?: string;
+    PollingTime?: number;
     
-    ScriptLocation?: string;
+    RecordPollingLimit?: number;
+}
+export declare namespace StreamingDataPreviewOptions {
     
-    PythonVersion?: string;
+    const filterSensitiveLog: (obj: StreamingDataPreviewOptions) => any;
 }
-export declare namespace JobCommand {
+
+export interface KafkaStreamingSourceOptions {
     
-    const filterSensitiveLog: (obj: JobCommand) => any;
+    BootstrapServers?: string;
+    
+    SecurityProtocol?: string;
+    
+    ConnectionName?: string;
+    
+    TopicName?: string;
+    
+    Assign?: string;
+    
+    SubscribePattern?: string;
+    
+    Classification?: string;
+    
+    Delimiter?: string;
+    
+    StartingOffsets?: string;
+    
+    EndingOffsets?: string;
+    
+    PollTimeoutMs?: number;
+    
+    NumRetries?: number;
+    
+    RetryIntervalMs?: number;
+    
+    MaxOffsetsPerTrigger?: number;
+    
+    MinPartitions?: number;
+}
+export declare namespace KafkaStreamingSourceOptions {
+    
+    const filterSensitiveLog: (obj: KafkaStreamingSourceOptions) => any;
 }
 
-export interface ConnectionsList {
+export interface CatalogKafkaSource {
     
-    Connections?: string[];
+    Name: string | undefined;
+    
+    WindowSize?: number;
+    
+    DetectSchema?: boolean;
+    
+    Table: string | undefined;
+    
+    Database: string | undefined;
+    
+    StreamingOptions?: KafkaStreamingSourceOptions;
+    
+    DataPreviewOptions?: StreamingDataPreviewOptions;
 }
-export declare namespace ConnectionsList {
+export declare namespace CatalogKafkaSource {
     
-    const filterSensitiveLog: (obj: ConnectionsList) => any;
+    const filterSensitiveLog: (obj: CatalogKafkaSource) => any;
+}
+export declare enum StartingPosition {
+    EARLIEST = "earliest",
+    LATEST = "latest",
+    TRIM_HORIZON = "trim_horizon"
 }
 
-export interface ExecutionProperty {
+export interface KinesisStreamingSourceOptions {
     
-    MaxConcurrentRuns?: number;
+    EndpointUrl?: string;
+    
+    StreamName?: string;
+    
+    Classification?: string;
+    
+    Delimiter?: string;
+    
+    StartingPosition?: StartingPosition | string;
+    
+    MaxFetchTimeInMs?: number;
+    
+    MaxFetchRecordsPerShard?: number;
+    
+    MaxRecordPerRead?: number;
+    
+    AddIdleTimeBetweenReads?: boolean;
+    
+    IdleTimeBetweenReadsInMs?: number;
+    
+    DescribeShardInterval?: number;
+    
+    NumRetries?: number;
+    
+    RetryIntervalMs?: number;
+    
+    MaxRetryIntervalMs?: number;
+    
+    AvoidEmptyBatches?: boolean;
+    
+    StreamArn?: string;
+    
+    RoleArn?: string;
+    
+    RoleSessionName?: string;
 }
-export declare namespace ExecutionProperty {
+export declare namespace KinesisStreamingSourceOptions {
     
-    const filterSensitiveLog: (obj: ExecutionProperty) => any;
+    const filterSensitiveLog: (obj: KinesisStreamingSourceOptions) => any;
 }
 
-export interface Job {
+export interface CatalogKinesisSource {
     
-    Name?: string;
+    Name: string | undefined;
     
-    Description?: string;
+    WindowSize?: number;
     
-    LogUri?: string;
+    DetectSchema?: boolean;
     
-    Role?: string;
+    Table: string | undefined;
     
-    CreatedOn?: Date;
+    Database: string | undefined;
     
-    LastModifiedOn?: Date;
+    StreamingOptions?: KinesisStreamingSourceOptions;
     
-    ExecutionProperty?: ExecutionProperty;
+    DataPreviewOptions?: StreamingDataPreviewOptions;
+}
+export declare namespace CatalogKinesisSource {
     
-    Command?: JobCommand;
+    const filterSensitiveLog: (obj: CatalogKinesisSource) => any;
+}
+
+export interface CatalogSource {
     
-    DefaultArguments?: {
-        [key: string]: string;
-    };
+    Name: string | undefined;
     
-    NonOverridableArguments?: {
-        [key: string]: string;
-    };
+    Database: string | undefined;
     
-    Connections?: ConnectionsList;
+    Table: string | undefined;
+}
+export declare namespace CatalogSource {
     
-    MaxRetries?: number;
+    const filterSensitiveLog: (obj: CatalogSource) => any;
+}
+
+export interface BasicCatalogTarget {
     
-    AllocatedCapacity?: number;
+    Name: string | undefined;
     
-    Timeout?: number;
+    Inputs: string[] | undefined;
     
-    MaxCapacity?: number;
+    Database: string | undefined;
     
-    WorkerType?: WorkerType | string;
+    Table: string | undefined;
+}
+export declare namespace BasicCatalogTarget {
     
-    NumberOfWorkers?: number;
+    const filterSensitiveLog: (obj: BasicCatalogTarget) => any;
+}
+
+export interface CustomCode {
     
-    SecurityConfiguration?: string;
+    Name: string | undefined;
     
-    NotificationProperty?: NotificationProperty;
+    Inputs: string[] | undefined;
     
-    GlueVersion?: string;
+    Code: string | undefined;
+    
+    ClassName: string | undefined;
+    
+    OutputSchemas?: GlueSchema[];
+}
+export declare namespace CustomCode {
+    
+    const filterSensitiveLog: (obj: CustomCode) => any;
+}
+
+export interface DirectKafkaSource {
+    
+    Name: string | undefined;
+    
+    StreamingOptions?: KafkaStreamingSourceOptions;
+    
+    WindowSize?: number;
+    
+    DetectSchema?: boolean;
+    
+    DataPreviewOptions?: StreamingDataPreviewOptions;
+}
+export declare namespace DirectKafkaSource {
+    
+    const filterSensitiveLog: (obj: DirectKafkaSource) => any;
+}
+
+export interface DirectKinesisSource {
+    
+    Name: string | undefined;
+    
+    WindowSize?: number;
+    
+    DetectSchema?: boolean;
+    
+    StreamingOptions?: KinesisStreamingSourceOptions;
+    
+    DataPreviewOptions?: StreamingDataPreviewOptions;
+}
+export declare namespace DirectKinesisSource {
+    
+    const filterSensitiveLog: (obj: DirectKinesisSource) => any;
+}
+
+export interface DropDuplicates {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    Columns?: string[][];
+}
+export declare namespace DropDuplicates {
+    
+    const filterSensitiveLog: (obj: DropDuplicates) => any;
+}
+
+export interface DropFields {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    Paths: string[][] | undefined;
+}
+export declare namespace DropFields {
+    
+    const filterSensitiveLog: (obj: DropFields) => any;
+}
+
+export interface NullCheckBoxList {
+    
+    IsEmpty?: boolean;
+    
+    IsNullString?: boolean;
+    
+    IsNegOne?: boolean;
+}
+export declare namespace NullCheckBoxList {
+    
+    const filterSensitiveLog: (obj: NullCheckBoxList) => any;
+}
+
+export interface Datatype {
+    
+    Id: string | undefined;
+    
+    Label: string | undefined;
+}
+export declare namespace Datatype {
+    
+    const filterSensitiveLog: (obj: Datatype) => any;
+}
+
+export interface NullValueField {
+    
+    Value: string | undefined;
+    
+    Datatype: Datatype | undefined;
+}
+export declare namespace NullValueField {
+    
+    const filterSensitiveLog: (obj: NullValueField) => any;
+}
+
+export interface DropNullFields {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    NullCheckBoxList?: NullCheckBoxList;
+    
+    NullTextList?: NullValueField[];
+}
+export declare namespace DropNullFields {
+    
+    const filterSensitiveLog: (obj: DropNullFields) => any;
+}
+
+export interface DynamoDBCatalogSource {
+    
+    Name: string | undefined;
+    
+    Database: string | undefined;
+    
+    Table: string | undefined;
+}
+export declare namespace DynamoDBCatalogSource {
+    
+    const filterSensitiveLog: (obj: DynamoDBCatalogSource) => any;
+}
+
+export interface FillMissingValues {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    ImputedPath: string | undefined;
+    
+    FilledPath?: string;
+}
+export declare namespace FillMissingValues {
+    
+    const filterSensitiveLog: (obj: FillMissingValues) => any;
+}
+export declare enum FilterOperation {
+    EQ = "EQ",
+    GT = "GT",
+    GTE = "GTE",
+    ISNULL = "ISNULL",
+    LT = "LT",
+    LTE = "LTE",
+    REGEX = "REGEX"
+}
+export declare enum FilterValueType {
+    COLUMNEXTRACTED = "COLUMNEXTRACTED",
+    CONSTANT = "CONSTANT"
+}
+
+export interface FilterValue {
+    
+    Type: FilterValueType | string | undefined;
+    
+    Value: string[] | undefined;
+}
+export declare namespace FilterValue {
+    
+    const filterSensitiveLog: (obj: FilterValue) => any;
+}
+
+export interface FilterExpression {
+    
+    Operation: FilterOperation | string | undefined;
+    
+    Negated?: boolean;
+    
+    Values: FilterValue[] | undefined;
+}
+export declare namespace FilterExpression {
+    
+    const filterSensitiveLog: (obj: FilterExpression) => any;
+}
+export declare enum FilterLogicalOperator {
+    AND = "AND",
+    OR = "OR"
+}
+
+export interface Filter {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    LogicalOperator: FilterLogicalOperator | string | undefined;
+    
+    Filters: FilterExpression[] | undefined;
+}
+export declare namespace Filter {
+    
+    const filterSensitiveLog: (obj: Filter) => any;
+}
+
+export interface S3SourceAdditionalOptions {
+    
+    BoundedSize?: number;
+    
+    BoundedFiles?: number;
 }
-export declare namespace Job {
+export declare namespace S3SourceAdditionalOptions {
     
-    const filterSensitiveLog: (obj: Job) => any;
+    const filterSensitiveLog: (obj: S3SourceAdditionalOptions) => any;
 }
-export interface BatchGetJobsResponse {
+
+export interface GovernedCatalogSource {
     
-    Jobs?: Job[];
+    Name: string | undefined;
+    
+    Database: string | undefined;
+    
+    Table: string | undefined;
+    
+    PartitionPredicate?: string;
     
-    JobsNotFound?: string[];
+    AdditionalOptions?: S3SourceAdditionalOptions;
 }
-export declare namespace BatchGetJobsResponse {
+export declare namespace GovernedCatalogSource {
     
-    const filterSensitiveLog: (obj: BatchGetJobsResponse) => any;
+    const filterSensitiveLog: (obj: GovernedCatalogSource) => any;
+}
+export declare enum UpdateCatalogBehavior {
+    LOG = "LOG",
+    UPDATE_IN_DATABASE = "UPDATE_IN_DATABASE"
+}
+
+export interface CatalogSchemaChangePolicy {
+    
+    EnableUpdateCatalog?: boolean;
+    
+    UpdateBehavior?: UpdateCatalogBehavior | string;
+}
+export declare namespace CatalogSchemaChangePolicy {
+    
+    const filterSensitiveLog: (obj: CatalogSchemaChangePolicy) => any;
+}
+
+export interface GovernedCatalogTarget {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    PartitionKeys?: string[][];
+    
+    Table: string | undefined;
+    
+    Database: string | undefined;
+    
+    SchemaChangePolicy?: CatalogSchemaChangePolicy;
+}
+export declare namespace GovernedCatalogTarget {
+    
+    const filterSensitiveLog: (obj: GovernedCatalogTarget) => any;
+}
+export declare enum JDBCDataType {
+    ARRAY = "ARRAY",
+    BIGINT = "BIGINT",
+    BINARY = "BINARY",
+    BIT = "BIT",
+    BLOB = "BLOB",
+    BOOLEAN = "BOOLEAN",
+    CHAR = "CHAR",
+    CLOB = "CLOB",
+    DATALINK = "DATALINK",
+    DATE = "DATE",
+    DECIMAL = "DECIMAL",
+    DISTINCT = "DISTINCT",
+    DOUBLE = "DOUBLE",
+    FLOAT = "FLOAT",
+    INTEGER = "INTEGER",
+    JAVA_OBJECT = "JAVA_OBJECT",
+    LONGNVARCHAR = "LONGNVARCHAR",
+    LONGVARBINARY = "LONGVARBINARY",
+    LONGVARCHAR = "LONGVARCHAR",
+    NCHAR = "NCHAR",
+    NCLOB = "NCLOB",
+    NULL = "NULL",
+    NUMERIC = "NUMERIC",
+    NVARCHAR = "NVARCHAR",
+    OTHER = "OTHER",
+    REAL = "REAL",
+    REF = "REF",
+    REF_CURSOR = "REF_CURSOR",
+    ROWID = "ROWID",
+    SMALLINT = "SMALLINT",
+    SQLXML = "SQLXML",
+    STRUCT = "STRUCT",
+    TIME = "TIME",
+    TIMESTAMP = "TIMESTAMP",
+    TIMESTAMP_WITH_TIMEZONE = "TIMESTAMP_WITH_TIMEZONE",
+    TIME_WITH_TIMEZONE = "TIME_WITH_TIMEZONE",
+    TINYINT = "TINYINT",
+    VARBINARY = "VARBINARY",
+    VARCHAR = "VARCHAR"
+}
+export declare enum GlueRecordType {
+    BIGDECIMAL = "BIGDECIMAL",
+    BYTE = "BYTE",
+    DATE = "DATE",
+    DOUBLE = "DOUBLE",
+    FLOAT = "FLOAT",
+    INT = "INT",
+    LONG = "LONG",
+    SHORT = "SHORT",
+    STRING = "STRING",
+    TIMESTAMP = "TIMESTAMP"
+}
+
+export interface JDBCConnectorOptions {
+    
+    FilterPredicate?: string;
+    
+    PartitionColumn?: string;
+    
+    LowerBound?: number;
+    
+    UpperBound?: number;
+    
+    NumPartitions?: number;
+    
+    JobBookmarkKeys?: string[];
+    
+    JobBookmarkKeysSortOrder?: string;
+    
+    DataTypeMapping?: {
+        [key: string]: GlueRecordType | string;
+    };
+}
+export declare namespace JDBCConnectorOptions {
+    
+    const filterSensitiveLog: (obj: JDBCConnectorOptions) => any;
+}
+
+export interface JDBCConnectorSource {
+    
+    Name: string | undefined;
+    
+    ConnectionName: string | undefined;
+    
+    ConnectorName: string | undefined;
+    
+    ConnectionType: string | undefined;
+    
+    AdditionalOptions?: JDBCConnectorOptions;
+    
+    ConnectionTable?: string;
+    
+    Query?: string;
+    
+    OutputSchemas?: GlueSchema[];
+}
+export declare namespace JDBCConnectorSource {
+    
+    const filterSensitiveLog: (obj: JDBCConnectorSource) => any;
+}
+
+export interface JDBCConnectorTarget {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    ConnectionName: string | undefined;
+    
+    ConnectionTable: string | undefined;
+    
+    ConnectorName: string | undefined;
+    
+    ConnectionType: string | undefined;
+    
+    AdditionalOptions?: {
+        [key: string]: string;
+    };
+    
+    OutputSchemas?: GlueSchema[];
+}
+export declare namespace JDBCConnectorTarget {
+    
+    const filterSensitiveLog: (obj: JDBCConnectorTarget) => any;
+}
+
+export interface JoinColumn {
+    
+    From: string | undefined;
+    
+    Keys: string[][] | undefined;
+}
+export declare namespace JoinColumn {
+    
+    const filterSensitiveLog: (obj: JoinColumn) => any;
+}
+export declare enum JoinType {
+    EQUIJOIN = "equijoin",
+    LEFT = "left",
+    LEFT_ANTI = "leftanti",
+    LEFT_SEMI = "leftsemi",
+    OUTER = "outer",
+    RIGHT = "right"
+}
+
+export interface Join {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    JoinType: JoinType | string | undefined;
+    
+    Columns: JoinColumn[] | undefined;
+}
+export declare namespace Join {
+    
+    const filterSensitiveLog: (obj: Join) => any;
+}
+
+export interface Merge {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    Source: string | undefined;
+    
+    PrimaryKeys: string[][] | undefined;
+}
+export declare namespace Merge {
+    
+    const filterSensitiveLog: (obj: Merge) => any;
+}
+
+export interface MicrosoftSQLServerCatalogSource {
+    
+    Name: string | undefined;
+    
+    Database: string | undefined;
+    
+    Table: string | undefined;
+}
+export declare namespace MicrosoftSQLServerCatalogSource {
+    
+    const filterSensitiveLog: (obj: MicrosoftSQLServerCatalogSource) => any;
+}
+
+export interface MicrosoftSQLServerCatalogTarget {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    Database: string | undefined;
+    
+    Table: string | undefined;
+}
+export declare namespace MicrosoftSQLServerCatalogTarget {
+    
+    const filterSensitiveLog: (obj: MicrosoftSQLServerCatalogTarget) => any;
+}
+
+export interface MySQLCatalogSource {
+    
+    Name: string | undefined;
+    
+    Database: string | undefined;
+    
+    Table: string | undefined;
+}
+export declare namespace MySQLCatalogSource {
+    
+    const filterSensitiveLog: (obj: MySQLCatalogSource) => any;
+}
+
+export interface MySQLCatalogTarget {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    Database: string | undefined;
+    
+    Table: string | undefined;
+}
+export declare namespace MySQLCatalogTarget {
+    
+    const filterSensitiveLog: (obj: MySQLCatalogTarget) => any;
+}
+
+export interface OracleSQLCatalogSource {
+    
+    Name: string | undefined;
+    
+    Database: string | undefined;
+    
+    Table: string | undefined;
+}
+export declare namespace OracleSQLCatalogSource {
+    
+    const filterSensitiveLog: (obj: OracleSQLCatalogSource) => any;
+}
+
+export interface OracleSQLCatalogTarget {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    Database: string | undefined;
+    
+    Table: string | undefined;
+}
+export declare namespace OracleSQLCatalogTarget {
+    
+    const filterSensitiveLog: (obj: OracleSQLCatalogTarget) => any;
+}
+export declare enum PiiType {
+    ColumnAudit = "ColumnAudit",
+    ColumnMasking = "ColumnMasking",
+    RowAudit = "RowAudit",
+    RowMasking = "RowMasking"
+}
+
+export interface PIIDetection {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    PiiType: PiiType | string | undefined;
+    
+    EntityTypesToDetect: string[] | undefined;
+    
+    OutputColumnName?: string;
+    
+    SampleFraction?: number;
+    
+    ThresholdFraction?: number;
+    
+    MaskValue?: string;
+}
+export declare namespace PIIDetection {
+    
+    const filterSensitiveLog: (obj: PIIDetection) => any;
+}
+
+export interface PostgreSQLCatalogSource {
+    
+    Name: string | undefined;
+    
+    Database: string | undefined;
+    
+    Table: string | undefined;
+}
+export declare namespace PostgreSQLCatalogSource {
+    
+    const filterSensitiveLog: (obj: PostgreSQLCatalogSource) => any;
+}
+
+export interface PostgreSQLCatalogTarget {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    Database: string | undefined;
+    
+    Table: string | undefined;
+}
+export declare namespace PostgreSQLCatalogTarget {
+    
+    const filterSensitiveLog: (obj: PostgreSQLCatalogTarget) => any;
+}
+
+export interface RedshiftSource {
+    
+    Name: string | undefined;
+    
+    Database: string | undefined;
+    
+    Table: string | undefined;
+    
+    RedshiftTmpDir?: string;
+    
+    TmpDirIAMRole?: string;
+}
+export declare namespace RedshiftSource {
+    
+    const filterSensitiveLog: (obj: RedshiftSource) => any;
+}
+
+export interface UpsertRedshiftTargetOptions {
+    
+    TableLocation?: string;
+    
+    ConnectionName?: string;
+    
+    UpsertKeys?: string[];
+}
+export declare namespace UpsertRedshiftTargetOptions {
+    
+    const filterSensitiveLog: (obj: UpsertRedshiftTargetOptions) => any;
+}
+
+export interface RedshiftTarget {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    Database: string | undefined;
+    
+    Table: string | undefined;
+    
+    RedshiftTmpDir?: string;
+    
+    TmpDirIAMRole?: string;
+    
+    UpsertRedshiftOptions?: UpsertRedshiftTargetOptions;
+}
+export declare namespace RedshiftTarget {
+    
+    const filterSensitiveLog: (obj: RedshiftTarget) => any;
+}
+
+export interface RelationalCatalogSource {
+    
+    Name: string | undefined;
+    
+    Database: string | undefined;
+    
+    Table: string | undefined;
+}
+export declare namespace RelationalCatalogSource {
+    
+    const filterSensitiveLog: (obj: RelationalCatalogSource) => any;
+}
+
+export interface RenameField {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    SourcePath: string[] | undefined;
+    
+    TargetPath: string[] | undefined;
+}
+export declare namespace RenameField {
+    
+    const filterSensitiveLog: (obj: RenameField) => any;
+}
+
+export interface S3CatalogSource {
+    
+    Name: string | undefined;
+    
+    Database: string | undefined;
+    
+    Table: string | undefined;
+    
+    PartitionPredicate?: string;
+    
+    AdditionalOptions?: S3SourceAdditionalOptions;
+}
+export declare namespace S3CatalogSource {
+    
+    const filterSensitiveLog: (obj: S3CatalogSource) => any;
+}
+
+export interface S3CatalogTarget {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    PartitionKeys?: string[][];
+    
+    Table: string | undefined;
+    
+    Database: string | undefined;
+    
+    SchemaChangePolicy?: CatalogSchemaChangePolicy;
+}
+export declare namespace S3CatalogTarget {
+    
+    const filterSensitiveLog: (obj: S3CatalogTarget) => any;
+}
+
+export interface S3DirectSourceAdditionalOptions {
+    
+    BoundedSize?: number;
+    
+    BoundedFiles?: number;
+    
+    EnableSamplePath?: boolean;
+    
+    SamplePath?: string;
+}
+export declare namespace S3DirectSourceAdditionalOptions {
+    
+    const filterSensitiveLog: (obj: S3DirectSourceAdditionalOptions) => any;
+}
+export declare enum CompressionType {
+    BZIP2 = "bzip2",
+    GZIP = "gzip"
+}
+export declare enum QuoteChar {
+    DISABLED = "disabled",
+    QUILLEMET = "quillemet",
+    QUOTE = "quote",
+    SINGLE_QUOTE = "single_quote"
+}
+export declare enum Separator {
+    COMMA = "comma",
+    CTRLA = "ctrla",
+    PIPE = "pipe",
+    SEMICOLON = "semicolon",
+    TAB = "tab"
+}
+
+export interface S3CsvSource {
+    
+    Name: string | undefined;
+    
+    Paths: string[] | undefined;
+    
+    CompressionType?: CompressionType | string;
+    
+    Exclusions?: string[];
+    
+    GroupSize?: string;
+    
+    GroupFiles?: string;
+    
+    Recurse?: boolean;
+    
+    MaxBand?: number;
+    
+    MaxFilesInBand?: number;
+    
+    AdditionalOptions?: S3DirectSourceAdditionalOptions;
+    
+    Separator: Separator | string | undefined;
+    
+    Escaper?: string;
+    
+    QuoteChar: QuoteChar | string | undefined;
+    
+    Multiline?: boolean;
+    
+    WithHeader?: boolean;
+    
+    WriteHeader?: boolean;
+    
+    SkipFirst?: boolean;
+    
+    OptimizePerformance?: boolean;
+    
+    OutputSchemas?: GlueSchema[];
+}
+export declare namespace S3CsvSource {
+    
+    const filterSensitiveLog: (obj: S3CsvSource) => any;
+}
+export declare enum TargetFormat {
+    AVRO = "avro",
+    CSV = "csv",
+    JSON = "json",
+    ORC = "orc",
+    PARQUET = "parquet"
+}
+
+export interface DirectSchemaChangePolicy {
+    
+    EnableUpdateCatalog?: boolean;
+    
+    UpdateBehavior?: UpdateCatalogBehavior | string;
+    
+    Table?: string;
+    
+    Database?: string;
+}
+export declare namespace DirectSchemaChangePolicy {
+    
+    const filterSensitiveLog: (obj: DirectSchemaChangePolicy) => any;
+}
+
+export interface S3DirectTarget {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    PartitionKeys?: string[][];
+    
+    Path: string | undefined;
+    
+    Compression?: string;
+    
+    Format: TargetFormat | string | undefined;
+    
+    SchemaChangePolicy?: DirectSchemaChangePolicy;
+}
+export declare namespace S3DirectTarget {
+    
+    const filterSensitiveLog: (obj: S3DirectTarget) => any;
+}
+export declare enum ParquetCompressionType {
+    GZIP = "gzip",
+    LZO = "lzo",
+    NONE = "none",
+    SNAPPY = "snappy",
+    UNCOMPRESSED = "uncompressed"
+}
+
+export interface S3GlueParquetTarget {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    PartitionKeys?: string[][];
+    
+    Path: string | undefined;
+    
+    Compression?: ParquetCompressionType | string;
+    
+    SchemaChangePolicy?: DirectSchemaChangePolicy;
+}
+export declare namespace S3GlueParquetTarget {
+    
+    const filterSensitiveLog: (obj: S3GlueParquetTarget) => any;
+}
+
+export interface S3JsonSource {
+    
+    Name: string | undefined;
+    
+    Paths: string[] | undefined;
+    
+    CompressionType?: CompressionType | string;
+    
+    Exclusions?: string[];
+    
+    GroupSize?: string;
+    
+    GroupFiles?: string;
+    
+    Recurse?: boolean;
+    
+    MaxBand?: number;
+    
+    MaxFilesInBand?: number;
+    
+    AdditionalOptions?: S3DirectSourceAdditionalOptions;
+    
+    JsonPath?: string;
+    
+    Multiline?: boolean;
+    
+    OutputSchemas?: GlueSchema[];
+}
+export declare namespace S3JsonSource {
+    
+    const filterSensitiveLog: (obj: S3JsonSource) => any;
+}
+
+export interface S3ParquetSource {
+    
+    Name: string | undefined;
+    
+    Paths: string[] | undefined;
+    
+    CompressionType?: ParquetCompressionType | string;
+    
+    Exclusions?: string[];
+    
+    GroupSize?: string;
+    
+    GroupFiles?: string;
+    
+    Recurse?: boolean;
+    
+    MaxBand?: number;
+    
+    MaxFilesInBand?: number;
+    
+    AdditionalOptions?: S3DirectSourceAdditionalOptions;
+    
+    OutputSchemas?: GlueSchema[];
+}
+export declare namespace S3ParquetSource {
+    
+    const filterSensitiveLog: (obj: S3ParquetSource) => any;
+}
+
+export interface SelectFields {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    Paths: string[][] | undefined;
+}
+export declare namespace SelectFields {
+    
+    const filterSensitiveLog: (obj: SelectFields) => any;
+}
+
+export interface SelectFromCollection {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    Index: number | undefined;
+}
+export declare namespace SelectFromCollection {
+    
+    const filterSensitiveLog: (obj: SelectFromCollection) => any;
+}
+
+export interface SparkConnectorSource {
+    
+    Name: string | undefined;
+    
+    ConnectionName: string | undefined;
+    
+    ConnectorName: string | undefined;
+    
+    ConnectionType: string | undefined;
+    
+    AdditionalOptions?: {
+        [key: string]: string;
+    };
+    
+    OutputSchemas?: GlueSchema[];
+}
+export declare namespace SparkConnectorSource {
+    
+    const filterSensitiveLog: (obj: SparkConnectorSource) => any;
+}
+
+export interface SparkConnectorTarget {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    ConnectionName: string | undefined;
+    
+    ConnectorName: string | undefined;
+    
+    ConnectionType: string | undefined;
+    
+    AdditionalOptions?: {
+        [key: string]: string;
+    };
+    
+    OutputSchemas?: GlueSchema[];
+}
+export declare namespace SparkConnectorTarget {
+    
+    const filterSensitiveLog: (obj: SparkConnectorTarget) => any;
+}
+
+export interface SqlAlias {
+    
+    From: string | undefined;
+    
+    Alias: string | undefined;
+}
+export declare namespace SqlAlias {
+    
+    const filterSensitiveLog: (obj: SqlAlias) => any;
+}
+
+export interface SparkSQL {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    SqlQuery: string | undefined;
+    
+    SqlAliases: SqlAlias[] | undefined;
+    
+    OutputSchemas?: GlueSchema[];
+}
+export declare namespace SparkSQL {
+    
+    const filterSensitiveLog: (obj: SparkSQL) => any;
+}
+
+export interface Spigot {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    Path: string | undefined;
+    
+    Topk?: number;
+    
+    Prob?: number;
+}
+export declare namespace Spigot {
+    
+    const filterSensitiveLog: (obj: Spigot) => any;
+}
+
+export interface SplitFields {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    Paths: string[][] | undefined;
+}
+export declare namespace SplitFields {
+    
+    const filterSensitiveLog: (obj: SplitFields) => any;
+}
+export declare enum UnionType {
+    ALL = "ALL",
+    DISTINCT = "DISTINCT"
+}
+
+export interface Union {
+    
+    Name: string | undefined;
+    
+    Inputs: string[] | undefined;
+    
+    UnionType: UnionType | string | undefined;
+}
+export declare namespace Union {
+    
+    const filterSensitiveLog: (obj: Union) => any;
+}
+
+export interface JobCommand {
+    
+    Name?: string;
+    
+    ScriptLocation?: string;
+    
+    PythonVersion?: string;
+}
+export declare namespace JobCommand {
+    
+    const filterSensitiveLog: (obj: JobCommand) => any;
+}
+
+export interface ConnectionsList {
+    
+    Connections?: string[];
+}
+export declare namespace ConnectionsList {
+    
+    const filterSensitiveLog: (obj: ConnectionsList) => any;
+}
+
+export interface ExecutionProperty {
+    
+    MaxConcurrentRuns?: number;
+}
+export declare namespace ExecutionProperty {
+    
+    const filterSensitiveLog: (obj: ExecutionProperty) => any;
 }
 export interface BatchGetPartitionRequest {