@aws-sdk/client-swf 3.183.0 → 3.186.0

package/dist-es/commands/PollForDecisionTaskCommand.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 { DecisionTaskFilterSensitiveLog, PollForDecisionTaskInputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0PollForDecisionTaskCommand, serializeAws_json1_0PollForDecisionTaskCommand, } from "../protocols/Aws_json1_0";
-export class PollForDecisionTaskCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PollForDecisionTaskCommand = (function (_super) {
+    __extends(PollForDecisionTaskCommand, _super);
+    function PollForDecisionTaskCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PollForDecisionTaskCommand.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 = "SWFClient";
-        const commandName = "PollForDecisionTaskCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SWFClient";
+        var commandName = "PollForDecisionTaskCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PollForDecisionTaskInputFilterSensitiveLog,
             outputFilterSensitiveLog: DecisionTaskFilterSensitiveLog,
         };
-        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);
+    };
+    PollForDecisionTaskCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0PollForDecisionTaskCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PollForDecisionTaskCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0PollForDecisionTaskCommand(output, context);
-    }
-}
+    };
+    return PollForDecisionTaskCommand;
+}($Command));
+export { PollForDecisionTaskCommand };

package/dist-es/commands/RecordActivityTaskHeartbeatCommand.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 { ActivityTaskStatusFilterSensitiveLog, RecordActivityTaskHeartbeatInputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0RecordActivityTaskHeartbeatCommand, serializeAws_json1_0RecordActivityTaskHeartbeatCommand, } from "../protocols/Aws_json1_0";
-export class RecordActivityTaskHeartbeatCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RecordActivityTaskHeartbeatCommand = (function (_super) {
+    __extends(RecordActivityTaskHeartbeatCommand, _super);
+    function RecordActivityTaskHeartbeatCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RecordActivityTaskHeartbeatCommand.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 = "SWFClient";
-        const commandName = "RecordActivityTaskHeartbeatCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SWFClient";
+        var commandName = "RecordActivityTaskHeartbeatCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RecordActivityTaskHeartbeatInputFilterSensitiveLog,
             outputFilterSensitiveLog: ActivityTaskStatusFilterSensitiveLog,
         };
-        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);
+    };
+    RecordActivityTaskHeartbeatCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0RecordActivityTaskHeartbeatCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RecordActivityTaskHeartbeatCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0RecordActivityTaskHeartbeatCommand(output, context);
-    }
-}
+    };
+    return RecordActivityTaskHeartbeatCommand;
+}($Command));
+export { RecordActivityTaskHeartbeatCommand };

package/dist-es/commands/RegisterActivityTypeCommand.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 { RegisterActivityTypeInputFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_json1_0RegisterActivityTypeCommand, serializeAws_json1_0RegisterActivityTypeCommand, } from "../protocols/Aws_json1_0";
-export class RegisterActivityTypeCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RegisterActivityTypeCommand = (function (_super) {
+    __extends(RegisterActivityTypeCommand, _super);
+    function RegisterActivityTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RegisterActivityTypeCommand.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 = "SWFClient";
-        const commandName = "RegisterActivityTypeCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SWFClient";
+        var commandName = "RegisterActivityTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RegisterActivityTypeInputFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        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);
+    };
+    RegisterActivityTypeCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0RegisterActivityTypeCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RegisterActivityTypeCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0RegisterActivityTypeCommand(output, context);
-    }
-}
+    };
+    return RegisterActivityTypeCommand;
+}($Command));
+export { RegisterActivityTypeCommand };

package/dist-es/commands/RegisterDomainCommand.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 { RegisterDomainInputFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_json1_0RegisterDomainCommand, serializeAws_json1_0RegisterDomainCommand, } from "../protocols/Aws_json1_0";
-export class RegisterDomainCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RegisterDomainCommand = (function (_super) {
+    __extends(RegisterDomainCommand, _super);
+    function RegisterDomainCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RegisterDomainCommand.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 = "SWFClient";
-        const commandName = "RegisterDomainCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SWFClient";
+        var commandName = "RegisterDomainCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RegisterDomainInputFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        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);
+    };
+    RegisterDomainCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0RegisterDomainCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RegisterDomainCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0RegisterDomainCommand(output, context);
-    }
-}
+    };
+    return RegisterDomainCommand;
+}($Command));
+export { RegisterDomainCommand };

package/dist-es/commands/RegisterWorkflowTypeCommand.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 { RegisterWorkflowTypeInputFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_json1_0RegisterWorkflowTypeCommand, serializeAws_json1_0RegisterWorkflowTypeCommand, } from "../protocols/Aws_json1_0";
-export class RegisterWorkflowTypeCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RegisterWorkflowTypeCommand = (function (_super) {
+    __extends(RegisterWorkflowTypeCommand, _super);
+    function RegisterWorkflowTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RegisterWorkflowTypeCommand.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 = "SWFClient";
-        const commandName = "RegisterWorkflowTypeCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SWFClient";
+        var commandName = "RegisterWorkflowTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RegisterWorkflowTypeInputFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        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);
+    };
+    RegisterWorkflowTypeCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0RegisterWorkflowTypeCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RegisterWorkflowTypeCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0RegisterWorkflowTypeCommand(output, context);
-    }
-}
+    };
+    return RegisterWorkflowTypeCommand;
+}($Command));
+export { RegisterWorkflowTypeCommand };

