@aws-sdk/client-swf 3.32.0 → 3.36.0

package/dist-es/commands/RecordActivityTaskHeartbeatCommand.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 { ActivityTaskStatus, RecordActivityTaskHeartbeatInput } from "../models/models_0";
+import { deserializeAws_json1_0RecordActivityTaskHeartbeatCommand, serializeAws_json1_0RecordActivityTaskHeartbeatCommand, } from "../protocols/Aws_json1_0";
+var RecordActivityTaskHeartbeatCommand = (function (_super) {
+    __extends(RecordActivityTaskHeartbeatCommand, _super);
+    function RecordActivityTaskHeartbeatCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RecordActivityTaskHeartbeatCommand.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 = "RecordActivityTaskHeartbeatCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RecordActivityTaskHeartbeatInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ActivityTaskStatus.filterSensitiveLog,
+        };
+        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);
+    };
+    RecordActivityTaskHeartbeatCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0RecordActivityTaskHeartbeatCommand(output, context);
+    };
+    return RecordActivityTaskHeartbeatCommand;
+}($Command));
+export { RecordActivityTaskHeartbeatCommand };

package/dist-es/commands/RegisterActivityTypeCommand.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 { RegisterActivityTypeInput } from "../models/models_0";
+import { deserializeAws_json1_0RegisterActivityTypeCommand, serializeAws_json1_0RegisterActivityTypeCommand, } from "../protocols/Aws_json1_0";
+var RegisterActivityTypeCommand = (function (_super) {
+    __extends(RegisterActivityTypeCommand, _super);
+    function RegisterActivityTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RegisterActivityTypeCommand.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 = "RegisterActivityTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RegisterActivityTypeInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        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);
+    };
+    RegisterActivityTypeCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0RegisterActivityTypeCommand(output, context);
+    };
+    return RegisterActivityTypeCommand;
+}($Command));
+export { RegisterActivityTypeCommand };

package/dist-es/commands/RegisterDomainCommand.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 { RegisterDomainInput } from "../models/models_0";
+import { deserializeAws_json1_0RegisterDomainCommand, serializeAws_json1_0RegisterDomainCommand, } from "../protocols/Aws_json1_0";
+var RegisterDomainCommand = (function (_super) {
+    __extends(RegisterDomainCommand, _super);
+    function RegisterDomainCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RegisterDomainCommand.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 = "RegisterDomainCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RegisterDomainInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        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);
+    };
+    RegisterDomainCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0RegisterDomainCommand(output, context);
+    };
+    return RegisterDomainCommand;
+}($Command));
+export { RegisterDomainCommand };

package/dist-es/commands/RegisterWorkflowTypeCommand.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 { RegisterWorkflowTypeInput } from "../models/models_0";
+import { deserializeAws_json1_0RegisterWorkflowTypeCommand, serializeAws_json1_0RegisterWorkflowTypeCommand, } from "../protocols/Aws_json1_0";
+var RegisterWorkflowTypeCommand = (function (_super) {
+    __extends(RegisterWorkflowTypeCommand, _super);
+    function RegisterWorkflowTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RegisterWorkflowTypeCommand.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 = "RegisterWorkflowTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RegisterWorkflowTypeInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        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);
+    };
+    RegisterWorkflowTypeCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0RegisterWorkflowTypeCommand(output, context);
+    };
+    return RegisterWorkflowTypeCommand;
+}($Command));
+export { RegisterWorkflowTypeCommand };

package/dist-es/commands/RequestCancelWorkflowExecutionCommand.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 { RequestCancelWorkflowExecutionInput } from "../models/models_0";
+import { deserializeAws_json1_0RequestCancelWorkflowExecutionCommand, serializeAws_json1_0RequestCancelWorkflowExecutionCommand, } from "../protocols/Aws_json1_0";
+var RequestCancelWorkflowExecutionCommand = (function (_super) {
+    __extends(RequestCancelWorkflowExecutionCommand, _super);
+    function RequestCancelWorkflowExecutionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RequestCancelWorkflowExecutionCommand.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 = "RequestCancelWorkflowExecutionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RequestCancelWorkflowExecutionInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        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);
+    };
+    RequestCancelWorkflowExecutionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0RequestCancelWorkflowExecutionCommand(output, context);
+    };
+    return RequestCancelWorkflowExecutionCommand;
+}($Command));
+export { RequestCancelWorkflowExecutionCommand };

package/dist-es/commands/RespondActivityTaskCanceledCommand.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 { RespondActivityTaskCanceledInput } from "../models/models_0";
+import { deserializeAws_json1_0RespondActivityTaskCanceledCommand, serializeAws_json1_0RespondActivityTaskCanceledCommand, } from "../protocols/Aws_json1_0";
+var RespondActivityTaskCanceledCommand = (function (_super) {
+    __extends(RespondActivityTaskCanceledCommand, _super);
+    function RespondActivityTaskCanceledCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RespondActivityTaskCanceledCommand.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 = "RespondActivityTaskCanceledCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RespondActivityTaskCanceledInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        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);
+    };
+    RespondActivityTaskCanceledCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0RespondActivityTaskCanceledCommand(output, context);
+    };
+    return RespondActivityTaskCanceledCommand;
+}($Command));
+export { RespondActivityTaskCanceledCommand };

