@aws-sdk/client-swf 3.901.0 → 3.907.0

package/dist-cjs/index.js

@@ -1,2521 +1,2359 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ActivityTaskTimeoutType: () => ActivityTaskTimeoutType,
-  CancelTimerFailedCause: () => CancelTimerFailedCause,
-  CancelWorkflowExecutionFailedCause: () => CancelWorkflowExecutionFailedCause,
-  ChildPolicy: () => ChildPolicy,
-  CloseStatus: () => CloseStatus,
-  CompleteWorkflowExecutionFailedCause: () => CompleteWorkflowExecutionFailedCause,
-  ContinueAsNewWorkflowExecutionFailedCause: () => ContinueAsNewWorkflowExecutionFailedCause,
-  CountClosedWorkflowExecutionsCommand: () => CountClosedWorkflowExecutionsCommand,
-  CountOpenWorkflowExecutionsCommand: () => CountOpenWorkflowExecutionsCommand,
-  CountPendingActivityTasksCommand: () => CountPendingActivityTasksCommand,
-  CountPendingDecisionTasksCommand: () => CountPendingDecisionTasksCommand,
-  DecisionTaskTimeoutType: () => DecisionTaskTimeoutType,
-  DecisionType: () => DecisionType,
-  DefaultUndefinedFault: () => DefaultUndefinedFault,
-  DeleteActivityTypeCommand: () => DeleteActivityTypeCommand,
-  DeleteWorkflowTypeCommand: () => DeleteWorkflowTypeCommand,
-  DeprecateActivityTypeCommand: () => DeprecateActivityTypeCommand,
-  DeprecateDomainCommand: () => DeprecateDomainCommand,
-  DeprecateWorkflowTypeCommand: () => DeprecateWorkflowTypeCommand,
-  DescribeActivityTypeCommand: () => DescribeActivityTypeCommand,
-  DescribeDomainCommand: () => DescribeDomainCommand,
-  DescribeWorkflowExecutionCommand: () => DescribeWorkflowExecutionCommand,
-  DescribeWorkflowTypeCommand: () => DescribeWorkflowTypeCommand,
-  DomainAlreadyExistsFault: () => DomainAlreadyExistsFault,
-  DomainDeprecatedFault: () => DomainDeprecatedFault,
-  EventType: () => EventType,
-  ExecutionStatus: () => ExecutionStatus,
-  FailWorkflowExecutionFailedCause: () => FailWorkflowExecutionFailedCause,
-  GetWorkflowExecutionHistoryCommand: () => GetWorkflowExecutionHistoryCommand,
-  LambdaFunctionTimeoutType: () => LambdaFunctionTimeoutType,
-  LimitExceededFault: () => LimitExceededFault,
-  ListActivityTypesCommand: () => ListActivityTypesCommand,
-  ListClosedWorkflowExecutionsCommand: () => ListClosedWorkflowExecutionsCommand,
-  ListDomainsCommand: () => ListDomainsCommand,
-  ListOpenWorkflowExecutionsCommand: () => ListOpenWorkflowExecutionsCommand,
-  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
-  ListWorkflowTypesCommand: () => ListWorkflowTypesCommand,
-  OperationNotPermittedFault: () => OperationNotPermittedFault,
-  PollForActivityTaskCommand: () => PollForActivityTaskCommand,
-  PollForDecisionTaskCommand: () => PollForDecisionTaskCommand,
-  RecordActivityTaskHeartbeatCommand: () => RecordActivityTaskHeartbeatCommand,
-  RecordMarkerFailedCause: () => RecordMarkerFailedCause,
-  RegisterActivityTypeCommand: () => RegisterActivityTypeCommand,
-  RegisterDomainCommand: () => RegisterDomainCommand,
-  RegisterWorkflowTypeCommand: () => RegisterWorkflowTypeCommand,
-  RegistrationStatus: () => RegistrationStatus,
-  RequestCancelActivityTaskFailedCause: () => RequestCancelActivityTaskFailedCause,
-  RequestCancelExternalWorkflowExecutionFailedCause: () => RequestCancelExternalWorkflowExecutionFailedCause,
-  RequestCancelWorkflowExecutionCommand: () => RequestCancelWorkflowExecutionCommand,
-  RespondActivityTaskCanceledCommand: () => RespondActivityTaskCanceledCommand,
-  RespondActivityTaskCompletedCommand: () => RespondActivityTaskCompletedCommand,
-  RespondActivityTaskFailedCommand: () => RespondActivityTaskFailedCommand,
-  RespondDecisionTaskCompletedCommand: () => RespondDecisionTaskCompletedCommand,
-  SWF: () => SWF,
-  SWFClient: () => SWFClient,
-  SWFServiceException: () => SWFServiceException,
-  ScheduleActivityTaskFailedCause: () => ScheduleActivityTaskFailedCause,
-  ScheduleLambdaFunctionFailedCause: () => ScheduleLambdaFunctionFailedCause,
-  SignalExternalWorkflowExecutionFailedCause: () => SignalExternalWorkflowExecutionFailedCause,
-  SignalWorkflowExecutionCommand: () => SignalWorkflowExecutionCommand,
-  StartChildWorkflowExecutionFailedCause: () => StartChildWorkflowExecutionFailedCause,
-  StartLambdaFunctionFailedCause: () => StartLambdaFunctionFailedCause,
-  StartTimerFailedCause: () => StartTimerFailedCause,
-  StartWorkflowExecutionCommand: () => StartWorkflowExecutionCommand,
-  TagResourceCommand: () => TagResourceCommand,
-  TerminateWorkflowExecutionCommand: () => TerminateWorkflowExecutionCommand,
-  TooManyTagsFault: () => TooManyTagsFault,
-  TypeAlreadyExistsFault: () => TypeAlreadyExistsFault,
-  TypeDeprecatedFault: () => TypeDeprecatedFault,
-  TypeNotDeprecatedFault: () => TypeNotDeprecatedFault,
-  UndeprecateActivityTypeCommand: () => UndeprecateActivityTypeCommand,
-  UndeprecateDomainCommand: () => UndeprecateDomainCommand,
-  UndeprecateWorkflowTypeCommand: () => UndeprecateWorkflowTypeCommand,
-  UnknownResourceFault: () => UnknownResourceFault,
-  UntagResourceCommand: () => UntagResourceCommand,
-  WorkflowExecutionAlreadyStartedFault: () => WorkflowExecutionAlreadyStartedFault,
-  WorkflowExecutionCancelRequestedCause: () => WorkflowExecutionCancelRequestedCause,
-  WorkflowExecutionTerminatedCause: () => WorkflowExecutionTerminatedCause,
-  WorkflowExecutionTimeoutType: () => WorkflowExecutionTimeoutType,
-  __Client: () => import_smithy_client.Client,
-  paginateGetWorkflowExecutionHistory: () => paginateGetWorkflowExecutionHistory,
-  paginateListActivityTypes: () => paginateListActivityTypes,
-  paginateListClosedWorkflowExecutions: () => paginateListClosedWorkflowExecutions,
-  paginateListDomains: () => paginateListDomains,
-  paginateListOpenWorkflowExecutions: () => paginateListOpenWorkflowExecutions,
-  paginateListWorkflowTypes: () => paginateListWorkflowTypes,
-  paginatePollForDecisionTask: () => paginatePollForDecisionTask
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/SWFClient.ts
-var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
-var import_middleware_logger = require("@aws-sdk/middleware-logger");
-var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
-var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
-var import_config_resolver = require("@smithy/config-resolver");
-var import_core = require("@smithy/core");
-var import_middleware_content_length = require("@smithy/middleware-content-length");
-var import_middleware_endpoint = require("@smithy/middleware-endpoint");
-var import_middleware_retry = require("@smithy/middleware-retry");
-
-var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
-
-// src/endpoint/EndpointParameters.ts
-var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
-  return Object.assign(options, {
-    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
-    useFipsEndpoint: options.useFipsEndpoint ?? false,
-    defaultSigningName: "swf"
-  });
-}, "resolveClientEndpointParameters");
-var commonParams = {
-  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-  Endpoint: { type: "builtInParams", name: "endpoint" },
-  Region: { type: "builtInParams", name: "region" },
-  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+'use strict';
+
+var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
+var middlewareLogger = require('@aws-sdk/middleware-logger');
+var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
+var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
+var configResolver = require('@smithy/config-resolver');
+var core = require('@smithy/core');
+var middlewareContentLength = require('@smithy/middleware-content-length');
+var middlewareEndpoint = require('@smithy/middleware-endpoint');
+var middlewareRetry = require('@smithy/middleware-retry');
+var smithyClient = require('@smithy/smithy-client');
+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, {
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "swf",
+    });
 };
-
-// src/SWFClient.ts
-var import_runtimeConfig = require("././runtimeConfig");
-
-// src/runtimeExtensions.ts
-var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
-var import_protocol_http = require("@smithy/protocol-http");
-var import_smithy_client = require("@smithy/smithy-client");
-
-// src/auth/httpAuthExtensionConfiguration.ts
-var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
-  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
-  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
-  let _credentials = runtimeConfig.credentials;
-  return {
-    setHttpAuthScheme(httpAuthScheme) {
-      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
-      if (index === -1) {
-        _httpAuthSchemes.push(httpAuthScheme);
-      } else {
-        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
-      }
-    },
-    httpAuthSchemes() {
-      return _httpAuthSchemes;
-    },
-    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
-      _httpAuthSchemeProvider = httpAuthSchemeProvider;
-    },
-    httpAuthSchemeProvider() {
-      return _httpAuthSchemeProvider;
-    },
-    setCredentials(credentials) {
-      _credentials = credentials;
-    },
-    credentials() {
-      return _credentials;
+const commonParams = {
+    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+    Endpoint: { type: "builtInParams", name: "endpoint" },
+    Region: { type: "builtInParams", name: "region" },
+    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+};
+
+const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
+    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+    let _credentials = runtimeConfig.credentials;
+    return {
+        setHttpAuthScheme(httpAuthScheme) {
+            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+            if (index === -1) {
+                _httpAuthSchemes.push(httpAuthScheme);
+            }
+            else {
+                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+            }
+        },
+        httpAuthSchemes() {
+            return _httpAuthSchemes;
+        },
+        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+            _httpAuthSchemeProvider = httpAuthSchemeProvider;
+        },
+        httpAuthSchemeProvider() {
+            return _httpAuthSchemeProvider;
+        },
+        setCredentials(credentials) {
+            _credentials = credentials;
+        },
+        credentials() {
+            return _credentials;
+        },
+    };
+};
+const resolveHttpAuthRuntimeConfig = (config) => {
+    return {
+        httpAuthSchemes: config.httpAuthSchemes(),
+        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+        credentials: config.credentials(),
+    };
+};
+
+const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
+    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    extensions.forEach((extension) => extension.configure(extensionConfiguration));
+    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+};
+
+class SWFClient extends smithyClient.Client {
+    config;
+    constructor(...[configuration]) {
+        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        super(_config_0);
+        this.initConfig = _config_0;
+        const _config_1 = resolveClientEndpointParameters(_config_0);
+        const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
+        const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
+        const _config_4 = configResolver.resolveRegionConfig(_config_3);
+        const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
+        const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
+        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
+        this.config = _config_8;
+        this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
+        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
+        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
+        this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
+        this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultSWFHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+                "aws.auth#sigv4": config.credentials,
+            }),
+        }));
+        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
     }
-  };
-}, "getHttpAuthExtensionConfiguration");
-var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
-  return {
-    httpAuthSchemes: config.httpAuthSchemes(),
-    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
-    credentials: config.credentials()
-  };
-}, "resolveHttpAuthRuntimeConfig");
-
-// src/runtimeExtensions.ts
-var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
-  const extensionConfiguration = Object.assign(
-    (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
-    (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
-    (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
-    getHttpAuthExtensionConfiguration(runtimeConfig)
-  );
-  extensions.forEach((extension) => extension.configure(extensionConfiguration));
-  return Object.assign(
-    runtimeConfig,
-    (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
-    (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
-    (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
-    resolveHttpAuthRuntimeConfig(extensionConfiguration)
-  );
-}, "resolveRuntimeExtensions");
-
-// src/SWFClient.ts
-var SWFClient = class extends import_smithy_client.Client {
-  static {
-    __name(this, "SWFClient");
-  }
-  /**
-   * The resolved configuration of SWFClient class. This is resolved and normalized from the {@link SWFClientConfig | constructor configuration interface}.
-   */
-  config;
-  constructor(...[configuration]) {
-    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
-    super(_config_0);
-    this.initConfig = _config_0;
-    const _config_1 = resolveClientEndpointParameters(_config_0);
-    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
-    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
-    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
-    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
-    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
-    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
-    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
-    this.config = _config_8;
-    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
-    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
-    this.middlewareStack.use(
-      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
-        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultSWFHttpAuthSchemeParametersProvider,
-        identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
-          "aws.auth#sigv4": config.credentials
-        }), "identityProviderConfigProvider")
-      })
-    );
-    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
-  }
-  /**
-   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-   */
-  destroy() {
-    super.destroy();
-  }
-};
-
-// src/SWF.ts
-
-
-// src/commands/CountClosedWorkflowExecutionsCommand.ts
-
-var import_middleware_serde = require("@smithy/middleware-serde");
-
-
-// src/protocols/Aws_json1_0.ts
-var import_core2 = require("@aws-sdk/core");
-
+    destroy() {
+        super.destroy();
+    }
+}
 
+class SWFServiceException extends smithyClient.ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, SWFServiceException.prototype);
+    }
+}
 
