@aws-sdk/client-sfn 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,4365 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SFNServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./SFNClient"), exports);
-tslib_1.__exportStar(require("./SFN"), 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 SFNServiceException_1 = require("./models/SFNServiceException");
-Object.defineProperty(exports, "SFNServiceException", { enumerable: true, get: function () { return SFNServiceException_1.SFNServiceException; } });
+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, {
+  ActivityDoesNotExist: () => ActivityDoesNotExist,
+  ActivityFailedEventDetailsFilterSensitiveLog: () => ActivityFailedEventDetailsFilterSensitiveLog,
+  ActivityLimitExceeded: () => ActivityLimitExceeded,
+  ActivityScheduleFailedEventDetailsFilterSensitiveLog: () => ActivityScheduleFailedEventDetailsFilterSensitiveLog,
+  ActivityScheduledEventDetailsFilterSensitiveLog: () => ActivityScheduledEventDetailsFilterSensitiveLog,
+  ActivitySucceededEventDetailsFilterSensitiveLog: () => ActivitySucceededEventDetailsFilterSensitiveLog,
+  ActivityTimedOutEventDetailsFilterSensitiveLog: () => ActivityTimedOutEventDetailsFilterSensitiveLog,
+  ActivityWorkerLimitExceeded: () => ActivityWorkerLimitExceeded,
+  ConflictException: () => ConflictException,
+  CreateActivityCommand: () => CreateActivityCommand,
+  CreateStateMachineAliasCommand: () => CreateStateMachineAliasCommand,
+  CreateStateMachineAliasInputFilterSensitiveLog: () => CreateStateMachineAliasInputFilterSensitiveLog,
+  CreateStateMachineCommand: () => CreateStateMachineCommand,
+  CreateStateMachineInputFilterSensitiveLog: () => CreateStateMachineInputFilterSensitiveLog,
+  DeleteActivityCommand: () => DeleteActivityCommand,
+  DeleteStateMachineAliasCommand: () => DeleteStateMachineAliasCommand,
+  DeleteStateMachineCommand: () => DeleteStateMachineCommand,
+  DeleteStateMachineVersionCommand: () => DeleteStateMachineVersionCommand,
+  DescribeActivityCommand: () => DescribeActivityCommand,
+  DescribeExecutionCommand: () => DescribeExecutionCommand,
+  DescribeExecutionOutputFilterSensitiveLog: () => DescribeExecutionOutputFilterSensitiveLog,
+  DescribeMapRunCommand: () => DescribeMapRunCommand,
+  DescribeStateMachineAliasCommand: () => DescribeStateMachineAliasCommand,
+  DescribeStateMachineAliasOutputFilterSensitiveLog: () => DescribeStateMachineAliasOutputFilterSensitiveLog,
+  DescribeStateMachineCommand: () => DescribeStateMachineCommand,
+  DescribeStateMachineForExecutionCommand: () => DescribeStateMachineForExecutionCommand,
+  DescribeStateMachineForExecutionOutputFilterSensitiveLog: () => DescribeStateMachineForExecutionOutputFilterSensitiveLog,
+  DescribeStateMachineOutputFilterSensitiveLog: () => DescribeStateMachineOutputFilterSensitiveLog,
+  ExecutionAbortedEventDetailsFilterSensitiveLog: () => ExecutionAbortedEventDetailsFilterSensitiveLog,
+  ExecutionAlreadyExists: () => ExecutionAlreadyExists,
+  ExecutionDoesNotExist: () => ExecutionDoesNotExist,
+  ExecutionFailedEventDetailsFilterSensitiveLog: () => ExecutionFailedEventDetailsFilterSensitiveLog,
+  ExecutionLimitExceeded: () => ExecutionLimitExceeded,
+  ExecutionNotRedrivable: () => ExecutionNotRedrivable,
+  ExecutionRedriveFilter: () => ExecutionRedriveFilter,
+  ExecutionRedriveStatus: () => ExecutionRedriveStatus,
+  ExecutionStartedEventDetailsFilterSensitiveLog: () => ExecutionStartedEventDetailsFilterSensitiveLog,
+  ExecutionStatus: () => ExecutionStatus,
+  ExecutionSucceededEventDetailsFilterSensitiveLog: () => ExecutionSucceededEventDetailsFilterSensitiveLog,
+  ExecutionTimedOutEventDetailsFilterSensitiveLog: () => ExecutionTimedOutEventDetailsFilterSensitiveLog,
+  GetActivityTaskCommand: () => GetActivityTaskCommand,
+  GetActivityTaskOutputFilterSensitiveLog: () => GetActivityTaskOutputFilterSensitiveLog,
+  GetExecutionHistoryCommand: () => GetExecutionHistoryCommand,
+  GetExecutionHistoryOutputFilterSensitiveLog: () => GetExecutionHistoryOutputFilterSensitiveLog,
+  HistoryEventFilterSensitiveLog: () => HistoryEventFilterSensitiveLog,
+  HistoryEventType: () => HistoryEventType,
+  InspectionDataFilterSensitiveLog: () => InspectionDataFilterSensitiveLog,
+  InspectionLevel: () => InspectionLevel,
+  InvalidArn: () => InvalidArn,
+  InvalidDefinition: () => InvalidDefinition,
+  InvalidExecutionInput: () => InvalidExecutionInput,
+  InvalidLoggingConfiguration: () => InvalidLoggingConfiguration,
+  InvalidName: () => InvalidName,
+  InvalidOutput: () => InvalidOutput,
+  InvalidToken: () => InvalidToken,
+  InvalidTracingConfiguration: () => InvalidTracingConfiguration,
+  LambdaFunctionFailedEventDetailsFilterSensitiveLog: () => LambdaFunctionFailedEventDetailsFilterSensitiveLog,
+  LambdaFunctionScheduleFailedEventDetailsFilterSensitiveLog: () => LambdaFunctionScheduleFailedEventDetailsFilterSensitiveLog,
+  LambdaFunctionScheduledEventDetailsFilterSensitiveLog: () => LambdaFunctionScheduledEventDetailsFilterSensitiveLog,
+  LambdaFunctionStartFailedEventDetailsFilterSensitiveLog: () => LambdaFunctionStartFailedEventDetailsFilterSensitiveLog,
+  LambdaFunctionSucceededEventDetailsFilterSensitiveLog: () => LambdaFunctionSucceededEventDetailsFilterSensitiveLog,
+  LambdaFunctionTimedOutEventDetailsFilterSensitiveLog: () => LambdaFunctionTimedOutEventDetailsFilterSensitiveLog,
+  ListActivitiesCommand: () => ListActivitiesCommand,
+  ListExecutionsCommand: () => ListExecutionsCommand,
+  ListMapRunsCommand: () => ListMapRunsCommand,
+  ListStateMachineAliasesCommand: () => ListStateMachineAliasesCommand,
+  ListStateMachineVersionsCommand: () => ListStateMachineVersionsCommand,
+  ListStateMachinesCommand: () => ListStateMachinesCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  LogLevel: () => LogLevel,
+  MapRunFailedEventDetailsFilterSensitiveLog: () => MapRunFailedEventDetailsFilterSensitiveLog,
+  MapRunStatus: () => MapRunStatus,
+  MissingRequiredParameter: () => MissingRequiredParameter,
+  PublishStateMachineVersionCommand: () => PublishStateMachineVersionCommand,
+  PublishStateMachineVersionInputFilterSensitiveLog: () => PublishStateMachineVersionInputFilterSensitiveLog,
+  RedriveExecutionCommand: () => RedriveExecutionCommand,
+  ResourceNotFound: () => ResourceNotFound,
+  SFN: () => SFN,
+  SFNClient: () => SFNClient,
+  SFNServiceException: () => SFNServiceException,
+  SendTaskFailureCommand: () => SendTaskFailureCommand,
+  SendTaskFailureInputFilterSensitiveLog: () => SendTaskFailureInputFilterSensitiveLog,
+  SendTaskHeartbeatCommand: () => SendTaskHeartbeatCommand,
+  SendTaskSuccessCommand: () => SendTaskSuccessCommand,
+  SendTaskSuccessInputFilterSensitiveLog: () => SendTaskSuccessInputFilterSensitiveLog,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  StartExecutionCommand: () => StartExecutionCommand,
+  StartExecutionInputFilterSensitiveLog: () => StartExecutionInputFilterSensitiveLog,
+  StartSyncExecutionCommand: () => StartSyncExecutionCommand,
+  StartSyncExecutionInputFilterSensitiveLog: () => StartSyncExecutionInputFilterSensitiveLog,
+  StartSyncExecutionOutputFilterSensitiveLog: () => StartSyncExecutionOutputFilterSensitiveLog,
+  StateEnteredEventDetailsFilterSensitiveLog: () => StateEnteredEventDetailsFilterSensitiveLog,
+  StateExitedEventDetailsFilterSensitiveLog: () => StateExitedEventDetailsFilterSensitiveLog,
+  StateMachineAlreadyExists: () => StateMachineAlreadyExists,
+  StateMachineDeleting: () => StateMachineDeleting,
+  StateMachineDoesNotExist: () => StateMachineDoesNotExist,
+  StateMachineLimitExceeded: () => StateMachineLimitExceeded,
+  StateMachineStatus: () => StateMachineStatus,
+  StateMachineType: () => StateMachineType,
+  StateMachineTypeNotSupported: () => StateMachineTypeNotSupported,
+  StopExecutionCommand: () => StopExecutionCommand,
+  StopExecutionInputFilterSensitiveLog: () => StopExecutionInputFilterSensitiveLog,
+  SyncExecutionStatus: () => SyncExecutionStatus,
+  TagResourceCommand: () => TagResourceCommand,
+  TaskDoesNotExist: () => TaskDoesNotExist,
+  TaskFailedEventDetailsFilterSensitiveLog: () => TaskFailedEventDetailsFilterSensitiveLog,
+  TaskScheduledEventDetailsFilterSensitiveLog: () => TaskScheduledEventDetailsFilterSensitiveLog,
+  TaskStartFailedEventDetailsFilterSensitiveLog: () => TaskStartFailedEventDetailsFilterSensitiveLog,
+  TaskSubmitFailedEventDetailsFilterSensitiveLog: () => TaskSubmitFailedEventDetailsFilterSensitiveLog,
+  TaskSubmittedEventDetailsFilterSensitiveLog: () => TaskSubmittedEventDetailsFilterSensitiveLog,
+  TaskSucceededEventDetailsFilterSensitiveLog: () => TaskSucceededEventDetailsFilterSensitiveLog,
+  TaskTimedOut: () => TaskTimedOut,
+  TaskTimedOutEventDetailsFilterSensitiveLog: () => TaskTimedOutEventDetailsFilterSensitiveLog,
+  TestExecutionStatus: () => TestExecutionStatus,
+  TestStateCommand: () => TestStateCommand,
+  TestStateInputFilterSensitiveLog: () => TestStateInputFilterSensitiveLog,
+  TestStateOutputFilterSensitiveLog: () => TestStateOutputFilterSensitiveLog,
+  TooManyTags: () => TooManyTags,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateMapRunCommand: () => UpdateMapRunCommand,
+  UpdateStateMachineAliasCommand: () => UpdateStateMachineAliasCommand,
+  UpdateStateMachineAliasInputFilterSensitiveLog: () => UpdateStateMachineAliasInputFilterSensitiveLog,
+  UpdateStateMachineCommand: () => UpdateStateMachineCommand,
+  UpdateStateMachineInputFilterSensitiveLog: () => UpdateStateMachineInputFilterSensitiveLog,
+  ValidationException: () => ValidationException,
+  ValidationExceptionReason: () => ValidationExceptionReason,
+  __Client: () => import_smithy_client.Client,
+  paginateGetExecutionHistory: () => paginateGetExecutionHistory,
+  paginateListActivities: () => paginateListActivities,
+  paginateListExecutions: () => paginateListExecutions,
+  paginateListMapRuns: () => paginateListMapRuns,
+  paginateListStateMachines: () => paginateListStateMachines
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/SFNClient.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: "states"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/SFNClient.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/SFNClient.ts
+var _SFNClient = class _SFNClient 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(_SFNClient, "SFNClient");
+var SFNClient = _SFNClient;
+
+// src/SFN.ts
+
+
+// src/commands/CreateActivityCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_0.ts
+
+
+var import_uuid = require("uuid");
+
+// src/models/models_0.ts
+
+
+// src/models/SFNServiceException.ts
+
+var _SFNServiceException = class _SFNServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _SFNServiceException.prototype);
+  }
+};
+__name(_SFNServiceException, "SFNServiceException");
+var SFNServiceException = _SFNServiceException;
+
+// src/models/models_0.ts
+var _ActivityDoesNotExist = class _ActivityDoesNotExist extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ActivityDoesNotExist",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ActivityDoesNotExist";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ActivityDoesNotExist.prototype);
+  }
+};
+__name(_ActivityDoesNotExist, "ActivityDoesNotExist");
+var ActivityDoesNotExist = _ActivityDoesNotExist;
+var _ActivityLimitExceeded = class _ActivityLimitExceeded extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ActivityLimitExceeded",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ActivityLimitExceeded";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ActivityLimitExceeded.prototype);
+  }
+};
+__name(_ActivityLimitExceeded, "ActivityLimitExceeded");
+var ActivityLimitExceeded = _ActivityLimitExceeded;
+var _ActivityWorkerLimitExceeded = class _ActivityWorkerLimitExceeded extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ActivityWorkerLimitExceeded",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ActivityWorkerLimitExceeded";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ActivityWorkerLimitExceeded.prototype);
+  }
+};
+__name(_ActivityWorkerLimitExceeded, "ActivityWorkerLimitExceeded");
+var ActivityWorkerLimitExceeded = _ActivityWorkerLimitExceeded;
+var _InvalidName = class _InvalidName extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidName",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidName";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidName.prototype);
+  }
+};
+__name(_InvalidName, "InvalidName");
+var InvalidName = _InvalidName;
+var _TooManyTags = class _TooManyTags extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyTags",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyTags";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyTags.prototype);
+    this.resourceName = opts.resourceName;
+  }
+};
+__name(_TooManyTags, "TooManyTags");
+var TooManyTags = _TooManyTags;
+var _ConflictException = class _ConflictException extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var LogLevel = {
+  ALL: "ALL",
+  ERROR: "ERROR",
+  FATAL: "FATAL",
+  OFF: "OFF"
+};
+var StateMachineType = {
+  EXPRESS: "EXPRESS",
+  STANDARD: "STANDARD"
+};
+var _InvalidArn = class _InvalidArn extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidArn",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidArn";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidArn.prototype);
+  }
+};
+__name(_InvalidArn, "InvalidArn");
+var InvalidArn = _InvalidArn;
+var _InvalidDefinition = class _InvalidDefinition extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidDefinition",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidDefinition";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidDefinition.prototype);
+  }
+};
+__name(_InvalidDefinition, "InvalidDefinition");
+var InvalidDefinition = _InvalidDefinition;
+var _InvalidLoggingConfiguration = class _InvalidLoggingConfiguration extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidLoggingConfiguration",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidLoggingConfiguration";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidLoggingConfiguration.prototype);
+  }
+};
+__name(_InvalidLoggingConfiguration, "InvalidLoggingConfiguration");
+var InvalidLoggingConfiguration = _InvalidLoggingConfiguration;
+var _InvalidTracingConfiguration = class _InvalidTracingConfiguration extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidTracingConfiguration",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidTracingConfiguration";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidTracingConfiguration.prototype);
+  }
+};
+__name(_InvalidTracingConfiguration, "InvalidTracingConfiguration");
+var InvalidTracingConfiguration = _InvalidTracingConfiguration;
+var _StateMachineAlreadyExists = class _StateMachineAlreadyExists extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "StateMachineAlreadyExists",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "StateMachineAlreadyExists";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _StateMachineAlreadyExists.prototype);
+  }
+};
+__name(_StateMachineAlreadyExists, "StateMachineAlreadyExists");
+var StateMachineAlreadyExists = _StateMachineAlreadyExists;
+var _StateMachineDeleting = class _StateMachineDeleting extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "StateMachineDeleting",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "StateMachineDeleting";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _StateMachineDeleting.prototype);
+  }
+};
+__name(_StateMachineDeleting, "StateMachineDeleting");
+var StateMachineDeleting = _StateMachineDeleting;
+var _StateMachineLimitExceeded = class _StateMachineLimitExceeded extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "StateMachineLimitExceeded",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "StateMachineLimitExceeded";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _StateMachineLimitExceeded.prototype);
+  }
+};
+__name(_StateMachineLimitExceeded, "StateMachineLimitExceeded");
+var StateMachineLimitExceeded = _StateMachineLimitExceeded;
+var _StateMachineTypeNotSupported = class _StateMachineTypeNotSupported extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "StateMachineTypeNotSupported",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "StateMachineTypeNotSupported";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _StateMachineTypeNotSupported.prototype);
+  }
+};
+__name(_StateMachineTypeNotSupported, "StateMachineTypeNotSupported");
+var StateMachineTypeNotSupported = _StateMachineTypeNotSupported;
+var ValidationExceptionReason = {
+  API_DOES_NOT_SUPPORT_LABELED_ARNS: "API_DOES_NOT_SUPPORT_LABELED_ARNS",
+  CANNOT_UPDATE_COMPLETED_MAP_RUN: "CANNOT_UPDATE_COMPLETED_MAP_RUN",
+  INVALID_ROUTING_CONFIGURATION: "INVALID_ROUTING_CONFIGURATION",
+  MISSING_REQUIRED_PARAMETER: "MISSING_REQUIRED_PARAMETER"
+};
+var _ValidationException = class _ValidationException extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+    this.reason = opts.reason;
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var _ResourceNotFound = class _ResourceNotFound extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFound",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFound";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFound.prototype);
+    this.resourceName = opts.resourceName;
+  }
+};
+__name(_ResourceNotFound, "ResourceNotFound");
+var ResourceNotFound = _ResourceNotFound;
+var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+  }
+};
+__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
+var ServiceQuotaExceededException = _ServiceQuotaExceededException;
+var ExecutionRedriveStatus = {
+  NOT_REDRIVABLE: "NOT_REDRIVABLE",
+  REDRIVABLE: "REDRIVABLE",
+  REDRIVABLE_BY_MAP_RUN: "REDRIVABLE_BY_MAP_RUN"
+};
+var ExecutionStatus = {
+  ABORTED: "ABORTED",
+  FAILED: "FAILED",
+  PENDING_REDRIVE: "PENDING_REDRIVE",
+  RUNNING: "RUNNING",
+  SUCCEEDED: "SUCCEEDED",
+  TIMED_OUT: "TIMED_OUT"
+};
+var _ExecutionDoesNotExist = class _ExecutionDoesNotExist extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ExecutionDoesNotExist",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ExecutionDoesNotExist";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ExecutionDoesNotExist.prototype);
+  }
+};
+__name(_ExecutionDoesNotExist, "ExecutionDoesNotExist");
+var ExecutionDoesNotExist = _ExecutionDoesNotExist;
+var MapRunStatus = {
+  ABORTED: "ABORTED",
+  FAILED: "FAILED",
+  RUNNING: "RUNNING",
+  SUCCEEDED: "SUCCEEDED"
+};
+var StateMachineStatus = {
+  ACTIVE: "ACTIVE",
+  DELETING: "DELETING"
+};
+var _StateMachineDoesNotExist = class _StateMachineDoesNotExist extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "StateMachineDoesNotExist",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "StateMachineDoesNotExist";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _StateMachineDoesNotExist.prototype);
+  }
+};
+__name(_StateMachineDoesNotExist, "StateMachineDoesNotExist");
+var StateMachineDoesNotExist = _StateMachineDoesNotExist;
+var HistoryEventType = {
+  ActivityFailed: "ActivityFailed",
+  ActivityScheduleFailed: "ActivityScheduleFailed",
+  ActivityScheduled: "ActivityScheduled",
+  ActivityStarted: "ActivityStarted",
+  ActivitySucceeded: "ActivitySucceeded",
+  ActivityTimedOut: "ActivityTimedOut",
+  ChoiceStateEntered: "ChoiceStateEntered",
+  ChoiceStateExited: "ChoiceStateExited",
+  ExecutionAborted: "ExecutionAborted",
+  ExecutionFailed: "ExecutionFailed",
+  ExecutionRedriven: "ExecutionRedriven",
+  ExecutionStarted: "ExecutionStarted",
+  ExecutionSucceeded: "ExecutionSucceeded",
+  ExecutionTimedOut: "ExecutionTimedOut",
+  FailStateEntered: "FailStateEntered",
+  LambdaFunctionFailed: "LambdaFunctionFailed",
+  LambdaFunctionScheduleFailed: "LambdaFunctionScheduleFailed",
+  LambdaFunctionScheduled: "LambdaFunctionScheduled",
+  LambdaFunctionStartFailed: "LambdaFunctionStartFailed",
+  LambdaFunctionStarted: "LambdaFunctionStarted",
+  LambdaFunctionSucceeded: "LambdaFunctionSucceeded",
+  LambdaFunctionTimedOut: "LambdaFunctionTimedOut",
+  MapIterationAborted: "MapIterationAborted",
+  MapIterationFailed: "MapIterationFailed",
+  MapIterationStarted: "MapIterationStarted",
+  MapIterationSucceeded: "MapIterationSucceeded",
+  MapRunAborted: "MapRunAborted",
+  MapRunFailed: "MapRunFailed",
+  MapRunRedriven: "MapRunRedriven",
+  MapRunStarted: "MapRunStarted",
+  MapRunSucceeded: "MapRunSucceeded",
+  MapStateAborted: "MapStateAborted",
+  MapStateEntered: "MapStateEntered",
+  MapStateExited: "MapStateExited",
+  MapStateFailed: "MapStateFailed",
+  MapStateStarted: "MapStateStarted",
+  MapStateSucceeded: "MapStateSucceeded",
+  ParallelStateAborted: "ParallelStateAborted",
+  ParallelStateEntered: "ParallelStateEntered",
+  ParallelStateExited: "ParallelStateExited",
+  ParallelStateFailed: "ParallelStateFailed",
+  ParallelStateStarted: "ParallelStateStarted",
+  ParallelStateSucceeded: "ParallelStateSucceeded",
+  PassStateEntered: "PassStateEntered",
+  PassStateExited: "PassStateExited",
+  SucceedStateEntered: "SucceedStateEntered",
+  SucceedStateExited: "SucceedStateExited",
+  TaskFailed: "TaskFailed",
+  TaskScheduled: "TaskScheduled",
+  TaskStartFailed: "TaskStartFailed",
+  TaskStarted: "TaskStarted",
+  TaskStateAborted: "TaskStateAborted",
+  TaskStateEntered: "TaskStateEntered",
+  TaskStateExited: "TaskStateExited",
+  TaskSubmitFailed: "TaskSubmitFailed",
+  TaskSubmitted: "TaskSubmitted",
+  TaskSucceeded: "TaskSucceeded",
+  TaskTimedOut: "TaskTimedOut",
+  WaitStateAborted: "WaitStateAborted",
+  WaitStateEntered: "WaitStateEntered",
+  WaitStateExited: "WaitStateExited"
+};
+var _InvalidToken = class _InvalidToken extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidToken",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidToken";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidToken.prototype);
+  }
+};
+__name(_InvalidToken, "InvalidToken");
+var InvalidToken = _InvalidToken;
+var ExecutionRedriveFilter = {
+  NOT_REDRIVEN: "NOT_REDRIVEN",
+  REDRIVEN: "REDRIVEN"
+};
+var _ExecutionLimitExceeded = class _ExecutionLimitExceeded extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ExecutionLimitExceeded",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ExecutionLimitExceeded";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ExecutionLimitExceeded.prototype);
+  }
+};
+__name(_ExecutionLimitExceeded, "ExecutionLimitExceeded");
+var ExecutionLimitExceeded = _ExecutionLimitExceeded;
+var _ExecutionNotRedrivable = class _ExecutionNotRedrivable extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ExecutionNotRedrivable",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ExecutionNotRedrivable";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ExecutionNotRedrivable.prototype);
+  }
+};
+__name(_ExecutionNotRedrivable, "ExecutionNotRedrivable");
+var ExecutionNotRedrivable = _ExecutionNotRedrivable;
+var _TaskDoesNotExist = class _TaskDoesNotExist extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TaskDoesNotExist",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TaskDoesNotExist";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TaskDoesNotExist.prototype);
+  }
+};
+__name(_TaskDoesNotExist, "TaskDoesNotExist");
+var TaskDoesNotExist = _TaskDoesNotExist;
+var _TaskTimedOut = class _TaskTimedOut extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TaskTimedOut",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TaskTimedOut";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TaskTimedOut.prototype);
+  }
+};
+__name(_TaskTimedOut, "TaskTimedOut");
+var TaskTimedOut = _TaskTimedOut;
+var _InvalidOutput = class _InvalidOutput extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidOutput",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidOutput";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidOutput.prototype);
+  }
+};
+__name(_InvalidOutput, "InvalidOutput");
+var InvalidOutput = _InvalidOutput;
+var _ExecutionAlreadyExists = class _ExecutionAlreadyExists extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ExecutionAlreadyExists",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ExecutionAlreadyExists";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ExecutionAlreadyExists.prototype);
+  }
+};
+__name(_ExecutionAlreadyExists, "ExecutionAlreadyExists");
+var ExecutionAlreadyExists = _ExecutionAlreadyExists;
+var _InvalidExecutionInput = class _InvalidExecutionInput extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidExecutionInput",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidExecutionInput";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidExecutionInput.prototype);
+  }
+};
+__name(_InvalidExecutionInput, "InvalidExecutionInput");
+var InvalidExecutionInput = _InvalidExecutionInput;
+var SyncExecutionStatus = {
+  FAILED: "FAILED",
+  SUCCEEDED: "SUCCEEDED",
+  TIMED_OUT: "TIMED_OUT"
+};
+var InspectionLevel = {
+  DEBUG: "DEBUG",
+  INFO: "INFO",
+  TRACE: "TRACE"
+};
+var TestExecutionStatus = {
+  CAUGHT_ERROR: "CAUGHT_ERROR",
+  FAILED: "FAILED",
+  RETRIABLE: "RETRIABLE",
+  SUCCEEDED: "SUCCEEDED"
+};
+var _MissingRequiredParameter = class _MissingRequiredParameter extends SFNServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "MissingRequiredParameter",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "MissingRequiredParameter";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _MissingRequiredParameter.prototype);
+  }
+};
+__name(_MissingRequiredParameter, "MissingRequiredParameter");
+var MissingRequiredParameter = _MissingRequiredParameter;
+var ActivityFailedEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "ActivityFailedEventDetailsFilterSensitiveLog");
+var ActivityScheduledEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.input && { input: import_smithy_client.SENSITIVE_STRING }
+}), "ActivityScheduledEventDetailsFilterSensitiveLog");
+var ActivityScheduleFailedEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "ActivityScheduleFailedEventDetailsFilterSensitiveLog");
+var ActivitySucceededEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.output && { output: import_smithy_client.SENSITIVE_STRING }
+}), "ActivitySucceededEventDetailsFilterSensitiveLog");
+var ActivityTimedOutEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "ActivityTimedOutEventDetailsFilterSensitiveLog");
+var CreateStateMachineInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.definition && { definition: import_smithy_client.SENSITIVE_STRING },
+  ...obj.versionDescription && { versionDescription: import_smithy_client.SENSITIVE_STRING }
+}), "CreateStateMachineInputFilterSensitiveLog");
+var CreateStateMachineAliasInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.description && { description: import_smithy_client.SENSITIVE_STRING }
+}), "CreateStateMachineAliasInputFilterSensitiveLog");
+var DescribeExecutionOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.input && { input: import_smithy_client.SENSITIVE_STRING },
+  ...obj.output && { output: import_smithy_client.SENSITIVE_STRING },
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING },
+  ...obj.redriveStatusReason && { redriveStatusReason: import_smithy_client.SENSITIVE_STRING }
+}), "DescribeExecutionOutputFilterSensitiveLog");
+var DescribeStateMachineOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.definition && { definition: import_smithy_client.SENSITIVE_STRING },
+  ...obj.description && { description: import_smithy_client.SENSITIVE_STRING }
+}), "DescribeStateMachineOutputFilterSensitiveLog");
+var DescribeStateMachineAliasOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.description && { description: import_smithy_client.SENSITIVE_STRING }
+}), "DescribeStateMachineAliasOutputFilterSensitiveLog");
+var DescribeStateMachineForExecutionOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.definition && { definition: import_smithy_client.SENSITIVE_STRING }
+}), "DescribeStateMachineForExecutionOutputFilterSensitiveLog");
+var GetActivityTaskOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.input && { input: import_smithy_client.SENSITIVE_STRING }
+}), "GetActivityTaskOutputFilterSensitiveLog");
+var ExecutionAbortedEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "ExecutionAbortedEventDetailsFilterSensitiveLog");
+var ExecutionFailedEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "ExecutionFailedEventDetailsFilterSensitiveLog");
+var ExecutionStartedEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.input && { input: import_smithy_client.SENSITIVE_STRING }
+}), "ExecutionStartedEventDetailsFilterSensitiveLog");
+var ExecutionSucceededEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.output && { output: import_smithy_client.SENSITIVE_STRING }
+}), "ExecutionSucceededEventDetailsFilterSensitiveLog");
+var ExecutionTimedOutEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "ExecutionTimedOutEventDetailsFilterSensitiveLog");
+var LambdaFunctionFailedEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "LambdaFunctionFailedEventDetailsFilterSensitiveLog");
+var LambdaFunctionScheduledEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.input && { input: import_smithy_client.SENSITIVE_STRING }
+}), "LambdaFunctionScheduledEventDetailsFilterSensitiveLog");
+var LambdaFunctionScheduleFailedEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "LambdaFunctionScheduleFailedEventDetailsFilterSensitiveLog");
+var LambdaFunctionStartFailedEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "LambdaFunctionStartFailedEventDetailsFilterSensitiveLog");
+var LambdaFunctionSucceededEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.output && { output: import_smithy_client.SENSITIVE_STRING }
+}), "LambdaFunctionSucceededEventDetailsFilterSensitiveLog");
+var LambdaFunctionTimedOutEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "LambdaFunctionTimedOutEventDetailsFilterSensitiveLog");
+var MapRunFailedEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "MapRunFailedEventDetailsFilterSensitiveLog");
+var StateEnteredEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.input && { input: import_smithy_client.SENSITIVE_STRING }
+}), "StateEnteredEventDetailsFilterSensitiveLog");
+var StateExitedEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.output && { output: import_smithy_client.SENSITIVE_STRING }
+}), "StateExitedEventDetailsFilterSensitiveLog");
+var TaskFailedEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "TaskFailedEventDetailsFilterSensitiveLog");
+var TaskScheduledEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.parameters && { parameters: import_smithy_client.SENSITIVE_STRING }
+}), "TaskScheduledEventDetailsFilterSensitiveLog");
+var TaskStartFailedEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "TaskStartFailedEventDetailsFilterSensitiveLog");
+var TaskSubmitFailedEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "TaskSubmitFailedEventDetailsFilterSensitiveLog");
+var TaskSubmittedEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.output && { output: import_smithy_client.SENSITIVE_STRING }
+}), "TaskSubmittedEventDetailsFilterSensitiveLog");
+var TaskSucceededEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.output && { output: import_smithy_client.SENSITIVE_STRING }
+}), "TaskSucceededEventDetailsFilterSensitiveLog");
+var TaskTimedOutEventDetailsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "TaskTimedOutEventDetailsFilterSensitiveLog");
+var HistoryEventFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.activityFailedEventDetails && {
+    activityFailedEventDetails: ActivityFailedEventDetailsFilterSensitiveLog(obj.activityFailedEventDetails)
+  },
+  ...obj.activityScheduleFailedEventDetails && {
+    activityScheduleFailedEventDetails: ActivityScheduleFailedEventDetailsFilterSensitiveLog(
+      obj.activityScheduleFailedEventDetails
+    )
+  },
+  ...obj.activityScheduledEventDetails && {
+    activityScheduledEventDetails: ActivityScheduledEventDetailsFilterSensitiveLog(obj.activityScheduledEventDetails)
+  },
+  ...obj.activitySucceededEventDetails && {
+    activitySucceededEventDetails: ActivitySucceededEventDetailsFilterSensitiveLog(obj.activitySucceededEventDetails)
+  },
+  ...obj.activityTimedOutEventDetails && {
+    activityTimedOutEventDetails: ActivityTimedOutEventDetailsFilterSensitiveLog(obj.activityTimedOutEventDetails)
+  },
+  ...obj.taskFailedEventDetails && {
+    taskFailedEventDetails: TaskFailedEventDetailsFilterSensitiveLog(obj.taskFailedEventDetails)
+  },
+  ...obj.taskScheduledEventDetails && {
+    taskScheduledEventDetails: TaskScheduledEventDetailsFilterSensitiveLog(obj.taskScheduledEventDetails)
+  },
+  ...obj.taskStartFailedEventDetails && {
+    taskStartFailedEventDetails: TaskStartFailedEventDetailsFilterSensitiveLog(obj.taskStartFailedEventDetails)
+  },
+  ...obj.taskSubmitFailedEventDetails && {
+    taskSubmitFailedEventDetails: TaskSubmitFailedEventDetailsFilterSensitiveLog(obj.taskSubmitFailedEventDetails)
+  },
+  ...obj.taskSubmittedEventDetails && {
+    taskSubmittedEventDetails: TaskSubmittedEventDetailsFilterSensitiveLog(obj.taskSubmittedEventDetails)
+  },
+  ...obj.taskSucceededEventDetails && {
+    taskSucceededEventDetails: TaskSucceededEventDetailsFilterSensitiveLog(obj.taskSucceededEventDetails)
+  },
+  ...obj.taskTimedOutEventDetails && {
+    taskTimedOutEventDetails: TaskTimedOutEventDetailsFilterSensitiveLog(obj.taskTimedOutEventDetails)
+  },
+  ...obj.executionFailedEventDetails && {
+    executionFailedEventDetails: ExecutionFailedEventDetailsFilterSensitiveLog(obj.executionFailedEventDetails)
+  },
+  ...obj.executionStartedEventDetails && {
+    executionStartedEventDetails: ExecutionStartedEventDetailsFilterSensitiveLog(obj.executionStartedEventDetails)
+  },
+  ...obj.executionSucceededEventDetails && {
+    executionSucceededEventDetails: ExecutionSucceededEventDetailsFilterSensitiveLog(
+      obj.executionSucceededEventDetails
+    )
+  },
+  ...obj.executionAbortedEventDetails && {
+    executionAbortedEventDetails: ExecutionAbortedEventDetailsFilterSensitiveLog(obj.executionAbortedEventDetails)
+  },
+  ...obj.executionTimedOutEventDetails && {
+    executionTimedOutEventDetails: ExecutionTimedOutEventDetailsFilterSensitiveLog(obj.executionTimedOutEventDetails)
+  },
+  ...obj.lambdaFunctionFailedEventDetails && {
+    lambdaFunctionFailedEventDetails: LambdaFunctionFailedEventDetailsFilterSensitiveLog(
+      obj.lambdaFunctionFailedEventDetails
+    )
+  },
+  ...obj.lambdaFunctionScheduleFailedEventDetails && {
+    lambdaFunctionScheduleFailedEventDetails: LambdaFunctionScheduleFailedEventDetailsFilterSensitiveLog(
+      obj.lambdaFunctionScheduleFailedEventDetails
+    )
+  },
+  ...obj.lambdaFunctionScheduledEventDetails && {
+    lambdaFunctionScheduledEventDetails: LambdaFunctionScheduledEventDetailsFilterSensitiveLog(
+      obj.lambdaFunctionScheduledEventDetails
+    )
+  },
+  ...obj.lambdaFunctionStartFailedEventDetails && {
+    lambdaFunctionStartFailedEventDetails: LambdaFunctionStartFailedEventDetailsFilterSensitiveLog(
+      obj.lambdaFunctionStartFailedEventDetails
+    )
+  },
+  ...obj.lambdaFunctionSucceededEventDetails && {
+    lambdaFunctionSucceededEventDetails: LambdaFunctionSucceededEventDetailsFilterSensitiveLog(
+      obj.lambdaFunctionSucceededEventDetails
+    )
+  },
+  ...obj.lambdaFunctionTimedOutEventDetails && {
+    lambdaFunctionTimedOutEventDetails: LambdaFunctionTimedOutEventDetailsFilterSensitiveLog(
+      obj.lambdaFunctionTimedOutEventDetails
+    )
+  },
+  ...obj.stateEnteredEventDetails && {
+    stateEnteredEventDetails: StateEnteredEventDetailsFilterSensitiveLog(obj.stateEnteredEventDetails)
+  },
+  ...obj.stateExitedEventDetails && {
+    stateExitedEventDetails: StateExitedEventDetailsFilterSensitiveLog(obj.stateExitedEventDetails)
+  },
+  ...obj.mapRunFailedEventDetails && {
+    mapRunFailedEventDetails: MapRunFailedEventDetailsFilterSensitiveLog(obj.mapRunFailedEventDetails)
+  }
+}), "HistoryEventFilterSensitiveLog");
+var GetExecutionHistoryOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.events && { events: obj.events.map((item) => HistoryEventFilterSensitiveLog(item)) }
+}), "GetExecutionHistoryOutputFilterSensitiveLog");
+var PublishStateMachineVersionInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.description && { description: import_smithy_client.SENSITIVE_STRING }
+}), "PublishStateMachineVersionInputFilterSensitiveLog");
+var SendTaskFailureInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "SendTaskFailureInputFilterSensitiveLog");
+var SendTaskSuccessInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.output && { output: import_smithy_client.SENSITIVE_STRING }
+}), "SendTaskSuccessInputFilterSensitiveLog");
+var StartExecutionInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.input && { input: import_smithy_client.SENSITIVE_STRING }
+}), "StartExecutionInputFilterSensitiveLog");
+var StartSyncExecutionInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.input && { input: import_smithy_client.SENSITIVE_STRING }
+}), "StartSyncExecutionInputFilterSensitiveLog");
+var StartSyncExecutionOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING },
+  ...obj.input && { input: import_smithy_client.SENSITIVE_STRING },
+  ...obj.output && { output: import_smithy_client.SENSITIVE_STRING }
+}), "StartSyncExecutionOutputFilterSensitiveLog");
+var StopExecutionInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING }
+}), "StopExecutionInputFilterSensitiveLog");
+var TestStateInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.definition && { definition: import_smithy_client.SENSITIVE_STRING },
+  ...obj.input && { input: import_smithy_client.SENSITIVE_STRING }
+}), "TestStateInputFilterSensitiveLog");
+var InspectionDataFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.input && { input: import_smithy_client.SENSITIVE_STRING },
+  ...obj.afterInputPath && { afterInputPath: import_smithy_client.SENSITIVE_STRING },
+  ...obj.afterParameters && { afterParameters: import_smithy_client.SENSITIVE_STRING },
+  ...obj.result && { result: import_smithy_client.SENSITIVE_STRING },
+  ...obj.afterResultSelector && { afterResultSelector: import_smithy_client.SENSITIVE_STRING },
+  ...obj.afterResultPath && { afterResultPath: import_smithy_client.SENSITIVE_STRING }
+}), "InspectionDataFilterSensitiveLog");
+var TestStateOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.output && { output: import_smithy_client.SENSITIVE_STRING },
+  ...obj.error && { error: import_smithy_client.SENSITIVE_STRING },
+  ...obj.cause && { cause: import_smithy_client.SENSITIVE_STRING },
+  ...obj.inspectionData && { inspectionData: import_smithy_client.SENSITIVE_STRING }
+}), "TestStateOutputFilterSensitiveLog");
+var UpdateStateMachineInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.definition && { definition: import_smithy_client.SENSITIVE_STRING },
+  ...obj.versionDescription && { versionDescription: import_smithy_client.SENSITIVE_STRING }
+}), "UpdateStateMachineInputFilterSensitiveLog");
+var UpdateStateMachineAliasInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.description && { description: import_smithy_client.SENSITIVE_STRING }
+}), "UpdateStateMachineAliasInputFilterSensitiveLog");
+
+// src/protocols/Aws_json1_0.ts
+var se_CreateActivityCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateActivity");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateActivityCommand");
+var se_CreateStateMachineCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateStateMachine");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateStateMachineCommand");
+var se_CreateStateMachineAliasCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateStateMachineAlias");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateStateMachineAliasCommand");
+var se_DeleteActivityCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteActivity");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteActivityCommand");
+var se_DeleteStateMachineCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteStateMachine");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteStateMachineCommand");
+var se_DeleteStateMachineAliasCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteStateMachineAlias");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteStateMachineAliasCommand");
+var se_DeleteStateMachineVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteStateMachineVersion");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteStateMachineVersionCommand");
+var se_DescribeActivityCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeActivity");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeActivityCommand");
+var se_DescribeExecutionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeExecution");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeExecutionCommand");
+var se_DescribeMapRunCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeMapRun");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeMapRunCommand");
+var se_DescribeStateMachineCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeStateMachine");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeStateMachineCommand");
+var se_DescribeStateMachineAliasCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeStateMachineAlias");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeStateMachineAliasCommand");
+var se_DescribeStateMachineForExecutionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeStateMachineForExecution");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeStateMachineForExecutionCommand");
+var se_GetActivityTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetActivityTask");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetActivityTaskCommand");
+var se_GetExecutionHistoryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetExecutionHistory");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetExecutionHistoryCommand");
+var se_ListActivitiesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListActivities");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListActivitiesCommand");
+var se_ListExecutionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListExecutions");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListExecutionsCommand");
+var se_ListMapRunsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListMapRuns");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListMapRunsCommand");
+var se_ListStateMachineAliasesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListStateMachineAliases");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListStateMachineAliasesCommand");
+var se_ListStateMachinesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListStateMachines");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListStateMachinesCommand");
+var se_ListStateMachineVersionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListStateMachineVersions");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListStateMachineVersionsCommand");
+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_PublishStateMachineVersionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PublishStateMachineVersion");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PublishStateMachineVersionCommand");
+var se_RedriveExecutionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RedriveExecution");
+  let body;
+  body = JSON.stringify(se_RedriveExecutionInput(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RedriveExecutionCommand");
+var se_SendTaskFailureCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("SendTaskFailure");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SendTaskFailureCommand");
+var se_SendTaskHeartbeatCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("SendTaskHeartbeat");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SendTaskHeartbeatCommand");
+var se_SendTaskSuccessCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("SendTaskSuccess");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SendTaskSuccessCommand");
+var se_StartExecutionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartExecution");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartExecutionCommand");
+var se_StartSyncExecutionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartSyncExecution");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  let { hostname: resolvedHostname } = await context.endpoint();
+  if (context.disableHostPrefix !== true) {
+    resolvedHostname = "sync-" + resolvedHostname;
+    if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
+      throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+    }
+  }
+  return buildHttpRpcRequest(context, headers, "/", resolvedHostname, body);
+}, "se_StartSyncExecutionCommand");
+var se_StopExecutionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StopExecution");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StopExecutionCommand");
+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_TestStateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("TestState");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  let { hostname: resolvedHostname } = await context.endpoint();
+  if (context.disableHostPrefix !== true) {
+    resolvedHostname = "sync-" + resolvedHostname;
+    if (!(0, import_protocol_http.isValidHostname)(resolvedHostname)) {
+      throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+    }
+  }
+  return buildHttpRpcRequest(context, headers, "/", resolvedHostname, body);
+}, "se_TestStateCommand");
+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 se_UpdateMapRunCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateMapRun");
+  let body;
+  body = JSON.stringify(se_UpdateMapRunInput(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateMapRunCommand");
+var se_UpdateStateMachineCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateStateMachine");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateStateMachineCommand");
+var se_UpdateStateMachineAliasCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateStateMachineAlias");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateStateMachineAliasCommand");
+var de_CreateActivityCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateActivityCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateActivityOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateActivityCommand");
+var de_CreateActivityCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ActivityLimitExceeded":
+    case "com.amazonaws.sfn#ActivityLimitExceeded":
+      throw await de_ActivityLimitExceededRes(parsedOutput, context);
+    case "InvalidName":
+    case "com.amazonaws.sfn#InvalidName":
+      throw await de_InvalidNameRes(parsedOutput, context);
+    case "TooManyTags":
+    case "com.amazonaws.sfn#TooManyTags":
+      throw await de_TooManyTagsRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateActivityCommandError");
+var de_CreateStateMachineCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateStateMachineCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateStateMachineOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateStateMachineCommand");
+var de_CreateStateMachineCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.sfn#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "InvalidDefinition":
+    case "com.amazonaws.sfn#InvalidDefinition":
+      throw await de_InvalidDefinitionRes(parsedOutput, context);
+    case "InvalidLoggingConfiguration":
+    case "com.amazonaws.sfn#InvalidLoggingConfiguration":
+      throw await de_InvalidLoggingConfigurationRes(parsedOutput, context);
+    case "InvalidName":
+    case "com.amazonaws.sfn#InvalidName":
+      throw await de_InvalidNameRes(parsedOutput, context);
+    case "InvalidTracingConfiguration":
+    case "com.amazonaws.sfn#InvalidTracingConfiguration":
+      throw await de_InvalidTracingConfigurationRes(parsedOutput, context);
+    case "StateMachineAlreadyExists":
+    case "com.amazonaws.sfn#StateMachineAlreadyExists":
+      throw await de_StateMachineAlreadyExistsRes(parsedOutput, context);
+    case "StateMachineDeleting":
+    case "com.amazonaws.sfn#StateMachineDeleting":
+      throw await de_StateMachineDeletingRes(parsedOutput, context);
+    case "StateMachineLimitExceeded":
+    case "com.amazonaws.sfn#StateMachineLimitExceeded":
+      throw await de_StateMachineLimitExceededRes(parsedOutput, context);
+    case "StateMachineTypeNotSupported":
+    case "com.amazonaws.sfn#StateMachineTypeNotSupported":
+      throw await de_StateMachineTypeNotSupportedRes(parsedOutput, context);
+    case "TooManyTags":
+    case "com.amazonaws.sfn#TooManyTags":
+      throw await de_TooManyTagsRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sfn#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateStateMachineCommandError");
+var de_CreateStateMachineAliasCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateStateMachineAliasCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateStateMachineAliasOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateStateMachineAliasCommand");
+var de_CreateStateMachineAliasCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.sfn#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "InvalidName":
+    case "com.amazonaws.sfn#InvalidName":
+      throw await de_InvalidNameRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.sfn#ResourceNotFound":
+      throw await de_ResourceNotFoundRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.sfn#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "StateMachineDeleting":
+    case "com.amazonaws.sfn#StateMachineDeleting":
+      throw await de_StateMachineDeletingRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sfn#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateStateMachineAliasCommandError");
+var de_DeleteActivityCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteActivityCommandError(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_DeleteActivityCommand");
+var de_DeleteActivityCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteActivityCommandError");
+var de_DeleteStateMachineCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteStateMachineCommandError(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_DeleteStateMachineCommand");
+var de_DeleteStateMachineCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sfn#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteStateMachineCommandError");
+var de_DeleteStateMachineAliasCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteStateMachineAliasCommandError(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_DeleteStateMachineAliasCommand");
+var de_DeleteStateMachineAliasCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.sfn#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.sfn#ResourceNotFound":
+      throw await de_ResourceNotFoundRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sfn#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteStateMachineAliasCommandError");
+var de_DeleteStateMachineVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteStateMachineVersionCommandError(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_DeleteStateMachineVersionCommand");
+var de_DeleteStateMachineVersionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.sfn#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sfn#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteStateMachineVersionCommandError");
+var de_DescribeActivityCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeActivityCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeActivityOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeActivityCommand");
+var de_DescribeActivityCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ActivityDoesNotExist":
+    case "com.amazonaws.sfn#ActivityDoesNotExist":
+      throw await de_ActivityDoesNotExistRes(parsedOutput, context);
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeActivityCommandError");
+var de_DescribeExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeExecutionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeExecutionOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeExecutionCommand");
+var de_DescribeExecutionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ExecutionDoesNotExist":
+    case "com.amazonaws.sfn#ExecutionDoesNotExist":
+      throw await de_ExecutionDoesNotExistRes(parsedOutput, context);
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeExecutionCommandError");
+var de_DescribeMapRunCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeMapRunCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeMapRunOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeMapRunCommand");
+var de_DescribeMapRunCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.sfn#ResourceNotFound":
+      throw await de_ResourceNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeMapRunCommandError");
+var de_DescribeStateMachineCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeStateMachineCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeStateMachineOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeStateMachineCommand");
+var de_DescribeStateMachineCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "StateMachineDoesNotExist":
+    case "com.amazonaws.sfn#StateMachineDoesNotExist":
+      throw await de_StateMachineDoesNotExistRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeStateMachineCommandError");
+var de_DescribeStateMachineAliasCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeStateMachineAliasCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeStateMachineAliasOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeStateMachineAliasCommand");
+var de_DescribeStateMachineAliasCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.sfn#ResourceNotFound":
+      throw await de_ResourceNotFoundRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sfn#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeStateMachineAliasCommandError");
+var de_DescribeStateMachineForExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeStateMachineForExecutionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeStateMachineForExecutionOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeStateMachineForExecutionCommand");
+var de_DescribeStateMachineForExecutionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ExecutionDoesNotExist":
+    case "com.amazonaws.sfn#ExecutionDoesNotExist":
+      throw await de_ExecutionDoesNotExistRes(parsedOutput, context);
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeStateMachineForExecutionCommandError");
+var de_GetActivityTaskCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetActivityTaskCommandError(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_GetActivityTaskCommand");
+var de_GetActivityTaskCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ActivityDoesNotExist":
+    case "com.amazonaws.sfn#ActivityDoesNotExist":
+      throw await de_ActivityDoesNotExistRes(parsedOutput, context);
+    case "ActivityWorkerLimitExceeded":
+    case "com.amazonaws.sfn#ActivityWorkerLimitExceeded":
+      throw await de_ActivityWorkerLimitExceededRes(parsedOutput, context);
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetActivityTaskCommandError");
+var de_GetExecutionHistoryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetExecutionHistoryCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetExecutionHistoryOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetExecutionHistoryCommand");
+var de_GetExecutionHistoryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ExecutionDoesNotExist":
+    case "com.amazonaws.sfn#ExecutionDoesNotExist":
+      throw await de_ExecutionDoesNotExistRes(parsedOutput, context);
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "InvalidToken":
+    case "com.amazonaws.sfn#InvalidToken":
+      throw await de_InvalidTokenRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetExecutionHistoryCommandError");
+var de_ListActivitiesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListActivitiesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListActivitiesOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListActivitiesCommand");
+var de_ListActivitiesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidToken":
+    case "com.amazonaws.sfn#InvalidToken":
+      throw await de_InvalidTokenRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListActivitiesCommandError");
+var de_ListExecutionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListExecutionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListExecutionsOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListExecutionsCommand");
+var de_ListExecutionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "InvalidToken":
+    case "com.amazonaws.sfn#InvalidToken":
+      throw await de_InvalidTokenRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.sfn#ResourceNotFound":
+      throw await de_ResourceNotFoundRes(parsedOutput, context);
+    case "StateMachineDoesNotExist":
+    case "com.amazonaws.sfn#StateMachineDoesNotExist":
+      throw await de_StateMachineDoesNotExistRes(parsedOutput, context);
+    case "StateMachineTypeNotSupported":
+    case "com.amazonaws.sfn#StateMachineTypeNotSupported":
+      throw await de_StateMachineTypeNotSupportedRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sfn#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListExecutionsCommandError");
+var de_ListMapRunsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListMapRunsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListMapRunsOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListMapRunsCommand");
+var de_ListMapRunsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ExecutionDoesNotExist":
+    case "com.amazonaws.sfn#ExecutionDoesNotExist":
+      throw await de_ExecutionDoesNotExistRes(parsedOutput, context);
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "InvalidToken":
+    case "com.amazonaws.sfn#InvalidToken":
+      throw await de_InvalidTokenRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListMapRunsCommandError");
+var de_ListStateMachineAliasesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListStateMachineAliasesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListStateMachineAliasesOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListStateMachineAliasesCommand");
+var de_ListStateMachineAliasesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "InvalidToken":
+    case "com.amazonaws.sfn#InvalidToken":
+      throw await de_InvalidTokenRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.sfn#ResourceNotFound":
+      throw await de_ResourceNotFoundRes(parsedOutput, context);
+    case "StateMachineDeleting":
+    case "com.amazonaws.sfn#StateMachineDeleting":
+      throw await de_StateMachineDeletingRes(parsedOutput, context);
+    case "StateMachineDoesNotExist":
+    case "com.amazonaws.sfn#StateMachineDoesNotExist":
+      throw await de_StateMachineDoesNotExistRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListStateMachineAliasesCommandError");
+var de_ListStateMachinesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListStateMachinesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListStateMachinesOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListStateMachinesCommand");
+var de_ListStateMachinesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidToken":
+    case "com.amazonaws.sfn#InvalidToken":
+      throw await de_InvalidTokenRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListStateMachinesCommandError");
+var de_ListStateMachineVersionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListStateMachineVersionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListStateMachineVersionsOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListStateMachineVersionsCommand");
+var de_ListStateMachineVersionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "InvalidToken":
+    case "com.amazonaws.sfn#InvalidToken":
+      throw await de_InvalidTokenRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sfn#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListStateMachineVersionsCommandError");
+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 "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.sfn#ResourceNotFound":
+      throw await de_ResourceNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_PublishStateMachineVersionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PublishStateMachineVersionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_PublishStateMachineVersionOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PublishStateMachineVersionCommand");
+var de_PublishStateMachineVersionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.sfn#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.sfn#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "StateMachineDeleting":
+    case "com.amazonaws.sfn#StateMachineDeleting":
+      throw await de_StateMachineDeletingRes(parsedOutput, context);
+    case "StateMachineDoesNotExist":
+    case "com.amazonaws.sfn#StateMachineDoesNotExist":
+      throw await de_StateMachineDoesNotExistRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sfn#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PublishStateMachineVersionCommandError");
+var de_RedriveExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RedriveExecutionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_RedriveExecutionOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_RedriveExecutionCommand");
+var de_RedriveExecutionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ExecutionDoesNotExist":
+    case "com.amazonaws.sfn#ExecutionDoesNotExist":
+      throw await de_ExecutionDoesNotExistRes(parsedOutput, context);
+    case "ExecutionLimitExceeded":
+    case "com.amazonaws.sfn#ExecutionLimitExceeded":
+      throw await de_ExecutionLimitExceededRes(parsedOutput, context);
+    case "ExecutionNotRedrivable":
+    case "com.amazonaws.sfn#ExecutionNotRedrivable":
+      throw await de_ExecutionNotRedrivableRes(parsedOutput, context);
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RedriveExecutionCommandError");
+var de_SendTaskFailureCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SendTaskFailureCommandError(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_SendTaskFailureCommand");
+var de_SendTaskFailureCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidToken":
+    case "com.amazonaws.sfn#InvalidToken":
+      throw await de_InvalidTokenRes(parsedOutput, context);
+    case "TaskDoesNotExist":
+    case "com.amazonaws.sfn#TaskDoesNotExist":
+      throw await de_TaskDoesNotExistRes(parsedOutput, context);
+    case "TaskTimedOut":
+    case "com.amazonaws.sfn#TaskTimedOut":
+      throw await de_TaskTimedOutRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SendTaskFailureCommandError");
+var de_SendTaskHeartbeatCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SendTaskHeartbeatCommandError(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_SendTaskHeartbeatCommand");
+var de_SendTaskHeartbeatCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidToken":
+    case "com.amazonaws.sfn#InvalidToken":
+      throw await de_InvalidTokenRes(parsedOutput, context);
+    case "TaskDoesNotExist":
+    case "com.amazonaws.sfn#TaskDoesNotExist":
+      throw await de_TaskDoesNotExistRes(parsedOutput, context);
+    case "TaskTimedOut":
+    case "com.amazonaws.sfn#TaskTimedOut":
+      throw await de_TaskTimedOutRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SendTaskHeartbeatCommandError");
+var de_SendTaskSuccessCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SendTaskSuccessCommandError(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_SendTaskSuccessCommand");
+var de_SendTaskSuccessCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidOutput":
+    case "com.amazonaws.sfn#InvalidOutput":
+      throw await de_InvalidOutputRes(parsedOutput, context);
+    case "InvalidToken":
+    case "com.amazonaws.sfn#InvalidToken":
+      throw await de_InvalidTokenRes(parsedOutput, context);
+    case "TaskDoesNotExist":
+    case "com.amazonaws.sfn#TaskDoesNotExist":
+      throw await de_TaskDoesNotExistRes(parsedOutput, context);
+    case "TaskTimedOut":
+    case "com.amazonaws.sfn#TaskTimedOut":
+      throw await de_TaskTimedOutRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SendTaskSuccessCommandError");
+var de_StartExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartExecutionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_StartExecutionOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartExecutionCommand");
+var de_StartExecutionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ExecutionAlreadyExists":
+    case "com.amazonaws.sfn#ExecutionAlreadyExists":
+      throw await de_ExecutionAlreadyExistsRes(parsedOutput, context);
+    case "ExecutionLimitExceeded":
+    case "com.amazonaws.sfn#ExecutionLimitExceeded":
+      throw await de_ExecutionLimitExceededRes(parsedOutput, context);
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "InvalidExecutionInput":
+    case "com.amazonaws.sfn#InvalidExecutionInput":
+      throw await de_InvalidExecutionInputRes(parsedOutput, context);
+    case "InvalidName":
+    case "com.amazonaws.sfn#InvalidName":
+      throw await de_InvalidNameRes(parsedOutput, context);
+    case "StateMachineDeleting":
+    case "com.amazonaws.sfn#StateMachineDeleting":
+      throw await de_StateMachineDeletingRes(parsedOutput, context);
+    case "StateMachineDoesNotExist":
+    case "com.amazonaws.sfn#StateMachineDoesNotExist":
+      throw await de_StateMachineDoesNotExistRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sfn#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartExecutionCommandError");
+var de_StartSyncExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartSyncExecutionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_StartSyncExecutionOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartSyncExecutionCommand");
+var de_StartSyncExecutionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "InvalidExecutionInput":
+    case "com.amazonaws.sfn#InvalidExecutionInput":
+      throw await de_InvalidExecutionInputRes(parsedOutput, context);
+    case "InvalidName":
+    case "com.amazonaws.sfn#InvalidName":
+      throw await de_InvalidNameRes(parsedOutput, context);
+    case "StateMachineDeleting":
+    case "com.amazonaws.sfn#StateMachineDeleting":
+      throw await de_StateMachineDeletingRes(parsedOutput, context);
+    case "StateMachineDoesNotExist":
+    case "com.amazonaws.sfn#StateMachineDoesNotExist":
+      throw await de_StateMachineDoesNotExistRes(parsedOutput, context);
+    case "StateMachineTypeNotSupported":
+    case "com.amazonaws.sfn#StateMachineTypeNotSupported":
+      throw await de_StateMachineTypeNotSupportedRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartSyncExecutionCommandError");
+var de_StopExecutionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StopExecutionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_StopExecutionOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StopExecutionCommand");
+var de_StopExecutionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ExecutionDoesNotExist":
+    case "com.amazonaws.sfn#ExecutionDoesNotExist":
+      throw await de_ExecutionDoesNotExistRes(parsedOutput, context);
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sfn#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StopExecutionCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TagResourceCommandError(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_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 "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.sfn#ResourceNotFound":
+      throw await de_ResourceNotFoundRes(parsedOutput, context);
+    case "TooManyTags":
+    case "com.amazonaws.sfn#TooManyTags":
+      throw await de_TooManyTagsRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_TestStateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TestStateCommandError(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_TestStateCommand");
+var de_TestStateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "InvalidDefinition":
+    case "com.amazonaws.sfn#InvalidDefinition":
+      throw await de_InvalidDefinitionRes(parsedOutput, context);
+    case "InvalidExecutionInput":
+    case "com.amazonaws.sfn#InvalidExecutionInput":
+      throw await de_InvalidExecutionInputRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sfn#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TestStateCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UntagResourceCommandError(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_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 "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.sfn#ResourceNotFound":
+      throw await de_ResourceNotFoundRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateMapRunCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateMapRunCommandError(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_UpdateMapRunCommand");
+var de_UpdateMapRunCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.sfn#ResourceNotFound":
+      throw await de_ResourceNotFoundRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sfn#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateMapRunCommandError");
+var de_UpdateStateMachineCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateStateMachineCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateStateMachineOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateStateMachineCommand");
+var de_UpdateStateMachineCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.sfn#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "InvalidDefinition":
+    case "com.amazonaws.sfn#InvalidDefinition":
+      throw await de_InvalidDefinitionRes(parsedOutput, context);
+    case "InvalidLoggingConfiguration":
+    case "com.amazonaws.sfn#InvalidLoggingConfiguration":
+      throw await de_InvalidLoggingConfigurationRes(parsedOutput, context);
+    case "InvalidTracingConfiguration":
+    case "com.amazonaws.sfn#InvalidTracingConfiguration":
+      throw await de_InvalidTracingConfigurationRes(parsedOutput, context);
+    case "MissingRequiredParameter":
+    case "com.amazonaws.sfn#MissingRequiredParameter":
+      throw await de_MissingRequiredParameterRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.sfn#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "StateMachineDeleting":
+    case "com.amazonaws.sfn#StateMachineDeleting":
+      throw await de_StateMachineDeletingRes(parsedOutput, context);
+    case "StateMachineDoesNotExist":
+    case "com.amazonaws.sfn#StateMachineDoesNotExist":
+      throw await de_StateMachineDoesNotExistRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sfn#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateStateMachineCommandError");
+var de_UpdateStateMachineAliasCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateStateMachineAliasCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateStateMachineAliasOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateStateMachineAliasCommand");
+var de_UpdateStateMachineAliasCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConflictException":
+    case "com.amazonaws.sfn#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InvalidArn":
+    case "com.amazonaws.sfn#InvalidArn":
+      throw await de_InvalidArnRes(parsedOutput, context);
+    case "ResourceNotFound":
+    case "com.amazonaws.sfn#ResourceNotFound":
+      throw await de_ResourceNotFoundRes(parsedOutput, context);
+    case "StateMachineDeleting":
+    case "com.amazonaws.sfn#StateMachineDeleting":
+      throw await de_StateMachineDeletingRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sfn#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateStateMachineAliasCommandError");
+var de_ActivityDoesNotExistRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ActivityDoesNotExist({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ActivityDoesNotExistRes");
+var de_ActivityLimitExceededRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ActivityLimitExceeded({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ActivityLimitExceededRes");
+var de_ActivityWorkerLimitExceededRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ActivityWorkerLimitExceeded({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ActivityWorkerLimitExceededRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ConflictExceptionRes");
+var de_ExecutionAlreadyExistsRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ExecutionAlreadyExists({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ExecutionAlreadyExistsRes");
+var de_ExecutionDoesNotExistRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ExecutionDoesNotExist({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ExecutionDoesNotExistRes");
+var de_ExecutionLimitExceededRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ExecutionLimitExceeded({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ExecutionLimitExceededRes");
+var de_ExecutionNotRedrivableRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ExecutionNotRedrivable({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ExecutionNotRedrivableRes");
+var de_InvalidArnRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidArn({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidArnRes");
+var de_InvalidDefinitionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidDefinition({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidDefinitionRes");
+var de_InvalidExecutionInputRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidExecutionInput({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidExecutionInputRes");
+var de_InvalidLoggingConfigurationRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidLoggingConfiguration({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidLoggingConfigurationRes");
+var de_InvalidNameRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidName({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidNameRes");
+var de_InvalidOutputRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidOutput({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidOutputRes");
+var de_InvalidTokenRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidToken({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidTokenRes");
+var de_InvalidTracingConfigurationRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidTracingConfiguration({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidTracingConfigurationRes");
+var de_MissingRequiredParameterRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new MissingRequiredParameter({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_MissingRequiredParameterRes");
+var de_ResourceNotFoundRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceNotFoundRes");
+var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ServiceQuotaExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ServiceQuotaExceededExceptionRes");
+var de_StateMachineAlreadyExistsRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new StateMachineAlreadyExists({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_StateMachineAlreadyExistsRes");
+var de_StateMachineDeletingRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new StateMachineDeleting({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_StateMachineDeletingRes");
+var de_StateMachineDoesNotExistRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new StateMachineDoesNotExist({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_StateMachineDoesNotExistRes");
+var de_StateMachineLimitExceededRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new StateMachineLimitExceeded({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_StateMachineLimitExceededRes");
+var de_StateMachineTypeNotSupportedRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new StateMachineTypeNotSupported({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_StateMachineTypeNotSupportedRes");
+var de_TaskDoesNotExistRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TaskDoesNotExist({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TaskDoesNotExistRes");
+var de_TaskTimedOutRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TaskTimedOut({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TaskTimedOutRes");
+var de_TooManyTagsRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TooManyTags({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TooManyTagsRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ValidationExceptionRes");
+var se_RedriveExecutionInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+    executionArn: []
+  });
+}, "se_RedriveExecutionInput");
+var se_UpdateMapRunInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    mapRunArn: [],
+    maxConcurrency: [],
+    toleratedFailureCount: [],
+    toleratedFailurePercentage: import_smithy_client.serializeFloat
+  });
+}, "se_UpdateMapRunInput");
+var de_ActivityList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ActivityListItem(entry, context);
+  });
+  return retVal;
+}, "de_ActivityList");
+var de_ActivityListItem = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    activityArn: import_smithy_client.expectString,
+    creationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    name: import_smithy_client.expectString
+  });
+}, "de_ActivityListItem");
+var de_CreateActivityOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    activityArn: import_smithy_client.expectString,
+    creationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_CreateActivityOutput");
+var de_CreateStateMachineAliasOutput = /* @__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)(_))),
+    stateMachineAliasArn: import_smithy_client.expectString
+  });
+}, "de_CreateStateMachineAliasOutput");
+var de_CreateStateMachineOutput = /* @__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)(_))),
+    stateMachineArn: import_smithy_client.expectString,
+    stateMachineVersionArn: import_smithy_client.expectString
+  });
+}, "de_CreateStateMachineOutput");
+var de_DescribeActivityOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    activityArn: import_smithy_client.expectString,
+    creationDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    name: import_smithy_client.expectString
+  });
+}, "de_DescribeActivityOutput");
+var de_DescribeExecutionOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    cause: import_smithy_client.expectString,
+    error: import_smithy_client.expectString,
+    executionArn: import_smithy_client.expectString,
+    input: import_smithy_client.expectString,
+    inputDetails: import_smithy_client._json,
+    mapRunArn: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    output: import_smithy_client.expectString,
+    outputDetails: import_smithy_client._json,
+    redriveCount: import_smithy_client.expectInt32,
+    redriveDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    redriveStatus: import_smithy_client.expectString,
+    redriveStatusReason: import_smithy_client.expectString,
+    startDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    stateMachineAliasArn: import_smithy_client.expectString,
+    stateMachineArn: import_smithy_client.expectString,
+    stateMachineVersionArn: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    stopDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    traceHeader: import_smithy_client.expectString
+  });
+}, "de_DescribeExecutionOutput");
+var de_DescribeMapRunOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    executionArn: import_smithy_client.expectString,
+    executionCounts: import_smithy_client._json,
+    itemCounts: import_smithy_client._json,
+    mapRunArn: import_smithy_client.expectString,
+    maxConcurrency: import_smithy_client.expectInt32,
+    redriveCount: import_smithy_client.expectInt32,
+    redriveDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    startDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    status: import_smithy_client.expectString,
+    stopDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    toleratedFailureCount: import_smithy_client.expectLong,
+    toleratedFailurePercentage: import_smithy_client.limitedParseFloat32
+  });
+}, "de_DescribeMapRunOutput");
+var de_DescribeStateMachineAliasOutput = /* @__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)(_))),
+    description: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    routingConfiguration: import_smithy_client._json,
+    stateMachineAliasArn: import_smithy_client.expectString,
+    updateDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_DescribeStateMachineAliasOutput");
+var de_DescribeStateMachineForExecutionOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    definition: import_smithy_client.expectString,
+    label: import_smithy_client.expectString,
+    loggingConfiguration: import_smithy_client._json,
+    mapRunArn: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    revisionId: import_smithy_client.expectString,
+    roleArn: import_smithy_client.expectString,
+    stateMachineArn: import_smithy_client.expectString,
+    tracingConfiguration: import_smithy_client._json,
+    updateDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_DescribeStateMachineForExecutionOutput");
+var de_DescribeStateMachineOutput = /* @__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)(_))),
+    definition: import_smithy_client.expectString,
+    description: import_smithy_client.expectString,
+    label: import_smithy_client.expectString,
+    loggingConfiguration: import_smithy_client._json,
+    name: import_smithy_client.expectString,
+    revisionId: import_smithy_client.expectString,
+    roleArn: import_smithy_client.expectString,
+    stateMachineArn: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    tracingConfiguration: import_smithy_client._json,
+    type: import_smithy_client.expectString
+  });
+}, "de_DescribeStateMachineOutput");
+var de_ExecutionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ExecutionListItem(entry, context);
+  });
+  return retVal;
+}, "de_ExecutionList");
+var de_ExecutionListItem = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    executionArn: import_smithy_client.expectString,
+    itemCount: import_smithy_client.expectInt32,
+    mapRunArn: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    redriveCount: import_smithy_client.expectInt32,
+    redriveDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    startDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    stateMachineAliasArn: import_smithy_client.expectString,
+    stateMachineArn: import_smithy_client.expectString,
+    stateMachineVersionArn: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    stopDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_ExecutionListItem");
+var de_GetExecutionHistoryOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    events: (_) => de_HistoryEventList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+}, "de_GetExecutionHistoryOutput");
+var de_HistoryEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    activityFailedEventDetails: import_smithy_client._json,
+    activityScheduleFailedEventDetails: import_smithy_client._json,
+    activityScheduledEventDetails: import_smithy_client._json,
+    activityStartedEventDetails: import_smithy_client._json,
+    activitySucceededEventDetails: import_smithy_client._json,
+    activityTimedOutEventDetails: import_smithy_client._json,
+    executionAbortedEventDetails: import_smithy_client._json,
+    executionFailedEventDetails: import_smithy_client._json,
+    executionRedrivenEventDetails: import_smithy_client._json,
+    executionStartedEventDetails: import_smithy_client._json,
+    executionSucceededEventDetails: import_smithy_client._json,
+    executionTimedOutEventDetails: import_smithy_client._json,
+    id: import_smithy_client.expectLong,
+    lambdaFunctionFailedEventDetails: import_smithy_client._json,
+    lambdaFunctionScheduleFailedEventDetails: import_smithy_client._json,
+    lambdaFunctionScheduledEventDetails: import_smithy_client._json,
+    lambdaFunctionStartFailedEventDetails: import_smithy_client._json,
+    lambdaFunctionSucceededEventDetails: import_smithy_client._json,
+    lambdaFunctionTimedOutEventDetails: import_smithy_client._json,
+    mapIterationAbortedEventDetails: import_smithy_client._json,
+    mapIterationFailedEventDetails: import_smithy_client._json,
+    mapIterationStartedEventDetails: import_smithy_client._json,
+    mapIterationSucceededEventDetails: import_smithy_client._json,
+    mapRunFailedEventDetails: import_smithy_client._json,
+    mapRunRedrivenEventDetails: import_smithy_client._json,
+    mapRunStartedEventDetails: import_smithy_client._json,
+    mapStateStartedEventDetails: import_smithy_client._json,
+    previousEventId: import_smithy_client.expectLong,
+    stateEnteredEventDetails: import_smithy_client._json,
+    stateExitedEventDetails: import_smithy_client._json,
+    taskFailedEventDetails: import_smithy_client._json,
+    taskScheduledEventDetails: import_smithy_client._json,
+    taskStartFailedEventDetails: import_smithy_client._json,
+    taskStartedEventDetails: import_smithy_client._json,
+    taskSubmitFailedEventDetails: import_smithy_client._json,
+    taskSubmittedEventDetails: import_smithy_client._json,
+    taskSucceededEventDetails: import_smithy_client._json,
+    taskTimedOutEventDetails: import_smithy_client._json,
+    timestamp: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    type: import_smithy_client.expectString
+  });
+}, "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_ListActivitiesOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    activities: (_) => de_ActivityList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+}, "de_ListActivitiesOutput");
+var de_ListExecutionsOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    executions: (_) => de_ExecutionList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+}, "de_ListExecutionsOutput");
+var de_ListMapRunsOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    mapRuns: (_) => de_MapRunList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+}, "de_ListMapRunsOutput");
+var de_ListStateMachineAliasesOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    nextToken: import_smithy_client.expectString,
+    stateMachineAliases: (_) => de_StateMachineAliasList(_, context)
+  });
+}, "de_ListStateMachineAliasesOutput");
+var de_ListStateMachinesOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    nextToken: import_smithy_client.expectString,
+    stateMachines: (_) => de_StateMachineList(_, context)
+  });
+}, "de_ListStateMachinesOutput");
+var de_ListStateMachineVersionsOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    nextToken: import_smithy_client.expectString,
+    stateMachineVersions: (_) => de_StateMachineVersionList(_, context)
+  });
+}, "de_ListStateMachineVersionsOutput");
+var de_MapRunList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_MapRunListItem(entry, context);
+  });
+  return retVal;
+}, "de_MapRunList");
+var de_MapRunListItem = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    executionArn: import_smithy_client.expectString,
+    mapRunArn: import_smithy_client.expectString,
+    startDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    stateMachineArn: import_smithy_client.expectString,
+    stopDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_MapRunListItem");
+var de_PublishStateMachineVersionOutput = /* @__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)(_))),
+    stateMachineVersionArn: import_smithy_client.expectString
+  });
+}, "de_PublishStateMachineVersionOutput");
+var de_RedriveExecutionOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    redriveDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_RedriveExecutionOutput");
+var de_StartExecutionOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    executionArn: import_smithy_client.expectString,
+    startDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_StartExecutionOutput");
+var de_StartSyncExecutionOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    billingDetails: import_smithy_client._json,
+    cause: import_smithy_client.expectString,
+    error: import_smithy_client.expectString,
+    executionArn: import_smithy_client.expectString,
+    input: import_smithy_client.expectString,
+    inputDetails: import_smithy_client._json,
+    name: import_smithy_client.expectString,
+    output: import_smithy_client.expectString,
+    outputDetails: import_smithy_client._json,
+    startDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    stateMachineArn: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    stopDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    traceHeader: import_smithy_client.expectString
+  });
+}, "de_StartSyncExecutionOutput");
+var de_StateMachineAliasList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_StateMachineAliasListItem(entry, context);
+  });
+  return retVal;
+}, "de_StateMachineAliasList");
+var de_StateMachineAliasListItem = /* @__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)(_))),
+    stateMachineAliasArn: import_smithy_client.expectString
+  });
+}, "de_StateMachineAliasListItem");
+var de_StateMachineList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_StateMachineListItem(entry, context);
+  });
+  return retVal;
+}, "de_StateMachineList");
+var de_StateMachineListItem = /* @__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)(_))),
+    name: import_smithy_client.expectString,
+    stateMachineArn: import_smithy_client.expectString,
+    type: import_smithy_client.expectString
+  });
+}, "de_StateMachineListItem");
+var de_StateMachineVersionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_StateMachineVersionListItem(entry, context);
+  });
+  return retVal;
+}, "de_StateMachineVersionList");
+var de_StateMachineVersionListItem = /* @__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)(_))),
+    stateMachineVersionArn: import_smithy_client.expectString
+  });
+}, "de_StateMachineVersionListItem");
+var de_StopExecutionOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    stopDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_StopExecutionOutput");
+var de_UpdateStateMachineAliasOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    updateDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_UpdateStateMachineAliasOutput");
+var de_UpdateStateMachineOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    revisionId: import_smithy_client.expectString,
+    stateMachineVersionArn: import_smithy_client.expectString,
+    updateDate: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_UpdateStateMachineOutput");
+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)(SFNServiceException);
+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": `AWSStepFunctions.${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/CreateActivityCommand.ts
+var _CreateActivityCommand = class _CreateActivityCommand 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("AWSStepFunctions", "CreateActivity", {}).n("SFNClient", "CreateActivityCommand").f(void 0, void 0).ser(se_CreateActivityCommand).de(de_CreateActivityCommand).build() {
+};
+__name(_CreateActivityCommand, "CreateActivityCommand");
+var CreateActivityCommand = _CreateActivityCommand;
+
+// src/commands/CreateStateMachineAliasCommand.ts
+
+
+
+
+var _CreateStateMachineAliasCommand = class _CreateStateMachineAliasCommand 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("AWSStepFunctions", "CreateStateMachineAlias", {}).n("SFNClient", "CreateStateMachineAliasCommand").f(CreateStateMachineAliasInputFilterSensitiveLog, void 0).ser(se_CreateStateMachineAliasCommand).de(de_CreateStateMachineAliasCommand).build() {
+};
+__name(_CreateStateMachineAliasCommand, "CreateStateMachineAliasCommand");
+var CreateStateMachineAliasCommand = _CreateStateMachineAliasCommand;
+
+// src/commands/CreateStateMachineCommand.ts
+
+
+
+
+var _CreateStateMachineCommand = class _CreateStateMachineCommand 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("AWSStepFunctions", "CreateStateMachine", {}).n("SFNClient", "CreateStateMachineCommand").f(CreateStateMachineInputFilterSensitiveLog, void 0).ser(se_CreateStateMachineCommand).de(de_CreateStateMachineCommand).build() {
+};
+__name(_CreateStateMachineCommand, "CreateStateMachineCommand");
+var CreateStateMachineCommand = _CreateStateMachineCommand;
+
+// src/commands/DeleteActivityCommand.ts
+
+
+
+
+var _DeleteActivityCommand = class _DeleteActivityCommand 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("AWSStepFunctions", "DeleteActivity", {}).n("SFNClient", "DeleteActivityCommand").f(void 0, void 0).ser(se_DeleteActivityCommand).de(de_DeleteActivityCommand).build() {
+};
+__name(_DeleteActivityCommand, "DeleteActivityCommand");
+var DeleteActivityCommand = _DeleteActivityCommand;
+
+// src/commands/DeleteStateMachineAliasCommand.ts
+
+
+
+
+var _DeleteStateMachineAliasCommand = class _DeleteStateMachineAliasCommand 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("AWSStepFunctions", "DeleteStateMachineAlias", {}).n("SFNClient", "DeleteStateMachineAliasCommand").f(void 0, void 0).ser(se_DeleteStateMachineAliasCommand).de(de_DeleteStateMachineAliasCommand).build() {
+};
+__name(_DeleteStateMachineAliasCommand, "DeleteStateMachineAliasCommand");
+var DeleteStateMachineAliasCommand = _DeleteStateMachineAliasCommand;
+
+// src/commands/DeleteStateMachineCommand.ts
+
+
+
+
+var _DeleteStateMachineCommand = class _DeleteStateMachineCommand 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("AWSStepFunctions", "DeleteStateMachine", {}).n("SFNClient", "DeleteStateMachineCommand").f(void 0, void 0).ser(se_DeleteStateMachineCommand).de(de_DeleteStateMachineCommand).build() {
+};
+__name(_DeleteStateMachineCommand, "DeleteStateMachineCommand");
+var DeleteStateMachineCommand = _DeleteStateMachineCommand;
+
+// src/commands/DeleteStateMachineVersionCommand.ts
+
+
+
+
+var _DeleteStateMachineVersionCommand = class _DeleteStateMachineVersionCommand 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("AWSStepFunctions", "DeleteStateMachineVersion", {}).n("SFNClient", "DeleteStateMachineVersionCommand").f(void 0, void 0).ser(se_DeleteStateMachineVersionCommand).de(de_DeleteStateMachineVersionCommand).build() {
+};
+__name(_DeleteStateMachineVersionCommand, "DeleteStateMachineVersionCommand");
+var DeleteStateMachineVersionCommand = _DeleteStateMachineVersionCommand;
+
+// src/commands/DescribeActivityCommand.ts
+
+
+
+
+var _DescribeActivityCommand = class _DescribeActivityCommand 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("AWSStepFunctions", "DescribeActivity", {}).n("SFNClient", "DescribeActivityCommand").f(void 0, void 0).ser(se_DescribeActivityCommand).de(de_DescribeActivityCommand).build() {
+};
+__name(_DescribeActivityCommand, "DescribeActivityCommand");
+var DescribeActivityCommand = _DescribeActivityCommand;
+
+// src/commands/DescribeExecutionCommand.ts
+
+
+
+
+var _DescribeExecutionCommand = class _DescribeExecutionCommand 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("AWSStepFunctions", "DescribeExecution", {}).n("SFNClient", "DescribeExecutionCommand").f(void 0, DescribeExecutionOutputFilterSensitiveLog).ser(se_DescribeExecutionCommand).de(de_DescribeExecutionCommand).build() {
+};
+__name(_DescribeExecutionCommand, "DescribeExecutionCommand");
+var DescribeExecutionCommand = _DescribeExecutionCommand;
+
+// src/commands/DescribeMapRunCommand.ts
+
+
+
+
+var _DescribeMapRunCommand = class _DescribeMapRunCommand 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("AWSStepFunctions", "DescribeMapRun", {}).n("SFNClient", "DescribeMapRunCommand").f(void 0, void 0).ser(se_DescribeMapRunCommand).de(de_DescribeMapRunCommand).build() {
+};
+__name(_DescribeMapRunCommand, "DescribeMapRunCommand");
+var DescribeMapRunCommand = _DescribeMapRunCommand;
+
+// src/commands/DescribeStateMachineAliasCommand.ts
+
+
+
+
+var _DescribeStateMachineAliasCommand = class _DescribeStateMachineAliasCommand 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("AWSStepFunctions", "DescribeStateMachineAlias", {}).n("SFNClient", "DescribeStateMachineAliasCommand").f(void 0, DescribeStateMachineAliasOutputFilterSensitiveLog).ser(se_DescribeStateMachineAliasCommand).de(de_DescribeStateMachineAliasCommand).build() {
+};
+__name(_DescribeStateMachineAliasCommand, "DescribeStateMachineAliasCommand");
+var DescribeStateMachineAliasCommand = _DescribeStateMachineAliasCommand;
+
+// src/commands/DescribeStateMachineCommand.ts
+
+
+
+
+var _DescribeStateMachineCommand = class _DescribeStateMachineCommand 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("AWSStepFunctions", "DescribeStateMachine", {}).n("SFNClient", "DescribeStateMachineCommand").f(void 0, DescribeStateMachineOutputFilterSensitiveLog).ser(se_DescribeStateMachineCommand).de(de_DescribeStateMachineCommand).build() {
+};
+__name(_DescribeStateMachineCommand, "DescribeStateMachineCommand");
+var DescribeStateMachineCommand = _DescribeStateMachineCommand;
+
+// src/commands/DescribeStateMachineForExecutionCommand.ts
+
+
+
+
+var _DescribeStateMachineForExecutionCommand = class _DescribeStateMachineForExecutionCommand 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("AWSStepFunctions", "DescribeStateMachineForExecution", {}).n("SFNClient", "DescribeStateMachineForExecutionCommand").f(void 0, DescribeStateMachineForExecutionOutputFilterSensitiveLog).ser(se_DescribeStateMachineForExecutionCommand).de(de_DescribeStateMachineForExecutionCommand).build() {
+};
+__name(_DescribeStateMachineForExecutionCommand, "DescribeStateMachineForExecutionCommand");
+var DescribeStateMachineForExecutionCommand = _DescribeStateMachineForExecutionCommand;
+
+// src/commands/GetActivityTaskCommand.ts
+
+
+
+
+var _GetActivityTaskCommand = class _GetActivityTaskCommand 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("AWSStepFunctions", "GetActivityTask", {}).n("SFNClient", "GetActivityTaskCommand").f(void 0, GetActivityTaskOutputFilterSensitiveLog).ser(se_GetActivityTaskCommand).de(de_GetActivityTaskCommand).build() {
+};
+__name(_GetActivityTaskCommand, "GetActivityTaskCommand");
+var GetActivityTaskCommand = _GetActivityTaskCommand;
+
+// src/commands/GetExecutionHistoryCommand.ts
+
+
+
+
+var _GetExecutionHistoryCommand = class _GetExecutionHistoryCommand 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("AWSStepFunctions", "GetExecutionHistory", {}).n("SFNClient", "GetExecutionHistoryCommand").f(void 0, GetExecutionHistoryOutputFilterSensitiveLog).ser(se_GetExecutionHistoryCommand).de(de_GetExecutionHistoryCommand).build() {
+};
+__name(_GetExecutionHistoryCommand, "GetExecutionHistoryCommand");
+var GetExecutionHistoryCommand = _GetExecutionHistoryCommand;
+
+// src/commands/ListActivitiesCommand.ts
+
+
+
+
+var _ListActivitiesCommand = class _ListActivitiesCommand 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("AWSStepFunctions", "ListActivities", {}).n("SFNClient", "ListActivitiesCommand").f(void 0, void 0).ser(se_ListActivitiesCommand).de(de_ListActivitiesCommand).build() {
+};
+__name(_ListActivitiesCommand, "ListActivitiesCommand");
+var ListActivitiesCommand = _ListActivitiesCommand;
+
+// src/commands/ListExecutionsCommand.ts
+
+
+
+
+var _ListExecutionsCommand = class _ListExecutionsCommand 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("AWSStepFunctions", "ListExecutions", {}).n("SFNClient", "ListExecutionsCommand").f(void 0, void 0).ser(se_ListExecutionsCommand).de(de_ListExecutionsCommand).build() {
+};
+__name(_ListExecutionsCommand, "ListExecutionsCommand");
+var ListExecutionsCommand = _ListExecutionsCommand;
+
+// src/commands/ListMapRunsCommand.ts
+
+
+
+
+var _ListMapRunsCommand = class _ListMapRunsCommand 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("AWSStepFunctions", "ListMapRuns", {}).n("SFNClient", "ListMapRunsCommand").f(void 0, void 0).ser(se_ListMapRunsCommand).de(de_ListMapRunsCommand).build() {
+};
+__name(_ListMapRunsCommand, "ListMapRunsCommand");
+var ListMapRunsCommand = _ListMapRunsCommand;
+
+// src/commands/ListStateMachineAliasesCommand.ts
+
+
+
+
+var _ListStateMachineAliasesCommand = class _ListStateMachineAliasesCommand 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("AWSStepFunctions", "ListStateMachineAliases", {}).n("SFNClient", "ListStateMachineAliasesCommand").f(void 0, void 0).ser(se_ListStateMachineAliasesCommand).de(de_ListStateMachineAliasesCommand).build() {
+};
+__name(_ListStateMachineAliasesCommand, "ListStateMachineAliasesCommand");
+var ListStateMachineAliasesCommand = _ListStateMachineAliasesCommand;
+
+// src/commands/ListStateMachinesCommand.ts
+
+
+
+
+var _ListStateMachinesCommand = class _ListStateMachinesCommand 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("AWSStepFunctions", "ListStateMachines", {}).n("SFNClient", "ListStateMachinesCommand").f(void 0, void 0).ser(se_ListStateMachinesCommand).de(de_ListStateMachinesCommand).build() {
+};
+__name(_ListStateMachinesCommand, "ListStateMachinesCommand");
+var ListStateMachinesCommand = _ListStateMachinesCommand;
+
+// src/commands/ListStateMachineVersionsCommand.ts
+
+
+
+
+var _ListStateMachineVersionsCommand = class _ListStateMachineVersionsCommand 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("AWSStepFunctions", "ListStateMachineVersions", {}).n("SFNClient", "ListStateMachineVersionsCommand").f(void 0, void 0).ser(se_ListStateMachineVersionsCommand).de(de_ListStateMachineVersionsCommand).build() {
+};
+__name(_ListStateMachineVersionsCommand, "ListStateMachineVersionsCommand");
+var ListStateMachineVersionsCommand = _ListStateMachineVersionsCommand;
+
+// 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("AWSStepFunctions", "ListTagsForResource", {}).n("SFNClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/PublishStateMachineVersionCommand.ts
+
+
+
+
+var _PublishStateMachineVersionCommand = class _PublishStateMachineVersionCommand 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("AWSStepFunctions", "PublishStateMachineVersion", {}).n("SFNClient", "PublishStateMachineVersionCommand").f(PublishStateMachineVersionInputFilterSensitiveLog, void 0).ser(se_PublishStateMachineVersionCommand).de(de_PublishStateMachineVersionCommand).build() {
+};
+__name(_PublishStateMachineVersionCommand, "PublishStateMachineVersionCommand");
+var PublishStateMachineVersionCommand = _PublishStateMachineVersionCommand;
+
+// src/commands/RedriveExecutionCommand.ts
+
+
+
+
+var _RedriveExecutionCommand = class _RedriveExecutionCommand 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("AWSStepFunctions", "RedriveExecution", {}).n("SFNClient", "RedriveExecutionCommand").f(void 0, void 0).ser(se_RedriveExecutionCommand).de(de_RedriveExecutionCommand).build() {
+};
+__name(_RedriveExecutionCommand, "RedriveExecutionCommand");
+var RedriveExecutionCommand = _RedriveExecutionCommand;
+
+// src/commands/SendTaskFailureCommand.ts
+
+
+
+
+var _SendTaskFailureCommand = class _SendTaskFailureCommand 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("AWSStepFunctions", "SendTaskFailure", {}).n("SFNClient", "SendTaskFailureCommand").f(SendTaskFailureInputFilterSensitiveLog, void 0).ser(se_SendTaskFailureCommand).de(de_SendTaskFailureCommand).build() {
+};
+__name(_SendTaskFailureCommand, "SendTaskFailureCommand");
+var SendTaskFailureCommand = _SendTaskFailureCommand;
+
+// src/commands/SendTaskHeartbeatCommand.ts
+
+
+
+
+var _SendTaskHeartbeatCommand = class _SendTaskHeartbeatCommand 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("AWSStepFunctions", "SendTaskHeartbeat", {}).n("SFNClient", "SendTaskHeartbeatCommand").f(void 0, void 0).ser(se_SendTaskHeartbeatCommand).de(de_SendTaskHeartbeatCommand).build() {
+};
+__name(_SendTaskHeartbeatCommand, "SendTaskHeartbeatCommand");
+var SendTaskHeartbeatCommand = _SendTaskHeartbeatCommand;
+
+// src/commands/SendTaskSuccessCommand.ts
+
+
+
+
+var _SendTaskSuccessCommand = class _SendTaskSuccessCommand 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("AWSStepFunctions", "SendTaskSuccess", {}).n("SFNClient", "SendTaskSuccessCommand").f(SendTaskSuccessInputFilterSensitiveLog, void 0).ser(se_SendTaskSuccessCommand).de(de_SendTaskSuccessCommand).build() {
+};
+__name(_SendTaskSuccessCommand, "SendTaskSuccessCommand");
+var SendTaskSuccessCommand = _SendTaskSuccessCommand;
+
+// src/commands/StartExecutionCommand.ts
+
+
+
+
+var _StartExecutionCommand = class _StartExecutionCommand 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("AWSStepFunctions", "StartExecution", {}).n("SFNClient", "StartExecutionCommand").f(StartExecutionInputFilterSensitiveLog, void 0).ser(se_StartExecutionCommand).de(de_StartExecutionCommand).build() {
+};
+__name(_StartExecutionCommand, "StartExecutionCommand");
+var StartExecutionCommand = _StartExecutionCommand;
+
+// src/commands/StartSyncExecutionCommand.ts
+
+
+
+
+var _StartSyncExecutionCommand = class _StartSyncExecutionCommand 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("AWSStepFunctions", "StartSyncExecution", {}).n("SFNClient", "StartSyncExecutionCommand").f(StartSyncExecutionInputFilterSensitiveLog, StartSyncExecutionOutputFilterSensitiveLog).ser(se_StartSyncExecutionCommand).de(de_StartSyncExecutionCommand).build() {
+};
+__name(_StartSyncExecutionCommand, "StartSyncExecutionCommand");
+var StartSyncExecutionCommand = _StartSyncExecutionCommand;
+
+// src/commands/StopExecutionCommand.ts
+
+
+
+
+var _StopExecutionCommand = class _StopExecutionCommand 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("AWSStepFunctions", "StopExecution", {}).n("SFNClient", "StopExecutionCommand").f(StopExecutionInputFilterSensitiveLog, void 0).ser(se_StopExecutionCommand).de(de_StopExecutionCommand).build() {
+};
+__name(_StopExecutionCommand, "StopExecutionCommand");
+var StopExecutionCommand = _StopExecutionCommand;
+
+// 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("AWSStepFunctions", "TagResource", {}).n("SFNClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/TestStateCommand.ts
+
+
+
+
+var _TestStateCommand = class _TestStateCommand 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("AWSStepFunctions", "TestState", {}).n("SFNClient", "TestStateCommand").f(TestStateInputFilterSensitiveLog, TestStateOutputFilterSensitiveLog).ser(se_TestStateCommand).de(de_TestStateCommand).build() {
+};
+__name(_TestStateCommand, "TestStateCommand");
+var TestStateCommand = _TestStateCommand;
+
+// 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("AWSStepFunctions", "UntagResource", {}).n("SFNClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateMapRunCommand.ts
+
+
+
+
+var _UpdateMapRunCommand = class _UpdateMapRunCommand 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("AWSStepFunctions", "UpdateMapRun", {}).n("SFNClient", "UpdateMapRunCommand").f(void 0, void 0).ser(se_UpdateMapRunCommand).de(de_UpdateMapRunCommand).build() {
+};
+__name(_UpdateMapRunCommand, "UpdateMapRunCommand");
+var UpdateMapRunCommand = _UpdateMapRunCommand;
+
+// src/commands/UpdateStateMachineAliasCommand.ts
+
+
+
+
+var _UpdateStateMachineAliasCommand = class _UpdateStateMachineAliasCommand 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("AWSStepFunctions", "UpdateStateMachineAlias", {}).n("SFNClient", "UpdateStateMachineAliasCommand").f(UpdateStateMachineAliasInputFilterSensitiveLog, void 0).ser(se_UpdateStateMachineAliasCommand).de(de_UpdateStateMachineAliasCommand).build() {
+};
+__name(_UpdateStateMachineAliasCommand, "UpdateStateMachineAliasCommand");
+var UpdateStateMachineAliasCommand = _UpdateStateMachineAliasCommand;
+
+// src/commands/UpdateStateMachineCommand.ts
+
+
+
+
+var _UpdateStateMachineCommand = class _UpdateStateMachineCommand 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("AWSStepFunctions", "UpdateStateMachine", {}).n("SFNClient", "UpdateStateMachineCommand").f(UpdateStateMachineInputFilterSensitiveLog, void 0).ser(se_UpdateStateMachineCommand).de(de_UpdateStateMachineCommand).build() {
+};
+__name(_UpdateStateMachineCommand, "UpdateStateMachineCommand");
+var UpdateStateMachineCommand = _UpdateStateMachineCommand;
+
+// src/SFN.ts
+var commands = {
+  CreateActivityCommand,
+  CreateStateMachineCommand,
+  CreateStateMachineAliasCommand,
+  DeleteActivityCommand,
+  DeleteStateMachineCommand,
+  DeleteStateMachineAliasCommand,
+  DeleteStateMachineVersionCommand,
+  DescribeActivityCommand,
+  DescribeExecutionCommand,
+  DescribeMapRunCommand,
+  DescribeStateMachineCommand,
+  DescribeStateMachineAliasCommand,
+  DescribeStateMachineForExecutionCommand,
+  GetActivityTaskCommand,
+  GetExecutionHistoryCommand,
+  ListActivitiesCommand,
+  ListExecutionsCommand,
+  ListMapRunsCommand,
+  ListStateMachineAliasesCommand,
+  ListStateMachinesCommand,
+  ListStateMachineVersionsCommand,
+  ListTagsForResourceCommand,
+  PublishStateMachineVersionCommand,
+  RedriveExecutionCommand,
+  SendTaskFailureCommand,
+  SendTaskHeartbeatCommand,
+  SendTaskSuccessCommand,
+  StartExecutionCommand,
+  StartSyncExecutionCommand,
+  StopExecutionCommand,
+  TagResourceCommand,
+  TestStateCommand,
+  UntagResourceCommand,
+  UpdateMapRunCommand,
+  UpdateStateMachineCommand,
+  UpdateStateMachineAliasCommand
+};
+var _SFN = class _SFN extends SFNClient {
+};
+__name(_SFN, "SFN");
+var SFN = _SFN;
+(0, import_smithy_client.createAggregatedClient)(commands, SFN);
+
+// src/pagination/GetExecutionHistoryPaginator.ts
+var import_core = require("@smithy/core");
+var paginateGetExecutionHistory = (0, import_core.createPaginator)(SFNClient, GetExecutionHistoryCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListActivitiesPaginator.ts
+
+var paginateListActivities = (0, import_core.createPaginator)(SFNClient, ListActivitiesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListExecutionsPaginator.ts
+
+var paginateListExecutions = (0, import_core.createPaginator)(SFNClient, ListExecutionsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListMapRunsPaginator.ts
+
+var paginateListMapRuns = (0, import_core.createPaginator)(SFNClient, ListMapRunsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListStateMachinesPaginator.ts
+
+var paginateListStateMachines = (0, import_core.createPaginator)(SFNClient, ListStateMachinesCommand, "nextToken", "nextToken", "maxResults");
+
+// 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 = {
+  ActivityDoesNotExist,
+  ActivityFailedEventDetailsFilterSensitiveLog,
+  ActivityLimitExceeded,
+  ActivityScheduleFailedEventDetailsFilterSensitiveLog,
+  ActivityScheduledEventDetailsFilterSensitiveLog,
+  ActivitySucceededEventDetailsFilterSensitiveLog,
+  ActivityTimedOutEventDetailsFilterSensitiveLog,
+  ActivityWorkerLimitExceeded,
+  ConflictException,
+  CreateActivityCommand,
+  CreateStateMachineAliasCommand,
+  CreateStateMachineAliasInputFilterSensitiveLog,
+  CreateStateMachineCommand,
+  CreateStateMachineInputFilterSensitiveLog,
+  DeleteActivityCommand,
+  DeleteStateMachineAliasCommand,
+  DeleteStateMachineCommand,
+  DeleteStateMachineVersionCommand,
+  DescribeActivityCommand,
+  DescribeExecutionCommand,
+  DescribeExecutionOutputFilterSensitiveLog,
+  DescribeMapRunCommand,
+  DescribeStateMachineAliasCommand,
+  DescribeStateMachineAliasOutputFilterSensitiveLog,
+  DescribeStateMachineCommand,
+  DescribeStateMachineForExecutionCommand,
+  DescribeStateMachineForExecutionOutputFilterSensitiveLog,
+  DescribeStateMachineOutputFilterSensitiveLog,
+  ExecutionAbortedEventDetailsFilterSensitiveLog,
+  ExecutionAlreadyExists,
+  ExecutionDoesNotExist,
+  ExecutionFailedEventDetailsFilterSensitiveLog,
+  ExecutionLimitExceeded,
+  ExecutionNotRedrivable,
+  ExecutionRedriveFilter,
+  ExecutionRedriveStatus,
+  ExecutionStartedEventDetailsFilterSensitiveLog,
+  ExecutionStatus,
+  ExecutionSucceededEventDetailsFilterSensitiveLog,
+  ExecutionTimedOutEventDetailsFilterSensitiveLog,
+  GetActivityTaskCommand,
+  GetActivityTaskOutputFilterSensitiveLog,
+  GetExecutionHistoryCommand,
+  GetExecutionHistoryOutputFilterSensitiveLog,
+  HistoryEventFilterSensitiveLog,
+  HistoryEventType,
+  InspectionDataFilterSensitiveLog,
+  InspectionLevel,
+  InvalidArn,
+  InvalidDefinition,
+  InvalidExecutionInput,
+  InvalidLoggingConfiguration,
+  InvalidName,
+  InvalidOutput,
+  InvalidToken,
+  InvalidTracingConfiguration,
+  LambdaFunctionFailedEventDetailsFilterSensitiveLog,
+  LambdaFunctionScheduleFailedEventDetailsFilterSensitiveLog,
+  LambdaFunctionScheduledEventDetailsFilterSensitiveLog,
+  LambdaFunctionStartFailedEventDetailsFilterSensitiveLog,
+  LambdaFunctionSucceededEventDetailsFilterSensitiveLog,
+  LambdaFunctionTimedOutEventDetailsFilterSensitiveLog,
+  ListActivitiesCommand,
+  ListExecutionsCommand,
+  ListMapRunsCommand,
+  ListStateMachineAliasesCommand,
+  ListStateMachineVersionsCommand,
+  ListStateMachinesCommand,
+  ListTagsForResourceCommand,
+  LogLevel,
+  MapRunFailedEventDetailsFilterSensitiveLog,
+  MapRunStatus,
+  MissingRequiredParameter,
+  PublishStateMachineVersionCommand,
+  PublishStateMachineVersionInputFilterSensitiveLog,
+  RedriveExecutionCommand,
+  ResourceNotFound,
+  SFN,
+  SFNClient,
+  SFNServiceException,
+  SendTaskFailureCommand,
+  SendTaskFailureInputFilterSensitiveLog,
+  SendTaskHeartbeatCommand,
+  SendTaskSuccessCommand,
+  SendTaskSuccessInputFilterSensitiveLog,
+  ServiceQuotaExceededException,
+  StartExecutionCommand,
+  StartExecutionInputFilterSensitiveLog,
+  StartSyncExecutionCommand,
+  StartSyncExecutionInputFilterSensitiveLog,
+  StartSyncExecutionOutputFilterSensitiveLog,
+  StateEnteredEventDetailsFilterSensitiveLog,
+  StateExitedEventDetailsFilterSensitiveLog,
+  StateMachineAlreadyExists,
+  StateMachineDeleting,
+  StateMachineDoesNotExist,
+  StateMachineLimitExceeded,
+  StateMachineStatus,
+  StateMachineType,
+  StateMachineTypeNotSupported,
+  StopExecutionCommand,
+  StopExecutionInputFilterSensitiveLog,
+  SyncExecutionStatus,
+  TagResourceCommand,
+  TaskDoesNotExist,
+  TaskFailedEventDetailsFilterSensitiveLog,
+  TaskScheduledEventDetailsFilterSensitiveLog,
+  TaskStartFailedEventDetailsFilterSensitiveLog,
+  TaskSubmitFailedEventDetailsFilterSensitiveLog,
+  TaskSubmittedEventDetailsFilterSensitiveLog,
+  TaskSucceededEventDetailsFilterSensitiveLog,
+  TaskTimedOut,
+  TaskTimedOutEventDetailsFilterSensitiveLog,
+  TestExecutionStatus,
+  TestStateCommand,
+  TestStateInputFilterSensitiveLog,
+  TestStateOutputFilterSensitiveLog,
+  TooManyTags,
+  UntagResourceCommand,
+  UpdateMapRunCommand,
+  UpdateStateMachineAliasCommand,
+  UpdateStateMachineAliasInputFilterSensitiveLog,
+  UpdateStateMachineCommand,
+  UpdateStateMachineInputFilterSensitiveLog,
+  ValidationException,
+  ValidationExceptionReason,
+  __Client,
+  paginateGetExecutionHistory,
+  paginateListActivities,
+  paginateListExecutions,
+  paginateListMapRuns,
+  paginateListStateMachines
+});