@aws-sdk/client-swf 3.32.0 → 3.36.0

package/dist-es/commands/DeprecateActivityTypeCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeprecateActivityTypeInput } from "../models/models_0";
+import { deserializeAws_json1_0DeprecateActivityTypeCommand, serializeAws_json1_0DeprecateActivityTypeCommand, } from "../protocols/Aws_json1_0";
+var DeprecateActivityTypeCommand = (function (_super) {
+    __extends(DeprecateActivityTypeCommand, _super);
+    function DeprecateActivityTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeprecateActivityTypeCommand.prototype.resolveMiddleware = function (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 = "DeprecateActivityTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeprecateActivityTypeInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeprecateActivityTypeCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0DeprecateActivityTypeCommand(input, context);
+    };
+    DeprecateActivityTypeCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DeprecateActivityTypeCommand(output, context);
+    };
+    return DeprecateActivityTypeCommand;
+}($Command));
+export { DeprecateActivityTypeCommand };

package/dist-es/commands/DeprecateDomainCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeprecateDomainInput } from "../models/models_0";
+import { deserializeAws_json1_0DeprecateDomainCommand, serializeAws_json1_0DeprecateDomainCommand, } from "../protocols/Aws_json1_0";
+var DeprecateDomainCommand = (function (_super) {
+    __extends(DeprecateDomainCommand, _super);
+    function DeprecateDomainCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeprecateDomainCommand.prototype.resolveMiddleware = function (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 = "DeprecateDomainCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeprecateDomainInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeprecateDomainCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0DeprecateDomainCommand(input, context);
+    };
+    DeprecateDomainCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DeprecateDomainCommand(output, context);
+    };
+    return DeprecateDomainCommand;
+}($Command));
+export { DeprecateDomainCommand };

package/dist-es/commands/DeprecateWorkflowTypeCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeprecateWorkflowTypeInput } from "../models/models_0";
+import { deserializeAws_json1_0DeprecateWorkflowTypeCommand, serializeAws_json1_0DeprecateWorkflowTypeCommand, } from "../protocols/Aws_json1_0";
+var DeprecateWorkflowTypeCommand = (function (_super) {
+    __extends(DeprecateWorkflowTypeCommand, _super);
+    function DeprecateWorkflowTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeprecateWorkflowTypeCommand.prototype.resolveMiddleware = function (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 = "DeprecateWorkflowTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeprecateWorkflowTypeInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeprecateWorkflowTypeCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0DeprecateWorkflowTypeCommand(input, context);
+    };
+    DeprecateWorkflowTypeCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DeprecateWorkflowTypeCommand(output, context);
+    };
+    return DeprecateWorkflowTypeCommand;
+}($Command));
+export { DeprecateWorkflowTypeCommand };

package/dist-es/commands/DescribeActivityTypeCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ActivityTypeDetail, DescribeActivityTypeInput } from "../models/models_0";
+import { deserializeAws_json1_0DescribeActivityTypeCommand, serializeAws_json1_0DescribeActivityTypeCommand, } from "../protocols/Aws_json1_0";
+var DescribeActivityTypeCommand = (function (_super) {
+    __extends(DescribeActivityTypeCommand, _super);
+    function DescribeActivityTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeActivityTypeCommand.prototype.resolveMiddleware = function (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 = "DescribeActivityTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeActivityTypeInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ActivityTypeDetail.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeActivityTypeCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0DescribeActivityTypeCommand(input, context);
+    };
+    DescribeActivityTypeCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DescribeActivityTypeCommand(output, context);
+    };
+    return DescribeActivityTypeCommand;
+}($Command));
+export { DescribeActivityTypeCommand };