-// src/models/SWFServiceException.ts
+const ActivityTaskTimeoutType = {
+    HEARTBEAT: "HEARTBEAT",
+    SCHEDULE_TO_CLOSE: "SCHEDULE_TO_CLOSE",
+    SCHEDULE_TO_START: "SCHEDULE_TO_START",
+    START_TO_CLOSE: "START_TO_CLOSE",
+};
+const RegistrationStatus = {
+    DEPRECATED: "DEPRECATED",
+    REGISTERED: "REGISTERED",
+};
+const CancelTimerFailedCause = {
+    OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
+    TIMER_ID_UNKNOWN: "TIMER_ID_UNKNOWN",
+};
+const CancelWorkflowExecutionFailedCause = {
+    OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
+    UNHANDLED_DECISION: "UNHANDLED_DECISION",
+};
+const ChildPolicy = {
+    ABANDON: "ABANDON",
+    REQUEST_CANCEL: "REQUEST_CANCEL",
+    TERMINATE: "TERMINATE",
+};
+const WorkflowExecutionTimeoutType = {
+    START_TO_CLOSE: "START_TO_CLOSE",
+};
+const CloseStatus = {
+    CANCELED: "CANCELED",
+    COMPLETED: "COMPLETED",
+    CONTINUED_AS_NEW: "CONTINUED_AS_NEW",
+    FAILED: "FAILED",
+    TERMINATED: "TERMINATED",
+    TIMED_OUT: "TIMED_OUT",
+};
+const CompleteWorkflowExecutionFailedCause = {
+    OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
+    UNHANDLED_DECISION: "UNHANDLED_DECISION",
+};
+const ContinueAsNewWorkflowExecutionFailedCause = {
+    CONTINUE_AS_NEW_WORKFLOW_EXECUTION_RATE_EXCEEDED: "CONTINUE_AS_NEW_WORKFLOW_EXECUTION_RATE_EXCEEDED",
+    DEFAULT_CHILD_POLICY_UNDEFINED: "DEFAULT_CHILD_POLICY_UNDEFINED",
+    DEFAULT_EXECUTION_START_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_EXECUTION_START_TO_CLOSE_TIMEOUT_UNDEFINED",
+    DEFAULT_TASK_LIST_UNDEFINED: "DEFAULT_TASK_LIST_UNDEFINED",
+    DEFAULT_TASK_START_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_TASK_START_TO_CLOSE_TIMEOUT_UNDEFINED",
+    OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
+    UNHANDLED_DECISION: "UNHANDLED_DECISION",
+    WORKFLOW_TYPE_DEPRECATED: "WORKFLOW_TYPE_DEPRECATED",
+    WORKFLOW_TYPE_DOES_NOT_EXIST: "WORKFLOW_TYPE_DOES_NOT_EXIST",
+};
+class OperationNotPermittedFault extends SWFServiceException {
+    name = "OperationNotPermittedFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "OperationNotPermittedFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, OperationNotPermittedFault.prototype);
+    }
+}
+class UnknownResourceFault extends SWFServiceException {
+    name = "UnknownResourceFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "UnknownResourceFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UnknownResourceFault.prototype);
+    }
+}
+const DecisionType = {
+    CancelTimer: "CancelTimer",
+    CancelWorkflowExecution: "CancelWorkflowExecution",
+    CompleteWorkflowExecution: "CompleteWorkflowExecution",
+    ContinueAsNewWorkflowExecution: "ContinueAsNewWorkflowExecution",
+    FailWorkflowExecution: "FailWorkflowExecution",
+    RecordMarker: "RecordMarker",
+    RequestCancelActivityTask: "RequestCancelActivityTask",
+    RequestCancelExternalWorkflowExecution: "RequestCancelExternalWorkflowExecution",
+    ScheduleActivityTask: "ScheduleActivityTask",
+    ScheduleLambdaFunction: "ScheduleLambdaFunction",
+    SignalExternalWorkflowExecution: "SignalExternalWorkflowExecution",
+    StartChildWorkflowExecution: "StartChildWorkflowExecution",
+    StartTimer: "StartTimer",
+};
+const DecisionTaskTimeoutType = {
+    SCHEDULE_TO_START: "SCHEDULE_TO_START",
+    START_TO_CLOSE: "START_TO_CLOSE",
+};
+const EventType = {
+    ActivityTaskCancelRequested: "ActivityTaskCancelRequested",
+    ActivityTaskCanceled: "ActivityTaskCanceled",
+    ActivityTaskCompleted: "ActivityTaskCompleted",
+    ActivityTaskFailed: "ActivityTaskFailed",
+    ActivityTaskScheduled: "ActivityTaskScheduled",
+    ActivityTaskStarted: "ActivityTaskStarted",
+    ActivityTaskTimedOut: "ActivityTaskTimedOut",
+    CancelTimerFailed: "CancelTimerFailed",
+    CancelWorkflowExecutionFailed: "CancelWorkflowExecutionFailed",
+    ChildWorkflowExecutionCanceled: "ChildWorkflowExecutionCanceled",
+    ChildWorkflowExecutionCompleted: "ChildWorkflowExecutionCompleted",
+    ChildWorkflowExecutionFailed: "ChildWorkflowExecutionFailed",
+    ChildWorkflowExecutionStarted: "ChildWorkflowExecutionStarted",
+    ChildWorkflowExecutionTerminated: "ChildWorkflowExecutionTerminated",
+    ChildWorkflowExecutionTimedOut: "ChildWorkflowExecutionTimedOut",
+    CompleteWorkflowExecutionFailed: "CompleteWorkflowExecutionFailed",
+    ContinueAsNewWorkflowExecutionFailed: "ContinueAsNewWorkflowExecutionFailed",
+    DecisionTaskCompleted: "DecisionTaskCompleted",
+    DecisionTaskScheduled: "DecisionTaskScheduled",
+    DecisionTaskStarted: "DecisionTaskStarted",
+    DecisionTaskTimedOut: "DecisionTaskTimedOut",
+    ExternalWorkflowExecutionCancelRequested: "ExternalWorkflowExecutionCancelRequested",
+    ExternalWorkflowExecutionSignaled: "ExternalWorkflowExecutionSignaled",
+    FailWorkflowExecutionFailed: "FailWorkflowExecutionFailed",
+    LambdaFunctionCompleted: "LambdaFunctionCompleted",
+    LambdaFunctionFailed: "LambdaFunctionFailed",
+    LambdaFunctionScheduled: "LambdaFunctionScheduled",
+    LambdaFunctionStarted: "LambdaFunctionStarted",
+    LambdaFunctionTimedOut: "LambdaFunctionTimedOut",
+    MarkerRecorded: "MarkerRecorded",
+    RecordMarkerFailed: "RecordMarkerFailed",
+    RequestCancelActivityTaskFailed: "RequestCancelActivityTaskFailed",
+    RequestCancelExternalWorkflowExecutionFailed: "RequestCancelExternalWorkflowExecutionFailed",
+    RequestCancelExternalWorkflowExecutionInitiated: "RequestCancelExternalWorkflowExecutionInitiated",
+    ScheduleActivityTaskFailed: "ScheduleActivityTaskFailed",
+    ScheduleLambdaFunctionFailed: "ScheduleLambdaFunctionFailed",
+    SignalExternalWorkflowExecutionFailed: "SignalExternalWorkflowExecutionFailed",
+    SignalExternalWorkflowExecutionInitiated: "SignalExternalWorkflowExecutionInitiated",
+    StartChildWorkflowExecutionFailed: "StartChildWorkflowExecutionFailed",
+    StartChildWorkflowExecutionInitiated: "StartChildWorkflowExecutionInitiated",
+    StartLambdaFunctionFailed: "StartLambdaFunctionFailed",
+    StartTimerFailed: "StartTimerFailed",
+    TimerCanceled: "TimerCanceled",
+    TimerFired: "TimerFired",
+    TimerStarted: "TimerStarted",
+    WorkflowExecutionCancelRequested: "WorkflowExecutionCancelRequested",
+    WorkflowExecutionCanceled: "WorkflowExecutionCanceled",
+    WorkflowExecutionCompleted: "WorkflowExecutionCompleted",
+    WorkflowExecutionContinuedAsNew: "WorkflowExecutionContinuedAsNew",
+    WorkflowExecutionFailed: "WorkflowExecutionFailed",
+    WorkflowExecutionSignaled: "WorkflowExecutionSignaled",
+    WorkflowExecutionStarted: "WorkflowExecutionStarted",
+    WorkflowExecutionTerminated: "WorkflowExecutionTerminated",
+    WorkflowExecutionTimedOut: "WorkflowExecutionTimedOut",
+};
+const FailWorkflowExecutionFailedCause = {
+    OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
+    UNHANDLED_DECISION: "UNHANDLED_DECISION",
+};
+const LambdaFunctionTimeoutType = {
+    START_TO_CLOSE: "START_TO_CLOSE",
+};
+const RecordMarkerFailedCause = {
+    OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
+};
+const RequestCancelActivityTaskFailedCause = {
+    ACTIVITY_ID_UNKNOWN: "ACTIVITY_ID_UNKNOWN",
+    OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
+};
+const RequestCancelExternalWorkflowExecutionFailedCause = {
+    OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
+    REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_RATE_EXCEEDED: "REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_RATE_EXCEEDED",
+    UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION: "UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION",
+};
+const ScheduleActivityTaskFailedCause = {
+    ACTIVITY_CREATION_RATE_EXCEEDED: "ACTIVITY_CREATION_RATE_EXCEEDED",
+    ACTIVITY_ID_ALREADY_IN_USE: "ACTIVITY_ID_ALREADY_IN_USE",
+    ACTIVITY_TYPE_DEPRECATED: "ACTIVITY_TYPE_DEPRECATED",
+    ACTIVITY_TYPE_DOES_NOT_EXIST: "ACTIVITY_TYPE_DOES_NOT_EXIST",
+    DEFAULT_HEARTBEAT_TIMEOUT_UNDEFINED: "DEFAULT_HEARTBEAT_TIMEOUT_UNDEFINED",
+    DEFAULT_SCHEDULE_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_SCHEDULE_TO_CLOSE_TIMEOUT_UNDEFINED",
+    DEFAULT_SCHEDULE_TO_START_TIMEOUT_UNDEFINED: "DEFAULT_SCHEDULE_TO_START_TIMEOUT_UNDEFINED",
+    DEFAULT_START_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_START_TO_CLOSE_TIMEOUT_UNDEFINED",
+    DEFAULT_TASK_LIST_UNDEFINED: "DEFAULT_TASK_LIST_UNDEFINED",
+    OPEN_ACTIVITIES_LIMIT_EXCEEDED: "OPEN_ACTIVITIES_LIMIT_EXCEEDED",
+    OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
+};
+const ScheduleLambdaFunctionFailedCause = {
+    ID_ALREADY_IN_USE: "ID_ALREADY_IN_USE",
+    LAMBDA_FUNCTION_CREATION_RATE_EXCEEDED: "LAMBDA_FUNCTION_CREATION_RATE_EXCEEDED",
+    LAMBDA_SERVICE_NOT_AVAILABLE_IN_REGION: "LAMBDA_SERVICE_NOT_AVAILABLE_IN_REGION",
+    OPEN_LAMBDA_FUNCTIONS_LIMIT_EXCEEDED: "OPEN_LAMBDA_FUNCTIONS_LIMIT_EXCEEDED",
+};
+const SignalExternalWorkflowExecutionFailedCause = {
+    OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
+    SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_RATE_EXCEEDED: "SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_RATE_EXCEEDED",
+    UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION: "UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION",
+};
+const StartChildWorkflowExecutionFailedCause = {
+    CHILD_CREATION_RATE_EXCEEDED: "CHILD_CREATION_RATE_EXCEEDED",
+    DEFAULT_CHILD_POLICY_UNDEFINED: "DEFAULT_CHILD_POLICY_UNDEFINED",
+    DEFAULT_EXECUTION_START_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_EXECUTION_START_TO_CLOSE_TIMEOUT_UNDEFINED",
+    DEFAULT_TASK_LIST_UNDEFINED: "DEFAULT_TASK_LIST_UNDEFINED",
+    DEFAULT_TASK_START_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_TASK_START_TO_CLOSE_TIMEOUT_UNDEFINED",
+    OPEN_CHILDREN_LIMIT_EXCEEDED: "OPEN_CHILDREN_LIMIT_EXCEEDED",
+    OPEN_WORKFLOWS_LIMIT_EXCEEDED: "OPEN_WORKFLOWS_LIMIT_EXCEEDED",
+    OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
+    WORKFLOW_ALREADY_RUNNING: "WORKFLOW_ALREADY_RUNNING",
+    WORKFLOW_TYPE_DEPRECATED: "WORKFLOW_TYPE_DEPRECATED",
+    WORKFLOW_TYPE_DOES_NOT_EXIST: "WORKFLOW_TYPE_DOES_NOT_EXIST",
+};
+const StartLambdaFunctionFailedCause = {
+    ASSUME_ROLE_FAILED: "ASSUME_ROLE_FAILED",
+};
+const StartTimerFailedCause = {
+    OPEN_TIMERS_LIMIT_EXCEEDED: "OPEN_TIMERS_LIMIT_EXCEEDED",
+    OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
+    TIMER_CREATION_RATE_EXCEEDED: "TIMER_CREATION_RATE_EXCEEDED",
+    TIMER_ID_ALREADY_IN_USE: "TIMER_ID_ALREADY_IN_USE",
+};
+const WorkflowExecutionCancelRequestedCause = {
+    CHILD_POLICY_APPLIED: "CHILD_POLICY_APPLIED",
+};
+const WorkflowExecutionTerminatedCause = {
+    CHILD_POLICY_APPLIED: "CHILD_POLICY_APPLIED",
+    EVENT_LIMIT_EXCEEDED: "EVENT_LIMIT_EXCEEDED",
+    OPERATOR_INITIATED: "OPERATOR_INITIATED",
+};
+class DefaultUndefinedFault extends SWFServiceException {
+    name = "DefaultUndefinedFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DefaultUndefinedFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DefaultUndefinedFault.prototype);
+    }
+}
+class TypeNotDeprecatedFault extends SWFServiceException {
+    name = "TypeNotDeprecatedFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TypeNotDeprecatedFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TypeNotDeprecatedFault.prototype);
+    }
+}
+class TypeDeprecatedFault extends SWFServiceException {
+    name = "TypeDeprecatedFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TypeDeprecatedFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TypeDeprecatedFault.prototype);
+    }
+}
+class DomainDeprecatedFault extends SWFServiceException {
+    name = "DomainDeprecatedFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DomainDeprecatedFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DomainDeprecatedFault.prototype);
+    }
+}
+const ExecutionStatus = {
+    CLOSED: "CLOSED",
+    OPEN: "OPEN",
+};
+class DomainAlreadyExistsFault extends SWFServiceException {
+    name = "DomainAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DomainAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DomainAlreadyExistsFault.prototype);
+    }
+}
+class LimitExceededFault extends SWFServiceException {
+    name = "LimitExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "LimitExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LimitExceededFault.prototype);
+    }
+}
+class TypeAlreadyExistsFault extends SWFServiceException {
+    name = "TypeAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TypeAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TypeAlreadyExistsFault.prototype);
+    }
+}
+class TooManyTagsFault extends SWFServiceException {
+    name = "TooManyTagsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TooManyTagsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TooManyTagsFault.prototype);
+    }
+}
+class WorkflowExecutionAlreadyStartedFault extends SWFServiceException {
+    name = "WorkflowExecutionAlreadyStartedFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "WorkflowExecutionAlreadyStartedFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, WorkflowExecutionAlreadyStartedFault.prototype);
+    }
+}
 
