@aws-sdk/client-swf 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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