@aws-sdk/client-swf 3.478.0 → 3.484.0

package/dist-es/commands/RespondActivityTaskCompletedCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_RespondActivityTaskCompletedCommand, se_RespondActivityTaskCompletedCommand, } from "../protocols/Aws_json1_0";
 export { $Command };
-export class RespondActivityTaskCompletedCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, RespondActivityTaskCompletedCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "SWFClient";
-        const commandName = "RespondActivityTaskCompletedCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "SimpleWorkflowService",
-                operation: "RespondActivityTaskCompleted",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_RespondActivityTaskCompletedCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_RespondActivityTaskCompletedCommand(output, context);
-    }
+export class RespondActivityTaskCompletedCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("SimpleWorkflowService", "RespondActivityTaskCompleted", {})
+    .n("SWFClient", "RespondActivityTaskCompletedCommand")
+    .f(void 0, void 0)
+    .ser(se_RespondActivityTaskCompletedCommand)
+    .de(de_RespondActivityTaskCompletedCommand)
+    .build() {
 }

package/dist-es/commands/RespondActivityTaskFailedCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_RespondActivityTaskFailedCommand, se_RespondActivityTaskFailedCommand } from "../protocols/Aws_json1_0";
 export { $Command };
-export class RespondActivityTaskFailedCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, RespondActivityTaskFailedCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "SWFClient";
-        const commandName = "RespondActivityTaskFailedCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "SimpleWorkflowService",
-                operation: "RespondActivityTaskFailed",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_RespondActivityTaskFailedCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_RespondActivityTaskFailedCommand(output, context);
-    }
+export class RespondActivityTaskFailedCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("SimpleWorkflowService", "RespondActivityTaskFailed", {})
+    .n("SWFClient", "RespondActivityTaskFailedCommand")
+    .f(void 0, void 0)
+    .ser(se_RespondActivityTaskFailedCommand)
+    .de(de_RespondActivityTaskFailedCommand)
+    .build() {
 }

package/dist-es/commands/RespondDecisionTaskCompletedCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_RespondDecisionTaskCompletedCommand, se_RespondDecisionTaskCompletedCommand, } from "../protocols/Aws_json1_0";
 export { $Command };
-export class RespondDecisionTaskCompletedCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, RespondDecisionTaskCompletedCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "SWFClient";
-        const commandName = "RespondDecisionTaskCompletedCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "SimpleWorkflowService",
-                operation: "RespondDecisionTaskCompleted",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_RespondDecisionTaskCompletedCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_RespondDecisionTaskCompletedCommand(output, context);
-    }
+export class RespondDecisionTaskCompletedCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("SimpleWorkflowService", "RespondDecisionTaskCompleted", {})
+    .n("SWFClient", "RespondDecisionTaskCompletedCommand")
+    .f(void 0, void 0)
+    .ser(se_RespondDecisionTaskCompletedCommand)
+    .de(de_RespondDecisionTaskCompletedCommand)
+    .build() {
 }

package/dist-es/commands/SignalWorkflowExecutionCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_SignalWorkflowExecutionCommand, se_SignalWorkflowExecutionCommand } from "../protocols/Aws_json1_0";
 export { $Command };
-export class SignalWorkflowExecutionCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, SignalWorkflowExecutionCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "SWFClient";
-        const commandName = "SignalWorkflowExecutionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "SimpleWorkflowService",
-                operation: "SignalWorkflowExecution",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_SignalWorkflowExecutionCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_SignalWorkflowExecutionCommand(output, context);
-    }
+export class SignalWorkflowExecutionCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("SimpleWorkflowService", "SignalWorkflowExecution", {})
+    .n("SWFClient", "SignalWorkflowExecutionCommand")
+    .f(void 0, void 0)
+    .ser(se_SignalWorkflowExecutionCommand)
+    .de(de_SignalWorkflowExecutionCommand)
+    .build() {
 }

package/dist-es/commands/StartWorkflowExecutionCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_StartWorkflowExecutionCommand, se_StartWorkflowExecutionCommand } from "../protocols/Aws_json1_0";
 export { $Command };