package/dist-es/commands/DescribeDomainCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DescribeDomainInput, DomainDetail } from "../models/models_0";
+import { deserializeAws_json1_0DescribeDomainCommand, serializeAws_json1_0DescribeDomainCommand, } from "../protocols/Aws_json1_0";
+var DescribeDomainCommand = (function (_super) {
+    __extends(DescribeDomainCommand, _super);
+    function DescribeDomainCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeDomainCommand.prototype.resolveMiddleware = function (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 = "DescribeDomainCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeDomainInput.filterSensitiveLog,
+            outputFilterSensitiveLog: DomainDetail.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeDomainCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0DescribeDomainCommand(input, context);
+    };
+    DescribeDomainCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DescribeDomainCommand(output, context);
+    };
+    return DescribeDomainCommand;
+}($Command));
+export { DescribeDomainCommand };

package/dist-es/commands/DescribeWorkflowExecutionCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DescribeWorkflowExecutionInput, WorkflowExecutionDetail } from "../models/models_0";
+import { deserializeAws_json1_0DescribeWorkflowExecutionCommand, serializeAws_json1_0DescribeWorkflowExecutionCommand, } from "../protocols/Aws_json1_0";
+var DescribeWorkflowExecutionCommand = (function (_super) {
+    __extends(DescribeWorkflowExecutionCommand, _super);
+    function DescribeWorkflowExecutionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeWorkflowExecutionCommand.prototype.resolveMiddleware = function (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 = "DescribeWorkflowExecutionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeWorkflowExecutionInput.filterSensitiveLog,
+            outputFilterSensitiveLog: WorkflowExecutionDetail.filterSensitiveLog,
+        };
+        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);
+    };
+    DescribeWorkflowExecutionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DescribeWorkflowExecutionCommand(output, context);
+    };
+    return DescribeWorkflowExecutionCommand;
+}($Command));
+export { DescribeWorkflowExecutionCommand };

package/dist-es/commands/DescribeWorkflowTypeCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DescribeWorkflowTypeInput, WorkflowTypeDetail } from "../models/models_0";
+import { deserializeAws_json1_0DescribeWorkflowTypeCommand, serializeAws_json1_0DescribeWorkflowTypeCommand, } from "../protocols/Aws_json1_0";
+var DescribeWorkflowTypeCommand = (function (_super) {
+    __extends(DescribeWorkflowTypeCommand, _super);
+    function DescribeWorkflowTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeWorkflowTypeCommand.prototype.resolveMiddleware = function (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 = "DescribeWorkflowTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeWorkflowTypeInput.filterSensitiveLog,
+            outputFilterSensitiveLog: WorkflowTypeDetail.filterSensitiveLog,
+        };
+        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);
+    };
+    DescribeWorkflowTypeCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DescribeWorkflowTypeCommand(output, context);
+    };
+    return DescribeWorkflowTypeCommand;
+}($Command));
+export { DescribeWorkflowTypeCommand };

package/dist-es/commands/GetWorkflowExecutionHistoryCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetWorkflowExecutionHistoryInput, History } from "../models/models_0";
+import { deserializeAws_json1_0GetWorkflowExecutionHistoryCommand, serializeAws_json1_0GetWorkflowExecutionHistoryCommand, } from "../protocols/Aws_json1_0";
+var GetWorkflowExecutionHistoryCommand = (function (_super) {
+    __extends(GetWorkflowExecutionHistoryCommand, _super);
+    function GetWorkflowExecutionHistoryCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetWorkflowExecutionHistoryCommand.prototype.resolveMiddleware = function (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 = "GetWorkflowExecutionHistoryCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetWorkflowExecutionHistoryInput.filterSensitiveLog,
+            outputFilterSensitiveLog: History.filterSensitiveLog,
+        };
+        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);
+    };
+    GetWorkflowExecutionHistoryCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0GetWorkflowExecutionHistoryCommand(output, context);
+    };
+    return GetWorkflowExecutionHistoryCommand;
+}($Command));
+export { GetWorkflowExecutionHistoryCommand };

