@aws-sdk/client-swf 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,3298 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SWFServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./SWFClient"), exports);
-tslib_1.__exportStar(require("./SWF"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var SWFServiceException_1 = require("./models/SWFServiceException");
-Object.defineProperty(exports, "SWFServiceException", { enumerable: true, get: function () { return SWFServiceException_1.SWFServiceException; } });
+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 src_exports = {};
+__export(src_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,
+  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,
+  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(src_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_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+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");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...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" }
+};
+
+// 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");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/SWFClient.ts
+var _SWFClient = class _SWFClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    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_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(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();
+  }
+};
+__name(_SWFClient, "SWFClient");
+var SWFClient = _SWFClient;
+
+// src/SWF.ts
+
+
+// src/commands/CountClosedWorkflowExecutionsCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_0.ts
+
+
+
+// src/models/SWFServiceException.ts
+
+var _SWFServiceException = class _SWFServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _SWFServiceException.prototype);
+  }
+};
+__name(_SWFServiceException, "SWFServiceException");
+var SWFServiceException = _SWFServiceException;
+
+// 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 {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "OperationNotPermittedFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "OperationNotPermittedFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _OperationNotPermittedFault.prototype);
+  }
+};
+__name(_OperationNotPermittedFault, "OperationNotPermittedFault");
+var OperationNotPermittedFault = _OperationNotPermittedFault;
+var _UnknownResourceFault = class _UnknownResourceFault extends SWFServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnknownResourceFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnknownResourceFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnknownResourceFault.prototype);
+  }
+};
+__name(_UnknownResourceFault, "UnknownResourceFault");
+var UnknownResourceFault = _UnknownResourceFault;
+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 {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DefaultUndefinedFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DefaultUndefinedFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DefaultUndefinedFault.prototype);
+  }
+};
+__name(_DefaultUndefinedFault, "DefaultUndefinedFault");
+var DefaultUndefinedFault = _DefaultUndefinedFault;
+var _TypeDeprecatedFault = class _TypeDeprecatedFault extends SWFServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TypeDeprecatedFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TypeDeprecatedFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TypeDeprecatedFault.prototype);
+  }
+};
+__name(_TypeDeprecatedFault, "TypeDeprecatedFault");
+var TypeDeprecatedFault = _TypeDeprecatedFault;
+var _DomainDeprecatedFault = class _DomainDeprecatedFault extends SWFServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DomainDeprecatedFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DomainDeprecatedFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DomainDeprecatedFault.prototype);
+  }
+};
+__name(_DomainDeprecatedFault, "DomainDeprecatedFault");
+var DomainDeprecatedFault = _DomainDeprecatedFault;
+var ExecutionStatus = {
+  CLOSED: "CLOSED",
+  OPEN: "OPEN"
+};
+var _DomainAlreadyExistsFault = class _DomainAlreadyExistsFault extends SWFServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DomainAlreadyExistsFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DomainAlreadyExistsFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DomainAlreadyExistsFault.prototype);
+  }
+};
+__name(_DomainAlreadyExistsFault, "DomainAlreadyExistsFault");
+var DomainAlreadyExistsFault = _DomainAlreadyExistsFault;
+var _LimitExceededFault = class _LimitExceededFault extends SWFServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitExceededFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitExceededFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitExceededFault.prototype);
+  }
+};
+__name(_LimitExceededFault, "LimitExceededFault");
+var LimitExceededFault = _LimitExceededFault;
+var _TypeAlreadyExistsFault = class _TypeAlreadyExistsFault extends SWFServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TypeAlreadyExistsFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TypeAlreadyExistsFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TypeAlreadyExistsFault.prototype);
+  }
+};
+__name(_TypeAlreadyExistsFault, "TypeAlreadyExistsFault");
+var TypeAlreadyExistsFault = _TypeAlreadyExistsFault;
+var _TooManyTagsFault = class _TooManyTagsFault extends SWFServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyTagsFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyTagsFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyTagsFault.prototype);
+  }
+};
+__name(_TooManyTagsFault, "TooManyTagsFault");
+var TooManyTagsFault = _TooManyTagsFault;
+var _WorkflowExecutionAlreadyStartedFault = class _WorkflowExecutionAlreadyStartedFault extends SWFServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "WorkflowExecutionAlreadyStartedFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "WorkflowExecutionAlreadyStartedFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _WorkflowExecutionAlreadyStartedFault.prototype);
+  }
+};
+__name(_WorkflowExecutionAlreadyStartedFault, "WorkflowExecutionAlreadyStartedFault");
+var WorkflowExecutionAlreadyStartedFault = _WorkflowExecutionAlreadyStartedFault;
+
+// 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_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_CountClosedWorkflowExecutionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CountClosedWorkflowExecutionsCommand");
+var de_CountClosedWorkflowExecutionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CountClosedWorkflowExecutionsCommandError");
+var de_CountOpenWorkflowExecutionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CountOpenWorkflowExecutionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CountOpenWorkflowExecutionsCommand");
+var de_CountOpenWorkflowExecutionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CountOpenWorkflowExecutionsCommandError");
+var de_CountPendingActivityTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CountPendingActivityTasksCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CountPendingActivityTasksCommand");
+var de_CountPendingActivityTasksCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CountPendingActivityTasksCommandError");
+var de_CountPendingDecisionTasksCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CountPendingDecisionTasksCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CountPendingDecisionTasksCommand");
+var de_CountPendingDecisionTasksCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CountPendingDecisionTasksCommandError");
+var de_DeprecateActivityTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeprecateActivityTypeCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeprecateActivityTypeCommand");
+var de_DeprecateActivityTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "OperationNotPermittedFault":
+    case "com.amazonaws.swf#OperationNotPermittedFault":
+      throw await de_OperationNotPermittedFaultRes(parsedOutput, context);
+    case "TypeDeprecatedFault":
+    case "com.amazonaws.swf#TypeDeprecatedFault":
+      throw await de_TypeDeprecatedFaultRes(parsedOutput, context);
+    case "UnknownResourceFault":
+    case "com.amazonaws.swf#UnknownResourceFault":
+      throw await de_UnknownResourceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeprecateActivityTypeCommandError");
+var de_DeprecateDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeprecateDomainCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeprecateDomainCommand");
+var de_DeprecateDomainCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DomainDeprecatedFault":
+    case "com.amazonaws.swf#DomainDeprecatedFault":
+      throw await de_DomainDeprecatedFaultRes(parsedOutput, context);
+    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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeprecateDomainCommandError");
+var de_DeprecateWorkflowTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeprecateWorkflowTypeCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeprecateWorkflowTypeCommand");
+var de_DeprecateWorkflowTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "OperationNotPermittedFault":
+    case "com.amazonaws.swf#OperationNotPermittedFault":
+      throw await de_OperationNotPermittedFaultRes(parsedOutput, context);
+    case "TypeDeprecatedFault":
+    case "com.amazonaws.swf#TypeDeprecatedFault":
+      throw await de_TypeDeprecatedFaultRes(parsedOutput, context);
+    case "UnknownResourceFault":
+    case "com.amazonaws.swf#UnknownResourceFault":
+      throw await de_UnknownResourceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeprecateWorkflowTypeCommandError");
+var de_DescribeActivityTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeActivityTypeCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ActivityTypeDetail(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeActivityTypeCommand");
+var de_DescribeActivityTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeActivityTypeCommandError");
+var de_DescribeDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeDomainCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeDomainCommand");
+var de_DescribeDomainCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeDomainCommandError");
+var de_DescribeWorkflowExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeWorkflowExecutionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_WorkflowExecutionDetail(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeWorkflowExecutionCommand");
+var de_DescribeWorkflowExecutionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeWorkflowExecutionCommandError");
+var de_DescribeWorkflowTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeWorkflowTypeCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_WorkflowTypeDetail(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeWorkflowTypeCommand");
+var de_DescribeWorkflowTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeWorkflowTypeCommandError");
+var de_GetWorkflowExecutionHistoryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetWorkflowExecutionHistoryCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_History(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetWorkflowExecutionHistoryCommand");
+var de_GetWorkflowExecutionHistoryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetWorkflowExecutionHistoryCommandError");
+var de_ListActivityTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListActivityTypesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ActivityTypeInfos(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListActivityTypesCommand");
+var de_ListActivityTypesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListActivityTypesCommandError");
+var de_ListClosedWorkflowExecutionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListClosedWorkflowExecutionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_WorkflowExecutionInfos(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListClosedWorkflowExecutionsCommand");
+var de_ListClosedWorkflowExecutionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListClosedWorkflowExecutionsCommandError");
+var de_ListDomainsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListDomainsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListDomainsCommand");
+var de_ListDomainsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "OperationNotPermittedFault":
+    case "com.amazonaws.swf#OperationNotPermittedFault":
+      throw await de_OperationNotPermittedFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListDomainsCommandError");
+var de_ListOpenWorkflowExecutionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListOpenWorkflowExecutionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_WorkflowExecutionInfos(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListOpenWorkflowExecutionsCommand");
+var de_ListOpenWorkflowExecutionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListOpenWorkflowExecutionsCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededFault":
+    case "com.amazonaws.swf#LimitExceededFault":
+      throw await de_LimitExceededFaultRes(parsedOutput, context);
+    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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_ListWorkflowTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListWorkflowTypesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_WorkflowTypeInfos(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListWorkflowTypesCommand");
+var de_ListWorkflowTypesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListWorkflowTypesCommandError");
+var de_PollForActivityTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PollForActivityTaskCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PollForActivityTaskCommand");
+var de_PollForActivityTaskCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededFault":
+    case "com.amazonaws.swf#LimitExceededFault":
+      throw await de_LimitExceededFaultRes(parsedOutput, context);
+    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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PollForActivityTaskCommandError");
+var de_PollForDecisionTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PollForDecisionTaskCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DecisionTask(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PollForDecisionTaskCommand");
+var de_PollForDecisionTaskCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededFault":
+    case "com.amazonaws.swf#LimitExceededFault":
+      throw await de_LimitExceededFaultRes(parsedOutput, context);
+    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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PollForDecisionTaskCommandError");
+var de_RecordActivityTaskHeartbeatCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RecordActivityTaskHeartbeatCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_RecordActivityTaskHeartbeatCommand");
+var de_RecordActivityTaskHeartbeatCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RecordActivityTaskHeartbeatCommandError");
+var de_RegisterActivityTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RegisterActivityTypeCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_RegisterActivityTypeCommand");
+var de_RegisterActivityTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededFault":
+    case "com.amazonaws.swf#LimitExceededFault":
+      throw await de_LimitExceededFaultRes(parsedOutput, context);
+    case "OperationNotPermittedFault":
+    case "com.amazonaws.swf#OperationNotPermittedFault":
+      throw await de_OperationNotPermittedFaultRes(parsedOutput, context);
+    case "TypeAlreadyExistsFault":
+    case "com.amazonaws.swf#TypeAlreadyExistsFault":
+      throw await de_TypeAlreadyExistsFaultRes(parsedOutput, context);
+    case "UnknownResourceFault":
+    case "com.amazonaws.swf#UnknownResourceFault":
+      throw await de_UnknownResourceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RegisterActivityTypeCommandError");
+var de_RegisterDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RegisterDomainCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_RegisterDomainCommand");
+var de_RegisterDomainCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DomainAlreadyExistsFault":
+    case "com.amazonaws.swf#DomainAlreadyExistsFault":
+      throw await de_DomainAlreadyExistsFaultRes(parsedOutput, context);
+    case "LimitExceededFault":
+    case "com.amazonaws.swf#LimitExceededFault":
+      throw await de_LimitExceededFaultRes(parsedOutput, context);
+    case "OperationNotPermittedFault":
+    case "com.amazonaws.swf#OperationNotPermittedFault":
+      throw await de_OperationNotPermittedFaultRes(parsedOutput, context);
+    case "TooManyTagsFault":
+    case "com.amazonaws.swf#TooManyTagsFault":
+      throw await de_TooManyTagsFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RegisterDomainCommandError");
+var de_RegisterWorkflowTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RegisterWorkflowTypeCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_RegisterWorkflowTypeCommand");
+var de_RegisterWorkflowTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededFault":
+    case "com.amazonaws.swf#LimitExceededFault":
+      throw await de_LimitExceededFaultRes(parsedOutput, context);
+    case "OperationNotPermittedFault":
+    case "com.amazonaws.swf#OperationNotPermittedFault":
+      throw await de_OperationNotPermittedFaultRes(parsedOutput, context);
+    case "TypeAlreadyExistsFault":
+    case "com.amazonaws.swf#TypeAlreadyExistsFault":
+      throw await de_TypeAlreadyExistsFaultRes(parsedOutput, context);
+    case "UnknownResourceFault":
+    case "com.amazonaws.swf#UnknownResourceFault":
+      throw await de_UnknownResourceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RegisterWorkflowTypeCommandError");
+var de_RequestCancelWorkflowExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RequestCancelWorkflowExecutionCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_RequestCancelWorkflowExecutionCommand");
+var de_RequestCancelWorkflowExecutionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RequestCancelWorkflowExecutionCommandError");
+var de_RespondActivityTaskCanceledCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RespondActivityTaskCanceledCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_RespondActivityTaskCanceledCommand");
+var de_RespondActivityTaskCanceledCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RespondActivityTaskCanceledCommandError");
+var de_RespondActivityTaskCompletedCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RespondActivityTaskCompletedCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_RespondActivityTaskCompletedCommand");
+var de_RespondActivityTaskCompletedCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RespondActivityTaskCompletedCommandError");
+var de_RespondActivityTaskFailedCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RespondActivityTaskFailedCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_RespondActivityTaskFailedCommand");
+var de_RespondActivityTaskFailedCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RespondActivityTaskFailedCommandError");
+var de_RespondDecisionTaskCompletedCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RespondDecisionTaskCompletedCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_RespondDecisionTaskCompletedCommand");
+var de_RespondDecisionTaskCompletedCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RespondDecisionTaskCompletedCommandError");
+var de_SignalWorkflowExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SignalWorkflowExecutionCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_SignalWorkflowExecutionCommand");
+var de_SignalWorkflowExecutionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SignalWorkflowExecutionCommandError");
+var de_StartWorkflowExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartWorkflowExecutionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartWorkflowExecutionCommand");
+var de_StartWorkflowExecutionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DefaultUndefinedFault":
+    case "com.amazonaws.swf#DefaultUndefinedFault":
+      throw await de_DefaultUndefinedFaultRes(parsedOutput, context);
+    case "LimitExceededFault":
+    case "com.amazonaws.swf#LimitExceededFault":
+      throw await de_LimitExceededFaultRes(parsedOutput, context);
+    case "OperationNotPermittedFault":
+    case "com.amazonaws.swf#OperationNotPermittedFault":
+      throw await de_OperationNotPermittedFaultRes(parsedOutput, context);
+    case "TypeDeprecatedFault":
+    case "com.amazonaws.swf#TypeDeprecatedFault":
+      throw await de_TypeDeprecatedFaultRes(parsedOutput, context);
+    case "UnknownResourceFault":
+    case "com.amazonaws.swf#UnknownResourceFault":
+      throw await de_UnknownResourceFaultRes(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_StartWorkflowExecutionCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededFault":
+    case "com.amazonaws.swf#LimitExceededFault":
+      throw await de_LimitExceededFaultRes(parsedOutput, context);
+    case "OperationNotPermittedFault":
+    case "com.amazonaws.swf#OperationNotPermittedFault":
+      throw await de_OperationNotPermittedFaultRes(parsedOutput, context);
+    case "TooManyTagsFault":
+    case "com.amazonaws.swf#TooManyTagsFault":
+      throw await de_TooManyTagsFaultRes(parsedOutput, context);
+    case "UnknownResourceFault":
+    case "com.amazonaws.swf#UnknownResourceFault":
+      throw await de_UnknownResourceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_TerminateWorkflowExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TerminateWorkflowExecutionCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_TerminateWorkflowExecutionCommand");
+var de_TerminateWorkflowExecutionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = 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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TerminateWorkflowExecutionCommandError");
+var de_UndeprecateActivityTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UndeprecateActivityTypeCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_UndeprecateActivityTypeCommand");
+var de_UndeprecateActivityTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "OperationNotPermittedFault":
+    case "com.amazonaws.swf#OperationNotPermittedFault":
+      throw await de_OperationNotPermittedFaultRes(parsedOutput, context);
+    case "TypeAlreadyExistsFault":
+    case "com.amazonaws.swf#TypeAlreadyExistsFault":
+      throw await de_TypeAlreadyExistsFaultRes(parsedOutput, context);
+    case "UnknownResourceFault":
+    case "com.amazonaws.swf#UnknownResourceFault":
+      throw await de_UnknownResourceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UndeprecateActivityTypeCommandError");
+var de_UndeprecateDomainCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UndeprecateDomainCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_UndeprecateDomainCommand");
+var de_UndeprecateDomainCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DomainAlreadyExistsFault":
+    case "com.amazonaws.swf#DomainAlreadyExistsFault":
+      throw await de_DomainAlreadyExistsFaultRes(parsedOutput, context);
+    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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UndeprecateDomainCommandError");
+var de_UndeprecateWorkflowTypeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UndeprecateWorkflowTypeCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_UndeprecateWorkflowTypeCommand");
+var de_UndeprecateWorkflowTypeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "OperationNotPermittedFault":
+    case "com.amazonaws.swf#OperationNotPermittedFault":
+      throw await de_OperationNotPermittedFaultRes(parsedOutput, context);
+    case "TypeAlreadyExistsFault":
+    case "com.amazonaws.swf#TypeAlreadyExistsFault":
+      throw await de_TypeAlreadyExistsFaultRes(parsedOutput, context);
+    case "UnknownResourceFault":
+    case "com.amazonaws.swf#UnknownResourceFault":
+      throw await de_UnknownResourceFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UndeprecateWorkflowTypeCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LimitExceededFault":
+    case "com.amazonaws.swf#LimitExceededFault":
+      throw await de_LimitExceededFaultRes(parsedOutput, context);
+    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);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+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_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: (_) => se_ExecutionTimeFilter(_, context),
+    domain: [],
+    executionFilter: import_smithy_client._json,
+    startTimeFilter: (_) => se_ExecutionTimeFilter(_, context),
+    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: (_) => se_ExecutionTimeFilter(_, context),
+    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: (_) => Math.round(_.getTime() / 1e3),
+    oldestDate: (_) => Math.round(_.getTime() / 1e3)
+  });
+}, "se_ExecutionTimeFilter");
+var se_ListClosedWorkflowExecutionsInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    closeStatusFilter: import_smithy_client._json,
+    closeTimeFilter: (_) => se_ExecutionTimeFilter(_, context),
+    domain: [],
+    executionFilter: import_smithy_client._json,
+    maximumPageSize: [],
+    nextPageToken: [],
+    reverseOrder: [],
+    startTimeFilter: (_) => se_ExecutionTimeFilter(_, context),
+    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: (_) => se_ExecutionTimeFilter(_, context),
+    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: (_) => de_ActivityTypeInfo(_, context)
+  });
+}, "de_ActivityTypeDetail");
+var de_ActivityTypeInfo = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    activityType: import_smithy_client._json,
+    creationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    deprecationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    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: (_) => de_ActivityTypeInfoList(_, context)
+  });
+}, "de_ActivityTypeInfos");
+var de_DecisionTask = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    events: (_) => de_HistoryEventList(_, context),
+    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: (_) => de_HistoryEventList(_, context),
+    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: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    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: (_) => de_WorkflowExecutionInfo(_, context),
+    latestActivityTaskTimestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    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: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    execution: import_smithy_client._json,
+    executionStatus: import_smithy_client.expectString,
+    parent: import_smithy_client._json,
+    startTimestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    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: (_) => de_WorkflowExecutionInfoList(_, context),
+    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: (_) => de_WorkflowTypeInfo(_, context)
+  });
+}, "de_WorkflowTypeDetail");
+var de_WorkflowTypeInfo = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    creationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    deprecationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    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: (_) => de_WorkflowTypeInfoList(_, context)
+  });
+}, "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 collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+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");
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/CountClosedWorkflowExecutionsCommand.ts
+var _CountClosedWorkflowExecutionsCommand = class _CountClosedWorkflowExecutionsCommand 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() {
+};
+__name(_CountClosedWorkflowExecutionsCommand, "CountClosedWorkflowExecutionsCommand");
+var CountClosedWorkflowExecutionsCommand = _CountClosedWorkflowExecutionsCommand;
+
+// src/commands/CountOpenWorkflowExecutionsCommand.ts
+
+
+
+
+var _CountOpenWorkflowExecutionsCommand = class _CountOpenWorkflowExecutionsCommand 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() {
+};
+__name(_CountOpenWorkflowExecutionsCommand, "CountOpenWorkflowExecutionsCommand");
+var CountOpenWorkflowExecutionsCommand = _CountOpenWorkflowExecutionsCommand;
+
+// src/commands/CountPendingActivityTasksCommand.ts
+
+
+
+
+var _CountPendingActivityTasksCommand = class _CountPendingActivityTasksCommand 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() {
+};
+__name(_CountPendingActivityTasksCommand, "CountPendingActivityTasksCommand");
+var CountPendingActivityTasksCommand = _CountPendingActivityTasksCommand;
+
+// src/commands/CountPendingDecisionTasksCommand.ts
+
+
+
+
+var _CountPendingDecisionTasksCommand = class _CountPendingDecisionTasksCommand 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() {
+};
+__name(_CountPendingDecisionTasksCommand, "CountPendingDecisionTasksCommand");
+var CountPendingDecisionTasksCommand = _CountPendingDecisionTasksCommand;
+
+// src/commands/DeprecateActivityTypeCommand.ts
+
+
+
+
+var _DeprecateActivityTypeCommand = class _DeprecateActivityTypeCommand 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() {
+};
+__name(_DeprecateActivityTypeCommand, "DeprecateActivityTypeCommand");
+var DeprecateActivityTypeCommand = _DeprecateActivityTypeCommand;
+
+// src/commands/DeprecateDomainCommand.ts
+
+
+
+
+var _DeprecateDomainCommand = class _DeprecateDomainCommand 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() {
+};
+__name(_DeprecateDomainCommand, "DeprecateDomainCommand");
+var DeprecateDomainCommand = _DeprecateDomainCommand;
+
+// src/commands/DeprecateWorkflowTypeCommand.ts
+
+
+
+
+var _DeprecateWorkflowTypeCommand = class _DeprecateWorkflowTypeCommand 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() {
+};
+__name(_DeprecateWorkflowTypeCommand, "DeprecateWorkflowTypeCommand");
+var DeprecateWorkflowTypeCommand = _DeprecateWorkflowTypeCommand;
+
+// src/commands/DescribeActivityTypeCommand.ts
+
+
+
+
+var _DescribeActivityTypeCommand = class _DescribeActivityTypeCommand 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() {
+};
+__name(_DescribeActivityTypeCommand, "DescribeActivityTypeCommand");
+var DescribeActivityTypeCommand = _DescribeActivityTypeCommand;
+
+// src/commands/DescribeDomainCommand.ts
+
+
+
+
+var _DescribeDomainCommand = class _DescribeDomainCommand 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() {
+};
+__name(_DescribeDomainCommand, "DescribeDomainCommand");
+var DescribeDomainCommand = _DescribeDomainCommand;
+
+// src/commands/DescribeWorkflowExecutionCommand.ts
+
+
+
+
+var _DescribeWorkflowExecutionCommand = class _DescribeWorkflowExecutionCommand 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() {
+};
+__name(_DescribeWorkflowExecutionCommand, "DescribeWorkflowExecutionCommand");
+var DescribeWorkflowExecutionCommand = _DescribeWorkflowExecutionCommand;
+
+// src/commands/DescribeWorkflowTypeCommand.ts
+
+
+
+
+var _DescribeWorkflowTypeCommand = class _DescribeWorkflowTypeCommand 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() {
+};
+__name(_DescribeWorkflowTypeCommand, "DescribeWorkflowTypeCommand");
+var DescribeWorkflowTypeCommand = _DescribeWorkflowTypeCommand;
+
+// src/commands/GetWorkflowExecutionHistoryCommand.ts
+
+
+
+
+var _GetWorkflowExecutionHistoryCommand = class _GetWorkflowExecutionHistoryCommand 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() {
+};
+__name(_GetWorkflowExecutionHistoryCommand, "GetWorkflowExecutionHistoryCommand");
+var GetWorkflowExecutionHistoryCommand = _GetWorkflowExecutionHistoryCommand;
+
+// src/commands/ListActivityTypesCommand.ts
+
+
+
+
+var _ListActivityTypesCommand = class _ListActivityTypesCommand 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() {
+};
+__name(_ListActivityTypesCommand, "ListActivityTypesCommand");
+var ListActivityTypesCommand = _ListActivityTypesCommand;
+
+// src/commands/ListClosedWorkflowExecutionsCommand.ts
+
+
+
+
+var _ListClosedWorkflowExecutionsCommand = class _ListClosedWorkflowExecutionsCommand 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() {
+};
+__name(_ListClosedWorkflowExecutionsCommand, "ListClosedWorkflowExecutionsCommand");
+var ListClosedWorkflowExecutionsCommand = _ListClosedWorkflowExecutionsCommand;
+
+// src/commands/ListDomainsCommand.ts
+
+
+
+
+var _ListDomainsCommand = class _ListDomainsCommand 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() {
+};
+__name(_ListDomainsCommand, "ListDomainsCommand");
+var ListDomainsCommand = _ListDomainsCommand;
+
+// src/commands/ListOpenWorkflowExecutionsCommand.ts
+
+
+
+
+var _ListOpenWorkflowExecutionsCommand = class _ListOpenWorkflowExecutionsCommand 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() {
+};
+__name(_ListOpenWorkflowExecutionsCommand, "ListOpenWorkflowExecutionsCommand");
+var ListOpenWorkflowExecutionsCommand = _ListOpenWorkflowExecutionsCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand 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() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/ListWorkflowTypesCommand.ts
+
+
+
+
+var _ListWorkflowTypesCommand = class _ListWorkflowTypesCommand 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() {
+};
+__name(_ListWorkflowTypesCommand, "ListWorkflowTypesCommand");
+var ListWorkflowTypesCommand = _ListWorkflowTypesCommand;
+
+// src/commands/PollForActivityTaskCommand.ts
+
+
+
+
+var _PollForActivityTaskCommand = class _PollForActivityTaskCommand 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() {
+};
+__name(_PollForActivityTaskCommand, "PollForActivityTaskCommand");
+var PollForActivityTaskCommand = _PollForActivityTaskCommand;
+
+// src/commands/PollForDecisionTaskCommand.ts
+
+
+
+
+var _PollForDecisionTaskCommand = class _PollForDecisionTaskCommand 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() {
+};
+__name(_PollForDecisionTaskCommand, "PollForDecisionTaskCommand");
+var PollForDecisionTaskCommand = _PollForDecisionTaskCommand;
+
+// src/commands/RecordActivityTaskHeartbeatCommand.ts
+
+
+
+
+var _RecordActivityTaskHeartbeatCommand = class _RecordActivityTaskHeartbeatCommand 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() {
+};
+__name(_RecordActivityTaskHeartbeatCommand, "RecordActivityTaskHeartbeatCommand");
+var RecordActivityTaskHeartbeatCommand = _RecordActivityTaskHeartbeatCommand;
+
+// src/commands/RegisterActivityTypeCommand.ts
+
+
+
+
+var _RegisterActivityTypeCommand = class _RegisterActivityTypeCommand 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() {
+};
+__name(_RegisterActivityTypeCommand, "RegisterActivityTypeCommand");
+var RegisterActivityTypeCommand = _RegisterActivityTypeCommand;
+
+// src/commands/RegisterDomainCommand.ts
+
+
+
+
+var _RegisterDomainCommand = class _RegisterDomainCommand 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() {
+};
+__name(_RegisterDomainCommand, "RegisterDomainCommand");
+var RegisterDomainCommand = _RegisterDomainCommand;
+
+// src/commands/RegisterWorkflowTypeCommand.ts
+
+
+
+
+var _RegisterWorkflowTypeCommand = class _RegisterWorkflowTypeCommand 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() {
+};
+__name(_RegisterWorkflowTypeCommand, "RegisterWorkflowTypeCommand");
+var RegisterWorkflowTypeCommand = _RegisterWorkflowTypeCommand;
+
+// src/commands/RequestCancelWorkflowExecutionCommand.ts
+
+
+
+
+var _RequestCancelWorkflowExecutionCommand = class _RequestCancelWorkflowExecutionCommand 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() {
+};
+__name(_RequestCancelWorkflowExecutionCommand, "RequestCancelWorkflowExecutionCommand");
+var RequestCancelWorkflowExecutionCommand = _RequestCancelWorkflowExecutionCommand;
+
+// src/commands/RespondActivityTaskCanceledCommand.ts
+
+
+
+
+var _RespondActivityTaskCanceledCommand = class _RespondActivityTaskCanceledCommand 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() {
+};
+__name(_RespondActivityTaskCanceledCommand, "RespondActivityTaskCanceledCommand");
+var RespondActivityTaskCanceledCommand = _RespondActivityTaskCanceledCommand;
+
+// src/commands/RespondActivityTaskCompletedCommand.ts
+
+
+
+
+var _RespondActivityTaskCompletedCommand = class _RespondActivityTaskCompletedCommand 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() {
+};
+__name(_RespondActivityTaskCompletedCommand, "RespondActivityTaskCompletedCommand");
+var RespondActivityTaskCompletedCommand = _RespondActivityTaskCompletedCommand;
+
+// src/commands/RespondActivityTaskFailedCommand.ts
+
+
+
+
+var _RespondActivityTaskFailedCommand = class _RespondActivityTaskFailedCommand 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() {
+};
+__name(_RespondActivityTaskFailedCommand, "RespondActivityTaskFailedCommand");
+var RespondActivityTaskFailedCommand = _RespondActivityTaskFailedCommand;
+
+// src/commands/RespondDecisionTaskCompletedCommand.ts
+
+
+
+
+var _RespondDecisionTaskCompletedCommand = class _RespondDecisionTaskCompletedCommand 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() {
+};
+__name(_RespondDecisionTaskCompletedCommand, "RespondDecisionTaskCompletedCommand");
+var RespondDecisionTaskCompletedCommand = _RespondDecisionTaskCompletedCommand;
+
+// src/commands/SignalWorkflowExecutionCommand.ts
+
+
+
+
+var _SignalWorkflowExecutionCommand = class _SignalWorkflowExecutionCommand 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() {
+};
+__name(_SignalWorkflowExecutionCommand, "SignalWorkflowExecutionCommand");
+var SignalWorkflowExecutionCommand = _SignalWorkflowExecutionCommand;
+
+// src/commands/StartWorkflowExecutionCommand.ts
+
+
+
+
+var _StartWorkflowExecutionCommand = class _StartWorkflowExecutionCommand 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() {
+};
+__name(_StartWorkflowExecutionCommand, "StartWorkflowExecutionCommand");
+var StartWorkflowExecutionCommand = _StartWorkflowExecutionCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand 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() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/TerminateWorkflowExecutionCommand.ts
+
+
+
+
+var _TerminateWorkflowExecutionCommand = class _TerminateWorkflowExecutionCommand 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() {
+};
+__name(_TerminateWorkflowExecutionCommand, "TerminateWorkflowExecutionCommand");
+var TerminateWorkflowExecutionCommand = _TerminateWorkflowExecutionCommand;
+
+// src/commands/UndeprecateActivityTypeCommand.ts
+
+
+
+
+var _UndeprecateActivityTypeCommand = class _UndeprecateActivityTypeCommand 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() {
+};
+__name(_UndeprecateActivityTypeCommand, "UndeprecateActivityTypeCommand");
+var UndeprecateActivityTypeCommand = _UndeprecateActivityTypeCommand;
+
+// src/commands/UndeprecateDomainCommand.ts
+
+
+
+
+var _UndeprecateDomainCommand = class _UndeprecateDomainCommand 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() {
+};
+__name(_UndeprecateDomainCommand, "UndeprecateDomainCommand");
+var UndeprecateDomainCommand = _UndeprecateDomainCommand;
+
+// src/commands/UndeprecateWorkflowTypeCommand.ts
+
+
+
+
+var _UndeprecateWorkflowTypeCommand = class _UndeprecateWorkflowTypeCommand 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() {
+};
+__name(_UndeprecateWorkflowTypeCommand, "UndeprecateWorkflowTypeCommand");
+var UndeprecateWorkflowTypeCommand = _UndeprecateWorkflowTypeCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand 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() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/SWF.ts
+var commands = {
+  CountClosedWorkflowExecutionsCommand,
+  CountOpenWorkflowExecutionsCommand,
+  CountPendingActivityTasksCommand,
+  CountPendingDecisionTasksCommand,
+  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 _SWF extends SWFClient {
+};
+__name(_SWF, "SWF");
+var SWF = _SWF;
+(0, import_smithy_client.createAggregatedClient)(commands, SWF);
+
+// src/pagination/GetWorkflowExecutionHistoryPaginator.ts
+var import_core = require("@smithy/core");
+var paginateGetWorkflowExecutionHistory = (0, import_core.createPaginator)(SWFClient, GetWorkflowExecutionHistoryCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
+
+// src/pagination/ListActivityTypesPaginator.ts
+
+var paginateListActivityTypes = (0, import_core.createPaginator)(SWFClient, ListActivityTypesCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
+
+// src/pagination/ListClosedWorkflowExecutionsPaginator.ts
+
+var paginateListClosedWorkflowExecutions = (0, import_core.createPaginator)(SWFClient, ListClosedWorkflowExecutionsCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
+
+// src/pagination/ListDomainsPaginator.ts
+
+var paginateListDomains = (0, import_core.createPaginator)(SWFClient, ListDomainsCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
+
+// src/pagination/ListOpenWorkflowExecutionsPaginator.ts
+
+var paginateListOpenWorkflowExecutions = (0, import_core.createPaginator)(SWFClient, ListOpenWorkflowExecutionsCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
+
+// src/pagination/ListWorkflowTypesPaginator.ts
+
+var paginateListWorkflowTypes = (0, import_core.createPaginator)(SWFClient, ListWorkflowTypesCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
+
+// src/pagination/PollForDecisionTaskPaginator.ts
+
+var paginatePollForDecisionTask = (0, import_core.createPaginator)(SWFClient, PollForDecisionTaskCommand, "nextPageToken", "nextPageToken", "maximumPageSize");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActivityTaskTimeoutType,
+  CancelTimerFailedCause,
+  CancelWorkflowExecutionFailedCause,
+  ChildPolicy,
+  CloseStatus,
+  CompleteWorkflowExecutionFailedCause,
+  ContinueAsNewWorkflowExecutionFailedCause,
+  CountClosedWorkflowExecutionsCommand,
+  CountOpenWorkflowExecutionsCommand,
+  CountPendingActivityTasksCommand,
+  CountPendingDecisionTasksCommand,
+  DecisionTaskTimeoutType,
+  DecisionType,
+  DefaultUndefinedFault,
+  DeprecateActivityTypeCommand,
+  DeprecateDomainCommand,
+  DeprecateWorkflowTypeCommand,
+  DescribeActivityTypeCommand,
+  DescribeDomainCommand,
+  DescribeWorkflowExecutionCommand,
+  DescribeWorkflowTypeCommand,
+  DomainAlreadyExistsFault,
+  DomainDeprecatedFault,
+  EventType,
+  ExecutionStatus,
+  FailWorkflowExecutionFailedCause,
+  GetWorkflowExecutionHistoryCommand,
+  LambdaFunctionTimeoutType,
+  LimitExceededFault,
+  ListActivityTypesCommand,
+  ListClosedWorkflowExecutionsCommand,
+  ListDomainsCommand,
+  ListOpenWorkflowExecutionsCommand,
+  ListTagsForResourceCommand,
+  ListWorkflowTypesCommand,
+  OperationNotPermittedFault,
+  PollForActivityTaskCommand,
+  PollForDecisionTaskCommand,
+  RecordActivityTaskHeartbeatCommand,
+  RecordMarkerFailedCause,
+  RegisterActivityTypeCommand,
+  RegisterDomainCommand,
+  RegisterWorkflowTypeCommand,
+  RegistrationStatus,
+  RequestCancelActivityTaskFailedCause,
+  RequestCancelExternalWorkflowExecutionFailedCause,
+  RequestCancelWorkflowExecutionCommand,
+  RespondActivityTaskCanceledCommand,
+  RespondActivityTaskCompletedCommand,
+  RespondActivityTaskFailedCommand,
+  RespondDecisionTaskCompletedCommand,
+  SWF,
+  SWFClient,
+  SWFServiceException,
+  ScheduleActivityTaskFailedCause,
+  ScheduleLambdaFunctionFailedCause,
+  SignalExternalWorkflowExecutionFailedCause,
+  SignalWorkflowExecutionCommand,
+  StartChildWorkflowExecutionFailedCause,
+  StartLambdaFunctionFailedCause,
+  StartTimerFailedCause,
+  StartWorkflowExecutionCommand,
+  TagResourceCommand,
+  TerminateWorkflowExecutionCommand,
+  TooManyTagsFault,
+  TypeAlreadyExistsFault,
+  TypeDeprecatedFault,
+  UndeprecateActivityTypeCommand,
+  UndeprecateDomainCommand,
+  UndeprecateWorkflowTypeCommand,
+  UnknownResourceFault,
+  UntagResourceCommand,
+  WorkflowExecutionAlreadyStartedFault,
+  WorkflowExecutionCancelRequestedCause,
+  WorkflowExecutionTerminatedCause,
+  WorkflowExecutionTimeoutType,
+  __Client,
+  paginateGetWorkflowExecutionHistory,
+  paginateListActivityTypes,
+  paginateListClosedWorkflowExecutions,
+  paginateListDomains,
+  paginateListOpenWorkflowExecutions,
+  paginateListWorkflowTypes,
+  paginatePollForDecisionTask
+});