package/dist-es/commands/RespondActivityTaskCompletedCommand.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 { RespondActivityTaskCompletedInput } from "../models/models_0";
+import { deserializeAws_json1_0RespondActivityTaskCompletedCommand, serializeAws_json1_0RespondActivityTaskCompletedCommand, } from "../protocols/Aws_json1_0";
+var RespondActivityTaskCompletedCommand = (function (_super) {
+    __extends(RespondActivityTaskCompletedCommand, _super);
+    function RespondActivityTaskCompletedCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RespondActivityTaskCompletedCommand.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 = "RespondActivityTaskCompletedCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RespondActivityTaskCompletedInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        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);
+    };
+    RespondActivityTaskCompletedCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0RespondActivityTaskCompletedCommand(output, context);
+    };
+    return RespondActivityTaskCompletedCommand;
+}($Command));
+export { RespondActivityTaskCompletedCommand };

package/dist-es/commands/RespondActivityTaskFailedCommand.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 { RespondActivityTaskFailedInput } from "../models/models_0";
+import { deserializeAws_json1_0RespondActivityTaskFailedCommand, serializeAws_json1_0RespondActivityTaskFailedCommand, } from "../protocols/Aws_json1_0";
+var RespondActivityTaskFailedCommand = (function (_super) {
+    __extends(RespondActivityTaskFailedCommand, _super);
+    function RespondActivityTaskFailedCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RespondActivityTaskFailedCommand.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 = "RespondActivityTaskFailedCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RespondActivityTaskFailedInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        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);
+    };
+    RespondActivityTaskFailedCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0RespondActivityTaskFailedCommand(output, context);
+    };
+    return RespondActivityTaskFailedCommand;
+}($Command));
+export { RespondActivityTaskFailedCommand };

package/dist-es/commands/RespondDecisionTaskCompletedCommand.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 { RespondDecisionTaskCompletedInput } from "../models/models_0";
+import { deserializeAws_json1_0RespondDecisionTaskCompletedCommand, serializeAws_json1_0RespondDecisionTaskCompletedCommand, } from "../protocols/Aws_json1_0";
+var RespondDecisionTaskCompletedCommand = (function (_super) {
+    __extends(RespondDecisionTaskCompletedCommand, _super);
+    function RespondDecisionTaskCompletedCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    RespondDecisionTaskCompletedCommand.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 = "RespondDecisionTaskCompletedCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: RespondDecisionTaskCompletedInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        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);
+    };
+    RespondDecisionTaskCompletedCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0RespondDecisionTaskCompletedCommand(output, context);
+    };
+    return RespondDecisionTaskCompletedCommand;
+}($Command));
+export { RespondDecisionTaskCompletedCommand };

package/dist-es/commands/SignalWorkflowExecutionCommand.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 { SignalWorkflowExecutionInput } from "../models/models_0";
+import { deserializeAws_json1_0SignalWorkflowExecutionCommand, serializeAws_json1_0SignalWorkflowExecutionCommand, } from "../protocols/Aws_json1_0";
+var SignalWorkflowExecutionCommand = (function (_super) {
+    __extends(SignalWorkflowExecutionCommand, _super);
+    function SignalWorkflowExecutionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    SignalWorkflowExecutionCommand.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 = "SignalWorkflowExecutionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: SignalWorkflowExecutionInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    SignalWorkflowExecutionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0SignalWorkflowExecutionCommand(input, context);
+    };
+    SignalWorkflowExecutionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0SignalWorkflowExecutionCommand(output, context);
+    };
+    return SignalWorkflowExecutionCommand;
+}($Command));
+export { SignalWorkflowExecutionCommand };

package/dist-es/commands/StartWorkflowExecutionCommand.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 { Run, StartWorkflowExecutionInput } from "../models/models_0";
+import { deserializeAws_json1_0StartWorkflowExecutionCommand, serializeAws_json1_0StartWorkflowExecutionCommand, } from "../protocols/Aws_json1_0";
+var StartWorkflowExecutionCommand = (function (_super) {
+    __extends(StartWorkflowExecutionCommand, _super);
+    function StartWorkflowExecutionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    StartWorkflowExecutionCommand.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 = "StartWorkflowExecutionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: StartWorkflowExecutionInput.filterSensitiveLog,
+            outputFilterSensitiveLog: Run.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    StartWorkflowExecutionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0StartWorkflowExecutionCommand(input, context);
+    };
+    StartWorkflowExecutionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0StartWorkflowExecutionCommand(output, context);
+    };
+    return StartWorkflowExecutionCommand;
+}($Command));
+export { StartWorkflowExecutionCommand };

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

@@ -1,43 +1,15 @@
 import { __extends } from "tslib";
