@aws-sdk/client-sfn 3.926.0 → 3.928.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,9 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
-var uuid = require('@smithy/uuid');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -92,6 +90,7 @@ class SFNClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -111,14 +110,14 @@ class SFNClient extends smithyClient.Client {
     }
 }
 
-class SFNServiceException extends smithyClient.ServiceException {
+let SFNServiceException$1 = class SFNServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, SFNServiceException.prototype);
     }
-}
+};
 
-class ActivityAlreadyExists extends SFNServiceException {
+let ActivityAlreadyExists$1 = class ActivityAlreadyExists extends SFNServiceException$1 {
     name = "ActivityAlreadyExists";
     $fault = "client";
     constructor(opts) {
@@ -129,8 +128,8 @@ class ActivityAlreadyExists extends SFNServiceException {
         });
         Object.setPrototypeOf(this, ActivityAlreadyExists.prototype);
     }
-}
-class ActivityDoesNotExist extends SFNServiceException {
+};
+let ActivityDoesNotExist$1 = class ActivityDoesNotExist extends SFNServiceException$1 {
     name = "ActivityDoesNotExist";
     $fault = "client";
     constructor(opts) {
@@ -141,8 +140,8 @@ class ActivityDoesNotExist extends SFNServiceException {
         });
         Object.setPrototypeOf(this, ActivityDoesNotExist.prototype);
     }
-}
-class ActivityLimitExceeded extends SFNServiceException {
+};
+let ActivityLimitExceeded$1 = class ActivityLimitExceeded extends SFNServiceException$1 {
     name = "ActivityLimitExceeded";
     $fault = "client";
     constructor(opts) {
@@ -153,8 +152,8 @@ class ActivityLimitExceeded extends SFNServiceException {
         });
         Object.setPrototypeOf(this, ActivityLimitExceeded.prototype);
     }
-}
-class ActivityWorkerLimitExceeded extends SFNServiceException {
+};
+let ActivityWorkerLimitExceeded$1 = class ActivityWorkerLimitExceeded extends SFNServiceException$1 {
     name = "ActivityWorkerLimitExceeded";
     $fault = "client";
     constructor(opts) {
@@ -165,12 +164,12 @@ class ActivityWorkerLimitExceeded extends SFNServiceException {
         });
         Object.setPrototypeOf(this, ActivityWorkerLimitExceeded.prototype);
     }
-}
+};
 const EncryptionType = {
     AWS_OWNED_KEY: "AWS_OWNED_KEY",
     CUSTOMER_MANAGED_KMS_KEY: "CUSTOMER_MANAGED_KMS_KEY",
 };
-class InvalidEncryptionConfiguration extends SFNServiceException {
+let InvalidEncryptionConfiguration$1 = class InvalidEncryptionConfiguration extends SFNServiceException$1 {
     name = "InvalidEncryptionConfiguration";
     $fault = "client";
     constructor(opts) {
@@ -181,8 +180,8 @@ class InvalidEncryptionConfiguration extends SFNServiceException {
         });
         Object.setPrototypeOf(this, InvalidEncryptionConfiguration.prototype);
     }
-}
-class InvalidName extends SFNServiceException {
+};
+let InvalidName$1 = class InvalidName extends SFNServiceException$1 {
     name = "InvalidName";
     $fault = "client";
     constructor(opts) {
@@ -193,8 +192,8 @@ class InvalidName extends SFNServiceException {
         });
         Object.setPrototypeOf(this, InvalidName.prototype);
     }
-}
-class KmsAccessDeniedException extends SFNServiceException {
+};
+let KmsAccessDeniedException$1 = class KmsAccessDeniedException extends SFNServiceException$1 {
     name = "KmsAccessDeniedException";
     $fault = "client";
     constructor(opts) {
@@ -205,8 +204,8 @@ class KmsAccessDeniedException extends SFNServiceException {
         });
         Object.setPrototypeOf(this, KmsAccessDeniedException.prototype);
     }
-}
-class KmsThrottlingException extends SFNServiceException {
+};
+let KmsThrottlingException$1 = class KmsThrottlingException extends SFNServiceException$1 {
     name = "KmsThrottlingException";
     $fault = "client";
     constructor(opts) {
@@ -217,8 +216,8 @@ class KmsThrottlingException extends SFNServiceException {
         });
         Object.setPrototypeOf(this, KmsThrottlingException.prototype);
     }
-}
-class TooManyTags extends SFNServiceException {
+};
+let TooManyTags$1 = class TooManyTags extends SFNServiceException$1 {
     name = "TooManyTags";
     $fault = "client";
     resourceName;
@@ -231,8 +230,8 @@ class TooManyTags extends SFNServiceException {
         Object.setPrototypeOf(this, TooManyTags.prototype);
         this.resourceName = opts.resourceName;
     }
-}
-class ConflictException extends SFNServiceException {
+};
+let ConflictException$1 = class ConflictException extends SFNServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     constructor(opts) {
@@ -243,7 +242,7 @@ class ConflictException extends SFNServiceException {
         });
         Object.setPrototypeOf(this, ConflictException.prototype);
     }
-}
+};
 const LogLevel = {
     ALL: "ALL",
     ERROR: "ERROR",
@@ -254,7 +253,7 @@ const StateMachineType = {
     EXPRESS: "EXPRESS",
     STANDARD: "STANDARD",
 };
-class InvalidArn extends SFNServiceException {
+let InvalidArn$1 = class InvalidArn extends SFNServiceException$1 {
     name = "InvalidArn";
     $fault = "client";
     constructor(opts) {
@@ -265,8 +264,8 @@ class InvalidArn extends SFNServiceException {
         });
         Object.setPrototypeOf(this, InvalidArn.prototype);
     }
-}
-class InvalidDefinition extends SFNServiceException {
+};
+let InvalidDefinition$1 = class InvalidDefinition extends SFNServiceException$1 {
     name = "InvalidDefinition";
     $fault = "client";
     constructor(opts) {
@@ -277,8 +276,8 @@ class InvalidDefinition extends SFNServiceException {
         });
         Object.setPrototypeOf(this, InvalidDefinition.prototype);
     }
-}
-class InvalidLoggingConfiguration extends SFNServiceException {
+};
+let InvalidLoggingConfiguration$1 = class InvalidLoggingConfiguration extends SFNServiceException$1 {
     name = "InvalidLoggingConfiguration";
     $fault = "client";
     constructor(opts) {
@@ -289,8 +288,8 @@ class InvalidLoggingConfiguration extends SFNServiceException {
         });
         Object.setPrototypeOf(this, InvalidLoggingConfiguration.prototype);
     }
-}
-class InvalidTracingConfiguration extends SFNServiceException {
+};
+let InvalidTracingConfiguration$1 = class InvalidTracingConfiguration extends SFNServiceException$1 {
     name = "InvalidTracingConfiguration";
     $fault = "client";
     constructor(opts) {
@@ -301,8 +300,8 @@ class InvalidTracingConfiguration extends SFNServiceException {
         });
         Object.setPrototypeOf(this, InvalidTracingConfiguration.prototype);
     }
-}
-class StateMachineAlreadyExists extends SFNServiceException {
+};
+let StateMachineAlreadyExists$1 = class StateMachineAlreadyExists extends SFNServiceException$1 {
     name = "StateMachineAlreadyExists";
     $fault = "client";
     constructor(opts) {
@@ -313,8 +312,8 @@ class StateMachineAlreadyExists extends SFNServiceException {
         });
         Object.setPrototypeOf(this, StateMachineAlreadyExists.prototype);
     }
-}
-class StateMachineDeleting extends SFNServiceException {
+};
+let StateMachineDeleting$1 = class StateMachineDeleting extends SFNServiceException$1 {
     name = "StateMachineDeleting";
     $fault = "client";
     constructor(opts) {
@@ -325,8 +324,8 @@ class StateMachineDeleting extends SFNServiceException {
         });
         Object.setPrototypeOf(this, StateMachineDeleting.prototype);
     }
-}
-class StateMachineLimitExceeded extends SFNServiceException {
+};
+let StateMachineLimitExceeded$1 = class StateMachineLimitExceeded extends SFNServiceException$1 {
     name = "StateMachineLimitExceeded";
     $fault = "client";
     constructor(opts) {
@@ -337,8 +336,8 @@ class StateMachineLimitExceeded extends SFNServiceException {
         });
         Object.setPrototypeOf(this, StateMachineLimitExceeded.prototype);
     }
-}
-class StateMachineTypeNotSupported extends SFNServiceException {
+};
+let StateMachineTypeNotSupported$1 = class StateMachineTypeNotSupported extends SFNServiceException$1 {
     name = "StateMachineTypeNotSupported";
     $fault = "client";
     constructor(opts) {
@@ -349,14 +348,14 @@ class StateMachineTypeNotSupported extends SFNServiceException {
         });
         Object.setPrototypeOf(this, StateMachineTypeNotSupported.prototype);
     }
-}
+};
 const 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",
 };
-class ValidationException extends SFNServiceException {
+let ValidationException$1 = class ValidationException extends SFNServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     reason;
@@ -369,8 +368,8 @@ class ValidationException extends SFNServiceException {
         Object.setPrototypeOf(this, ValidationException.prototype);
         this.reason = opts.reason;
     }
-}
-class ResourceNotFound extends SFNServiceException {
+};
+let ResourceNotFound$1 = class ResourceNotFound extends SFNServiceException$1 {
     name = "ResourceNotFound";
     $fault = "client";
     resourceName;
@@ -383,8 +382,8 @@ class ResourceNotFound extends SFNServiceException {
         Object.setPrototypeOf(this, ResourceNotFound.prototype);
         this.resourceName = opts.resourceName;
     }
-}
-class ServiceQuotaExceededException extends SFNServiceException {
+};
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends SFNServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     constructor(opts) {
@@ -395,7 +394,7 @@ class ServiceQuotaExceededException extends SFNServiceException {
         });
         Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
     }
-}
+};
 const IncludedData = {
     ALL_DATA: "ALL_DATA",
     METADATA_ONLY: "METADATA_ONLY",
@@ -413,7 +412,7 @@ const ExecutionStatus = {
     SUCCEEDED: "SUCCEEDED",
     TIMED_OUT: "TIMED_OUT",
 };
-class ExecutionDoesNotExist extends SFNServiceException {
+let ExecutionDoesNotExist$1 = class ExecutionDoesNotExist extends SFNServiceException$1 {
     name = "ExecutionDoesNotExist";
     $fault = "client";
     constructor(opts) {
@@ -424,7 +423,7 @@ class ExecutionDoesNotExist extends SFNServiceException {
         });
         Object.setPrototypeOf(this, ExecutionDoesNotExist.prototype);
     }
-}
+};
 const KmsKeyState = {
     CREATING: "CREATING",
     DISABLED: "DISABLED",
@@ -432,7 +431,7 @@ const KmsKeyState = {
     PENDING_IMPORT: "PENDING_IMPORT",
     UNAVAILABLE: "UNAVAILABLE",
 };
-class KmsInvalidStateException extends SFNServiceException {
+let KmsInvalidStateException$1 = class KmsInvalidStateException extends SFNServiceException$1 {
     name = "KmsInvalidStateException";
     $fault = "client";
     kmsKeyState;
@@ -445,7 +444,7 @@ class KmsInvalidStateException extends SFNServiceException {
         Object.setPrototypeOf(this, KmsInvalidStateException.prototype);
         this.kmsKeyState = opts.kmsKeyState;
     }
-}
+};
 const MapRunStatus = {
     ABORTED: "ABORTED",
     FAILED: "FAILED",
@@ -456,7 +455,7 @@ const StateMachineStatus = {
     ACTIVE: "ACTIVE",
     DELETING: "DELETING",
 };
-class StateMachineDoesNotExist extends SFNServiceException {
+let StateMachineDoesNotExist$1 = class StateMachineDoesNotExist extends SFNServiceException$1 {
     name = "StateMachineDoesNotExist";
     $fault = "client";
     constructor(opts) {
@@ -467,7 +466,7 @@ class StateMachineDoesNotExist extends SFNServiceException {
         });
         Object.setPrototypeOf(this, StateMachineDoesNotExist.prototype);
     }
-}
+};
 const HistoryEventType = {
     ActivityFailed: "ActivityFailed",
     ActivityScheduleFailed: "ActivityScheduleFailed",
@@ -532,7 +531,7 @@ const HistoryEventType = {
     WaitStateEntered: "WaitStateEntered",
     WaitStateExited: "WaitStateExited",
 };
-class InvalidToken extends SFNServiceException {
+let InvalidToken$1 = class InvalidToken extends SFNServiceException$1 {
     name = "InvalidToken";
     $fault = "client";
     constructor(opts) {
@@ -543,12 +542,12 @@ class InvalidToken extends SFNServiceException {
         });
         Object.setPrototypeOf(this, InvalidToken.prototype);
     }
-}
+};
 const ExecutionRedriveFilter = {
     NOT_REDRIVEN: "NOT_REDRIVEN",
     REDRIVEN: "REDRIVEN",
 };
-class ExecutionLimitExceeded extends SFNServiceException {
+let ExecutionLimitExceeded$1 = class ExecutionLimitExceeded extends SFNServiceException$1 {
     name = "ExecutionLimitExceeded";
     $fault = "client";
     constructor(opts) {
@@ -559,8 +558,8 @@ class ExecutionLimitExceeded extends SFNServiceException {
         });
         Object.setPrototypeOf(this, ExecutionLimitExceeded.prototype);
     }
-}
-class ExecutionNotRedrivable extends SFNServiceException {
+};
+let ExecutionNotRedrivable$1 = class ExecutionNotRedrivable extends SFNServiceException$1 {
     name = "ExecutionNotRedrivable";
     $fault = "client";
     constructor(opts) {
@@ -571,8 +570,8 @@ class ExecutionNotRedrivable extends SFNServiceException {
         });
         Object.setPrototypeOf(this, ExecutionNotRedrivable.prototype);
     }
-}
-class TaskDoesNotExist extends SFNServiceException {
+};
+let TaskDoesNotExist$1 = class TaskDoesNotExist extends SFNServiceException$1 {
     name = "TaskDoesNotExist";
     $fault = "client";
     constructor(opts) {
@@ -583,8 +582,8 @@ class TaskDoesNotExist extends SFNServiceException {
         });
         Object.setPrototypeOf(this, TaskDoesNotExist.prototype);
     }
-}
-class TaskTimedOut extends SFNServiceException {
+};
+let TaskTimedOut$1 = class TaskTimedOut extends SFNServiceException$1 {
     name = "TaskTimedOut";
     $fault = "client";
     constructor(opts) {
@@ -595,8 +594,8 @@ class TaskTimedOut extends SFNServiceException {
         });
         Object.setPrototypeOf(this, TaskTimedOut.prototype);
     }
-}
-class InvalidOutput extends SFNServiceException {
+};
+let InvalidOutput$1 = class InvalidOutput extends SFNServiceException$1 {
     name = "InvalidOutput";
     $fault = "client";
     constructor(opts) {
@@ -607,8 +606,8 @@ class InvalidOutput extends SFNServiceException {
         });
         Object.setPrototypeOf(this, InvalidOutput.prototype);
     }
-}
-class ExecutionAlreadyExists extends SFNServiceException {
+};
+let ExecutionAlreadyExists$1 = class ExecutionAlreadyExists extends SFNServiceException$1 {
     name = "ExecutionAlreadyExists";
     $fault = "client";
     constructor(opts) {
@@ -619,8 +618,8 @@ class ExecutionAlreadyExists extends SFNServiceException {
         });
         Object.setPrototypeOf(this, ExecutionAlreadyExists.prototype);
     }
-}
-class InvalidExecutionInput extends SFNServiceException {
+};
+let InvalidExecutionInput$1 = class InvalidExecutionInput extends SFNServiceException$1 {
     name = "InvalidExecutionInput";
     $fault = "client";
     constructor(opts) {
@@ -631,7 +630,7 @@ class InvalidExecutionInput extends SFNServiceException {
         });
         Object.setPrototypeOf(this, InvalidExecutionInput.prototype);
     }