-var SWFServiceException = class _SWFServiceException extends import_smithy_client.ServiceException {
-  static {
-    __name(this, "SWFServiceException");
-  }
-  /**
-   * @internal
-   */
-  constructor(options) {
-    super(options);
-    Object.setPrototypeOf(this, _SWFServiceException.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,
+            });
+    }
 };
-
-// src/models/models_0.ts
-var ActivityTaskTimeoutType = {
-  HEARTBEAT: "HEARTBEAT",
-  SCHEDULE_TO_CLOSE: "SCHEDULE_TO_CLOSE",
-  SCHEDULE_TO_START: "SCHEDULE_TO_START",
-  START_TO_CLOSE: "START_TO_CLOSE"
-};
-var RegistrationStatus = {
-  DEPRECATED: "DEPRECATED",
-  REGISTERED: "REGISTERED"
-};
-var CancelTimerFailedCause = {
-  OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
-  TIMER_ID_UNKNOWN: "TIMER_ID_UNKNOWN"
-};
-var CancelWorkflowExecutionFailedCause = {
-  OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
-  UNHANDLED_DECISION: "UNHANDLED_DECISION"
-};
-var ChildPolicy = {
-  ABANDON: "ABANDON",
-  REQUEST_CANCEL: "REQUEST_CANCEL",
-  TERMINATE: "TERMINATE"
-};
-var WorkflowExecutionTimeoutType = {
-  START_TO_CLOSE: "START_TO_CLOSE"
-};
-var CloseStatus = {
-  CANCELED: "CANCELED",
-  COMPLETED: "COMPLETED",
-  CONTINUED_AS_NEW: "CONTINUED_AS_NEW",
-  FAILED: "FAILED",
-  TERMINATED: "TERMINATED",
-  TIMED_OUT: "TIMED_OUT"
-};
-var CompleteWorkflowExecutionFailedCause = {
-  OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
-  UNHANDLED_DECISION: "UNHANDLED_DECISION"
-};
-var ContinueAsNewWorkflowExecutionFailedCause = {
-  CONTINUE_AS_NEW_WORKFLOW_EXECUTION_RATE_EXCEEDED: "CONTINUE_AS_NEW_WORKFLOW_EXECUTION_RATE_EXCEEDED",
-  DEFAULT_CHILD_POLICY_UNDEFINED: "DEFAULT_CHILD_POLICY_UNDEFINED",
-  DEFAULT_EXECUTION_START_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_EXECUTION_START_TO_CLOSE_TIMEOUT_UNDEFINED",
-  DEFAULT_TASK_LIST_UNDEFINED: "DEFAULT_TASK_LIST_UNDEFINED",
-  DEFAULT_TASK_START_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_TASK_START_TO_CLOSE_TIMEOUT_UNDEFINED",
-  OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
-  UNHANDLED_DECISION: "UNHANDLED_DECISION",
-  WORKFLOW_TYPE_DEPRECATED: "WORKFLOW_TYPE_DEPRECATED",
-  WORKFLOW_TYPE_DOES_NOT_EXIST: "WORKFLOW_TYPE_DOES_NOT_EXIST"
-};
-var OperationNotPermittedFault = class _OperationNotPermittedFault extends SWFServiceException {
-  static {
-    __name(this, "OperationNotPermittedFault");
-  }
-  name = "OperationNotPermittedFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "OperationNotPermittedFault",
-      $fault: "client",
-      ...opts
+const de_DefaultUndefinedFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new DefaultUndefinedFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _OperationNotPermittedFault.prototype);
-  }
-};
-var UnknownResourceFault = class _UnknownResourceFault extends SWFServiceException {
-  static {
-    __name(this, "UnknownResourceFault");
-  }
-  name = "UnknownResourceFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "UnknownResourceFault",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _UnknownResourceFault.prototype);
-  }
-};
-var DecisionType = {
-  CancelTimer: "CancelTimer",
-  CancelWorkflowExecution: "CancelWorkflowExecution",
-  CompleteWorkflowExecution: "CompleteWorkflowExecution",
-  ContinueAsNewWorkflowExecution: "ContinueAsNewWorkflowExecution",
-  FailWorkflowExecution: "FailWorkflowExecution",
-  RecordMarker: "RecordMarker",
-  RequestCancelActivityTask: "RequestCancelActivityTask",
-  RequestCancelExternalWorkflowExecution: "RequestCancelExternalWorkflowExecution",
-  ScheduleActivityTask: "ScheduleActivityTask",
-  ScheduleLambdaFunction: "ScheduleLambdaFunction",
-  SignalExternalWorkflowExecution: "SignalExternalWorkflowExecution",
-  StartChildWorkflowExecution: "StartChildWorkflowExecution",
-  StartTimer: "StartTimer"
-};
-var DecisionTaskTimeoutType = {
-  SCHEDULE_TO_START: "SCHEDULE_TO_START",
-  START_TO_CLOSE: "START_TO_CLOSE"
-};
-var EventType = {
-  ActivityTaskCancelRequested: "ActivityTaskCancelRequested",
-  ActivityTaskCanceled: "ActivityTaskCanceled",
-  ActivityTaskCompleted: "ActivityTaskCompleted",
-  ActivityTaskFailed: "ActivityTaskFailed",
-  ActivityTaskScheduled: "ActivityTaskScheduled",
-  ActivityTaskStarted: "ActivityTaskStarted",
-  ActivityTaskTimedOut: "ActivityTaskTimedOut",
-  CancelTimerFailed: "CancelTimerFailed",
-  CancelWorkflowExecutionFailed: "CancelWorkflowExecutionFailed",
-  ChildWorkflowExecutionCanceled: "ChildWorkflowExecutionCanceled",
-  ChildWorkflowExecutionCompleted: "ChildWorkflowExecutionCompleted",
-  ChildWorkflowExecutionFailed: "ChildWorkflowExecutionFailed",
-  ChildWorkflowExecutionStarted: "ChildWorkflowExecutionStarted",
-  ChildWorkflowExecutionTerminated: "ChildWorkflowExecutionTerminated",
-  ChildWorkflowExecutionTimedOut: "ChildWorkflowExecutionTimedOut",
-  CompleteWorkflowExecutionFailed: "CompleteWorkflowExecutionFailed",
-  ContinueAsNewWorkflowExecutionFailed: "ContinueAsNewWorkflowExecutionFailed",
-  DecisionTaskCompleted: "DecisionTaskCompleted",
-  DecisionTaskScheduled: "DecisionTaskScheduled",
-  DecisionTaskStarted: "DecisionTaskStarted",
-  DecisionTaskTimedOut: "DecisionTaskTimedOut",
-  ExternalWorkflowExecutionCancelRequested: "ExternalWorkflowExecutionCancelRequested",
-  ExternalWorkflowExecutionSignaled: "ExternalWorkflowExecutionSignaled",
-  FailWorkflowExecutionFailed: "FailWorkflowExecutionFailed",
-  LambdaFunctionCompleted: "LambdaFunctionCompleted",
-  LambdaFunctionFailed: "LambdaFunctionFailed",
-  LambdaFunctionScheduled: "LambdaFunctionScheduled",
-  LambdaFunctionStarted: "LambdaFunctionStarted",
-  LambdaFunctionTimedOut: "LambdaFunctionTimedOut",
-  MarkerRecorded: "MarkerRecorded",
-  RecordMarkerFailed: "RecordMarkerFailed",
-  RequestCancelActivityTaskFailed: "RequestCancelActivityTaskFailed",
-  RequestCancelExternalWorkflowExecutionFailed: "RequestCancelExternalWorkflowExecutionFailed",
-  RequestCancelExternalWorkflowExecutionInitiated: "RequestCancelExternalWorkflowExecutionInitiated",
-  ScheduleActivityTaskFailed: "ScheduleActivityTaskFailed",
-  ScheduleLambdaFunctionFailed: "ScheduleLambdaFunctionFailed",
-  SignalExternalWorkflowExecutionFailed: "SignalExternalWorkflowExecutionFailed",
-  SignalExternalWorkflowExecutionInitiated: "SignalExternalWorkflowExecutionInitiated",
-  StartChildWorkflowExecutionFailed: "StartChildWorkflowExecutionFailed",
-  StartChildWorkflowExecutionInitiated: "StartChildWorkflowExecutionInitiated",
-  StartLambdaFunctionFailed: "StartLambdaFunctionFailed",
-  StartTimerFailed: "StartTimerFailed",
-  TimerCanceled: "TimerCanceled",
-  TimerFired: "TimerFired",
-  TimerStarted: "TimerStarted",
-  WorkflowExecutionCancelRequested: "WorkflowExecutionCancelRequested",
-  WorkflowExecutionCanceled: "WorkflowExecutionCanceled",
-  WorkflowExecutionCompleted: "WorkflowExecutionCompleted",
-  WorkflowExecutionContinuedAsNew: "WorkflowExecutionContinuedAsNew",
-  WorkflowExecutionFailed: "WorkflowExecutionFailed",
-  WorkflowExecutionSignaled: "WorkflowExecutionSignaled",
-  WorkflowExecutionStarted: "WorkflowExecutionStarted",
-  WorkflowExecutionTerminated: "WorkflowExecutionTerminated",
-  WorkflowExecutionTimedOut: "WorkflowExecutionTimedOut"
-};
-var FailWorkflowExecutionFailedCause = {
-  OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
-  UNHANDLED_DECISION: "UNHANDLED_DECISION"
-};
-var LambdaFunctionTimeoutType = {
-  START_TO_CLOSE: "START_TO_CLOSE"
-};
-var RecordMarkerFailedCause = {
-  OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED"
-};
-var RequestCancelActivityTaskFailedCause = {
-  ACTIVITY_ID_UNKNOWN: "ACTIVITY_ID_UNKNOWN",
-  OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED"
-};
-var RequestCancelExternalWorkflowExecutionFailedCause = {
-  OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
-  REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_RATE_EXCEEDED: "REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_RATE_EXCEEDED",
-  UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION: "UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION"
-};
-var ScheduleActivityTaskFailedCause = {
-  ACTIVITY_CREATION_RATE_EXCEEDED: "ACTIVITY_CREATION_RATE_EXCEEDED",
-  ACTIVITY_ID_ALREADY_IN_USE: "ACTIVITY_ID_ALREADY_IN_USE",
-  ACTIVITY_TYPE_DEPRECATED: "ACTIVITY_TYPE_DEPRECATED",
-  ACTIVITY_TYPE_DOES_NOT_EXIST: "ACTIVITY_TYPE_DOES_NOT_EXIST",
-  DEFAULT_HEARTBEAT_TIMEOUT_UNDEFINED: "DEFAULT_HEARTBEAT_TIMEOUT_UNDEFINED",
-  DEFAULT_SCHEDULE_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_SCHEDULE_TO_CLOSE_TIMEOUT_UNDEFINED",
-  DEFAULT_SCHEDULE_TO_START_TIMEOUT_UNDEFINED: "DEFAULT_SCHEDULE_TO_START_TIMEOUT_UNDEFINED",
-  DEFAULT_START_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_START_TO_CLOSE_TIMEOUT_UNDEFINED",
-  DEFAULT_TASK_LIST_UNDEFINED: "DEFAULT_TASK_LIST_UNDEFINED",
-  OPEN_ACTIVITIES_LIMIT_EXCEEDED: "OPEN_ACTIVITIES_LIMIT_EXCEEDED",
-  OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED"
-};
-var ScheduleLambdaFunctionFailedCause = {
-  ID_ALREADY_IN_USE: "ID_ALREADY_IN_USE",
-  LAMBDA_FUNCTION_CREATION_RATE_EXCEEDED: "LAMBDA_FUNCTION_CREATION_RATE_EXCEEDED",
-  LAMBDA_SERVICE_NOT_AVAILABLE_IN_REGION: "LAMBDA_SERVICE_NOT_AVAILABLE_IN_REGION",
-  OPEN_LAMBDA_FUNCTIONS_LIMIT_EXCEEDED: "OPEN_LAMBDA_FUNCTIONS_LIMIT_EXCEEDED"
-};
-var SignalExternalWorkflowExecutionFailedCause = {
-  OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
-  SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_RATE_EXCEEDED: "SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_RATE_EXCEEDED",
-  UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION: "UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION"
-};
-var StartChildWorkflowExecutionFailedCause = {
-  CHILD_CREATION_RATE_EXCEEDED: "CHILD_CREATION_RATE_EXCEEDED",
-  DEFAULT_CHILD_POLICY_UNDEFINED: "DEFAULT_CHILD_POLICY_UNDEFINED",
-  DEFAULT_EXECUTION_START_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_EXECUTION_START_TO_CLOSE_TIMEOUT_UNDEFINED",
-  DEFAULT_TASK_LIST_UNDEFINED: "DEFAULT_TASK_LIST_UNDEFINED",
-  DEFAULT_TASK_START_TO_CLOSE_TIMEOUT_UNDEFINED: "DEFAULT_TASK_START_TO_CLOSE_TIMEOUT_UNDEFINED",
-  OPEN_CHILDREN_LIMIT_EXCEEDED: "OPEN_CHILDREN_LIMIT_EXCEEDED",
-  OPEN_WORKFLOWS_LIMIT_EXCEEDED: "OPEN_WORKFLOWS_LIMIT_EXCEEDED",
-  OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
-  WORKFLOW_ALREADY_RUNNING: "WORKFLOW_ALREADY_RUNNING",
-  WORKFLOW_TYPE_DEPRECATED: "WORKFLOW_TYPE_DEPRECATED",
-  WORKFLOW_TYPE_DOES_NOT_EXIST: "WORKFLOW_TYPE_DOES_NOT_EXIST"
-};
-var StartLambdaFunctionFailedCause = {
-  ASSUME_ROLE_FAILED: "ASSUME_ROLE_FAILED"
-};
-var StartTimerFailedCause = {
-  OPEN_TIMERS_LIMIT_EXCEEDED: "OPEN_TIMERS_LIMIT_EXCEEDED",
-  OPERATION_NOT_PERMITTED: "OPERATION_NOT_PERMITTED",
-  TIMER_CREATION_RATE_EXCEEDED: "TIMER_CREATION_RATE_EXCEEDED",
-  TIMER_ID_ALREADY_IN_USE: "TIMER_ID_ALREADY_IN_USE"
-};
-var WorkflowExecutionCancelRequestedCause = {
-  CHILD_POLICY_APPLIED: "CHILD_POLICY_APPLIED"
-};
-var WorkflowExecutionTerminatedCause = {
-  CHILD_POLICY_APPLIED: "CHILD_POLICY_APPLIED",
-  EVENT_LIMIT_EXCEEDED: "EVENT_LIMIT_EXCEEDED",
-  OPERATOR_INITIATED: "OPERATOR_INITIATED"
-};
-var DefaultUndefinedFault = class _DefaultUndefinedFault extends SWFServiceException {
-  static {
-    __name(this, "DefaultUndefinedFault");
-  }
-  name = "DefaultUndefinedFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "DefaultUndefinedFault",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _DefaultUndefinedFault.prototype);
-  }
-};
-var TypeNotDeprecatedFault = class _TypeNotDeprecatedFault extends SWFServiceException {
-  static {
-    __name(this, "TypeNotDeprecatedFault");
-  }
-  name = "TypeNotDeprecatedFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "TypeNotDeprecatedFault",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _TypeNotDeprecatedFault.prototype);
-  }
-};
-var TypeDeprecatedFault = class _TypeDeprecatedFault extends SWFServiceException {
-  static {
-    __name(this, "TypeDeprecatedFault");
-  }
-  name = "TypeDeprecatedFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "TypeDeprecatedFault",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _TypeDeprecatedFault.prototype);
-  }
-};
-var DomainDeprecatedFault = class _DomainDeprecatedFault extends SWFServiceException {
-  static {
-    __name(this, "DomainDeprecatedFault");
-  }
-  name = "DomainDeprecatedFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "DomainDeprecatedFault",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _DomainDeprecatedFault.prototype);
-  }
-};
-var ExecutionStatus = {
-  CLOSED: "CLOSED",
-  OPEN: "OPEN"
-};
-var DomainAlreadyExistsFault = class _DomainAlreadyExistsFault extends SWFServiceException {
-  static {
-    __name(this, "DomainAlreadyExistsFault");
-  }
-  name = "DomainAlreadyExistsFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "DomainAlreadyExistsFault",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _DomainAlreadyExistsFault.prototype);
-  }
-};
-var LimitExceededFault = class _LimitExceededFault extends SWFServiceException {
-  static {
-    __name(this, "LimitExceededFault");
-  }
-  name = "LimitExceededFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "LimitExceededFault",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _LimitExceededFault.prototype);
-  }
-};
-var TypeAlreadyExistsFault = class _TypeAlreadyExistsFault extends SWFServiceException {
-  static {
-    __name(this, "TypeAlreadyExistsFault");
-  }
-  name = "TypeAlreadyExistsFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "TypeAlreadyExistsFault",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _TypeAlreadyExistsFault.prototype);
-  }
-};
-var TooManyTagsFault = class _TooManyTagsFault extends SWFServiceException {
-  static {
-    __name(this, "TooManyTagsFault");
-  }
-  name = "TooManyTagsFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "TooManyTagsFault",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _TooManyTagsFault.prototype);
-  }
-};
-var WorkflowExecutionAlreadyStartedFault = class _WorkflowExecutionAlreadyStartedFault extends SWFServiceException {
-  static {
-    __name(this, "WorkflowExecutionAlreadyStartedFault");
-  }
-  name = "WorkflowExecutionAlreadyStartedFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "WorkflowExecutionAlreadyStartedFault",
-      $fault: "client",
-      ...opts
+    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,
     });