-export class StartWorkflowExecutionCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, StartWorkflowExecutionCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "SWFClient";
-        const commandName = "StartWorkflowExecutionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "SimpleWorkflowService",
-                operation: "StartWorkflowExecution",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_StartWorkflowExecutionCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_StartWorkflowExecutionCommand(output, context);
-    }
+export class StartWorkflowExecutionCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("SimpleWorkflowService", "StartWorkflowExecution", {})
+    .n("SWFClient", "StartWorkflowExecutionCommand")
+    .f(void 0, void 0)
+    .ser(se_StartWorkflowExecutionCommand)
+    .de(de_StartWorkflowExecutionCommand)
+    .build() {
 }

package/dist-es/commands/TagResourceCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_TagResourceCommand, se_TagResourceCommand } from "../protocols/Aws_json1_0";
 export { $Command };
-export class TagResourceCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, TagResourceCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "SWFClient";
-        const commandName = "TagResourceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "SimpleWorkflowService",
-                operation: "TagResource",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_TagResourceCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_TagResourceCommand(output, context);
-    }
+export class TagResourceCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("SimpleWorkflowService", "TagResource", {})
+    .n("SWFClient", "TagResourceCommand")
+    .f(void 0, void 0)
+    .ser(se_TagResourceCommand)
+    .de(de_TagResourceCommand)
+    .build() {
 }

package/dist-es/commands/TerminateWorkflowExecutionCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_TerminateWorkflowExecutionCommand, se_TerminateWorkflowExecutionCommand } from "../protocols/Aws_json1_0";
 export { $Command };
-export class TerminateWorkflowExecutionCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, TerminateWorkflowExecutionCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "SWFClient";
-        const commandName = "TerminateWorkflowExecutionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "SimpleWorkflowService",
-                operation: "TerminateWorkflowExecution",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_TerminateWorkflowExecutionCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_TerminateWorkflowExecutionCommand(output, context);
-    }
+export class TerminateWorkflowExecutionCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("SimpleWorkflowService", "TerminateWorkflowExecution", {})
+    .n("SWFClient", "TerminateWorkflowExecutionCommand")
+    .f(void 0, void 0)
+    .ser(se_TerminateWorkflowExecutionCommand)
+    .de(de_TerminateWorkflowExecutionCommand)
+    .build() {
 }

package/dist-es/commands/UndeprecateActivityTypeCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_UndeprecateActivityTypeCommand, se_UndeprecateActivityTypeCommand } from "../protocols/Aws_json1_0";
 export { $Command };
-export class UndeprecateActivityTypeCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, UndeprecateActivityTypeCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "SWFClient";
-        const commandName = "UndeprecateActivityTypeCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "SimpleWorkflowService",
-                operation: "UndeprecateActivityType",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_UndeprecateActivityTypeCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_UndeprecateActivityTypeCommand(output, context);
-    }
+export class UndeprecateActivityTypeCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("SimpleWorkflowService", "UndeprecateActivityType", {})
+    .n("SWFClient", "UndeprecateActivityTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_UndeprecateActivityTypeCommand)
+    .de(de_UndeprecateActivityTypeCommand)
+    .build() {
 }

package/dist-es/commands/UndeprecateDomainCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_UndeprecateDomainCommand, se_UndeprecateDomainCommand } from "../protocols/Aws_json1_0";
 export { $Command };
-export class UndeprecateDomainCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, UndeprecateDomainCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "SWFClient";
-        const commandName = "UndeprecateDomainCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "SimpleWorkflowService",
-                operation: "UndeprecateDomain",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_UndeprecateDomainCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_UndeprecateDomainCommand(output, context);
-    }
+export class UndeprecateDomainCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("SimpleWorkflowService", "UndeprecateDomain", {})
+    .n("SWFClient", "UndeprecateDomainCommand")
+    .f(void 0, void 0)
+    .ser(se_UndeprecateDomainCommand)
+    .de(de_UndeprecateDomainCommand)
+    .build() {
 }