@aws-sdk/client-swf 3.185.0 → 3.188.0

package/dist-es/commands/PollForDecisionTaskCommand.js

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

package/dist-es/commands/RecordActivityTaskHeartbeatCommand.js

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

package/dist-es/commands/RegisterActivityTypeCommand.js

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

package/dist-es/commands/RegisterDomainCommand.js

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

package/dist-es/commands/RegisterWorkflowTypeCommand.js

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

package/dist-es/commands/RequestCancelWorkflowExecutionCommand.js

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

package/dist-es/commands/RespondActivityTaskCanceledCommand.js

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

package/dist-es/commands/RespondActivityTaskCompletedCommand.js

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

package/dist-es/commands/RespondActivityTaskFailedCommand.js

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

package/dist-es/commands/RespondDecisionTaskCompletedCommand.js

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