-    Object.setPrototypeOf(this, _WorkflowExecutionAlreadyStartedFault.prototype);
-  }
-};
-
-// src/protocols/Aws_json1_0.ts
-var se_CountClosedWorkflowExecutionsCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("CountClosedWorkflowExecutions");
-  let body;
-  body = JSON.stringify(se_CountClosedWorkflowExecutionsInput(input, context));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_CountClosedWorkflowExecutionsCommand");
-var se_CountOpenWorkflowExecutionsCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("CountOpenWorkflowExecutions");
-  let body;
-  body = JSON.stringify(se_CountOpenWorkflowExecutionsInput(input, context));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_CountOpenWorkflowExecutionsCommand");
-var se_CountPendingActivityTasksCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("CountPendingActivityTasks");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_CountPendingActivityTasksCommand");
-var se_CountPendingDecisionTasksCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("CountPendingDecisionTasks");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_CountPendingDecisionTasksCommand");
-var se_DeleteActivityTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DeleteActivityType");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DeleteActivityTypeCommand");
-var se_DeleteWorkflowTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DeleteWorkflowType");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DeleteWorkflowTypeCommand");
-var se_DeprecateActivityTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DeprecateActivityType");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DeprecateActivityTypeCommand");
-var se_DeprecateDomainCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DeprecateDomain");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DeprecateDomainCommand");
-var se_DeprecateWorkflowTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DeprecateWorkflowType");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DeprecateWorkflowTypeCommand");
-var se_DescribeActivityTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DescribeActivityType");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DescribeActivityTypeCommand");
-var se_DescribeDomainCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DescribeDomain");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DescribeDomainCommand");
-var se_DescribeWorkflowExecutionCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DescribeWorkflowExecution");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DescribeWorkflowExecutionCommand");
-var se_DescribeWorkflowTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DescribeWorkflowType");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DescribeWorkflowTypeCommand");
-var se_GetWorkflowExecutionHistoryCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("GetWorkflowExecutionHistory");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_GetWorkflowExecutionHistoryCommand");
-var se_ListActivityTypesCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("ListActivityTypes");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_ListActivityTypesCommand");
-var se_ListClosedWorkflowExecutionsCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("ListClosedWorkflowExecutions");
-  let body;
-  body = JSON.stringify(se_ListClosedWorkflowExecutionsInput(input, context));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_ListClosedWorkflowExecutionsCommand");
-var se_ListDomainsCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("ListDomains");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_ListDomainsCommand");
-var se_ListOpenWorkflowExecutionsCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("ListOpenWorkflowExecutions");
-  let body;
-  body = JSON.stringify(se_ListOpenWorkflowExecutionsInput(input, context));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_ListOpenWorkflowExecutionsCommand");
-var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("ListTagsForResource");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_ListTagsForResourceCommand");
-var se_ListWorkflowTypesCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("ListWorkflowTypes");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_ListWorkflowTypesCommand");
-var se_PollForActivityTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("PollForActivityTask");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_PollForActivityTaskCommand");
-var se_PollForDecisionTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("PollForDecisionTask");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_PollForDecisionTaskCommand");
-var se_RecordActivityTaskHeartbeatCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("RecordActivityTaskHeartbeat");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_RecordActivityTaskHeartbeatCommand");
-var se_RegisterActivityTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("RegisterActivityType");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_RegisterActivityTypeCommand");
-var se_RegisterDomainCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("RegisterDomain");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_RegisterDomainCommand");
-var se_RegisterWorkflowTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("RegisterWorkflowType");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_RegisterWorkflowTypeCommand");
-var se_RequestCancelWorkflowExecutionCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("RequestCancelWorkflowExecution");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_RequestCancelWorkflowExecutionCommand");
-var se_RespondActivityTaskCanceledCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("RespondActivityTaskCanceled");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_RespondActivityTaskCanceledCommand");
-var se_RespondActivityTaskCompletedCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("RespondActivityTaskCompleted");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_RespondActivityTaskCompletedCommand");
-var se_RespondActivityTaskFailedCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("RespondActivityTaskFailed");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_RespondActivityTaskFailedCommand");
-var se_RespondDecisionTaskCompletedCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("RespondDecisionTaskCompleted");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_RespondDecisionTaskCompletedCommand");
-var se_SignalWorkflowExecutionCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("SignalWorkflowExecution");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_SignalWorkflowExecutionCommand");
-var se_StartWorkflowExecutionCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("StartWorkflowExecution");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_StartWorkflowExecutionCommand");
-var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("TagResource");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_TagResourceCommand");
-var se_TerminateWorkflowExecutionCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("TerminateWorkflowExecution");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_TerminateWorkflowExecutionCommand");
-var se_UndeprecateActivityTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("UndeprecateActivityType");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_UndeprecateActivityTypeCommand");
-var se_UndeprecateDomainCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("UndeprecateDomain");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_UndeprecateDomainCommand");
-var se_UndeprecateWorkflowTypeCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("UndeprecateWorkflowType");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_UndeprecateWorkflowTypeCommand");
-var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("UntagResource");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_UntagResourceCommand");
-var de_CountClosedWorkflowExecutionsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CountClosedWorkflowExecutionsCommand");
-var de_CountOpenWorkflowExecutionsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CountOpenWorkflowExecutionsCommand");
-var de_CountPendingActivityTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CountPendingActivityTasksCommand");
-var de_CountPendingDecisionTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CountPendingDecisionTasksCommand");
-var de_DeleteActivityTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_DeleteActivityTypeCommand");
-var de_DeleteWorkflowTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_DeleteWorkflowTypeCommand");
-var de_DeprecateActivityTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_DeprecateActivityTypeCommand");
-var de_DeprecateDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_DeprecateDomainCommand");
-var de_DeprecateWorkflowTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_DeprecateWorkflowTypeCommand");
-var de_DescribeActivityTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_ActivityTypeDetail(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeActivityTypeCommand");
-var de_DescribeDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeDomainCommand");
-var de_DescribeWorkflowExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_WorkflowExecutionDetail(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeWorkflowExecutionCommand");
-var de_DescribeWorkflowTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_WorkflowTypeDetail(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeWorkflowTypeCommand");
-var de_GetWorkflowExecutionHistoryCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_History(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_GetWorkflowExecutionHistoryCommand");
-var de_ListActivityTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_ActivityTypeInfos(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListActivityTypesCommand");
-var de_ListClosedWorkflowExecutionsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_WorkflowExecutionInfos(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListClosedWorkflowExecutionsCommand");
-var de_ListDomainsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListDomainsCommand");
-var de_ListOpenWorkflowExecutionsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_WorkflowExecutionInfos(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListOpenWorkflowExecutionsCommand");
-var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListTagsForResourceCommand");
-var de_ListWorkflowTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_WorkflowTypeInfos(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListWorkflowTypesCommand");
-var de_PollForActivityTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_PollForActivityTaskCommand");
-var de_PollForDecisionTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_DecisionTask(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_PollForDecisionTaskCommand");
-var de_RecordActivityTaskHeartbeatCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_RecordActivityTaskHeartbeatCommand");
-var de_RegisterActivityTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_RegisterActivityTypeCommand");
-var de_RegisterDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_RegisterDomainCommand");
-var de_RegisterWorkflowTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_RegisterWorkflowTypeCommand");
-var de_RequestCancelWorkflowExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_RequestCancelWorkflowExecutionCommand");
-var de_RespondActivityTaskCanceledCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_RespondActivityTaskCanceledCommand");
-var de_RespondActivityTaskCompletedCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_RespondActivityTaskCompletedCommand");
-var de_RespondActivityTaskFailedCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_RespondActivityTaskFailedCommand");
-var de_RespondDecisionTaskCompletedCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_RespondDecisionTaskCompletedCommand");
-var de_SignalWorkflowExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_SignalWorkflowExecutionCommand");
-var de_StartWorkflowExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_StartWorkflowExecutionCommand");
-var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_TagResourceCommand");
-var de_TerminateWorkflowExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_TerminateWorkflowExecutionCommand");
-var de_UndeprecateActivityTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_UndeprecateActivityTypeCommand");
-var de_UndeprecateDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_UndeprecateDomainCommand");
-var de_UndeprecateWorkflowTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_UndeprecateWorkflowTypeCommand");
-var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  await (0, import_smithy_client.collectBody)(output.body, context);
-  const response = {
-    $metadata: deserializeMetadata(output)
-  };
-  return response;
-}, "de_UntagResourceCommand");
-var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
-  const parsedOutput = {
-    ...output,
-    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
-  };
-  const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
-  switch (errorCode) {
-    case "OperationNotPermittedFault":
-    case "com.amazonaws.swf#OperationNotPermittedFault":
-      throw await de_OperationNotPermittedFaultRes(parsedOutput, context);
-    case "UnknownResourceFault":
-    case "com.amazonaws.swf#UnknownResourceFault":
-      throw await de_UnknownResourceFaultRes(parsedOutput, context);
-    case "TypeNotDeprecatedFault":
-    case "com.amazonaws.swf#TypeNotDeprecatedFault":
-      throw await de_TypeNotDeprecatedFaultRes(parsedOutput, context);
-    case "TypeDeprecatedFault":
-    case "com.amazonaws.swf#TypeDeprecatedFault":
-      throw await de_TypeDeprecatedFaultRes(parsedOutput, context);
-    case "DomainDeprecatedFault":
-    case "com.amazonaws.swf#DomainDeprecatedFault":
-      throw await de_DomainDeprecatedFaultRes(parsedOutput, context);
-    case "LimitExceededFault":
-    case "com.amazonaws.swf#LimitExceededFault":
-      throw await de_LimitExceededFaultRes(parsedOutput, context);
-    case "TypeAlreadyExistsFault":
-    case "com.amazonaws.swf#TypeAlreadyExistsFault":
-      throw await de_TypeAlreadyExistsFaultRes(parsedOutput, context);
-    case "DomainAlreadyExistsFault":
-    case "com.amazonaws.swf#DomainAlreadyExistsFault":
-      throw await de_DomainAlreadyExistsFaultRes(parsedOutput, context);
-    case "TooManyTagsFault":
-    case "com.amazonaws.swf#TooManyTagsFault":
-      throw await de_TooManyTagsFaultRes(parsedOutput, context);
-    case "DefaultUndefinedFault":
-    case "com.amazonaws.swf#DefaultUndefinedFault":
-      throw await de_DefaultUndefinedFaultRes(parsedOutput, context);
-    case "WorkflowExecutionAlreadyStartedFault":
-    case "com.amazonaws.swf#WorkflowExecutionAlreadyStartedFault":
-      throw await de_WorkflowExecutionAlreadyStartedFaultRes(parsedOutput, context);
-    default:
-      const parsedBody = parsedOutput.body;
-      return throwDefaultError({
-        output,
-        parsedBody,
-        errorCode
-      });
-  }
-}, "de_CommandError");
-var de_DefaultUndefinedFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new DefaultUndefinedFault({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_DefaultUndefinedFaultRes");
-var de_DomainAlreadyExistsFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new DomainAlreadyExistsFault({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_DomainAlreadyExistsFaultRes");
-var de_DomainDeprecatedFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new DomainDeprecatedFault({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_DomainDeprecatedFaultRes");
-var de_LimitExceededFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new LimitExceededFault({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_LimitExceededFaultRes");
-var de_OperationNotPermittedFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new OperationNotPermittedFault({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_OperationNotPermittedFaultRes");
-var de_TooManyTagsFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new TooManyTagsFault({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_TooManyTagsFaultRes");
-var de_TypeAlreadyExistsFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new TypeAlreadyExistsFault({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_TypeAlreadyExistsFaultRes");
-var de_TypeDeprecatedFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new TypeDeprecatedFault({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_TypeDeprecatedFaultRes");
-var de_TypeNotDeprecatedFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new TypeNotDeprecatedFault({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_TypeNotDeprecatedFaultRes");
-var de_UnknownResourceFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new UnknownResourceFault({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_UnknownResourceFaultRes");
-var de_WorkflowExecutionAlreadyStartedFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new WorkflowExecutionAlreadyStartedFault({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_WorkflowExecutionAlreadyStartedFaultRes");
-var se_CountClosedWorkflowExecutionsInput = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    closeStatusFilter: import_smithy_client._json,
-    closeTimeFilter: /* @__PURE__ */ __name((_) => se_ExecutionTimeFilter(_, context), "closeTimeFilter"),
-    domain: [],
-    executionFilter: import_smithy_client._json,
-    startTimeFilter: /* @__PURE__ */ __name((_) => se_ExecutionTimeFilter(_, context), "startTimeFilter"),
-    tagFilter: import_smithy_client._json,
-    typeFilter: import_smithy_client._json
-  });
-}, "se_CountClosedWorkflowExecutionsInput");
-var se_CountOpenWorkflowExecutionsInput = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    domain: [],
-    executionFilter: import_smithy_client._json,
-    startTimeFilter: /* @__PURE__ */ __name((_) => se_ExecutionTimeFilter(_, context), "startTimeFilter"),
-    tagFilter: import_smithy_client._json,
-    typeFilter: import_smithy_client._json
-  });
-}, "se_CountOpenWorkflowExecutionsInput");
-var se_ExecutionTimeFilter = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    latestDate: /* @__PURE__ */ __name((_) => _.getTime() / 1e3, "latestDate"),
-    oldestDate: /* @__PURE__ */ __name((_) => _.getTime() / 1e3, "oldestDate")
-  });
-}, "se_ExecutionTimeFilter");
-var se_ListClosedWorkflowExecutionsInput = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    closeStatusFilter: import_smithy_client._json,
-    closeTimeFilter: /* @__PURE__ */ __name((_) => se_ExecutionTimeFilter(_, context), "closeTimeFilter"),
-    domain: [],
-    executionFilter: import_smithy_client._json,
-    maximumPageSize: [],
-    nextPageToken: [],
-    reverseOrder: [],
-    startTimeFilter: /* @__PURE__ */ __name((_) => se_ExecutionTimeFilter(_, context), "startTimeFilter"),
-    tagFilter: import_smithy_client._json,
-    typeFilter: import_smithy_client._json
-  });
-}, "se_ListClosedWorkflowExecutionsInput");
-var se_ListOpenWorkflowExecutionsInput = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    domain: [],
-    executionFilter: import_smithy_client._json,
-    maximumPageSize: [],
-    nextPageToken: [],
-    reverseOrder: [],
-    startTimeFilter: /* @__PURE__ */ __name((_) => se_ExecutionTimeFilter(_, context), "startTimeFilter"),
-    tagFilter: import_smithy_client._json,
-    typeFilter: import_smithy_client._json
-  });
-}, "se_ListOpenWorkflowExecutionsInput");
-var de_ActivityTypeDetail = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    configuration: import_smithy_client._json,
-    typeInfo: /* @__PURE__ */ __name((_) => de_ActivityTypeInfo(_, context), "typeInfo")
-  });
-}, "de_ActivityTypeDetail");
-var de_ActivityTypeInfo = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    activityType: import_smithy_client._json,
-    creationDate: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "creationDate"),
-    deprecationDate: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "deprecationDate"),
-    description: import_smithy_client.expectString,
-    status: import_smithy_client.expectString
-  });
-}, "de_ActivityTypeInfo");
-var de_ActivityTypeInfoList = /* @__PURE__ */ __name((output, context) => {
-  const retVal = (output || []).filter((e) => e != null).map((entry) => {
-    return de_ActivityTypeInfo(entry, context);
-  });
-  return retVal;
-}, "de_ActivityTypeInfoList");
-var de_ActivityTypeInfos = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    nextPageToken: import_smithy_client.expectString,
-    typeInfos: /* @__PURE__ */ __name((_) => de_ActivityTypeInfoList(_, context), "typeInfos")
-  });
-}, "de_ActivityTypeInfos");
-var de_DecisionTask = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    events: /* @__PURE__ */ __name((_) => de_HistoryEventList(_, context), "events"),
-    nextPageToken: import_smithy_client.expectString,
-    previousStartedEventId: import_smithy_client.expectLong,
-    startedEventId: import_smithy_client.expectLong,
-    taskToken: import_smithy_client.expectString,
-    workflowExecution: import_smithy_client._json,
-    workflowType: import_smithy_client._json
-  });
-}, "de_DecisionTask");
-var de_History = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    events: /* @__PURE__ */ __name((_) => de_HistoryEventList(_, context), "events"),
-    nextPageToken: import_smithy_client.expectString
-  });
-}, "de_History");
-var de_HistoryEvent = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    activityTaskCancelRequestedEventAttributes: import_smithy_client._json,
-    activityTaskCanceledEventAttributes: import_smithy_client._json,
-    activityTaskCompletedEventAttributes: import_smithy_client._json,
-    activityTaskFailedEventAttributes: import_smithy_client._json,
-    activityTaskScheduledEventAttributes: import_smithy_client._json,
-    activityTaskStartedEventAttributes: import_smithy_client._json,
-    activityTaskTimedOutEventAttributes: import_smithy_client._json,
-    cancelTimerFailedEventAttributes: import_smithy_client._json,
-    cancelWorkflowExecutionFailedEventAttributes: import_smithy_client._json,
-    childWorkflowExecutionCanceledEventAttributes: import_smithy_client._json,
-    childWorkflowExecutionCompletedEventAttributes: import_smithy_client._json,
-    childWorkflowExecutionFailedEventAttributes: import_smithy_client._json,
-    childWorkflowExecutionStartedEventAttributes: import_smithy_client._json,
-    childWorkflowExecutionTerminatedEventAttributes: import_smithy_client._json,
-    childWorkflowExecutionTimedOutEventAttributes: import_smithy_client._json,
-    completeWorkflowExecutionFailedEventAttributes: import_smithy_client._json,
-    continueAsNewWorkflowExecutionFailedEventAttributes: import_smithy_client._json,
-    decisionTaskCompletedEventAttributes: import_smithy_client._json,
-    decisionTaskScheduledEventAttributes: import_smithy_client._json,
-    decisionTaskStartedEventAttributes: import_smithy_client._json,
-    decisionTaskTimedOutEventAttributes: import_smithy_client._json,
-    eventId: import_smithy_client.expectLong,
-    eventTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "eventTimestamp"),
-    eventType: import_smithy_client.expectString,
-    externalWorkflowExecutionCancelRequestedEventAttributes: import_smithy_client._json,
-    externalWorkflowExecutionSignaledEventAttributes: import_smithy_client._json,
-    failWorkflowExecutionFailedEventAttributes: import_smithy_client._json,
-    lambdaFunctionCompletedEventAttributes: import_smithy_client._json,
-    lambdaFunctionFailedEventAttributes: import_smithy_client._json,
-    lambdaFunctionScheduledEventAttributes: import_smithy_client._json,
-    lambdaFunctionStartedEventAttributes: import_smithy_client._json,
-    lambdaFunctionTimedOutEventAttributes: import_smithy_client._json,
-    markerRecordedEventAttributes: import_smithy_client._json,
-    recordMarkerFailedEventAttributes: import_smithy_client._json,
-    requestCancelActivityTaskFailedEventAttributes: import_smithy_client._json,
-    requestCancelExternalWorkflowExecutionFailedEventAttributes: import_smithy_client._json,
-    requestCancelExternalWorkflowExecutionInitiatedEventAttributes: import_smithy_client._json,
-    scheduleActivityTaskFailedEventAttributes: import_smithy_client._json,
-    scheduleLambdaFunctionFailedEventAttributes: import_smithy_client._json,
-    signalExternalWorkflowExecutionFailedEventAttributes: import_smithy_client._json,
-    signalExternalWorkflowExecutionInitiatedEventAttributes: import_smithy_client._json,
-    startChildWorkflowExecutionFailedEventAttributes: import_smithy_client._json,
-    startChildWorkflowExecutionInitiatedEventAttributes: import_smithy_client._json,
-    startLambdaFunctionFailedEventAttributes: import_smithy_client._json,
-    startTimerFailedEventAttributes: import_smithy_client._json,
-    timerCanceledEventAttributes: import_smithy_client._json,
-    timerFiredEventAttributes: import_smithy_client._json,
-    timerStartedEventAttributes: import_smithy_client._json,
-    workflowExecutionCancelRequestedEventAttributes: import_smithy_client._json,
-    workflowExecutionCanceledEventAttributes: import_smithy_client._json,
-    workflowExecutionCompletedEventAttributes: import_smithy_client._json,
-    workflowExecutionContinuedAsNewEventAttributes: import_smithy_client._json,
-    workflowExecutionFailedEventAttributes: import_smithy_client._json,
-    workflowExecutionSignaledEventAttributes: import_smithy_client._json,
-    workflowExecutionStartedEventAttributes: import_smithy_client._json,
-    workflowExecutionTerminatedEventAttributes: import_smithy_client._json,
-    workflowExecutionTimedOutEventAttributes: import_smithy_client._json
-  });
-}, "de_HistoryEvent");
-var de_HistoryEventList = /* @__PURE__ */ __name((output, context) => {
-  const retVal = (output || []).filter((e) => e != null).map((entry) => {
-    return de_HistoryEvent(entry, context);
-  });
-  return retVal;
-}, "de_HistoryEventList");
-var de_WorkflowExecutionDetail = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    executionConfiguration: import_smithy_client._json,
-    executionInfo: /* @__PURE__ */ __name((_) => de_WorkflowExecutionInfo(_, context), "executionInfo"),
-    latestActivityTaskTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "latestActivityTaskTimestamp"),
-    latestExecutionContext: import_smithy_client.expectString,
-    openCounts: import_smithy_client._json
-  });
-}, "de_WorkflowExecutionDetail");
-var de_WorkflowExecutionInfo = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    cancelRequested: import_smithy_client.expectBoolean,
-    closeStatus: import_smithy_client.expectString,
-    closeTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "closeTimestamp"),
-    execution: import_smithy_client._json,
-    executionStatus: import_smithy_client.expectString,
-    parent: import_smithy_client._json,
-    startTimestamp: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "startTimestamp"),
-    tagList: import_smithy_client._json,
-    workflowType: import_smithy_client._json
-  });
-}, "de_WorkflowExecutionInfo");
-var de_WorkflowExecutionInfoList = /* @__PURE__ */ __name((output, context) => {
-  const retVal = (output || []).filter((e) => e != null).map((entry) => {
-    return de_WorkflowExecutionInfo(entry, context);
-  });
-  return retVal;
-}, "de_WorkflowExecutionInfoList");
-var de_WorkflowExecutionInfos = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    executionInfos: /* @__PURE__ */ __name((_) => de_WorkflowExecutionInfoList(_, context), "executionInfos"),
-    nextPageToken: import_smithy_client.expectString
-  });
-}, "de_WorkflowExecutionInfos");
-var de_WorkflowTypeDetail = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    configuration: import_smithy_client._json,
-    typeInfo: /* @__PURE__ */ __name((_) => de_WorkflowTypeInfo(_, context), "typeInfo")
-  });
-}, "de_WorkflowTypeDetail");
-var de_WorkflowTypeInfo = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    creationDate: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "creationDate"),
-    deprecationDate: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "deprecationDate"),
-    description: import_smithy_client.expectString,
-    status: import_smithy_client.expectString,
-    workflowType: import_smithy_client._json
-  });
-}, "de_WorkflowTypeInfo");
-var de_WorkflowTypeInfoList = /* @__PURE__ */ __name((output, context) => {
-  const retVal = (output || []).filter((e) => e != null).map((entry) => {
-    return de_WorkflowTypeInfo(entry, context);
-  });
-  return retVal;
-}, "de_WorkflowTypeInfoList");
-var de_WorkflowTypeInfos = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    nextPageToken: import_smithy_client.expectString,
-    typeInfos: /* @__PURE__ */ __name((_) => de_WorkflowTypeInfoList(_, context), "typeInfos")
-  });
-}, "de_WorkflowTypeInfos");
-var deserializeMetadata = /* @__PURE__ */ __name((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"]
-}), "deserializeMetadata");
-var throwDefaultError = (0, import_smithy_client.withBaseException)(SWFServiceException);
-var buildHttpRpcRequest = /* @__PURE__ */ __name(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 (resolvedHostname !== void 0) {
-    contents.hostname = resolvedHostname;
-  }
-  if (body !== void 0) {
-    contents.body = body;
-  }
-  return new import_protocol_http.HttpRequest(contents);
-}, "buildHttpRpcRequest");
-function sharedHeaders(operation) {
-  return {
-    "content-type": "application/x-amz-json-1.0",
-    "x-amz-target": `SimpleWorkflowService.${operation}`
-  };
-}
-__name(sharedHeaders, "sharedHeaders");
-
-// src/commands/CountClosedWorkflowExecutionsCommand.ts
-var CountClosedWorkflowExecutionsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "CountClosedWorkflowExecutions", {}).n("SWFClient", "CountClosedWorkflowExecutionsCommand").f(void 0, void 0).ser(se_CountClosedWorkflowExecutionsCommand).de(de_CountClosedWorkflowExecutionsCommand).build() {
-  static {
-    __name(this, "CountClosedWorkflowExecutionsCommand");
-  }
-};
-
-// src/commands/CountOpenWorkflowExecutionsCommand.ts
-
-
-
-var CountOpenWorkflowExecutionsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "CountOpenWorkflowExecutions", {}).n("SWFClient", "CountOpenWorkflowExecutionsCommand").f(void 0, void 0).ser(se_CountOpenWorkflowExecutionsCommand).de(de_CountOpenWorkflowExecutionsCommand).build() {
-  static {
-    __name(this, "CountOpenWorkflowExecutionsCommand");
-  }
-};
-
-// src/commands/CountPendingActivityTasksCommand.ts
-
-
-
-var CountPendingActivityTasksCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "CountPendingActivityTasks", {}).n("SWFClient", "CountPendingActivityTasksCommand").f(void 0, void 0).ser(se_CountPendingActivityTasksCommand).de(de_CountPendingActivityTasksCommand).build() {
-  static {
-    __name(this, "CountPendingActivityTasksCommand");
-  }
-};
-
-// src/commands/CountPendingDecisionTasksCommand.ts
-
-
-
-var CountPendingDecisionTasksCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "CountPendingDecisionTasks", {}).n("SWFClient", "CountPendingDecisionTasksCommand").f(void 0, void 0).ser(se_CountPendingDecisionTasksCommand).de(de_CountPendingDecisionTasksCommand).build() {
-  static {
-    __name(this, "CountPendingDecisionTasksCommand");
-  }
-};
-
-// src/commands/DeleteActivityTypeCommand.ts
-
-
-
-var DeleteActivityTypeCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "DeleteActivityType", {}).n("SWFClient", "DeleteActivityTypeCommand").f(void 0, void 0).ser(se_DeleteActivityTypeCommand).de(de_DeleteActivityTypeCommand).build() {
-  static {
-    __name(this, "DeleteActivityTypeCommand");
-  }
-};
-
-// src/commands/DeleteWorkflowTypeCommand.ts
-
-
-
-var DeleteWorkflowTypeCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "DeleteWorkflowType", {}).n("SWFClient", "DeleteWorkflowTypeCommand").f(void 0, void 0).ser(se_DeleteWorkflowTypeCommand).de(de_DeleteWorkflowTypeCommand).build() {
-  static {
-    __name(this, "DeleteWorkflowTypeCommand");
-  }
-};
-
-// src/commands/DeprecateActivityTypeCommand.ts
-
-
-
-var DeprecateActivityTypeCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "DeprecateActivityType", {}).n("SWFClient", "DeprecateActivityTypeCommand").f(void 0, void 0).ser(se_DeprecateActivityTypeCommand).de(de_DeprecateActivityTypeCommand).build() {
-  static {
-    __name(this, "DeprecateActivityTypeCommand");
-  }
-};
-
-// src/commands/DeprecateDomainCommand.ts
-
-
-
-var DeprecateDomainCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "DeprecateDomain", {}).n("SWFClient", "DeprecateDomainCommand").f(void 0, void 0).ser(se_DeprecateDomainCommand).de(de_DeprecateDomainCommand).build() {
-  static {
-    __name(this, "DeprecateDomainCommand");
-  }
-};
-
-// src/commands/DeprecateWorkflowTypeCommand.ts
-
-
-
-var DeprecateWorkflowTypeCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "DeprecateWorkflowType", {}).n("SWFClient", "DeprecateWorkflowTypeCommand").f(void 0, void 0).ser(se_DeprecateWorkflowTypeCommand).de(de_DeprecateWorkflowTypeCommand).build() {
-  static {
-    __name(this, "DeprecateWorkflowTypeCommand");
-  }
-};
-
-// src/commands/DescribeActivityTypeCommand.ts
-
-
-
-var DescribeActivityTypeCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "DescribeActivityType", {}).n("SWFClient", "DescribeActivityTypeCommand").f(void 0, void 0).ser(se_DescribeActivityTypeCommand).de(de_DescribeActivityTypeCommand).build() {
-  static {
-    __name(this, "DescribeActivityTypeCommand");
-  }
-};
-
-// src/commands/DescribeDomainCommand.ts
-
-
-
-var DescribeDomainCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "DescribeDomain", {}).n("SWFClient", "DescribeDomainCommand").f(void 0, void 0).ser(se_DescribeDomainCommand).de(de_DescribeDomainCommand).build() {
-  static {
-    __name(this, "DescribeDomainCommand");
-  }
 };