package/dist-es/commands/ListActivityTypesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ActivityTypeInfos, ListActivityTypesInput } from "../models/models_0";
+import { deserializeAws_json1_0ListActivityTypesCommand, serializeAws_json1_0ListActivityTypesCommand, } from "../protocols/Aws_json1_0";
+var ListActivityTypesCommand = (function (_super) {
+    __extends(ListActivityTypesCommand, _super);
+    function ListActivityTypesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListActivityTypesCommand.prototype.resolveMiddleware = function (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 = "ListActivityTypesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListActivityTypesInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ActivityTypeInfos.filterSensitiveLog,
+        };
+        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);
+    };
+    ListActivityTypesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ListActivityTypesCommand(output, context);
+    };
+    return ListActivityTypesCommand;
+}($Command));
+export { ListActivityTypesCommand };

package/dist-es/commands/ListClosedWorkflowExecutionsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListClosedWorkflowExecutionsInput, WorkflowExecutionInfos } from "../models/models_0";
+import { deserializeAws_json1_0ListClosedWorkflowExecutionsCommand, serializeAws_json1_0ListClosedWorkflowExecutionsCommand, } from "../protocols/Aws_json1_0";
+var ListClosedWorkflowExecutionsCommand = (function (_super) {
+    __extends(ListClosedWorkflowExecutionsCommand, _super);
+    function ListClosedWorkflowExecutionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListClosedWorkflowExecutionsCommand.prototype.resolveMiddleware = function (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 = "ListClosedWorkflowExecutionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListClosedWorkflowExecutionsInput.filterSensitiveLog,
+            outputFilterSensitiveLog: WorkflowExecutionInfos.filterSensitiveLog,
+        };
+        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);
+    };
+    ListClosedWorkflowExecutionsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ListClosedWorkflowExecutionsCommand(output, context);
+    };
+    return ListClosedWorkflowExecutionsCommand;
+}($Command));
+export { ListClosedWorkflowExecutionsCommand };

package/dist-es/commands/ListDomainsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DomainInfos, ListDomainsInput } from "../models/models_0";
+import { deserializeAws_json1_0ListDomainsCommand, serializeAws_json1_0ListDomainsCommand, } from "../protocols/Aws_json1_0";
+var ListDomainsCommand = (function (_super) {
+    __extends(ListDomainsCommand, _super);
+    function ListDomainsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListDomainsCommand.prototype.resolveMiddleware = function (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 = "ListDomainsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListDomainsInput.filterSensitiveLog,
+            outputFilterSensitiveLog: DomainInfos.filterSensitiveLog,
+        };
+        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);
+    };
+    ListDomainsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ListDomainsCommand(output, context);
+    };
+    return ListDomainsCommand;
+}($Command));
+export { ListDomainsCommand };

package/dist-es/commands/ListOpenWorkflowExecutionsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListOpenWorkflowExecutionsInput, WorkflowExecutionInfos } from "../models/models_0";
+import { deserializeAws_json1_0ListOpenWorkflowExecutionsCommand, serializeAws_json1_0ListOpenWorkflowExecutionsCommand, } from "../protocols/Aws_json1_0";
+var ListOpenWorkflowExecutionsCommand = (function (_super) {
+    __extends(ListOpenWorkflowExecutionsCommand, _super);
+    function ListOpenWorkflowExecutionsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListOpenWorkflowExecutionsCommand.prototype.resolveMiddleware = function (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 = "ListOpenWorkflowExecutionsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListOpenWorkflowExecutionsInput.filterSensitiveLog,
+            outputFilterSensitiveLog: WorkflowExecutionInfos.filterSensitiveLog,
+        };
+        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);
+    };
+    ListOpenWorkflowExecutionsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ListOpenWorkflowExecutionsCommand(output, context);
+    };
+    return ListOpenWorkflowExecutionsCommand;
+}($Command));
+export { ListOpenWorkflowExecutionsCommand };

package/{dist/es → dist-es}/commands/ListTagsForResourceCommand.js

@@ -1,40 +1,15 @@
 import { __extends } from "tslib";