-import { TagResourceInput } from "../models/models_0";
-import { deserializeAws_json1_0TagResourceCommand, serializeAws_json1_0TagResourceCommand, } from "../protocols/Aws_json1_0";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-/**
- * <p>Add a tag to a Amazon SWF domain.</p>
- *          <note>
- *             <p>Amazon SWF supports a maximum of 50 tags per resource.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SWFClient, TagResourceCommand } from "@aws-sdk/client-swf"; // ES Modules import
- * // const { SWFClient, TagResourceCommand } = require("@aws-sdk/client-swf"); // CommonJS import
- * const client = new SWFClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link SWFClientResolvedConfig | config} for command's `input` shape.
- *
- */
-var TagResourceCommand = /** @class */ (function (_super) {
+import { TagResourceInput } from "../models/models_0";
+import { deserializeAws_json1_0TagResourceCommand, serializeAws_json1_0TagResourceCommand, } from "../protocols/Aws_json1_0";
+var TagResourceCommand = (function (_super) {
     __extends(TagResourceCommand, _super);
-    // Start section: command_properties
-    // End section: command_properties
     function TagResourceCommand(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
-     */
     TagResourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
         var stack = clientStack.concat(this.middlewareStack);
@@ -65,4 +37,3 @@ var TagResourceCommand = /** @class */ (function (_super) {
     return TagResourceCommand;
 }($Command));
 export { TagResourceCommand };
-//# sourceMappingURL=TagResourceCommand.js.map

package/dist-es/commands/TerminateWorkflowExecutionCommand.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 { TerminateWorkflowExecutionInput } from "../models/models_0";
+import { deserializeAws_json1_0TerminateWorkflowExecutionCommand, serializeAws_json1_0TerminateWorkflowExecutionCommand, } from "../protocols/Aws_json1_0";
+var TerminateWorkflowExecutionCommand = (function (_super) {
+    __extends(TerminateWorkflowExecutionCommand, _super);
+    function TerminateWorkflowExecutionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    TerminateWorkflowExecutionCommand.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 = "TerminateWorkflowExecutionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: TerminateWorkflowExecutionInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    TerminateWorkflowExecutionCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0TerminateWorkflowExecutionCommand(input, context);
+    };
+    TerminateWorkflowExecutionCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0TerminateWorkflowExecutionCommand(output, context);
+    };
+    return TerminateWorkflowExecutionCommand;
+}($Command));
+export { TerminateWorkflowExecutionCommand };

package/dist-es/commands/UndeprecateActivityTypeCommand.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 { UndeprecateActivityTypeInput } from "../models/models_0";
+import { deserializeAws_json1_0UndeprecateActivityTypeCommand, serializeAws_json1_0UndeprecateActivityTypeCommand, } from "../protocols/Aws_json1_0";
+var UndeprecateActivityTypeCommand = (function (_super) {
+    __extends(UndeprecateActivityTypeCommand, _super);
+    function UndeprecateActivityTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UndeprecateActivityTypeCommand.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 = "UndeprecateActivityTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UndeprecateActivityTypeInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UndeprecateActivityTypeCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0UndeprecateActivityTypeCommand(input, context);
+    };
+    UndeprecateActivityTypeCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0UndeprecateActivityTypeCommand(output, context);
+    };
+    return UndeprecateActivityTypeCommand;
+}($Command));
+export { UndeprecateActivityTypeCommand };

package/dist-es/commands/UndeprecateDomainCommand.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 { UndeprecateDomainInput } from "../models/models_0";
+import { deserializeAws_json1_0UndeprecateDomainCommand, serializeAws_json1_0UndeprecateDomainCommand, } from "../protocols/Aws_json1_0";
+var UndeprecateDomainCommand = (function (_super) {
+    __extends(UndeprecateDomainCommand, _super);
+    function UndeprecateDomainCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UndeprecateDomainCommand.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 = "UndeprecateDomainCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UndeprecateDomainInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UndeprecateDomainCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0UndeprecateDomainCommand(input, context);
+    };
+    UndeprecateDomainCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0UndeprecateDomainCommand(output, context);
+    };
+    return UndeprecateDomainCommand;
+}($Command));
+export { UndeprecateDomainCommand };

package/dist-es/commands/UndeprecateWorkflowTypeCommand.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 { UndeprecateWorkflowTypeInput } from "../models/models_0";
+import { deserializeAws_json1_0UndeprecateWorkflowTypeCommand, serializeAws_json1_0UndeprecateWorkflowTypeCommand, } from "../protocols/Aws_json1_0";
+var UndeprecateWorkflowTypeCommand = (function (_super) {
+    __extends(UndeprecateWorkflowTypeCommand, _super);
+    function UndeprecateWorkflowTypeCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UndeprecateWorkflowTypeCommand.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 = "UndeprecateWorkflowTypeCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UndeprecateWorkflowTypeInput.filterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UndeprecateWorkflowTypeCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0UndeprecateWorkflowTypeCommand(input, context);
+    };
+    UndeprecateWorkflowTypeCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0UndeprecateWorkflowTypeCommand(output, context);
+    };
+    return UndeprecateWorkflowTypeCommand;
+}($Command));
+export { UndeprecateWorkflowTypeCommand };