-}
+};
 const SyncExecutionStatus = {
     FAILED: "FAILED",
     SUCCEEDED: "SUCCEEDED",
@@ -648,7 +647,7 @@ const TestExecutionStatus = {
     RETRIABLE: "RETRIABLE",
     SUCCEEDED: "SUCCEEDED",
 };
-class MissingRequiredParameter extends SFNServiceException {
+let MissingRequiredParameter$1 = class MissingRequiredParameter extends SFNServiceException$1 {
     name = "MissingRequiredParameter";
     $fault = "client";
     constructor(opts) {
@@ -659,7 +658,7 @@ class MissingRequiredParameter extends SFNServiceException {
         });
         Object.setPrototypeOf(this, MissingRequiredParameter.prototype);
     }
-}
+};
 const ValidateStateMachineDefinitionSeverity = {
     ERROR: "ERROR",
     WARNING: "WARNING",
@@ -668,1886 +667,1879 @@ const ValidateStateMachineDefinitionResultCode = {
     FAIL: "FAIL",
     OK: "OK",
 };
-const ActivityFailedEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const ActivityScheduledEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.input && { input: smithyClient.SENSITIVE_STRING }),
-});
-const ActivityScheduleFailedEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const ActivitySucceededEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.output && { output: smithyClient.SENSITIVE_STRING }),
-});
-const ActivityTimedOutEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const CreateStateMachineInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: smithyClient.SENSITIVE_STRING }),
-    ...(obj.versionDescription && { versionDescription: smithyClient.SENSITIVE_STRING }),
-});
-const CreateStateMachineAliasInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-});
-const DescribeExecutionOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.input && { input: smithyClient.SENSITIVE_STRING }),
-    ...(obj.output && { output: smithyClient.SENSITIVE_STRING }),
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-    ...(obj.redriveStatusReason && { redriveStatusReason: smithyClient.SENSITIVE_STRING }),
-});
-const DescribeStateMachineOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: smithyClient.SENSITIVE_STRING }),
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-    ...(obj.variableReferences && { variableReferences: smithyClient.SENSITIVE_STRING }),
-});
-const DescribeStateMachineAliasOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-});
-const DescribeStateMachineForExecutionOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: smithyClient.SENSITIVE_STRING }),
-    ...(obj.variableReferences && { variableReferences: smithyClient.SENSITIVE_STRING }),
-});
-const GetActivityTaskOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.input && { input: smithyClient.SENSITIVE_STRING }),
-});
-const EvaluationFailedEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-    ...(obj.location && { location: smithyClient.SENSITIVE_STRING }),
-});
-const ExecutionAbortedEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const ExecutionFailedEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const ExecutionStartedEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.input && { input: smithyClient.SENSITIVE_STRING }),
-});
-const ExecutionSucceededEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.output && { output: smithyClient.SENSITIVE_STRING }),
-});
-const ExecutionTimedOutEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const LambdaFunctionFailedEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const LambdaFunctionScheduledEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.input && { input: smithyClient.SENSITIVE_STRING }),
-});
-const LambdaFunctionScheduleFailedEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const LambdaFunctionStartFailedEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const LambdaFunctionSucceededEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.output && { output: smithyClient.SENSITIVE_STRING }),
-});
-const LambdaFunctionTimedOutEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const MapRunFailedEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const StateEnteredEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.input && { input: smithyClient.SENSITIVE_STRING }),
-});
-const StateExitedEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.output && { output: smithyClient.SENSITIVE_STRING }),
-    ...(obj.assignedVariables && { assignedVariables: smithyClient.SENSITIVE_STRING }),
-});
-const TaskFailedEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const TaskScheduledEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.parameters && { parameters: smithyClient.SENSITIVE_STRING }),
-});
-const TaskStartFailedEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const TaskSubmitFailedEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const TaskSubmittedEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.output && { output: smithyClient.SENSITIVE_STRING }),
-});
-const TaskSucceededEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.output && { output: smithyClient.SENSITIVE_STRING }),
-});
-const TaskTimedOutEventDetailsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const HistoryEventFilterSensitiveLog = (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),
-    }),
-    ...(obj.evaluationFailedEventDetails && {
-        evaluationFailedEventDetails: EvaluationFailedEventDetailsFilterSensitiveLog(obj.evaluationFailedEventDetails),
-    }),
-});
-const GetExecutionHistoryOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.events && { events: obj.events.map((item) => HistoryEventFilterSensitiveLog(item)) }),
-});
-const PublishStateMachineVersionInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-});
-const SendTaskFailureInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const SendTaskSuccessInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.output && { output: smithyClient.SENSITIVE_STRING }),
-});
-const StartExecutionInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.input && { input: smithyClient.SENSITIVE_STRING }),
-});
-const StartSyncExecutionInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.input && { input: smithyClient.SENSITIVE_STRING }),
-});
-const StartSyncExecutionOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-    ...(obj.input && { input: smithyClient.SENSITIVE_STRING }),
-    ...(obj.output && { output: smithyClient.SENSITIVE_STRING }),
-});
-const StopExecutionInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-});
-const TestStateInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: smithyClient.SENSITIVE_STRING }),
-    ...(obj.input && { input: smithyClient.SENSITIVE_STRING }),
-    ...(obj.variables && { variables: smithyClient.SENSITIVE_STRING }),
-});
-const InspectionDataFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.input && { input: smithyClient.SENSITIVE_STRING }),
-    ...(obj.afterArguments && { afterArguments: smithyClient.SENSITIVE_STRING }),
-    ...(obj.afterInputPath && { afterInputPath: smithyClient.SENSITIVE_STRING }),
-    ...(obj.afterParameters && { afterParameters: smithyClient.SENSITIVE_STRING }),
-    ...(obj.result && { result: smithyClient.SENSITIVE_STRING }),
-    ...(obj.afterResultSelector && { afterResultSelector: smithyClient.SENSITIVE_STRING }),
-    ...(obj.afterResultPath && { afterResultPath: smithyClient.SENSITIVE_STRING }),
-    ...(obj.variables && { variables: smithyClient.SENSITIVE_STRING }),
-});
-const TestStateOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.output && { output: smithyClient.SENSITIVE_STRING }),
-    ...(obj.error && { error: smithyClient.SENSITIVE_STRING }),
-    ...(obj.cause && { cause: smithyClient.SENSITIVE_STRING }),
-    ...(obj.inspectionData && { inspectionData: smithyClient.SENSITIVE_STRING }),
-});
-const UpdateStateMachineInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: smithyClient.SENSITIVE_STRING }),
-    ...(obj.versionDescription && { versionDescription: smithyClient.SENSITIVE_STRING }),
-});
-const UpdateStateMachineAliasInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.description && { description: smithyClient.SENSITIVE_STRING }),
-});
-const ValidateStateMachineDefinitionInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.definition && { definition: smithyClient.SENSITIVE_STRING }),
-});
-const ValidateStateMachineDefinitionDiagnosticFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.code && { code: smithyClient.SENSITIVE_STRING }),
-    ...(obj.message && { message: smithyClient.SENSITIVE_STRING }),
-    ...(obj.location && { location: smithyClient.SENSITIVE_STRING }),
-});
-const ValidateStateMachineDefinitionOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.diagnostics && {
-        diagnostics: obj.diagnostics.map((item) => ValidateStateMachineDefinitionDiagnosticFilterSensitiveLog(item)),
-    }),
-});
 
