@aws-sdk/client-glue 3.183.0 → 3.186.0

package/dist-es/Glue.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { BatchCreatePartitionCommand, } from "./commands/BatchCreatePartitionCommand";
 import { BatchDeleteConnectionCommand, } from "./commands/BatchDeleteConnectionCommand";
 import { BatchDeletePartitionCommand, } from "./commands/BatchDeletePartitionCommand";
@@ -174,2590 +175,2626 @@ import { UpdateCrawlerScheduleCommand, } from "./commands/UpdateCrawlerScheduleC
 import { UpdateDatabaseCommand, } from "./commands/UpdateDatabaseCommand";
 import { UpdateDevEndpointCommand, } from "./commands/UpdateDevEndpointCommand";
 import { UpdateJobCommand } from "./commands/UpdateJobCommand";
+import { UpdateJobFromSourceControlCommand, } from "./commands/UpdateJobFromSourceControlCommand";
 import { UpdateMLTransformCommand, } from "./commands/UpdateMLTransformCommand";
 import { UpdatePartitionCommand, } from "./commands/UpdatePartitionCommand";
 import { UpdateRegistryCommand, } from "./commands/UpdateRegistryCommand";
 import { UpdateSchemaCommand, } from "./commands/UpdateSchemaCommand";
+import { UpdateSourceControlFromJobCommand, } from "./commands/UpdateSourceControlFromJobCommand";
 import { UpdateTableCommand } from "./commands/UpdateTableCommand";
 import { UpdateTriggerCommand, } from "./commands/UpdateTriggerCommand";
 import { UpdateUserDefinedFunctionCommand, } from "./commands/UpdateUserDefinedFunctionCommand";
 import { UpdateWorkflowCommand, } from "./commands/UpdateWorkflowCommand";
 import { GlueClient } from "./GlueClient";