package/dist-es/commands/RequestCancelWorkflowExecutionCommand.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 { RequestCancelWorkflowExecutionInputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0RequestCancelWorkflowExecutionCommand, serializeAws_json1_0RequestCancelWorkflowExecutionCommand, } from "../protocols/Aws_json1_0";
-export class RequestCancelWorkflowExecutionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RequestCancelWorkflowExecutionCommand = (function (_super) {
+    __extends(RequestCancelWorkflowExecutionCommand, _super);
+    function RequestCancelWorkflowExecutionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RequestCancelWorkflowExecutionCommand.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 = "SWFClient";
-        const commandName = "RequestCancelWorkflowExecutionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SWFClient";
+        var commandName = "RequestCancelWorkflowExecutionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RequestCancelWorkflowExecutionInputFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        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);
+    };
+    RequestCancelWorkflowExecutionCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0RequestCancelWorkflowExecutionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RequestCancelWorkflowExecutionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0RequestCancelWorkflowExecutionCommand(output, context);
-    }
-}
+    };
+    return RequestCancelWorkflowExecutionCommand;
+}($Command));
+export { RequestCancelWorkflowExecutionCommand };

package/dist-es/commands/RespondActivityTaskCanceledCommand.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 { RespondActivityTaskCanceledInputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0RespondActivityTaskCanceledCommand, serializeAws_json1_0RespondActivityTaskCanceledCommand, } from "../protocols/Aws_json1_0";
-export class RespondActivityTaskCanceledCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RespondActivityTaskCanceledCommand = (function (_super) {
+    __extends(RespondActivityTaskCanceledCommand, _super);
+    function RespondActivityTaskCanceledCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RespondActivityTaskCanceledCommand.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 = "SWFClient";
-        const commandName = "RespondActivityTaskCanceledCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SWFClient";
+        var commandName = "RespondActivityTaskCanceledCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RespondActivityTaskCanceledInputFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        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);
+    };
+    RespondActivityTaskCanceledCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0RespondActivityTaskCanceledCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RespondActivityTaskCanceledCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0RespondActivityTaskCanceledCommand(output, context);
-    }
-}
+    };
+    return RespondActivityTaskCanceledCommand;
+}($Command));
+export { RespondActivityTaskCanceledCommand };

package/dist-es/commands/RespondActivityTaskCompletedCommand.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 { RespondActivityTaskCompletedInputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0RespondActivityTaskCompletedCommand, serializeAws_json1_0RespondActivityTaskCompletedCommand, } from "../protocols/Aws_json1_0";
-export class RespondActivityTaskCompletedCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RespondActivityTaskCompletedCommand = (function (_super) {
+    __extends(RespondActivityTaskCompletedCommand, _super);
+    function RespondActivityTaskCompletedCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RespondActivityTaskCompletedCommand.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 = "SWFClient";
-        const commandName = "RespondActivityTaskCompletedCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SWFClient";
+        var commandName = "RespondActivityTaskCompletedCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RespondActivityTaskCompletedInputFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        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);
+    };
+    RespondActivityTaskCompletedCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0RespondActivityTaskCompletedCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RespondActivityTaskCompletedCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0RespondActivityTaskCompletedCommand(output, context);
-    }
-}
+    };
+    return RespondActivityTaskCompletedCommand;
+}($Command));
+export { RespondActivityTaskCompletedCommand };

package/dist-es/commands/RespondActivityTaskFailedCommand.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 { RespondActivityTaskFailedInputFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_json1_0RespondActivityTaskFailedCommand, serializeAws_json1_0RespondActivityTaskFailedCommand, } from "../protocols/Aws_json1_0";
-export class RespondActivityTaskFailedCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RespondActivityTaskFailedCommand = (function (_super) {
+    __extends(RespondActivityTaskFailedCommand, _super);
+    function RespondActivityTaskFailedCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RespondActivityTaskFailedCommand.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 = "SWFClient";
-        const commandName = "RespondActivityTaskFailedCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SWFClient";
+        var commandName = "RespondActivityTaskFailedCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RespondActivityTaskFailedInputFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        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);
+    };
+    RespondActivityTaskFailedCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0RespondActivityTaskFailedCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RespondActivityTaskFailedCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0RespondActivityTaskFailedCommand(output, context);
-    }
-}
+    };
+    return RespondActivityTaskFailedCommand;
+}($Command));
+export { RespondActivityTaskFailedCommand };

package/dist-es/commands/RespondDecisionTaskCompletedCommand.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 { RespondDecisionTaskCompletedInputFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_0RespondDecisionTaskCompletedCommand, serializeAws_json1_0RespondDecisionTaskCompletedCommand, } from "../protocols/Aws_json1_0";
-export class RespondDecisionTaskCompletedCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var RespondDecisionTaskCompletedCommand = (function (_super) {
+    __extends(RespondDecisionTaskCompletedCommand, _super);
+    function RespondDecisionTaskCompletedCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    RespondDecisionTaskCompletedCommand.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 = "SWFClient";
-        const commandName = "RespondDecisionTaskCompletedCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "SWFClient";
+        var commandName = "RespondDecisionTaskCompletedCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: RespondDecisionTaskCompletedInputFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        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);
+    };
+    RespondDecisionTaskCompletedCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_0RespondDecisionTaskCompletedCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    RespondDecisionTaskCompletedCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_0RespondDecisionTaskCompletedCommand(output, context);
-    }
-}
+    };
+    return RespondDecisionTaskCompletedCommand;
+}($Command));
+export { RespondDecisionTaskCompletedCommand };