-
-// src/commands/DescribeWorkflowExecutionCommand.ts
-
-
-
-var DescribeWorkflowExecutionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "DescribeWorkflowExecution", {}).n("SWFClient", "DescribeWorkflowExecutionCommand").f(void 0, void 0).ser(se_DescribeWorkflowExecutionCommand).de(de_DescribeWorkflowExecutionCommand).build() {
-  static {
-    __name(this, "DescribeWorkflowExecutionCommand");
-  }
+const se_CountOpenWorkflowExecutionsInput = (input, context) => {
+    return smithyClient.take(input, {
+        domain: [],
+        executionFilter: smithyClient._json,
+        startTimeFilter: (_) => se_ExecutionTimeFilter(_),
+        tagFilter: smithyClient._json,
+        typeFilter: smithyClient._json,
+    });
 };
-
-// src/commands/DescribeWorkflowTypeCommand.ts
-
-
-
-var DescribeWorkflowTypeCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "DescribeWorkflowType", {}).n("SWFClient", "DescribeWorkflowTypeCommand").f(void 0, void 0).ser(se_DescribeWorkflowTypeCommand).de(de_DescribeWorkflowTypeCommand).build() {
-  static {
-    __name(this, "DescribeWorkflowTypeCommand");
-  }
+const se_ExecutionTimeFilter = (input, context) => {
+    return smithyClient.take(input, {
+        latestDate: (_) => _.getTime() / 1_000,
+        oldestDate: (_) => _.getTime() / 1_000,
+    });
 };
-
-// src/commands/GetWorkflowExecutionHistoryCommand.ts
-
-
-
-var GetWorkflowExecutionHistoryCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "GetWorkflowExecutionHistory", {}).n("SWFClient", "GetWorkflowExecutionHistoryCommand").f(void 0, void 0).ser(se_GetWorkflowExecutionHistoryCommand).de(de_GetWorkflowExecutionHistoryCommand).build() {
-  static {
-    __name(this, "GetWorkflowExecutionHistoryCommand");
-  }
+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,
+    });
 };
