@aws-sdk/client-glue 3.85.0 → 3.93.0

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

@@ -1,403 +1,2587 @@
-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";
+/**
+ * <p>The workflow is in an invalid state to perform a requested operation.</p>
+ */
+export declare class IllegalWorkflowStateException extends __BaseException {
+    readonly name: "IllegalWorkflowStateException";
+    readonly $fault: "client";
     /**
-     * <p>Returns the name of the updated job definition.</p>
+     * <p>A message describing the problem.</p>
      */
-    JobName?: string;
-}
-export declare namespace UpdateJobResponse {
+    Message?: string;
     /**
      * @internal
      */
-    const filterSensitiveLog: (obj: UpdateJobResponse) => any;
+    constructor(opts: __ExceptionOptionType<IllegalWorkflowStateException, __BaseException>);
 }
-export interface UpdateMLTransformRequest {
-    /**
-     * <p>A unique identifier that was generated when the transform was created.</p>
-     */
-    TransformId: string | undefined;
+export interface ResumeWorkflowRunRequest {
     /**
-     * <p>The unique name that you gave the transform when you created it.</p>
+     * <p>The name of the workflow to resume.</p>
      */
-    Name?: string;
+    Name: string | undefined;
     /**
-     * <p>A description of the transform. The default is an empty string.</p>
+     * <p>The ID of the workflow run to resume.</p>
      */
-    Description?: string;
+    RunId: string | undefined;
     /**
-     * <p>The configuration parameters that are specific to the transform type (algorithm) used.
-     *       Conditionally dependent on the transform type.</p>
+     * <p>A list of the node IDs for the nodes you want to restart. The nodes that are to be restarted must have a run attempt in the original run.</p>
      */
-    Parameters?: TransformParameters;
+    NodeIds: string[] | undefined;
+}
+export declare namespace ResumeWorkflowRunRequest {
     /**
-     * <p>The name or Amazon Resource Name (ARN) of the IAM role with the required
-     *       permissions.</p>
+     * @internal
      */
-    Role?: string;
+    const filterSensitiveLog: (obj: ResumeWorkflowRunRequest) => any;
+}
+export interface ResumeWorkflowRunResponse {
     /**
-     * <p>This value determines which version of Glue this machine learning transform is compatible with. Glue 1.0 is recommended for most customers. If the value is not set, the Glue compatibility defaults to Glue 0.9.  For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions">Glue Versions</a> in the developer guide.</p>
+     * <p>The new ID assigned to the resumed workflow run. Each resume of a workflow run will have a new run ID.</p>
      */
-    GlueVersion?: string;
+    RunId?: string;
     /**
-     * <p>The number of Glue data processing units (DPUs) that are allocated to task runs for this transform. You can allocate from 2 to 100 DPUs; the default is 10. A DPU is a relative measure of
-     *       processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more
-     *       information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing
-     *         page</a>. </p>
-     *
-     *          <p>When the <code>WorkerType</code> field is set to a value other than <code>Standard</code>, the <code>MaxCapacity</code> field is set automatically and becomes read-only.</p>
+     * <p>A list of the node IDs for the nodes that were actually restarted.</p>
      */
-    MaxCapacity?: number;
+    NodeIds?: string[];
+}
+export declare namespace ResumeWorkflowRunResponse {
     /**
-     * <p>The type of predefined worker that is allocated when this task runs. Accepts a value of Standard, G.1X, or G.2X.</p>
-     * 	        <ul>
-     *             <li>
-     *                <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p>
-     *             </li>
-     *             <li>
-     *                <p>For the <code>G.1X</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 64GB disk, and 1 executor per worker.</p>
-     *             </li>
-     *             <li>
-     *                <p>For the <code>G.2X</code> worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.</p>
-     *             </li>
-     *          </ul>
+     * @internal
      */
-    WorkerType?: WorkerType | string;
+    const filterSensitiveLog: (obj: ResumeWorkflowRunResponse) => any;
+}
+export interface RunStatementRequest {
     /**
-     * <p>The number of workers of a defined <code>workerType</code> that are allocated when this task runs.</p>
+     * <p>The Session Id of the statement to be run.</p>
      */
-    NumberOfWorkers?: number;
+    SessionId: string | undefined;
     /**
-     * <p>The timeout for a task run for this transform in minutes. This is the maximum time that a task run for this transform can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
+     * <p>The statement code to be run.</p>
      */
-    Timeout?: number;
+    Code: string | undefined;
     /**
-     * <p>The maximum number of times to retry a task for this transform after a task run fails.</p>
+     * <p>The origin of the request.</p>
      */
-    MaxRetries?: number;
+    RequestOrigin?: string;
 }
-export declare namespace UpdateMLTransformRequest {
+export declare namespace RunStatementRequest {
     /**
      * @internal
      */
-    const filterSensitiveLog: (obj: UpdateMLTransformRequest) => any;
+    const filterSensitiveLog: (obj: RunStatementRequest) => any;
 }
-export interface UpdateMLTransformResponse {
+export interface RunStatementResponse {
     /**
-     * <p>The unique identifier for the transform that was updated.</p>
+     * <p>Returns the Id of the statement that was run.</p>
      */
-    TransformId?: string;
+    Id?: number;
 }
-export declare namespace UpdateMLTransformResponse {
+export declare namespace RunStatementResponse {
     /**
      * @internal
      */
-    const filterSensitiveLog: (obj: UpdateMLTransformResponse) => any;
+    const filterSensitiveLog: (obj: RunStatementResponse) => any;
 }
-export interface UpdatePartitionRequest {
+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"
+}
+/**
+ * <p>Defines a property predicate.</p>
+ */
+export interface PropertyPredicate {
     /**
-     * <p>The ID of the Data Catalog where the partition to be updated resides. If none is provided,
-     *       the Amazon Web Services account ID is used by default.</p>
+     * <p>The key of the property.</p>
      */
-    CatalogId?: string;
+    Key?: string;
     /**
-     * <p>The name of the catalog database in which the table in question
-     *       resides.</p>
+     * <p>The value of the property.</p>
      */
-    DatabaseName: string | undefined;
+    Value?: string;
     /**
-     * <p>The name of the table in which the partition to be updated is located.</p>
+     * <p>The comparator used to compare this property to others.</p>
      */
-    TableName: string | undefined;
+    Comparator?: Comparator | string;
+}
+export declare namespace PropertyPredicate {
     /**
-     * <p>List of partition key values that define the partition to update.</p>
+     * @internal
      */
-    PartitionValueList: string[] | undefined;
+    const filterSensitiveLog: (obj: PropertyPredicate) => any;
+}
+export declare enum Sort {
+    ASCENDING = "ASC",
+    DESCENDING = "DESC"
+}
+/**
+ * <p>Specifies a field to sort by and a sort order.</p>
+ */
+export interface SortCriterion {
     /**
-     * <p>The new partition object to update the partition to.</p>
-     *
-     * 	        <p>The <code>Values</code> property can't be changed. If you want to change the partition key values for a partition, delete and recreate the partition.</p>
+     * <p>The name of the field on which to sort.</p>
      */
-    PartitionInput: PartitionInput | undefined;
-}
-export declare namespace UpdatePartitionRequest {
+    FieldName?: string;
     /**
-     * @internal
+     * <p>An ascending or descending sort.</p>
      */
-    const filterSensitiveLog: (obj: UpdatePartitionRequest) => any;
-}
-export interface UpdatePartitionResponse {
+    Sort?: Sort | string;
 }
-export declare namespace UpdatePartitionResponse {
+export declare namespace SortCriterion {
     /**
      * @internal
      */
-    const filterSensitiveLog: (obj: UpdatePartitionResponse) => any;
+    const filterSensitiveLog: (obj: SortCriterion) => any;
 }
-export interface UpdateRegistryInput {
+export interface SearchTablesRequest {
     /**
-     * <p>This is a wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
+     * <p>A unique identifier, consisting of <code>
+     *                <i>account_id</i>
+     *             </code>.</p>
      */
-    RegistryId: RegistryId | undefined;
+    CatalogId?: string;
     /**
-     * <p>A description of the registry. If description is not provided, this field will not be updated.</p>
+     * <p>A continuation token, included if this is a continuation call.</p>
      */
-    Description: string | undefined;
-}
-export declare namespace UpdateRegistryInput {
+    NextToken?: string;
     /**
-     * @internal
+     * <p>A list of key-value pairs, and a comparator used to filter the search results. Returns all entities matching the predicate.</p>
+     *
+     * 	        <p>The <code>Comparator</code> member of the <code>PropertyPredicate</code> struct is used only for time fields, and can be omitted for other field types. Also, when comparing string values, such as when <code>Key=Name</code>, a fuzzy match algorithm is used. The <code>Key</code> field (for example, the value of the <code>Name</code> field) is split on certain punctuation characters, for example, -, :, #, etc. into tokens. Then each token is exact-match compared with the <code>Value</code> member of <code>PropertyPredicate</code>. For example, if <code>Key=Name</code> and <code>Value=link</code>, tables named <code>customer-link</code> and <code>xx-link-yy</code> are returned, but <code>xxlinkyy</code> is not returned.</p>
      */
-    const filterSensitiveLog: (obj: UpdateRegistryInput) => any;
-}
-export interface UpdateRegistryResponse {
+    Filters?: PropertyPredicate[];
     /**
-     * <p>The name of the updated registry.</p>
+     * <p>A string used for a text search.</p>
+     * 	        <p>Specifying a value in quotes filters based on an exact match to the value.</p>
      */
-    RegistryName?: string;
+    SearchText?: string;
     /**
-     * <p>The Amazon Resource name (ARN) of the updated registry.</p>
+     * <p>A list of criteria for sorting the results by a field name, in an ascending or descending order.</p>
      */
-    RegistryArn?: string;
-}
-export declare namespace UpdateRegistryResponse {
+    SortCriteria?: SortCriterion[];
     /**
-     * @internal
+     * <p>The maximum number of tables to return in a single response.</p>
      */
-    const filterSensitiveLog: (obj: UpdateRegistryResponse) => any;
-}
-export interface UpdateSchemaInput {
+    MaxResults?: number;
     /**
-     * <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
+     * <p>Allows you to specify that you want to search the tables shared with your account. The allowable values are <code>FOREIGN</code> or <code>ALL</code>. </p>
+     *
      * 	        <ul>
      *             <li>
-     *                <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p>
+     *                <p>If set to <code>FOREIGN</code>, will search the tables shared with your account. </p>
      *             </li>
      *             <li>
-     *                <p>SchemaId$SchemaName: The name of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p>
+     *                <p>If set to <code>ALL</code>, will search the tables shared with your account, as well as the tables in yor local account. </p>
      *             </li>
      *          </ul>
      */
-    SchemaId: SchemaId | undefined;
+    ResourceShareType?: ResourceShareType | string;
+}
+export declare namespace SearchTablesRequest {
     /**
-     * <p>Version number required for check pointing. One of <code>VersionNumber</code> or <code>Compatibility</code> has to be provided.</p>
+     * @internal
      */
-    SchemaVersionNumber?: SchemaVersionNumber;
+    const filterSensitiveLog: (obj: SearchTablesRequest) => any;
+}
+export interface SearchTablesResponse {
     /**
-     * <p>The new compatibility setting for the schema.</p>
+     * <p>A continuation token, present if the current list segment is not the last.</p>
      */
-    Compatibility?: Compatibility | string;
+    NextToken?: string;
     /**
-     * <p>The new description for the schema.</p>
+     * <p>A list of the requested <code>Table</code> objects. The <code>SearchTables</code> response returns only the tables that you have access to.</p>
      */
-    Description?: string;
+    TableList?: Table[];
 }
-export declare namespace UpdateSchemaInput {
+export declare namespace SearchTablesResponse {
     /**
      * @internal
      */
-    const filterSensitiveLog: (obj: UpdateSchemaInput) => any;
+    const filterSensitiveLog: (obj: SearchTablesResponse) => any;
 }
-export interface UpdateSchemaResponse {
+export declare class IllegalBlueprintStateException extends __BaseException {
+    readonly name: "IllegalBlueprintStateException";
+    readonly $fault: "client";
+    Message?: string;
     /**
-     * <p>The Amazon Resource Name (ARN) of the schema.</p>
+     * @internal
      */
-    SchemaArn?: string;
+    constructor(opts: __ExceptionOptionType<IllegalBlueprintStateException, __BaseException>);
+}
+export interface StartBlueprintRunRequest {
     /**
-     * <p>The name of the schema.</p>
+     * <p>The name of the blueprint.</p>
      */
-    SchemaName?: string;
+    BlueprintName: string | undefined;
     /**
-     * <p>The name of the registry that contains the schema.</p>
+     * <p>Specifies the parameters as a <code>BlueprintParameters</code> object.</p>
      */
-    RegistryName?: string;
-}
-export declare namespace UpdateSchemaResponse {
+    Parameters?: string;
     /**
-     * @internal
+     * <p>Specifies the IAM role used to create the workflow.</p>
      */
-    const filterSensitiveLog: (obj: UpdateSchemaResponse) => any;
+    RoleArn: string | undefined;
 }
-export interface UpdateTableRequest {
-    /**
-     * <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account
-     *       ID is used by default.</p>
-     */
-    CatalogId?: string;
+export declare namespace StartBlueprintRunRequest {
     /**
-     * <p>The name of the catalog database in which the table resides. For Hive
-     *       compatibility, this name is entirely lowercase.</p>
+     * @internal
      */
-    DatabaseName: string | undefined;
+    const filterSensitiveLog: (obj: StartBlueprintRunRequest) => any;
+}
+export interface StartBlueprintRunResponse {
     /**
-     * <p>An updated <code>TableInput</code> object to define the metadata table
-     *       in the catalog.</p>
+     * <p>The run ID for this blueprint run.</p>
      */
-    TableInput: TableInput | undefined;
+    RunId?: string;
+}
+export declare namespace StartBlueprintRunResponse {
     /**
-     * <p>By default, <code>UpdateTable</code> always creates an archived version of the table
-     *       before updating it. However, if <code>skipArchive</code> is set to true,
-     *         <code>UpdateTable</code> does not create the archived version.</p>
+     * @internal
      */
-    SkipArchive?: boolean;
+    const filterSensitiveLog: (obj: StartBlueprintRunResponse) => any;
+}
+export interface StartCrawlerRequest {
     /**
-     * <p>The transaction ID at which to update the table contents. </p>
+     * <p>Name of the crawler to start.</p>
      */
-    TransactionId?: string;
-    VersionId?: string;
+    Name: string | undefined;
 }
-export declare namespace UpdateTableRequest {
+export declare namespace StartCrawlerRequest {
     /**
      * @internal
      */
-    const filterSensitiveLog: (obj: UpdateTableRequest) => any;
+    const filterSensitiveLog: (obj: StartCrawlerRequest) => any;
 }
-export interface UpdateTableResponse {
+export interface StartCrawlerResponse {
 }
-export declare namespace UpdateTableResponse {
+export declare namespace StartCrawlerResponse {
     /**
      * @internal
      */
-    const filterSensitiveLog: (obj: UpdateTableResponse) => any;
+    const filterSensitiveLog: (obj: StartCrawlerResponse) => any;
 }
 /**
- * <p>A structure used to provide information used to update a trigger. This object updates the
- *       previous trigger definition by overwriting it completely.</p>
+ * <p>There is no applicable schedule.</p>
  */
-export interface TriggerUpdate {
+export declare class NoScheduleException extends __BaseException {
+    readonly name: "NoScheduleException";
+    readonly $fault: "client";
     /**
-     * <p>Reserved for future use.</p>
+     * <p>A message describing the problem.</p>
      */
-    Name?: string;
+    Message?: string;
     /**
-     * <p>A description of this trigger.</p>
+     * @internal
      */
-    Description?: string;
+    constructor(opts: __ExceptionOptionType<NoScheduleException, __BaseException>);
+}
+/**
+ * <p>The specified scheduler is already running.</p>
+ */
+export declare class SchedulerRunningException extends __BaseException {
+    readonly name: "SchedulerRunningException";
+    readonly $fault: "client";
     /**
-     * <p>A <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based
-     *       Schedules for Jobs and Crawlers</a>. For example, to run
-     *       something every day at 12:15 UTC, you would specify:
-     *       <code>cron(15 12 * * ? *)</code>.</p>
+     * <p>A message describing the problem.</p>
      */
-    Schedule?: string;
+    Message?: string;
     /**
-     * <p>The actions initiated by this trigger.</p>
+     * @internal
      */
-    Actions?: Action[];
+    constructor(opts: __ExceptionOptionType<SchedulerRunningException, __BaseException>);
+}
+export interface StartCrawlerScheduleRequest {
     /**
-     * <p>The predicate of this trigger, which defines when it will fire.</p>
+     * <p>Name of the crawler to schedule.</p>
      */
-    Predicate?: Predicate;
+    CrawlerName: string | undefined;
+}
+export declare namespace StartCrawlerScheduleRequest {
     /**
-     * <p>Batch condition that must be met (specified number of events received or batch time window expired)
-     *       before EventBridge event trigger fires.</p>
+     * @internal
      */
-    EventBatchingCondition?: EventBatchingCondition;
+    const filterSensitiveLog: (obj: StartCrawlerScheduleRequest) => any;
 }
-export declare namespace TriggerUpdate {
+export interface StartCrawlerScheduleResponse {
+}
+export declare namespace StartCrawlerScheduleResponse {
     /**
      * @internal
      */
-    const filterSensitiveLog: (obj: TriggerUpdate) => any;
+    const filterSensitiveLog: (obj: StartCrawlerScheduleResponse) => any;
 }
-export interface UpdateTriggerRequest {
+export interface StartExportLabelsTaskRunRequest {
     /**
-     * <p>The name of the trigger to update.</p>
+     * <p>The unique identifier of the machine learning transform.</p>
      */
-    Name: string | undefined;
+    TransformId: string | undefined;
     /**
-     * <p>The new values with which to update the trigger.</p>
+     * <p>The Amazon S3 path where you export the labels.</p>
      */
-    TriggerUpdate: TriggerUpdate | undefined;
+    OutputS3Path: string | undefined;
 }
-export declare namespace UpdateTriggerRequest {
+export declare namespace StartExportLabelsTaskRunRequest {
     /**
      * @internal
      */
-    const filterSensitiveLog: (obj: UpdateTriggerRequest) => any;
+    const filterSensitiveLog: (obj: StartExportLabelsTaskRunRequest) => any;
 }
-export interface UpdateTriggerResponse {
+export interface StartExportLabelsTaskRunResponse {
     /**
-     * <p>The resulting trigger definition.</p>
+     * <p>The unique identifier for the task run.</p>
      */
-    Trigger?: Trigger;
+    TaskRunId?: string;
 }
-export declare namespace UpdateTriggerResponse {
+export declare namespace StartExportLabelsTaskRunResponse {
     /**
      * @internal
      */
-    const filterSensitiveLog: (obj: UpdateTriggerResponse) => any;
+    const filterSensitiveLog: (obj: StartExportLabelsTaskRunResponse) => any;
 }
-export interface UpdateUserDefinedFunctionRequest {
-    /**
-     * <p>The ID of the Data Catalog where the function to be updated is located. If none is
-     *       provided, the Amazon Web Services account ID is used by default.</p>
-     */
-    CatalogId?: string;
+export interface StartImportLabelsTaskRunRequest {
     /**
-     * <p>The name of the catalog database where the function to be updated is
-     *       located.</p>
+     * <p>The unique identifier of the machine learning transform.</p>
      */
-    DatabaseName: string | undefined;
+    TransformId: string | undefined;
     /**
-     * <p>The name of the function.</p>
+     * <p>The Amazon Simple Storage Service (Amazon S3) path from where you import the
+     *       labels.</p>
      */
-    FunctionName: string | undefined;
+    InputS3Path: string | undefined;
     /**
-     * <p>A <code>FunctionInput</code> object that redefines the function in the Data
-     *       Catalog.</p>
+     * <p>Indicates whether to overwrite your existing labels.</p>
      */
-    FunctionInput: UserDefinedFunctionInput | undefined;
+    ReplaceAllLabels?: boolean;
 }
-export declare namespace UpdateUserDefinedFunctionRequest {
+export declare namespace StartImportLabelsTaskRunRequest {
     /**
      * @internal
      */
-    const filterSensitiveLog: (obj: UpdateUserDefinedFunctionRequest) => any;
+    const filterSensitiveLog: (obj: StartImportLabelsTaskRunRequest) => any;
 }
-export interface UpdateUserDefinedFunctionResponse {
+export interface StartImportLabelsTaskRunResponse {
+    /**
+     * <p>The unique identifier for the task run.</p>
+     */
+    TaskRunId?: string;
 }
-export declare namespace UpdateUserDefinedFunctionResponse {
+export declare namespace StartImportLabelsTaskRunResponse {
     /**
      * @internal
      */
-    const filterSensitiveLog: (obj: UpdateUserDefinedFunctionResponse) => any;
+    const filterSensitiveLog: (obj: StartImportLabelsTaskRunResponse) => any;
 }
-export interface UpdateWorkflowRequest {
+export interface StartJobRunRequest {
     /**
-     * <p>Name of the workflow to be updated.</p>
+     * <p>The name of the job definition to use.</p>
      */
-    Name: string | undefined;
+    JobName: string | undefined;
     /**
-     * <p>The description of the workflow.</p>
+     * <p>The ID of a previous <code>JobRun</code> to retry.</p>
      */
-    Description?: string;
+    JobRunId?: string;
     /**
-     * <p>A collection of properties to be used as part of each execution of the workflow.</p>
+     * <p>The job arguments specifically for this run. For this job run, they replace the default arguments set in the job definition itself.</p>
+     *          <p>You can specify arguments here that your own job-execution script
+     *       consumes, as well as arguments that Glue itself consumes.</p>
+     *          <p>For information about how to specify and consume your own Job arguments, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html">Calling Glue APIs in Python</a> topic in the developer guide.</p>
+     *          <p>For information about the key-value pairs that Glue consumes to set up your job, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html">Special Parameters Used by Glue</a> topic in the developer guide.</p>
      */
-    DefaultRunProperties?: {
+    Arguments?: {
         [key: string]: string;
     };
     /**
-     * <p>You can use this parameter to prevent unwanted multiple updates to data, to control costs, or in some cases, to prevent exceeding the maximum number of concurrent runs of any of the component jobs. If you leave this parameter blank, there is no limit to the number of concurrent workflow runs.</p>
+     * @deprecated
+     *
+     * <p>This field is deprecated. Use <code>MaxCapacity</code> instead.</p>
+     *
+     *          <p>The number of Glue data processing units (DPUs) to allocate to this JobRun.
+     *       From 2 to 100 DPUs can be allocated; the default is 10. A DPU is a relative measure
+     *       of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory.
+     *       For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue
+     *         pricing page</a>.</p>
      */
-    MaxConcurrentRuns?: number;
-}
+    AllocatedCapacity?: number;
+    /**
+     * <p>The <code>JobRun</code> timeout in minutes. This is the maximum time that a job run can
+     *       consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default
+     *       is 2,880 minutes (48 hours). This overrides the timeout value set in the parent job.</p>
+     */
+    Timeout?: number;
+    /**
+     * <p>The number of Glue data processing units (DPUs) that can be allocated when this job runs. A DPU is a relative measure
+     *       of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory.
+     *       For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue
+     *         pricing page</a>.</p>
+     *
+     *          <p>Do not set <code>Max Capacity</code> if using <code>WorkerType</code> and <code>NumberOfWorkers</code>.</p>
+     *
+     *          <p>The value that can be allocated for <code>MaxCapacity</code> depends on whether you are
+     *       running a Python shell job, or an Apache Spark ETL job:</p>
+     *          <ul>
+     *             <li>
+     *                <p>When you specify a Python shell job (<code>JobCommand.Name</code>="pythonshell"), you can
+     *         allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.</p>
+     *             </li>
+     *             <li>
+     *                <p>When you specify an Apache Spark ETL job (<code>JobCommand.Name</code>="glueetl"), you can allocate from 2 to 100 DPUs. The default is 10 DPUs. This job type cannot have a fractional DPU allocation.</p>
+     *             </li>
+     *          </ul>
+     */
+    MaxCapacity?: number;
+    /**
+     * <p>The name of the <code>SecurityConfiguration</code> structure to be used with this job
+     *       run.</p>
+     */
+    SecurityConfiguration?: string;
+    /**
+     * <p>Specifies configuration properties of a job run notification.</p>
+     */
+    NotificationProperty?: NotificationProperty;
+    /**
+     * <p>The type of predefined worker that is allocated when a job runs. Accepts a value of Standard, G.1X, or G.2X.</p>
+     *          <ul>
+     *             <li>
+     *                <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p>
+     *             </li>
+     *             <li>
+     *                <p>For the <code>G.1X</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 64GB disk, and 1 executor per worker.</p>
+     *             </li>
+     *             <li>
+     *                <p>For the <code>G.2X</code> worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.</p>
+     *             </li>
+     *          </ul>
+     */
+    WorkerType?: WorkerType | string;
+    /**
+     * <p>The number of workers of a defined <code>workerType</code> that are allocated when a job runs.</p>
+     *
+     *          <p>The maximum number of workers you can define are 299 for <code>G.1X</code>, and 149 for <code>G.2X</code>. </p>
+     */
+    NumberOfWorkers?: number;
+}
+export declare namespace StartJobRunRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartJobRunRequest) => any;
+}
+export interface StartJobRunResponse {
+    /**
+     * <p>The ID assigned to this job run.</p>
+     */
+    JobRunId?: string;
+}
+export declare namespace StartJobRunResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartJobRunResponse) => any;
+}
+/**
+ * <p>The machine learning transform is not ready to run.</p>
+ */
+export declare class MLTransformNotReadyException extends __BaseException {
+    readonly name: "MLTransformNotReadyException";
+    readonly $fault: "client";
+    /**
+     * <p>A message describing the problem.</p>
+     */
+    Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<MLTransformNotReadyException, __BaseException>);
+}
+export interface StartMLEvaluationTaskRunRequest {
+    /**
+     * <p>The unique identifier of the machine learning transform.</p>
+     */
+    TransformId: string | undefined;
+}
+export declare namespace StartMLEvaluationTaskRunRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartMLEvaluationTaskRunRequest) => any;
+}
+export interface StartMLEvaluationTaskRunResponse {
+    /**
+     * <p>The unique identifier associated with this run.</p>
+     */
+    TaskRunId?: string;
+}
+export declare namespace StartMLEvaluationTaskRunResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartMLEvaluationTaskRunResponse) => any;
+}
+export interface StartMLLabelingSetGenerationTaskRunRequest {
+    /**
+     * <p>The unique identifier of the machine learning transform.</p>
+     */
+    TransformId: string | undefined;
+    /**
+     * <p>The Amazon Simple Storage Service (Amazon S3) path where you generate the labeling
+     *       set.</p>
+     */
+    OutputS3Path: string | undefined;
+}
+export declare namespace StartMLLabelingSetGenerationTaskRunRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartMLLabelingSetGenerationTaskRunRequest) => any;
+}
+export interface StartMLLabelingSetGenerationTaskRunResponse {
+    /**
+     * <p>The unique run identifier that is associated with this task run.</p>
+     */
+    TaskRunId?: string;
+}
+export declare namespace StartMLLabelingSetGenerationTaskRunResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartMLLabelingSetGenerationTaskRunResponse) => any;
+}
+export interface StartTriggerRequest {
+    /**
+     * <p>The name of the trigger to start.</p>
+     */
+    Name: string | undefined;
+}
+export declare namespace StartTriggerRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartTriggerRequest) => any;
+}
+export interface StartTriggerResponse {
+    /**
+     * <p>The name of the trigger that was started.</p>
+     */
+    Name?: string;
+}
+export declare namespace StartTriggerResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartTriggerResponse) => any;
+}
+export interface StartWorkflowRunRequest {
+    /**
+     * <p>The name of the workflow to start.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>The workflow run properties for the new workflow run.</p>
+     */
+    RunProperties?: {
+        [key: string]: string;
+    };
+}
+export declare namespace StartWorkflowRunRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartWorkflowRunRequest) => any;
+}
+export interface StartWorkflowRunResponse {
+    /**
+     * <p>An Id for the new run.</p>
+     */
+    RunId?: string;
+}
+export declare namespace StartWorkflowRunResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartWorkflowRunResponse) => any;
+}
+/**
+ * <p>The specified crawler is not running.</p>
+ */
+export declare class CrawlerNotRunningException extends __BaseException {
+    readonly name: "CrawlerNotRunningException";
+    readonly $fault: "client";
+    /**
+     * <p>A message describing the problem.</p>
+     */
+    Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CrawlerNotRunningException, __BaseException>);
+}
+/**
+ * <p>The specified crawler is stopping.</p>
+ */
+export declare class CrawlerStoppingException extends __BaseException {
+    readonly name: "CrawlerStoppingException";
+    readonly $fault: "client";
+    /**
+     * <p>A message describing the problem.</p>
+     */
+    Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<CrawlerStoppingException, __BaseException>);
+}
+export interface StopCrawlerRequest {
+    /**
+     * <p>Name of the crawler to stop.</p>
+     */
+    Name: string | undefined;
+}
+export declare namespace StopCrawlerRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StopCrawlerRequest) => any;
+}
+export interface StopCrawlerResponse {
+}
+export declare namespace StopCrawlerResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StopCrawlerResponse) => any;
+}
+/**
+ * <p>The specified scheduler is not running.</p>
+ */
+export declare class SchedulerNotRunningException extends __BaseException {
+    readonly name: "SchedulerNotRunningException";
+    readonly $fault: "client";
+    /**
+     * <p>A message describing the problem.</p>
+     */
+    Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<SchedulerNotRunningException, __BaseException>);
+}
+export interface StopCrawlerScheduleRequest {
+    /**
+     * <p>Name of the crawler whose schedule state to set.</p>
+     */
+    CrawlerName: string | undefined;
+}
+export declare namespace StopCrawlerScheduleRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StopCrawlerScheduleRequest) => any;
+}
+export interface StopCrawlerScheduleResponse {
+}
+export declare namespace StopCrawlerScheduleResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StopCrawlerScheduleResponse) => any;
+}
+export interface StopSessionRequest {
+    /**
+     * <p>The ID of the session to be stopped.</p>
+     */
+    Id: string | undefined;
+    /**
+     * <p>The origin of the request.</p>
+     */
+    RequestOrigin?: string;
+}
+export declare namespace StopSessionRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StopSessionRequest) => any;
+}
+export interface StopSessionResponse {
+    /**
+     * <p>Returns the Id of the stopped session.</p>
+     */
+    Id?: string;
+}
+export declare namespace StopSessionResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StopSessionResponse) => any;
+}
+export interface StopTriggerRequest {
+    /**
+     * <p>The name of the trigger to stop.</p>
+     */
+    Name: string | undefined;
+}
+export declare namespace StopTriggerRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StopTriggerRequest) => any;
+}
+export interface StopTriggerResponse {
+    /**
+     * <p>The name of the trigger that was stopped.</p>
+     */
+    Name?: string;
+}
+export declare namespace StopTriggerResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StopTriggerResponse) => any;
+}
+export interface StopWorkflowRunRequest {
+    /**
+     * <p>The name of the workflow to stop.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>The ID of the workflow run to stop.</p>
+     */
+    RunId: string | undefined;
+}
+export declare namespace StopWorkflowRunRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StopWorkflowRunRequest) => any;
+}
+export interface StopWorkflowRunResponse {
+}
+export declare namespace StopWorkflowRunResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StopWorkflowRunResponse) => any;
+}
+export interface TagResourceRequest {
+    /**
+     * <p>The ARN of the Glue resource to which to add the tags. For more
+     *       information about Glue resource ARNs, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-common.html#aws-glue-api-regex-aws-glue-arn-id">Glue ARN string pattern</a>.</p>
+     */
+    ResourceArn: string | undefined;
+    /**
+     * <p>Tags to add to this resource.</p>
+     */
+    TagsToAdd: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    /**
+     * <p>The Amazon Resource Name (ARN) of the resource from which to remove the tags.</p>
+     */
+    ResourceArn: string | undefined;
+    /**
+     * <p>Tags to remove from this resource.</p>
+     */
+    TagsToRemove: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateBlueprintRequest {
+    /**
+     * <p>The name of the blueprint.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>A description of the blueprint.</p>
+     */
+    Description?: string;
+    /**
+     * <p>Specifies a path in Amazon S3 where the blueprint is published.</p>
+     */
+    BlueprintLocation: string | undefined;
+}
+export declare namespace UpdateBlueprintRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateBlueprintRequest) => any;
+}
+export interface UpdateBlueprintResponse {
+    /**
+     * <p>Returns the name of the blueprint that was updated.</p>
+     */
+    Name?: string;
+}
+export declare namespace UpdateBlueprintResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateBlueprintResponse) => any;
+}
+/**
+ * <p>Specifies a custom CSV classifier to be updated.</p>
+ */
+export interface UpdateCsvClassifierRequest {
+    /**
+     * <p>The name of the classifier.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>A custom symbol to denote what separates each column entry in the row.</p>
+     */
+    Delimiter?: string;
+    /**
+     * <p>A custom symbol to denote what combines content into a single column value. It must be
+     *       different from the column delimiter.</p>
+     */
+    QuoteSymbol?: string;
+    /**
+     * <p>Indicates whether the CSV file contains a header.</p>
+     */
+    ContainsHeader?: CsvHeaderOption | string;
+    /**
+     * <p>A list of strings representing column names.</p>
+     */
+    Header?: string[];
+    /**
+     * <p>Specifies not to trim values before identifying the type of column values. The default value is true.</p>
+     */
+    DisableValueTrimming?: boolean;
+    /**
+     * <p>Enables the processing of files that contain only one column.</p>
+     */
+    AllowSingleColumn?: boolean;
+}
+export declare namespace UpdateCsvClassifierRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateCsvClassifierRequest) => any;
+}
+/**
+ * <p>Specifies a grok classifier to update when passed to
+ *       <code>UpdateClassifier</code>.</p>
+ */
+export interface UpdateGrokClassifierRequest {
+    /**
+     * <p>The name of the <code>GrokClassifier</code>.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>An identifier of the data format that the classifier matches, such as Twitter, JSON, Omniture logs,
+     *       Amazon CloudWatch Logs, and so on.</p>
+     */
+    Classification?: string;
+    /**
+     * <p>The grok pattern used by this classifier.</p>
+     */
+    GrokPattern?: string;
+    /**
+     * <p>Optional custom grok patterns used by this classifier.</p>
+     */
+    CustomPatterns?: string;
+}
+export declare namespace UpdateGrokClassifierRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateGrokClassifierRequest) => any;
+}
+/**
+ * <p>Specifies a JSON classifier to be updated.</p>
+ */
+export interface UpdateJsonClassifierRequest {
+    /**
+     * <p>The name of the classifier.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>A <code>JsonPath</code> string defining the JSON data for the classifier to classify.
+     *       Glue supports a subset of JsonPath, as described in <a href="https://docs.aws.amazon.com/glue/latest/dg/custom-classifier.html#custom-classifier-json">Writing JsonPath Custom Classifiers</a>.</p>
+     */
+    JsonPath?: string;
+}
+export declare namespace UpdateJsonClassifierRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateJsonClassifierRequest) => any;
+}
+/**
+ * <p>Specifies an XML classifier to be updated.</p>
+ */
+export interface UpdateXMLClassifierRequest {
+    /**
+     * <p>The name of the classifier.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>An identifier of the data format that the classifier matches.</p>
+     */
+    Classification?: string;
+    /**
+     * <p>The XML tag designating the element that contains each record in an XML document being
+     *       parsed. This cannot identify a self-closing element (closed by <code>/></code>). An empty
+     *       row element that contains only attributes can be parsed as long as it ends with a closing tag
+     *       (for example, <code><row item_a="A" item_b="B"></row></code> is okay, but
+     *         <code><row item_a="A" item_b="B" /></code> is not).</p>
+     */
+    RowTag?: string;
+}
+export declare namespace UpdateXMLClassifierRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateXMLClassifierRequest) => any;
+}
+export interface UpdateClassifierRequest {
+    /**
+     * <p>A <code>GrokClassifier</code> object with updated fields.</p>
+     */
+    GrokClassifier?: UpdateGrokClassifierRequest;
+    /**
+     * <p>An <code>XMLClassifier</code> object with updated fields.</p>
+     */
+    XMLClassifier?: UpdateXMLClassifierRequest;
+    /**
+     * <p>A <code>JsonClassifier</code> object with updated fields.</p>
+     */
+    JsonClassifier?: UpdateJsonClassifierRequest;
+    /**
+     * <p>A <code>CsvClassifier</code> object with updated fields.</p>
+     */
+    CsvClassifier?: UpdateCsvClassifierRequest;
+}
+export declare namespace UpdateClassifierRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateClassifierRequest) => any;
+}
+export interface UpdateClassifierResponse {
+}
+export declare namespace UpdateClassifierResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateClassifierResponse) => any;
+}
+/**
+ * <p>There was a version conflict.</p>
+ */
+export declare class VersionMismatchException extends __BaseException {
+    readonly name: "VersionMismatchException";
+    readonly $fault: "client";
+    /**
+     * <p>A message describing the problem.</p>
+     */
+    Message?: string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<VersionMismatchException, __BaseException>);
+}
+export interface UpdateColumnStatisticsForPartitionRequest {
+    /**
+     * <p>The ID of the Data Catalog where the partitions in question reside.
+     *       If none is supplied, the Amazon Web Services account ID is used by default.</p>
+     */
+    CatalogId?: string;
+    /**
+     * <p>The name of the catalog database where the partitions reside.</p>
+     */
+    DatabaseName: string | undefined;
+    /**
+     * <p>The name of the partitions' table.</p>
+     */
+    TableName: string | undefined;
+    /**
+     * <p>A list of partition values identifying the partition.</p>
+     */
+    PartitionValues: string[] | undefined;
+    /**
+     * <p>A list of the column statistics.</p>
+     */
+    ColumnStatisticsList: ColumnStatistics[] | undefined;
+}
+export declare namespace UpdateColumnStatisticsForPartitionRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateColumnStatisticsForPartitionRequest) => any;
+}
+/**
+ * <p>Encapsulates a <code>ColumnStatistics</code> object that failed and the reason for failure.</p>
+ */
+export interface ColumnStatisticsError {
+    /**
+     * <p>The <code>ColumnStatistics</code> of the column.</p>
+     */
+    ColumnStatistics?: ColumnStatistics;
+    /**
+     * <p>An error message with the reason for the failure of an operation.</p>
+     */
+    Error?: ErrorDetail;
+}
+export declare namespace ColumnStatisticsError {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ColumnStatisticsError) => any;
+}
+export interface UpdateColumnStatisticsForPartitionResponse {
+    /**
+     * <p>Error occurred during updating column statistics data.</p>
+     */
+    Errors?: ColumnStatisticsError[];
+}
+export declare namespace UpdateColumnStatisticsForPartitionResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateColumnStatisticsForPartitionResponse) => any;
+}
+export interface UpdateColumnStatisticsForTableRequest {
+    /**
+     * <p>The ID of the Data Catalog where the partitions in question reside.
+     *       If none is supplied, the Amazon Web Services account ID is used by default.</p>
+     */
+    CatalogId?: string;
+    /**
+     * <p>The name of the catalog database where the partitions reside.</p>
+     */
+    DatabaseName: string | undefined;
+    /**
+     * <p>The name of the partitions' table.</p>
+     */
+    TableName: string | undefined;
+    /**
+     * <p>A list of the column statistics.</p>
+     */
+    ColumnStatisticsList: ColumnStatistics[] | undefined;
+}
+export declare namespace UpdateColumnStatisticsForTableRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateColumnStatisticsForTableRequest) => any;
+}
+export interface UpdateColumnStatisticsForTableResponse {
+    /**
+     * <p>List of ColumnStatisticsErrors.</p>
+     */
+    Errors?: ColumnStatisticsError[];
+}
+export declare namespace UpdateColumnStatisticsForTableResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateColumnStatisticsForTableResponse) => any;
+}
+export interface UpdateConnectionRequest {
+    /**
+     * <p>The ID of the Data Catalog in which the connection resides. If none is provided, the Amazon Web Services
+     *       account ID is used by default.</p>
+     */
+    CatalogId?: string;
+    /**
+     * <p>The name of the connection definition to update.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>A <code>ConnectionInput</code> object that redefines the connection
+     *       in question.</p>
+     */
+    ConnectionInput: ConnectionInput | undefined;
+}
+export declare namespace UpdateConnectionRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateConnectionRequest) => any;
+}
+export interface UpdateConnectionResponse {
+}
+export declare namespace UpdateConnectionResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateConnectionResponse) => any;
+}
+export interface UpdateCrawlerRequest {
+    /**
+     * <p>Name of the new crawler.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>The IAM role or Amazon Resource Name (ARN) of an IAM role that is used by the new crawler
+     *       to access customer resources.</p>
+     */
+    Role?: string;
+    /**
+     * <p>The Glue database where results are stored, such as:
+     *         <code>arn:aws:daylight:us-east-1::database/sometable/*</code>.</p>
+     */
+    DatabaseName?: string;
+    /**
+     * <p>A description of the new crawler.</p>
+     */
+    Description?: string;
+    /**
+     * <p>A list of targets to crawl.</p>
+     */
+    Targets?: CrawlerTargets;
+    /**
+     * <p>A <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run
+     *       something every day at 12:15 UTC, you would specify:
+     *       <code>cron(15 12 * * ? *)</code>.</p>
+     */
+    Schedule?: string;
+    /**
+     * <p>A list of custom classifiers that the user
+     *       has registered. By default, all built-in classifiers are included in a crawl,
+     *       but these custom classifiers always override the default classifiers
+     *       for a given classification.</p>
+     */
+    Classifiers?: string[];
+    /**
+     * <p>The table prefix used for catalog tables that are created.</p>
+     */
+    TablePrefix?: string;
+    /**
+     * <p>The policy for the crawler's update and deletion behavior.</p>
+     */
+    SchemaChangePolicy?: SchemaChangePolicy;
+    /**
+     * <p>A policy that specifies whether to crawl the entire dataset again, or to crawl only folders that were added since the last crawler run.</p>
+     */
+    RecrawlPolicy?: RecrawlPolicy;
+    /**
+     * <p>Specifies data lineage configuration settings for the crawler.</p>
+     */
+    LineageConfiguration?: LineageConfiguration;
+    /**
+     * <p>Specifies AWS Lake Formation configuration settings for the crawler.</p>
+     */
+    LakeFormationConfiguration?: LakeFormationConfiguration;
+    /**
+     * <p>Crawler configuration information. This versioned JSON string allows users
+     *         to specify aspects of a crawler's behavior.
+     *         For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/crawler-configuration.html">Configuring a Crawler</a>.</p>
+     */
+    Configuration?: string;
+    /**
+     * <p>The name of the <code>SecurityConfiguration</code> structure to be used by this
+     *       crawler.</p>
+     */
+    CrawlerSecurityConfiguration?: string;
+}
+export declare namespace UpdateCrawlerRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateCrawlerRequest) => any;
+}
+export interface UpdateCrawlerResponse {
+}
+export declare namespace UpdateCrawlerResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateCrawlerResponse) => any;
+}
+export interface UpdateCrawlerScheduleRequest {
+    /**
+     * <p>The name of the crawler whose schedule to update.</p>
+     */
+    CrawlerName: string | undefined;
+    /**
+     * <p>The updated <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based Schedules for Jobs and Crawlers</a>. For example, to run
+     *       something every day at 12:15 UTC, you would specify:
+     *       <code>cron(15 12 * * ? *)</code>.</p>
+     */
+    Schedule?: string;
+}
+export declare namespace UpdateCrawlerScheduleRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateCrawlerScheduleRequest) => any;
+}
+export interface UpdateCrawlerScheduleResponse {
+}
+export declare namespace UpdateCrawlerScheduleResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateCrawlerScheduleResponse) => any;
+}
+export interface UpdateDatabaseRequest {
+    /**
+     * <p>The ID of the Data Catalog in which the metadata database resides. If none is provided,
+     *       the Amazon Web Services account ID is used by default.</p>
+     */
+    CatalogId?: string;
+    /**
+     * <p>The name of the database to update in the catalog. For Hive
+     *       compatibility, this is folded to lowercase.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>A <code>DatabaseInput</code> object specifying the new definition
+     *       of the metadata database in the catalog.</p>
+     */
+    DatabaseInput: DatabaseInput | undefined;
+}
+export declare namespace UpdateDatabaseRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateDatabaseRequest) => any;
+}
+export interface UpdateDatabaseResponse {
+}
+export declare namespace UpdateDatabaseResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateDatabaseResponse) => any;
+}
+/**
+ * <p>Custom libraries to be loaded into a development endpoint.</p>
+ */
+export interface DevEndpointCustomLibraries {
+    /**
+     * <p>The paths to one or more Python libraries in an Amazon Simple Storage Service (Amazon S3)
+     *       bucket that should be loaded in your <code>DevEndpoint</code>. Multiple values must be
+     *       complete paths separated by a comma.</p>
+     *          <note>
+     *             <p>You can only use pure Python libraries with a <code>DevEndpoint</code>. Libraries that rely on
+     *         C extensions, such as the <a href="http://pandas.pydata.org/">pandas</a> Python data
+     *         analysis library, are not currently supported.</p>
+     *          </note>
+     */
+    ExtraPythonLibsS3Path?: string;
+    /**
+     * <p>The path to one or more Java <code>.jar</code> files in an S3 bucket that should be loaded
+     *       in your <code>DevEndpoint</code>.</p>
+     *          <note>
+     *             <p>You can only use pure Java/Scala libraries with a <code>DevEndpoint</code>.</p>
+     *          </note>
+     */
+    ExtraJarsS3Path?: string;
+}
+export declare namespace DevEndpointCustomLibraries {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DevEndpointCustomLibraries) => any;
+}
+export interface UpdateDevEndpointRequest {
+    /**
+     * <p>The name of the <code>DevEndpoint</code> to be updated.</p>
+     */
+    EndpointName: string | undefined;
+    /**
+     * <p>The public key for the <code>DevEndpoint</code> to use.</p>
+     */
+    PublicKey?: string;
+    /**
+     * <p>The list of public keys for the <code>DevEndpoint</code> to use.</p>
+     */
+    AddPublicKeys?: string[];
+    /**
+     * <p>The list of public keys to be deleted from the <code>DevEndpoint</code>.</p>
+     */
+    DeletePublicKeys?: string[];
+    /**
+     * <p>Custom Python or Java libraries to be loaded in the <code>DevEndpoint</code>.</p>
+     */
+    CustomLibraries?: DevEndpointCustomLibraries;
+    /**
+     * <p>
+     *             <code>True</code> if the list of custom libraries to be loaded in the development endpoint
+     *       needs to be updated, or <code>False</code> if otherwise.</p>
+     */
+    UpdateEtlLibraries?: boolean;
+    /**
+     * <p>The list of argument keys to be deleted from the map of arguments used to configure the
+     *         <code>DevEndpoint</code>.</p>
+     */
+    DeleteArguments?: string[];
+    /**
+     * <p>The map of arguments to add the map of arguments used to configure the
+     *         <code>DevEndpoint</code>.</p>
+     *
+     * 	        <p>Valid arguments are:</p>
+     * 	        <ul>
+     *             <li>
+     *                <p>
+     *                   <code>"--enable-glue-datacatalog": ""</code>
+     *                </p>
+     *             </li>
+     *          </ul>
+     *
+     *          <p>You can specify a version of Python support for development endpoints by using the <code>Arguments</code> parameter in the <code>CreateDevEndpoint</code> or <code>UpdateDevEndpoint</code> APIs. If no arguments are provided, the version defaults to Python 2.</p>
+     */
+    AddArguments?: {
+        [key: string]: string;
+    };
+}
+export declare namespace UpdateDevEndpointRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateDevEndpointRequest) => any;
+}
+export interface UpdateDevEndpointResponse {
+}
+export declare namespace UpdateDevEndpointResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateDevEndpointResponse) => any;
+}
+export interface UpdateJobResponse {
+    /**
+     * <p>Returns the name of the updated job definition.</p>
+     */
+    JobName?: string;
+}
+export declare namespace UpdateJobResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateJobResponse) => any;
+}
+export interface UpdateMLTransformRequest {
+    /**
+     * <p>A unique identifier that was generated when the transform was created.</p>
+     */
+    TransformId: string | undefined;
+    /**
+     * <p>The unique name that you gave the transform when you created it.</p>
+     */
+    Name?: string;
+    /**
+     * <p>A description of the transform. The default is an empty string.</p>
+     */
+    Description?: string;
+    /**
+     * <p>The configuration parameters that are specific to the transform type (algorithm) used.
+     *       Conditionally dependent on the transform type.</p>
+     */
+    Parameters?: TransformParameters;
+    /**
+     * <p>The name or Amazon Resource Name (ARN) of the IAM role with the required
+     *       permissions.</p>
+     */
+    Role?: string;
+    /**
+     * <p>This value determines which version of Glue this machine learning transform is compatible with. Glue 1.0 is recommended for most customers. If the value is not set, the Glue compatibility defaults to Glue 0.9.  For more information, see <a href="https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions">Glue Versions</a> in the developer guide.</p>
+     */
+    GlueVersion?: string;
+    /**
+     * <p>The number of Glue data processing units (DPUs) that are allocated to task runs for this transform. You can allocate from 2 to 100 DPUs; the default is 10. A DPU is a relative measure of
+     *       processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more
+     *       information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing
+     *         page</a>. </p>
+     *
+     *          <p>When the <code>WorkerType</code> field is set to a value other than <code>Standard</code>, the <code>MaxCapacity</code> field is set automatically and becomes read-only.</p>
+     */
+    MaxCapacity?: number;
+    /**
+     * <p>The type of predefined worker that is allocated when this task runs. Accepts a value of Standard, G.1X, or G.2X.</p>
+     * 	        <ul>
+     *             <li>
+     *                <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p>
+     *             </li>
+     *             <li>
+     *                <p>For the <code>G.1X</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 64GB disk, and 1 executor per worker.</p>
+     *             </li>
+     *             <li>
+     *                <p>For the <code>G.2X</code> worker type, each worker provides 8 vCPU, 32 GB of memory and a 128GB disk, and 1 executor per worker.</p>
+     *             </li>
+     *          </ul>
+     */
+    WorkerType?: WorkerType | string;
+    /**
+     * <p>The number of workers of a defined <code>workerType</code> that are allocated when this task runs.</p>
+     */
+    NumberOfWorkers?: number;
+    /**
+     * <p>The timeout for a task run for this transform in minutes. This is the maximum time that a task run for this transform can consume resources before it is terminated and enters <code>TIMEOUT</code> status. The default is 2,880 minutes (48 hours).</p>
+     */
+    Timeout?: number;
+    /**
+     * <p>The maximum number of times to retry a task for this transform after a task run fails.</p>
+     */
+    MaxRetries?: number;
+}
+export declare namespace UpdateMLTransformRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateMLTransformRequest) => any;
+}
+export interface UpdateMLTransformResponse {
+    /**
+     * <p>The unique identifier for the transform that was updated.</p>
+     */
+    TransformId?: string;
+}
+export declare namespace UpdateMLTransformResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateMLTransformResponse) => any;
+}
+export interface UpdatePartitionRequest {
+    /**
+     * <p>The ID of the Data Catalog where the partition to be updated resides. If none is provided,
+     *       the Amazon Web Services account ID is used by default.</p>
+     */
+    CatalogId?: string;
+    /**
+     * <p>The name of the catalog database in which the table in question
+     *       resides.</p>
+     */
+    DatabaseName: string | undefined;
+    /**
+     * <p>The name of the table in which the partition to be updated is located.</p>
+     */
+    TableName: string | undefined;
+    /**
+     * <p>List of partition key values that define the partition to update.</p>
+     */
+    PartitionValueList: string[] | undefined;
+    /**
+     * <p>The new partition object to update the partition to.</p>
+     *
+     * 	        <p>The <code>Values</code> property can't be changed. If you want to change the partition key values for a partition, delete and recreate the partition.</p>
+     */
+    PartitionInput: PartitionInput | undefined;
+}
+export declare namespace UpdatePartitionRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdatePartitionRequest) => any;
+}
+export interface UpdatePartitionResponse {
+}
+export declare namespace UpdatePartitionResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdatePartitionResponse) => any;
+}
+export interface UpdateRegistryInput {
+    /**
+     * <p>This is a wrapper structure that may contain the registry name and Amazon Resource Name (ARN).</p>
+     */
+    RegistryId: RegistryId | undefined;
+    /**
+     * <p>A description of the registry. If description is not provided, this field will not be updated.</p>
+     */
+    Description: string | undefined;
+}
+export declare namespace UpdateRegistryInput {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateRegistryInput) => any;
+}
+export interface UpdateRegistryResponse {
+    /**
+     * <p>The name of the updated registry.</p>
+     */
+    RegistryName?: string;
+    /**
+     * <p>The Amazon Resource name (ARN) of the updated registry.</p>
+     */
+    RegistryArn?: string;
+}
+export declare namespace UpdateRegistryResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateRegistryResponse) => any;
+}
+export interface UpdateSchemaInput {
+    /**
+     * <p>This is a wrapper structure to contain schema identity fields. The structure contains:</p>
+     * 	        <ul>
+     *             <li>
+     *                <p>SchemaId$SchemaArn: The Amazon Resource Name (ARN) of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p>
+     *             </li>
+     *             <li>
+     *                <p>SchemaId$SchemaName: The name of the schema. One of <code>SchemaArn</code> or <code>SchemaName</code> has to be provided.</p>
+     *             </li>
+     *          </ul>
+     */
+    SchemaId: SchemaId | undefined;
+    /**
+     * <p>Version number required for check pointing. One of <code>VersionNumber</code> or <code>Compatibility</code> has to be provided.</p>
+     */
+    SchemaVersionNumber?: SchemaVersionNumber;
+    /**
+     * <p>The new compatibility setting for the schema.</p>
+     */
+    Compatibility?: Compatibility | string;
+    /**
+     * <p>The new description for the schema.</p>
+     */
+    Description?: string;
+}
+export declare namespace UpdateSchemaInput {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateSchemaInput) => any;
+}
+export interface UpdateSchemaResponse {
+    /**
+     * <p>The Amazon Resource Name (ARN) of the schema.</p>
+     */
+    SchemaArn?: string;
+    /**
+     * <p>The name of the schema.</p>
+     */
+    SchemaName?: string;
+    /**
+     * <p>The name of the registry that contains the schema.</p>
+     */
+    RegistryName?: string;
+}
+export declare namespace UpdateSchemaResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateSchemaResponse) => any;
+}
+export interface UpdateTableRequest {
+    /**
+     * <p>The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account
+     *       ID is used by default.</p>
+     */
+    CatalogId?: string;
+    /**
+     * <p>The name of the catalog database in which the table resides. For Hive
+     *       compatibility, this name is entirely lowercase.</p>
+     */
+    DatabaseName: string | undefined;
+    /**
+     * <p>An updated <code>TableInput</code> object to define the metadata table
+     *       in the catalog.</p>
+     */
+    TableInput: TableInput | undefined;
+    /**
+     * <p>By default, <code>UpdateTable</code> always creates an archived version of the table
+     *       before updating it. However, if <code>skipArchive</code> is set to true,
+     *         <code>UpdateTable</code> does not create the archived version.</p>
+     */
+    SkipArchive?: boolean;
+    /**
+     * <p>The transaction ID at which to update the table contents. </p>
+     */
+    TransactionId?: string;
+    VersionId?: string;
+}
+export declare namespace UpdateTableRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateTableRequest) => any;
+}
+export interface UpdateTableResponse {
+}
+export declare namespace UpdateTableResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateTableResponse) => any;
+}
+/**
+ * <p>A structure used to provide information used to update a trigger. This object updates the
+ *       previous trigger definition by overwriting it completely.</p>
+ */
+export interface TriggerUpdate {
+    /**
+     * <p>Reserved for future use.</p>
+     */
+    Name?: string;
+    /**
+     * <p>A description of this trigger.</p>
+     */
+    Description?: string;
+    /**
+     * <p>A <code>cron</code> expression used to specify the schedule (see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-data-warehouse-schedule.html">Time-Based
+     *       Schedules for Jobs and Crawlers</a>. For example, to run
+     *       something every day at 12:15 UTC, you would specify:
+     *       <code>cron(15 12 * * ? *)</code>.</p>
+     */
+    Schedule?: string;
+    /**
+     * <p>The actions initiated by this trigger.</p>
+     */
+    Actions?: Action[];
+    /**
+     * <p>The predicate of this trigger, which defines when it will fire.</p>
+     */
+    Predicate?: Predicate;
+    /**
+     * <p>Batch condition that must be met (specified number of events received or batch time window expired)
+     *       before EventBridge event trigger fires.</p>
+     */
+    EventBatchingCondition?: EventBatchingCondition;
+}
+export declare namespace TriggerUpdate {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: TriggerUpdate) => any;
+}
+export interface UpdateTriggerRequest {
+    /**
+     * <p>The name of the trigger to update.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>The new values with which to update the trigger.</p>
+     */
+    TriggerUpdate: TriggerUpdate | undefined;
+}
+export declare namespace UpdateTriggerRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateTriggerRequest) => any;
+}
+export interface UpdateTriggerResponse {
+    /**
+     * <p>The resulting trigger definition.</p>
+     */
+    Trigger?: Trigger;
+}
+export declare namespace UpdateTriggerResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateTriggerResponse) => any;
+}
+export interface UpdateUserDefinedFunctionRequest {
+    /**
+     * <p>The ID of the Data Catalog where the function to be updated is located. If none is
+     *       provided, the Amazon Web Services account ID is used by default.</p>
+     */
+    CatalogId?: string;
+    /**
+     * <p>The name of the catalog database where the function to be updated is
+     *       located.</p>
+     */
+    DatabaseName: string | undefined;
+    /**
+     * <p>The name of the function.</p>
+     */
+    FunctionName: string | undefined;
+    /**
+     * <p>A <code>FunctionInput</code> object that redefines the function in the Data
+     *       Catalog.</p>
+     */
+    FunctionInput: UserDefinedFunctionInput | undefined;
+}
+export declare namespace UpdateUserDefinedFunctionRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateUserDefinedFunctionRequest) => any;
+}
+export interface UpdateUserDefinedFunctionResponse {
+}
+export declare namespace UpdateUserDefinedFunctionResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateUserDefinedFunctionResponse) => any;
+}
+export interface UpdateWorkflowRequest {
+    /**
+     * <p>Name of the workflow to be updated.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>The description of the workflow.</p>
+     */
+    Description?: string;
+    /**
+     * <p>A collection of properties to be used as part of each execution of the workflow.</p>
+     */
+    DefaultRunProperties?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>You can use this parameter to prevent unwanted multiple updates to data, to control costs, or in some cases, to prevent exceeding the maximum number of concurrent runs of any of the component jobs. If you leave this parameter blank, there is no limit to the number of concurrent workflow runs.</p>
+     */
+    MaxConcurrentRuns?: number;
+}
 export declare namespace UpdateWorkflowRequest {
     /**
      * @internal
      */
-    const filterSensitiveLog: (obj: UpdateWorkflowRequest) => any;
+    const filterSensitiveLog: (obj: UpdateWorkflowRequest) => any;
+}
+export interface UpdateWorkflowResponse {
+    /**
+     * <p>The name of the workflow which was specified in input.</p>
+     */
+    Name?: string;
+}
+export declare namespace UpdateWorkflowResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateWorkflowResponse) => any;
+}
+/**
+ * <p>Specifies the mapping of data property keys.</p>
+ */
+export interface Mapping {
+    /**
+     * <p>After the apply mapping, what the name of the column should be. Can be the same as <code>FromPath</code>.</p>
+     */
+    ToKey?: string;
+    /**
+     * <p>The table or column to be modified.</p>
+     */
+    FromPath?: string[];
+    /**
+     * <p>The type of the data to be modified.</p>
+     */
+    FromType?: string;
+    /**
+     * <p>The data type that the data is to be modified to.</p>
+     */
+    ToType?: string;
+    /**
+     * <p>If true, then the column is removed.</p>
+     */
+    Dropped?: boolean;
+    /**
+     * <p>Only applicable to nested data structures. If you want to change the parent structure, but also one of its children, you can fill out this data strucutre. It is also <code>Mapping</code>, but its <code>FromPath</code> will be the parent's <code>FromPath</code> plus the <code>FromPath</code> from this structure.</p>
+     *
+     *          <p>For the children part, suppose you have the structure:</p>
+     *
+     * 	        <p>
+     *             <code>{
+     *   "FromPath": "OuterStructure",
+     *   "ToKey": "OuterStructure",
+     *   "ToType": "Struct",
+     *   "Dropped": false,
+     *   "Chidlren": [{
+     *        "FromPath": "inner",
+     *        "ToKey": "inner",
+     *        "ToType": "Double",
+     *       "Dropped": false,
+     *   }]
+     * }</code>
+     *          </p>
+     *
+     *          <p>You can specify a <code>Mapping</code> that looks like:</p>
+     *
+     * 	        <p>
+     *             <code>{
+     *   "FromPath": "OuterStructure",
+     *   "ToKey": "OuterStructure",
+     *   "ToType": "Struct",
+     *   "Dropped": false,
+     *   "Chidlren": [{
+     *        "FromPath": "inner",
+     *        "ToKey": "inner",
+     *        "ToType": "Double",
+     *       "Dropped": false,
+     *   }]
+     * }</code>
+     *          </p>
+     */
+    Children?: Mapping[];
+}
+export declare namespace Mapping {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: Mapping) => any;
+}
+/**
+ * <p>Specifies a transform that maps data property keys in the data source to data property keys in the data target. You can rename keys, modify the data types for keys, and choose which keys to drop from the dataset.</p>
+ */
+export interface ApplyMapping {
+    /**
+     * <p>The name of the transform node.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>The data inputs identified by their node names.</p>
+     */
+    Inputs: string[] | undefined;
+    /**
+     * <p>Specifies the mapping of data property keys in the data source to data property keys in the data target.</p>
+     */
+    Mapping: Mapping[] | undefined;
+}
+export declare namespace ApplyMapping {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ApplyMapping) => any;
+}
+/**
+ * <p>
+ *             <code>CodeGenConfigurationNode</code> enumerates all valid Node types. One and only one of its member variables can be populated.</p>
+ */
+export interface CodeGenConfigurationNode {
+    /**
+     * <p>Specifies a connector to an Amazon Athena data source.</p>
+     */
+    AthenaConnectorSource?: AthenaConnectorSource;
+    /**
+     * <p>Specifies a connector to a JDBC data source.</p>
+     */
+    JDBCConnectorSource?: JDBCConnectorSource;
+    /**
+     * <p>Specifies a connector to an Apache Spark data source.</p>
+     */
+    SparkConnectorSource?: SparkConnectorSource;
+    /**
+     * <p>Specifies a data store in the Glue Data Catalog.</p>
+     */
+    CatalogSource?: CatalogSource;
+    /**
+     * <p>Specifies an Amazon Redshift data store.</p>
+     */
+    RedshiftSource?: RedshiftSource;
+    /**
+     * <p>Specifies an Amazon S3 data store in the Glue Data Catalog.</p>
+     */
+    S3CatalogSource?: S3CatalogSource;
+    /**
+     * <p>Specifies a command-separated value (CSV) data store stored in Amazon S3.</p>
+     */
+    S3CsvSource?: S3CsvSource;
+    /**
+     * <p>Specifies a JSON data store stored in Amazon S3.</p>
+     */
+    S3JsonSource?: S3JsonSource;
+    /**
+     * <p>Specifies an Apache Parquet data store stored in Amazon S3.</p>
+     */
+    S3ParquetSource?: S3ParquetSource;
+    /**
+     * <p>Specifies a Relational database data source in the Glue Data Catalog.</p>
+     */
+    RelationalCatalogSource?: RelationalCatalogSource;
+    /**
+     * <p>Specifies a DynamoDB data source in the Glue Data Catalog.</p>
+     */
+    DynamoDBCatalogSource?: DynamoDBCatalogSource;
+    /**
+     * <p>Specifies a data target that writes to Amazon S3 in Apache Parquet columnar storage.</p>
+     */
+    JDBCConnectorTarget?: JDBCConnectorTarget;
+    /**
+     * <p>Specifies a target that uses an Apache Spark connector.</p>
+     */
+    SparkConnectorTarget?: SparkConnectorTarget;
+    /**
+     * <p>Specifies a target that uses a Glue Data Catalog table.</p>
+     */
+    CatalogTarget?: BasicCatalogTarget;
+    /**
+     * <p>Specifies a target that uses Amazon Redshift.</p>
+     */
+    RedshiftTarget?: RedshiftTarget;
+    /**
+     * <p>Specifies a data target that writes to Amazon S3 using the Glue Data Catalog.</p>
+     */
+    S3CatalogTarget?: S3CatalogTarget;
+    /**
+     * <p>Specifies a data target that writes to Amazon S3 in Apache Parquet columnar storage.</p>
+     */
+    S3GlueParquetTarget?: S3GlueParquetTarget;
+    /**
+     * <p>Specifies a data target that writes to Amazon S3.</p>
+     */
+    S3DirectTarget?: S3DirectTarget;
+    /**
+     * <p>Specifies a transform that maps data property keys in the data source to data property keys in the data target. You can rename keys, modify the data types for keys, and choose which keys to drop from the dataset.</p>
+     */
+    ApplyMapping?: ApplyMapping;
+    /**
+     * <p>Specifies a transform that chooses the data property keys that you want to keep.</p>
+     */
+    SelectFields?: SelectFields;
+    /**
+     * <p>Specifies a transform that chooses the data property keys that you want to drop.</p>
+     */
+    DropFields?: DropFields;
+    /**
+     * <p>Specifies a transform that renames a single data property key.</p>
+     */
+    RenameField?: RenameField;
+    /**
+     * <p>Specifies a transform that writes samples of the data to an Amazon S3 bucket.</p>
+     */
+    Spigot?: Spigot;
+    /**
+     * <p>Specifies a transform that joins two datasets into one dataset using a comparison phrase on the specified data property keys. You can use inner, outer, left, right, left semi, and left anti joins.</p>
+     */
+    Join?: Join;
+    /**
+     * <p>Specifies a transform that splits data property keys into two <code>DynamicFrames</code>. The output is a collection of <code>DynamicFrames</code>: one with selected data property keys, and one with the remaining data property keys.</p>
+     */
+    SplitFields?: SplitFields;
+    /**
+     * <p>Specifies a transform that chooses one <code>DynamicFrame</code> from a collection of <code>DynamicFrames</code>. The output is the selected <code>DynamicFrame</code>
+     *          </p>
+     */
+    SelectFromCollection?: SelectFromCollection;
+    /**
+     * <p>Specifies a transform that locates records in the dataset that have missing values and adds a new field with a value determined by imputation. The input data set is used to train the machine learning model that determines what the missing value should be.</p>
+     */
+    FillMissingValues?: FillMissingValues;
+    /**
+     * <p>Specifies a transform that splits a dataset into two, based on a filter condition.</p>
+     */
+    Filter?: Filter;
+    /**
+     * <p>Specifies a transform that uses custom code you provide to perform the data transformation. The output is a collection of DynamicFrames.</p>
+     */
+    CustomCode?: CustomCode;
+    /**
+     * <p>Specifies a transform where you enter a SQL query using Spark SQL syntax to transform the data. The output is a single <code>DynamicFrame</code>.</p>
+     */
+    SparkSQL?: SparkSQL;
+    /**
+     * <p>Specifies a direct Amazon Kinesis data source.</p>
+     */
+    DirectKinesisSource?: DirectKinesisSource;
+    /**
+     * <p>Specifies an Apache Kafka data store.</p>
+     */
+    DirectKafkaSource?: DirectKafkaSource;
+    /**
+     * <p>Specifies a Kinesis data source in the Glue Data Catalog.</p>
+     */
+    CatalogKinesisSource?: CatalogKinesisSource;
+    /**
+     * <p>Specifies an Apache Kafka data store in the Data Catalog.</p>
+     */
+    CatalogKafkaSource?: CatalogKafkaSource;
+    /**
+     * <p>Specifies a transform that removes columns from the dataset if all values in the column are 'null'. By default, Glue Studio will recognize null objects, but some values such as empty strings, strings that are "null", -1 integers or other placeholders such as zeros, are not automatically recognized as nulls.</p>
+     */
+    DropNullFields?: DropNullFields;
+    /**
+     * <p>Specifies a transform that merges a <code>DynamicFrame</code> with a staging <code>DynamicFrame</code> based on the specified primary keys to identify records. Duplicate records (records with the same primary keys) are not de-duplicated. </p>
+     */
+    Merge?: Merge;
+    /**
+     * <p>Specifies a transform that combines the rows from two or more datasets into a single result.</p>
+     */
+    Union?: Union;
+    /**
+     * <p>Specifies a transform that identifies, removes or masks PII data.</p>
+     */
+    PIIDetection?: PIIDetection;
+    /**
+     * <p>Specifies a transform that groups rows by chosen fields and computes the aggregated value by specified function.</p>
+     */
+    Aggregate?: Aggregate;
+    /**
+     * <p>Specifies a transform that removes rows of repeating data from a data set.</p>
+     */
+    DropDuplicates?: DropDuplicates;
+    /**
+     * <p>Specifies a data target that writes to a goverened catalog.</p>
+     */
+    GovernedCatalogTarget?: GovernedCatalogTarget;
+    /**
+     * <p>Specifies a data source in a goverened Data Catalog.</p>
+     */
+    GovernedCatalogSource?: GovernedCatalogSource;
+    /**
+     * <p>Specifies a Microsoft SQL server data source in the Glue Data Catalog.</p>
+     */
+    MicrosoftSQLServerCatalogSource?: MicrosoftSQLServerCatalogSource;
+    /**
+     * <p>Specifies a MySQL data source in the Glue Data Catalog.</p>
+     */
+    MySQLCatalogSource?: MySQLCatalogSource;
+    /**
+     * <p>Specifies an Oracle data source in the Glue Data Catalog.</p>
+     */
+    OracleSQLCatalogSource?: OracleSQLCatalogSource;
+    /**
+     * <p>Specifies a PostgresSQL data source in the Glue Data Catalog.</p>
+     */
+    PostgreSQLCatalogSource?: PostgreSQLCatalogSource;
+    /**
+     * <p>Specifies a target that uses Microsoft SQL.</p>
+     */
+    MicrosoftSQLServerCatalogTarget?: MicrosoftSQLServerCatalogTarget;
+    /**
+     * <p>Specifies a target that uses MySQL.</p>
+     */
+    MySQLCatalogTarget?: MySQLCatalogTarget;
+    /**
+     * <p>Specifies a target that uses Oracle SQL.</p>
+     */
+    OracleSQLCatalogTarget?: OracleSQLCatalogTarget;
+    /**
+     * <p>Specifies a target that uses Postgres SQL.</p>
+     */
+    PostgreSQLCatalogTarget?: PostgreSQLCatalogTarget;
+}
+export declare namespace CodeGenConfigurationNode {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CodeGenConfigurationNode) => any;
+}
+export interface CreateJobRequest {
+    /**
+     * <p>The name you assign to this job definition. It must be unique in your account.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>Description of the job being defined.</p>
+     */
+    Description?: string;
+    /**
+     * <p>This field is reserved for future use.</p>
+     */
+    LogUri?: string;
+    /**
+     * <p>The name or Amazon Resource Name (ARN) of the IAM role associated with this job.</p>
+     */
+    Role: string | undefined;
+    /**
+     * <p>An <code>ExecutionProperty</code> specifying the maximum number of concurrent runs allowed
+     *       for this job.</p>
+     */
+    ExecutionProperty?: ExecutionProperty;
+    /**
+     * <p>The <code>JobCommand</code> that runs this job.</p>
+     */
+    Command: JobCommand | undefined;
+    /**
+     * <p>The default arguments for this job.</p>
+     *          <p>You can specify arguments here that your own job-execution script
+     *       consumes, as well as arguments that Glue itself consumes.</p>
+     *          <p>For information about how to specify and consume your own Job arguments, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html">Calling Glue APIs in Python</a> topic in the developer guide.</p>
+     *          <p>For information about the key-value pairs that Glue consumes to set up your job, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html">Special Parameters Used by Glue</a> topic in the developer guide.</p>
+     */
+    DefaultArguments?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>Non-overridable arguments for this job, specified as name-value pairs.</p>
+     */
+    NonOverridableArguments?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>The connections used for this job.</p>
+     */
+    Connections?: ConnectionsList;
+    /**
+     * <p>The maximum number of times to retry this job if it fails.</p>
+     */
+    MaxRetries?: number;
+    /**
+     * @deprecated
+     *
+     * <p>This parameter is deprecated. Use <code>MaxCapacity</code> instead.</p>
+     *
+     *          <p>The number of Glue data processing units (DPUs) to allocate to this Job. You can
+     *       allocate from 2 to 100 DPUs; the default is 10. A DPU is a relative measure of processing
+     *       power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information,
+     *       see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing
+     *       page</a>.</p>
+     */
+    AllocatedCapacity?: number;
+    /**
+     * <p>The job timeout in minutes.  This is the maximum time that a job run
+     *       can consume resources before it is terminated and enters <code>TIMEOUT</code>
+     *       status. The default is 2,880 minutes (48 hours).</p>
+     */
+    Timeout?: number;
+    /**
+     * <p>For Glue version 1.0 or earlier jobs, using the standard worker type, the number of Glue data processing units (DPUs) that can be allocated when this job runs. A DPU is a relative measure
+     *        of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory.
+     *        For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue
+     *          pricing page</a>.</p>
+     *
+     * 	        <p>Do not set <code>Max Capacity</code> if using <code>WorkerType</code> and <code>NumberOfWorkers</code>.</p>
+     *
+     *          <p>The value that can be allocated for <code>MaxCapacity</code> depends on whether you are
+     *       running a Python shell job or an Apache Spark ETL job:</p>
+     *          <ul>
+     *             <li>
+     *                <p>When you specify a Python shell job (<code>JobCommand.Name</code>="pythonshell"), you can
+     *           allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.</p>
+     *             </li>
+     *             <li>
+     *                <p>When you specify an Apache Spark ETL job (<code>JobCommand.Name</code>="glueetl") or Apache
+     *          Spark streaming ETL job (<code>JobCommand.Name</code>="gluestreaming"), you can allocate from 2 to 100 DPUs.
+     *          The default is 10 DPUs. This job type cannot have a fractional DPU allocation.</p>
+     *             </li>
+     *          </ul>
+     *          <p>For Glue version 2.0 jobs, you cannot instead specify a <code>Maximum capacity</code>. Instead, you should specify a <code>Worker type</code> and the <code>Number of workers</code>.</p>
+     */
+    MaxCapacity?: number;
+    /**
+     * <p>The name of the <code>SecurityConfiguration</code> structure to be used with this
+     *       job.</p>
+     */
+    SecurityConfiguration?: string;
+    /**
+     * <p>The tags to use with this job. You may use tags to limit access to the job. For more information about tags in Glue, see <a href="https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html">Amazon Web Services Tags in Glue</a> in the developer guide.</p>
+     */
+    Tags?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>Specifies configuration properties of a job notification.</p>
+     */
+    NotificationProperty?: NotificationProperty;
+    /**
+     * <p>Glue version determines the versions of Apache Spark and Python that Glue supports. The Python version indicates the version supported for jobs of type Spark. </p>
+     *
+     *          <p>For more information about the available Glue versions and corresponding Spark and Python versions, see <a href="https://docs.aws.amazon.com/glue/latest/dg/add-job.html">Glue version</a> in the developer guide.</p>
+     *
+     * 	        <p>Jobs that are created without specifying a Glue version default to Glue 0.9.</p>
+     */
+    GlueVersion?: string;
+    /**
+     * <p>The number of workers of a defined <code>workerType</code> that are allocated when a job runs.</p>
+     *
+     * 	        <p>The maximum number of workers you can define are 299 for <code>G.1X</code>, and 149 for <code>G.2X</code>. </p>
+     */
+    NumberOfWorkers?: number;
+    /**
+     * <p>The type of predefined worker that is allocated when a job runs. Accepts a value of Standard, G.1X, or G.2X.</p>
+     * 	        <ul>
+     *             <li>
+     *                <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p>
+     *             </li>
+     *             <li>
+     *                <p>For the <code>G.1X</code> worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p>
+     *             </li>
+     *             <li>
+     *                <p>For the <code>G.2X</code> worker type, each worker maps to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p>
+     *             </li>
+     *          </ul>
+     */
+    WorkerType?: WorkerType | string;
+    /**
+     * <p>The representation of a directed acyclic graph on which both the Glue Studio visual component and Glue Studio code generation is based.</p>
+     */
+    CodeGenConfigurationNodes?: {
+        [key: string]: CodeGenConfigurationNode;
+    };
+}
+export declare namespace CreateJobRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CreateJobRequest) => any;
 }
