@aws-sdk/client-glue 3.183.0 → 3.185.0

package/dist-es/commands/StartBlueprintRunCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { StartBlueprintRunRequestFilterSensitiveLog, StartBlueprintRunResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_json1_1StartBlueprintRunCommand, serializeAws_json1_1StartBlueprintRunCommand, } from "../protocols/Aws_json1_1";
-export class StartBlueprintRunCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartBlueprintRunCommand = (function (_super) {
+    __extends(StartBlueprintRunCommand, _super);
+    function StartBlueprintRunCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartBlueprintRunCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "GlueClient";
-        const commandName = "StartBlueprintRunCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GlueClient";
+        var commandName = "StartBlueprintRunCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartBlueprintRunRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartBlueprintRunResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartBlueprintRunCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1StartBlueprintRunCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartBlueprintRunCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1StartBlueprintRunCommand(output, context);
-    }
-}
+    };
+    return StartBlueprintRunCommand;
+}($Command));
+export { StartBlueprintRunCommand };

package/dist-es/commands/StartCrawlerCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { StartCrawlerRequestFilterSensitiveLog, StartCrawlerResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_json1_1StartCrawlerCommand, serializeAws_json1_1StartCrawlerCommand, } from "../protocols/Aws_json1_1";
-export class StartCrawlerCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartCrawlerCommand = (function (_super) {
+    __extends(StartCrawlerCommand, _super);
+    function StartCrawlerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartCrawlerCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "GlueClient";
-        const commandName = "StartCrawlerCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GlueClient";
+        var commandName = "StartCrawlerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartCrawlerRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartCrawlerResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartCrawlerCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1StartCrawlerCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartCrawlerCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1StartCrawlerCommand(output, context);
-    }
-}
+    };
+    return StartCrawlerCommand;
+}($Command));
+export { StartCrawlerCommand };

package/dist-es/commands/StartCrawlerScheduleCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { StartCrawlerScheduleRequestFilterSensitiveLog, StartCrawlerScheduleResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_json1_1StartCrawlerScheduleCommand, serializeAws_json1_1StartCrawlerScheduleCommand, } from "../protocols/Aws_json1_1";
-export class StartCrawlerScheduleCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartCrawlerScheduleCommand = (function (_super) {
+    __extends(StartCrawlerScheduleCommand, _super);
+    function StartCrawlerScheduleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartCrawlerScheduleCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "GlueClient";
-        const commandName = "StartCrawlerScheduleCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GlueClient";
+        var commandName = "StartCrawlerScheduleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartCrawlerScheduleRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartCrawlerScheduleResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartCrawlerScheduleCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1StartCrawlerScheduleCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartCrawlerScheduleCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1StartCrawlerScheduleCommand(output, context);
-    }
-}
+    };
+    return StartCrawlerScheduleCommand;
+}($Command));
+export { StartCrawlerScheduleCommand };

package/dist-es/commands/StartExportLabelsTaskRunCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { StartExportLabelsTaskRunRequestFilterSensitiveLog, StartExportLabelsTaskRunResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_json1_1StartExportLabelsTaskRunCommand, serializeAws_json1_1StartExportLabelsTaskRunCommand, } from "../protocols/Aws_json1_1";
-export class StartExportLabelsTaskRunCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartExportLabelsTaskRunCommand = (function (_super) {
+    __extends(StartExportLabelsTaskRunCommand, _super);
+    function StartExportLabelsTaskRunCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartExportLabelsTaskRunCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "GlueClient";
-        const commandName = "StartExportLabelsTaskRunCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GlueClient";
+        var commandName = "StartExportLabelsTaskRunCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartExportLabelsTaskRunRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartExportLabelsTaskRunResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartExportLabelsTaskRunCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1StartExportLabelsTaskRunCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartExportLabelsTaskRunCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1StartExportLabelsTaskRunCommand(output, context);
-    }
-}
+    };
+    return StartExportLabelsTaskRunCommand;
+}($Command));
+export { StartExportLabelsTaskRunCommand };

package/dist-es/commands/StartImportLabelsTaskRunCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { StartImportLabelsTaskRunRequestFilterSensitiveLog, StartImportLabelsTaskRunResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_json1_1StartImportLabelsTaskRunCommand, serializeAws_json1_1StartImportLabelsTaskRunCommand, } from "../protocols/Aws_json1_1";
-export class StartImportLabelsTaskRunCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartImportLabelsTaskRunCommand = (function (_super) {
+    __extends(StartImportLabelsTaskRunCommand, _super);
+    function StartImportLabelsTaskRunCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartImportLabelsTaskRunCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "GlueClient";
-        const commandName = "StartImportLabelsTaskRunCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GlueClient";
+        var commandName = "StartImportLabelsTaskRunCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartImportLabelsTaskRunRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartImportLabelsTaskRunResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartImportLabelsTaskRunCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1StartImportLabelsTaskRunCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartImportLabelsTaskRunCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1StartImportLabelsTaskRunCommand(output, context);
-    }
-}
+    };
+    return StartImportLabelsTaskRunCommand;
+}($Command));
+export { StartImportLabelsTaskRunCommand };