-import { ListTagsForResourceInput, ListTagsForResourceOutput } from "../models/models_0";
-import { deserializeAws_json1_0ListTagsForResourceCommand, serializeAws_json1_0ListTagsForResourceCommand, } from "../protocols/Aws_json1_0";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>List tags for a given domain.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SWFClient, ListTagsForResourceCommand } from "@aws-sdk/client-swf"; // ES Modules import
- * // const { SWFClient, ListTagsForResourceCommand } = require("@aws-sdk/client-swf"); // CommonJS import
- * const client = new SWFClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link SWFClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var ListTagsForResourceCommand = /** @class */ (function (_super) {
+import { ListTagsForResourceInput, ListTagsForResourceOutput } from "../models/models_0";
+import { deserializeAws_json1_0ListTagsForResourceCommand, serializeAws_json1_0ListTagsForResourceCommand, } from "../protocols/Aws_json1_0";
+var ListTagsForResourceCommand = (function (_super) {
     __extends(ListTagsForResourceCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function ListTagsForResourceCommand(input) {
-        var _this = 
-        // Start section: command_constructor
-        _super.call(this) || this;
+        var _this = _super.call(this) || this;
         _this.input = input;
         return _this;
-        // End section: command_constructor
     }
-    /**
-     * @internal
-     */
     ListTagsForResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -62,4 +37,3 @@ var ListTagsForResourceCommand = /** @class */ (function (_super) {
     return ListTagsForResourceCommand;
 }($Command));
 export { ListTagsForResourceCommand };
-//# sourceMappingURL=ListTagsForResourceCommand.js.map

package/dist-es/commands/ListWorkflowTypesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListWorkflowTypesInput, WorkflowTypeInfos } from "../models/models_0";
+import { deserializeAws_json1_0ListWorkflowTypesCommand, serializeAws_json1_0ListWorkflowTypesCommand, } from "../protocols/Aws_json1_0";
+var ListWorkflowTypesCommand = (function (_super) {
+    __extends(ListWorkflowTypesCommand, _super);
+    function ListWorkflowTypesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListWorkflowTypesCommand.prototype.resolveMiddleware = function (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 = "ListWorkflowTypesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListWorkflowTypesInput.filterSensitiveLog,
+            outputFilterSensitiveLog: WorkflowTypeInfos.filterSensitiveLog,
+        };
+        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);
+    };
+    ListWorkflowTypesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ListWorkflowTypesCommand(output, context);
+    };
+    return ListWorkflowTypesCommand;
+}($Command));
+export { ListWorkflowTypesCommand };

package/dist-es/commands/PollForActivityTaskCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ActivityTask, PollForActivityTaskInput } from "../models/models_0";
+import { deserializeAws_json1_0PollForActivityTaskCommand, serializeAws_json1_0PollForActivityTaskCommand, } from "../protocols/Aws_json1_0";
+var PollForActivityTaskCommand = (function (_super) {
+    __extends(PollForActivityTaskCommand, _super);
+    function PollForActivityTaskCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    PollForActivityTaskCommand.prototype.resolveMiddleware = function (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 = "PollForActivityTaskCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: PollForActivityTaskInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ActivityTask.filterSensitiveLog,
+        };
+        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);
+    };
+    PollForActivityTaskCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0PollForActivityTaskCommand(output, context);
+    };
+    return PollForActivityTaskCommand;
+}($Command));
+export { PollForActivityTaskCommand };

package/dist-es/commands/PollForDecisionTaskCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DecisionTask, PollForDecisionTaskInput } 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;
+    }
+    PollForDecisionTaskCommand.prototype.resolveMiddleware = function (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,
+            inputFilterSensitiveLog: PollForDecisionTaskInput.filterSensitiveLog,
+            outputFilterSensitiveLog: DecisionTask.filterSensitiveLog,
+        };
+        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);
+    };
+    PollForDecisionTaskCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0PollForDecisionTaskCommand(output, context);
+    };
+    return PollForDecisionTaskCommand;
+}($Command));
+export { PollForDecisionTaskCommand };