@aws-sdk/client-glue 3.180.0 → 3.183.0

package/dist-es/Glue.js

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