package/dist-es/commands/StartJobRunCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { StartJobRunRequestFilterSensitiveLog, StartJobRunResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_json1_1StartJobRunCommand, serializeAws_json1_1StartJobRunCommand, } from "../protocols/Aws_json1_1";
-export class StartJobRunCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartJobRunCommand = (function (_super) {
+    __extends(StartJobRunCommand, _super);
+    function StartJobRunCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartJobRunCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "GlueClient";
-        const commandName = "StartJobRunCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GlueClient";
+        var commandName = "StartJobRunCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartJobRunRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartJobRunResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartJobRunCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1StartJobRunCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartJobRunCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1StartJobRunCommand(output, context);
-    }
-}
+    };
+    return StartJobRunCommand;
+}($Command));
+export { StartJobRunCommand };

package/dist-es/commands/StartMLEvaluationTaskRunCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { StartMLEvaluationTaskRunRequestFilterSensitiveLog, StartMLEvaluationTaskRunResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_json1_1StartMLEvaluationTaskRunCommand, serializeAws_json1_1StartMLEvaluationTaskRunCommand, } from "../protocols/Aws_json1_1";
-export class StartMLEvaluationTaskRunCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartMLEvaluationTaskRunCommand = (function (_super) {
+    __extends(StartMLEvaluationTaskRunCommand, _super);
+    function StartMLEvaluationTaskRunCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartMLEvaluationTaskRunCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "GlueClient";
-        const commandName = "StartMLEvaluationTaskRunCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GlueClient";
+        var commandName = "StartMLEvaluationTaskRunCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartMLEvaluationTaskRunRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartMLEvaluationTaskRunResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartMLEvaluationTaskRunCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1StartMLEvaluationTaskRunCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartMLEvaluationTaskRunCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1StartMLEvaluationTaskRunCommand(output, context);
-    }
-}
+    };
+    return StartMLEvaluationTaskRunCommand;
+}($Command));
+export { StartMLEvaluationTaskRunCommand };

package/dist-es/commands/StartMLLabelingSetGenerationTaskRunCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { StartMLLabelingSetGenerationTaskRunRequestFilterSensitiveLog, StartMLLabelingSetGenerationTaskRunResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_json1_1StartMLLabelingSetGenerationTaskRunCommand, serializeAws_json1_1StartMLLabelingSetGenerationTaskRunCommand, } from "../protocols/Aws_json1_1";
-export class StartMLLabelingSetGenerationTaskRunCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartMLLabelingSetGenerationTaskRunCommand = (function (_super) {
+    __extends(StartMLLabelingSetGenerationTaskRunCommand, _super);
+    function StartMLLabelingSetGenerationTaskRunCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartMLLabelingSetGenerationTaskRunCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "GlueClient";
-        const commandName = "StartMLLabelingSetGenerationTaskRunCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GlueClient";
+        var commandName = "StartMLLabelingSetGenerationTaskRunCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartMLLabelingSetGenerationTaskRunRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartMLLabelingSetGenerationTaskRunResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartMLLabelingSetGenerationTaskRunCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1StartMLLabelingSetGenerationTaskRunCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartMLLabelingSetGenerationTaskRunCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1StartMLLabelingSetGenerationTaskRunCommand(output, context);
-    }
-}
+    };
+    return StartMLLabelingSetGenerationTaskRunCommand;
+}($Command));
+export { StartMLLabelingSetGenerationTaskRunCommand };

package/dist-es/commands/StartTriggerCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { StartTriggerRequestFilterSensitiveLog, StartTriggerResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_json1_1StartTriggerCommand, serializeAws_json1_1StartTriggerCommand, } from "../protocols/Aws_json1_1";
-export class StartTriggerCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartTriggerCommand = (function (_super) {
+    __extends(StartTriggerCommand, _super);
+    function StartTriggerCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartTriggerCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "GlueClient";
-        const commandName = "StartTriggerCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GlueClient";
+        var commandName = "StartTriggerCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartTriggerRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartTriggerResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartTriggerCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1StartTriggerCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartTriggerCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1StartTriggerCommand(output, context);
-    }
-}
+    };
+    return StartTriggerCommand;
+}($Command));
+export { StartTriggerCommand };

package/dist-es/commands/StartWorkflowRunCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { StartWorkflowRunRequestFilterSensitiveLog, StartWorkflowRunResponseFilterSensitiveLog, } from "../models/models_2";
 import { deserializeAws_json1_1StartWorkflowRunCommand, serializeAws_json1_1StartWorkflowRunCommand, } from "../protocols/Aws_json1_1";
-export class StartWorkflowRunCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var StartWorkflowRunCommand = (function (_super) {
+    __extends(StartWorkflowRunCommand, _super);
+    function StartWorkflowRunCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    StartWorkflowRunCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "GlueClient";
-        const commandName = "StartWorkflowRunCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "GlueClient";
+        var commandName = "StartWorkflowRunCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: StartWorkflowRunRequestFilterSensitiveLog,
             outputFilterSensitiveLog: StartWorkflowRunResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartWorkflowRunCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1StartWorkflowRunCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    StartWorkflowRunCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1StartWorkflowRunCommand(output, context);
-    }
-}
+    };
+    return StartWorkflowRunCommand;
+}($Command));
+export { StartWorkflowRunCommand };