-
-// src/commands/ListActivityTypesCommand.ts
-
-
-
-var ListActivityTypesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "ListActivityTypes", {}).n("SWFClient", "ListActivityTypesCommand").f(void 0, void 0).ser(se_ListActivityTypesCommand).de(de_ListActivityTypesCommand).build() {
-  static {
-    __name(this, "ListActivityTypesCommand");
-  }
+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,
+    });
 };
-
-// src/commands/ListClosedWorkflowExecutionsCommand.ts
-
-
-
-var ListClosedWorkflowExecutionsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "ListClosedWorkflowExecutions", {}).n("SWFClient", "ListClosedWorkflowExecutionsCommand").f(void 0, void 0).ser(se_ListClosedWorkflowExecutionsCommand).de(de_ListClosedWorkflowExecutionsCommand).build() {
-  static {
-    __name(this, "ListClosedWorkflowExecutionsCommand");
-  }
+const de_ActivityTypeDetail = (output, context) => {
+    return smithyClient.take(output, {
+        configuration: smithyClient._json,
+        typeInfo: (_) => de_ActivityTypeInfo(_),
+    });
 };
-
-// src/commands/ListDomainsCommand.ts
-
-
-
-var ListDomainsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "ListDomains", {}).n("SWFClient", "ListDomainsCommand").f(void 0, void 0).ser(se_ListDomainsCommand).de(de_ListDomainsCommand).build() {
-  static {
-    __name(this, "ListDomainsCommand");
-  }
+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,
+    });
 };
-
-// src/commands/ListOpenWorkflowExecutionsCommand.ts
-
-
-
-var ListOpenWorkflowExecutionsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "ListOpenWorkflowExecutions", {}).n("SWFClient", "ListOpenWorkflowExecutionsCommand").f(void 0, void 0).ser(se_ListOpenWorkflowExecutionsCommand).de(de_ListOpenWorkflowExecutionsCommand).build() {
-  static {
-    __name(this, "ListOpenWorkflowExecutionsCommand");
-  }
+const de_ActivityTypeInfoList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ActivityTypeInfo(entry);
+    });
+    return retVal;
 };
-
-// src/commands/ListTagsForResourceCommand.ts
-
-
-
-var ListTagsForResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "ListTagsForResource", {}).n("SWFClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
-  static {
-    __name(this, "ListTagsForResourceCommand");
-  }
+const de_ActivityTypeInfos = (output, context) => {
+    return smithyClient.take(output, {
+        nextPageToken: smithyClient.expectString,
+        typeInfos: (_) => de_ActivityTypeInfoList(_),
+    });
 };
-
-// src/commands/ListWorkflowTypesCommand.ts
-
-
-
-var ListWorkflowTypesCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "ListWorkflowTypes", {}).n("SWFClient", "ListWorkflowTypesCommand").f(void 0, void 0).ser(se_ListWorkflowTypesCommand).de(de_ListWorkflowTypesCommand).build() {
-  static {
-    __name(this, "ListWorkflowTypesCommand");
-  }
+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,
+    });
 };
-
-// src/commands/PollForActivityTaskCommand.ts
-
-
-
-var PollForActivityTaskCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "PollForActivityTask", {}).n("SWFClient", "PollForActivityTaskCommand").f(void 0, void 0).ser(se_PollForActivityTaskCommand).de(de_PollForActivityTaskCommand).build() {
-  static {
-    __name(this, "PollForActivityTaskCommand");
-  }
+const de_History = (output, context) => {
+    return smithyClient.take(output, {
+        events: (_) => de_HistoryEventList(_),
+        nextPageToken: smithyClient.expectString,
+    });
 };
-
-// src/commands/PollForDecisionTaskCommand.ts
-
-
-
-var PollForDecisionTaskCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "PollForDecisionTask", {}).n("SWFClient", "PollForDecisionTaskCommand").f(void 0, void 0).ser(se_PollForDecisionTaskCommand).de(de_PollForDecisionTaskCommand).build() {
-  static {
-    __name(this, "PollForDecisionTaskCommand");
-  }
+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,
+    });
 };
-
-// src/commands/RecordActivityTaskHeartbeatCommand.ts
-
-
-
-var RecordActivityTaskHeartbeatCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "RecordActivityTaskHeartbeat", {}).n("SWFClient", "RecordActivityTaskHeartbeatCommand").f(void 0, void 0).ser(se_RecordActivityTaskHeartbeatCommand).de(de_RecordActivityTaskHeartbeatCommand).build() {
-  static {
-    __name(this, "RecordActivityTaskHeartbeatCommand");
-  }
+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,
+    });
 };
-
-// src/commands/RegisterActivityTypeCommand.ts
-
-
-
-var RegisterActivityTypeCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "RegisterActivityType", {}).n("SWFClient", "RegisterActivityTypeCommand").f(void 0, void 0).ser(se_RegisterActivityTypeCommand).de(de_RegisterActivityTypeCommand).build() {
-  static {
-    __name(this, "RegisterActivityTypeCommand");
-  }
+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,
+    });
 };
-
-// src/commands/RegisterDomainCommand.ts
-
-
-
-var RegisterDomainCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "RegisterDomain", {}).n("SWFClient", "RegisterDomainCommand").f(void 0, void 0).ser(se_RegisterDomainCommand).de(de_RegisterDomainCommand).build() {
-  static {
-    __name(this, "RegisterDomainCommand");
-  }
+const de_WorkflowExecutionInfoList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_WorkflowExecutionInfo(entry);
+    });
+    return retVal;
 };
-
-// src/commands/RegisterWorkflowTypeCommand.ts
-
-
-
-var RegisterWorkflowTypeCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "RegisterWorkflowType", {}).n("SWFClient", "RegisterWorkflowTypeCommand").f(void 0, void 0).ser(se_RegisterWorkflowTypeCommand).de(de_RegisterWorkflowTypeCommand).build() {
-  static {
-    __name(this, "RegisterWorkflowTypeCommand");
-  }
+const de_WorkflowExecutionInfos = (output, context) => {
+    return smithyClient.take(output, {
+        executionInfos: (_) => de_WorkflowExecutionInfoList(_),
+        nextPageToken: smithyClient.expectString,
+    });
 };
-
-// src/commands/RequestCancelWorkflowExecutionCommand.ts
-
-
-
-var RequestCancelWorkflowExecutionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "RequestCancelWorkflowExecution", {}).n("SWFClient", "RequestCancelWorkflowExecutionCommand").f(void 0, void 0).ser(se_RequestCancelWorkflowExecutionCommand).de(de_RequestCancelWorkflowExecutionCommand).build() {
-  static {
-    __name(this, "RequestCancelWorkflowExecutionCommand");
-  }
+const de_WorkflowTypeDetail = (output, context) => {
+    return smithyClient.take(output, {
+        configuration: smithyClient._json,
+        typeInfo: (_) => de_WorkflowTypeInfo(_),
+    });
 };
-
-// src/commands/RespondActivityTaskCanceledCommand.ts
-
-
-
-var RespondActivityTaskCanceledCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "RespondActivityTaskCanceled", {}).n("SWFClient", "RespondActivityTaskCanceledCommand").f(void 0, void 0).ser(se_RespondActivityTaskCanceledCommand).de(de_RespondActivityTaskCanceledCommand).build() {
-  static {
-    __name(this, "RespondActivityTaskCanceledCommand");
-  }
+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,
+    });
 };
-
-// src/commands/RespondActivityTaskCompletedCommand.ts
-
-
-
-var RespondActivityTaskCompletedCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "RespondActivityTaskCompleted", {}).n("SWFClient", "RespondActivityTaskCompletedCommand").f(void 0, void 0).ser(se_RespondActivityTaskCompletedCommand).de(de_RespondActivityTaskCompletedCommand).build() {
-  static {
-    __name(this, "RespondActivityTaskCompletedCommand");
-  }
+const de_WorkflowTypeInfoList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_WorkflowTypeInfo(entry);
+    });
+    return retVal;
 };