-const se_CreateActivityCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateActivity");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateStateMachineCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateStateMachine");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateStateMachineAliasCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateStateMachineAlias");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteActivityCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteActivity");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteStateMachineCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteStateMachine");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteStateMachineAliasCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteStateMachineAlias");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteStateMachineVersionCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteStateMachineVersion");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeActivityCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeActivity");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeExecutionCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeExecution");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeMapRunCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeMapRun");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeStateMachineCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeStateMachine");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeStateMachineAliasCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeStateMachineAlias");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeStateMachineForExecutionCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeStateMachineForExecution");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetActivityTaskCommand = async (input, context) => {
-    const headers = sharedHeaders("GetActivityTask");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetExecutionHistoryCommand = async (input, context) => {
-    const headers = sharedHeaders("GetExecutionHistory");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListActivitiesCommand = async (input, context) => {
-    const headers = sharedHeaders("ListActivities");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListExecutionsCommand = async (input, context) => {
-    const headers = sharedHeaders("ListExecutions");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListMapRunsCommand = async (input, context) => {
-    const headers = sharedHeaders("ListMapRuns");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListStateMachineAliasesCommand = async (input, context) => {
-    const headers = sharedHeaders("ListStateMachineAliases");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListStateMachinesCommand = async (input, context) => {
-    const headers = sharedHeaders("ListStateMachines");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListStateMachineVersionsCommand = async (input, context) => {
-    const headers = sharedHeaders("ListStateMachineVersions");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("ListTagsForResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_PublishStateMachineVersionCommand = async (input, context) => {
-    const headers = sharedHeaders("PublishStateMachineVersion");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_RedriveExecutionCommand = async (input, context) => {
-    const headers = sharedHeaders("RedriveExecution");
-    let body;
-    body = JSON.stringify(se_RedriveExecutionInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_SendTaskFailureCommand = async (input, context) => {
-    const headers = sharedHeaders("SendTaskFailure");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_SendTaskHeartbeatCommand = async (input, context) => {
-    const headers = sharedHeaders("SendTaskHeartbeat");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_SendTaskSuccessCommand = async (input, context) => {
-    const headers = sharedHeaders("SendTaskSuccess");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_StartExecutionCommand = async (input, context) => {
-    const headers = sharedHeaders("StartExecution");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_StartSyncExecutionCommand = async (input, context) => {
-    const headers = sharedHeaders("StartSyncExecution");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    let { hostname: resolvedHostname } = await context.endpoint();
-    if (context.disableHostPrefix !== true) {
-        resolvedHostname = "sync-" + resolvedHostname;
-        if (!protocolHttp.isValidHostname(resolvedHostname)) {
-            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
-        }
-    }
-    return buildHttpRpcRequest(context, headers, "/", resolvedHostname, body);
-};
-const se_StopExecutionCommand = async (input, context) => {
-    const headers = sharedHeaders("StopExecution");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_TagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("TagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_TestStateCommand = async (input, context) => {
-    const headers = sharedHeaders("TestState");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    let { hostname: resolvedHostname } = await context.endpoint();
-    if (context.disableHostPrefix !== true) {
-        resolvedHostname = "sync-" + resolvedHostname;
-        if (!protocolHttp.isValidHostname(resolvedHostname)) {
-            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
-        }
-    }
-    return buildHttpRpcRequest(context, headers, "/", resolvedHostname, body);
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("UntagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateMapRunCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateMapRun");
-    let body;
-    body = JSON.stringify(se_UpdateMapRunInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateStateMachineCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateStateMachine");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateStateMachineAliasCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateStateMachineAlias");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ValidateStateMachineDefinitionCommand = async (input, context) => {
-    const headers = sharedHeaders("ValidateStateMachineDefinition");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_CreateActivityCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_CreateActivityOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateStateMachineCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_CreateStateMachineOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateStateMachineAliasCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_CreateStateMachineAliasOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteActivityCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteStateMachineCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteStateMachineAliasCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteStateMachineVersionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeActivityCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeActivityOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeExecutionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeExecutionOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeMapRunCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeMapRunOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeStateMachineCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeStateMachineOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeStateMachineAliasCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeStateMachineAliasOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeStateMachineForExecutionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeStateMachineForExecutionOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetActivityTaskCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetExecutionHistoryCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetExecutionHistoryOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListActivitiesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListActivitiesOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListExecutionsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListExecutionsOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListMapRunsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListMapRunsOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListStateMachineAliasesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListStateMachineAliasesOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListStateMachinesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListStateMachinesOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListStateMachineVersionsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListStateMachineVersionsOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PublishStateMachineVersionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_PublishStateMachineVersionOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_RedriveExecutionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_RedriveExecutionOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_SendTaskFailureCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_SendTaskHeartbeatCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_SendTaskSuccessCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_StartExecutionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_StartExecutionOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_StartSyncExecutionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_StartSyncExecutionOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_StopExecutionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_StopExecutionOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_TestStateCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateMapRunCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateStateMachineCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_UpdateStateMachineOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateStateMachineAliasCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_UpdateStateMachineAliasOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ValidateStateMachineDefinitionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ActivityAlreadyExists":
-        case "com.amazonaws.sfn#ActivityAlreadyExists":
-            throw await de_ActivityAlreadyExistsRes(parsedOutput);
-        case "ActivityLimitExceeded":
-        case "com.amazonaws.sfn#ActivityLimitExceeded":
-            throw await de_ActivityLimitExceededRes(parsedOutput);
-        case "InvalidEncryptionConfiguration":
-        case "com.amazonaws.sfn#InvalidEncryptionConfiguration":
-            throw await de_InvalidEncryptionConfigurationRes(parsedOutput);
-        case "InvalidName":
-        case "com.amazonaws.sfn#InvalidName":
-            throw await de_InvalidNameRes(parsedOutput);
-        case "KmsAccessDeniedException":
-        case "com.amazonaws.sfn#KmsAccessDeniedException":
-            throw await de_KmsAccessDeniedExceptionRes(parsedOutput);
-        case "KmsThrottlingException":
-        case "com.amazonaws.sfn#KmsThrottlingException":
-            throw await de_KmsThrottlingExceptionRes(parsedOutput);
-        case "TooManyTags":
-        case "com.amazonaws.sfn#TooManyTags":
-            throw await de_TooManyTagsRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.sfn#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await de_InvalidArnRes(parsedOutput);
-        case "InvalidDefinition":
-        case "com.amazonaws.sfn#InvalidDefinition":
-            throw await de_InvalidDefinitionRes(parsedOutput);
-        case "InvalidLoggingConfiguration":
-        case "com.amazonaws.sfn#InvalidLoggingConfiguration":
-            throw await de_InvalidLoggingConfigurationRes(parsedOutput);
-        case "InvalidTracingConfiguration":
-        case "com.amazonaws.sfn#InvalidTracingConfiguration":
-            throw await de_InvalidTracingConfigurationRes(parsedOutput);
-        case "StateMachineAlreadyExists":
-        case "com.amazonaws.sfn#StateMachineAlreadyExists":
-            throw await de_StateMachineAlreadyExistsRes(parsedOutput);
-        case "StateMachineDeleting":
-        case "com.amazonaws.sfn#StateMachineDeleting":
-            throw await de_StateMachineDeletingRes(parsedOutput);
-        case "StateMachineLimitExceeded":
-        case "com.amazonaws.sfn#StateMachineLimitExceeded":
-            throw await de_StateMachineLimitExceededRes(parsedOutput);
-        case "StateMachineTypeNotSupported":
-        case "com.amazonaws.sfn#StateMachineTypeNotSupported":
-            throw await de_StateMachineTypeNotSupportedRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.sfn#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ResourceNotFound":
-        case "com.amazonaws.sfn#ResourceNotFound":
-            throw await de_ResourceNotFoundRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.sfn#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "ActivityDoesNotExist":
-        case "com.amazonaws.sfn#ActivityDoesNotExist":
-            throw await de_ActivityDoesNotExistRes(parsedOutput);
-        case "ExecutionDoesNotExist":
-        case "com.amazonaws.sfn#ExecutionDoesNotExist":
-            throw await de_ExecutionDoesNotExistRes(parsedOutput);
-        case "KmsInvalidStateException":
-        case "com.amazonaws.sfn#KmsInvalidStateException":
-            throw await de_KmsInvalidStateExceptionRes(parsedOutput);
-        case "StateMachineDoesNotExist":
-        case "com.amazonaws.sfn#StateMachineDoesNotExist":
-            throw await de_StateMachineDoesNotExistRes(parsedOutput);
-        case "ActivityWorkerLimitExceeded":
-        case "com.amazonaws.sfn#ActivityWorkerLimitExceeded":
-            throw await de_ActivityWorkerLimitExceededRes(parsedOutput);
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await de_InvalidTokenRes(parsedOutput);
-        case "ExecutionLimitExceeded":
-        case "com.amazonaws.sfn#ExecutionLimitExceeded":
-            throw await de_ExecutionLimitExceededRes(parsedOutput);
-        case "ExecutionNotRedrivable":
-        case "com.amazonaws.sfn#ExecutionNotRedrivable":
-            throw await de_ExecutionNotRedrivableRes(parsedOutput);
-        case "TaskDoesNotExist":
-        case "com.amazonaws.sfn#TaskDoesNotExist":
-            throw await de_TaskDoesNotExistRes(parsedOutput);
-        case "TaskTimedOut":
-        case "com.amazonaws.sfn#TaskTimedOut":
-            throw await de_TaskTimedOutRes(parsedOutput);
-        case "InvalidOutput":
-        case "com.amazonaws.sfn#InvalidOutput":
-            throw await de_InvalidOutputRes(parsedOutput);
-        case "ExecutionAlreadyExists":
-        case "com.amazonaws.sfn#ExecutionAlreadyExists":
-            throw await de_ExecutionAlreadyExistsRes(parsedOutput);
-        case "InvalidExecutionInput":
-        case "com.amazonaws.sfn#InvalidExecutionInput":
-            throw await de_InvalidExecutionInputRes(parsedOutput);
-        case "MissingRequiredParameter":
-        case "com.amazonaws.sfn#MissingRequiredParameter":
-            throw await de_MissingRequiredParameterRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const de_ActivityAlreadyExistsRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ActivityAlreadyExists({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ActivityDoesNotExistRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ActivityDoesNotExist({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ActivityLimitExceededRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ActivityLimitExceeded({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ActivityWorkerLimitExceededRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ActivityWorkerLimitExceeded({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ExecutionAlreadyExistsRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ExecutionAlreadyExists({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ExecutionDoesNotExistRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ExecutionDoesNotExist({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ExecutionLimitExceededRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ExecutionLimitExceeded({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ExecutionNotRedrivableRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ExecutionNotRedrivable({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidArnRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidArn({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidDefinitionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidDefinition({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidEncryptionConfigurationRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidEncryptionConfiguration({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidExecutionInputRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidExecutionInput({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidLoggingConfigurationRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidLoggingConfiguration({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidNameRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidName({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidOutputRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidOutput({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidTokenRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidToken({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidTracingConfigurationRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidTracingConfiguration({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_KmsAccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new KmsAccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_KmsInvalidStateExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new KmsInvalidStateException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_KmsThrottlingExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new KmsThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_MissingRequiredParameterRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new MissingRequiredParameter({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ResourceNotFoundRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ResourceNotFound({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ServiceQuotaExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_StateMachineAlreadyExistsRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new StateMachineAlreadyExists({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_StateMachineDeletingRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new StateMachineDeleting({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_StateMachineDoesNotExistRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new StateMachineDoesNotExist({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_StateMachineLimitExceededRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new StateMachineLimitExceeded({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_StateMachineTypeNotSupportedRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new StateMachineTypeNotSupported({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_TaskDoesNotExistRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new TaskDoesNotExist({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_TaskTimedOutRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new TaskTimedOut({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_TooManyTagsRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new TooManyTags({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const se_RedriveExecutionInput = (input, context) => {
-    return smithyClient.take(input, {
-        clientToken: [true, (_) => _ ?? uuid.v4()],
-        executionArn: [],
-    });
-};
-const se_UpdateMapRunInput = (input, context) => {
-    return smithyClient.take(input, {
-        mapRunArn: [],
-        maxConcurrency: [],
-        toleratedFailureCount: [],
-        toleratedFailurePercentage: smithyClient.serializeFloat,
-    });
-};
-const de_ActivityList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ActivityListItem(entry);
-    });
-    return retVal;
-};
-const de_ActivityListItem = (output, context) => {
-    return smithyClient.take(output, {
-        activityArn: smithyClient.expectString,
-        creationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        name: smithyClient.expectString,
-    });
-};
-const de_CreateActivityOutput = (output, context) => {
-    return smithyClient.take(output, {
-        activityArn: smithyClient.expectString,
-        creationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_CreateStateMachineAliasOutput = (output, context) => {
-    return smithyClient.take(output, {
-        creationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        stateMachineAliasArn: smithyClient.expectString,
-    });
-};
-const de_CreateStateMachineOutput = (output, context) => {
-    return smithyClient.take(output, {
-        creationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        stateMachineArn: smithyClient.expectString,
-        stateMachineVersionArn: smithyClient.expectString,
-    });
-};
-const de_DescribeActivityOutput = (output, context) => {
-    return smithyClient.take(output, {
-        activityArn: smithyClient.expectString,
-        creationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        encryptionConfiguration: smithyClient._json,
-        name: smithyClient.expectString,
-    });
-};
-const de_DescribeExecutionOutput = (output, context) => {
-    return smithyClient.take(output, {
-        cause: smithyClient.expectString,
-        error: smithyClient.expectString,
-        executionArn: smithyClient.expectString,
-        input: smithyClient.expectString,
-        inputDetails: smithyClient._json,
-        mapRunArn: smithyClient.expectString,
-        name: smithyClient.expectString,
-        output: smithyClient.expectString,
-        outputDetails: smithyClient._json,
-        redriveCount: smithyClient.expectInt32,
-        redriveDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        redriveStatus: smithyClient.expectString,
-        redriveStatusReason: smithyClient.expectString,
-        startDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        stateMachineAliasArn: smithyClient.expectString,
-        stateMachineArn: smithyClient.expectString,
-        stateMachineVersionArn: smithyClient.expectString,
-        status: smithyClient.expectString,
-        stopDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        traceHeader: smithyClient.expectString,
-    });
-};
-const de_DescribeMapRunOutput = (output, context) => {
-    return smithyClient.take(output, {
-        executionArn: smithyClient.expectString,
-        executionCounts: smithyClient._json,
-        itemCounts: smithyClient._json,
-        mapRunArn: smithyClient.expectString,
-        maxConcurrency: smithyClient.expectInt32,
-        redriveCount: smithyClient.expectInt32,
-        redriveDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        startDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        status: smithyClient.expectString,
-        stopDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        toleratedFailureCount: smithyClient.expectLong,
-        toleratedFailurePercentage: smithyClient.limitedParseFloat32,
-    });
-};
-const de_DescribeStateMachineAliasOutput = (output, context) => {
-    return smithyClient.take(output, {
-        creationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        description: smithyClient.expectString,
-        name: smithyClient.expectString,
-        routingConfiguration: smithyClient._json,
-        stateMachineAliasArn: smithyClient.expectString,
-        updateDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_DescribeStateMachineForExecutionOutput = (output, context) => {
-    return smithyClient.take(output, {
-        definition: smithyClient.expectString,
-        encryptionConfiguration: smithyClient._json,
-        label: smithyClient.expectString,
-        loggingConfiguration: smithyClient._json,
-        mapRunArn: smithyClient.expectString,
-        name: smithyClient.expectString,
-        revisionId: smithyClient.expectString,
-        roleArn: smithyClient.expectString,
-        stateMachineArn: smithyClient.expectString,
-        tracingConfiguration: smithyClient._json,
-        updateDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        variableReferences: smithyClient._json,
-    });
-};
-const de_DescribeStateMachineOutput = (output, context) => {
-    return smithyClient.take(output, {
-        creationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        definition: smithyClient.expectString,
-        description: smithyClient.expectString,
-        encryptionConfiguration: smithyClient._json,
-        label: smithyClient.expectString,
-        loggingConfiguration: smithyClient._json,
-        name: smithyClient.expectString,
-        revisionId: smithyClient.expectString,
-        roleArn: smithyClient.expectString,
-        stateMachineArn: smithyClient.expectString,
-        status: smithyClient.expectString,
-        tracingConfiguration: smithyClient._json,
-        type: smithyClient.expectString,
-        variableReferences: smithyClient._json,
-    });
-};
-const de_ExecutionList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ExecutionListItem(entry);
-    });
-    return retVal;
-};
-const de_ExecutionListItem = (output, context) => {
-    return smithyClient.take(output, {
-        executionArn: smithyClient.expectString,
-        itemCount: smithyClient.expectInt32,
-        mapRunArn: smithyClient.expectString,
-        name: smithyClient.expectString,
-        redriveCount: smithyClient.expectInt32,
-        redriveDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        startDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        stateMachineAliasArn: smithyClient.expectString,
-        stateMachineArn: smithyClient.expectString,
-        stateMachineVersionArn: smithyClient.expectString,
-        status: smithyClient.expectString,
-        stopDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_GetExecutionHistoryOutput = (output, context) => {
-    return smithyClient.take(output, {
-        events: (_) => de_HistoryEventList(_),
-        nextToken: smithyClient.expectString,
-    });
-};
-const de_HistoryEvent = (output, context) => {
-    return smithyClient.take(output, {
-        activityFailedEventDetails: smithyClient._json,
-        activityScheduleFailedEventDetails: smithyClient._json,
-        activityScheduledEventDetails: smithyClient._json,
-        activityStartedEventDetails: smithyClient._json,
-        activitySucceededEventDetails: smithyClient._json,
-        activityTimedOutEventDetails: smithyClient._json,
-        evaluationFailedEventDetails: smithyClient._json,
-        executionAbortedEventDetails: smithyClient._json,
-        executionFailedEventDetails: smithyClient._json,
-        executionRedrivenEventDetails: smithyClient._json,
-        executionStartedEventDetails: smithyClient._json,
-        executionSucceededEventDetails: smithyClient._json,
-        executionTimedOutEventDetails: smithyClient._json,
-        id: smithyClient.expectLong,
-        lambdaFunctionFailedEventDetails: smithyClient._json,
-        lambdaFunctionScheduleFailedEventDetails: smithyClient._json,
-        lambdaFunctionScheduledEventDetails: smithyClient._json,
-        lambdaFunctionStartFailedEventDetails: smithyClient._json,
-        lambdaFunctionSucceededEventDetails: smithyClient._json,
-        lambdaFunctionTimedOutEventDetails: smithyClient._json,
-        mapIterationAbortedEventDetails: smithyClient._json,
-        mapIterationFailedEventDetails: smithyClient._json,
-        mapIterationStartedEventDetails: smithyClient._json,
-        mapIterationSucceededEventDetails: smithyClient._json,
-        mapRunFailedEventDetails: smithyClient._json,
-        mapRunRedrivenEventDetails: smithyClient._json,
-        mapRunStartedEventDetails: smithyClient._json,
-        mapStateStartedEventDetails: smithyClient._json,
-        previousEventId: smithyClient.expectLong,
-        stateEnteredEventDetails: smithyClient._json,
-        stateExitedEventDetails: smithyClient._json,
-        taskFailedEventDetails: smithyClient._json,
-        taskScheduledEventDetails: smithyClient._json,
-        taskStartFailedEventDetails: smithyClient._json,
-        taskStartedEventDetails: smithyClient._json,
-        taskSubmitFailedEventDetails: smithyClient._json,
-        taskSubmittedEventDetails: smithyClient._json,
-        taskSucceededEventDetails: smithyClient._json,
-        taskTimedOutEventDetails: smithyClient._json,
-        timestamp: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        type: smithyClient.expectString,
-    });
-};
-const de_HistoryEventList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_HistoryEvent(entry);
-    });
-    return retVal;
-};
-const de_ListActivitiesOutput = (output, context) => {
-    return smithyClient.take(output, {
-        activities: (_) => de_ActivityList(_),
-        nextToken: smithyClient.expectString,
-    });
-};
-const de_ListExecutionsOutput = (output, context) => {
-    return smithyClient.take(output, {
-        executions: (_) => de_ExecutionList(_),
-        nextToken: smithyClient.expectString,
-    });
-};
-const de_ListMapRunsOutput = (output, context) => {
-    return smithyClient.take(output, {
-        mapRuns: (_) => de_MapRunList(_),
-        nextToken: smithyClient.expectString,
-    });
-};
-const de_ListStateMachineAliasesOutput = (output, context) => {
-    return smithyClient.take(output, {
-        nextToken: smithyClient.expectString,
-        stateMachineAliases: (_) => de_StateMachineAliasList(_),
-    });
-};
-const de_ListStateMachinesOutput = (output, context) => {
-    return smithyClient.take(output, {
-        nextToken: smithyClient.expectString,
-        stateMachines: (_) => de_StateMachineList(_),
-    });
-};
-const de_ListStateMachineVersionsOutput = (output, context) => {
-    return smithyClient.take(output, {
-        nextToken: smithyClient.expectString,
-        stateMachineVersions: (_) => de_StateMachineVersionList(_),
-    });
-};
-const de_MapRunList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_MapRunListItem(entry);
-    });
-    return retVal;
-};
-const de_MapRunListItem = (output, context) => {
-    return smithyClient.take(output, {
-        executionArn: smithyClient.expectString,
-        mapRunArn: smithyClient.expectString,
-        startDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        stateMachineArn: smithyClient.expectString,
-        stopDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_PublishStateMachineVersionOutput = (output, context) => {
-    return smithyClient.take(output, {
-        creationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        stateMachineVersionArn: smithyClient.expectString,
-    });
-};
-const de_RedriveExecutionOutput = (output, context) => {
-    return smithyClient.take(output, {
-        redriveDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_StartExecutionOutput = (output, context) => {
-    return smithyClient.take(output, {
-        executionArn: smithyClient.expectString,
-        startDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_StartSyncExecutionOutput = (output, context) => {
-    return smithyClient.take(output, {
-        billingDetails: smithyClient._json,
-        cause: smithyClient.expectString,
-        error: smithyClient.expectString,
-        executionArn: smithyClient.expectString,
-        input: smithyClient.expectString,
-        inputDetails: smithyClient._json,
-        name: smithyClient.expectString,
-        output: smithyClient.expectString,
-        outputDetails: smithyClient._json,
-        startDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        stateMachineArn: smithyClient.expectString,
-        status: smithyClient.expectString,
-        stopDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        traceHeader: smithyClient.expectString,
-    });
-};
-const de_StateMachineAliasList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_StateMachineAliasListItem(entry);
-    });
-    return retVal;
-};
-const de_StateMachineAliasListItem = (output, context) => {
-    return smithyClient.take(output, {
-        creationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        stateMachineAliasArn: smithyClient.expectString,
-    });
-};
-const de_StateMachineList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_StateMachineListItem(entry);
-    });
-    return retVal;
-};
-const de_StateMachineListItem = (output, context) => {
-    return smithyClient.take(output, {
-        creationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        name: smithyClient.expectString,
-        stateMachineArn: smithyClient.expectString,
-        type: smithyClient.expectString,
-    });
-};
-const de_StateMachineVersionList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_StateMachineVersionListItem(entry);
-    });
-    return retVal;
-};
-const de_StateMachineVersionListItem = (output, context) => {
-    return smithyClient.take(output, {
-        creationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        stateMachineVersionArn: smithyClient.expectString,
-    });
-};
-const de_StopExecutionOutput = (output, context) => {
-    return smithyClient.take(output, {
-        stopDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_UpdateStateMachineAliasOutput = (output, context) => {
-    return smithyClient.take(output, {
-        updateDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_UpdateStateMachineOutput = (output, context) => {
-    return smithyClient.take(output, {
-        revisionId: smithyClient.expectString,
-        stateMachineVersionArn: smithyClient.expectString,
-        updateDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
-const throwDefaultError = smithyClient.withBaseException(SFNServiceException);
-const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const contents = {
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-        headers,
-    };
-    if (resolvedHostname !== undefined) {
-        contents.hostname = resolvedHostname;
-    }
-    if (body !== undefined) {
-        contents.body = body;
-    }
-    return new protocolHttp.HttpRequest(contents);
-};
-function sharedHeaders(operation) {
-    return {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": `AWSStepFunctions.${operation}`,
-    };
-}
+const _AAE = "ActivityAlreadyExists";
+const _AD = "AliasDescription";
+const _ADNE = "ActivityDoesNotExist";
+const _AFED = "ActivityFailedEventDetails";
+const _AL = "ActivityList";
+const _ALE = "ActivityLimitExceeded";
+const _ALI = "ActivityListItem";
+const _ASED = "ActivityScheduledEventDetails";
+const _ASEDc = "ActivityStartedEventDetails";
+const _ASEDct = "ActivitySucceededEventDetails";
+const _ASFED = "ActivityScheduleFailedEventDetails";
+const _ATOED = "ActivityTimedOutEventDetails";
+const _AV = "AssignedVariables";
+const _AVD = "AssignedVariablesDetails";
+const _AWLE = "ActivityWorkerLimitExceeded";
+const _BD = "BillingDetails";
+const _CA = "CreateActivity";
+const _CAI = "CreateActivityInput";
+const _CAO = "CreateActivityOutput";
+const _CE = "ConflictException";
+const _CP = "ConnectorParameters";
+const _CSM = "CreateStateMachine";
+const _CSMA = "CreateStateMachineAlias";
+const _CSMAI = "CreateStateMachineAliasInput";
+const _CSMAO = "CreateStateMachineAliasOutput";
+const _CSMI = "CreateStateMachineInput";
+const _CSMO = "CreateStateMachineOutput";
+const _CWEEDD = "CloudWatchEventsExecutionDataDetails";
+const _CWLLG = "CloudWatchLogsLogGroup";
+const _D = "Definition";
+const _DA = "DeleteActivity";
+const _DAI = "DeleteActivityInput";
+const _DAIe = "DescribeActivityInput";
+const _DAO = "DeleteActivityOutput";
+const _DAOe = "DescribeActivityOutput";
+const _DAe = "DescribeActivity";
+const _DE = "DescribeExecution";
+const _DEI = "DescribeExecutionInput";
+const _DEO = "DescribeExecutionOutput";
+const _DMR = "DescribeMapRun";
+const _DMRI = "DescribeMapRunInput";
+const _DMRO = "DescribeMapRunOutput";
+const _DSM = "DeleteStateMachine";
+const _DSMA = "DeleteStateMachineAlias";
+const _DSMAI = "DeleteStateMachineAliasInput";
+const _DSMAIe = "DescribeStateMachineAliasInput";
+const _DSMAO = "DeleteStateMachineAliasOutput";
+const _DSMAOe = "DescribeStateMachineAliasOutput";
+const _DSMAe = "DescribeStateMachineAlias";
+const _DSMFE = "DescribeStateMachineForExecution";
+const _DSMFEI = "DescribeStateMachineForExecutionInput";
+const _DSMFEO = "DescribeStateMachineForExecutionOutput";
+const _DSMI = "DeleteStateMachineInput";
+const _DSMIe = "DescribeStateMachineInput";
+const _DSMO = "DeleteStateMachineOutput";
+const _DSMOe = "DescribeStateMachineOutput";
+const _DSMV = "DeleteStateMachineVersion";
+const _DSMVI = "DeleteStateMachineVersionInput";
+const _DSMVO = "DeleteStateMachineVersionOutput";
+const _DSMe = "DescribeStateMachine";
+const _EAE = "ExecutionAlreadyExists";
+const _EAED = "ExecutionAbortedEventDetails";
+const _EC = "EncryptionConfiguration";
+const _EDNE = "ExecutionDoesNotExist";
+const _EFED = "EvaluationFailedEventDetails";
+const _EFEDx = "ExecutionFailedEventDetails";
+const _EFL = "EvaluationFailureLocation";
+const _EL = "ExecutionList";
+const _ELE = "ExecutionLimitExceeded";
+const _ELI = "ExecutionListItem";
+const _ENR = "ExecutionNotRedrivable";
+const _ERED = "ExecutionRedrivenEventDetails";
+const _ESED = "ExecutionStartedEventDetails";
+const _ESEDx = "ExecutionSucceededEventDetails";
+const _ETOED = "ExecutionTimedOutEventDetails";
+const _GAT = "GetActivityTask";
+const _GATI = "GetActivityTaskInput";
+const _GATO = "GetActivityTaskOutput";
+const _GEH = "GetExecutionHistory";
+const _GEHI = "GetExecutionHistoryInput";
+const _GEHO = "GetExecutionHistoryOutput";
+const _HE = "HistoryEvent";
+const _HEEDD = "HistoryEventExecutionDataDetails";
+const _HEL = "HistoryEventList";
+const _IA = "InvalidArn";
+const _ID = "InspectionData";
+const _IDR = "InspectionDataRequest";
+const _IDRn = "InspectionDataResponse";
+const _IDn = "InvalidDefinition";
+const _IEC = "InvalidEncryptionConfiguration";
+const _IEI = "InvalidExecutionInput";
+const _ILC = "InvalidLoggingConfiguration";
+const _IN = "InvalidName";
+const _IO = "InvalidOutput";
+const _IT = "InvalidToken";
+const _ITC = "InvalidTracingConfiguration";
+const _KADE = "KmsAccessDeniedException";
+const _KISE = "KmsInvalidStateException";
+const _KTE = "KmsThrottlingException";
+const _LA = "ListActivities";
+const _LAI = "ListActivitiesInput";
+const _LAO = "ListActivitiesOutput";
+const _LC = "LoggingConfiguration";
+const _LD = "LogDestination";
+const _LDL = "LogDestinationList";
+const _LE = "ListExecutions";
+const _LEI = "ListExecutionsInput";
+const _LEO = "ListExecutionsOutput";
+const _LFFED = "LambdaFunctionFailedEventDetails";
+const _LFSED = "LambdaFunctionScheduledEventDetails";
+const _LFSEDa = "LambdaFunctionSucceededEventDetails";
+const _LFSFED = "LambdaFunctionScheduleFailedEventDetails";
+const _LFSFEDa = "LambdaFunctionStartFailedEventDetails";
+const _LFTOED = "LambdaFunctionTimedOutEventDetails";
+const _LMR = "ListMapRuns";
+const _LMRI = "ListMapRunsInput";
+const _LMRO = "ListMapRunsOutput";
+const _LSM = "ListStateMachines";
+const _LSMA = "ListStateMachineAliases";
+const _LSMAI = "ListStateMachineAliasesInput";
+const _LSMAO = "ListStateMachineAliasesOutput";
+const _LSMI = "ListStateMachinesInput";
+const _LSMO = "ListStateMachinesOutput";
+const _LSMV = "ListStateMachineVersions";
+const _LSMVI = "ListStateMachineVersionsInput";
+const _LSMVO = "ListStateMachineVersionsOutput";
+const _LTFR = "ListTagsForResource";
+const _LTFRI = "ListTagsForResourceInput";
+const _LTFRO = "ListTagsForResourceOutput";
+const _MIED = "MapIterationEventDetails";
+const _MREC = "MapRunExecutionCounts";
+const _MRFED = "MapRunFailedEventDetails";
+const _MRIC = "MapRunItemCounts";
+const _MRL = "MapRunList";
+const _MRLI = "MapRunListItem";
+const _MRP = "MissingRequiredParameter";
+const _MRRED = "MapRunRedrivenEventDetails";
+const _MRSED = "MapRunStartedEventDetails";
+const _MSSED = "MapStateStartedEventDetails";
+const _PSMV = "PublishStateMachineVersion";
+const _PSMVI = "PublishStateMachineVersionInput";
+const _PSMVO = "PublishStateMachineVersionOutput";
+const _RCL = "RoutingConfigurationList";
+const _RCLI = "RoutingConfigurationListItem";
+const _RE = "RedriveExecution";
+const _REI = "RedriveExecutionInput";
+const _REO = "RedriveExecutionOutput";
+const _RNF = "ResourceNotFound";
+const _SC = "SensitiveCause";
+const _SD = "SensitiveData";
+const _SDJI = "SensitiveDataJobInput";
+const _SE = "SensitiveError";
+const _SEED = "StateEnteredEventDetails";
+const _SEEDt = "StateExitedEventDetails";
+const _SEI = "StartExecutionInput";
+const _SEIt = "StopExecutionInput";
+const _SEO = "StartExecutionOutput";
+const _SEOt = "StopExecutionOutput";
+const _SEt = "StartExecution";
+const _SEto = "StopExecution";
+const _SMAE = "StateMachineAlreadyExists";
+const _SMAL = "StateMachineAliasList";
+const _SMALI = "StateMachineAliasListItem";
+const _SMD = "StateMachineDeleting";
+const _SMDNE = "StateMachineDoesNotExist";
+const _SML = "StateMachineList";
+const _SMLE = "StateMachineLimitExceeded";
+const _SMLI = "StateMachineListItem";
+const _SMTNS = "StateMachineTypeNotSupported";
+const _SMVL = "StateMachineVersionList";
+const _SMVLI = "StateMachineVersionListItem";
+const _SQEE = "ServiceQuotaExceededException";
+const _SSE = "StartSyncExecution";
+const _SSEI = "StartSyncExecutionInput";
+const _SSEO = "StartSyncExecutionOutput";
+const _STF = "SendTaskFailure";
+const _STFI = "SendTaskFailureInput";
+const _STFO = "SendTaskFailureOutput";
+const _STH = "SendTaskHeartbeat";
+const _STHI = "SendTaskHeartbeatInput";
+const _STHO = "SendTaskHeartbeatOutput";
+const _STS = "SendTaskSuccess";
+const _STSI = "SendTaskSuccessInput";
+const _STSO = "SendTaskSuccessOutput";
+const _T = "Tag";
+const _TC = "TaskCredentials";
+const _TCr = "TracingConfiguration";
+const _TDNE = "TaskDoesNotExist";
+const _TFED = "TaskFailedEventDetails";
+const _TL = "TagList";
+const _TMT = "TooManyTags";
+const _TR = "TagResource";
+const _TRI = "TagResourceInput";
+const _TRO = "TagResourceOutput";
+const _TS = "TestState";
+const _TSED = "TaskScheduledEventDetails";
+const _TSEDa = "TaskStartedEventDetails";
+const _TSEDas = "TaskSubmittedEventDetails";
+const _TSEDask = "TaskSucceededEventDetails";
+const _TSFED = "TaskStartFailedEventDetails";
+const _TSFEDa = "TaskSubmitFailedEventDetails";
+const _TSI = "TestStateInput";
+const _TSO = "TestStateOutput";
+const _TTO = "TaskTimedOut";
+const _TTOED = "TaskTimedOutEventDetails";
+const _UMR = "UpdateMapRun";
+const _UMRI = "UpdateMapRunInput";
+const _UMRO = "UpdateMapRunOutput";
+const _UR = "UntagResource";
+const _URI = "UntagResourceInput";
+const _URO = "UntagResourceOutput";
+const _USM = "UpdateStateMachine";
+const _USMA = "UpdateStateMachineAlias";
+const _USMAI = "UpdateStateMachineAliasInput";
+const _USMAO = "UpdateStateMachineAliasOutput";
+const _USMI = "UpdateStateMachineInput";
+const _USMO = "UpdateStateMachineOutput";
+const _VD = "VersionDescription";
+const _VE = "ValidationException";
+const _VN = "VariableName";
+const _VNL = "VariableNameList";
+const _VR = "VariableReferences";
+const _VSMD = "ValidateStateMachineDefinition";
+const _VSMDC = "ValidateStateMachineDefinitionCode";
+const _VSMDD = "ValidateStateMachineDefinitionDiagnostic";
+const _VSMDDL = "ValidateStateMachineDefinitionDiagnosticList";
+const _VSMDI = "ValidateStateMachineDefinitionInput";
+const _VSMDL = "ValidateStateMachineDefinitionLocation";
+const _VSMDM = "ValidateStateMachineDefinitionMessage";
+const _VSMDO = "ValidateStateMachineDefinitionOutput";
+const _VV = "VariableValue";
+const _a = "activities";
+const _aA = "activityArn";
+const _aAf = "afterArguments";
+const _aFED = "activityFailedEventDetails";
+const _aIP = "afterInputPath";
+const _aP = "afterParameters";
+const _aRP = "afterResultPath";
+const _aRS = "afterResultSelector";
+const _aSED = "activityScheduledEventDetails";
+const _aSEDc = "activityStartedEventDetails";
+const _aSEDct = "activitySucceededEventDetails";
+const _aSFED = "activityScheduleFailedEventDetails";
+const _aTOED = "activityTimedOutEventDetails";
+const _aV = "assignedVariables";
+const _aVD = "assignedVariablesDetails";
+const _ab = "aborted";
+const _b = "body";
+const _bD = "billingDetails";
+const _bDIM = "billedDurationInMilliseconds";
+const _bMUIMB = "billedMemoryUsedInMB";
+const _c = "client";
+const _cD = "creationDate";
+const _cT = "clientToken";
+const _cWLLG = "cloudWatchLogsLogGroup";
+const _ca = "cause";
+const _co = "code";
+const _d = "description";
+const _de = "definition";
+const _des = "destinations";
+const _di = "diagnostics";
+const _e = "error";
+const _eA = "executionArn";
+const _eAED = "executionAbortedEventDetails";
+const _eC = "encryptionConfiguration";
+const _eCx = "executionCounts";
+const _eFED = "executionFailedEventDetails";
+const _eFEDv = "evaluationFailedEventDetails";
+const _eRED = "executionRedrivenEventDetails";
+const _eSED = "executionStartedEventDetails";
+const _eSEDx = "executionSucceededEventDetails";
+const _eTOED = "executionTimedOutEventDetails";
+const _en = "enabled";
+const _end = "endpoint";
+const _ev = "events";
+const _ex = "executions";
+const _f = "failed";
+const _fNR = "failuresNotRedrivable";
+const _h = "headers";
+const _hE = "httpError";
+const _hIS = "heartbeatInSeconds";
+const _i = "input";
+const _iC = "itemCounts";
+const _iCt = "itemCount";
+const _iD = "inputDetails";
+const _iDn = "includedData";
+const _iDns = "inspectionData";
+const _iED = "includeExecutionData";
+const _iL = "inspectionLevel";
+const _id = "id";
+const _in = "included";
+const _ind = "index";
+const _k = "key";
+const _kDKRPS = "kmsDataKeyReusePeriodSeconds";
+const _kKI = "kmsKeyId";
+const _kKS = "kmsKeyState";
+const _l = "label";
+const _lC = "loggingConfiguration";
+const _lFFED = "lambdaFunctionFailedEventDetails";
+const _lFSED = "lambdaFunctionScheduledEventDetails";
+const _lFSEDa = "lambdaFunctionSucceededEventDetails";
+const _lFSFED = "lambdaFunctionScheduleFailedEventDetails";
+const _lFSFEDa = "lambdaFunctionStartFailedEventDetails";
+const _lFTOED = "lambdaFunctionTimedOutEventDetails";
+const _lGA = "logGroupArn";
+const _le = "level";
+const _len = "length";
+const _lo = "location";
+const _m = "message";
+const _mC = "maxConcurrency";
+const _mIAED = "mapIterationAbortedEventDetails";
+const _mIFED = "mapIterationFailedEventDetails";
+const _mISED = "mapIterationStartedEventDetails";
+const _mISEDa = "mapIterationSucceededEventDetails";
+const _mR = "maxResults";
+const _mRA = "mapRunArn";
+const _mRFED = "mapRunFailedEventDetails";
+const _mRRED = "mapRunRedrivenEventDetails";
+const _mRSED = "mapRunStartedEventDetails";
+const _mRa = "mapRuns";
+const _mSSED = "mapStateStartedEventDetails";
+const _me = "method";
+const _n = "name";
+const _nS = "nextState";
+const _nT = "nextToken";
+const _o = "output";
+const _oD = "outputDetails";
+const _p = "publish";
+const _pEI = "previousEventId";
+const _pR = "pendingRedrive";
+const _pa = "parameters";
+const _pe = "pending";
+const _pr = "protocol";
+const _r = "resource";
+const _rA = "roleArn";
+const _rAe = "resourceArn";
+const _rC = "routingConfiguration";
+const _rCe = "redriveCount";
+const _rD = "redriveDate";
+const _rF = "redriveFilter";
+const _rI = "revisionId";
+const _rN = "resourceName";
+const _rO = "reverseOrder";
+const _rS = "redriveStatus";
+const _rSR = "redriveStatusReason";
+const _rSe = "revealSecrets";
+const _rT = "resourceType";
+const _rW = "resultsWritten";
+const _re = "result";
+const _rea = "reason";
+const _reg = "region";
+const _req = "request";
+const _res = "response";
+const _ru = "running";
+const _s = "status";
+const _sC = "statusCode";
+const _sD = "startDate";
+const _sDt = "stopDate";
+const _sEED = "stateEnteredEventDetails";
+const _sEEDt = "stateExitedEventDetails";
+const _sF = "statusFilter";
+const _sM = "statusMessage";
+const _sMA = "stateMachineArn";
+const _sMAA = "stateMachineAliasArn";
+const _sMAt = "stateMachineAliases";
+const _sMV = "stateMachineVersions";
+const _sMVA = "stateMachineVersionArn";
+const _sMt = "stateMachines";
+const _se = "severity";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.sfn";
+const _st = "state";
+const _su = "succeeded";
+const _t = "truncated";
+const _tC = "tracingConfiguration";
+const _tCa = "taskCredentials";
+const _tFC = "toleratedFailureCount";
+const _tFED = "taskFailedEventDetails";
+const _tFP = "toleratedFailurePercentage";
+const _tH = "traceHeader";
+const _tIS = "timeoutInSeconds";
+const _tK = "tagKeys";
+const _tO = "timedOut";
+const _tSED = "taskScheduledEventDetails";
+const _tSEDa = "taskStartedEventDetails";
+const _tSEDas = "taskSubmittedEventDetails";
+const _tSEDask = "taskSucceededEventDetails";
+const _tSFED = "taskStartFailedEventDetails";
+const _tSFEDa = "taskSubmitFailedEventDetails";
+const _tT = "taskToken";
+const _tTOED = "taskTimedOutEventDetails";
+const _ta = "tags";
+const _ti = "timestamp";
+const _to = "total";
+const _ty = "type";
+const _u = "url";
+const _uD = "updateDate";
+const _v = "variables";
+const _vD = "versionDescription";
+const _vR = "variableReferences";
+const _va = "value";
+const _w = "weight";
+const _wN = "workerName";
+const n0 = "com.amazonaws.sfn";
+var AliasDescription = [0, n0, _AD, 8, 0];
+var ConnectorParameters = [0, n0, _CP, 8, 0];
+var Definition = [0, n0, _D, 8, 0];
+var EvaluationFailureLocation = [0, n0, _EFL, 8, 0];
+var SensitiveCause = [0, n0, _SC, 8, 0];
+var SensitiveData = [0, n0, _SD, 8, 0];
+var SensitiveDataJobInput = [0, n0, _SDJI, 8, 0];
+var SensitiveError = [0, n0, _SE, 8, 0];
+var ValidateStateMachineDefinitionCode = [0, n0, _VSMDC, 8, 0];
+var ValidateStateMachineDefinitionLocation = [0, n0, _VSMDL, 8, 0];
+var ValidateStateMachineDefinitionMessage = [0, n0, _VSMDM, 8, 0];
+var VariableName = [0, n0, _VN, 8, 0];
+var VariableValue = [0, n0, _VV, 8, 0];
+var VersionDescription = [0, n0, _VD, 8, 0];
+var ActivityAlreadyExists = [
+    -3,
+    n0,
+    _AAE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ActivityAlreadyExists, ActivityAlreadyExists$1);
+var ActivityDoesNotExist = [
+    -3,
+    n0,
+    _ADNE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ActivityDoesNotExist, ActivityDoesNotExist$1);
+var ActivityFailedEventDetails = [
+    3,
+    n0,
+    _AFED,
+    0,
+    [_e, _ca],
+    [
+        [() => SensitiveError, 0],
+        [() => SensitiveCause, 0],
+    ],
+];
+var ActivityLimitExceeded = [
+    -3,
+    n0,
+    _ALE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ActivityLimitExceeded, ActivityLimitExceeded$1);
+var ActivityListItem = [3, n0, _ALI, 0, [_aA, _n, _cD], [0, 0, 4]];
+var ActivityScheduledEventDetails = [
+    3,
+    n0,
+    _ASED,
+    0,
+    [_r, _i, _iD, _tIS, _hIS],
+    [0, [() => SensitiveData, 0], () => HistoryEventExecutionDataDetails, 1, 1],
+];
+var ActivityScheduleFailedEventDetails = [
+    3,
+    n0,
+    _ASFED,
+    0,
+    [_e, _ca],
+    [
+        [() => SensitiveError, 0],
+        [() => SensitiveCause, 0],
+    ],
+];
+var ActivityStartedEventDetails = [3, n0, _ASEDc, 0, [_wN], [0]];
+var ActivitySucceededEventDetails = [
+    3,
+    n0,
+    _ASEDct,
+    0,
+    [_o, _oD],
+    [[() => SensitiveData, 0], () => HistoryEventExecutionDataDetails],
+];
+var ActivityTimedOutEventDetails = [
+    3,
+    n0,
+    _ATOED,
+    0,
+    [_e, _ca],
+    [
+        [() => SensitiveError, 0],
+        [() => SensitiveCause, 0],
+    ],
+];
+var ActivityWorkerLimitExceeded = [
+    -3,
+    n0,
+    _AWLE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ActivityWorkerLimitExceeded, ActivityWorkerLimitExceeded$1);
+var AssignedVariablesDetails = [3, n0, _AVD, 0, [_t], [2]];
+var BillingDetails = [3, n0, _BD, 0, [_bMUIMB, _bDIM], [1, 1]];
+var CloudWatchEventsExecutionDataDetails = [3, n0, _CWEEDD, 0, [_in], [2]];
+var CloudWatchLogsLogGroup = [3, n0, _CWLLG, 0, [_lGA], [0]];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateActivityInput = [
+    3,
+    n0,
+    _CAI,
+    0,
+    [_n, _ta, _eC],
+    [0, () => TagList, () => EncryptionConfiguration],
+];
+var CreateActivityOutput = [3, n0, _CAO, 0, [_aA, _cD], [0, 4]];
+var CreateStateMachineAliasInput = [
+    3,
+    n0,
+    _CSMAI,
+    0,
+    [_d, _n, _rC],
+    [[() => AliasDescription, 0], 0, () => RoutingConfigurationList],
+];
+var CreateStateMachineAliasOutput = [3, n0, _CSMAO, 0, [_sMAA, _cD], [0, 4]];
+var CreateStateMachineInput = [
+    3,
+    n0,
+    _CSMI,
+    0,
+    [_n, _de, _rA, _ty, _lC, _ta, _tC, _p, _vD, _eC],
+    [
+        0,
+        [() => Definition, 0],
+        0,
+        0,
+        () => LoggingConfiguration,
+        () => TagList,
+        () => TracingConfiguration,
+        2,
+        [() => VersionDescription, 0],
+        () => EncryptionConfiguration,
+    ],
+];
+var CreateStateMachineOutput = [3, n0, _CSMO, 0, [_sMA, _cD, _sMVA], [0, 4, 0]];
+var DeleteActivityInput = [3, n0, _DAI, 0, [_aA], [0]];
+var DeleteActivityOutput = [3, n0, _DAO, 0, [], []];
+var DeleteStateMachineAliasInput = [3, n0, _DSMAI, 0, [_sMAA], [0]];
+var DeleteStateMachineAliasOutput = [3, n0, _DSMAO, 0, [], []];
+var DeleteStateMachineInput = [3, n0, _DSMI, 0, [_sMA], [0]];
+var DeleteStateMachineOutput = [3, n0, _DSMO, 0, [], []];
+var DeleteStateMachineVersionInput = [3, n0, _DSMVI, 0, [_sMVA], [0]];
+var DeleteStateMachineVersionOutput = [3, n0, _DSMVO, 0, [], []];
+var DescribeActivityInput = [3, n0, _DAIe, 0, [_aA], [0]];
+var DescribeActivityOutput = [
+    3,
+    n0,
+    _DAOe,
+    0,
+    [_aA, _n, _cD, _eC],
+    [0, 0, 4, () => EncryptionConfiguration],
+];
+var DescribeExecutionInput = [3, n0, _DEI, 0, [_eA, _iDn], [0, 0]];
+var DescribeExecutionOutput = [
+    3,
+    n0,
+    _DEO,
+    0,
+    [_eA, _sMA, _n, _s, _sD, _sDt, _i, _iD, _o, _oD, _tH, _mRA, _e, _ca, _sMVA, _sMAA, _rCe, _rD, _rS, _rSR],
+    [
+        0,
+        0,
+        0,
+        0,
+        4,
+        4,
+        [() => SensitiveData, 0],
+        () => CloudWatchEventsExecutionDataDetails,
+        [() => SensitiveData, 0],
+        () => CloudWatchEventsExecutionDataDetails,
+        0,
+        0,
+        [() => SensitiveError, 0],
+        [() => SensitiveCause, 0],
+        0,
+        0,
+        1,
+        4,
+        0,
+        [() => SensitiveData, 0],
+    ],
+];
+var DescribeMapRunInput = [3, n0, _DMRI, 0, [_mRA], [0]];
+var DescribeMapRunOutput = [
+    3,
+    n0,
+    _DMRO,
+    0,
+    [_mRA, _eA, _s, _sD, _sDt, _mC, _tFP, _tFC, _iC, _eCx, _rCe, _rD],
+    [0, 0, 0, 4, 4, 1, 1, 1, () => MapRunItemCounts, () => MapRunExecutionCounts, 1, 4],
+];
+var DescribeStateMachineAliasInput = [3, n0, _DSMAIe, 0, [_sMAA], [0]];
+var DescribeStateMachineAliasOutput = [
+    3,
+    n0,
+    _DSMAOe,
+    0,
+    [_sMAA, _n, _d, _rC, _cD, _uD],
+    [0, 0, [() => AliasDescription, 0], () => RoutingConfigurationList, 4, 4],
+];
+var DescribeStateMachineForExecutionInput = [3, n0, _DSMFEI, 0, [_eA, _iDn], [0, 0]];
+var DescribeStateMachineForExecutionOutput = [
+    3,
+    n0,
+    _DSMFEO,
+    0,
+    [_sMA, _n, _de, _rA, _uD, _lC, _tC, _mRA, _l, _rI, _eC, _vR],
+    [
+        0,
+        0,
+        [() => Definition, 0],
+        0,
+        4,
+        () => LoggingConfiguration,
+        () => TracingConfiguration,
+        0,
+        0,
+        0,
+        () => EncryptionConfiguration,
+        [() => VariableReferences, 0],
+    ],
+];
+var DescribeStateMachineInput = [3, n0, _DSMIe, 0, [_sMA, _iDn], [0, 0]];
+var DescribeStateMachineOutput = [
+    3,
+    n0,
+    _DSMOe,
+    0,
+    [_sMA, _n, _s, _de, _rA, _ty, _cD, _lC, _tC, _l, _rI, _d, _eC, _vR],
+    [
+        0,
+        0,
+        0,
+        [() => Definition, 0],
+        0,
+        0,
+        4,
+        () => LoggingConfiguration,
+        () => TracingConfiguration,
+        0,
+        0,
+        [() => VersionDescription, 0],
+        () => EncryptionConfiguration,
+        [() => VariableReferences, 0],
+    ],
+];
+var EncryptionConfiguration = [3, n0, _EC, 0, [_kKI, _kDKRPS, _ty], [0, 1, 0]];
+var EvaluationFailedEventDetails = [
+    3,
+    n0,
+    _EFED,
+    0,
+    [_e, _ca, _lo, _st],
+    [[() => SensitiveError, 0], [() => SensitiveCause, 0], [() => EvaluationFailureLocation, 0], 0],
+];
+var ExecutionAbortedEventDetails = [
+    3,
+    n0,
+    _EAED,
+    0,
+    [_e, _ca],
+    [
+        [() => SensitiveError, 0],
+        [() => SensitiveCause, 0],
+    ],
+];
+var ExecutionAlreadyExists = [
+    -3,
+    n0,
+    _EAE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ExecutionAlreadyExists, ExecutionAlreadyExists$1);
+var ExecutionDoesNotExist = [
+    -3,
+    n0,
+    _EDNE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ExecutionDoesNotExist, ExecutionDoesNotExist$1);
+var ExecutionFailedEventDetails = [
+    3,
+    n0,
+    _EFEDx,
+    0,
+    [_e, _ca],
+    [
+        [() => SensitiveError, 0],
+        [() => SensitiveCause, 0],
+    ],
+];
+var ExecutionLimitExceeded = [
+    -3,
+    n0,
+    _ELE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ExecutionLimitExceeded, ExecutionLimitExceeded$1);
+var ExecutionListItem = [
+    3,
+    n0,
+    _ELI,
+    0,
+    [_eA, _sMA, _n, _s, _sD, _sDt, _mRA, _iCt, _sMVA, _sMAA, _rCe, _rD],
+    [0, 0, 0, 0, 4, 4, 0, 1, 0, 0, 1, 4],
+];
+var ExecutionNotRedrivable = [
+    -3,
+    n0,
+    _ENR,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ExecutionNotRedrivable, ExecutionNotRedrivable$1);
+var ExecutionRedrivenEventDetails = [3, n0, _ERED, 0, [_rCe], [1]];
+var ExecutionStartedEventDetails = [
+    3,
+    n0,
+    _ESED,
+    0,
+    [_i, _iD, _rA, _sMAA, _sMVA],
+    [[() => SensitiveData, 0], () => HistoryEventExecutionDataDetails, 0, 0, 0],
+];
+var ExecutionSucceededEventDetails = [
+    3,
+    n0,
+    _ESEDx,
+    0,
+    [_o, _oD],
+    [[() => SensitiveData, 0], () => HistoryEventExecutionDataDetails],
+];
+var ExecutionTimedOutEventDetails = [
+    3,
+    n0,
+    _ETOED,
+    0,
+    [_e, _ca],
+    [
+        [() => SensitiveError, 0],
+        [() => SensitiveCause, 0],
+    ],
+];
+var GetActivityTaskInput = [3, n0, _GATI, 0, [_aA, _wN], [0, 0]];
+var GetActivityTaskOutput = [
+    3,
+    n0,
+    _GATO,
+    0,
+    [_tT, _i],
+    [0, [() => SensitiveDataJobInput, 0]],
+];
+var GetExecutionHistoryInput = [
+    3,
+    n0,
+    _GEHI,
+    0,
+    [_eA, _mR, _rO, _nT, _iED],
+    [0, 1, 2, 0, 2],
+];
+var GetExecutionHistoryOutput = [
+    3,
+    n0,
+    _GEHO,
+    0,
+    [_ev, _nT],
+    [[() => HistoryEventList, 0], 0],
+];
+var HistoryEvent = [
+    3,
+    n0,
+    _HE,
+    0,
+    [
+        _ti,
+        _ty,
+        _id,
+        _pEI,
+        _aFED,
+        _aSFED,
+        _aSED,
+        _aSEDc,
+        _aSEDct,
+        _aTOED,
+        _tFED,
+        _tSED,
+        _tSFED,
+        _tSEDa,
+        _tSFEDa,
+        _tSEDas,
+        _tSEDask,
+        _tTOED,
+        _eFED,
+        _eSED,
+        _eSEDx,
+        _eAED,
+        _eTOED,
+        _eRED,
+        _mSSED,
+        _mISED,
+        _mISEDa,
+        _mIFED,
+        _mIAED,
+        _lFFED,
+        _lFSFED,
+        _lFSED,
+        _lFSFEDa,
+        _lFSEDa,
+        _lFTOED,
+        _sEED,
+        _sEEDt,
+        _mRSED,
+        _mRFED,
+        _mRRED,
+        _eFEDv,
+    ],
+    [
+        4,
+        0,
+        1,
+        1,
+        [() => ActivityFailedEventDetails, 0],
+        [() => ActivityScheduleFailedEventDetails, 0],
+        [() => ActivityScheduledEventDetails, 0],
+        () => ActivityStartedEventDetails,
+        [() => ActivitySucceededEventDetails, 0],
+        [() => ActivityTimedOutEventDetails, 0],
+        [() => TaskFailedEventDetails, 0],
+        [() => TaskScheduledEventDetails, 0],
+        [() => TaskStartFailedEventDetails, 0],
+        () => TaskStartedEventDetails,
+        [() => TaskSubmitFailedEventDetails, 0],
+        [() => TaskSubmittedEventDetails, 0],
+        [() => TaskSucceededEventDetails, 0],
+        [() => TaskTimedOutEventDetails, 0],
+        [() => ExecutionFailedEventDetails, 0],
+        [() => ExecutionStartedEventDetails, 0],
+        [() => ExecutionSucceededEventDetails, 0],
+        [() => ExecutionAbortedEventDetails, 0],
+        [() => ExecutionTimedOutEventDetails, 0],
+        () => ExecutionRedrivenEventDetails,
+        () => MapStateStartedEventDetails,
+        () => MapIterationEventDetails,
+        () => MapIterationEventDetails,
+        () => MapIterationEventDetails,
+        () => MapIterationEventDetails,
+        [() => LambdaFunctionFailedEventDetails, 0],
+        [() => LambdaFunctionScheduleFailedEventDetails, 0],
+        [() => LambdaFunctionScheduledEventDetails, 0],
+        [() => LambdaFunctionStartFailedEventDetails, 0],
+        [() => LambdaFunctionSucceededEventDetails, 0],
+        [() => LambdaFunctionTimedOutEventDetails, 0],
+        [() => StateEnteredEventDetails, 0],
+        [() => StateExitedEventDetails, 0],
+        () => MapRunStartedEventDetails,
+        [() => MapRunFailedEventDetails, 0],
+        () => MapRunRedrivenEventDetails,
+        [() => EvaluationFailedEventDetails, 0],
+    ],
+];
+var HistoryEventExecutionDataDetails = [3, n0, _HEEDD, 0, [_t], [2]];
+var InspectionData = [
+    3,
+    n0,
+    _ID,
+    8,
+    [_i, _aAf, _aIP, _aP, _re, _aRS, _aRP, _req, _res, _v],
+    [
+        [() => SensitiveData, 0],
+        [() => SensitiveData, 0],
+        [() => SensitiveData, 0],
+        [() => SensitiveData, 0],
+        [() => SensitiveData, 0],
+        [() => SensitiveData, 0],
+        [() => SensitiveData, 0],
+        () => InspectionDataRequest,
+        () => InspectionDataResponse,
+        [() => SensitiveData, 0],
+    ],
+];
+var InspectionDataRequest = [3, n0, _IDR, 0, [_pr, _me, _u, _h, _b], [0, 0, 0, 0, 0]];
+var InspectionDataResponse = [3, n0, _IDRn, 0, [_pr, _sC, _sM, _h, _b], [0, 0, 0, 0, 0]];
+var InvalidArn = [
+    -3,
+    n0,
+    _IA,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidArn, InvalidArn$1);
+var InvalidDefinition = [
+    -3,
+    n0,
+    _IDn,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidDefinition, InvalidDefinition$1);
+var InvalidEncryptionConfiguration = [
+    -3,
+    n0,
+    _IEC,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidEncryptionConfiguration, InvalidEncryptionConfiguration$1);
+var InvalidExecutionInput = [
+    -3,
+    n0,
+    _IEI,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidExecutionInput, InvalidExecutionInput$1);
+var InvalidLoggingConfiguration = [
+    -3,
+    n0,
+    _ILC,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidLoggingConfiguration, InvalidLoggingConfiguration$1);
+var InvalidName = [
+    -3,
+    n0,
+    _IN,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidName, InvalidName$1);
+var InvalidOutput = [
+    -3,
+    n0,
+    _IO,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidOutput, InvalidOutput$1);
+var InvalidToken = [
+    -3,
+    n0,
+    _IT,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidToken, InvalidToken$1);
+var InvalidTracingConfiguration = [
+    -3,
+    n0,
+    _ITC,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidTracingConfiguration, InvalidTracingConfiguration$1);
+var KmsAccessDeniedException = [
+    -3,
+    n0,
+    _KADE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(KmsAccessDeniedException, KmsAccessDeniedException$1);
+var KmsInvalidStateException = [
+    -3,
+    n0,
+    _KISE,
+    {
+        [_e]: _c,
+    },
+    [_kKS, _m],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(KmsInvalidStateException, KmsInvalidStateException$1);
+var KmsThrottlingException = [
+    -3,
+    n0,
+    _KTE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(KmsThrottlingException, KmsThrottlingException$1);
+var LambdaFunctionFailedEventDetails = [
+    3,
+    n0,
+    _LFFED,
+    0,
+    [_e, _ca],
+    [
+        [() => SensitiveError, 0],
+        [() => SensitiveCause, 0],
+    ],
+];
+var LambdaFunctionScheduledEventDetails = [
+    3,
+    n0,
+    _LFSED,
+    0,
+    [_r, _i, _iD, _tIS, _tCa],
+    [0, [() => SensitiveData, 0], () => HistoryEventExecutionDataDetails, 1, () => TaskCredentials],
+];
+var LambdaFunctionScheduleFailedEventDetails = [
+    3,
+    n0,
+    _LFSFED,
+    0,
+    [_e, _ca],
+    [
+        [() => SensitiveError, 0],
+        [() => SensitiveCause, 0],
+    ],
+];
+var LambdaFunctionStartFailedEventDetails = [
+    3,
+    n0,
+    _LFSFEDa,
+    0,
+    [_e, _ca],
+    [
+        [() => SensitiveError, 0],
+        [() => SensitiveCause, 0],
+    ],
+];
+var LambdaFunctionSucceededEventDetails = [
+    3,
+    n0,
+    _LFSEDa,
+    0,
+    [_o, _oD],
+    [[() => SensitiveData, 0], () => HistoryEventExecutionDataDetails],
+];
+var LambdaFunctionTimedOutEventDetails = [
+    3,
+    n0,
+    _LFTOED,
+    0,
+    [_e, _ca],
+    [
+        [() => SensitiveError, 0],
+        [() => SensitiveCause, 0],
+    ],
+];
+var ListActivitiesInput = [3, n0, _LAI, 0, [_mR, _nT], [1, 0]];
+var ListActivitiesOutput = [3, n0, _LAO, 0, [_a, _nT], [() => ActivityList, 0]];
+var ListExecutionsInput = [
+    3,
+    n0,
+    _LEI,
+    0,
+    [_sMA, _sF, _mR, _nT, _mRA, _rF],
+    [0, 0, 1, 0, 0, 0],
+];
+var ListExecutionsOutput = [3, n0, _LEO, 0, [_ex, _nT], [() => ExecutionList, 0]];
+var ListMapRunsInput = [3, n0, _LMRI, 0, [_eA, _mR, _nT], [0, 1, 0]];
+var ListMapRunsOutput = [3, n0, _LMRO, 0, [_mRa, _nT], [() => MapRunList, 0]];
+var ListStateMachineAliasesInput = [3, n0, _LSMAI, 0, [_sMA, _nT, _mR], [0, 0, 1]];
+var ListStateMachineAliasesOutput = [
+    3,
+    n0,
+    _LSMAO,
+    0,
+    [_sMAt, _nT],
+    [() => StateMachineAliasList, 0],
+];
+var ListStateMachinesInput = [3, n0, _LSMI, 0, [_mR, _nT], [1, 0]];
+var ListStateMachinesOutput = [3, n0, _LSMO, 0, [_sMt, _nT], [() => StateMachineList, 0]];
+var ListStateMachineVersionsInput = [3, n0, _LSMVI, 0, [_sMA, _nT, _mR], [0, 0, 1]];
+var ListStateMachineVersionsOutput = [
+    3,
+    n0,
+    _LSMVO,
+    0,
+    [_sMV, _nT],
+    [() => StateMachineVersionList, 0],
+];
+var ListTagsForResourceInput = [3, n0, _LTFRI, 0, [_rAe], [0]];
+var ListTagsForResourceOutput = [3, n0, _LTFRO, 0, [_ta], [() => TagList]];
+var LogDestination = [3, n0, _LD, 0, [_cWLLG], [() => CloudWatchLogsLogGroup]];
+var LoggingConfiguration = [
+    3,
+    n0,
+    _LC,
+    0,
+    [_le, _iED, _des],
+    [0, 2, () => LogDestinationList],
+];
+var MapIterationEventDetails = [3, n0, _MIED, 0, [_n, _ind], [0, 1]];
+var MapRunExecutionCounts = [
+    3,
+    n0,
+    _MREC,
+    0,
+    [_pe, _ru, _su, _f, _tO, _ab, _to, _rW, _fNR, _pR],
+    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+];
+var MapRunFailedEventDetails = [
+    3,
+    n0,
+    _MRFED,
+    0,
+    [_e, _ca],
+    [
+        [() => SensitiveError, 0],
+        [() => SensitiveCause, 0],
+    ],
+];
+var MapRunItemCounts = [
+    3,
+    n0,
+    _MRIC,
+    0,
+    [_pe, _ru, _su, _f, _tO, _ab, _to, _rW, _fNR, _pR],
+    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
+];
+var MapRunListItem = [3, n0, _MRLI, 0, [_eA, _mRA, _sMA, _sD, _sDt], [0, 0, 0, 4, 4]];
+var MapRunRedrivenEventDetails = [3, n0, _MRRED, 0, [_mRA, _rCe], [0, 1]];
+var MapRunStartedEventDetails = [3, n0, _MRSED, 0, [_mRA], [0]];
+var MapStateStartedEventDetails = [3, n0, _MSSED, 0, [_len], [1]];
+var MissingRequiredParameter = [
+    -3,
+    n0,
+    _MRP,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(MissingRequiredParameter, MissingRequiredParameter$1);
+var PublishStateMachineVersionInput = [
+    3,
+    n0,
+    _PSMVI,
+    0,
+    [_sMA, _rI, _d],
+    [0, 0, [() => VersionDescription, 0]],
+];
+var PublishStateMachineVersionOutput = [3, n0, _PSMVO, 0, [_cD, _sMVA], [4, 0]];
+var RedriveExecutionInput = [3, n0, _REI, 0, [_eA, _cT], [0, [0, 4]]];
+var RedriveExecutionOutput = [3, n0, _REO, 0, [_rD], [4]];
+var ResourceNotFound = [
+    -3,
+    n0,
+    _RNF,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m, _rN],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFound, ResourceNotFound$1);
+var RoutingConfigurationListItem = [3, n0, _RCLI, 0, [_sMVA, _w], [0, 1]];
+var SendTaskFailureInput = [
+    3,
+    n0,
+    _STFI,
+    0,
+    [_tT, _e, _ca],
+    [0, [() => SensitiveError, 0], [() => SensitiveCause, 0]],
+];
+var SendTaskFailureOutput = [3, n0, _STFO, 0, [], []];
+var SendTaskHeartbeatInput = [3, n0, _STHI, 0, [_tT], [0]];
+var SendTaskHeartbeatOutput = [3, n0, _STHO, 0, [], []];
+var SendTaskSuccessInput = [3, n0, _STSI, 0, [_tT, _o], [0, [() => SensitiveData, 0]]];
+var SendTaskSuccessOutput = [3, n0, _STSO, 0, [], []];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var StartExecutionInput = [
+    3,
+    n0,
+    _SEI,
+    0,
+    [_sMA, _n, _i, _tH],
+    [0, 0, [() => SensitiveData, 0], 0],
+];
+var StartExecutionOutput = [3, n0, _SEO, 0, [_eA, _sD], [0, 4]];
+var StartSyncExecutionInput = [
+    3,
+    n0,
+    _SSEI,
+    0,
+    [_sMA, _n, _i, _tH, _iDn],
+    [0, 0, [() => SensitiveData, 0], 0, 0],
+];
+var StartSyncExecutionOutput = [
+    3,
+    n0,
+    _SSEO,
+    0,
+    [_eA, _sMA, _n, _sD, _sDt, _s, _e, _ca, _i, _iD, _o, _oD, _tH, _bD],
+    [
+        0,
+        0,
+        0,
+        4,
+        4,
+        0,
+        [() => SensitiveError, 0],
+        [() => SensitiveCause, 0],
+        [() => SensitiveData, 0],
+        () => CloudWatchEventsExecutionDataDetails,
+        [() => SensitiveData, 0],
+        () => CloudWatchEventsExecutionDataDetails,
+        0,
+        () => BillingDetails,
+    ],
+];
+var StateEnteredEventDetails = [
+    3,
+    n0,
+    _SEED,
+    0,
+    [_n, _i, _iD],
+    [0, [() => SensitiveData, 0], () => HistoryEventExecutionDataDetails],
+];
+var StateExitedEventDetails = [
+    3,
+    n0,
+    _SEEDt,
+    0,
+    [_n, _o, _oD, _aV, _aVD],
+    [
+        0,
+        [() => SensitiveData, 0],
+        () => HistoryEventExecutionDataDetails,
+        [() => AssignedVariables, 0],
+        () => AssignedVariablesDetails,
+    ],
+];
+var StateMachineAliasListItem = [3, n0, _SMALI, 0, [_sMAA, _cD], [0, 4]];
+var StateMachineAlreadyExists = [
+    -3,
+    n0,
+    _SMAE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(StateMachineAlreadyExists, StateMachineAlreadyExists$1);
+var StateMachineDeleting = [
+    -3,
+    n0,
+    _SMD,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(StateMachineDeleting, StateMachineDeleting$1);
+var StateMachineDoesNotExist = [
+    -3,
+    n0,
+    _SMDNE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(StateMachineDoesNotExist, StateMachineDoesNotExist$1);
+var StateMachineLimitExceeded = [
+    -3,
+    n0,
+    _SMLE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(StateMachineLimitExceeded, StateMachineLimitExceeded$1);
+var StateMachineListItem = [3, n0, _SMLI, 0, [_sMA, _n, _ty, _cD], [0, 0, 0, 4]];
+var StateMachineTypeNotSupported = [
+    -3,
+    n0,
+    _SMTNS,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(StateMachineTypeNotSupported, StateMachineTypeNotSupported$1);
+var StateMachineVersionListItem = [3, n0, _SMVLI, 0, [_sMVA, _cD], [0, 4]];
+var StopExecutionInput = [
+    3,
+    n0,
+    _SEIt,
+    0,
+    [_eA, _e, _ca],
+    [0, [() => SensitiveError, 0], [() => SensitiveCause, 0]],
+];
+var StopExecutionOutput = [3, n0, _SEOt, 0, [_sDt], [4]];
+var Tag = [3, n0, _T, 0, [_k, _va], [0, 0]];
+var TagResourceInput = [3, n0, _TRI, 0, [_rAe, _ta], [0, () => TagList]];
+var TagResourceOutput = [3, n0, _TRO, 0, [], []];
+var TaskCredentials = [3, n0, _TC, 0, [_rA], [0]];
+var TaskDoesNotExist = [
+    -3,
+    n0,
+    _TDNE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TaskDoesNotExist, TaskDoesNotExist$1);
+var TaskFailedEventDetails = [
+    3,
+    n0,
+    _TFED,
+    0,
+    [_rT, _r, _e, _ca],
+    [0, 0, [() => SensitiveError, 0], [() => SensitiveCause, 0]],
+];
+var TaskScheduledEventDetails = [
+    3,
+    n0,
+    _TSED,
+    0,
+    [_rT, _r, _reg, _pa, _tIS, _hIS, _tCa],
+    [0, 0, 0, [() => ConnectorParameters, 0], 1, 1, () => TaskCredentials],
+];
+var TaskStartedEventDetails = [3, n0, _TSEDa, 0, [_rT, _r], [0, 0]];
+var TaskStartFailedEventDetails = [
+    3,
+    n0,
+    _TSFED,
+    0,
+    [_rT, _r, _e, _ca],
+    [0, 0, [() => SensitiveError, 0], [() => SensitiveCause, 0]],
+];
+var TaskSubmitFailedEventDetails = [
+    3,
+    n0,
+    _TSFEDa,
+    0,
+    [_rT, _r, _e, _ca],
+    [0, 0, [() => SensitiveError, 0], [() => SensitiveCause, 0]],
+];
+var TaskSubmittedEventDetails = [
+    3,
+    n0,
+    _TSEDas,
+    0,
+    [_rT, _r, _o, _oD],
+    [0, 0, [() => SensitiveData, 0], () => HistoryEventExecutionDataDetails],
+];
+var TaskSucceededEventDetails = [
+    3,
+    n0,
+    _TSEDask,
+    0,
+    [_rT, _r, _o, _oD],
+    [0, 0, [() => SensitiveData, 0], () => HistoryEventExecutionDataDetails],
+];
+var TaskTimedOut = [
+    -3,
+    n0,
+    _TTO,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TaskTimedOut, TaskTimedOut$1);
+var TaskTimedOutEventDetails = [
+    3,
+    n0,
+    _TTOED,
+    0,
+    [_rT, _r, _e, _ca],
+    [0, 0, [() => SensitiveError, 0], [() => SensitiveCause, 0]],
+];
+var TestStateInput = [
+    3,
+    n0,
+    _TSI,
+    0,
+    [_de, _rA, _i, _iL, _rSe, _v],
+    [[() => Definition, 0], 0, [() => SensitiveData, 0], 0, 2, [() => SensitiveData, 0]],
+];
+var TestStateOutput = [
+    3,
+    n0,
+    _TSO,
+    0,
+    [_o, _e, _ca, _iDns, _nS, _s],
+    [[() => SensitiveData, 0], [() => SensitiveError, 0], [() => SensitiveCause, 0], [() => InspectionData, 0], 0, 0],
+];
+var TooManyTags = [
+    -3,
+    n0,
+    _TMT,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m, _rN],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(TooManyTags, TooManyTags$1);
+var TracingConfiguration = [3, n0, _TCr, 0, [_en], [2]];
+var UntagResourceInput = [3, n0, _URI, 0, [_rAe, _tK], [0, 64 | 0]];
+var UntagResourceOutput = [3, n0, _URO, 0, [], []];
+var UpdateMapRunInput = [3, n0, _UMRI, 0, [_mRA, _mC, _tFP, _tFC], [0, 1, 1, 1]];
+var UpdateMapRunOutput = [3, n0, _UMRO, 0, [], []];
+var UpdateStateMachineAliasInput = [
+    3,
+    n0,
+    _USMAI,
+    0,
+    [_sMAA, _d, _rC],
+    [0, [() => AliasDescription, 0], () => RoutingConfigurationList],
+];
+var UpdateStateMachineAliasOutput = [3, n0, _USMAO, 0, [_uD], [4]];
+var UpdateStateMachineInput = [
+    3,
+    n0,
+    _USMI,
+    0,
+    [_sMA, _de, _rA, _lC, _tC, _p, _vD, _eC],
+    [
+        0,
+        [() => Definition, 0],
+        0,
+        () => LoggingConfiguration,
+        () => TracingConfiguration,
+        2,
+        [() => VersionDescription, 0],
+        () => EncryptionConfiguration,
+    ],
+];
+var UpdateStateMachineOutput = [3, n0, _USMO, 0, [_uD, _rI, _sMVA], [4, 0, 0]];
+var ValidateStateMachineDefinitionDiagnostic = [
+    3,
+    n0,
+    _VSMDD,
+    0,
+    [_se, _co, _m, _lo],
+    [
+        0,
+        [() => ValidateStateMachineDefinitionCode, 0],
+        [() => ValidateStateMachineDefinitionMessage, 0],
+        [() => ValidateStateMachineDefinitionLocation, 0],
+    ],
+];
+var ValidateStateMachineDefinitionInput = [
+    3,
+    n0,
+    _VSMDI,
+    0,
+    [_de, _ty, _se, _mR],
+    [[() => Definition, 0], 0, 0, 1],
+];
+var ValidateStateMachineDefinitionOutput = [
+    3,
+    n0,
+    _VSMDO,
+    0,
+    [_re, _di, _t],
+    [0, [() => ValidateStateMachineDefinitionDiagnosticList, 0], 2],
+];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m, _rea],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var SFNServiceException = [-3, _sm, "SFNServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(SFNServiceException, SFNServiceException$1);
+var ActivityList = [1, n0, _AL, 0, () => ActivityListItem];
+var ExecutionList = [1, n0, _EL, 0, () => ExecutionListItem];
+var HistoryEventList = [1, n0, _HEL, 0, [() => HistoryEvent, 0]];
+var LogDestinationList = [1, n0, _LDL, 0, () => LogDestination];
+var MapRunList = [1, n0, _MRL, 0, () => MapRunListItem];
+var RoutingConfigurationList = [1, n0, _RCL, 0, () => RoutingConfigurationListItem];
+var StateMachineAliasList = [1, n0, _SMAL, 0, () => StateMachineAliasListItem];
+var StateMachineList = [1, n0, _SML, 0, () => StateMachineListItem];
+var StateMachineVersionList = [1, n0, _SMVL, 0, () => StateMachineVersionListItem];
+var TagList = [1, n0, _TL, 0, () => Tag];
+var ValidateStateMachineDefinitionDiagnosticList = [
+    1,
+    n0,
+    _VSMDDL,
+    0,
+    [() => ValidateStateMachineDefinitionDiagnostic, 0],
+];
+var VariableNameList = [1, n0, _VNL, 0, [() => VariableName, 0]];
+var AssignedVariables = [2, n0, _AV, 0, [() => VariableName, 0], [() => VariableValue, 0]];
+var VariableReferences = [2, n0, _VR, 8, [0, 0], [() => VariableNameList, 0]];
+var CreateActivity = [
+    9,
+    n0,
+    _CA,
+    2,
+    () => CreateActivityInput,
+    () => CreateActivityOutput,
+];
+var CreateStateMachine = [
+    9,
+    n0,
+    _CSM,
+    2,
+    () => CreateStateMachineInput,
+    () => CreateStateMachineOutput,
+];
+var CreateStateMachineAlias = [
+    9,
+    n0,
+    _CSMA,
+    0,
+    () => CreateStateMachineAliasInput,
+    () => CreateStateMachineAliasOutput,
+];
+var DeleteActivity = [
+    9,
+    n0,
+    _DA,
+    0,
+    () => DeleteActivityInput,
+    () => DeleteActivityOutput,
+];
+var DeleteStateMachine = [
+    9,
+    n0,
+    _DSM,
+    0,
+    () => DeleteStateMachineInput,
+    () => DeleteStateMachineOutput,
+];
+var DeleteStateMachineAlias = [
+    9,
+    n0,
+    _DSMA,
+    0,
+    () => DeleteStateMachineAliasInput,
+    () => DeleteStateMachineAliasOutput,
+];
+var DeleteStateMachineVersion = [
+    9,
+    n0,
+    _DSMV,
+    0,
+    () => DeleteStateMachineVersionInput,
+    () => DeleteStateMachineVersionOutput,
+];
+var DescribeActivity = [
+    9,
+    n0,
+    _DAe,
+    0,
+    () => DescribeActivityInput,
+    () => DescribeActivityOutput,
+];
+var DescribeExecution = [
+    9,
+    n0,
+    _DE,
+    0,
+    () => DescribeExecutionInput,
+    () => DescribeExecutionOutput,
+];
+var DescribeMapRun = [
+    9,
+    n0,
+    _DMR,
+    0,
+    () => DescribeMapRunInput,
+    () => DescribeMapRunOutput,
+];
+var DescribeStateMachine = [
+    9,
+    n0,
+    _DSMe,
+    0,
+    () => DescribeStateMachineInput,
+    () => DescribeStateMachineOutput,
+];
+var DescribeStateMachineAlias = [
+    9,
+    n0,
+    _DSMAe,
+    0,
+    () => DescribeStateMachineAliasInput,
+    () => DescribeStateMachineAliasOutput,
+];
+var DescribeStateMachineForExecution = [
+    9,
+    n0,
+    _DSMFE,
+    0,
+    () => DescribeStateMachineForExecutionInput,
+    () => DescribeStateMachineForExecutionOutput,
+];
+var GetActivityTask = [
+    9,
+    n0,
+    _GAT,
+    0,
+    () => GetActivityTaskInput,
+    () => GetActivityTaskOutput,
+];
+var GetExecutionHistory = [
+    9,
+    n0,
+    _GEH,
+    0,
+    () => GetExecutionHistoryInput,
+    () => GetExecutionHistoryOutput,
+];
+var ListActivities = [
+    9,
+    n0,
+    _LA,
+    0,
+    () => ListActivitiesInput,
+    () => ListActivitiesOutput,
+];
+var ListExecutions = [
+    9,
+    n0,
+    _LE,
+    0,
+    () => ListExecutionsInput,
+    () => ListExecutionsOutput,
+];
+var ListMapRuns = [9, n0, _LMR, 0, () => ListMapRunsInput, () => ListMapRunsOutput];
+var ListStateMachineAliases = [
+    9,
+    n0,
+    _LSMA,
+    0,
+    () => ListStateMachineAliasesInput,
+    () => ListStateMachineAliasesOutput,
+];
+var ListStateMachines = [
+    9,
+    n0,
+    _LSM,
+    0,
+    () => ListStateMachinesInput,
+    () => ListStateMachinesOutput,
+];
+var ListStateMachineVersions = [
+    9,
+    n0,
+    _LSMV,
+    0,
+    () => ListStateMachineVersionsInput,
+    () => ListStateMachineVersionsOutput,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    0,
+    () => ListTagsForResourceInput,
+    () => ListTagsForResourceOutput,
+];
+var PublishStateMachineVersion = [
+    9,
+    n0,
+    _PSMV,
+    2,
+    () => PublishStateMachineVersionInput,
+    () => PublishStateMachineVersionOutput,
+];
+var RedriveExecution = [
+    9,
+    n0,
+    _RE,
+    2,
+    () => RedriveExecutionInput,
+    () => RedriveExecutionOutput,
+];
+var SendTaskFailure = [
+    9,
+    n0,
+    _STF,
+    0,
+    () => SendTaskFailureInput,
+    () => SendTaskFailureOutput,
+];
+var SendTaskHeartbeat = [
+    9,
+    n0,
+    _STH,
+    0,
+    () => SendTaskHeartbeatInput,
+    () => SendTaskHeartbeatOutput,
+];
+var SendTaskSuccess = [
+    9,
+    n0,
+    _STS,
+    0,
+    () => SendTaskSuccessInput,
+    () => SendTaskSuccessOutput,
+];
+var StartExecution = [
+    9,
+    n0,
+    _SEt,
+    2,
+    () => StartExecutionInput,
+    () => StartExecutionOutput,
+];
+var StartSyncExecution = [
+    9,
+    n0,
+    _SSE,
+    {
+        [_end]: ["sync-"],
+    },
+    () => StartSyncExecutionInput,
+    () => StartSyncExecutionOutput,
+];
+var StopExecution = [
+    9,
+    n0,
+    _SEto,
+    0,
+    () => StopExecutionInput,
+    () => StopExecutionOutput,
+];
+var TagResource = [9, n0, _TR, 0, () => TagResourceInput, () => TagResourceOutput];
+var TestState = [
+    9,
+    n0,
+    _TS,
+    {
+        [_end]: ["sync-"],
+    },
+    () => TestStateInput,
+    () => TestStateOutput,
+];
+var UntagResource = [9, n0, _UR, 0, () => UntagResourceInput, () => UntagResourceOutput];
+var UpdateMapRun = [9, n0, _UMR, 0, () => UpdateMapRunInput, () => UpdateMapRunOutput];
+var UpdateStateMachine = [
+    9,
+    n0,
+    _USM,
+    2,
+    () => UpdateStateMachineInput,
+    () => UpdateStateMachineOutput,
+];
+var UpdateStateMachineAlias = [
+    9,
+    n0,
+    _USMA,
+    0,
+    () => UpdateStateMachineAliasInput,
+    () => UpdateStateMachineAliasOutput,
+];
+var ValidateStateMachineDefinition = [
+    9,
+    n0,
+    _VSMD,
+    0,
+    () => ValidateStateMachineDefinitionInput,
+    () => ValidateStateMachineDefinitionOutput,
+];
 
 class CreateActivityCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "CreateActivity", {})
     .n("SFNClient", "CreateActivityCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateActivityCommand)
-    .de(de_CreateActivityCommand)
+    .sc(CreateActivity)
     .build() {
 }
 
@@ -2555,16 +2547,11 @@ class CreateStateMachineAliasCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "CreateStateMachineAlias", {})
     .n("SFNClient", "CreateStateMachineAliasCommand")
-    .f(CreateStateMachineAliasInputFilterSensitiveLog, void 0)
-    .ser(se_CreateStateMachineAliasCommand)
-    .de(de_CreateStateMachineAliasCommand)
+    .sc(CreateStateMachineAlias)
     .build() {
 }
 
@@ -2572,16 +2559,11 @@ class CreateStateMachineCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "CreateStateMachine", {})
     .n("SFNClient", "CreateStateMachineCommand")
-    .f(CreateStateMachineInputFilterSensitiveLog, void 0)
-    .ser(se_CreateStateMachineCommand)
-    .de(de_CreateStateMachineCommand)
+    .sc(CreateStateMachine)
     .build() {
 }
 
@@ -2589,16 +2571,11 @@ class DeleteActivityCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DeleteActivity", {})
     .n("SFNClient", "DeleteActivityCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteActivityCommand)
-    .de(de_DeleteActivityCommand)
+    .sc(DeleteActivity)
     .build() {
 }
 
@@ -2606,16 +2583,11 @@ class DeleteStateMachineAliasCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DeleteStateMachineAlias", {})
     .n("SFNClient", "DeleteStateMachineAliasCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteStateMachineAliasCommand)
-    .de(de_DeleteStateMachineAliasCommand)
+    .sc(DeleteStateMachineAlias)
     .build() {
 }
 
@@ -2623,16 +2595,11 @@ class DeleteStateMachineCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DeleteStateMachine", {})
     .n("SFNClient", "DeleteStateMachineCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteStateMachineCommand)
-    .de(de_DeleteStateMachineCommand)
+    .sc(DeleteStateMachine)
     .build() {
 }
 
@@ -2640,16 +2607,11 @@ class DeleteStateMachineVersionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DeleteStateMachineVersion", {})
     .n("SFNClient", "DeleteStateMachineVersionCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteStateMachineVersionCommand)
-    .de(de_DeleteStateMachineVersionCommand)
+    .sc(DeleteStateMachineVersion)
     .build() {
 }
 
@@ -2657,16 +2619,11 @@ class DescribeActivityCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DescribeActivity", {})
     .n("SFNClient", "DescribeActivityCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeActivityCommand)
-    .de(de_DescribeActivityCommand)
+    .sc(DescribeActivity)
     .build() {
 }
 
@@ -2674,16 +2631,11 @@ class DescribeExecutionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DescribeExecution", {})
     .n("SFNClient", "DescribeExecutionCommand")
-    .f(void 0, DescribeExecutionOutputFilterSensitiveLog)
-    .ser(se_DescribeExecutionCommand)
-    .de(de_DescribeExecutionCommand)
+    .sc(DescribeExecution)
     .build() {
 }
 
@@ -2691,16 +2643,11 @@ class DescribeMapRunCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DescribeMapRun", {})
     .n("SFNClient", "DescribeMapRunCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeMapRunCommand)
-    .de(de_DescribeMapRunCommand)
+    .sc(DescribeMapRun)
     .build() {
 }
 
@@ -2708,16 +2655,11 @@ class DescribeStateMachineAliasCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DescribeStateMachineAlias", {})
     .n("SFNClient", "DescribeStateMachineAliasCommand")
-    .f(void 0, DescribeStateMachineAliasOutputFilterSensitiveLog)
-    .ser(se_DescribeStateMachineAliasCommand)
-    .de(de_DescribeStateMachineAliasCommand)
+    .sc(DescribeStateMachineAlias)
     .build() {
 }
 
@@ -2725,16 +2667,11 @@ class DescribeStateMachineCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DescribeStateMachine", {})
     .n("SFNClient", "DescribeStateMachineCommand")
-    .f(void 0, DescribeStateMachineOutputFilterSensitiveLog)
-    .ser(se_DescribeStateMachineCommand)
-    .de(de_DescribeStateMachineCommand)
+    .sc(DescribeStateMachine)
     .build() {
 }
 
@@ -2742,16 +2679,11 @@ class DescribeStateMachineForExecutionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "DescribeStateMachineForExecution", {})
     .n("SFNClient", "DescribeStateMachineForExecutionCommand")
-    .f(void 0, DescribeStateMachineForExecutionOutputFilterSensitiveLog)
-    .ser(se_DescribeStateMachineForExecutionCommand)
-    .de(de_DescribeStateMachineForExecutionCommand)
+    .sc(DescribeStateMachineForExecution)
     .build() {
 }
 
@@ -2759,16 +2691,11 @@ class GetActivityTaskCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "GetActivityTask", {})
     .n("SFNClient", "GetActivityTaskCommand")
-    .f(void 0, GetActivityTaskOutputFilterSensitiveLog)
-    .ser(se_GetActivityTaskCommand)
-    .de(de_GetActivityTaskCommand)
+    .sc(GetActivityTask)
     .build() {
 }
 
@@ -2776,16 +2703,11 @@ class GetExecutionHistoryCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "GetExecutionHistory", {})
     .n("SFNClient", "GetExecutionHistoryCommand")
-    .f(void 0, GetExecutionHistoryOutputFilterSensitiveLog)
-    .ser(se_GetExecutionHistoryCommand)
-    .de(de_GetExecutionHistoryCommand)
+    .sc(GetExecutionHistory)
     .build() {
 }
 
@@ -2793,16 +2715,11 @@ class ListActivitiesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "ListActivities", {})
     .n("SFNClient", "ListActivitiesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListActivitiesCommand)
-    .de(de_ListActivitiesCommand)
+    .sc(ListActivities)
     .build() {
 }
 
@@ -2810,16 +2727,11 @@ class ListExecutionsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "ListExecutions", {})
     .n("SFNClient", "ListExecutionsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListExecutionsCommand)
-    .de(de_ListExecutionsCommand)
+    .sc(ListExecutions)
     .build() {
 }
 
@@ -2827,16 +2739,11 @@ class ListMapRunsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "ListMapRuns", {})
     .n("SFNClient", "ListMapRunsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListMapRunsCommand)
-    .de(de_ListMapRunsCommand)
+    .sc(ListMapRuns)
     .build() {
 }
 
@@ -2844,16 +2751,11 @@ class ListStateMachineAliasesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "ListStateMachineAliases", {})
     .n("SFNClient", "ListStateMachineAliasesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListStateMachineAliasesCommand)
-    .de(de_ListStateMachineAliasesCommand)
+    .sc(ListStateMachineAliases)
     .build() {
 }
 
@@ -2861,16 +2763,11 @@ class ListStateMachinesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "ListStateMachines", {})
     .n("SFNClient", "ListStateMachinesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListStateMachinesCommand)
-    .de(de_ListStateMachinesCommand)
+    .sc(ListStateMachines)
     .build() {
 }
 
@@ -2878,16 +2775,11 @@ class ListStateMachineVersionsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "ListStateMachineVersions", {})
     .n("SFNClient", "ListStateMachineVersionsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListStateMachineVersionsCommand)
-    .de(de_ListStateMachineVersionsCommand)
+    .sc(ListStateMachineVersions)
     .build() {
 }
 
@@ -2895,16 +2787,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "ListTagsForResource", {})
     .n("SFNClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -2912,16 +2799,11 @@ class PublishStateMachineVersionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "PublishStateMachineVersion", {})
     .n("SFNClient", "PublishStateMachineVersionCommand")
-    .f(PublishStateMachineVersionInputFilterSensitiveLog, void 0)
-    .ser(se_PublishStateMachineVersionCommand)
-    .de(de_PublishStateMachineVersionCommand)
+    .sc(PublishStateMachineVersion)
     .build() {
 }
 
@@ -2929,16 +2811,11 @@ class RedriveExecutionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "RedriveExecution", {})
     .n("SFNClient", "RedriveExecutionCommand")
-    .f(void 0, void 0)
-    .ser(se_RedriveExecutionCommand)
-    .de(de_RedriveExecutionCommand)
+    .sc(RedriveExecution)
     .build() {
 }
 
@@ -2946,16 +2823,11 @@ class SendTaskFailureCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "SendTaskFailure", {})
     .n("SFNClient", "SendTaskFailureCommand")
-    .f(SendTaskFailureInputFilterSensitiveLog, void 0)
-    .ser(se_SendTaskFailureCommand)
-    .de(de_SendTaskFailureCommand)
+    .sc(SendTaskFailure)
     .build() {
 }
 
@@ -2963,16 +2835,11 @@ class SendTaskHeartbeatCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "SendTaskHeartbeat", {})
     .n("SFNClient", "SendTaskHeartbeatCommand")
-    .f(void 0, void 0)
-    .ser(se_SendTaskHeartbeatCommand)
-    .de(de_SendTaskHeartbeatCommand)
+    .sc(SendTaskHeartbeat)
     .build() {
 }
 
@@ -2980,16 +2847,11 @@ class SendTaskSuccessCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "SendTaskSuccess", {})
     .n("SFNClient", "SendTaskSuccessCommand")
-    .f(SendTaskSuccessInputFilterSensitiveLog, void 0)
-    .ser(se_SendTaskSuccessCommand)
-    .de(de_SendTaskSuccessCommand)
+    .sc(SendTaskSuccess)
     .build() {
 }
 
@@ -2997,16 +2859,11 @@ class StartExecutionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "StartExecution", {})
     .n("SFNClient", "StartExecutionCommand")
-    .f(StartExecutionInputFilterSensitiveLog, void 0)
-    .ser(se_StartExecutionCommand)
-    .de(de_StartExecutionCommand)
+    .sc(StartExecution)
     .build() {
 }
 
@@ -3014,16 +2871,11 @@ class StartSyncExecutionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "StartSyncExecution", {})
     .n("SFNClient", "StartSyncExecutionCommand")
-    .f(StartSyncExecutionInputFilterSensitiveLog, StartSyncExecutionOutputFilterSensitiveLog)
-    .ser(se_StartSyncExecutionCommand)
-    .de(de_StartSyncExecutionCommand)
+    .sc(StartSyncExecution)
     .build() {
 }
 
@@ -3031,16 +2883,11 @@ class StopExecutionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "StopExecution", {})
     .n("SFNClient", "StopExecutionCommand")
-    .f(StopExecutionInputFilterSensitiveLog, void 0)
-    .ser(se_StopExecutionCommand)
-    .de(de_StopExecutionCommand)
+    .sc(StopExecution)
     .build() {
 }
 
@@ -3048,16 +2895,11 @@ class TagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "TagResource", {})
     .n("SFNClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -3065,16 +2907,11 @@ class TestStateCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "TestState", {})
     .n("SFNClient", "TestStateCommand")
-    .f(TestStateInputFilterSensitiveLog, TestStateOutputFilterSensitiveLog)
-    .ser(se_TestStateCommand)
-    .de(de_TestStateCommand)
+    .sc(TestState)
     .build() {
 }
 
@@ -3082,16 +2919,11 @@ class UntagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "UntagResource", {})
     .n("SFNClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -3099,16 +2931,11 @@ class UpdateMapRunCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "UpdateMapRun", {})
     .n("SFNClient", "UpdateMapRunCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateMapRunCommand)
-    .de(de_UpdateMapRunCommand)
+    .sc(UpdateMapRun)
     .build() {
 }
 
@@ -3116,16 +2943,11 @@ class UpdateStateMachineAliasCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "UpdateStateMachineAlias", {})
     .n("SFNClient", "UpdateStateMachineAliasCommand")
-    .f(UpdateStateMachineAliasInputFilterSensitiveLog, void 0)
-    .ser(se_UpdateStateMachineAliasCommand)
-    .de(de_UpdateStateMachineAliasCommand)
+    .sc(UpdateStateMachineAlias)
     .build() {
 }
 
@@ -3133,16 +2955,11 @@ class UpdateStateMachineCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "UpdateStateMachine", {})
     .n("SFNClient", "UpdateStateMachineCommand")
-    .f(UpdateStateMachineInputFilterSensitiveLog, void 0)
-    .ser(se_UpdateStateMachineCommand)
-    .de(de_UpdateStateMachineCommand)
+    .sc(UpdateStateMachine)
     .build() {
 }
 
@@ -3150,16 +2967,11 @@ class ValidateStateMachineDefinitionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSStepFunctions", "ValidateStateMachineDefinition", {})
     .n("SFNClient", "ValidateStateMachineDefinitionCommand")
-    .f(ValidateStateMachineDefinitionInputFilterSensitiveLog, ValidateStateMachineDefinitionOutputFilterSensitiveLog)
-    .ser(se_ValidateStateMachineDefinitionCommand)
-    .de(de_ValidateStateMachineDefinitionCommand)
+    .sc(ValidateStateMachineDefinition)
     .build() {
 }
 
@@ -3224,77 +3036,50 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.ActivityAlreadyExists = ActivityAlreadyExists;
-exports.ActivityDoesNotExist = ActivityDoesNotExist;
-exports.ActivityFailedEventDetailsFilterSensitiveLog = ActivityFailedEventDetailsFilterSensitiveLog;
-exports.ActivityLimitExceeded = ActivityLimitExceeded;
-exports.ActivityScheduleFailedEventDetailsFilterSensitiveLog = ActivityScheduleFailedEventDetailsFilterSensitiveLog;
-exports.ActivityScheduledEventDetailsFilterSensitiveLog = ActivityScheduledEventDetailsFilterSensitiveLog;
-exports.ActivitySucceededEventDetailsFilterSensitiveLog = ActivitySucceededEventDetailsFilterSensitiveLog;
-exports.ActivityTimedOutEventDetailsFilterSensitiveLog = ActivityTimedOutEventDetailsFilterSensitiveLog;
-exports.ActivityWorkerLimitExceeded = ActivityWorkerLimitExceeded;
-exports.ConflictException = ConflictException;
+exports.ActivityAlreadyExists = ActivityAlreadyExists$1;
+exports.ActivityDoesNotExist = ActivityDoesNotExist$1;
+exports.ActivityLimitExceeded = ActivityLimitExceeded$1;
+exports.ActivityWorkerLimitExceeded = ActivityWorkerLimitExceeded$1;
+exports.ConflictException = ConflictException$1;
 exports.CreateActivityCommand = CreateActivityCommand;
 exports.CreateStateMachineAliasCommand = CreateStateMachineAliasCommand;
-exports.CreateStateMachineAliasInputFilterSensitiveLog = CreateStateMachineAliasInputFilterSensitiveLog;
 exports.CreateStateMachineCommand = CreateStateMachineCommand;
-exports.CreateStateMachineInputFilterSensitiveLog = CreateStateMachineInputFilterSensitiveLog;
 exports.DeleteActivityCommand = DeleteActivityCommand;
 exports.DeleteStateMachineAliasCommand = DeleteStateMachineAliasCommand;
 exports.DeleteStateMachineCommand = DeleteStateMachineCommand;
 exports.DeleteStateMachineVersionCommand = DeleteStateMachineVersionCommand;
 exports.DescribeActivityCommand = DescribeActivityCommand;
 exports.DescribeExecutionCommand = DescribeExecutionCommand;
-exports.DescribeExecutionOutputFilterSensitiveLog = DescribeExecutionOutputFilterSensitiveLog;
 exports.DescribeMapRunCommand = DescribeMapRunCommand;
 exports.DescribeStateMachineAliasCommand = DescribeStateMachineAliasCommand;
-exports.DescribeStateMachineAliasOutputFilterSensitiveLog = DescribeStateMachineAliasOutputFilterSensitiveLog;
 exports.DescribeStateMachineCommand = DescribeStateMachineCommand;
 exports.DescribeStateMachineForExecutionCommand = DescribeStateMachineForExecutionCommand;
-exports.DescribeStateMachineForExecutionOutputFilterSensitiveLog = DescribeStateMachineForExecutionOutputFilterSensitiveLog;
-exports.DescribeStateMachineOutputFilterSensitiveLog = DescribeStateMachineOutputFilterSensitiveLog;
 exports.EncryptionType = EncryptionType;
-exports.EvaluationFailedEventDetailsFilterSensitiveLog = EvaluationFailedEventDetailsFilterSensitiveLog;
-exports.ExecutionAbortedEventDetailsFilterSensitiveLog = ExecutionAbortedEventDetailsFilterSensitiveLog;
-exports.ExecutionAlreadyExists = ExecutionAlreadyExists;
-exports.ExecutionDoesNotExist = ExecutionDoesNotExist;
-exports.ExecutionFailedEventDetailsFilterSensitiveLog = ExecutionFailedEventDetailsFilterSensitiveLog;
-exports.ExecutionLimitExceeded = ExecutionLimitExceeded;
-exports.ExecutionNotRedrivable = ExecutionNotRedrivable;
+exports.ExecutionAlreadyExists = ExecutionAlreadyExists$1;
+exports.ExecutionDoesNotExist = ExecutionDoesNotExist$1;
+exports.ExecutionLimitExceeded = ExecutionLimitExceeded$1;
+exports.ExecutionNotRedrivable = ExecutionNotRedrivable$1;
 exports.ExecutionRedriveFilter = ExecutionRedriveFilter;
 exports.ExecutionRedriveStatus = ExecutionRedriveStatus;
-exports.ExecutionStartedEventDetailsFilterSensitiveLog = ExecutionStartedEventDetailsFilterSensitiveLog;
 exports.ExecutionStatus = ExecutionStatus;
-exports.ExecutionSucceededEventDetailsFilterSensitiveLog = ExecutionSucceededEventDetailsFilterSensitiveLog;
-exports.ExecutionTimedOutEventDetailsFilterSensitiveLog = ExecutionTimedOutEventDetailsFilterSensitiveLog;
 exports.GetActivityTaskCommand = GetActivityTaskCommand;
-exports.GetActivityTaskOutputFilterSensitiveLog = GetActivityTaskOutputFilterSensitiveLog;
 exports.GetExecutionHistoryCommand = GetExecutionHistoryCommand;
-exports.GetExecutionHistoryOutputFilterSensitiveLog = GetExecutionHistoryOutputFilterSensitiveLog;
-exports.HistoryEventFilterSensitiveLog = HistoryEventFilterSensitiveLog;
 exports.HistoryEventType = HistoryEventType;
 exports.IncludedData = IncludedData;
-exports.InspectionDataFilterSensitiveLog = InspectionDataFilterSensitiveLog;
 exports.InspectionLevel = InspectionLevel;
-exports.InvalidArn = InvalidArn;
-exports.InvalidDefinition = InvalidDefinition;
-exports.InvalidEncryptionConfiguration = InvalidEncryptionConfiguration;
-exports.InvalidExecutionInput = InvalidExecutionInput;
-exports.InvalidLoggingConfiguration = InvalidLoggingConfiguration;
-exports.InvalidName = InvalidName;
-exports.InvalidOutput = InvalidOutput;
-exports.InvalidToken = InvalidToken;
-exports.InvalidTracingConfiguration = InvalidTracingConfiguration;
-exports.KmsAccessDeniedException = KmsAccessDeniedException;
-exports.KmsInvalidStateException = KmsInvalidStateException;
+exports.InvalidArn = InvalidArn$1;
+exports.InvalidDefinition = InvalidDefinition$1;
+exports.InvalidEncryptionConfiguration = InvalidEncryptionConfiguration$1;
+exports.InvalidExecutionInput = InvalidExecutionInput$1;
+exports.InvalidLoggingConfiguration = InvalidLoggingConfiguration$1;
+exports.InvalidName = InvalidName$1;
+exports.InvalidOutput = InvalidOutput$1;
+exports.InvalidToken = InvalidToken$1;
+exports.InvalidTracingConfiguration = InvalidTracingConfiguration$1;
+exports.KmsAccessDeniedException = KmsAccessDeniedException$1;
+exports.KmsInvalidStateException = KmsInvalidStateException$1;
 exports.KmsKeyState = KmsKeyState;
-exports.KmsThrottlingException = KmsThrottlingException;
-exports.LambdaFunctionFailedEventDetailsFilterSensitiveLog = LambdaFunctionFailedEventDetailsFilterSensitiveLog;
-exports.LambdaFunctionScheduleFailedEventDetailsFilterSensitiveLog = LambdaFunctionScheduleFailedEventDetailsFilterSensitiveLog;
-exports.LambdaFunctionScheduledEventDetailsFilterSensitiveLog = LambdaFunctionScheduledEventDetailsFilterSensitiveLog;
-exports.LambdaFunctionStartFailedEventDetailsFilterSensitiveLog = LambdaFunctionStartFailedEventDetailsFilterSensitiveLog;
-exports.LambdaFunctionSucceededEventDetailsFilterSensitiveLog = LambdaFunctionSucceededEventDetailsFilterSensitiveLog;
-exports.LambdaFunctionTimedOutEventDetailsFilterSensitiveLog = LambdaFunctionTimedOutEventDetailsFilterSensitiveLog;
+exports.KmsThrottlingException = KmsThrottlingException$1;
 exports.ListActivitiesCommand = ListActivitiesCommand;
 exports.ListExecutionsCommand = ListExecutionsCommand;
 exports.ListMapRunsCommand = ListMapRunsCommand;
@@ -3303,67 +3088,43 @@ exports.ListStateMachineVersionsCommand = ListStateMachineVersionsCommand;
 exports.ListStateMachinesCommand = ListStateMachinesCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.LogLevel = LogLevel;
-exports.MapRunFailedEventDetailsFilterSensitiveLog = MapRunFailedEventDetailsFilterSensitiveLog;
 exports.MapRunStatus = MapRunStatus;
-exports.MissingRequiredParameter = MissingRequiredParameter;
+exports.MissingRequiredParameter = MissingRequiredParameter$1;
 exports.PublishStateMachineVersionCommand = PublishStateMachineVersionCommand;
-exports.PublishStateMachineVersionInputFilterSensitiveLog = PublishStateMachineVersionInputFilterSensitiveLog;
 exports.RedriveExecutionCommand = RedriveExecutionCommand;
-exports.ResourceNotFound = ResourceNotFound;
+exports.ResourceNotFound = ResourceNotFound$1;
 exports.SFN = SFN;
 exports.SFNClient = SFNClient;
-exports.SFNServiceException = SFNServiceException;
+exports.SFNServiceException = SFNServiceException$1;
 exports.SendTaskFailureCommand = SendTaskFailureCommand;
-exports.SendTaskFailureInputFilterSensitiveLog = SendTaskFailureInputFilterSensitiveLog;
 exports.SendTaskHeartbeatCommand = SendTaskHeartbeatCommand;
 exports.SendTaskSuccessCommand = SendTaskSuccessCommand;
-exports.SendTaskSuccessInputFilterSensitiveLog = SendTaskSuccessInputFilterSensitiveLog;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.StartExecutionCommand = StartExecutionCommand;
-exports.StartExecutionInputFilterSensitiveLog = StartExecutionInputFilterSensitiveLog;
 exports.StartSyncExecutionCommand = StartSyncExecutionCommand;
-exports.StartSyncExecutionInputFilterSensitiveLog = StartSyncExecutionInputFilterSensitiveLog;
-exports.StartSyncExecutionOutputFilterSensitiveLog = StartSyncExecutionOutputFilterSensitiveLog;
-exports.StateEnteredEventDetailsFilterSensitiveLog = StateEnteredEventDetailsFilterSensitiveLog;
-exports.StateExitedEventDetailsFilterSensitiveLog = StateExitedEventDetailsFilterSensitiveLog;
-exports.StateMachineAlreadyExists = StateMachineAlreadyExists;
-exports.StateMachineDeleting = StateMachineDeleting;
-exports.StateMachineDoesNotExist = StateMachineDoesNotExist;
-exports.StateMachineLimitExceeded = StateMachineLimitExceeded;
+exports.StateMachineAlreadyExists = StateMachineAlreadyExists$1;
+exports.StateMachineDeleting = StateMachineDeleting$1;
+exports.StateMachineDoesNotExist = StateMachineDoesNotExist$1;
+exports.StateMachineLimitExceeded = StateMachineLimitExceeded$1;
 exports.StateMachineStatus = StateMachineStatus;
 exports.StateMachineType = StateMachineType;
-exports.StateMachineTypeNotSupported = StateMachineTypeNotSupported;
+exports.StateMachineTypeNotSupported = StateMachineTypeNotSupported$1;
 exports.StopExecutionCommand = StopExecutionCommand;
-exports.StopExecutionInputFilterSensitiveLog = StopExecutionInputFilterSensitiveLog;
 exports.SyncExecutionStatus = SyncExecutionStatus;
 exports.TagResourceCommand = TagResourceCommand;
-exports.TaskDoesNotExist = TaskDoesNotExist;
-exports.TaskFailedEventDetailsFilterSensitiveLog = TaskFailedEventDetailsFilterSensitiveLog;
-exports.TaskScheduledEventDetailsFilterSensitiveLog = TaskScheduledEventDetailsFilterSensitiveLog;
-exports.TaskStartFailedEventDetailsFilterSensitiveLog = TaskStartFailedEventDetailsFilterSensitiveLog;
-exports.TaskSubmitFailedEventDetailsFilterSensitiveLog = TaskSubmitFailedEventDetailsFilterSensitiveLog;
-exports.TaskSubmittedEventDetailsFilterSensitiveLog = TaskSubmittedEventDetailsFilterSensitiveLog;
-exports.TaskSucceededEventDetailsFilterSensitiveLog = TaskSucceededEventDetailsFilterSensitiveLog;
-exports.TaskTimedOut = TaskTimedOut;
-exports.TaskTimedOutEventDetailsFilterSensitiveLog = TaskTimedOutEventDetailsFilterSensitiveLog;
+exports.TaskDoesNotExist = TaskDoesNotExist$1;
+exports.TaskTimedOut = TaskTimedOut$1;
 exports.TestExecutionStatus = TestExecutionStatus;
 exports.TestStateCommand = TestStateCommand;
-exports.TestStateInputFilterSensitiveLog = TestStateInputFilterSensitiveLog;
-exports.TestStateOutputFilterSensitiveLog = TestStateOutputFilterSensitiveLog;
-exports.TooManyTags = TooManyTags;
+exports.TooManyTags = TooManyTags$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateMapRunCommand = UpdateMapRunCommand;
 exports.UpdateStateMachineAliasCommand = UpdateStateMachineAliasCommand;
-exports.UpdateStateMachineAliasInputFilterSensitiveLog = UpdateStateMachineAliasInputFilterSensitiveLog;
 exports.UpdateStateMachineCommand = UpdateStateMachineCommand;
-exports.UpdateStateMachineInputFilterSensitiveLog = UpdateStateMachineInputFilterSensitiveLog;
 exports.ValidateStateMachineDefinitionCommand = ValidateStateMachineDefinitionCommand;
-exports.ValidateStateMachineDefinitionDiagnosticFilterSensitiveLog = ValidateStateMachineDefinitionDiagnosticFilterSensitiveLog;
-exports.ValidateStateMachineDefinitionInputFilterSensitiveLog = ValidateStateMachineDefinitionInputFilterSensitiveLog;
-exports.ValidateStateMachineDefinitionOutputFilterSensitiveLog = ValidateStateMachineDefinitionOutputFilterSensitiveLog;
 exports.ValidateStateMachineDefinitionResultCode = ValidateStateMachineDefinitionResultCode;
 exports.ValidateStateMachineDefinitionSeverity = ValidateStateMachineDefinitionSeverity;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.ValidationExceptionReason = ValidationExceptionReason;
 exports.paginateGetExecutionHistory = paginateGetExecutionHistory;
 exports.paginateListActivities = paginateListActivities;