@aws-sdk/client-swf 3.927.0 → 3.929.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class SWFClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -110,12 +110,12 @@ class SWFClient extends smithyClient.Client {
     }
 }
 
-class SWFServiceException extends smithyClient.ServiceException {
+let SWFServiceException$1 = class SWFServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, SWFServiceException.prototype);
     }
-}
+};
 
 const ActivityTaskTimeoutType = {
     HEARTBEAT: "HEARTBEAT",
@@ -166,7 +166,7 @@ const ContinueAsNewWorkflowExecutionFailedCause = {
     WORKFLOW_TYPE_DEPRECATED: "WORKFLOW_TYPE_DEPRECATED",
     WORKFLOW_TYPE_DOES_NOT_EXIST: "WORKFLOW_TYPE_DOES_NOT_EXIST",
 };
-class OperationNotPermittedFault extends SWFServiceException {
+let OperationNotPermittedFault$1 = class OperationNotPermittedFault extends SWFServiceException$1 {
     name = "OperationNotPermittedFault";
     $fault = "client";
     constructor(opts) {
@@ -177,8 +177,8 @@ class OperationNotPermittedFault extends SWFServiceException {
         });
         Object.setPrototypeOf(this, OperationNotPermittedFault.prototype);
     }
-}
-class UnknownResourceFault extends SWFServiceException {
+};
+let UnknownResourceFault$1 = class UnknownResourceFault extends SWFServiceException$1 {
     name = "UnknownResourceFault";
     $fault = "client";
     constructor(opts) {
@@ -189,7 +189,7 @@ class UnknownResourceFault extends SWFServiceException {
         });
         Object.setPrototypeOf(this, UnknownResourceFault.prototype);
     }
-}
+};
 const DecisionType = {
     CancelTimer: "CancelTimer",
     CancelWorkflowExecution: "CancelWorkflowExecution",
@@ -338,7 +338,7 @@ const WorkflowExecutionTerminatedCause = {
     EVENT_LIMIT_EXCEEDED: "EVENT_LIMIT_EXCEEDED",
     OPERATOR_INITIATED: "OPERATOR_INITIATED",
 };
-class DefaultUndefinedFault extends SWFServiceException {
+let DefaultUndefinedFault$1 = class DefaultUndefinedFault extends SWFServiceException$1 {
     name = "DefaultUndefinedFault";
     $fault = "client";
     constructor(opts) {
@@ -349,8 +349,8 @@ class DefaultUndefinedFault extends SWFServiceException {
         });
         Object.setPrototypeOf(this, DefaultUndefinedFault.prototype);
     }
-}
-class TypeNotDeprecatedFault extends SWFServiceException {
+};
+let TypeNotDeprecatedFault$1 = class TypeNotDeprecatedFault extends SWFServiceException$1 {
     name = "TypeNotDeprecatedFault";
     $fault = "client";
     constructor(opts) {
@@ -361,8 +361,8 @@ class TypeNotDeprecatedFault extends SWFServiceException {
         });
         Object.setPrototypeOf(this, TypeNotDeprecatedFault.prototype);
     }
-}
-class TypeDeprecatedFault extends SWFServiceException {
+};
+let TypeDeprecatedFault$1 = class TypeDeprecatedFault extends SWFServiceException$1 {
     name = "TypeDeprecatedFault";
     $fault = "client";
     constructor(opts) {
@@ -373,8 +373,8 @@ class TypeDeprecatedFault extends SWFServiceException {
         });
         Object.setPrototypeOf(this, TypeDeprecatedFault.prototype);
     }
-}
-class DomainDeprecatedFault extends SWFServiceException {
+};
+let DomainDeprecatedFault$1 = class DomainDeprecatedFault extends SWFServiceException$1 {
     name = "DomainDeprecatedFault";
     $fault = "client";
     constructor(opts) {
@@ -385,12 +385,12 @@ class DomainDeprecatedFault extends SWFServiceException {
         });
         Object.setPrototypeOf(this, DomainDeprecatedFault.prototype);
     }
-}
+};
 const ExecutionStatus = {
     CLOSED: "CLOSED",
     OPEN: "OPEN",
 };
-class DomainAlreadyExistsFault extends SWFServiceException {
+let DomainAlreadyExistsFault$1 = class DomainAlreadyExistsFault extends SWFServiceException$1 {
     name = "DomainAlreadyExistsFault";
     $fault = "client";
     constructor(opts) {
@@ -401,8 +401,8 @@ class DomainAlreadyExistsFault extends SWFServiceException {
         });
         Object.setPrototypeOf(this, DomainAlreadyExistsFault.prototype);
     }
-}
-class LimitExceededFault extends SWFServiceException {
+};
+let LimitExceededFault$1 = class LimitExceededFault extends SWFServiceException$1 {
     name = "LimitExceededFault";
     $fault = "client";
     constructor(opts) {
@@ -413,8 +413,8 @@ class LimitExceededFault extends SWFServiceException {
         });
         Object.setPrototypeOf(this, LimitExceededFault.prototype);
     }
-}
-class TypeAlreadyExistsFault extends SWFServiceException {
+};
+let TypeAlreadyExistsFault$1 = class TypeAlreadyExistsFault extends SWFServiceException$1 {
     name = "TypeAlreadyExistsFault";
     $fault = "client";
     constructor(opts) {
@@ -425,8 +425,8 @@ class TypeAlreadyExistsFault extends SWFServiceException {
         });
         Object.setPrototypeOf(this, TypeAlreadyExistsFault.prototype);
     }
-}
-class TooManyTagsFault extends SWFServiceException {
+};
+let TooManyTagsFault$1 = class TooManyTagsFault extends SWFServiceException$1 {
     name = "TooManyTagsFault";
     $fault = "client";
     constructor(opts) {
@@ -437,8 +437,8 @@ class TooManyTagsFault extends SWFServiceException {
         });
         Object.setPrototypeOf(this, TooManyTagsFault.prototype);
     }
-}
-class WorkflowExecutionAlreadyStartedFault extends SWFServiceException {
+};
+let WorkflowExecutionAlreadyStartedFault$1 = class WorkflowExecutionAlreadyStartedFault extends SWFServiceException$1 {
     name = "WorkflowExecutionAlreadyStartedFault";
     $fault = "client";
     constructor(opts) {
@@ -449,1112 +449,1646 @@ class WorkflowExecutionAlreadyStartedFault extends SWFServiceException {
         });
         Object.setPrototypeOf(this, WorkflowExecutionAlreadyStartedFault.prototype);
     }
