@aws-sdk/client-glue 3.92.0 → 3.95.0

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

@@ -1,218 +1,675 @@
-import { Action, Compatibility, EventBatchingCondition, PartitionInput, Predicate, RegistryId, SchemaId, TableInput, TransformParameters, Trigger, UserDefinedFunctionInput, WorkerType } from "./models_0";
-import { SchemaVersionNumber } from "./models_1";
-export interface UpdateJobResponse {
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { GlueServiceException as __BaseException } from "./GlueServiceException";
+import { Action, Aggregate, AthenaConnectorSource, BasicCatalogTarget, CatalogKafkaSource, CatalogKinesisSource, CatalogSource, Compatibility, ConnectionInput, ConnectionsList, CrawlerTargets, CsvHeaderOption, CustomCode, DatabaseInput, DirectKafkaSource, DirectKinesisSource, DropDuplicates, DropFields, DropNullFields, DynamoDBCatalogSource, ErrorDetail, EventBatchingCondition, ExecutionProperty, FillMissingValues, Filter, GovernedCatalogSource, GovernedCatalogTarget, JDBCConnectorSource, JDBCConnectorTarget, JobCommand, Join, LakeFormationConfiguration, LineageConfiguration, Merge, MicrosoftSQLServerCatalogSource, MicrosoftSQLServerCatalogTarget, MySQLCatalogSource, MySQLCatalogTarget, NotificationProperty, OracleSQLCatalogSource, OracleSQLCatalogTarget, PartitionInput, PIIDetection, PostgreSQLCatalogSource, PostgreSQLCatalogTarget, Predicate, RecrawlPolicy, RedshiftSource, RedshiftTarget, RegistryId, RelationalCatalogSource, RenameField, S3CatalogSource, S3CatalogTarget, S3CsvSource, S3DirectTarget, S3GlueParquetTarget, S3JsonSource, S3ParquetSource, SchemaChangePolicy, SchemaId, SelectFields, SelectFromCollection, SparkConnectorSource, SparkConnectorTarget, SparkSQL, Spigot, SplitFields, TableInput, TransformParameters, Trigger, Union, UserDefinedFunctionInput, WorkerType } from "./models_0";
+import { ColumnStatistics, ResourceShareType, SchemaVersionNumber, Table } from "./models_1";
+
+export declare class IllegalWorkflowStateException extends __BaseException {
+    readonly name: "IllegalWorkflowStateException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<IllegalWorkflowStateException, __BaseException>);
+}
+export interface ResumeWorkflowRunRequest {
+    
+    Name: string | undefined;
+    
+    RunId: string | undefined;
+    
+    NodeIds: string[] | undefined;
+}
+export declare namespace ResumeWorkflowRunRequest {
+    
+    const filterSensitiveLog: (obj: ResumeWorkflowRunRequest) => any;
+}
+export interface ResumeWorkflowRunResponse {
+    
+    RunId?: string;
+    
+    NodeIds?: string[];
+}
+export declare namespace ResumeWorkflowRunResponse {
+    
+    const filterSensitiveLog: (obj: ResumeWorkflowRunResponse) => any;
+}
+export interface RunStatementRequest {
+    
+    SessionId: string | undefined;
+    
+    Code: string | undefined;
+    
+    RequestOrigin?: string;
+}
+export declare namespace RunStatementRequest {
+    
+    const filterSensitiveLog: (obj: RunStatementRequest) => any;
+}
+export interface RunStatementResponse {
+    
+    Id?: number;
+}
+export declare namespace RunStatementResponse {
+    
+    const filterSensitiveLog: (obj: RunStatementResponse) => any;
+}
+export declare enum Comparator {
+    EQUALS = "EQUALS",
+    GREATER_THAN = "GREATER_THAN",
+    GREATER_THAN_EQUALS = "GREATER_THAN_EQUALS",
+    LESS_THAN = "LESS_THAN",
+    LESS_THAN_EQUALS = "LESS_THAN_EQUALS"
+}
+
+export interface PropertyPredicate {
+    
+    Key?: string;
+    
+    Value?: string;
+    
+    Comparator?: Comparator | string;
+}
+export declare namespace PropertyPredicate {
+    
+    const filterSensitiveLog: (obj: PropertyPredicate) => any;
+}
+export declare enum Sort {
+    ASCENDING = "ASC",
+    DESCENDING = "DESC"
+}
+
+export interface SortCriterion {
+    
+    FieldName?: string;
+    
+    Sort?: Sort | string;
+}
+export declare namespace SortCriterion {
+    
+    const filterSensitiveLog: (obj: SortCriterion) => any;
+}
+export interface SearchTablesRequest {
+    
+    CatalogId?: string;
+    
+    NextToken?: string;
+    
+    Filters?: PropertyPredicate[];
+    
+    SearchText?: string;
+    
+    SortCriteria?: SortCriterion[];
+    
+    MaxResults?: number;
+    
+    ResourceShareType?: ResourceShareType | string;
+}
+export declare namespace SearchTablesRequest {
+    
+    const filterSensitiveLog: (obj: SearchTablesRequest) => any;
+}
+export interface SearchTablesResponse {
+    
+    NextToken?: string;
+    
+    TableList?: Table[];
+}
+export declare namespace SearchTablesResponse {
+    
+    const filterSensitiveLog: (obj: SearchTablesResponse) => any;
+}
+export declare class IllegalBlueprintStateException extends __BaseException {
+    readonly name: "IllegalBlueprintStateException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<IllegalBlueprintStateException, __BaseException>);
+}
+export interface StartBlueprintRunRequest {
+    
+    BlueprintName: string | undefined;
+    
+    Parameters?: string;
+    
+    RoleArn: string | undefined;
+}
+export declare namespace StartBlueprintRunRequest {
+    
+    const filterSensitiveLog: (obj: StartBlueprintRunRequest) => any;
+}
+export interface StartBlueprintRunResponse {
+    
+    RunId?: string;
+}
+export declare namespace StartBlueprintRunResponse {
     
-    JobName?: string;
+    const filterSensitiveLog: (obj: StartBlueprintRunResponse) => any;
 }
-export declare namespace UpdateJobResponse {
+export interface StartCrawlerRequest {
     
-    const filterSensitiveLog: (obj: UpdateJobResponse) => any;
+    Name: string | undefined;
+}
+export declare namespace StartCrawlerRequest {
+    
+    const filterSensitiveLog: (obj: StartCrawlerRequest) => any;
+}
+export interface StartCrawlerResponse {
+}
+export declare namespace StartCrawlerResponse {
+    
+    const filterSensitiveLog: (obj: StartCrawlerResponse) => any;
+}
+
+export declare class NoScheduleException extends __BaseException {
+    readonly name: "NoScheduleException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<NoScheduleException, __BaseException>);
+}
+
+export declare class SchedulerRunningException extends __BaseException {
+    readonly name: "SchedulerRunningException";
+    readonly $fault: "client";
+    
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<SchedulerRunningException, __BaseException>);
+}
+export interface StartCrawlerScheduleRequest {
+    
+    CrawlerName: string | undefined;
+}
+export declare namespace StartCrawlerScheduleRequest {
+    
+    const filterSensitiveLog: (obj: StartCrawlerScheduleRequest) => any;
+}
+export interface StartCrawlerScheduleResponse {
 }
-export interface UpdateMLTransformRequest {
+export declare namespace StartCrawlerScheduleResponse {
+    
+    const filterSensitiveLog: (obj: StartCrawlerScheduleResponse) => any;
+}
+export interface StartExportLabelsTaskRunRequest {
     
     TransformId: string | undefined;
     
-    Name?: string;
+    OutputS3Path: string | undefined;
+}
+export declare namespace StartExportLabelsTaskRunRequest {
     
-    Description?: string;
+    const filterSensitiveLog: (obj: StartExportLabelsTaskRunRequest) => any;
+}
+export interface StartExportLabelsTaskRunResponse {
     
-    Parameters?: TransformParameters;
+    TaskRunId?: string;
+}
+export declare namespace StartExportLabelsTaskRunResponse {
     
-    Role?: string;
+    const filterSensitiveLog: (obj: StartExportLabelsTaskRunResponse) => any;
+}
+export interface StartImportLabelsTaskRunRequest {
+    
+    TransformId: string | undefined;
     
-    GlueVersion?: string;
+    InputS3Path: string | undefined;
+    
+    ReplaceAllLabels?: boolean;
+}
+export declare namespace StartImportLabelsTaskRunRequest {
+    
+    const filterSensitiveLog: (obj: StartImportLabelsTaskRunRequest) => any;
+}
+export interface StartImportLabelsTaskRunResponse {
+    
+    TaskRunId?: string;
+}
+export declare namespace StartImportLabelsTaskRunResponse {
+    
+    const filterSensitiveLog: (obj: StartImportLabelsTaskRunResponse) => any;
+}
+export interface StartJobRunRequest {
+    
+    JobName: string | undefined;
+    
+    JobRunId?: string;
+    
+    Arguments?: {
+        [key: string]: string;
+    };
+    
+    AllocatedCapacity?: number;
+    
+    Timeout?: number;
     
     MaxCapacity?: number;
     
+    SecurityConfiguration?: string;
+    
+    NotificationProperty?: NotificationProperty;
+    
     WorkerType?: WorkerType | string;
     
     NumberOfWorkers?: number;
+}
+export declare namespace StartJobRunRequest {
     
-    Timeout?: number;
+    const filterSensitiveLog: (obj: StartJobRunRequest) => any;
+}
+export interface StartJobRunResponse {
     
-    MaxRetries?: number;
+    JobRunId?: string;
 }
-export declare namespace UpdateMLTransformRequest {
+export declare namespace StartJobRunResponse {
     
-    const filterSensitiveLog: (obj: UpdateMLTransformRequest) => any;
+    const filterSensitiveLog: (obj: StartJobRunResponse) => any;
 }
-export interface UpdateMLTransformResponse {
+
+export declare class MLTransformNotReadyException extends __BaseException {
+    readonly name: "MLTransformNotReadyException";
+    readonly $fault: "client";
+    
+    Message?: string;
     
-    TransformId?: string;
+    constructor(opts: __ExceptionOptionType<MLTransformNotReadyException, __BaseException>);
 }
-export declare namespace UpdateMLTransformResponse {
+export interface StartMLEvaluationTaskRunRequest {
     
-    const filterSensitiveLog: (obj: UpdateMLTransformResponse) => any;
+    TransformId: string | undefined;
 }
-export interface UpdatePartitionRequest {
+export declare namespace StartMLEvaluationTaskRunRequest {
     
-    CatalogId?: string;
+    const filterSensitiveLog: (obj: StartMLEvaluationTaskRunRequest) => any;
+}
+export interface StartMLEvaluationTaskRunResponse {
     
-    DatabaseName: string | undefined;
+    TaskRunId?: string;
+}
+export declare namespace StartMLEvaluationTaskRunResponse {
     
-    TableName: string | undefined;
+    const filterSensitiveLog: (obj: StartMLEvaluationTaskRunResponse) => any;
+}
+export interface StartMLLabelingSetGenerationTaskRunRequest {
     
-    PartitionValueList: string[] | undefined;
+    TransformId: string | undefined;
     
-    PartitionInput: PartitionInput | undefined;
+    OutputS3Path: string | undefined;
 }
-export declare namespace UpdatePartitionRequest {
+export declare namespace StartMLLabelingSetGenerationTaskRunRequest {
     
-    const filterSensitiveLog: (obj: UpdatePartitionRequest) => any;
+    const filterSensitiveLog: (obj: StartMLLabelingSetGenerationTaskRunRequest) => any;
 }
-export interface UpdatePartitionResponse {
+export interface StartMLLabelingSetGenerationTaskRunResponse {
+    
+    TaskRunId?: string;
 }
-export declare namespace UpdatePartitionResponse {
+export declare namespace StartMLLabelingSetGenerationTaskRunResponse {
     
-    const filterSensitiveLog: (obj: UpdatePartitionResponse) => any;
+    const filterSensitiveLog: (obj: StartMLLabelingSetGenerationTaskRunResponse) => any;
 }
-export interface UpdateRegistryInput {
+export interface StartTriggerRequest {
     
-    RegistryId: RegistryId | undefined;
+    Name: string | undefined;
+}
+export declare namespace StartTriggerRequest {
     
-    Description: string | undefined;
+    const filterSensitiveLog: (obj: StartTriggerRequest) => any;
 }
-export declare namespace UpdateRegistryInput {
+export interface StartTriggerResponse {
     
-    const filterSensitiveLog: (obj: UpdateRegistryInput) => any;
+    Name?: string;
 }
-export interface UpdateRegistryResponse {
+export declare namespace StartTriggerResponse {
     
-    RegistryName?: string;
+    const filterSensitiveLog: (obj: StartTriggerResponse) => any;
+}
+export interface StartWorkflowRunRequest {
     
-    RegistryArn?: string;
+    Name: string | undefined;
+    
+    RunProperties?: {
+        [key: string]: string;
+    };
 }
-export declare namespace UpdateRegistryResponse {
+export declare namespace StartWorkflowRunRequest {
     
-    const filterSensitiveLog: (obj: UpdateRegistryResponse) => any;
+    const filterSensitiveLog: (obj: StartWorkflowRunRequest) => any;
 }
-export interface UpdateSchemaInput {
+export interface StartWorkflowRunResponse {
     
-    SchemaId: SchemaId | undefined;
+    RunId?: string;
+}
+export declare namespace StartWorkflowRunResponse {
     
-    SchemaVersionNumber?: SchemaVersionNumber;
+    const filterSensitiveLog: (obj: StartWorkflowRunResponse) => any;
+}
+
+export declare class CrawlerNotRunningException extends __BaseException {
+    readonly name: "CrawlerNotRunningException";
+    readonly $fault: "client";
     
-    Compatibility?: Compatibility | string;
+    Message?: string;
     
-    Description?: string;
+    constructor(opts: __ExceptionOptionType<CrawlerNotRunningException, __BaseException>);
 }
-export declare namespace UpdateSchemaInput {
+
+export declare class CrawlerStoppingException extends __BaseException {
+    readonly name: "CrawlerStoppingException";
+    readonly $fault: "client";
+    
+    Message?: string;
     
-    const filterSensitiveLog: (obj: UpdateSchemaInput) => any;
+    constructor(opts: __ExceptionOptionType<CrawlerStoppingException, __BaseException>);
 }
-export interface UpdateSchemaResponse {
+export interface StopCrawlerRequest {
     
-    SchemaArn?: string;
+    Name: string | undefined;
+}
+export declare namespace StopCrawlerRequest {
     
-    SchemaName?: string;
+    const filterSensitiveLog: (obj: StopCrawlerRequest) => any;
+}
+export interface StopCrawlerResponse {
+}
+export declare namespace StopCrawlerResponse {
     
-    RegistryName?: string;
+    const filterSensitiveLog: (obj: StopCrawlerResponse) => any;
 }
-export declare namespace UpdateSchemaResponse {
+
+export declare class SchedulerNotRunningException extends __BaseException {
+    readonly name: "SchedulerNotRunningException";
+    readonly $fault: "client";
+    
+    Message?: string;
     
-    const filterSensitiveLog: (obj: UpdateSchemaResponse) => any;
+    constructor(opts: __ExceptionOptionType<SchedulerNotRunningException, __BaseException>);
 }
-export interface UpdateTableRequest {
+export interface StopCrawlerScheduleRequest {
     
-    CatalogId?: string;
+    CrawlerName: string | undefined;
+}
+export declare namespace StopCrawlerScheduleRequest {
     
-    DatabaseName: string | undefined;
+    const filterSensitiveLog: (obj: StopCrawlerScheduleRequest) => any;
+}
+export interface StopCrawlerScheduleResponse {
+}
+export declare namespace StopCrawlerScheduleResponse {
     
-    TableInput: TableInput | undefined;
+    const filterSensitiveLog: (obj: StopCrawlerScheduleResponse) => any;
+}
+export interface StopSessionRequest {
     
-    SkipArchive?: boolean;
+    Id: string | undefined;
     
-    TransactionId?: string;
-    VersionId?: string;
+    RequestOrigin?: string;
 }
-export declare namespace UpdateTableRequest {
+export declare namespace StopSessionRequest {
     
-    const filterSensitiveLog: (obj: UpdateTableRequest) => any;
+    const filterSensitiveLog: (obj: StopSessionRequest) => any;
 }
-export interface UpdateTableResponse {
+export interface StopSessionResponse {
+    
+    Id?: string;
 }
-export declare namespace UpdateTableResponse {
+export declare namespace StopSessionResponse {
     
-    const filterSensitiveLog: (obj: UpdateTableResponse) => any;
+    const filterSensitiveLog: (obj: StopSessionResponse) => any;
 }
-
-export interface TriggerUpdate {
+export interface StopTriggerRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace StopTriggerRequest {
+    
+    const filterSensitiveLog: (obj: StopTriggerRequest) => any;
+}
+export interface StopTriggerResponse {
     
     Name?: string;
+}
+export declare namespace StopTriggerResponse {
+    
+    const filterSensitiveLog: (obj: StopTriggerResponse) => any;
+}
+export interface StopWorkflowRunRequest {
+    
+    Name: string | undefined;
+    
+    RunId: string | undefined;
+}
+export declare namespace StopWorkflowRunRequest {
+    
+    const filterSensitiveLog: (obj: StopWorkflowRunRequest) => any;
+}
+export interface StopWorkflowRunResponse {
+}
+export declare namespace StopWorkflowRunResponse {
+    
+    const filterSensitiveLog: (obj: StopWorkflowRunResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagsToAdd: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagsToRemove: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateBlueprintRequest {
+    
+    Name: string | undefined;
     
     Description?: string;
     
-    Schedule?: string;
+    BlueprintLocation: string | undefined;
+}
+export declare namespace UpdateBlueprintRequest {
     
-    Actions?: Action[];
+    const filterSensitiveLog: (obj: UpdateBlueprintRequest) => any;
+}
+export interface UpdateBlueprintResponse {
     
-    Predicate?: Predicate;
+    Name?: string;
+}
+export declare namespace UpdateBlueprintResponse {
     
-    EventBatchingCondition?: EventBatchingCondition;
+    const filterSensitiveLog: (obj: UpdateBlueprintResponse) => any;
 }
-export declare namespace TriggerUpdate {
+
+export interface UpdateCsvClassifierRequest {
+    
+    Name: string | undefined;
+    
+    Delimiter?: string;
     
-    const filterSensitiveLog: (obj: TriggerUpdate) => any;
+    QuoteSymbol?: string;
+    
+    ContainsHeader?: CsvHeaderOption | string;
+    
+    Header?: string[];
+    
+    DisableValueTrimming?: boolean;
+    
+    AllowSingleColumn?: boolean;
 }
-export interface UpdateTriggerRequest {
+export declare namespace UpdateCsvClassifierRequest {
+    
+    const filterSensitiveLog: (obj: UpdateCsvClassifierRequest) => any;
+}
+
+export interface UpdateGrokClassifierRequest {
     
     Name: string | undefined;
     
-    TriggerUpdate: TriggerUpdate | undefined;
+    Classification?: string;
+    
+    GrokPattern?: string;
+    
+    CustomPatterns?: string;
 }
-export declare namespace UpdateTriggerRequest {
+export declare namespace UpdateGrokClassifierRequest {
     
-    const filterSensitiveLog: (obj: UpdateTriggerRequest) => any;
+    const filterSensitiveLog: (obj: UpdateGrokClassifierRequest) => any;
 }
-export interface UpdateTriggerResponse {
+
+export interface UpdateJsonClassifierRequest {
+    
+    Name: string | undefined;
+    
+    JsonPath?: string;
+}
+export declare namespace UpdateJsonClassifierRequest {
     
-    Trigger?: Trigger;
+    const filterSensitiveLog: (obj: UpdateJsonClassifierRequest) => any;
 }
-export declare namespace UpdateTriggerResponse {
+
+export interface UpdateXMLClassifierRequest {
+    
+    Name: string | undefined;
+    
+    Classification?: string;
+    
+    RowTag?: string;
+}
+export declare namespace UpdateXMLClassifierRequest {
+    
+    const filterSensitiveLog: (obj: UpdateXMLClassifierRequest) => any;
+}
+export interface UpdateClassifierRequest {
+    
+    GrokClassifier?: UpdateGrokClassifierRequest;
+    
+    XMLClassifier?: UpdateXMLClassifierRequest;
+    
+    JsonClassifier?: UpdateJsonClassifierRequest;
+    
+    CsvClassifier?: UpdateCsvClassifierRequest;
+}
+export declare namespace UpdateClassifierRequest {
+    
+    const filterSensitiveLog: (obj: UpdateClassifierRequest) => any;
+}
+export interface UpdateClassifierResponse {
+}
+export declare namespace UpdateClassifierResponse {
+    
+    const filterSensitiveLog: (obj: UpdateClassifierResponse) => any;
+}
+
+export declare class VersionMismatchException extends __BaseException {
+    readonly name: "VersionMismatchException";
+    readonly $fault: "client";
     
-    const filterSensitiveLog: (obj: UpdateTriggerResponse) => any;
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<VersionMismatchException, __BaseException>);
 }
-export interface UpdateUserDefinedFunctionRequest {
+export interface UpdateColumnStatisticsForPartitionRequest {
     
     CatalogId?: string;
     
     DatabaseName: string | undefined;
     
-    FunctionName: string | undefined;
+    TableName: string | undefined;
+    
+    PartitionValues: string[] | undefined;
     
-    FunctionInput: UserDefinedFunctionInput | undefined;
+    ColumnStatisticsList: ColumnStatistics[] | undefined;
 }
-export declare namespace UpdateUserDefinedFunctionRequest {
+export declare namespace UpdateColumnStatisticsForPartitionRequest {
     
-    const filterSensitiveLog: (obj: UpdateUserDefinedFunctionRequest) => any;
+    const filterSensitiveLog: (obj: UpdateColumnStatisticsForPartitionRequest) => any;
 }
-export interface UpdateUserDefinedFunctionResponse {
+
+export interface ColumnStatisticsError {
+    
+    ColumnStatistics?: ColumnStatistics;
+    
+    Error?: ErrorDetail;
 }
-export declare namespace UpdateUserDefinedFunctionResponse {
+export declare namespace ColumnStatisticsError {
     
-    const filterSensitiveLog: (obj: UpdateUserDefinedFunctionResponse) => any;
+    const filterSensitiveLog: (obj: ColumnStatisticsError) => any;
 }
-export interface UpdateWorkflowRequest {
+export interface UpdateColumnStatisticsForPartitionResponse {
     
-    Name: string | undefined;
+    Errors?: ColumnStatisticsError[];
+}
+export declare namespace UpdateColumnStatisticsForPartitionResponse {
     
-    Description?: string;
+    const filterSensitiveLog: (obj: UpdateColumnStatisticsForPartitionResponse) => any;
+}
+export interface UpdateColumnStatisticsForTableRequest {
     
-    DefaultRunProperties?: {
-        [key: string]: string;
-    };
+    CatalogId?: string;
+    
+    DatabaseName: string | undefined;
+    
+    TableName: string | undefined;
     
-    MaxConcurrentRuns?: number;
+    ColumnStatisticsList: ColumnStatistics[] | undefined;
 }
-export declare namespace UpdateWorkflowRequest {
+export declare namespace UpdateColumnStatisticsForTableRequest {
     
-    const filterSensitiveLog: (obj: UpdateWorkflowRequest) => any;
+    const filterSensitiveLog: (obj: UpdateColumnStatisticsForTableRequest) => any;
 }
-export interface UpdateWorkflowResponse {
+export interface UpdateColumnStatisticsForTableResponse {
     
-    Name?: string;
+    Errors?: ColumnStatisticsError[];
+}
+export declare namespace UpdateColumnStatisticsForTableResponse {
+    
+    const filterSensitiveLog: (obj: UpdateColumnStatisticsForTableResponse) => any;
+}
+export interface UpdateConnectionRequest {
+    
+    CatalogId?: string;
+    
+    Name: string | undefined;
+    
+    ConnectionInput: ConnectionInput | undefined;
+}
+export declare namespace UpdateConnectionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateConnectionRequest) => any;
+}
+export interface UpdateConnectionResponse {
 }
-export declare namespace UpdateWorkflowResponse {
+export declare namespace UpdateConnectionResponse {
     
-    const filterSensitiveLog: (obj: UpdateWorkflowResponse) => any;
+    const filterSensitiveLog: (obj: UpdateConnectionResponse) => any;
 }
+export interface UpdateCrawlerRequest {
+    
+    Name: string | undefined;
+    
+    Role?: string;
+