-
-// src/commands/RespondActivityTaskFailedCommand.ts
-
-
-
-var RespondActivityTaskFailedCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "RespondActivityTaskFailed", {}).n("SWFClient", "RespondActivityTaskFailedCommand").f(void 0, void 0).ser(se_RespondActivityTaskFailedCommand).de(de_RespondActivityTaskFailedCommand).build() {
-  static {
-    __name(this, "RespondActivityTaskFailedCommand");
-  }
+const de_WorkflowTypeInfos = (output, context) => {
+    return smithyClient.take(output, {
+        nextPageToken: smithyClient.expectString,
+        typeInfos: (_) => de_WorkflowTypeInfoList(_),
+    });
 };
-
-// src/commands/RespondDecisionTaskCompletedCommand.ts
-
-
-
-var RespondDecisionTaskCompletedCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "RespondDecisionTaskCompleted", {}).n("SWFClient", "RespondDecisionTaskCompletedCommand").f(void 0, void 0).ser(se_RespondDecisionTaskCompletedCommand).de(de_RespondDecisionTaskCompletedCommand).build() {
-  static {
-    __name(this, "RespondDecisionTaskCompletedCommand");
-  }
+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}`,
+    };
+}
 
-// src/commands/SignalWorkflowExecutionCommand.ts
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "CountClosedWorkflowExecutions", {})
+    .n("SWFClient", "CountClosedWorkflowExecutionsCommand")
+    .f(void 0, void 0)
+    .ser(se_CountClosedWorkflowExecutionsCommand)
+    .de(de_CountClosedWorkflowExecutionsCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "CountOpenWorkflowExecutions", {})
+    .n("SWFClient", "CountOpenWorkflowExecutionsCommand")
+    .f(void 0, void 0)
+    .ser(se_CountOpenWorkflowExecutionsCommand)
+    .de(de_CountOpenWorkflowExecutionsCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "CountPendingActivityTasks", {})
+    .n("SWFClient", "CountPendingActivityTasksCommand")
+    .f(void 0, void 0)
+    .ser(se_CountPendingActivityTasksCommand)
+    .de(de_CountPendingActivityTasksCommand)
+    .build() {
+}
 
-var SignalWorkflowExecutionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "SignalWorkflowExecution", {}).n("SWFClient", "SignalWorkflowExecutionCommand").f(void 0, void 0).ser(se_SignalWorkflowExecutionCommand).de(de_SignalWorkflowExecutionCommand).build() {
-  static {
-    __name(this, "SignalWorkflowExecutionCommand");
-  }
-};
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "CountPendingDecisionTasks", {})
+    .n("SWFClient", "CountPendingDecisionTasksCommand")
+    .f(void 0, void 0)
+    .ser(se_CountPendingDecisionTasksCommand)
+    .de(de_CountPendingDecisionTasksCommand)
+    .build() {
+}
 
-// src/commands/StartWorkflowExecutionCommand.ts
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "DeleteActivityType", {})
+    .n("SWFClient", "DeleteActivityTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteActivityTypeCommand)
+    .de(de_DeleteActivityTypeCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "DeleteWorkflowType", {})
+    .n("SWFClient", "DeleteWorkflowTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteWorkflowTypeCommand)
+    .de(de_DeleteWorkflowTypeCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "DeprecateActivityType", {})
+    .n("SWFClient", "DeprecateActivityTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_DeprecateActivityTypeCommand)
+    .de(de_DeprecateActivityTypeCommand)
+    .build() {
+}
 
-var StartWorkflowExecutionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "StartWorkflowExecution", {}).n("SWFClient", "StartWorkflowExecutionCommand").f(void 0, void 0).ser(se_StartWorkflowExecutionCommand).de(de_StartWorkflowExecutionCommand).build() {
-  static {
-    __name(this, "StartWorkflowExecutionCommand");
-  }
-};
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "DeprecateDomain", {})
+    .n("SWFClient", "DeprecateDomainCommand")
+    .f(void 0, void 0)
+    .ser(se_DeprecateDomainCommand)
+    .de(de_DeprecateDomainCommand)
+    .build() {
+}
 
-// src/commands/TagResourceCommand.ts
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "DeprecateWorkflowType", {})
+    .n("SWFClient", "DeprecateWorkflowTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_DeprecateWorkflowTypeCommand)
+    .de(de_DeprecateWorkflowTypeCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "DescribeActivityType", {})
+    .n("SWFClient", "DescribeActivityTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeActivityTypeCommand)
+    .de(de_DescribeActivityTypeCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "DescribeDomain", {})
+    .n("SWFClient", "DescribeDomainCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeDomainCommand)
+    .de(de_DescribeDomainCommand)
+    .build() {
+}
 
-var TagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "TagResource", {}).n("SWFClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
-  static {
-    __name(this, "TagResourceCommand");
-  }
-};
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "DescribeWorkflowExecution", {})
+    .n("SWFClient", "DescribeWorkflowExecutionCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeWorkflowExecutionCommand)
+    .de(de_DescribeWorkflowExecutionCommand)
+    .build() {
+}
 
-// src/commands/TerminateWorkflowExecutionCommand.ts
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "DescribeWorkflowType", {})
+    .n("SWFClient", "DescribeWorkflowTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeWorkflowTypeCommand)
+    .de(de_DescribeWorkflowTypeCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "GetWorkflowExecutionHistory", {})
+    .n("SWFClient", "GetWorkflowExecutionHistoryCommand")
+    .f(void 0, void 0)
+    .ser(se_GetWorkflowExecutionHistoryCommand)
+    .de(de_GetWorkflowExecutionHistoryCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "ListActivityTypes", {})
+    .n("SWFClient", "ListActivityTypesCommand")
+    .f(void 0, void 0)
+    .ser(se_ListActivityTypesCommand)
+    .de(de_ListActivityTypesCommand)
+    .build() {
+}
 
-var TerminateWorkflowExecutionCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "TerminateWorkflowExecution", {}).n("SWFClient", "TerminateWorkflowExecutionCommand").f(void 0, void 0).ser(se_TerminateWorkflowExecutionCommand).de(de_TerminateWorkflowExecutionCommand).build() {
-  static {
-    __name(this, "TerminateWorkflowExecutionCommand");
-  }
-};
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "ListClosedWorkflowExecutions", {})
+    .n("SWFClient", "ListClosedWorkflowExecutionsCommand")
+    .f(void 0, void 0)
+    .ser(se_ListClosedWorkflowExecutionsCommand)
+    .de(de_ListClosedWorkflowExecutionsCommand)
+    .build() {
+}
 
-// src/commands/UndeprecateActivityTypeCommand.ts
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "ListDomains", {})
+    .n("SWFClient", "ListDomainsCommand")
+    .f(void 0, void 0)
+    .ser(se_ListDomainsCommand)
+    .de(de_ListDomainsCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "ListOpenWorkflowExecutions", {})
+    .n("SWFClient", "ListOpenWorkflowExecutionsCommand")
+    .f(void 0, void 0)
+    .ser(se_ListOpenWorkflowExecutionsCommand)
+    .de(de_ListOpenWorkflowExecutionsCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "ListTagsForResource", {})
+    .n("SWFClient", "ListTagsForResourceCommand")
+    .f(void 0, void 0)
+    .ser(se_ListTagsForResourceCommand)
+    .de(de_ListTagsForResourceCommand)
+    .build() {
+}
 
-var UndeprecateActivityTypeCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "UndeprecateActivityType", {}).n("SWFClient", "UndeprecateActivityTypeCommand").f(void 0, void 0).ser(se_UndeprecateActivityTypeCommand).de(de_UndeprecateActivityTypeCommand).build() {
-  static {
-    __name(this, "UndeprecateActivityTypeCommand");
-  }
-};
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "ListWorkflowTypes", {})
+    .n("SWFClient", "ListWorkflowTypesCommand")
+    .f(void 0, void 0)
+    .ser(se_ListWorkflowTypesCommand)
+    .de(de_ListWorkflowTypesCommand)
+    .build() {
+}
 
-// src/commands/UndeprecateDomainCommand.ts
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "PollForActivityTask", {})
+    .n("SWFClient", "PollForActivityTaskCommand")
+    .f(void 0, void 0)
+    .ser(se_PollForActivityTaskCommand)
+    .de(de_PollForActivityTaskCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "PollForDecisionTask", {})
+    .n("SWFClient", "PollForDecisionTaskCommand")
+    .f(void 0, void 0)
+    .ser(se_PollForDecisionTaskCommand)
+    .de(de_PollForDecisionTaskCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "RecordActivityTaskHeartbeat", {})
+    .n("SWFClient", "RecordActivityTaskHeartbeatCommand")
+    .f(void 0, void 0)
+    .ser(se_RecordActivityTaskHeartbeatCommand)
+    .de(de_RecordActivityTaskHeartbeatCommand)
+    .build() {
+}
 
-var UndeprecateDomainCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "UndeprecateDomain", {}).n("SWFClient", "UndeprecateDomainCommand").f(void 0, void 0).ser(se_UndeprecateDomainCommand).de(de_UndeprecateDomainCommand).build() {
-  static {
-    __name(this, "UndeprecateDomainCommand");
-  }
-};
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "RegisterActivityType", {})
+    .n("SWFClient", "RegisterActivityTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_RegisterActivityTypeCommand)
+    .de(de_RegisterActivityTypeCommand)
+    .build() {
+}
 
-// src/commands/UndeprecateWorkflowTypeCommand.ts
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "RegisterDomain", {})
+    .n("SWFClient", "RegisterDomainCommand")
+    .f(void 0, void 0)
+    .ser(se_RegisterDomainCommand)
+    .de(de_RegisterDomainCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "RegisterWorkflowType", {})
+    .n("SWFClient", "RegisterWorkflowTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_RegisterWorkflowTypeCommand)
+    .de(de_RegisterWorkflowTypeCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "RequestCancelWorkflowExecution", {})
+    .n("SWFClient", "RequestCancelWorkflowExecutionCommand")
+    .f(void 0, void 0)
+    .ser(se_RequestCancelWorkflowExecutionCommand)
+    .de(de_RequestCancelWorkflowExecutionCommand)
+    .build() {
+}
 
-var UndeprecateWorkflowTypeCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "UndeprecateWorkflowType", {}).n("SWFClient", "UndeprecateWorkflowTypeCommand").f(void 0, void 0).ser(se_UndeprecateWorkflowTypeCommand).de(de_UndeprecateWorkflowTypeCommand).build() {
-  static {
-    __name(this, "UndeprecateWorkflowTypeCommand");
-  }
-};
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "RespondActivityTaskCanceled", {})
+    .n("SWFClient", "RespondActivityTaskCanceledCommand")
+    .f(void 0, void 0)
+    .ser(se_RespondActivityTaskCanceledCommand)
+    .de(de_RespondActivityTaskCanceledCommand)
+    .build() {
+}
 
-// src/commands/UntagResourceCommand.ts
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "RespondActivityTaskCompleted", {})
+    .n("SWFClient", "RespondActivityTaskCompletedCommand")
+    .f(void 0, void 0)
+    .ser(se_RespondActivityTaskCompletedCommand)
+    .de(de_RespondActivityTaskCompletedCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "RespondActivityTaskFailed", {})
+    .n("SWFClient", "RespondActivityTaskFailedCommand")
+    .f(void 0, void 0)
+    .ser(se_RespondActivityTaskFailedCommand)
+    .de(de_RespondActivityTaskFailedCommand)
+    .build() {
+}
 
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "RespondDecisionTaskCompleted", {})
+    .n("SWFClient", "RespondDecisionTaskCompletedCommand")
+    .f(void 0, void 0)
+    .ser(se_RespondDecisionTaskCompletedCommand)
+    .de(de_RespondDecisionTaskCompletedCommand)
+    .build() {
+}
 
-var UntagResourceCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("SimpleWorkflowService", "UntagResource", {}).n("SWFClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
-  static {
-    __name(this, "UntagResourceCommand");
-  }
-};
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "SignalWorkflowExecution", {})
+    .n("SWFClient", "SignalWorkflowExecutionCommand")
+    .f(void 0, void 0)
+    .ser(se_SignalWorkflowExecutionCommand)
+    .de(de_SignalWorkflowExecutionCommand)
+    .build() {
+}
 
-// src/SWF.ts
-var commands = {
-  CountClosedWorkflowExecutionsCommand,
-  CountOpenWorkflowExecutionsCommand,
-  CountPendingActivityTasksCommand,
-  CountPendingDecisionTasksCommand,
-  DeleteActivityTypeCommand,
-  DeleteWorkflowTypeCommand,
-  DeprecateActivityTypeCommand,
-  DeprecateDomainCommand,
-  DeprecateWorkflowTypeCommand,
-  DescribeActivityTypeCommand,
-  DescribeDomainCommand,
-  DescribeWorkflowExecutionCommand,
-  DescribeWorkflowTypeCommand,
-  GetWorkflowExecutionHistoryCommand,
-  ListActivityTypesCommand,
-  ListClosedWorkflowExecutionsCommand,
-  ListDomainsCommand,
-  ListOpenWorkflowExecutionsCommand,
-  ListTagsForResourceCommand,
-  ListWorkflowTypesCommand,
-  PollForActivityTaskCommand,
-  PollForDecisionTaskCommand,
-  RecordActivityTaskHeartbeatCommand,
-  RegisterActivityTypeCommand,
-  RegisterDomainCommand,
-  RegisterWorkflowTypeCommand,
-  RequestCancelWorkflowExecutionCommand,
-  RespondActivityTaskCanceledCommand,
-  RespondActivityTaskCompletedCommand,
-  RespondActivityTaskFailedCommand,
-  RespondDecisionTaskCompletedCommand,
-  SignalWorkflowExecutionCommand,
-  StartWorkflowExecutionCommand,
-  TagResourceCommand,
-  TerminateWorkflowExecutionCommand,
-  UndeprecateActivityTypeCommand,
-  UndeprecateDomainCommand,
-  UndeprecateWorkflowTypeCommand,
-  UntagResourceCommand
-};
-var SWF = class extends SWFClient {
-  static {
-    __name(this, "SWF");
-  }
-};
-(0, import_smithy_client.createAggregatedClient)(commands, SWF);
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "StartWorkflowExecution", {})
+    .n("SWFClient", "StartWorkflowExecutionCommand")
+    .f(void 0, void 0)
+    .ser(se_StartWorkflowExecutionCommand)
+    .de(de_StartWorkflowExecutionCommand)
+    .build() {
+}
 
-// src/pagination/GetWorkflowExecutionHistoryPaginator.ts
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "TagResource", {})
+    .n("SWFClient", "TagResourceCommand")
+    .f(void 0, void 0)
+    .ser(se_TagResourceCommand)
+    .de(de_TagResourceCommand)
+    .build() {
+}
 
-var paginateGetWorkflowExecutionHistory = (0, import_core.createPaginator)(SWFClient, GetWorkflowExecutionHistoryCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "TerminateWorkflowExecution", {})
+    .n("SWFClient", "TerminateWorkflowExecutionCommand")
+    .f(void 0, void 0)
+    .ser(se_TerminateWorkflowExecutionCommand)
+    .de(de_TerminateWorkflowExecutionCommand)
+    .build() {
+}
 
-// src/pagination/ListActivityTypesPaginator.ts
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "UndeprecateActivityType", {})
+    .n("SWFClient", "UndeprecateActivityTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_UndeprecateActivityTypeCommand)
+    .de(de_UndeprecateActivityTypeCommand)
+    .build() {
+}
 
-var paginateListActivityTypes = (0, import_core.createPaginator)(SWFClient, ListActivityTypesCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "UndeprecateDomain", {})
+    .n("SWFClient", "UndeprecateDomainCommand")
+    .f(void 0, void 0)
+    .ser(se_UndeprecateDomainCommand)
+    .de(de_UndeprecateDomainCommand)
+    .build() {
+}
 
-// src/pagination/ListClosedWorkflowExecutionsPaginator.ts
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "UndeprecateWorkflowType", {})
+    .n("SWFClient", "UndeprecateWorkflowTypeCommand")
+    .f(void 0, void 0)
+    .ser(se_UndeprecateWorkflowTypeCommand)
+    .de(de_UndeprecateWorkflowTypeCommand)
+    .build() {
+}
 
-var paginateListClosedWorkflowExecutions = (0, import_core.createPaginator)(SWFClient, ListClosedWorkflowExecutionsCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
+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()),
+    ];
+})
+    .s("SimpleWorkflowService", "UntagResource", {})
+    .n("SWFClient", "UntagResourceCommand")
+    .f(void 0, void 0)
+    .ser(se_UntagResourceCommand)
+    .de(de_UntagResourceCommand)
+    .build() {
+}
 
-// src/pagination/ListDomainsPaginator.ts
+const commands = {
+    CountClosedWorkflowExecutionsCommand,
+    CountOpenWorkflowExecutionsCommand,
+    CountPendingActivityTasksCommand,
+    CountPendingDecisionTasksCommand,
+    DeleteActivityTypeCommand,
+    DeleteWorkflowTypeCommand,
+    DeprecateActivityTypeCommand,
+    DeprecateDomainCommand,
+    DeprecateWorkflowTypeCommand,
+    DescribeActivityTypeCommand,
+    DescribeDomainCommand,
+    DescribeWorkflowExecutionCommand,
+    DescribeWorkflowTypeCommand,
+    GetWorkflowExecutionHistoryCommand,
+    ListActivityTypesCommand,
+    ListClosedWorkflowExecutionsCommand,
+    ListDomainsCommand,
+    ListOpenWorkflowExecutionsCommand,
+    ListTagsForResourceCommand,
+    ListWorkflowTypesCommand,
+    PollForActivityTaskCommand,
+    PollForDecisionTaskCommand,
+    RecordActivityTaskHeartbeatCommand,
+    RegisterActivityTypeCommand,
+    RegisterDomainCommand,
+    RegisterWorkflowTypeCommand,
+    RequestCancelWorkflowExecutionCommand,
+    RespondActivityTaskCanceledCommand,
+    RespondActivityTaskCompletedCommand,
+    RespondActivityTaskFailedCommand,
+    RespondDecisionTaskCompletedCommand,
+    SignalWorkflowExecutionCommand,
+    StartWorkflowExecutionCommand,
+    TagResourceCommand,
+    TerminateWorkflowExecutionCommand,
+    UndeprecateActivityTypeCommand,
+    UndeprecateDomainCommand,
+    UndeprecateWorkflowTypeCommand,
+    UntagResourceCommand,
+};
+class SWF extends SWFClient {
+}
+smithyClient.createAggregatedClient(commands, SWF);
 
-var paginateListDomains = (0, import_core.createPaginator)(SWFClient, ListDomainsCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
+const paginateGetWorkflowExecutionHistory = core.createPaginator(SWFClient, GetWorkflowExecutionHistoryCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
 
-// src/pagination/ListOpenWorkflowExecutionsPaginator.ts
+const paginateListActivityTypes = core.createPaginator(SWFClient, ListActivityTypesCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
 
-var paginateListOpenWorkflowExecutions = (0, import_core.createPaginator)(SWFClient, ListOpenWorkflowExecutionsCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
+const paginateListClosedWorkflowExecutions = core.createPaginator(SWFClient, ListClosedWorkflowExecutionsCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
 
-// src/pagination/ListWorkflowTypesPaginator.ts
+const paginateListDomains = core.createPaginator(SWFClient, ListDomainsCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
 
-var paginateListWorkflowTypes = (0, import_core.createPaginator)(SWFClient, ListWorkflowTypesCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
+const paginateListOpenWorkflowExecutions = core.createPaginator(SWFClient, ListOpenWorkflowExecutionsCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
 
-// src/pagination/PollForDecisionTaskPaginator.ts
+const paginateListWorkflowTypes = core.createPaginator(SWFClient, ListWorkflowTypesCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
 
-var paginatePollForDecisionTask = (0, import_core.createPaginator)(SWFClient, PollForDecisionTaskCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
-// Annotate the CommonJS export names for ESM import in node:
+const paginatePollForDecisionTask = core.createPaginator(SWFClient, PollForDecisionTaskCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
 
-0 && (module.exports = {
-  SWFServiceException,
-  __Client,
-  SWFClient,
-  SWF,
-  $Command,
-  CountClosedWorkflowExecutionsCommand,
-  CountOpenWorkflowExecutionsCommand,
-  CountPendingActivityTasksCommand,
-  CountPendingDecisionTasksCommand,
-  DeleteActivityTypeCommand,
-  DeleteWorkflowTypeCommand,
-  DeprecateActivityTypeCommand,
-  DeprecateDomainCommand,
-  DeprecateWorkflowTypeCommand,
-  DescribeActivityTypeCommand,
-  DescribeDomainCommand,
-  DescribeWorkflowExecutionCommand,
-  DescribeWorkflowTypeCommand,
-  GetWorkflowExecutionHistoryCommand,
-  ListActivityTypesCommand,
-  ListClosedWorkflowExecutionsCommand,
-  ListDomainsCommand,
-  ListOpenWorkflowExecutionsCommand,
-  ListTagsForResourceCommand,
-  ListWorkflowTypesCommand,
-  PollForActivityTaskCommand,
-  PollForDecisionTaskCommand,
-  RecordActivityTaskHeartbeatCommand,
-  RegisterActivityTypeCommand,
-  RegisterDomainCommand,
-  RegisterWorkflowTypeCommand,
-  RequestCancelWorkflowExecutionCommand,
-  RespondActivityTaskCanceledCommand,
-  RespondActivityTaskCompletedCommand,
-  RespondActivityTaskFailedCommand,
-  RespondDecisionTaskCompletedCommand,
-  SignalWorkflowExecutionCommand,
-  StartWorkflowExecutionCommand,
-  TagResourceCommand,
-  TerminateWorkflowExecutionCommand,
-  UndeprecateActivityTypeCommand,
-  UndeprecateDomainCommand,
-  UndeprecateWorkflowTypeCommand,
-  UntagResourceCommand,
-  paginateGetWorkflowExecutionHistory,
-  paginateListActivityTypes,
-  paginateListClosedWorkflowExecutions,
-  paginateListDomains,
-  paginateListOpenWorkflowExecutions,
-  paginateListWorkflowTypes,
-  paginatePollForDecisionTask,
-  ActivityTaskTimeoutType,
-  RegistrationStatus,
-  CancelTimerFailedCause,
-  CancelWorkflowExecutionFailedCause,
-  ChildPolicy,
-  WorkflowExecutionTimeoutType,
-  CloseStatus,
-  CompleteWorkflowExecutionFailedCause,
-  ContinueAsNewWorkflowExecutionFailedCause,
-  OperationNotPermittedFault,
-  UnknownResourceFault,
-  DecisionType,
-  DecisionTaskTimeoutType,
-  EventType,
-  FailWorkflowExecutionFailedCause,
-  LambdaFunctionTimeoutType,
-  RecordMarkerFailedCause,
-  RequestCancelActivityTaskFailedCause,
-  RequestCancelExternalWorkflowExecutionFailedCause,
-  ScheduleActivityTaskFailedCause,
-  ScheduleLambdaFunctionFailedCause,
-  SignalExternalWorkflowExecutionFailedCause,
-  StartChildWorkflowExecutionFailedCause,
-  StartLambdaFunctionFailedCause,
-  StartTimerFailedCause,
-  WorkflowExecutionCancelRequestedCause,
-  WorkflowExecutionTerminatedCause,
-  DefaultUndefinedFault,
-  TypeNotDeprecatedFault,
-  TypeDeprecatedFault,
-  DomainDeprecatedFault,
-  ExecutionStatus,
-  DomainAlreadyExistsFault,
-  LimitExceededFault,
-  TypeAlreadyExistsFault,
-  TooManyTagsFault,
-  WorkflowExecutionAlreadyStartedFault
+Object.defineProperty(exports, "$Command", {
+    enumerable: true,
+    get: function () { return smithyClient.Command; }
 });
-
+Object.defineProperty(exports, "__Client", {
+    enumerable: true,
+    get: function () { return smithyClient.Client; }
+});
+exports.ActivityTaskTimeoutType = ActivityTaskTimeoutType;
+exports.CancelTimerFailedCause = CancelTimerFailedCause;
+exports.CancelWorkflowExecutionFailedCause = CancelWorkflowExecutionFailedCause;
+exports.ChildPolicy = ChildPolicy;
+exports.CloseStatus = CloseStatus;
+exports.CompleteWorkflowExecutionFailedCause = CompleteWorkflowExecutionFailedCause;
+exports.ContinueAsNewWorkflowExecutionFailedCause = ContinueAsNewWorkflowExecutionFailedCause;
+exports.CountClosedWorkflowExecutionsCommand = CountClosedWorkflowExecutionsCommand;
+exports.CountOpenWorkflowExecutionsCommand = CountOpenWorkflowExecutionsCommand;
+exports.CountPendingActivityTasksCommand = CountPendingActivityTasksCommand;
+exports.CountPendingDecisionTasksCommand = CountPendingDecisionTasksCommand;
+exports.DecisionTaskTimeoutType = DecisionTaskTimeoutType;
+exports.DecisionType = DecisionType;
+exports.DefaultUndefinedFault = DefaultUndefinedFault;
+exports.DeleteActivityTypeCommand = DeleteActivityTypeCommand;
+exports.DeleteWorkflowTypeCommand = DeleteWorkflowTypeCommand;
+exports.DeprecateActivityTypeCommand = DeprecateActivityTypeCommand;
+exports.DeprecateDomainCommand = DeprecateDomainCommand;
+exports.DeprecateWorkflowTypeCommand = DeprecateWorkflowTypeCommand;
+exports.DescribeActivityTypeCommand = DescribeActivityTypeCommand;
+exports.DescribeDomainCommand = DescribeDomainCommand;
+exports.DescribeWorkflowExecutionCommand = DescribeWorkflowExecutionCommand;
+exports.DescribeWorkflowTypeCommand = DescribeWorkflowTypeCommand;
+exports.DomainAlreadyExistsFault = DomainAlreadyExistsFault;
+exports.DomainDeprecatedFault = DomainDeprecatedFault;
+exports.EventType = EventType;
+exports.ExecutionStatus = ExecutionStatus;
+exports.FailWorkflowExecutionFailedCause = FailWorkflowExecutionFailedCause;
+exports.GetWorkflowExecutionHistoryCommand = GetWorkflowExecutionHistoryCommand;
+exports.LambdaFunctionTimeoutType = LambdaFunctionTimeoutType;
+exports.LimitExceededFault = LimitExceededFault;
+exports.ListActivityTypesCommand = ListActivityTypesCommand;
+exports.ListClosedWorkflowExecutionsCommand = ListClosedWorkflowExecutionsCommand;
+exports.ListDomainsCommand = ListDomainsCommand;
+exports.ListOpenWorkflowExecutionsCommand = ListOpenWorkflowExecutionsCommand;
+exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
+exports.ListWorkflowTypesCommand = ListWorkflowTypesCommand;
+exports.OperationNotPermittedFault = OperationNotPermittedFault;
+exports.PollForActivityTaskCommand = PollForActivityTaskCommand;
+exports.PollForDecisionTaskCommand = PollForDecisionTaskCommand;
+exports.RecordActivityTaskHeartbeatCommand = RecordActivityTaskHeartbeatCommand;
+exports.RecordMarkerFailedCause = RecordMarkerFailedCause;
+exports.RegisterActivityTypeCommand = RegisterActivityTypeCommand;
+exports.RegisterDomainCommand = RegisterDomainCommand;
+exports.RegisterWorkflowTypeCommand = RegisterWorkflowTypeCommand;
+exports.RegistrationStatus = RegistrationStatus;
+exports.RequestCancelActivityTaskFailedCause = RequestCancelActivityTaskFailedCause;
+exports.RequestCancelExternalWorkflowExecutionFailedCause = RequestCancelExternalWorkflowExecutionFailedCause;
+exports.RequestCancelWorkflowExecutionCommand = RequestCancelWorkflowExecutionCommand;
+exports.RespondActivityTaskCanceledCommand = RespondActivityTaskCanceledCommand;
+exports.RespondActivityTaskCompletedCommand = RespondActivityTaskCompletedCommand;
+exports.RespondActivityTaskFailedCommand = RespondActivityTaskFailedCommand;
+exports.RespondDecisionTaskCompletedCommand = RespondDecisionTaskCompletedCommand;
+exports.SWF = SWF;
+exports.SWFClient = SWFClient;
+exports.SWFServiceException = SWFServiceException;
+exports.ScheduleActivityTaskFailedCause = ScheduleActivityTaskFailedCause;
+exports.ScheduleLambdaFunctionFailedCause = ScheduleLambdaFunctionFailedCause;
+exports.SignalExternalWorkflowExecutionFailedCause = SignalExternalWorkflowExecutionFailedCause;
+exports.SignalWorkflowExecutionCommand = SignalWorkflowExecutionCommand;
+exports.StartChildWorkflowExecutionFailedCause = StartChildWorkflowExecutionFailedCause;
+exports.StartLambdaFunctionFailedCause = StartLambdaFunctionFailedCause;
+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.UndeprecateActivityTypeCommand = UndeprecateActivityTypeCommand;
+exports.UndeprecateDomainCommand = UndeprecateDomainCommand;
+exports.UndeprecateWorkflowTypeCommand = UndeprecateWorkflowTypeCommand;
+exports.UnknownResourceFault = UnknownResourceFault;
+exports.UntagResourceCommand = UntagResourceCommand;
+exports.WorkflowExecutionAlreadyStartedFault = WorkflowExecutionAlreadyStartedFault;
+exports.WorkflowExecutionCancelRequestedCause = WorkflowExecutionCancelRequestedCause;
+exports.WorkflowExecutionTerminatedCause = WorkflowExecutionTerminatedCause;
+exports.WorkflowExecutionTimeoutType = WorkflowExecutionTimeoutType;
+exports.paginateGetWorkflowExecutionHistory = paginateGetWorkflowExecutionHistory;
+exports.paginateListActivityTypes = paginateListActivityTypes;
+exports.paginateListClosedWorkflowExecutions = paginateListClosedWorkflowExecutions;
+exports.paginateListDomains = paginateListDomains;
+exports.paginateListOpenWorkflowExecutions = paginateListOpenWorkflowExecutions;
+exports.paginateListWorkflowTypes = paginateListWorkflowTypes;
+exports.paginatePollForDecisionTask = paginatePollForDecisionTask;