-}
-
-const se_CountClosedWorkflowExecutionsCommand = async (input, context) => {
-    const headers = sharedHeaders("CountClosedWorkflowExecutions");
-    let body;
-    body = JSON.stringify(se_CountClosedWorkflowExecutionsInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CountOpenWorkflowExecutionsCommand = async (input, context) => {
-    const headers = sharedHeaders("CountOpenWorkflowExecutions");
-    let body;
-    body = JSON.stringify(se_CountOpenWorkflowExecutionsInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CountPendingActivityTasksCommand = async (input, context) => {
-    const headers = sharedHeaders("CountPendingActivityTasks");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CountPendingDecisionTasksCommand = async (input, context) => {
-    const headers = sharedHeaders("CountPendingDecisionTasks");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteActivityTypeCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteActivityType");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteWorkflowTypeCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteWorkflowType");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeprecateActivityTypeCommand = async (input, context) => {
-    const headers = sharedHeaders("DeprecateActivityType");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeprecateDomainCommand = async (input, context) => {
-    const headers = sharedHeaders("DeprecateDomain");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeprecateWorkflowTypeCommand = async (input, context) => {
-    const headers = sharedHeaders("DeprecateWorkflowType");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeActivityTypeCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeActivityType");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeDomainCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeDomain");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeWorkflowExecutionCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeWorkflowExecution");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeWorkflowTypeCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeWorkflowType");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetWorkflowExecutionHistoryCommand = async (input, context) => {
-    const headers = sharedHeaders("GetWorkflowExecutionHistory");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListActivityTypesCommand = async (input, context) => {
-    const headers = sharedHeaders("ListActivityTypes");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListClosedWorkflowExecutionsCommand = async (input, context) => {
-    const headers = sharedHeaders("ListClosedWorkflowExecutions");
-    let body;
-    body = JSON.stringify(se_ListClosedWorkflowExecutionsInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListDomainsCommand = async (input, context) => {
-    const headers = sharedHeaders("ListDomains");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListOpenWorkflowExecutionsCommand = async (input, context) => {
-    const headers = sharedHeaders("ListOpenWorkflowExecutions");
-    let body;
-    body = JSON.stringify(se_ListOpenWorkflowExecutionsInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("ListTagsForResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListWorkflowTypesCommand = async (input, context) => {
-    const headers = sharedHeaders("ListWorkflowTypes");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_PollForActivityTaskCommand = async (input, context) => {
-    const headers = sharedHeaders("PollForActivityTask");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_PollForDecisionTaskCommand = async (input, context) => {
-    const headers = sharedHeaders("PollForDecisionTask");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RecordActivityTaskHeartbeatCommand = async (input, context) => {
-    const headers = sharedHeaders("RecordActivityTaskHeartbeat");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RegisterActivityTypeCommand = async (input, context) => {
-    const headers = sharedHeaders("RegisterActivityType");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RegisterDomainCommand = async (input, context) => {
-    const headers = sharedHeaders("RegisterDomain");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RegisterWorkflowTypeCommand = async (input, context) => {
-    const headers = sharedHeaders("RegisterWorkflowType");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RequestCancelWorkflowExecutionCommand = async (input, context) => {
-    const headers = sharedHeaders("RequestCancelWorkflowExecution");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RespondActivityTaskCanceledCommand = async (input, context) => {
-    const headers = sharedHeaders("RespondActivityTaskCanceled");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RespondActivityTaskCompletedCommand = async (input, context) => {
-    const headers = sharedHeaders("RespondActivityTaskCompleted");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RespondActivityTaskFailedCommand = async (input, context) => {
-    const headers = sharedHeaders("RespondActivityTaskFailed");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RespondDecisionTaskCompletedCommand = async (input, context) => {
-    const headers = sharedHeaders("RespondDecisionTaskCompleted");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_SignalWorkflowExecutionCommand = async (input, context) => {
-    const headers = sharedHeaders("SignalWorkflowExecution");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_StartWorkflowExecutionCommand = async (input, context) => {
-    const headers = sharedHeaders("StartWorkflowExecution");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_TagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("TagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_TerminateWorkflowExecutionCommand = async (input, context) => {
-    const headers = sharedHeaders("TerminateWorkflowExecution");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UndeprecateActivityTypeCommand = async (input, context) => {
-    const headers = sharedHeaders("UndeprecateActivityType");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UndeprecateDomainCommand = async (input, context) => {
-    const headers = sharedHeaders("UndeprecateDomain");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UndeprecateWorkflowTypeCommand = async (input, context) => {
-    const headers = sharedHeaders("UndeprecateWorkflowType");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("UntagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_CountClosedWorkflowExecutionsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CountOpenWorkflowExecutionsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CountPendingActivityTasksCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CountPendingDecisionTasksCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteActivityTypeCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_DeleteWorkflowTypeCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_DeprecateActivityTypeCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_DeprecateDomainCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_DeprecateWorkflowTypeCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_DescribeActivityTypeCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ActivityTypeDetail(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeDomainCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeWorkflowExecutionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_WorkflowExecutionDetail(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeWorkflowTypeCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_WorkflowTypeDetail(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetWorkflowExecutionHistoryCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_History(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListActivityTypesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ActivityTypeInfos(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListClosedWorkflowExecutionsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_WorkflowExecutionInfos(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListDomainsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListOpenWorkflowExecutionsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_WorkflowExecutionInfos(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListWorkflowTypesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_WorkflowTypeInfos(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PollForActivityTaskCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PollForDecisionTaskCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DecisionTask(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_RecordActivityTaskHeartbeatCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_RegisterActivityTypeCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_RegisterDomainCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_RegisterWorkflowTypeCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_RequestCancelWorkflowExecutionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_RespondActivityTaskCanceledCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_RespondActivityTaskCompletedCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_RespondActivityTaskFailedCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_RespondDecisionTaskCompletedCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_SignalWorkflowExecutionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_StartWorkflowExecutionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_TerminateWorkflowExecutionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_UndeprecateActivityTypeCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_UndeprecateDomainCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_UndeprecateWorkflowTypeCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "OperationNotPermittedFault":
-        case "com.amazonaws.swf#OperationNotPermittedFault":
-            throw await de_OperationNotPermittedFaultRes(parsedOutput);
-        case "UnknownResourceFault":
-        case "com.amazonaws.swf#UnknownResourceFault":
-            throw await de_UnknownResourceFaultRes(parsedOutput);
-        case "TypeNotDeprecatedFault":
-        case "com.amazonaws.swf#TypeNotDeprecatedFault":
-            throw await de_TypeNotDeprecatedFaultRes(parsedOutput);
-        case "TypeDeprecatedFault":
-        case "com.amazonaws.swf#TypeDeprecatedFault":
-            throw await de_TypeDeprecatedFaultRes(parsedOutput);
-        case "DomainDeprecatedFault":
-        case "com.amazonaws.swf#DomainDeprecatedFault":
-            throw await de_DomainDeprecatedFaultRes(parsedOutput);
-        case "LimitExceededFault":
-        case "com.amazonaws.swf#LimitExceededFault":
-            throw await de_LimitExceededFaultRes(parsedOutput);
-        case "TypeAlreadyExistsFault":
-        case "com.amazonaws.swf#TypeAlreadyExistsFault":
-            throw await de_TypeAlreadyExistsFaultRes(parsedOutput);
-        case "DomainAlreadyExistsFault":
-        case "com.amazonaws.swf#DomainAlreadyExistsFault":
-            throw await de_DomainAlreadyExistsFaultRes(parsedOutput);
-        case "TooManyTagsFault":
-        case "com.amazonaws.swf#TooManyTagsFault":
-            throw await de_TooManyTagsFaultRes(parsedOutput);
-        case "DefaultUndefinedFault":
-        case "com.amazonaws.swf#DefaultUndefinedFault":
-            throw await de_DefaultUndefinedFaultRes(parsedOutput);
-        case "WorkflowExecutionAlreadyStartedFault":
-        case "com.amazonaws.swf#WorkflowExecutionAlreadyStartedFault":
-            throw await de_WorkflowExecutionAlreadyStartedFaultRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const de_DefaultUndefinedFaultRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new DefaultUndefinedFault({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_DomainAlreadyExistsFaultRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new DomainAlreadyExistsFault({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_DomainDeprecatedFaultRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new DomainDeprecatedFault({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_LimitExceededFaultRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new LimitExceededFault({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
 };
-const de_OperationNotPermittedFaultRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new OperationNotPermittedFault({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_TooManyTagsFaultRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new TooManyTagsFault({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_TypeAlreadyExistsFaultRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new TypeAlreadyExistsFault({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_TypeDeprecatedFaultRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new TypeDeprecatedFault({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_TypeNotDeprecatedFaultRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new TypeNotDeprecatedFault({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_UnknownResourceFaultRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new UnknownResourceFault({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_WorkflowExecutionAlreadyStartedFaultRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new WorkflowExecutionAlreadyStartedFault({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const se_CountClosedWorkflowExecutionsInput = (input, context) => {
-    return smithyClient.take(input, {
-        closeStatusFilter: smithyClient._json,
-        closeTimeFilter: (_) => se_ExecutionTimeFilter(_),
-        domain: [],
-        executionFilter: smithyClient._json,
-        startTimeFilter: (_) => se_ExecutionTimeFilter(_),
-        tagFilter: smithyClient._json,
-        typeFilter: smithyClient._json,
-    });
-};
-const se_CountOpenWorkflowExecutionsInput = (input, context) => {
-    return smithyClient.take(input, {
-        domain: [],
-        executionFilter: smithyClient._json,
-        startTimeFilter: (_) => se_ExecutionTimeFilter(_),
-        tagFilter: smithyClient._json,
-        typeFilter: smithyClient._json,
-    });
-};
-const se_ExecutionTimeFilter = (input, context) => {
-    return smithyClient.take(input, {
-        latestDate: (_) => _.getTime() / 1_000,
-        oldestDate: (_) => _.getTime() / 1_000,
-    });
-};
-const se_ListClosedWorkflowExecutionsInput = (input, context) => {
-    return smithyClient.take(input, {
-        closeStatusFilter: smithyClient._json,
-        closeTimeFilter: (_) => se_ExecutionTimeFilter(_),
-        domain: [],
-        executionFilter: smithyClient._json,
-        maximumPageSize: [],
-        nextPageToken: [],
-        reverseOrder: [],
-        startTimeFilter: (_) => se_ExecutionTimeFilter(_),
-        tagFilter: smithyClient._json,
-        typeFilter: smithyClient._json,
-    });
-};
-const se_ListOpenWorkflowExecutionsInput = (input, context) => {
-    return smithyClient.take(input, {
-        domain: [],
-        executionFilter: smithyClient._json,
-        maximumPageSize: [],
-        nextPageToken: [],
-        reverseOrder: [],
-        startTimeFilter: (_) => se_ExecutionTimeFilter(_),
-        tagFilter: smithyClient._json,
-        typeFilter: smithyClient._json,
-    });
-};
-const de_ActivityTypeDetail = (output, context) => {
-    return smithyClient.take(output, {
-        configuration: smithyClient._json,
-        typeInfo: (_) => de_ActivityTypeInfo(_),
-    });
-};
-const de_ActivityTypeInfo = (output, context) => {
-    return smithyClient.take(output, {
-        activityType: smithyClient._json,
-        creationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        deprecationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        description: smithyClient.expectString,
-        status: smithyClient.expectString,
-    });
-};
-const de_ActivityTypeInfoList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ActivityTypeInfo(entry);
-    });
-    return retVal;
-};
-const de_ActivityTypeInfos = (output, context) => {
-    return smithyClient.take(output, {
-        nextPageToken: smithyClient.expectString,
-        typeInfos: (_) => de_ActivityTypeInfoList(_),
-    });
-};
-const de_DecisionTask = (output, context) => {
-    return smithyClient.take(output, {
-        events: (_) => de_HistoryEventList(_),
-        nextPageToken: smithyClient.expectString,
-        previousStartedEventId: smithyClient.expectLong,
-        startedEventId: smithyClient.expectLong,
-        taskToken: smithyClient.expectString,
-        workflowExecution: smithyClient._json,
-        workflowType: smithyClient._json,
-    });
-};
-const de_History = (output, context) => {
-    return smithyClient.take(output, {
-        events: (_) => de_HistoryEventList(_),
-        nextPageToken: smithyClient.expectString,
-    });
-};
-const de_HistoryEvent = (output, context) => {
-    return smithyClient.take(output, {
-        activityTaskCancelRequestedEventAttributes: smithyClient._json,
-        activityTaskCanceledEventAttributes: smithyClient._json,
-        activityTaskCompletedEventAttributes: smithyClient._json,
-        activityTaskFailedEventAttributes: smithyClient._json,
-        activityTaskScheduledEventAttributes: smithyClient._json,
-        activityTaskStartedEventAttributes: smithyClient._json,
-        activityTaskTimedOutEventAttributes: smithyClient._json,
-        cancelTimerFailedEventAttributes: smithyClient._json,
-        cancelWorkflowExecutionFailedEventAttributes: smithyClient._json,
-        childWorkflowExecutionCanceledEventAttributes: smithyClient._json,
-        childWorkflowExecutionCompletedEventAttributes: smithyClient._json,
-        childWorkflowExecutionFailedEventAttributes: smithyClient._json,
-        childWorkflowExecutionStartedEventAttributes: smithyClient._json,
-        childWorkflowExecutionTerminatedEventAttributes: smithyClient._json,
-        childWorkflowExecutionTimedOutEventAttributes: smithyClient._json,
-        completeWorkflowExecutionFailedEventAttributes: smithyClient._json,
-        continueAsNewWorkflowExecutionFailedEventAttributes: smithyClient._json,
-        decisionTaskCompletedEventAttributes: smithyClient._json,
-        decisionTaskScheduledEventAttributes: smithyClient._json,
-        decisionTaskStartedEventAttributes: smithyClient._json,
-        decisionTaskTimedOutEventAttributes: smithyClient._json,
-        eventId: smithyClient.expectLong,
-        eventTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        eventType: smithyClient.expectString,
-        externalWorkflowExecutionCancelRequestedEventAttributes: smithyClient._json,
-        externalWorkflowExecutionSignaledEventAttributes: smithyClient._json,
-        failWorkflowExecutionFailedEventAttributes: smithyClient._json,
-        lambdaFunctionCompletedEventAttributes: smithyClient._json,
-        lambdaFunctionFailedEventAttributes: smithyClient._json,
-        lambdaFunctionScheduledEventAttributes: smithyClient._json,
-        lambdaFunctionStartedEventAttributes: smithyClient._json,
-        lambdaFunctionTimedOutEventAttributes: smithyClient._json,
-        markerRecordedEventAttributes: smithyClient._json,
-        recordMarkerFailedEventAttributes: smithyClient._json,
-        requestCancelActivityTaskFailedEventAttributes: smithyClient._json,
-        requestCancelExternalWorkflowExecutionFailedEventAttributes: smithyClient._json,
-        requestCancelExternalWorkflowExecutionInitiatedEventAttributes: smithyClient._json,
-        scheduleActivityTaskFailedEventAttributes: smithyClient._json,
-        scheduleLambdaFunctionFailedEventAttributes: smithyClient._json,
-        signalExternalWorkflowExecutionFailedEventAttributes: smithyClient._json,
-        signalExternalWorkflowExecutionInitiatedEventAttributes: smithyClient._json,
-        startChildWorkflowExecutionFailedEventAttributes: smithyClient._json,
-        startChildWorkflowExecutionInitiatedEventAttributes: smithyClient._json,
-        startLambdaFunctionFailedEventAttributes: smithyClient._json,
-        startTimerFailedEventAttributes: smithyClient._json,
-        timerCanceledEventAttributes: smithyClient._json,
-        timerFiredEventAttributes: smithyClient._json,
-        timerStartedEventAttributes: smithyClient._json,
-        workflowExecutionCancelRequestedEventAttributes: smithyClient._json,
-        workflowExecutionCanceledEventAttributes: smithyClient._json,
-        workflowExecutionCompletedEventAttributes: smithyClient._json,
-        workflowExecutionContinuedAsNewEventAttributes: smithyClient._json,
-        workflowExecutionFailedEventAttributes: smithyClient._json,
-        workflowExecutionSignaledEventAttributes: smithyClient._json,
-        workflowExecutionStartedEventAttributes: smithyClient._json,
-        workflowExecutionTerminatedEventAttributes: smithyClient._json,
-        workflowExecutionTimedOutEventAttributes: smithyClient._json,
-    });
-};
-const de_HistoryEventList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_HistoryEvent(entry);
-    });
-    return retVal;
-};
-const de_WorkflowExecutionDetail = (output, context) => {
-    return smithyClient.take(output, {
-        executionConfiguration: smithyClient._json,
-        executionInfo: (_) => de_WorkflowExecutionInfo(_),
-        latestActivityTaskTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        latestExecutionContext: smithyClient.expectString,
-        openCounts: smithyClient._json,
-    });
-};
-const de_WorkflowExecutionInfo = (output, context) => {
-    return smithyClient.take(output, {
-        cancelRequested: smithyClient.expectBoolean,
-        closeStatus: smithyClient.expectString,
-        closeTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        execution: smithyClient._json,
-        executionStatus: smithyClient.expectString,
-        parent: smithyClient._json,
-        startTimestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        tagList: smithyClient._json,
-        workflowType: smithyClient._json,
-    });
-};
-const de_WorkflowExecutionInfoList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_WorkflowExecutionInfo(entry);
-    });
-    return retVal;
-};
-const de_WorkflowExecutionInfos = (output, context) => {
-    return smithyClient.take(output, {
-        executionInfos: (_) => de_WorkflowExecutionInfoList(_),
-        nextPageToken: smithyClient.expectString,
-    });
-};
-const de_WorkflowTypeDetail = (output, context) => {
-    return smithyClient.take(output, {
-        configuration: smithyClient._json,
-        typeInfo: (_) => de_WorkflowTypeInfo(_),
-    });
-};
-const de_WorkflowTypeInfo = (output, context) => {
-    return smithyClient.take(output, {
-        creationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        deprecationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        description: smithyClient.expectString,
-        status: smithyClient.expectString,
-        workflowType: smithyClient._json,
-    });
-};
-const de_WorkflowTypeInfoList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_WorkflowTypeInfo(entry);
-    });
-    return retVal;
-};
-const de_WorkflowTypeInfos = (output, context) => {
-    return smithyClient.take(output, {
-        nextPageToken: smithyClient.expectString,
-        typeInfos: (_) => de_WorkflowTypeInfoList(_),
-    });
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
-const throwDefaultError = smithyClient.withBaseException(SWFServiceException);
-const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const contents = {
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-        headers,
-    };
-    if (body !== undefined) {
-        contents.body = body;
-    }
-    return new protocolHttp.HttpRequest(contents);
-};
-function sharedHeaders(operation) {
-    return {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": `SimpleWorkflowService.${operation}`,
-    };
-}
+
+const _AT = "ActivityTask";
+const _ATC = "ActivityTypeConfiguration";
+const _ATCEA = "ActivityTaskCanceledEventAttributes";
+const _ATCEAc = "ActivityTaskCompletedEventAttributes";
+const _ATCREA = "ActivityTaskCancelRequestedEventAttributes";
+const _ATD = "ActivityTypeDetail";
+const _ATFEA = "ActivityTaskFailedEventAttributes";
+const _ATI = "ActivityTypeInfo";
+const _ATIL = "ActivityTypeInfoList";
+const _ATIc = "ActivityTypeInfos";
+const _ATS = "ActivityTaskStatus";
+const _ATSEA = "ActivityTaskScheduledEventAttributes";
+const _ATSEAc = "ActivityTaskStartedEventAttributes";
+const _ATTOEA = "ActivityTaskTimedOutEventAttributes";
+const _ATc = "ActivityType";
+const _CANWEDA = "ContinueAsNewWorkflowExecutionDecisionAttributes";
+const _CANWEFEA = "ContinueAsNewWorkflowExecutionFailedEventAttributes";
+const _CCWE = "CountClosedWorkflowExecutions";
+const _CCWEI = "CountClosedWorkflowExecutionsInput";
+const _COWE = "CountOpenWorkflowExecutions";
+const _COWEI = "CountOpenWorkflowExecutionsInput";
+const _CPAT = "CountPendingActivityTasks";
+const _CPATI = "CountPendingActivityTasksInput";
+const _CPDT = "CountPendingDecisionTasks";
+const _CPDTI = "CountPendingDecisionTasksInput";
+const _CSF = "CloseStatusFilter";
+const _CTDA = "CancelTimerDecisionAttributes";
+const _CTFEA = "CancelTimerFailedEventAttributes";
+const _CWECEA = "ChildWorkflowExecutionCanceledEventAttributes";
+const _CWECEAh = "ChildWorkflowExecutionCompletedEventAttributes";
+const _CWEDA = "CancelWorkflowExecutionDecisionAttributes";
+const _CWEDAo = "CompleteWorkflowExecutionDecisionAttributes";
+const _CWEFEA = "CancelWorkflowExecutionFailedEventAttributes";
+const _CWEFEAh = "ChildWorkflowExecutionFailedEventAttributes";
+const _CWEFEAo = "CompleteWorkflowExecutionFailedEventAttributes";
+const _CWESEA = "ChildWorkflowExecutionStartedEventAttributes";
+const _CWETEA = "ChildWorkflowExecutionTerminatedEventAttributes";
+const _CWETOEA = "ChildWorkflowExecutionTimedOutEventAttributes";
+const _D = "Decision";
+const _DAEF = "DomainAlreadyExistsFault";
+const _DAT = "DeleteActivityType";
+const _DATI = "DeleteActivityTypeInput";
+const _DATIe = "DeprecateActivityTypeInput";
+const _DATIes = "DescribeActivityTypeInput";
+const _DATe = "DeprecateActivityType";
+const _DATes = "DescribeActivityType";
+const _DC = "DomainConfiguration";
+const _DD = "DomainDetail";
+const _DDF = "DomainDeprecatedFault";
+const _DDI = "DeprecateDomainInput";
+const _DDIe = "DescribeDomainInput";
+const _DDe = "DeprecateDomain";
+const _DDes = "DescribeDomain";
+const _DI = "DomainInfo";
+const _DIL = "DomainInfoList";
+const _DIo = "DomainInfos";
+const _DL = "DecisionList";
+const _DT = "DecisionTask";
+const _DTCEA = "DecisionTaskCompletedEventAttributes";
+const _DTSEA = "DecisionTaskScheduledEventAttributes";
+const _DTSEAe = "DecisionTaskStartedEventAttributes";
+const _DTTOEA = "DecisionTaskTimedOutEventAttributes";
+const _DUF = "DefaultUndefinedFault";
+const _DWE = "DescribeWorkflowExecution";
+const _DWEI = "DescribeWorkflowExecutionInput";
+const _DWT = "DeleteWorkflowType";
+const _DWTI = "DeleteWorkflowTypeInput";
+const _DWTIe = "DeprecateWorkflowTypeInput";
+const _DWTIes = "DescribeWorkflowTypeInput";
+const _DWTe = "DeprecateWorkflowType";
+const _DWTes = "DescribeWorkflowType";
+const _ETF = "ExecutionTimeFilter";
+const _EWECREA = "ExternalWorkflowExecutionCancelRequestedEventAttributes";
+const _EWESEA = "ExternalWorkflowExecutionSignaledEventAttributes";
+const _FWEDA = "FailWorkflowExecutionDecisionAttributes";
+const _FWEFEA = "FailWorkflowExecutionFailedEventAttributes";
+const _GWEH = "GetWorkflowExecutionHistory";
+const _GWEHI = "GetWorkflowExecutionHistoryInput";
+const _H = "History";
+const _HE = "HistoryEvent";
+const _HEL = "HistoryEventList";
+const _LAT = "ListActivityTypes";
+const _LATI = "ListActivityTypesInput";
+const _LCWE = "ListClosedWorkflowExecutions";
+const _LCWEI = "ListClosedWorkflowExecutionsInput";
+const _LD = "ListDomains";
+const _LDI = "ListDomainsInput";
+const _LEF = "LimitExceededFault";
+const _LFCEA = "LambdaFunctionCompletedEventAttributes";
+const _LFFEA = "LambdaFunctionFailedEventAttributes";
+const _LFSEA = "LambdaFunctionScheduledEventAttributes";
+const _LFSEAa = "LambdaFunctionStartedEventAttributes";
+const _LFTOEA = "LambdaFunctionTimedOutEventAttributes";
+const _LOWE = "ListOpenWorkflowExecutions";
+const _LOWEI = "ListOpenWorkflowExecutionsInput";
+const _LTFR = "ListTagsForResource";
+const _LTFRI = "ListTagsForResourceInput";
+const _LTFRO = "ListTagsForResourceOutput";
+const _LWT = "ListWorkflowTypes";
+const _LWTI = "ListWorkflowTypesInput";
+const _MREA = "MarkerRecordedEventAttributes";
+const _ONPF = "OperationNotPermittedFault";
+const _PFAT = "PollForActivityTask";
+const _PFATI = "PollForActivityTaskInput";
+const _PFDT = "PollForDecisionTask";
+const _PFDTI = "PollForDecisionTaskInput";
+const _PTC = "PendingTaskCount";
+const _R = "Run";
+const _RAT = "RegisterActivityType";
+const _RATC = "RespondActivityTaskCanceled";
+const _RATCI = "RespondActivityTaskCanceledInput";
+const _RATCIe = "RespondActivityTaskCompletedInput";
+const _RATCe = "RespondActivityTaskCompleted";
+const _RATF = "RespondActivityTaskFailed";
+const _RATFI = "RespondActivityTaskFailedInput";
+const _RATH = "RecordActivityTaskHeartbeat";
+const _RATHI = "RecordActivityTaskHeartbeatInput";
+const _RATI = "RegisterActivityTypeInput";
+const _RCATDA = "RequestCancelActivityTaskDecisionAttributes";
+const _RCATFEA = "RequestCancelActivityTaskFailedEventAttributes";
+const _RCEWEDA = "RequestCancelExternalWorkflowExecutionDecisionAttributes";
+const _RCEWEFEA = "RequestCancelExternalWorkflowExecutionFailedEventAttributes";
+const _RCEWEIEA = "RequestCancelExternalWorkflowExecutionInitiatedEventAttributes";
+const _RCWE = "RequestCancelWorkflowExecution";
+const _RCWEI = "RequestCancelWorkflowExecutionInput";
+const _RD = "RegisterDomain";
+const _RDI = "RegisterDomainInput";
+const _RDTC = "RespondDecisionTaskCompleted";
+const _RDTCI = "RespondDecisionTaskCompletedInput";
+const _RMDA = "RecordMarkerDecisionAttributes";
+const _RMFEA = "RecordMarkerFailedEventAttributes";
+const _RT = "ResourceTag";
+const _RTL = "ResourceTagList";
+const _RWT = "RegisterWorkflowType";
+const _RWTI = "RegisterWorkflowTypeInput";
+const _SATDA = "ScheduleActivityTaskDecisionAttributes";
+const _SATFEA = "ScheduleActivityTaskFailedEventAttributes";
+const _SCWEDA = "StartChildWorkflowExecutionDecisionAttributes";
+const _SCWEFEA = "StartChildWorkflowExecutionFailedEventAttributes";
+const _SCWEIEA = "StartChildWorkflowExecutionInitiatedEventAttributes";
+const _SEWEDA = "SignalExternalWorkflowExecutionDecisionAttributes";
+const _SEWEFEA = "SignalExternalWorkflowExecutionFailedEventAttributes";
+const _SEWEIEA = "SignalExternalWorkflowExecutionInitiatedEventAttributes";
+const _SLFDA = "ScheduleLambdaFunctionDecisionAttributes";
+const _SLFFEA = "ScheduleLambdaFunctionFailedEventAttributes";
+const _SLFFEAt = "StartLambdaFunctionFailedEventAttributes";
+const _STDA = "StartTimerDecisionAttributes";
+const _STFEA = "StartTimerFailedEventAttributes";
+const _SWE = "SignalWorkflowExecution";
+const _SWEI = "SignalWorkflowExecutionInput";
+const _SWEIt = "StartWorkflowExecutionInput";
+const _SWEt = "StartWorkflowExecution";
+const _TAEF = "TypeAlreadyExistsFault";
+const _TCEA = "TimerCanceledEventAttributes";
+const _TDF = "TypeDeprecatedFault";
+const _TF = "TagFilter";
+const _TFEA = "TimerFiredEventAttributes";
+const _TL = "TaskList";
+const _TMTF = "TooManyTagsFault";
+const _TNDF = "TypeNotDeprecatedFault";
+const _TR = "TagResource";
+const _TRI = "TagResourceInput";
+const _TSEA = "TimerStartedEventAttributes";
+const _TWE = "TerminateWorkflowExecution";
+const _TWEI = "TerminateWorkflowExecutionInput";
+const _UAT = "UndeprecateActivityType";
+const _UATI = "UndeprecateActivityTypeInput";
+const _UD = "UndeprecateDomain";
+const _UDI = "UndeprecateDomainInput";
+const _UR = "UntagResource";
+const _URF = "UnknownResourceFault";
+const _URI = "UntagResourceInput";
+const _UWT = "UndeprecateWorkflowType";
+const _UWTI = "UndeprecateWorkflowTypeInput";
+const _WE = "WorkflowExecution";
+const _WEASF = "WorkflowExecutionAlreadyStartedFault";
+const _WEC = "WorkflowExecutionConfiguration";
+const _WECANEA = "WorkflowExecutionContinuedAsNewEventAttributes";
+const _WECEA = "WorkflowExecutionCanceledEventAttributes";
+const _WECEAo = "WorkflowExecutionCompletedEventAttributes";
+const _WECREA = "WorkflowExecutionCancelRequestedEventAttributes";
+const _WECo = "WorkflowExecutionCount";
+const _WED = "WorkflowExecutionDetail";
+const _WEF = "WorkflowExecutionFilter";
+const _WEFEA = "WorkflowExecutionFailedEventAttributes";
+const _WEI = "WorkflowExecutionInfo";
+const _WEIL = "WorkflowExecutionInfoList";
+const _WEIo = "WorkflowExecutionInfos";
+const _WEOC = "WorkflowExecutionOpenCounts";
+const _WESEA = "WorkflowExecutionSignaledEventAttributes";
+const _WESEAo = "WorkflowExecutionStartedEventAttributes";
+const _WETEA = "WorkflowExecutionTerminatedEventAttributes";
+const _WETOEA = "WorkflowExecutionTimedOutEventAttributes";
+const _WT = "WorkflowType";
+const _WTC = "WorkflowTypeConfiguration";
+const _WTD = "WorkflowTypeDetail";
+const _WTF = "WorkflowTypeFilter";
+const _WTI = "WorkflowTypeInfo";
+const _WTIL = "WorkflowTypeInfoList";
+const _WTIo = "WorkflowTypeInfos";
+const _a = "arn";
+const _aI = "activityId";
+const _aT = "activityType";
+const _aTCEA = "activityTaskCompletedEventAttributes";
+const _aTCEAc = "activityTaskCanceledEventAttributes";
+const _aTCREA = "activityTaskCancelRequestedEventAttributes";
+const _aTFEA = "activityTaskFailedEventAttributes";
+const _aTSEA = "activityTaskScheduledEventAttributes";
+const _aTSEAc = "activityTaskStartedEventAttributes";
+const _aTTOEA = "activityTaskTimedOutEventAttributes";
+const _c = "control";
+const _cANWEDA = "continueAsNewWorkflowExecutionDecisionAttributes";
+const _cANWEFEA = "continueAsNewWorkflowExecutionFailedEventAttributes";
+const _cD = "creationDate";
+const _cERI = "continuedExecutionRunId";
+const _cP = "childPolicy";
+const _cR = "cancelRequested";
+const _cS = "closeStatus";
+const _cSF = "closeStatusFilter";
+const _cT = "closeTimestamp";
+const _cTDA = "cancelTimerDecisionAttributes";
+const _cTF = "closeTimeFilter";
+const _cTFEA = "cancelTimerFailedEventAttributes";
+const _cWECEA = "childWorkflowExecutionCompletedEventAttributes";
+const _cWECEAh = "childWorkflowExecutionCanceledEventAttributes";
+const _cWEDA = "completeWorkflowExecutionDecisionAttributes";
+const _cWEDAa = "cancelWorkflowExecutionDecisionAttributes";
+const _cWEFEA = "completeWorkflowExecutionFailedEventAttributes";
+const _cWEFEAa = "cancelWorkflowExecutionFailedEventAttributes";
+const _cWEFEAh = "childWorkflowExecutionFailedEventAttributes";
+const _cWESEA = "childWorkflowExecutionStartedEventAttributes";
+const _cWETEA = "childWorkflowExecutionTerminatedEventAttributes";
+const _cWETOEA = "childWorkflowExecutionTimedOutEventAttributes";
+const _ca = "cause";
+const _cl = "client";
+const _co = "configuration";
+const _cou = "count";
+const _d = "details";
+const _dCP = "defaultChildPolicy";
+const _dD = "deprecationDate";
+const _dESTCT = "defaultExecutionStartToCloseTimeout";
+const _dI = "domainInfo";
+const _dIo = "domainInfos";
+const _dLR = "defaultLambdaRole";
+const _dT = "decisionType";
+const _dTCEA = "decisionTaskCompletedEventAttributes";
+const _dTCEI = "decisionTaskCompletedEventId";
+const _dTHT = "defaultTaskHeartbeatTimeout";
+const _dTL = "defaultTaskList";
+const _dTP = "defaultTaskPriority";
+const _dTSEA = "decisionTaskScheduledEventAttributes";
+const _dTSEAe = "decisionTaskStartedEventAttributes";
+const _dTSTCT = "defaultTaskStartToCloseTimeout";
+const _dTSTCTe = "defaultTaskScheduleToCloseTimeout";
+const _dTSTST = "defaultTaskScheduleToStartTimeout";
+const _dTTOEA = "decisionTaskTimedOutEventAttributes";
+const _de = "description";
+const _dec = "decisions";
+const _do = "domain";
+const _e = "events";
+const _eC = "executionContext";
+const _eCx = "executionConfiguration";
+const _eF = "executionFilter";
+const _eI = "eventId";
+const _eIEI = "externalInitiatedEventId";
+const _eIx = "executionInfo";
+const _eIxe = "executionInfos";
+const _eS = "executionStatus";
+const _eSTCT = "executionStartToCloseTimeout";
+const _eT = "eventTimestamp";
+const _eTv = "eventType";
+const _eWE = "externalWorkflowExecution";
+const _eWECREA = "externalWorkflowExecutionCancelRequestedEventAttributes";
+const _eWESEA = "externalWorkflowExecutionSignaledEventAttributes";
+const _er = "error";
+const _ex = "execution";
+const _fWEDA = "failWorkflowExecutionDecisionAttributes";
+const _fWEFEA = "failWorkflowExecutionFailedEventAttributes";
+const _hE = "httpError";
+const _hT = "heartbeatTimeout";
+const _i = "input";
+const _iEI = "initiatedEventId";
+const _id = "identity";
+const _id_ = "id";
+const _k = "key";
+const _lATT = "latestActivityTaskTimestamp";
+const _lCREI = "latestCancelRequestedEventId";
+const _lD = "latestDate";
+const _lEC = "latestExecutionContext";
+const _lFCEA = "lambdaFunctionCompletedEventAttributes";
+const _lFFEA = "lambdaFunctionFailedEventAttributes";
+const _lFSEA = "lambdaFunctionScheduledEventAttributes";
+const _lFSEAa = "lambdaFunctionStartedEventAttributes";
+const _lFTOEA = "lambdaFunctionTimedOutEventAttributes";
+const _lR = "lambdaRole";
+const _m = "message";
+const _mN = "markerName";
+const _mPS = "maximumPageSize";
+const _mREA = "markerRecordedEventAttributes";
+const _n = "name";
+const _nERI = "newExecutionRunId";
+const _nPT = "nextPageToken";
+const _oAT = "openActivityTasks";
+const _oC = "openCounts";
+const _oCWE = "openChildWorkflowExecutions";
+const _oD = "oldestDate";
+const _oDT = "openDecisionTasks";
+const _oLF = "openLambdaFunctions";
+const _oT = "openTimers";
+const _p = "parent";
+const _pIEI = "parentInitiatedEventId";
+const _pSEI = "previousStartedEventId";
+const _pWE = "parentWorkflowExecution";
+const _r = "result";
+const _rA = "resourceArn";
+const _rCATDA = "requestCancelActivityTaskDecisionAttributes";
+const _rCATFEA = "requestCancelActivityTaskFailedEventAttributes";
+const _rCEWEDA = "requestCancelExternalWorkflowExecutionDecisionAttributes";
+const _rCEWEFEA = "requestCancelExternalWorkflowExecutionFailedEventAttributes";
+const _rCEWEIEA = "requestCancelExternalWorkflowExecutionInitiatedEventAttributes";
+const _rI = "runId";
+const _rMDA = "recordMarkerDecisionAttributes";
+const _rMFEA = "recordMarkerFailedEventAttributes";
+const _rO = "reverseOrder";
+const _rS = "registrationStatus";
+const _re = "reason";
+const _s = "status";
+const _sAPSE = "startAtPreviousStartedEvent";
+const _sATDA = "scheduleActivityTaskDecisionAttributes";
+const _sATFEA = "scheduleActivityTaskFailedEventAttributes";
+const _sCWEDA = "startChildWorkflowExecutionDecisionAttributes";
+const _sCWEFEA = "startChildWorkflowExecutionFailedEventAttributes";
+const _sCWEIEA = "startChildWorkflowExecutionInitiatedEventAttributes";
+const _sEI = "startedEventId";
+const _sEIc = "scheduledEventId";
+const _sEWEDA = "signalExternalWorkflowExecutionDecisionAttributes";
+const _sEWEFEA = "signalExternalWorkflowExecutionFailedEventAttributes";
+const _sEWEIEA = "signalExternalWorkflowExecutionInitiatedEventAttributes";
+const _sLFDA = "scheduleLambdaFunctionDecisionAttributes";
+const _sLFFEA = "scheduleLambdaFunctionFailedEventAttributes";
+const _sLFFEAt = "startLambdaFunctionFailedEventAttributes";
+const _sN = "signalName";
+const _sT = "startTimestamp";
+const _sTCT = "scheduleToCloseTimeout";
+const _sTCTt = "startToCloseTimeout";
+const _sTDA = "startTimerDecisionAttributes";
+const _sTF = "startTimeFilter";
+const _sTFEA = "startTimerFailedEventAttributes";
+const _sTFT = "startToFireTimeout";
+const _sTST = "scheduleToStartTimeout";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.swf";
+const _t = "tags";
+const _tCEA = "timerCanceledEventAttributes";
+const _tF = "typeFilter";
+const _tFEA = "timerFiredEventAttributes";
+const _tFa = "tagFilter";
+const _tI = "typeInfo";
+const _tIi = "timerId";
+const _tIy = "typeInfos";
+const _tK = "tagKeys";
+const _tL = "taskList";
+const _tLSTST = "taskListScheduleToStartTimeout";
+const _tLa = "tagList";
+const _tP = "taskPriority";
+const _tSEA = "timerStartedEventAttributes";
+const _tSTCT = "taskStartToCloseTimeout";
+const _tT = "taskToken";
+const _tTi = "timeoutType";
+const _ta = "tag";
+const _tr = "truncated";
+const _v = "version";
+const _va = "value";
+const _wE = "workflowExecution";
+const _wECANEA = "workflowExecutionContinuedAsNewEventAttributes";
+const _wECEA = "workflowExecutionCompletedEventAttributes";
+const _wECEAo = "workflowExecutionCanceledEventAttributes";
+const _wECREA = "workflowExecutionCancelRequestedEventAttributes";
+const _wEFEA = "workflowExecutionFailedEventAttributes";
+const _wERPID = "workflowExecutionRetentionPeriodInDays";
+const _wESEA = "workflowExecutionStartedEventAttributes";
+const _wESEAo = "workflowExecutionSignaledEventAttributes";
+const _wETEA = "workflowExecutionTerminatedEventAttributes";
+const _wETOEA = "workflowExecutionTimedOutEventAttributes";
+const _wI = "workflowId";
+const _wT = "workflowType";
+const _wTV = "workflowTypeVersion";
+const n0 = "com.amazonaws.swf";
+var ActivityTask = [
+    3,
+    n0,
+    _AT,
+    0,
+    [_tT, _aI, _sEI, _wE, _aT, _i],
+    [0, 0, 1, () => WorkflowExecution, () => ActivityType, 0],
+];
+var ActivityTaskCanceledEventAttributes = [
+    3,
+    n0,
+    _ATCEA,
+    0,
+    [_d, _sEIc, _sEI, _lCREI],
+    [0, 1, 1, 1],
+];
+var ActivityTaskCancelRequestedEventAttributes = [
+    3,
+    n0,
+    _ATCREA,
+    0,
+    [_dTCEI, _aI],
+    [1, 0],
+];
+var ActivityTaskCompletedEventAttributes = [
+    3,
+    n0,
+    _ATCEAc,
+    0,
+    [_r, _sEIc, _sEI],
+    [0, 1, 1],
+];
+var ActivityTaskFailedEventAttributes = [
+    3,
+    n0,
+    _ATFEA,
+    0,
+    [_re, _d, _sEIc, _sEI],
+    [0, 0, 1, 1],
+];
+var ActivityTaskScheduledEventAttributes = [
+    3,
+    n0,
+    _ATSEA,
+    0,
+    [_aT, _aI, _i, _c, _sTST, _sTCT, _sTCTt, _tL, _tP, _dTCEI, _hT],
+    [() => ActivityType, 0, 0, 0, 0, 0, 0, () => TaskList, 0, 1, 0],
+];
+var ActivityTaskStartedEventAttributes = [3, n0, _ATSEAc, 0, [_id, _sEIc], [0, 1]];
+var ActivityTaskStatus = [3, n0, _ATS, 0, [_cR], [2]];
+var ActivityTaskTimedOutEventAttributes = [
+    3,
+    n0,
+    _ATTOEA,
+    0,
+    [_tTi, _sEIc, _sEI, _d],
+    [0, 1, 1, 0],
+];
+var ActivityType = [3, n0, _ATc, 0, [_n, _v], [0, 0]];
+var ActivityTypeConfiguration = [
+    3,
+    n0,
+    _ATC,
+    0,
+    [_dTSTCT, _dTHT, _dTL, _dTP, _dTSTST, _dTSTCTe],
+    [0, 0, () => TaskList, 0, 0, 0],
+];
+var ActivityTypeDetail = [
+    3,
+    n0,
+    _ATD,
+    0,
+    [_tI, _co],
+    [() => ActivityTypeInfo, () => ActivityTypeConfiguration],
+];
+var ActivityTypeInfo = [
+    3,
+    n0,
+    _ATI,
+    0,
+    [_aT, _s, _de, _cD, _dD],
+    [() => ActivityType, 0, 0, 4, 4],
+];
+var ActivityTypeInfos = [3, n0, _ATIc, 0, [_tIy, _nPT], [() => ActivityTypeInfoList, 0]];
+var CancelTimerDecisionAttributes = [3, n0, _CTDA, 0, [_tIi], [0]];
+var CancelTimerFailedEventAttributes = [3, n0, _CTFEA, 0, [_tIi, _ca, _dTCEI], [0, 0, 1]];
+var CancelWorkflowExecutionDecisionAttributes = [3, n0, _CWEDA, 0, [_d], [0]];
+var CancelWorkflowExecutionFailedEventAttributes = [
+    3,
+    n0,
+    _CWEFEA,
+    0,
+    [_ca, _dTCEI],
+    [0, 1],
+];
+var ChildWorkflowExecutionCanceledEventAttributes = [
+    3,
+    n0,
+    _CWECEA,
+    0,
+    [_wE, _wT, _d, _iEI, _sEI],
+    [() => WorkflowExecution, () => WorkflowType, 0, 1, 1],
+];
+var ChildWorkflowExecutionCompletedEventAttributes = [
+    3,
+    n0,
+    _CWECEAh,
+    0,
+    [_wE, _wT, _r, _iEI, _sEI],
+    [() => WorkflowExecution, () => WorkflowType, 0, 1, 1],
+];
+var ChildWorkflowExecutionFailedEventAttributes = [
+    3,
+    n0,
+    _CWEFEAh,
+    0,
+    [_wE, _wT, _re, _d, _iEI, _sEI],
+    [() => WorkflowExecution, () => WorkflowType, 0, 0, 1, 1],
+];
+var ChildWorkflowExecutionStartedEventAttributes = [
+    3,
+    n0,
+    _CWESEA,
+    0,
+    [_wE, _wT, _iEI],
+    [() => WorkflowExecution, () => WorkflowType, 1],
+];
+var ChildWorkflowExecutionTerminatedEventAttributes = [
+    3,
+    n0,
+    _CWETEA,
+    0,
+    [_wE, _wT, _iEI, _sEI],
+    [() => WorkflowExecution, () => WorkflowType, 1, 1],
+];
+var ChildWorkflowExecutionTimedOutEventAttributes = [
+    3,
+    n0,
+    _CWETOEA,
+    0,
+    [_wE, _wT, _tTi, _iEI, _sEI],
+    [() => WorkflowExecution, () => WorkflowType, 0, 1, 1],
+];
+var CloseStatusFilter = [3, n0, _CSF, 0, [_s], [0]];
+var CompleteWorkflowExecutionDecisionAttributes = [3, n0, _CWEDAo, 0, [_r], [0]];
+var CompleteWorkflowExecutionFailedEventAttributes = [
+    3,
+    n0,
+    _CWEFEAo,
+    0,
+    [_ca, _dTCEI],
+    [0, 1],
+];
+var ContinueAsNewWorkflowExecutionDecisionAttributes = [
+    3,
+    n0,
+    _CANWEDA,
+    0,
+    [_i, _eSTCT, _tL, _tP, _tSTCT, _cP, _tLa, _wTV, _lR],
+    [0, 0, () => TaskList, 0, 0, 0, 64 | 0, 0, 0],
+];
+var ContinueAsNewWorkflowExecutionFailedEventAttributes = [
+    3,
+    n0,
+    _CANWEFEA,
+    0,
+    [_ca, _dTCEI],
+    [0, 1],
+];
+var CountClosedWorkflowExecutionsInput = [
+    3,
+    n0,
+    _CCWEI,
+    0,
+    [_do, _sTF, _cTF, _eF, _tF, _tFa, _cSF],
+    [
+        0,
+        () => ExecutionTimeFilter,
+        () => ExecutionTimeFilter,
+        () => WorkflowExecutionFilter,
+        () => WorkflowTypeFilter,
+        () => TagFilter,
+        () => CloseStatusFilter,
+    ],
+];
+var CountOpenWorkflowExecutionsInput = [
+    3,
+    n0,
+    _COWEI,
+    0,
+    [_do, _sTF, _tF, _tFa, _eF],
+    [0, () => ExecutionTimeFilter, () => WorkflowTypeFilter, () => TagFilter, () => WorkflowExecutionFilter],
+];
+var CountPendingActivityTasksInput = [3, n0, _CPATI, 0, [_do, _tL], [0, () => TaskList]];
+var CountPendingDecisionTasksInput = [3, n0, _CPDTI, 0, [_do, _tL], [0, () => TaskList]];
+var Decision = [
+    3,
+    n0,
+    _D,
+    0,
+    [_dT, _sATDA, _rCATDA, _cWEDA, _fWEDA, _cWEDAa, _cANWEDA, _rMDA, _sTDA, _cTDA, _sEWEDA, _rCEWEDA, _sCWEDA, _sLFDA],
+    [
+        0,
+        () => ScheduleActivityTaskDecisionAttributes,
+        () => RequestCancelActivityTaskDecisionAttributes,
+        () => CompleteWorkflowExecutionDecisionAttributes,
+        () => FailWorkflowExecutionDecisionAttributes,
+        () => CancelWorkflowExecutionDecisionAttributes,
+        () => ContinueAsNewWorkflowExecutionDecisionAttributes,
+        () => RecordMarkerDecisionAttributes,
+        () => StartTimerDecisionAttributes,
+        () => CancelTimerDecisionAttributes,
+        () => SignalExternalWorkflowExecutionDecisionAttributes,
+        () => RequestCancelExternalWorkflowExecutionDecisionAttributes,
+        () => StartChildWorkflowExecutionDecisionAttributes,
+        () => ScheduleLambdaFunctionDecisionAttributes,
+    ],
+];
+var DecisionTask = [
+    3,
+    n0,
+    _DT,
+    0,
+    [_tT, _sEI, _wE, _wT, _e, _nPT, _pSEI],
+    [0, 1, () => WorkflowExecution, () => WorkflowType, () => HistoryEventList, 0, 1],
+];
+var DecisionTaskCompletedEventAttributes = [
+    3,
+    n0,
+    _DTCEA,
+    0,
+    [_eC, _sEIc, _sEI, _tL, _tLSTST],
+    [0, 1, 1, () => TaskList, 0],
+];
+var DecisionTaskScheduledEventAttributes = [
+    3,
+    n0,
+    _DTSEA,
+    0,
+    [_tL, _tP, _sTCTt, _sTST],
+    [() => TaskList, 0, 0, 0],
+];
+var DecisionTaskStartedEventAttributes = [3, n0, _DTSEAe, 0, [_id, _sEIc], [0, 1]];
+var DecisionTaskTimedOutEventAttributes = [
+    3,
+    n0,
+    _DTTOEA,
+    0,
+    [_tTi, _sEIc, _sEI],
+    [0, 1, 1],
+];
+var DefaultUndefinedFault = [
+    -3,
+    n0,
+    _DUF,
+    {
+        [_er]: _cl,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(DefaultUndefinedFault, DefaultUndefinedFault$1);
+var DeleteActivityTypeInput = [3, n0, _DATI, 0, [_do, _aT], [0, () => ActivityType]];
+var DeleteWorkflowTypeInput = [3, n0, _DWTI, 0, [_do, _wT], [0, () => WorkflowType]];
+var DeprecateActivityTypeInput = [3, n0, _DATIe, 0, [_do, _aT], [0, () => ActivityType]];
+var DeprecateDomainInput = [3, n0, _DDI, 0, [_n], [0]];
+var DeprecateWorkflowTypeInput = [3, n0, _DWTIe, 0, [_do, _wT], [0, () => WorkflowType]];
+var DescribeActivityTypeInput = [3, n0, _DATIes, 0, [_do, _aT], [0, () => ActivityType]];
+var DescribeDomainInput = [3, n0, _DDIe, 0, [_n], [0]];
+var DescribeWorkflowExecutionInput = [
+    3,
+    n0,
+    _DWEI,
+    0,
+    [_do, _ex],
+    [0, () => WorkflowExecution],
+];
+var DescribeWorkflowTypeInput = [3, n0, _DWTIes, 0, [_do, _wT], [0, () => WorkflowType]];
+var DomainAlreadyExistsFault = [
+    -3,
+    n0,
+    _DAEF,
+    {
+        [_er]: _cl,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(DomainAlreadyExistsFault, DomainAlreadyExistsFault$1);
+var DomainConfiguration = [3, n0, _DC, 0, [_wERPID], [0]];
+var DomainDeprecatedFault = [
+    -3,
+    n0,
+    _DDF,
+    {
+        [_er]: _cl,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(DomainDeprecatedFault, DomainDeprecatedFault$1);
+var DomainDetail = [
+    3,
+    n0,
+    _DD,
+    0,
+    [_dI, _co],
+    [() => DomainInfo, () => DomainConfiguration],
+];
+var DomainInfo = [3, n0, _DI, 0, [_n, _s, _de, _a], [0, 0, 0, 0]];
+var DomainInfos = [3, n0, _DIo, 0, [_dIo, _nPT], [() => DomainInfoList, 0]];
+var ExecutionTimeFilter = [3, n0, _ETF, 0, [_oD, _lD], [4, 4]];
+var ExternalWorkflowExecutionCancelRequestedEventAttributes = [
+    3,
+    n0,
+    _EWECREA,
+    0,
+    [_wE, _iEI],
+    [() => WorkflowExecution, 1],
+];
+var ExternalWorkflowExecutionSignaledEventAttributes = [
+    3,
+    n0,
+    _EWESEA,
+    0,
+    [_wE, _iEI],
+    [() => WorkflowExecution, 1],
+];
+var FailWorkflowExecutionDecisionAttributes = [3, n0, _FWEDA, 0, [_re, _d], [0, 0]];
+var FailWorkflowExecutionFailedEventAttributes = [
+    3,
+    n0,
+    _FWEFEA,
+    0,
+    [_ca, _dTCEI],
+    [0, 1],
+];
+var GetWorkflowExecutionHistoryInput = [
+    3,
+    n0,
+    _GWEHI,
+    0,
+    [_do, _ex, _nPT, _mPS, _rO],
+    [0, () => WorkflowExecution, 0, 1, 2],
+];
+var History = [3, n0, _H, 0, [_e, _nPT], [() => HistoryEventList, 0]];
+var HistoryEvent = [
+    3,
+    n0,
+    _HE,
+    0,
+    [
+        _eT,
+        _eTv,
+        _eI,
+        _wESEA,
+        _wECEA,
+        _cWEFEA,
+        _wEFEA,
+        _fWEFEA,
+        _wETOEA,
+        _wECEAo,
+        _cWEFEAa,
+        _wECANEA,
+        _cANWEFEA,
+        _wETEA,
+        _wECREA,
+        _dTSEA,
+        _dTSEAe,
+        _dTCEA,
+        _dTTOEA,
+        _aTSEA,
+        _aTSEAc,
+        _aTCEA,
+        _aTFEA,
+        _aTTOEA,
+        _aTCEAc,
+        _aTCREA,
+        _wESEAo,
+        _mREA,
+        _rMFEA,
+        _tSEA,
+        _tFEA,
+        _tCEA,
+        _sCWEIEA,
+        _cWESEA,
+        _cWECEA,
+        _cWEFEAh,
+        _cWETOEA,
+        _cWECEAh,
+        _cWETEA,
+        _sEWEIEA,
+        _eWESEA,
+        _sEWEFEA,
+        _eWECREA,
+        _rCEWEIEA,
+        _rCEWEFEA,
+        _sATFEA,
+        _rCATFEA,
+        _sTFEA,
+        _cTFEA,
+        _sCWEFEA,
+        _lFSEA,
+        _lFSEAa,
+        _lFCEA,
+        _lFFEA,
+        _lFTOEA,
+        _sLFFEA,
+        _sLFFEAt,
+    ],
+    [
+        4,
+        0,
+        1,
+        () => WorkflowExecutionStartedEventAttributes,
+        () => WorkflowExecutionCompletedEventAttributes,
+        () => CompleteWorkflowExecutionFailedEventAttributes,
+        () => WorkflowExecutionFailedEventAttributes,
+        () => FailWorkflowExecutionFailedEventAttributes,
+        () => WorkflowExecutionTimedOutEventAttributes,
+        () => WorkflowExecutionCanceledEventAttributes,
+        () => CancelWorkflowExecutionFailedEventAttributes,
+        () => WorkflowExecutionContinuedAsNewEventAttributes,
+        () => ContinueAsNewWorkflowExecutionFailedEventAttributes,
+        () => WorkflowExecutionTerminatedEventAttributes,
+        () => WorkflowExecutionCancelRequestedEventAttributes,
+        () => DecisionTaskScheduledEventAttributes,
+        () => DecisionTaskStartedEventAttributes,
+        () => DecisionTaskCompletedEventAttributes,
+        () => DecisionTaskTimedOutEventAttributes,
+        () => ActivityTaskScheduledEventAttributes,
+        () => ActivityTaskStartedEventAttributes,
+        () => ActivityTaskCompletedEventAttributes,
+        () => ActivityTaskFailedEventAttributes,
+        () => ActivityTaskTimedOutEventAttributes,
+        () => ActivityTaskCanceledEventAttributes,
+        () => ActivityTaskCancelRequestedEventAttributes,
+        () => WorkflowExecutionSignaledEventAttributes,
+        () => MarkerRecordedEventAttributes,
+        () => RecordMarkerFailedEventAttributes,
+        () => TimerStartedEventAttributes,
+        () => TimerFiredEventAttributes,
+        () => TimerCanceledEventAttributes,
+        () => StartChildWorkflowExecutionInitiatedEventAttributes,
+        () => ChildWorkflowExecutionStartedEventAttributes,
+        () => ChildWorkflowExecutionCompletedEventAttributes,
+        () => ChildWorkflowExecutionFailedEventAttributes,
+        () => ChildWorkflowExecutionTimedOutEventAttributes,
+        () => ChildWorkflowExecutionCanceledEventAttributes,
+        () => ChildWorkflowExecutionTerminatedEventAttributes,
+        () => SignalExternalWorkflowExecutionInitiatedEventAttributes,
+        () => ExternalWorkflowExecutionSignaledEventAttributes,
+        () => SignalExternalWorkflowExecutionFailedEventAttributes,
+        () => ExternalWorkflowExecutionCancelRequestedEventAttributes,
+        () => RequestCancelExternalWorkflowExecutionInitiatedEventAttributes,
+        () => RequestCancelExternalWorkflowExecutionFailedEventAttributes,
+        () => ScheduleActivityTaskFailedEventAttributes,
+        () => RequestCancelActivityTaskFailedEventAttributes,
+        () => StartTimerFailedEventAttributes,
+        () => CancelTimerFailedEventAttributes,
+        () => StartChildWorkflowExecutionFailedEventAttributes,
+        () => LambdaFunctionScheduledEventAttributes,
+        () => LambdaFunctionStartedEventAttributes,
+        () => LambdaFunctionCompletedEventAttributes,
+        () => LambdaFunctionFailedEventAttributes,
+        () => LambdaFunctionTimedOutEventAttributes,
+        () => ScheduleLambdaFunctionFailedEventAttributes,
+        () => StartLambdaFunctionFailedEventAttributes,
+    ],
+];
+var LambdaFunctionCompletedEventAttributes = [
+    3,
+    n0,
+    _LFCEA,
+    0,
+    [_sEIc, _sEI, _r],
+    [1, 1, 0],
+];
+var LambdaFunctionFailedEventAttributes = [
+    3,
+    n0,
+    _LFFEA,
+    0,
+    [_sEIc, _sEI, _re, _d],
+    [1, 1, 0, 0],
+];
+var LambdaFunctionScheduledEventAttributes = [
+    3,
+    n0,
+    _LFSEA,
+    0,
+    [_id_, _n, _c, _i, _sTCTt, _dTCEI],
+    [0, 0, 0, 0, 0, 1],
+];
+var LambdaFunctionStartedEventAttributes = [3, n0, _LFSEAa, 0, [_sEIc], [1]];
+var LambdaFunctionTimedOutEventAttributes = [
+    3,
+    n0,
+    _LFTOEA,
+    0,
+    [_sEIc, _sEI, _tTi],
+    [1, 1, 0],
+];
+var LimitExceededFault = [
+    -3,
+    n0,
+    _LEF,
+    {
+        [_er]: _cl,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LimitExceededFault, LimitExceededFault$1);
+var ListActivityTypesInput = [
+    3,
+    n0,
+    _LATI,
+    0,
+    [_do, _n, _rS, _nPT, _mPS, _rO],
+    [0, 0, 0, 0, 1, 2],
+];
+var ListClosedWorkflowExecutionsInput = [
+    3,
+    n0,
+    _LCWEI,
+    0,
+    [_do, _sTF, _cTF, _eF, _cSF, _tF, _tFa, _nPT, _mPS, _rO],
+    [
+        0,
+        () => ExecutionTimeFilter,
+        () => ExecutionTimeFilter,
+        () => WorkflowExecutionFilter,
+        () => CloseStatusFilter,
+        () => WorkflowTypeFilter,
+        () => TagFilter,
+        0,
+        1,
+        2,
+    ],
+];
+var ListDomainsInput = [3, n0, _LDI, 0, [_nPT, _rS, _mPS, _rO], [0, 0, 1, 2]];
+var ListOpenWorkflowExecutionsInput = [
+    3,
+    n0,
+    _LOWEI,
+    0,
+    [_do, _sTF, _tF, _tFa, _nPT, _mPS, _rO, _eF],
+    [0, () => ExecutionTimeFilter, () => WorkflowTypeFilter, () => TagFilter, 0, 1, 2, () => WorkflowExecutionFilter],
+];
+var ListTagsForResourceInput = [3, n0, _LTFRI, 0, [_rA], [0]];
+var ListTagsForResourceOutput = [3, n0, _LTFRO, 0, [_t], [() => ResourceTagList]];
+var ListWorkflowTypesInput = [
+    3,
+    n0,
+    _LWTI,
+    0,
+    [_do, _n, _rS, _nPT, _mPS, _rO],
+    [0, 0, 0, 0, 1, 2],
+];
+var MarkerRecordedEventAttributes = [3, n0, _MREA, 0, [_mN, _d, _dTCEI], [0, 0, 1]];
+var OperationNotPermittedFault = [
+    -3,
+    n0,
+    _ONPF,
+    {
+        [_er]: _cl,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(OperationNotPermittedFault, OperationNotPermittedFault$1);
+var PendingTaskCount = [3, n0, _PTC, 0, [_cou, _tr], [1, 2]];
+var PollForActivityTaskInput = [
+    3,
+    n0,
+    _PFATI,
+    0,
+    [_do, _tL, _id],
+    [0, () => TaskList, 0],
+];
+var PollForDecisionTaskInput = [
+    3,
+    n0,
+    _PFDTI,
+    0,
+    [_do, _tL, _id, _nPT, _mPS, _rO, _sAPSE],
+    [0, () => TaskList, 0, 0, 1, 2, 2],
+];
+var RecordActivityTaskHeartbeatInput = [3, n0, _RATHI, 0, [_tT, _d], [0, 0]];
+var RecordMarkerDecisionAttributes = [3, n0, _RMDA, 0, [_mN, _d], [0, 0]];
+var RecordMarkerFailedEventAttributes = [3, n0, _RMFEA, 0, [_mN, _ca, _dTCEI], [0, 0, 1]];
+var RegisterActivityTypeInput = [
+    3,
+    n0,
+    _RATI,
+    0,
+    [_do, _n, _v, _de, _dTSTCT, _dTHT, _dTL, _dTP, _dTSTST, _dTSTCTe],
+    [0, 0, 0, 0, 0, 0, () => TaskList, 0, 0, 0],
+];
+var RegisterDomainInput = [
+    3,
+    n0,
+    _RDI,
+    0,
+    [_n, _de, _wERPID, _t],
+    [0, 0, 0, () => ResourceTagList],
+];
+var RegisterWorkflowTypeInput = [
+    3,
+    n0,
+    _RWTI,
+    0,
+    [_do, _n, _v, _de, _dTSTCT, _dESTCT, _dTL, _dTP, _dCP, _dLR],
+    [0, 0, 0, 0, 0, 0, () => TaskList, 0, 0, 0],
+];
+var RequestCancelActivityTaskDecisionAttributes = [3, n0, _RCATDA, 0, [_aI], [0]];
+var RequestCancelActivityTaskFailedEventAttributes = [
+    3,
+    n0,
+    _RCATFEA,
+    0,
+    [_aI, _ca, _dTCEI],
+    [0, 0, 1],
+];
+var RequestCancelExternalWorkflowExecutionDecisionAttributes = [
+    3,
+    n0,
+    _RCEWEDA,
+    0,
+    [_wI, _rI, _c],
+    [0, 0, 0],
+];
+var RequestCancelExternalWorkflowExecutionFailedEventAttributes = [
+    3,
+    n0,
+    _RCEWEFEA,
+    0,
+    [_wI, _rI, _ca, _iEI, _dTCEI, _c],
+    [0, 0, 0, 1, 1, 0],
+];
+var RequestCancelExternalWorkflowExecutionInitiatedEventAttributes = [
+    3,
+    n0,
+    _RCEWEIEA,
+    0,
+    [_wI, _rI, _dTCEI, _c],
+    [0, 0, 1, 0],
+];
+var RequestCancelWorkflowExecutionInput = [3, n0, _RCWEI, 0, [_do, _wI, _rI], [0, 0, 0]];
+var ResourceTag = [3, n0, _RT, 0, [_k, _va], [0, 0]];
+var RespondActivityTaskCanceledInput = [3, n0, _RATCI, 0, [_tT, _d], [0, 0]];
+var RespondActivityTaskCompletedInput = [3, n0, _RATCIe, 0, [_tT, _r], [0, 0]];
+var RespondActivityTaskFailedInput = [3, n0, _RATFI, 0, [_tT, _re, _d], [0, 0, 0]];
+var RespondDecisionTaskCompletedInput = [
+    3,
+    n0,
+    _RDTCI,
+    0,
+    [_tT, _dec, _eC, _tL, _tLSTST],
+    [0, () => DecisionList, 0, () => TaskList, 0],
+];
+var Run = [3, n0, _R, 0, [_rI], [0]];
+var ScheduleActivityTaskDecisionAttributes = [
+    3,
+    n0,
+    _SATDA,
+    0,
+    [_aT, _aI, _c, _i, _sTCT, _tL, _tP, _sTST, _sTCTt, _hT],
+    [() => ActivityType, 0, 0, 0, 0, () => TaskList, 0, 0, 0, 0],
+];
+var ScheduleActivityTaskFailedEventAttributes = [
+    3,
+    n0,
+    _SATFEA,
+    0,
+    [_aT, _aI, _ca, _dTCEI],
+    [() => ActivityType, 0, 0, 1],
+];
+var ScheduleLambdaFunctionDecisionAttributes = [
+    3,
+    n0,
+    _SLFDA,
+    0,
+    [_id_, _n, _c, _i, _sTCTt],
+    [0, 0, 0, 0, 0],
+];
+var ScheduleLambdaFunctionFailedEventAttributes = [
+    3,
+    n0,
+    _SLFFEA,
+    0,
+    [_id_, _n, _ca, _dTCEI],
+    [0, 0, 0, 1],
+];
+var SignalExternalWorkflowExecutionDecisionAttributes = [
+    3,
+    n0,
+    _SEWEDA,
+    0,
+    [_wI, _rI, _sN, _i, _c],
+    [0, 0, 0, 0, 0],
+];
+var SignalExternalWorkflowExecutionFailedEventAttributes = [
+    3,
+    n0,
+    _SEWEFEA,
+    0,
+    [_wI, _rI, _ca, _iEI, _dTCEI, _c],
+    [0, 0, 0, 1, 1, 0],
+];
+var SignalExternalWorkflowExecutionInitiatedEventAttributes = [
+    3,
+    n0,
+    _SEWEIEA,
+    0,
+    [_wI, _rI, _sN, _i, _dTCEI, _c],
+    [0, 0, 0, 0, 1, 0],
+];
+var SignalWorkflowExecutionInput = [
+    3,
+    n0,
+    _SWEI,
+    0,
+    [_do, _wI, _rI, _sN, _i],
+    [0, 0, 0, 0, 0],
+];
+var StartChildWorkflowExecutionDecisionAttributes = [
+    3,
+    n0,
+    _SCWEDA,
+    0,
+    [_wT, _wI, _c, _i, _eSTCT, _tL, _tP, _tSTCT, _cP, _tLa, _lR],
+    [() => WorkflowType, 0, 0, 0, 0, () => TaskList, 0, 0, 0, 64 | 0, 0],
+];
+var StartChildWorkflowExecutionFailedEventAttributes = [
+    3,
+    n0,
+    _SCWEFEA,
+    0,
+    [_wT, _ca, _wI, _iEI, _dTCEI, _c],
+    [() => WorkflowType, 0, 0, 1, 1, 0],
+];
+var StartChildWorkflowExecutionInitiatedEventAttributes = [
+    3,
+    n0,
+    _SCWEIEA,
+    0,
+    [_wI, _wT, _c, _i, _eSTCT, _tL, _tP, _dTCEI, _cP, _tSTCT, _tLa, _lR],
+    [0, () => WorkflowType, 0, 0, 0, () => TaskList, 0, 1, 0, 0, 64 | 0, 0],
+];
+var StartLambdaFunctionFailedEventAttributes = [
+    3,
+    n0,
+    _SLFFEAt,
+    0,
+    [_sEIc, _ca, _m],
+    [1, 0, 0],
+];
+var StartTimerDecisionAttributes = [3, n0, _STDA, 0, [_tIi, _c, _sTFT], [0, 0, 0]];
+var StartTimerFailedEventAttributes = [3, n0, _STFEA, 0, [_tIi, _ca, _dTCEI], [0, 0, 1]];
+var StartWorkflowExecutionInput = [
+    3,
+    n0,
+    _SWEIt,
+    0,
+    [_do, _wI, _wT, _tL, _tP, _i, _eSTCT, _tLa, _tSTCT, _cP, _lR],
+    [0, 0, () => WorkflowType, () => TaskList, 0, 0, 0, 64 | 0, 0, 0, 0],
+];
+var TagFilter = [3, n0, _TF, 0, [_ta], [0]];
+var TagResourceInput = [3, n0, _TRI, 0, [_rA, _t], [0, () => ResourceTagList]];
+var TaskList = [3, n0, _TL, 0, [_n], [0]];
+var TerminateWorkflowExecutionInput = [
+    3,
+    n0,
+    _TWEI,
+    0,
+    [_do, _wI, _rI, _re, _d, _cP],
+    [0, 0, 0, 0, 0, 0],
+];
+var TimerCanceledEventAttributes = [3, n0, _TCEA, 0, [_tIi, _sEI, _dTCEI], [0, 1, 1]];
+var TimerFiredEventAttributes = [3, n0, _TFEA, 0, [_tIi, _sEI], [0, 1]];
+var TimerStartedEventAttributes = [
+    3,
+    n0,
+    _TSEA,
+    0,
+    [_tIi, _c, _sTFT, _dTCEI],
+    [0, 0, 0, 1],
+];
+var TooManyTagsFault = [
+    -3,
+    n0,
+    _TMTF,
+    {
+        [_er]: _cl,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TooManyTagsFault, TooManyTagsFault$1);
+var TypeAlreadyExistsFault = [
+    -3,
+    n0,
+    _TAEF,
+    {
+        [_er]: _cl,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TypeAlreadyExistsFault, TypeAlreadyExistsFault$1);
+var TypeDeprecatedFault = [
+    -3,
+    n0,
+    _TDF,
+    {
+        [_er]: _cl,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TypeDeprecatedFault, TypeDeprecatedFault$1);
+var TypeNotDeprecatedFault = [
+    -3,
+    n0,
+    _TNDF,
+    {
+        [_er]: _cl,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TypeNotDeprecatedFault, TypeNotDeprecatedFault$1);
+var UndeprecateActivityTypeInput = [3, n0, _UATI, 0, [_do, _aT], [0, () => ActivityType]];
+var UndeprecateDomainInput = [3, n0, _UDI, 0, [_n], [0]];
+var UndeprecateWorkflowTypeInput = [3, n0, _UWTI, 0, [_do, _wT], [0, () => WorkflowType]];
+var UnknownResourceFault = [
+    -3,
+    n0,
+    _URF,
+    {
+        [_er]: _cl,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(UnknownResourceFault, UnknownResourceFault$1);
+var UntagResourceInput = [3, n0, _URI, 0, [_rA, _tK], [0, 64 | 0]];
+var WorkflowExecution = [3, n0, _WE, 0, [_wI, _rI], [0, 0]];
+var WorkflowExecutionAlreadyStartedFault = [
+    -3,
+    n0,
+    _WEASF,
+    {
+        [_er]: _cl,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(WorkflowExecutionAlreadyStartedFault, WorkflowExecutionAlreadyStartedFault$1);
+var WorkflowExecutionCanceledEventAttributes = [3, n0, _WECEA, 0, [_d, _dTCEI], [0, 1]];
+var WorkflowExecutionCancelRequestedEventAttributes = [
+    3,
+    n0,
+    _WECREA,
+    0,
+    [_eWE, _eIEI, _ca],
+    [() => WorkflowExecution, 1, 0],
+];
+var WorkflowExecutionCompletedEventAttributes = [3, n0, _WECEAo, 0, [_r, _dTCEI], [0, 1]];
+var WorkflowExecutionConfiguration = [
+    3,
+    n0,
+    _WEC,
+    0,
+    [_tSTCT, _eSTCT, _tL, _tP, _cP, _lR],
+    [0, 0, () => TaskList, 0, 0, 0],
+];
+var WorkflowExecutionContinuedAsNewEventAttributes = [
+    3,
+    n0,
+    _WECANEA,
+    0,
+    [_i, _dTCEI, _nERI, _eSTCT, _tL, _tP, _tSTCT, _cP, _tLa, _wT, _lR],
+    [0, 1, 0, 0, () => TaskList, 0, 0, 0, 64 | 0, () => WorkflowType, 0],
+];
+var WorkflowExecutionCount = [3, n0, _WECo, 0, [_cou, _tr], [1, 2]];
+var WorkflowExecutionDetail = [
+    3,
+    n0,
+    _WED,
+    0,
+    [_eIx, _eCx, _oC, _lATT, _lEC],
+    [() => WorkflowExecutionInfo, () => WorkflowExecutionConfiguration, () => WorkflowExecutionOpenCounts, 4, 0],
+];
+var WorkflowExecutionFailedEventAttributes = [
+    3,
+    n0,
+    _WEFEA,
+    0,
+    [_re, _d, _dTCEI],
+    [0, 0, 1],
+];
+var WorkflowExecutionFilter = [3, n0, _WEF, 0, [_wI], [0]];
+var WorkflowExecutionInfo = [
+    3,
+    n0,
+    _WEI,
+    0,
+    [_ex, _wT, _sT, _cT, _eS, _cS, _p, _tLa, _cR],
+    [() => WorkflowExecution, () => WorkflowType, 4, 4, 0, 0, () => WorkflowExecution, 64 | 0, 2],
+];
+var WorkflowExecutionInfos = [
+    3,
+    n0,
+    _WEIo,
+    0,
+    [_eIxe, _nPT],
+    [() => WorkflowExecutionInfoList, 0],
+];
+var WorkflowExecutionOpenCounts = [
+    3,
+    n0,
+    _WEOC,
+    0,
+    [_oAT, _oDT, _oT, _oCWE, _oLF],
+    [1, 1, 1, 1, 1],
+];
+var WorkflowExecutionSignaledEventAttributes = [
+    3,
+    n0,
+    _WESEA,
+    0,
+    [_sN, _i, _eWE, _eIEI],
+    [0, 0, () => WorkflowExecution, 1],
+];
+var WorkflowExecutionStartedEventAttributes = [
+    3,
+    n0,
+    _WESEAo,
+    0,
+    [_i, _eSTCT, _tSTCT, _cP, _tL, _tP, _wT, _tLa, _cERI, _pWE, _pIEI, _lR],
+    [0, 0, 0, 0, () => TaskList, 0, () => WorkflowType, 64 | 0, 0, () => WorkflowExecution, 1, 0],
+];
+var WorkflowExecutionTerminatedEventAttributes = [
+    3,
+    n0,
+    _WETEA,
+    0,
+    [_re, _d, _cP, _ca],
+    [0, 0, 0, 0],
+];
+var WorkflowExecutionTimedOutEventAttributes = [3, n0, _WETOEA, 0, [_tTi, _cP], [0, 0]];
+var WorkflowType = [3, n0, _WT, 0, [_n, _v], [0, 0]];
+var WorkflowTypeConfiguration = [
+    3,
+    n0,
+    _WTC,
+    0,
+    [_dTSTCT, _dESTCT, _dTL, _dTP, _dCP, _dLR],
+    [0, 0, () => TaskList, 0, 0, 0],
+];
+var WorkflowTypeDetail = [
+    3,
+    n0,
+    _WTD,
+    0,
+    [_tI, _co],
+    [() => WorkflowTypeInfo, () => WorkflowTypeConfiguration],
+];
+var WorkflowTypeFilter = [3, n0, _WTF, 0, [_n, _v], [0, 0]];
+var WorkflowTypeInfo = [
+    3,
+    n0,
+    _WTI,
+    0,
+    [_wT, _s, _de, _cD, _dD],
+    [() => WorkflowType, 0, 0, 4, 4],
+];
+var WorkflowTypeInfos = [3, n0, _WTIo, 0, [_tIy, _nPT], [() => WorkflowTypeInfoList, 0]];
+var __Unit = "unit";
+var SWFServiceException = [-3, _sm, "SWFServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(SWFServiceException, SWFServiceException$1);
+var ActivityTypeInfoList = [1, n0, _ATIL, 0, () => ActivityTypeInfo];
+var DecisionList = [1, n0, _DL, 0, () => Decision];
+var DomainInfoList = [1, n0, _DIL, 0, () => DomainInfo];
+var HistoryEventList = [1, n0, _HEL, 0, () => HistoryEvent];
+var ResourceTagList = [1, n0, _RTL, 0, () => ResourceTag];
+var WorkflowExecutionInfoList = [1, n0, _WEIL, 0, () => WorkflowExecutionInfo];
+var WorkflowTypeInfoList = [1, n0, _WTIL, 0, () => WorkflowTypeInfo];
+var CountClosedWorkflowExecutions = [
+    9,
+    n0,
+    _CCWE,
+    0,
+    () => CountClosedWorkflowExecutionsInput,
+    () => WorkflowExecutionCount,
+];
+var CountOpenWorkflowExecutions = [
+    9,
+    n0,
+    _COWE,
+    0,
+    () => CountOpenWorkflowExecutionsInput,
+    () => WorkflowExecutionCount,
+];
+var CountPendingActivityTasks = [
+    9,
+    n0,
+    _CPAT,
+    0,
+    () => CountPendingActivityTasksInput,
+    () => PendingTaskCount,
+];
+var CountPendingDecisionTasks = [
+    9,
+    n0,
+    _CPDT,
+    0,
+    () => CountPendingDecisionTasksInput,
+    () => PendingTaskCount,
+];
+var DeleteActivityType = [9, n0, _DAT, 0, () => DeleteActivityTypeInput, () => __Unit];
+var DeleteWorkflowType = [9, n0, _DWT, 0, () => DeleteWorkflowTypeInput, () => __Unit];
+var DeprecateActivityType = [
+    9,
+    n0,
+    _DATe,
+    0,
+    () => DeprecateActivityTypeInput,
+    () => __Unit,
+];
+var DeprecateDomain = [9, n0, _DDe, 0, () => DeprecateDomainInput, () => __Unit];
+var DeprecateWorkflowType = [
+    9,
+    n0,
+    _DWTe,
+    0,
+    () => DeprecateWorkflowTypeInput,
+    () => __Unit,
+];
+var DescribeActivityType = [
+    9,
+    n0,
+    _DATes,
+    0,
+    () => DescribeActivityTypeInput,
+    () => ActivityTypeDetail,
+];
+var DescribeDomain = [9, n0, _DDes, 0, () => DescribeDomainInput, () => DomainDetail];
+var DescribeWorkflowExecution = [
+    9,
+    n0,
+    _DWE,
+    0,
+    () => DescribeWorkflowExecutionInput,
+    () => WorkflowExecutionDetail,
+];
+var DescribeWorkflowType = [
+    9,
+    n0,
+    _DWTes,
+    0,
+    () => DescribeWorkflowTypeInput,
+    () => WorkflowTypeDetail,
+];
+var GetWorkflowExecutionHistory = [
+    9,
+    n0,
+    _GWEH,
+    0,
+    () => GetWorkflowExecutionHistoryInput,
+    () => History,
+];
+var ListActivityTypes = [
+    9,
+    n0,
+    _LAT,
+    0,
+    () => ListActivityTypesInput,
+    () => ActivityTypeInfos,
+];
+var ListClosedWorkflowExecutions = [
+    9,
+    n0,
+    _LCWE,
+    0,
+    () => ListClosedWorkflowExecutionsInput,
+    () => WorkflowExecutionInfos,
+];
+var ListDomains = [9, n0, _LD, 0, () => ListDomainsInput, () => DomainInfos];
+var ListOpenWorkflowExecutions = [
+    9,
+    n0,
+    _LOWE,
+    0,
+    () => ListOpenWorkflowExecutionsInput,
+    () => WorkflowExecutionInfos,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    0,
+    () => ListTagsForResourceInput,
+    () => ListTagsForResourceOutput,
+];
+var ListWorkflowTypes = [
+    9,
+    n0,
+    _LWT,
+    0,
+    () => ListWorkflowTypesInput,
+    () => WorkflowTypeInfos,
+];
+var PollForActivityTask = [
+    9,
+    n0,
+    _PFAT,
+    0,
+    () => PollForActivityTaskInput,
+    () => ActivityTask,
+];
+var PollForDecisionTask = [
+    9,
+    n0,
+    _PFDT,
+    0,
+    () => PollForDecisionTaskInput,
+    () => DecisionTask,
+];
+var RecordActivityTaskHeartbeat = [
+    9,
+    n0,
+    _RATH,
+    0,
+    () => RecordActivityTaskHeartbeatInput,
+    () => ActivityTaskStatus,
+];
+var RegisterActivityType = [
+    9,
+    n0,
+    _RAT,
+    0,
+    () => RegisterActivityTypeInput,
+    () => __Unit,
+];
+var RegisterDomain = [9, n0, _RD, 0, () => RegisterDomainInput, () => __Unit];
+var RegisterWorkflowType = [
+    9,
+    n0,
+    _RWT,
+    0,
+    () => RegisterWorkflowTypeInput,
+    () => __Unit,
+];
+var RequestCancelWorkflowExecution = [
+    9,
+    n0,
+    _RCWE,
+    0,
+    () => RequestCancelWorkflowExecutionInput,
+    () => __Unit,
+];
+var RespondActivityTaskCanceled = [
+    9,
+    n0,
+    _RATC,
+    0,
+    () => RespondActivityTaskCanceledInput,
+    () => __Unit,
+];
+var RespondActivityTaskCompleted = [
+    9,
+    n0,
+    _RATCe,
+    0,
+    () => RespondActivityTaskCompletedInput,
+    () => __Unit,
+];
+var RespondActivityTaskFailed = [
+    9,
+    n0,
+    _RATF,
+    0,
+    () => RespondActivityTaskFailedInput,
+    () => __Unit,
+];
+var RespondDecisionTaskCompleted = [
+    9,
+    n0,
+    _RDTC,
+    0,
+    () => RespondDecisionTaskCompletedInput,
+    () => __Unit,
+];
+var SignalWorkflowExecution = [
+    9,
+    n0,
+    _SWE,
+    0,
+    () => SignalWorkflowExecutionInput,
+    () => __Unit,
+];
+var StartWorkflowExecution = [
+    9,
+    n0,
+    _SWEt,
+    0,
+    () => StartWorkflowExecutionInput,
+    () => Run,
+];
+var TagResource = [9, n0, _TR, 0, () => TagResourceInput, () => __Unit];
+var TerminateWorkflowExecution = [
+    9,
+    n0,
+    _TWE,
+    0,
+    () => TerminateWorkflowExecutionInput,
+    () => __Unit,
+];
+var UndeprecateActivityType = [
+    9,
+    n0,
+    _UAT,
+    0,
+    () => UndeprecateActivityTypeInput,
+    () => __Unit,
+];
+var UndeprecateDomain = [9, n0, _UD, 0, () => UndeprecateDomainInput, () => __Unit];
+var UndeprecateWorkflowType = [
+    9,
+    n0,
+    _UWT,
+    0,
+    () => UndeprecateWorkflowTypeInput,
+    () => __Unit,
+];
+var UntagResource = [9, n0, _UR, 0, () => UntagResourceInput, () => __Unit];
 
 class CountClosedWorkflowExecutionsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "CountClosedWorkflowExecutions", {})
     .n("SWFClient", "CountClosedWorkflowExecutionsCommand")
-    .f(void 0, void 0)
-    .ser(se_CountClosedWorkflowExecutionsCommand)
-    .de(de_CountClosedWorkflowExecutionsCommand)
+    .sc(CountClosedWorkflowExecutions)
     .build() {
 }
 
@@ -1562,16 +2096,11 @@ class CountOpenWorkflowExecutionsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "CountOpenWorkflowExecutions", {})
     .n("SWFClient", "CountOpenWorkflowExecutionsCommand")
-    .f(void 0, void 0)
-    .ser(se_CountOpenWorkflowExecutionsCommand)
-    .de(de_CountOpenWorkflowExecutionsCommand)
+    .sc(CountOpenWorkflowExecutions)
     .build() {
 }
 
@@ -1579,16 +2108,11 @@ class CountPendingActivityTasksCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "CountPendingActivityTasks", {})
     .n("SWFClient", "CountPendingActivityTasksCommand")
-    .f(void 0, void 0)
-    .ser(se_CountPendingActivityTasksCommand)
-    .de(de_CountPendingActivityTasksCommand)
+    .sc(CountPendingActivityTasks)
     .build() {
 }
 
@@ -1596,16 +2120,11 @@ class CountPendingDecisionTasksCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "CountPendingDecisionTasks", {})
     .n("SWFClient", "CountPendingDecisionTasksCommand")
-    .f(void 0, void 0)
-    .ser(se_CountPendingDecisionTasksCommand)
-    .de(de_CountPendingDecisionTasksCommand)
+    .sc(CountPendingDecisionTasks)
     .build() {
 }
 
@@ -1613,16 +2132,11 @@ class DeleteActivityTypeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "DeleteActivityType", {})
     .n("SWFClient", "DeleteActivityTypeCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteActivityTypeCommand)
-    .de(de_DeleteActivityTypeCommand)
+    .sc(DeleteActivityType)
     .build() {
 }
 
@@ -1630,16 +2144,11 @@ class DeleteWorkflowTypeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "DeleteWorkflowType", {})
     .n("SWFClient", "DeleteWorkflowTypeCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteWorkflowTypeCommand)
-    .de(de_DeleteWorkflowTypeCommand)
+    .sc(DeleteWorkflowType)
     .build() {
 }
 
@@ -1647,16 +2156,11 @@ class DeprecateActivityTypeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "DeprecateActivityType", {})
     .n("SWFClient", "DeprecateActivityTypeCommand")
-    .f(void 0, void 0)
-    .ser(se_DeprecateActivityTypeCommand)
-    .de(de_DeprecateActivityTypeCommand)
+    .sc(DeprecateActivityType)
     .build() {
 }
 
@@ -1664,16 +2168,11 @@ class DeprecateDomainCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "DeprecateDomain", {})
     .n("SWFClient", "DeprecateDomainCommand")
-    .f(void 0, void 0)
-    .ser(se_DeprecateDomainCommand)
-    .de(de_DeprecateDomainCommand)
+    .sc(DeprecateDomain)
     .build() {
 }
 
@@ -1681,16 +2180,11 @@ class DeprecateWorkflowTypeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "DeprecateWorkflowType", {})
     .n("SWFClient", "DeprecateWorkflowTypeCommand")
-    .f(void 0, void 0)
-    .ser(se_DeprecateWorkflowTypeCommand)
-    .de(de_DeprecateWorkflowTypeCommand)
+    .sc(DeprecateWorkflowType)
     .build() {
 }
 
@@ -1698,16 +2192,11 @@ class DescribeActivityTypeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "DescribeActivityType", {})
     .n("SWFClient", "DescribeActivityTypeCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeActivityTypeCommand)
-    .de(de_DescribeActivityTypeCommand)
+    .sc(DescribeActivityType)
     .build() {
 }
 
@@ -1715,16 +2204,11 @@ class DescribeDomainCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "DescribeDomain", {})
     .n("SWFClient", "DescribeDomainCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeDomainCommand)
-    .de(de_DescribeDomainCommand)
+    .sc(DescribeDomain)
     .build() {
 }
 
@@ -1732,16 +2216,11 @@ class DescribeWorkflowExecutionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "DescribeWorkflowExecution", {})
     .n("SWFClient", "DescribeWorkflowExecutionCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeWorkflowExecutionCommand)
-    .de(de_DescribeWorkflowExecutionCommand)
+    .sc(DescribeWorkflowExecution)
     .build() {
 }
 
@@ -1749,16 +2228,11 @@ class DescribeWorkflowTypeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "DescribeWorkflowType", {})
     .n("SWFClient", "DescribeWorkflowTypeCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeWorkflowTypeCommand)
-    .de(de_DescribeWorkflowTypeCommand)
+    .sc(DescribeWorkflowType)
     .build() {
 }
 
@@ -1766,16 +2240,11 @@ class GetWorkflowExecutionHistoryCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "GetWorkflowExecutionHistory", {})
     .n("SWFClient", "GetWorkflowExecutionHistoryCommand")
-    .f(void 0, void 0)
-    .ser(se_GetWorkflowExecutionHistoryCommand)
-    .de(de_GetWorkflowExecutionHistoryCommand)
+    .sc(GetWorkflowExecutionHistory)
     .build() {
 }
 
@@ -1783,16 +2252,11 @@ class ListActivityTypesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "ListActivityTypes", {})
     .n("SWFClient", "ListActivityTypesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListActivityTypesCommand)
-    .de(de_ListActivityTypesCommand)
+    .sc(ListActivityTypes)
     .build() {
 }
 
@@ -1800,16 +2264,11 @@ class ListClosedWorkflowExecutionsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "ListClosedWorkflowExecutions", {})
     .n("SWFClient", "ListClosedWorkflowExecutionsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListClosedWorkflowExecutionsCommand)
-    .de(de_ListClosedWorkflowExecutionsCommand)
+    .sc(ListClosedWorkflowExecutions)
     .build() {
 }
 
@@ -1817,16 +2276,11 @@ class ListDomainsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "ListDomains", {})
     .n("SWFClient", "ListDomainsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListDomainsCommand)
-    .de(de_ListDomainsCommand)
+    .sc(ListDomains)
     .build() {
 }
 
@@ -1834,16 +2288,11 @@ class ListOpenWorkflowExecutionsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "ListOpenWorkflowExecutions", {})
     .n("SWFClient", "ListOpenWorkflowExecutionsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListOpenWorkflowExecutionsCommand)
-    .de(de_ListOpenWorkflowExecutionsCommand)
+    .sc(ListOpenWorkflowExecutions)
     .build() {
 }
 
@@ -1851,16 +2300,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "ListTagsForResource", {})
     .n("SWFClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1868,16 +2312,11 @@ class ListWorkflowTypesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "ListWorkflowTypes", {})
     .n("SWFClient", "ListWorkflowTypesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListWorkflowTypesCommand)
-    .de(de_ListWorkflowTypesCommand)
+    .sc(ListWorkflowTypes)
     .build() {
 }
 
@@ -1885,16 +2324,11 @@ class PollForActivityTaskCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "PollForActivityTask", {})
     .n("SWFClient", "PollForActivityTaskCommand")
-    .f(void 0, void 0)
-    .ser(se_PollForActivityTaskCommand)
-    .de(de_PollForActivityTaskCommand)
+    .sc(PollForActivityTask)
     .build() {
 }
 
@@ -1902,16 +2336,11 @@ class PollForDecisionTaskCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "PollForDecisionTask", {})
     .n("SWFClient", "PollForDecisionTaskCommand")
-    .f(void 0, void 0)
-    .ser(se_PollForDecisionTaskCommand)
-    .de(de_PollForDecisionTaskCommand)
+    .sc(PollForDecisionTask)
     .build() {
 }
 
@@ -1919,16 +2348,11 @@ class RecordActivityTaskHeartbeatCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "RecordActivityTaskHeartbeat", {})
     .n("SWFClient", "RecordActivityTaskHeartbeatCommand")
-    .f(void 0, void 0)
-    .ser(se_RecordActivityTaskHeartbeatCommand)
-    .de(de_RecordActivityTaskHeartbeatCommand)
+    .sc(RecordActivityTaskHeartbeat)
     .build() {
 }
 
@@ -1936,16 +2360,11 @@ class RegisterActivityTypeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "RegisterActivityType", {})
     .n("SWFClient", "RegisterActivityTypeCommand")
-    .f(void 0, void 0)
-    .ser(se_RegisterActivityTypeCommand)
-    .de(de_RegisterActivityTypeCommand)
+    .sc(RegisterActivityType)
     .build() {
 }
 
@@ -1953,16 +2372,11 @@ class RegisterDomainCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "RegisterDomain", {})
     .n("SWFClient", "RegisterDomainCommand")
-    .f(void 0, void 0)
-    .ser(se_RegisterDomainCommand)
-    .de(de_RegisterDomainCommand)
+    .sc(RegisterDomain)
     .build() {
 }
 
@@ -1970,16 +2384,11 @@ class RegisterWorkflowTypeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "RegisterWorkflowType", {})
     .n("SWFClient", "RegisterWorkflowTypeCommand")
-    .f(void 0, void 0)
-    .ser(se_RegisterWorkflowTypeCommand)
-    .de(de_RegisterWorkflowTypeCommand)
+    .sc(RegisterWorkflowType)
     .build() {
 }
 
@@ -1987,16 +2396,11 @@ class RequestCancelWorkflowExecutionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "RequestCancelWorkflowExecution", {})
     .n("SWFClient", "RequestCancelWorkflowExecutionCommand")
-    .f(void 0, void 0)
-    .ser(se_RequestCancelWorkflowExecutionCommand)
-    .de(de_RequestCancelWorkflowExecutionCommand)
+    .sc(RequestCancelWorkflowExecution)
     .build() {
 }
 
@@ -2004,16 +2408,11 @@ class RespondActivityTaskCanceledCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "RespondActivityTaskCanceled", {})
     .n("SWFClient", "RespondActivityTaskCanceledCommand")
-    .f(void 0, void 0)
-    .ser(se_RespondActivityTaskCanceledCommand)
-    .de(de_RespondActivityTaskCanceledCommand)
+    .sc(RespondActivityTaskCanceled)
     .build() {
 }
 
@@ -2021,16 +2420,11 @@ class RespondActivityTaskCompletedCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "RespondActivityTaskCompleted", {})
     .n("SWFClient", "RespondActivityTaskCompletedCommand")
-    .f(void 0, void 0)
-    .ser(se_RespondActivityTaskCompletedCommand)
-    .de(de_RespondActivityTaskCompletedCommand)
+    .sc(RespondActivityTaskCompleted)
     .build() {
 }
 
@@ -2038,16 +2432,11 @@ class RespondActivityTaskFailedCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "RespondActivityTaskFailed", {})
     .n("SWFClient", "RespondActivityTaskFailedCommand")
-    .f(void 0, void 0)
-    .ser(se_RespondActivityTaskFailedCommand)
-    .de(de_RespondActivityTaskFailedCommand)
+    .sc(RespondActivityTaskFailed)
     .build() {
 }
 
@@ -2055,16 +2444,11 @@ class RespondDecisionTaskCompletedCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "RespondDecisionTaskCompleted", {})
     .n("SWFClient", "RespondDecisionTaskCompletedCommand")
-    .f(void 0, void 0)
-    .ser(se_RespondDecisionTaskCompletedCommand)
-    .de(de_RespondDecisionTaskCompletedCommand)
+    .sc(RespondDecisionTaskCompleted)
     .build() {
 }
 
@@ -2072,16 +2456,11 @@ class SignalWorkflowExecutionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "SignalWorkflowExecution", {})
     .n("SWFClient", "SignalWorkflowExecutionCommand")
-    .f(void 0, void 0)
-    .ser(se_SignalWorkflowExecutionCommand)
-    .de(de_SignalWorkflowExecutionCommand)
+    .sc(SignalWorkflowExecution)
     .build() {
 }
 
@@ -2089,16 +2468,11 @@ class StartWorkflowExecutionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "StartWorkflowExecution", {})
     .n("SWFClient", "StartWorkflowExecutionCommand")
-    .f(void 0, void 0)
-    .ser(se_StartWorkflowExecutionCommand)
-    .de(de_StartWorkflowExecutionCommand)
+    .sc(StartWorkflowExecution)
     .build() {
 }
 
@@ -2106,16 +2480,11 @@ class TagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "TagResource", {})
     .n("SWFClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -2123,16 +2492,11 @@ class TerminateWorkflowExecutionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "TerminateWorkflowExecution", {})
     .n("SWFClient", "TerminateWorkflowExecutionCommand")
-    .f(void 0, void 0)
-    .ser(se_TerminateWorkflowExecutionCommand)
-    .de(de_TerminateWorkflowExecutionCommand)
+    .sc(TerminateWorkflowExecution)
     .build() {
 }
 
@@ -2140,16 +2504,11 @@ class UndeprecateActivityTypeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "UndeprecateActivityType", {})
     .n("SWFClient", "UndeprecateActivityTypeCommand")
-    .f(void 0, void 0)
-    .ser(se_UndeprecateActivityTypeCommand)
-    .de(de_UndeprecateActivityTypeCommand)
+    .sc(UndeprecateActivityType)
     .build() {
 }
 
@@ -2157,16 +2516,11 @@ class UndeprecateDomainCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "UndeprecateDomain", {})
     .n("SWFClient", "UndeprecateDomainCommand")
-    .f(void 0, void 0)
-    .ser(se_UndeprecateDomainCommand)
-    .de(de_UndeprecateDomainCommand)
+    .sc(UndeprecateDomain)
     .build() {
 }
 
@@ -2174,16 +2528,11 @@ class UndeprecateWorkflowTypeCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "UndeprecateWorkflowType", {})
     .n("SWFClient", "UndeprecateWorkflowTypeCommand")
-    .f(void 0, void 0)
-    .ser(se_UndeprecateWorkflowTypeCommand)
-    .de(de_UndeprecateWorkflowTypeCommand)
+    .sc(UndeprecateWorkflowType)
     .build() {
 }
 
@@ -2191,16 +2540,11 @@ class UntagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SimpleWorkflowService", "UntagResource", {})
     .n("SWFClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -2284,7 +2628,7 @@ exports.CountPendingActivityTasksCommand = CountPendingActivityTasksCommand;
 exports.CountPendingDecisionTasksCommand = CountPendingDecisionTasksCommand;
 exports.DecisionTaskTimeoutType = DecisionTaskTimeoutType;
 exports.DecisionType = DecisionType;
-exports.DefaultUndefinedFault = DefaultUndefinedFault;
+exports.DefaultUndefinedFault = DefaultUndefinedFault$1;
 exports.DeleteActivityTypeCommand = DeleteActivityTypeCommand;
 exports.DeleteWorkflowTypeCommand = DeleteWorkflowTypeCommand;
 exports.DeprecateActivityTypeCommand = DeprecateActivityTypeCommand;
@@ -2294,21 +2638,21 @@ exports.DescribeActivityTypeCommand = DescribeActivityTypeCommand;
 exports.DescribeDomainCommand = DescribeDomainCommand;
 exports.DescribeWorkflowExecutionCommand = DescribeWorkflowExecutionCommand;
 exports.DescribeWorkflowTypeCommand = DescribeWorkflowTypeCommand;
-exports.DomainAlreadyExistsFault = DomainAlreadyExistsFault;
-exports.DomainDeprecatedFault = DomainDeprecatedFault;
+exports.DomainAlreadyExistsFault = DomainAlreadyExistsFault$1;
+exports.DomainDeprecatedFault = DomainDeprecatedFault$1;
 exports.EventType = EventType;
 exports.ExecutionStatus = ExecutionStatus;
 exports.FailWorkflowExecutionFailedCause = FailWorkflowExecutionFailedCause;
 exports.GetWorkflowExecutionHistoryCommand = GetWorkflowExecutionHistoryCommand;
 exports.LambdaFunctionTimeoutType = LambdaFunctionTimeoutType;
-exports.LimitExceededFault = LimitExceededFault;
+exports.LimitExceededFault = LimitExceededFault$1;
 exports.ListActivityTypesCommand = ListActivityTypesCommand;
 exports.ListClosedWorkflowExecutionsCommand = ListClosedWorkflowExecutionsCommand;
 exports.ListDomainsCommand = ListDomainsCommand;
 exports.ListOpenWorkflowExecutionsCommand = ListOpenWorkflowExecutionsCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.ListWorkflowTypesCommand = ListWorkflowTypesCommand;
-exports.OperationNotPermittedFault = OperationNotPermittedFault;
+exports.OperationNotPermittedFault = OperationNotPermittedFault$1;
 exports.PollForActivityTaskCommand = PollForActivityTaskCommand;
 exports.PollForDecisionTaskCommand = PollForDecisionTaskCommand;
 exports.RecordActivityTaskHeartbeatCommand = RecordActivityTaskHeartbeatCommand;
@@ -2326,7 +2670,7 @@ exports.RespondActivityTaskFailedCommand = RespondActivityTaskFailedCommand;
 exports.RespondDecisionTaskCompletedCommand = RespondDecisionTaskCompletedCommand;
 exports.SWF = SWF;
 exports.SWFClient = SWFClient;
-exports.SWFServiceException = SWFServiceException;
+exports.SWFServiceException = SWFServiceException$1;
 exports.ScheduleActivityTaskFailedCause = ScheduleActivityTaskFailedCause;
 exports.ScheduleLambdaFunctionFailedCause = ScheduleLambdaFunctionFailedCause;
 exports.SignalExternalWorkflowExecutionFailedCause = SignalExternalWorkflowExecutionFailedCause;
@@ -2337,16 +2681,16 @@ exports.StartTimerFailedCause = StartTimerFailedCause;
 exports.StartWorkflowExecutionCommand = StartWorkflowExecutionCommand;
 exports.TagResourceCommand = TagResourceCommand;
 exports.TerminateWorkflowExecutionCommand = TerminateWorkflowExecutionCommand;
-exports.TooManyTagsFault = TooManyTagsFault;
-exports.TypeAlreadyExistsFault = TypeAlreadyExistsFault;
-exports.TypeDeprecatedFault = TypeDeprecatedFault;
-exports.TypeNotDeprecatedFault = TypeNotDeprecatedFault;
+exports.TooManyTagsFault = TooManyTagsFault$1;
+exports.TypeAlreadyExistsFault = TypeAlreadyExistsFault$1;
+exports.TypeDeprecatedFault = TypeDeprecatedFault$1;
+exports.TypeNotDeprecatedFault = TypeNotDeprecatedFault$1;
 exports.UndeprecateActivityTypeCommand = UndeprecateActivityTypeCommand;
 exports.UndeprecateDomainCommand = UndeprecateDomainCommand;
 exports.UndeprecateWorkflowTypeCommand = UndeprecateWorkflowTypeCommand;
-exports.UnknownResourceFault = UnknownResourceFault;
+exports.UnknownResourceFault = UnknownResourceFault$1;
 exports.UntagResourceCommand = UntagResourceCommand;
-exports.WorkflowExecutionAlreadyStartedFault = WorkflowExecutionAlreadyStartedFault;
+exports.WorkflowExecutionAlreadyStartedFault = WorkflowExecutionAlreadyStartedFault$1;
 exports.WorkflowExecutionCancelRequestedCause = WorkflowExecutionCancelRequestedCause;
 exports.WorkflowExecutionTerminatedCause = WorkflowExecutionTerminatedCause;
 exports.WorkflowExecutionTimeoutType = WorkflowExecutionTimeoutType;