-export class Glue extends GlueClient {
-    batchCreatePartition(args, optionsOrCb, cb) {
-        const command = new BatchCreatePartitionCommand(args);
+var Glue = (function (_super) {
+    __extends(Glue, _super);
+    function Glue() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Glue.prototype.batchCreatePartition = function (args, optionsOrCb, cb) {
+        var command = new BatchCreatePartitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchDeleteConnection(args, optionsOrCb, cb) {
-        const command = new BatchDeleteConnectionCommand(args);
+    };
+    Glue.prototype.batchDeleteConnection = function (args, optionsOrCb, cb) {
+        var command = new BatchDeleteConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchDeletePartition(args, optionsOrCb, cb) {
-        const command = new BatchDeletePartitionCommand(args);
+    };
+    Glue.prototype.batchDeletePartition = function (args, optionsOrCb, cb) {
+        var command = new BatchDeletePartitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchDeleteTable(args, optionsOrCb, cb) {
-        const command = new BatchDeleteTableCommand(args);
+    };
+    Glue.prototype.batchDeleteTable = function (args, optionsOrCb, cb) {
+        var command = new BatchDeleteTableCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchDeleteTableVersion(args, optionsOrCb, cb) {
-        const command = new BatchDeleteTableVersionCommand(args);
+    };
+    Glue.prototype.batchDeleteTableVersion = function (args, optionsOrCb, cb) {
+        var command = new BatchDeleteTableVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchGetBlueprints(args, optionsOrCb, cb) {
-        const command = new BatchGetBlueprintsCommand(args);
+    };
+    Glue.prototype.batchGetBlueprints = function (args, optionsOrCb, cb) {
+        var command = new BatchGetBlueprintsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchGetCrawlers(args, optionsOrCb, cb) {
-        const command = new BatchGetCrawlersCommand(args);
+    };
+    Glue.prototype.batchGetCrawlers = function (args, optionsOrCb, cb) {
+        var command = new BatchGetCrawlersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchGetCustomEntityTypes(args, optionsOrCb, cb) {
-        const command = new BatchGetCustomEntityTypesCommand(args);
+    };
+    Glue.prototype.batchGetCustomEntityTypes = function (args, optionsOrCb, cb) {
+        var command = new BatchGetCustomEntityTypesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchGetDevEndpoints(args, optionsOrCb, cb) {
-        const command = new BatchGetDevEndpointsCommand(args);
+    };
+    Glue.prototype.batchGetDevEndpoints = function (args, optionsOrCb, cb) {
+        var command = new BatchGetDevEndpointsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchGetJobs(args, optionsOrCb, cb) {
-        const command = new BatchGetJobsCommand(args);
+    };
+    Glue.prototype.batchGetJobs = function (args, optionsOrCb, cb) {
+        var command = new BatchGetJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchGetPartition(args, optionsOrCb, cb) {
-        const command = new BatchGetPartitionCommand(args);
+    };
+    Glue.prototype.batchGetPartition = function (args, optionsOrCb, cb) {
+        var command = new BatchGetPartitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchGetTriggers(args, optionsOrCb, cb) {
-        const command = new BatchGetTriggersCommand(args);
+    };
+    Glue.prototype.batchGetTriggers = function (args, optionsOrCb, cb) {
+        var command = new BatchGetTriggersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchGetWorkflows(args, optionsOrCb, cb) {
-        const command = new BatchGetWorkflowsCommand(args);
+    };
+    Glue.prototype.batchGetWorkflows = function (args, optionsOrCb, cb) {
+        var command = new BatchGetWorkflowsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchStopJobRun(args, optionsOrCb, cb) {
-        const command = new BatchStopJobRunCommand(args);
+    };
+    Glue.prototype.batchStopJobRun = function (args, optionsOrCb, cb) {
+        var command = new BatchStopJobRunCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    batchUpdatePartition(args, optionsOrCb, cb) {
-        const command = new BatchUpdatePartitionCommand(args);
+    };
+    Glue.prototype.batchUpdatePartition = function (args, optionsOrCb, cb) {
+        var command = new BatchUpdatePartitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    cancelMLTaskRun(args, optionsOrCb, cb) {
-        const command = new CancelMLTaskRunCommand(args);
+    };
+    Glue.prototype.cancelMLTaskRun = function (args, optionsOrCb, cb) {
+        var command = new CancelMLTaskRunCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    cancelStatement(args, optionsOrCb, cb) {
-        const command = new CancelStatementCommand(args);
+    };
+    Glue.prototype.cancelStatement = function (args, optionsOrCb, cb) {
+        var command = new CancelStatementCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    checkSchemaVersionValidity(args, optionsOrCb, cb) {
-        const command = new CheckSchemaVersionValidityCommand(args);
+    };
+    Glue.prototype.checkSchemaVersionValidity = function (args, optionsOrCb, cb) {
+        var command = new CheckSchemaVersionValidityCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createBlueprint(args, optionsOrCb, cb) {
-        const command = new CreateBlueprintCommand(args);
+    };
+    Glue.prototype.createBlueprint = function (args, optionsOrCb, cb) {
+        var command = new CreateBlueprintCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createClassifier(args, optionsOrCb, cb) {
-        const command = new CreateClassifierCommand(args);
+    };
+    Glue.prototype.createClassifier = function (args, optionsOrCb, cb) {
+        var command = new CreateClassifierCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createConnection(args, optionsOrCb, cb) {
-        const command = new CreateConnectionCommand(args);
+    };
+    Glue.prototype.createConnection = function (args, optionsOrCb, cb) {
+        var command = new CreateConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createCrawler(args, optionsOrCb, cb) {
-        const command = new CreateCrawlerCommand(args);
+    };
+    Glue.prototype.createCrawler = function (args, optionsOrCb, cb) {
+        var command = new CreateCrawlerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createCustomEntityType(args, optionsOrCb, cb) {
-        const command = new CreateCustomEntityTypeCommand(args);
+    };
+    Glue.prototype.createCustomEntityType = function (args, optionsOrCb, cb) {
+        var command = new CreateCustomEntityTypeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createDatabase(args, optionsOrCb, cb) {
-        const command = new CreateDatabaseCommand(args);
+    };
+    Glue.prototype.createDatabase = function (args, optionsOrCb, cb) {
+        var command = new CreateDatabaseCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createDevEndpoint(args, optionsOrCb, cb) {
-        const command = new CreateDevEndpointCommand(args);
+    };
+    Glue.prototype.createDevEndpoint = function (args, optionsOrCb, cb) {
+        var command = new CreateDevEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createJob(args, optionsOrCb, cb) {
-        const command = new CreateJobCommand(args);
+    };
+    Glue.prototype.createJob = function (args, optionsOrCb, cb) {
+        var command = new CreateJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createMLTransform(args, optionsOrCb, cb) {
-        const command = new CreateMLTransformCommand(args);
+    };
+    Glue.prototype.createMLTransform = function (args, optionsOrCb, cb) {
+        var command = new CreateMLTransformCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createPartition(args, optionsOrCb, cb) {
-        const command = new CreatePartitionCommand(args);
+    };
+    Glue.prototype.createPartition = function (args, optionsOrCb, cb) {
+        var command = new CreatePartitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createPartitionIndex(args, optionsOrCb, cb) {
-        const command = new CreatePartitionIndexCommand(args);
+    };
+    Glue.prototype.createPartitionIndex = function (args, optionsOrCb, cb) {
+        var command = new CreatePartitionIndexCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createRegistry(args, optionsOrCb, cb) {
-        const command = new CreateRegistryCommand(args);
+    };
+    Glue.prototype.createRegistry = function (args, optionsOrCb, cb) {
+        var command = new CreateRegistryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createSchema(args, optionsOrCb, cb) {
-        const command = new CreateSchemaCommand(args);
+    };
+    Glue.prototype.createSchema = function (args, optionsOrCb, cb) {
+        var command = new CreateSchemaCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createScript(args, optionsOrCb, cb) {
-        const command = new CreateScriptCommand(args);
+    };
+    Glue.prototype.createScript = function (args, optionsOrCb, cb) {
+        var command = new CreateScriptCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createSecurityConfiguration(args, optionsOrCb, cb) {
-        const command = new CreateSecurityConfigurationCommand(args);
+    };
+    Glue.prototype.createSecurityConfiguration = function (args, optionsOrCb, cb) {
+        var command = new CreateSecurityConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createSession(args, optionsOrCb, cb) {
-        const command = new CreateSessionCommand(args);
+    };
+    Glue.prototype.createSession = function (args, optionsOrCb, cb) {
+        var command = new CreateSessionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createTable(args, optionsOrCb, cb) {
-        const command = new CreateTableCommand(args);
+    };
+    Glue.prototype.createTable = function (args, optionsOrCb, cb) {
+        var command = new CreateTableCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createTrigger(args, optionsOrCb, cb) {
-        const command = new CreateTriggerCommand(args);
+    };
+    Glue.prototype.createTrigger = function (args, optionsOrCb, cb) {
+        var command = new CreateTriggerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createUserDefinedFunction(args, optionsOrCb, cb) {
-        const command = new CreateUserDefinedFunctionCommand(args);
+    };
+    Glue.prototype.createUserDefinedFunction = function (args, optionsOrCb, cb) {
+        var command = new CreateUserDefinedFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createWorkflow(args, optionsOrCb, cb) {
-        const command = new CreateWorkflowCommand(args);
+    };
+    Glue.prototype.createWorkflow = function (args, optionsOrCb, cb) {
+        var command = new CreateWorkflowCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteBlueprint(args, optionsOrCb, cb) {
-        const command = new DeleteBlueprintCommand(args);
+    };
+    Glue.prototype.deleteBlueprint = function (args, optionsOrCb, cb) {
+        var command = new DeleteBlueprintCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteClassifier(args, optionsOrCb, cb) {
-        const command = new DeleteClassifierCommand(args);
+    };
+    Glue.prototype.deleteClassifier = function (args, optionsOrCb, cb) {
+        var command = new DeleteClassifierCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteColumnStatisticsForPartition(args, optionsOrCb, cb) {
-        const command = new DeleteColumnStatisticsForPartitionCommand(args);
+    };
+    Glue.prototype.deleteColumnStatisticsForPartition = function (args, optionsOrCb, cb) {
+        var command = new DeleteColumnStatisticsForPartitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteColumnStatisticsForTable(args, optionsOrCb, cb) {
-        const command = new DeleteColumnStatisticsForTableCommand(args);
+    };
+    Glue.prototype.deleteColumnStatisticsForTable = function (args, optionsOrCb, cb) {
+        var command = new DeleteColumnStatisticsForTableCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteConnection(args, optionsOrCb, cb) {
-        const command = new DeleteConnectionCommand(args);
+    };
+    Glue.prototype.deleteConnection = function (args, optionsOrCb, cb) {
+        var command = new DeleteConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteCrawler(args, optionsOrCb, cb) {
-        const command = new DeleteCrawlerCommand(args);
+    };
+    Glue.prototype.deleteCrawler = function (args, optionsOrCb, cb) {
+        var command = new DeleteCrawlerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteCustomEntityType(args, optionsOrCb, cb) {
-        const command = new DeleteCustomEntityTypeCommand(args);
+    };
+    Glue.prototype.deleteCustomEntityType = function (args, optionsOrCb, cb) {
+        var command = new DeleteCustomEntityTypeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteDatabase(args, optionsOrCb, cb) {
-        const command = new DeleteDatabaseCommand(args);
+    };
+    Glue.prototype.deleteDatabase = function (args, optionsOrCb, cb) {
+        var command = new DeleteDatabaseCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteDevEndpoint(args, optionsOrCb, cb) {
-        const command = new DeleteDevEndpointCommand(args);
+    };
+    Glue.prototype.deleteDevEndpoint = function (args, optionsOrCb, cb) {
+        var command = new DeleteDevEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteJob(args, optionsOrCb, cb) {
-        const command = new DeleteJobCommand(args);
+    };
+    Glue.prototype.deleteJob = function (args, optionsOrCb, cb) {
+        var command = new DeleteJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteMLTransform(args, optionsOrCb, cb) {
-        const command = new DeleteMLTransformCommand(args);
+    };
+    Glue.prototype.deleteMLTransform = function (args, optionsOrCb, cb) {
+        var command = new DeleteMLTransformCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deletePartition(args, optionsOrCb, cb) {
-        const command = new DeletePartitionCommand(args);
+    };
+    Glue.prototype.deletePartition = function (args, optionsOrCb, cb) {
+        var command = new DeletePartitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deletePartitionIndex(args, optionsOrCb, cb) {
-        const command = new DeletePartitionIndexCommand(args);
+    };
+    Glue.prototype.deletePartitionIndex = function (args, optionsOrCb, cb) {
+        var command = new DeletePartitionIndexCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteRegistry(args, optionsOrCb, cb) {
-        const command = new DeleteRegistryCommand(args);
+    };
+    Glue.prototype.deleteRegistry = function (args, optionsOrCb, cb) {
+        var command = new DeleteRegistryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteResourcePolicy(args, optionsOrCb, cb) {
-        const command = new DeleteResourcePolicyCommand(args);
+    };
+    Glue.prototype.deleteResourcePolicy = function (args, optionsOrCb, cb) {
+        var command = new DeleteResourcePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteSchema(args, optionsOrCb, cb) {
-        const command = new DeleteSchemaCommand(args);
+    };
+    Glue.prototype.deleteSchema = function (args, optionsOrCb, cb) {
+        var command = new DeleteSchemaCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteSchemaVersions(args, optionsOrCb, cb) {
-        const command = new DeleteSchemaVersionsCommand(args);
+    };
+    Glue.prototype.deleteSchemaVersions = function (args, optionsOrCb, cb) {
+        var command = new DeleteSchemaVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteSecurityConfiguration(args, optionsOrCb, cb) {
-        const command = new DeleteSecurityConfigurationCommand(args);
+    };
+    Glue.prototype.deleteSecurityConfiguration = function (args, optionsOrCb, cb) {
+        var command = new DeleteSecurityConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteSession(args, optionsOrCb, cb) {
-        const command = new DeleteSessionCommand(args);
+    };
+    Glue.prototype.deleteSession = function (args, optionsOrCb, cb) {
+        var command = new DeleteSessionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteTable(args, optionsOrCb, cb) {
-        const command = new DeleteTableCommand(args);
+    };
+    Glue.prototype.deleteTable = function (args, optionsOrCb, cb) {
+        var command = new DeleteTableCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteTableVersion(args, optionsOrCb, cb) {
-        const command = new DeleteTableVersionCommand(args);
+    };
+    Glue.prototype.deleteTableVersion = function (args, optionsOrCb, cb) {
+        var command = new DeleteTableVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteTrigger(args, optionsOrCb, cb) {
-        const command = new DeleteTriggerCommand(args);
+    };
+    Glue.prototype.deleteTrigger = function (args, optionsOrCb, cb) {
+        var command = new DeleteTriggerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteUserDefinedFunction(args, optionsOrCb, cb) {
-        const command = new DeleteUserDefinedFunctionCommand(args);
+    };
+    Glue.prototype.deleteUserDefinedFunction = function (args, optionsOrCb, cb) {
+        var command = new DeleteUserDefinedFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteWorkflow(args, optionsOrCb, cb) {
-        const command = new DeleteWorkflowCommand(args);
+    };
+    Glue.prototype.deleteWorkflow = function (args, optionsOrCb, cb) {
+        var command = new DeleteWorkflowCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBlueprint(args, optionsOrCb, cb) {
-        const command = new GetBlueprintCommand(args);
+    };
+    Glue.prototype.getBlueprint = function (args, optionsOrCb, cb) {
+        var command = new GetBlueprintCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBlueprintRun(args, optionsOrCb, cb) {
-        const command = new GetBlueprintRunCommand(args);
+    };
+    Glue.prototype.getBlueprintRun = function (args, optionsOrCb, cb) {
+        var command = new GetBlueprintRunCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getBlueprintRuns(args, optionsOrCb, cb) {
-        const command = new GetBlueprintRunsCommand(args);
+    };
+    Glue.prototype.getBlueprintRuns = function (args, optionsOrCb, cb) {
+        var command = new GetBlueprintRunsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCatalogImportStatus(args, optionsOrCb, cb) {
-        const command = new GetCatalogImportStatusCommand(args);
+    };
+    Glue.prototype.getCatalogImportStatus = function (args, optionsOrCb, cb) {
+        var command = new GetCatalogImportStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getClassifier(args, optionsOrCb, cb) {
-        const command = new GetClassifierCommand(args);
+    };
+    Glue.prototype.getClassifier = function (args, optionsOrCb, cb) {
+        var command = new GetClassifierCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getClassifiers(args, optionsOrCb, cb) {
-        const command = new GetClassifiersCommand(args);
+    };
+    Glue.prototype.getClassifiers = function (args, optionsOrCb, cb) {
+        var command = new GetClassifiersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getColumnStatisticsForPartition(args, optionsOrCb, cb) {
-        const command = new GetColumnStatisticsForPartitionCommand(args);
+    };
+    Glue.prototype.getColumnStatisticsForPartition = function (args, optionsOrCb, cb) {
+        var command = new GetColumnStatisticsForPartitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getColumnStatisticsForTable(args, optionsOrCb, cb) {
-        const command = new GetColumnStatisticsForTableCommand(args);
+    };
+    Glue.prototype.getColumnStatisticsForTable = function (args, optionsOrCb, cb) {
+        var command = new GetColumnStatisticsForTableCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getConnection(args, optionsOrCb, cb) {
-        const command = new GetConnectionCommand(args);
+    };
+    Glue.prototype.getConnection = function (args, optionsOrCb, cb) {
+        var command = new GetConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getConnections(args, optionsOrCb, cb) {
-        const command = new GetConnectionsCommand(args);
+    };
+    Glue.prototype.getConnections = function (args, optionsOrCb, cb) {
+        var command = new GetConnectionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCrawler(args, optionsOrCb, cb) {
-        const command = new GetCrawlerCommand(args);
+    };
+    Glue.prototype.getCrawler = function (args, optionsOrCb, cb) {
+        var command = new GetCrawlerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCrawlerMetrics(args, optionsOrCb, cb) {
-        const command = new GetCrawlerMetricsCommand(args);
+    };
+    Glue.prototype.getCrawlerMetrics = function (args, optionsOrCb, cb) {
+        var command = new GetCrawlerMetricsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCrawlers(args, optionsOrCb, cb) {
-        const command = new GetCrawlersCommand(args);
+    };
+    Glue.prototype.getCrawlers = function (args, optionsOrCb, cb) {
+        var command = new GetCrawlersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getCustomEntityType(args, optionsOrCb, cb) {
-        const command = new GetCustomEntityTypeCommand(args);
+    };
+    Glue.prototype.getCustomEntityType = function (args, optionsOrCb, cb) {
+        var command = new GetCustomEntityTypeCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDatabase(args, optionsOrCb, cb) {
-        const command = new GetDatabaseCommand(args);
+    };
+    Glue.prototype.getDatabase = function (args, optionsOrCb, cb) {
+        var command = new GetDatabaseCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDatabases(args, optionsOrCb, cb) {
-        const command = new GetDatabasesCommand(args);
+    };
+    Glue.prototype.getDatabases = function (args, optionsOrCb, cb) {
+        var command = new GetDatabasesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDataCatalogEncryptionSettings(args, optionsOrCb, cb) {
-        const command = new GetDataCatalogEncryptionSettingsCommand(args);
+    };
+    Glue.prototype.getDataCatalogEncryptionSettings = function (args, optionsOrCb, cb) {
+        var command = new GetDataCatalogEncryptionSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDataflowGraph(args, optionsOrCb, cb) {
-        const command = new GetDataflowGraphCommand(args);
+    };
+    Glue.prototype.getDataflowGraph = function (args, optionsOrCb, cb) {
+        var command = new GetDataflowGraphCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDevEndpoint(args, optionsOrCb, cb) {
-        const command = new GetDevEndpointCommand(args);
+    };
+    Glue.prototype.getDevEndpoint = function (args, optionsOrCb, cb) {
+        var command = new GetDevEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getDevEndpoints(args, optionsOrCb, cb) {
-        const command = new GetDevEndpointsCommand(args);
+    };
+    Glue.prototype.getDevEndpoints = function (args, optionsOrCb, cb) {
+        var command = new GetDevEndpointsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getJob(args, optionsOrCb, cb) {
-        const command = new GetJobCommand(args);
+    };
+    Glue.prototype.getJob = function (args, optionsOrCb, cb) {
+        var command = new GetJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getJobBookmark(args, optionsOrCb, cb) {
-        const command = new GetJobBookmarkCommand(args);
+    };
+    Glue.prototype.getJobBookmark = function (args, optionsOrCb, cb) {
+        var command = new GetJobBookmarkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getJobRun(args, optionsOrCb, cb) {
-        const command = new GetJobRunCommand(args);
+    };
+    Glue.prototype.getJobRun = function (args, optionsOrCb, cb) {
+        var command = new GetJobRunCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getJobRuns(args, optionsOrCb, cb) {
-        const command = new GetJobRunsCommand(args);
+    };
+    Glue.prototype.getJobRuns = function (args, optionsOrCb, cb) {
+        var command = new GetJobRunsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getJobs(args, optionsOrCb, cb) {
-        const command = new GetJobsCommand(args);
+    };
+    Glue.prototype.getJobs = function (args, optionsOrCb, cb) {
+        var command = new GetJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getMapping(args, optionsOrCb, cb) {
-        const command = new GetMappingCommand(args);
+    };
+    Glue.prototype.getMapping = function (args, optionsOrCb, cb) {
+        var command = new GetMappingCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getMLTaskRun(args, optionsOrCb, cb) {
-        const command = new GetMLTaskRunCommand(args);
+    };
+    Glue.prototype.getMLTaskRun = function (args, optionsOrCb, cb) {
+        var command = new GetMLTaskRunCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getMLTaskRuns(args, optionsOrCb, cb) {
-        const command = new GetMLTaskRunsCommand(args);
+    };
+    Glue.prototype.getMLTaskRuns = function (args, optionsOrCb, cb) {
+        var command = new GetMLTaskRunsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getMLTransform(args, optionsOrCb, cb) {
-        const command = new GetMLTransformCommand(args);
+    };
+    Glue.prototype.getMLTransform = function (args, optionsOrCb, cb) {
+        var command = new GetMLTransformCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getMLTransforms(args, optionsOrCb, cb) {
-        const command = new GetMLTransformsCommand(args);
+    };
+    Glue.prototype.getMLTransforms = function (args, optionsOrCb, cb) {
+        var command = new GetMLTransformsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getPartition(args, optionsOrCb, cb) {
-        const command = new GetPartitionCommand(args);
+    };
+    Glue.prototype.getPartition = function (args, optionsOrCb, cb) {
+        var command = new GetPartitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getPartitionIndexes(args, optionsOrCb, cb) {
-        const command = new GetPartitionIndexesCommand(args);
+    };
+    Glue.prototype.getPartitionIndexes = function (args, optionsOrCb, cb) {
+        var command = new GetPartitionIndexesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getPartitions(args, optionsOrCb, cb) {
-        const command = new GetPartitionsCommand(args);
+    };
+    Glue.prototype.getPartitions = function (args, optionsOrCb, cb) {
+        var command = new GetPartitionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getPlan(args, optionsOrCb, cb) {
-        const command = new GetPlanCommand(args);
+    };
+    Glue.prototype.getPlan = function (args, optionsOrCb, cb) {
+        var command = new GetPlanCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getRegistry(args, optionsOrCb, cb) {
-        const command = new GetRegistryCommand(args);
+    };
+    Glue.prototype.getRegistry = function (args, optionsOrCb, cb) {
+        var command = new GetRegistryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getResourcePolicies(args, optionsOrCb, cb) {
-        const command = new GetResourcePoliciesCommand(args);
+    };
+    Glue.prototype.getResourcePolicies = function (args, optionsOrCb, cb) {
+        var command = new GetResourcePoliciesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getResourcePolicy(args, optionsOrCb, cb) {
-        const command = new GetResourcePolicyCommand(args);
+    };
+    Glue.prototype.getResourcePolicy = function (args, optionsOrCb, cb) {
+        var command = new GetResourcePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSchema(args, optionsOrCb, cb) {
-        const command = new GetSchemaCommand(args);
+    };
+    Glue.prototype.getSchema = function (args, optionsOrCb, cb) {
+        var command = new GetSchemaCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSchemaByDefinition(args, optionsOrCb, cb) {
-        const command = new GetSchemaByDefinitionCommand(args);
+    };
+    Glue.prototype.getSchemaByDefinition = function (args, optionsOrCb, cb) {
+        var command = new GetSchemaByDefinitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSchemaVersion(args, optionsOrCb, cb) {
-        const command = new GetSchemaVersionCommand(args);
+    };
+    Glue.prototype.getSchemaVersion = function (args, optionsOrCb, cb) {
+        var command = new GetSchemaVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSchemaVersionsDiff(args, optionsOrCb, cb) {
-        const command = new GetSchemaVersionsDiffCommand(args);
+    };
+    Glue.prototype.getSchemaVersionsDiff = function (args, optionsOrCb, cb) {
+        var command = new GetSchemaVersionsDiffCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSecurityConfiguration(args, optionsOrCb, cb) {
-        const command = new GetSecurityConfigurationCommand(args);
+    };
+    Glue.prototype.getSecurityConfiguration = function (args, optionsOrCb, cb) {
+        var command = new GetSecurityConfigurationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSecurityConfigurations(args, optionsOrCb, cb) {
-        const command = new GetSecurityConfigurationsCommand(args);
+    };
+    Glue.prototype.getSecurityConfigurations = function (args, optionsOrCb, cb) {
+        var command = new GetSecurityConfigurationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getSession(args, optionsOrCb, cb) {
-        const command = new GetSessionCommand(args);
+    };
+    Glue.prototype.getSession = function (args, optionsOrCb, cb) {
+        var command = new GetSessionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getStatement(args, optionsOrCb, cb) {
-        const command = new GetStatementCommand(args);
+    };
+    Glue.prototype.getStatement = function (args, optionsOrCb, cb) {
+        var command = new GetStatementCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getTable(args, optionsOrCb, cb) {
-        const command = new GetTableCommand(args);
+    };
+    Glue.prototype.getTable = function (args, optionsOrCb, cb) {
+        var command = new GetTableCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getTables(args, optionsOrCb, cb) {
-        const command = new GetTablesCommand(args);
+    };
+    Glue.prototype.getTables = function (args, optionsOrCb, cb) {
+        var command = new GetTablesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getTableVersion(args, optionsOrCb, cb) {
-        const command = new GetTableVersionCommand(args);
+    };
+    Glue.prototype.getTableVersion = function (args, optionsOrCb, cb) {
+        var command = new GetTableVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getTableVersions(args, optionsOrCb, cb) {
-        const command = new GetTableVersionsCommand(args);
+    };
+    Glue.prototype.getTableVersions = function (args, optionsOrCb, cb) {
+        var command = new GetTableVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getTags(args, optionsOrCb, cb) {
-        const command = new GetTagsCommand(args);
+    };
+    Glue.prototype.getTags = function (args, optionsOrCb, cb) {
+        var command = new GetTagsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getTrigger(args, optionsOrCb, cb) {
-        const command = new GetTriggerCommand(args);
+    };
+    Glue.prototype.getTrigger = function (args, optionsOrCb, cb) {
+        var command = new GetTriggerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getTriggers(args, optionsOrCb, cb) {
-        const command = new GetTriggersCommand(args);
+    };
+    Glue.prototype.getTriggers = function (args, optionsOrCb, cb) {
+        var command = new GetTriggersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getUnfilteredPartitionMetadata(args, optionsOrCb, cb) {
-        const command = new GetUnfilteredPartitionMetadataCommand(args);
+    };
+    Glue.prototype.getUnfilteredPartitionMetadata = function (args, optionsOrCb, cb) {
+        var command = new GetUnfilteredPartitionMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getUnfilteredPartitionsMetadata(args, optionsOrCb, cb) {
-        const command = new GetUnfilteredPartitionsMetadataCommand(args);
+    };
+    Glue.prototype.getUnfilteredPartitionsMetadata = function (args, optionsOrCb, cb) {
+        var command = new GetUnfilteredPartitionsMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getUnfilteredTableMetadata(args, optionsOrCb, cb) {
-        const command = new GetUnfilteredTableMetadataCommand(args);
+    };
+    Glue.prototype.getUnfilteredTableMetadata = function (args, optionsOrCb, cb) {
+        var command = new GetUnfilteredTableMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getUserDefinedFunction(args, optionsOrCb, cb) {
-        const command = new GetUserDefinedFunctionCommand(args);
+    };
+    Glue.prototype.getUserDefinedFunction = function (args, optionsOrCb, cb) {
+        var command = new GetUserDefinedFunctionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getUserDefinedFunctions(args, optionsOrCb, cb) {
-        const command = new GetUserDefinedFunctionsCommand(args);
+    };
+    Glue.prototype.getUserDefinedFunctions = function (args, optionsOrCb, cb) {
+        var command = new GetUserDefinedFunctionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getWorkflow(args, optionsOrCb, cb) {
-        const command = new GetWorkflowCommand(args);
+    };
+    Glue.prototype.getWorkflow = function (args, optionsOrCb, cb) {
+        var command = new GetWorkflowCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getWorkflowRun(args, optionsOrCb, cb) {
-        const command = new GetWorkflowRunCommand(args);
+    };
+    Glue.prototype.getWorkflowRun = function (args, optionsOrCb, cb) {
+        var command = new GetWorkflowRunCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getWorkflowRunProperties(args, optionsOrCb, cb) {
-        const command = new GetWorkflowRunPropertiesCommand(args);
+    };
+    Glue.prototype.getWorkflowRunProperties = function (args, optionsOrCb, cb) {
+        var command = new GetWorkflowRunPropertiesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    getWorkflowRuns(args, optionsOrCb, cb) {
-        const command = new GetWorkflowRunsCommand(args);
+    };
+    Glue.prototype.getWorkflowRuns = function (args, optionsOrCb, cb) {
+        var command = new GetWorkflowRunsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    importCatalogToGlue(args, optionsOrCb, cb) {
-        const command = new ImportCatalogToGlueCommand(args);
+    };
+    Glue.prototype.importCatalogToGlue = function (args, optionsOrCb, cb) {
+        var command = new ImportCatalogToGlueCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listBlueprints(args, optionsOrCb, cb) {
-        const command = new ListBlueprintsCommand(args);
+    };
+    Glue.prototype.listBlueprints = function (args, optionsOrCb, cb) {
+        var command = new ListBlueprintsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listCrawlers(args, optionsOrCb, cb) {
-        const command = new ListCrawlersCommand(args);
+    };
+    Glue.prototype.listCrawlers = function (args, optionsOrCb, cb) {
+        var command = new ListCrawlersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listCrawls(args, optionsOrCb, cb) {
-        const command = new ListCrawlsCommand(args);
+    };
+    Glue.prototype.listCrawls = function (args, optionsOrCb, cb) {
+        var command = new ListCrawlsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listCustomEntityTypes(args, optionsOrCb, cb) {
-        const command = new ListCustomEntityTypesCommand(args);
+    };
+    Glue.prototype.listCustomEntityTypes = function (args, optionsOrCb, cb) {
+        var command = new ListCustomEntityTypesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listDevEndpoints(args, optionsOrCb, cb) {
-        const command = new ListDevEndpointsCommand(args);
+    };
+    Glue.prototype.listDevEndpoints = function (args, optionsOrCb, cb) {
+        var command = new ListDevEndpointsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listJobs(args, optionsOrCb, cb) {
-        const command = new ListJobsCommand(args);
+    };
+    Glue.prototype.listJobs = function (args, optionsOrCb, cb) {
+        var command = new ListJobsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listMLTransforms(args, optionsOrCb, cb) {
-        const command = new ListMLTransformsCommand(args);
+    };
+    Glue.prototype.listMLTransforms = function (args, optionsOrCb, cb) {
+        var command = new ListMLTransformsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listRegistries(args, optionsOrCb, cb) {
-        const command = new ListRegistriesCommand(args);
+    };
+    Glue.prototype.listRegistries = function (args, optionsOrCb, cb) {
+        var command = new ListRegistriesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listSchemas(args, optionsOrCb, cb) {
-        const command = new ListSchemasCommand(args);
+    };
+    Glue.prototype.listSchemas = function (args, optionsOrCb, cb) {
+        var command = new ListSchemasCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listSchemaVersions(args, optionsOrCb, cb) {
-        const command = new ListSchemaVersionsCommand(args);
+    };
+    Glue.prototype.listSchemaVersions = function (args, optionsOrCb, cb) {
+        var command = new ListSchemaVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listSessions(args, optionsOrCb, cb) {
-        const command = new ListSessionsCommand(args);
+    };
+    Glue.prototype.listSessions = function (args, optionsOrCb, cb) {
+        var command = new ListSessionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listStatements(args, optionsOrCb, cb) {
-        const command = new ListStatementsCommand(args);
+    };
+    Glue.prototype.listStatements = function (args, optionsOrCb, cb) {
+        var command = new ListStatementsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTriggers(args, optionsOrCb, cb) {
-        const command = new ListTriggersCommand(args);
+    };
+    Glue.prototype.listTriggers = function (args, optionsOrCb, cb) {
+        var command = new ListTriggersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listWorkflows(args, optionsOrCb, cb) {
-        const command = new ListWorkflowsCommand(args);
+    };
+    Glue.prototype.listWorkflows = function (args, optionsOrCb, cb) {
+        var command = new ListWorkflowsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putDataCatalogEncryptionSettings(args, optionsOrCb, cb) {
-        const command = new PutDataCatalogEncryptionSettingsCommand(args);
+    };
+    Glue.prototype.putDataCatalogEncryptionSettings = function (args, optionsOrCb, cb) {
+        var command = new PutDataCatalogEncryptionSettingsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putResourcePolicy(args, optionsOrCb, cb) {
-        const command = new PutResourcePolicyCommand(args);
+    };
+    Glue.prototype.putResourcePolicy = function (args, optionsOrCb, cb) {
+        var command = new PutResourcePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putSchemaVersionMetadata(args, optionsOrCb, cb) {
-        const command = new PutSchemaVersionMetadataCommand(args);
+    };
+    Glue.prototype.putSchemaVersionMetadata = function (args, optionsOrCb, cb) {
+        var command = new PutSchemaVersionMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putWorkflowRunProperties(args, optionsOrCb, cb) {
-        const command = new PutWorkflowRunPropertiesCommand(args);
+    };
+    Glue.prototype.putWorkflowRunProperties = function (args, optionsOrCb, cb) {
+        var command = new PutWorkflowRunPropertiesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    querySchemaVersionMetadata(args, optionsOrCb, cb) {
-        const command = new QuerySchemaVersionMetadataCommand(args);
+    };
+    Glue.prototype.querySchemaVersionMetadata = function (args, optionsOrCb, cb) {
+        var command = new QuerySchemaVersionMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    registerSchemaVersion(args, optionsOrCb, cb) {
-        const command = new RegisterSchemaVersionCommand(args);
+    };
+    Glue.prototype.registerSchemaVersion = function (args, optionsOrCb, cb) {
+        var command = new RegisterSchemaVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    removeSchemaVersionMetadata(args, optionsOrCb, cb) {
-        const command = new RemoveSchemaVersionMetadataCommand(args);
+    };
+    Glue.prototype.removeSchemaVersionMetadata = function (args, optionsOrCb, cb) {
+        var command = new RemoveSchemaVersionMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    resetJobBookmark(args, optionsOrCb, cb) {
-        const command = new ResetJobBookmarkCommand(args);
+    };
+    Glue.prototype.resetJobBookmark = function (args, optionsOrCb, cb) {
+        var command = new ResetJobBookmarkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    resumeWorkflowRun(args, optionsOrCb, cb) {
-        const command = new ResumeWorkflowRunCommand(args);
+    };
+    Glue.prototype.resumeWorkflowRun = function (args, optionsOrCb, cb) {
+        var command = new ResumeWorkflowRunCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    runStatement(args, optionsOrCb, cb) {
-        const command = new RunStatementCommand(args);
+    };
+    Glue.prototype.runStatement = function (args, optionsOrCb, cb) {
+        var command = new RunStatementCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    searchTables(args, optionsOrCb, cb) {
-        const command = new SearchTablesCommand(args);
+    };
+    Glue.prototype.searchTables = function (args, optionsOrCb, cb) {
+        var command = new SearchTablesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startBlueprintRun(args, optionsOrCb, cb) {
-        const command = new StartBlueprintRunCommand(args);
+    };
+    Glue.prototype.startBlueprintRun = function (args, optionsOrCb, cb) {
+        var command = new StartBlueprintRunCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startCrawler(args, optionsOrCb, cb) {
-        const command = new StartCrawlerCommand(args);
+    };
+    Glue.prototype.startCrawler = function (args, optionsOrCb, cb) {
+        var command = new StartCrawlerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startCrawlerSchedule(args, optionsOrCb, cb) {
-        const command = new StartCrawlerScheduleCommand(args);
+    };
+    Glue.prototype.startCrawlerSchedule = function (args, optionsOrCb, cb) {
+        var command = new StartCrawlerScheduleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startExportLabelsTaskRun(args, optionsOrCb, cb) {
-        const command = new StartExportLabelsTaskRunCommand(args);
+    };
+    Glue.prototype.startExportLabelsTaskRun = function (args, optionsOrCb, cb) {
+        var command = new StartExportLabelsTaskRunCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startImportLabelsTaskRun(args, optionsOrCb, cb) {
-        const command = new StartImportLabelsTaskRunCommand(args);
+    };
+    Glue.prototype.startImportLabelsTaskRun = function (args, optionsOrCb, cb) {
+        var command = new StartImportLabelsTaskRunCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startJobRun(args, optionsOrCb, cb) {
-        const command = new StartJobRunCommand(args);
+    };
+    Glue.prototype.startJobRun = function (args, optionsOrCb, cb) {
+        var command = new StartJobRunCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startMLEvaluationTaskRun(args, optionsOrCb, cb) {
-        const command = new StartMLEvaluationTaskRunCommand(args);
+    };
+    Glue.prototype.startMLEvaluationTaskRun = function (args, optionsOrCb, cb) {
+        var command = new StartMLEvaluationTaskRunCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startMLLabelingSetGenerationTaskRun(args, optionsOrCb, cb) {
-        const command = new StartMLLabelingSetGenerationTaskRunCommand(args);
+    };
+    Glue.prototype.startMLLabelingSetGenerationTaskRun = function (args, optionsOrCb, cb) {
+        var command = new StartMLLabelingSetGenerationTaskRunCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startTrigger(args, optionsOrCb, cb) {
-        const command = new StartTriggerCommand(args);
+    };
+    Glue.prototype.startTrigger = function (args, optionsOrCb, cb) {
+        var command = new StartTriggerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startWorkflowRun(args, optionsOrCb, cb) {
-        const command = new StartWorkflowRunCommand(args);
+    };
+    Glue.prototype.startWorkflowRun = function (args, optionsOrCb, cb) {
+        var command = new StartWorkflowRunCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopCrawler(args, optionsOrCb, cb) {
-        const command = new StopCrawlerCommand(args);
+    };
+    Glue.prototype.stopCrawler = function (args, optionsOrCb, cb) {
+        var command = new StopCrawlerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopCrawlerSchedule(args, optionsOrCb, cb) {
-        const command = new StopCrawlerScheduleCommand(args);
+    };
+    Glue.prototype.stopCrawlerSchedule = function (args, optionsOrCb, cb) {
+        var command = new StopCrawlerScheduleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopSession(args, optionsOrCb, cb) {
-        const command = new StopSessionCommand(args);
+    };
+    Glue.prototype.stopSession = function (args, optionsOrCb, cb) {
+        var command = new StopSessionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopTrigger(args, optionsOrCb, cb) {
-        const command = new StopTriggerCommand(args);
+    };
+    Glue.prototype.stopTrigger = function (args, optionsOrCb, cb) {
+        var command = new StopTriggerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    stopWorkflowRun(args, optionsOrCb, cb) {
-        const command = new StopWorkflowRunCommand(args);
+    };
+    Glue.prototype.stopWorkflowRun = function (args, optionsOrCb, cb) {
+        var command = new StopWorkflowRunCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    tagResource(args, optionsOrCb, cb) {
-        const command = new TagResourceCommand(args);
+    };
+    Glue.prototype.tagResource = function (args, optionsOrCb, cb) {
+        var command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    untagResource(args, optionsOrCb, cb) {
-        const command = new UntagResourceCommand(args);
+    };
+    Glue.prototype.untagResource = function (args, optionsOrCb, cb) {
+        var command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateBlueprint(args, optionsOrCb, cb) {
-        const command = new UpdateBlueprintCommand(args);
+    };
+    Glue.prototype.updateBlueprint = function (args, optionsOrCb, cb) {
+        var command = new UpdateBlueprintCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateClassifier(args, optionsOrCb, cb) {
-        const command = new UpdateClassifierCommand(args);
+    };
+    Glue.prototype.updateClassifier = function (args, optionsOrCb, cb) {
+        var command = new UpdateClassifierCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateColumnStatisticsForPartition(args, optionsOrCb, cb) {
-        const command = new UpdateColumnStatisticsForPartitionCommand(args);
+    };
+    Glue.prototype.updateColumnStatisticsForPartition = function (args, optionsOrCb, cb) {
+        var command = new UpdateColumnStatisticsForPartitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateColumnStatisticsForTable(args, optionsOrCb, cb) {
-        const command = new UpdateColumnStatisticsForTableCommand(args);
+    };
+    Glue.prototype.updateColumnStatisticsForTable = function (args, optionsOrCb, cb) {
+        var command = new UpdateColumnStatisticsForTableCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateConnection(args, optionsOrCb, cb) {
-        const command = new UpdateConnectionCommand(args);
+    };
+    Glue.prototype.updateConnection = function (args, optionsOrCb, cb) {
+        var command = new UpdateConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateCrawler(args, optionsOrCb, cb) {
-        const command = new UpdateCrawlerCommand(args);
+    };
+    Glue.prototype.updateCrawler = function (args, optionsOrCb, cb) {
+        var command = new UpdateCrawlerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateCrawlerSchedule(args, optionsOrCb, cb) {
-        const command = new UpdateCrawlerScheduleCommand(args);
+    };
+    Glue.prototype.updateCrawlerSchedule = function (args, optionsOrCb, cb) {
+        var command = new UpdateCrawlerScheduleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateDatabase(args, optionsOrCb, cb) {
-        const command = new UpdateDatabaseCommand(args);
+    };
+    Glue.prototype.updateDatabase = function (args, optionsOrCb, cb) {
+        var command = new UpdateDatabaseCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateDevEndpoint(args, optionsOrCb, cb) {
-        const command = new UpdateDevEndpointCommand(args);
+    };
+    Glue.prototype.updateDevEndpoint = function (args, optionsOrCb, cb) {
+        var command = new UpdateDevEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateJob(args, optionsOrCb, cb) {
-        const command = new UpdateJobCommand(args);
+    };
+    Glue.prototype.updateJob = function (args, optionsOrCb, cb) {
+        var command = new UpdateJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateMLTransform(args, optionsOrCb, cb) {
-        const command = new UpdateMLTransformCommand(args);
+    };
+    Glue.prototype.updateJobFromSourceControl = function (args, optionsOrCb, cb) {
+        var command = new UpdateJobFromSourceControlCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updatePartition(args, optionsOrCb, cb) {
-        const command = new UpdatePartitionCommand(args);
+    };
+    Glue.prototype.updateMLTransform = function (args, optionsOrCb, cb) {
+        var command = new UpdateMLTransformCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateRegistry(args, optionsOrCb, cb) {
-        const command = new UpdateRegistryCommand(args);
+    };
+    Glue.prototype.updatePartition = function (args, optionsOrCb, cb) {
+        var command = new UpdatePartitionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateSchema(args, optionsOrCb, cb) {
-        const command = new UpdateSchemaCommand(args);
+    };
+    Glue.prototype.updateRegistry = function (args, optionsOrCb, cb) {
+        var command = new UpdateRegistryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateTable(args, optionsOrCb, cb) {
-        const command = new UpdateTableCommand(args);
+    };
+    Glue.prototype.updateSchema = function (args, optionsOrCb, cb) {
+        var command = new UpdateSchemaCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateTrigger(args, optionsOrCb, cb) {
-        const command = new UpdateTriggerCommand(args);
+    };
+    Glue.prototype.updateSourceControlFromJob = function (args, optionsOrCb, cb) {
+        var command = new UpdateSourceControlFromJobCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateUserDefinedFunction(args, optionsOrCb, cb) {
-        const command = new UpdateUserDefinedFunctionCommand(args);
+    };
+    Glue.prototype.updateTable = function (args, optionsOrCb, cb) {
+        var command = new UpdateTableCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateWorkflow(args, optionsOrCb, cb) {
-        const command = new UpdateWorkflowCommand(args);
+    };
+    Glue.prototype.updateTrigger = function (args, optionsOrCb, cb) {
+        var command = new UpdateTriggerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-}
+    };
+    Glue.prototype.updateUserDefinedFunction = function (args, optionsOrCb, cb) {
+        var command = new UpdateUserDefinedFunctionCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Glue.prototype.updateWorkflow = function (args, optionsOrCb, cb) {
+        var command = new UpdateWorkflowCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    return Glue;
+}(GlueClient));
+export { Glue };