-export interface UpdateWorkflowResponse {
+/**
+ * <p>Specifies a job definition.</p>
+ */
+export interface Job {
     /**
-     * <p>The name of the workflow which was specified in input.</p>
+     * <p>The name you assign to this job definition.</p>
      */
     Name?: string;
+    /**
+     * <p>A description of the job.</p>
+     */
+    Description?: string;
+    /**
+     * <p>This field is reserved for future use.</p>
+     */
+    LogUri?: string;
+    /**
+     * <p>The name or Amazon Resource Name (ARN) of the IAM role associated with this job.</p>
+     */
+    Role?: string;
+    /**
+     * <p>The time and date that this job definition was created.</p>
+     */
+    CreatedOn?: Date;
+    /**
+     * <p>The last point in time when this job definition was modified.</p>
+     */
+    LastModifiedOn?: Date;
+    /**
+     * <p>An <code>ExecutionProperty</code> specifying the maximum number of concurrent runs allowed
+     *       for this job.</p>
+     */
+    ExecutionProperty?: ExecutionProperty;
+    /**
+     * <p>The <code>JobCommand</code> that runs this job.</p>
+     */
+    Command?: JobCommand;
+    /**
+     * <p>The default arguments for this job, specified as name-value pairs.</p>
+     *          <p>You can specify arguments here that your own job-execution script
+     *       consumes, as well as arguments that Glue itself consumes.</p>
+     *          <p>For information about how to specify and consume your own Job arguments, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html">Calling Glue APIs in Python</a> topic in the developer guide.</p>
+     *          <p>For information about the key-value pairs that Glue consumes to set up your job, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html">Special Parameters Used by Glue</a> topic in the developer guide.</p>
+     */
+    DefaultArguments?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>Non-overridable arguments for this job, specified as name-value pairs.</p>
+     */
+    NonOverridableArguments?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>The connections used for this job.</p>
+     */
+    Connections?: ConnectionsList;
+    /**
+     * <p>The maximum number of times to retry this job after a JobRun fails.</p>
+     */
+    MaxRetries?: number;
+    /**
+     * @deprecated
+     *
+     * <p>This field is deprecated. Use <code>MaxCapacity</code> instead.</p>
+     *
+     *          <p>The number of Glue data processing units (DPUs) allocated to runs of this job. You can
+     *       allocate from 2 to 100 DPUs; the default is 10. A DPU is a relative measure of processing
+     *       power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information,
+     *       see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing
+     *       page</a>.</p>
+     * 	        <p></p>
+     */
+    AllocatedCapacity?: number;
+    /**
+     * <p>The job timeout in minutes.  This is the maximum time that a job run
+     *       can consume resources before it is terminated and enters <code>TIMEOUT</code>
+     *       status. The default is 2,880 minutes (48 hours).</p>
+     */
+    Timeout?: number;
+    /**
+     * <p>For Glue version 1.0 or earlier jobs, using the standard worker type, the number of Glue data processing units (DPUs) that can be allocated when this job runs. A DPU is a relative measure
+     *       of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory.
+     *       For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue
+     *       pricing page</a>.</p>
+     *
+     * 	        <p>Do not set <code>Max Capacity</code> if using <code>WorkerType</code> and <code>NumberOfWorkers</code>.</p>
+     *
+     * 	        <p>The value that can be allocated for <code>MaxCapacity</code> depends on whether you are
+     *       running a Python shell job, an Apache Spark ETL job, or an Apache Spark streaming ETL
+     *       job:</p>
+     *         <ul>
+     *             <li>
+     *                <p>When you specify a Python shell job (<code>JobCommand.Name</code>="pythonshell"), you can
+     *           allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.</p>
+     *             </li>
+     *             <li>
+     *                <p>When you specify an Apache Spark ETL job (<code>JobCommand.Name</code>="glueetl") or Apache
+     *             Spark streaming ETL job (<code>JobCommand.Name</code>="gluestreaming"), you can allocate from 2 to 100 DPUs.
+     *             The default is 10 DPUs. This job type cannot have a fractional DPU allocation.</p>
+     *             </li>
+     *          </ul>
+     *          <p>For Glue version 2.0 jobs, you cannot instead specify a <code>Maximum capacity</code>. Instead, you should specify a <code>Worker type</code> and the <code>Number of workers</code>.</p>
+     */
+    MaxCapacity?: number;
+    /**
+     * <p>The type of predefined worker that is allocated when a job runs. Accepts a value of Standard, G.1X, or G.2X.</p>
+     * 	        <ul>
+     *             <li>
+     *                <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p>
+     *             </li>
+     *             <li>
+     *                <p>For the <code>G.1X</code> worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p>
+     *             </li>
+     *             <li>
+     *                <p>For the <code>G.2X</code> worker type, each worker maps to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p>
+     *             </li>
+     *          </ul>
+     */
+    WorkerType?: WorkerType | string;
+    /**
+     * <p>The number of workers of a defined <code>workerType</code> that are allocated when a job runs.</p>
+     *
+     * 		       <p>The maximum number of workers you can define are 299 for <code>G.1X</code>, and 149 for <code>G.2X</code>. </p>
+     */
+    NumberOfWorkers?: number;
+    /**
+     * <p>The name of the <code>SecurityConfiguration</code> structure to be used with this
+     *       job.</p>
+     */
+    SecurityConfiguration?: string;
+    /**
+     * <p>Specifies configuration properties of a job notification.</p>
+     */
+    NotificationProperty?: NotificationProperty;
+    /**
+     * <p>Glue version determines the versions of Apache Spark and Python that Glue supports. The Python version indicates the version supported for jobs of type Spark. </p>
+     *
+     *          <p>For more information about the available Glue versions and corresponding Spark and Python versions, see <a href="https://docs.aws.amazon.com/glue/latest/dg/add-job.html">Glue version</a> in the developer guide.</p>
+     *
+     * 	        <p>Jobs that are created without specifying a Glue version default to Glue 0.9.</p>
+     */
+    GlueVersion?: string;
+    /**
+     * <p>The representation of a directed acyclic graph on which both the Glue Studio visual component and Glue Studio code generation is based.</p>
+     */
+    CodeGenConfigurationNodes?: {
+        [key: string]: CodeGenConfigurationNode;
+    };
 }
-export declare namespace UpdateWorkflowResponse {
+export declare namespace Job {
     /**
      * @internal
      */
-    const filterSensitiveLog: (obj: UpdateWorkflowResponse) => any;
+    const filterSensitiveLog: (obj: Job) => any;
+}
+/**
+ * <p>Specifies information used to update an existing job definition. The previous job
+ *       definition is completely overwritten by this information.</p>
+ */
+export interface JobUpdate {
+    /**
+     * <p>Description of the job being defined.</p>
+     */
+    Description?: string;
+    /**
+     * <p>This field is reserved for future use.</p>
+     */
+    LogUri?: string;
+    /**
+     * <p>The name or Amazon Resource Name (ARN) of the IAM role associated with this job
+     *       (required).</p>
+     */
+    Role?: string;
+    /**
+     * <p>An <code>ExecutionProperty</code> specifying the maximum number of concurrent runs allowed
+     *       for this job.</p>
+     */
+    ExecutionProperty?: ExecutionProperty;
+    /**
+     * <p>The <code>JobCommand</code> that runs this job (required).</p>
+     */
+    Command?: JobCommand;
+    /**
+     * <p>The default arguments for this job.</p>
+     *          <p>You can specify arguments here that your own job-execution script
+     *       consumes, as well as arguments that Glue itself consumes.</p>
+     *          <p>For information about how to specify and consume your own Job arguments, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-calling.html">Calling Glue APIs in Python</a> topic in the developer guide.</p>
+     *          <p>For information about the key-value pairs that Glue consumes to set up your job, see the <a href="https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html">Special Parameters Used by Glue</a> topic in the developer guide.</p>
+     */
+    DefaultArguments?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>Non-overridable arguments for this job, specified as name-value pairs.</p>
+     */
+    NonOverridableArguments?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>The connections used for this job.</p>
+     */
+    Connections?: ConnectionsList;
+    /**
+     * <p>The maximum number of times to retry this job if it fails.</p>
+     */
+    MaxRetries?: number;
+    /**
+     * @deprecated
+     *
+     * <p>This field is deprecated. Use <code>MaxCapacity</code> instead.</p>
+     *
+     *          <p>The number of Glue data processing units (DPUs) to allocate to this job. You can
+     *       allocate from 2 to 100 DPUs; the default is 10. A DPU is a relative measure of processing
+     *       power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information,
+     *       see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing
+     *       page</a>.</p>
+     */
+    AllocatedCapacity?: number;
+    /**
+     * <p>The job timeout in minutes.  This is the maximum time that a job run
+     *       can consume resources before it is terminated and enters <code>TIMEOUT</code>
+     *       status. The default is 2,880 minutes (48 hours).</p>
+     */
+    Timeout?: number;
+    /**
+     * <p>For Glue version 1.0 or earlier jobs, using the standard worker type, the number of Glue data processing units (DPUs) that can be allocated when this job runs. A DPU is a relative measure
+     *      of processing power that consists of 4 vCPUs of compute capacity and 16 GB of memory. For more information, see the <a href="https://aws.amazon.com/glue/pricing/">Glue pricing page</a>.</p>
+     *
+     * 	        <p>Do not set <code>Max Capacity</code> if using <code>WorkerType</code> and <code>NumberOfWorkers</code>.</p>
+     *
+     *          <p>The value that can be allocated for <code>MaxCapacity</code> depends on whether you are
+     *       running a Python shell job or an Apache Spark ETL job:</p>
+     *
+     *          <ul>
+     *             <li>
+     *                <p>When you specify a Python shell job (<code>JobCommand.Name</code>="pythonshell"), you can
+     *           allocate either 0.0625 or 1 DPU. The default is 0.0625 DPU.</p>
+     *             </li>
+     *             <li>
+     *                <p>When you specify an Apache Spark ETL job (<code>JobCommand.Name</code>="glueetl") or Apache
+     *            Spark streaming ETL job (<code>JobCommand.Name</code>="gluestreaming"), you can allocate from 2 to 100 DPUs.
+     *            The default is 10 DPUs. This job type cannot have a fractional DPU allocation.</p>
+     *             </li>
+     *          </ul>
+     * 	        <p>For Glue version 2.0 jobs, you cannot instead specify a <code>Maximum capacity</code>. Instead, you should specify a <code>Worker type</code> and the <code>Number of workers</code>.</p>
+     */
+    MaxCapacity?: number;
+    /**
+     * <p>The type of predefined worker that is allocated when a job runs. Accepts a value of Standard, G.1X, or G.2X.</p>
+     * 	        <ul>
+     *             <li>
+     *                <p>For the <code>Standard</code> worker type, each worker provides 4 vCPU, 16 GB of memory and a 50GB disk, and 2 executors per worker.</p>
+     *             </li>
+     *             <li>
+     *                <p>For the <code>G.1X</code> worker type, each worker maps to 1 DPU (4 vCPU, 16 GB of memory, 64 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p>
+     *             </li>
+     *             <li>
+     *                <p>For the <code>G.2X</code> worker type, each worker maps to 2 DPU (8 vCPU, 32 GB of memory, 128 GB disk), and provides 1 executor per worker. We recommend this worker type for memory-intensive jobs.</p>
+     *             </li>
+     *          </ul>
+     */
+    WorkerType?: WorkerType | string;
+    /**
+     * <p>The number of workers of a defined <code>workerType</code> that are allocated when a job runs.</p>
+     *
+     *          <p>The maximum number of workers you can define are 299 for <code>G.1X</code>, and 149 for <code>G.2X</code>. </p>
+     */
+    NumberOfWorkers?: number;
+    /**
+     * <p>The name of the <code>SecurityConfiguration</code> structure to be used with this
+     *       job.</p>
+     */
+    SecurityConfiguration?: string;
+    /**
+     * <p>Specifies the configuration properties of a job notification.</p>
+     */
+    NotificationProperty?: NotificationProperty;
+    /**
+     * <p>Glue version determines the versions of Apache Spark and Python that Glue supports. The Python version indicates the version supported for jobs of type Spark. </p>
+     *
+     *          <p>For more information about the available Glue versions and corresponding Spark and Python versions, see <a href="https://docs.aws.amazon.com/glue/latest/dg/add-job.html">Glue version</a> in the developer guide.</p>
+     */
+    GlueVersion?: string;
+    /**
+     * <p>The representation of a directed acyclic graph on which both the Glue Studio visual component and Glue Studio code generation is based.</p>
+     */
+    CodeGenConfigurationNodes?: {
+        [key: string]: CodeGenConfigurationNode;
+    };
+}
+export declare namespace JobUpdate {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: JobUpdate) => any;
+}
+export interface GetJobResponse {
+    /**
+     * <p>The requested job definition.</p>
+     */
+    Job?: Job;
+}
+export declare namespace GetJobResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetJobResponse) => any;
+}
+export interface UpdateJobRequest {
+    /**
+     * <p>The name of the job definition to update.</p>
+     */
+    JobName: string | undefined;
+    /**
+     * <p>Specifies the values with which to update the job definition.</p>
+     */
+    JobUpdate: JobUpdate | undefined;
+}
+export declare namespace UpdateJobRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateJobRequest) => any;
+}
+export interface BatchGetJobsResponse {
+    /**
+     * <p>A list of job definitions.</p>
+     */
+    Jobs?: Job[];
+    /**
+     * <p>A list of names of jobs not found.</p>
+     */
+    JobsNotFound?: string[];
+}
+export declare namespace BatchGetJobsResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: BatchGetJobsResponse) => any;
+}
+export interface GetJobsResponse {
+    /**
+     * <p>A list of job definitions.</p>
+     */
+    Jobs?: Job[];
+    /**
+     * <p>A continuation token, if not all job definitions have yet been returned.</p>
+     */
+    NextToken?: string;
+}
+export declare namespace GetJobsResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetJobsResponse) => any;
 }