@aws-sdk/client-sfn 3.1075.0 → 3.1076.0

package/dist-cjs/index.js

@@ -1,21 +1,57 @@
-var __exportStar = (m, e) => { Object.assign(e, m); };
-const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin, getLongPollPlugin } = require("@aws-sdk/core/client");
+const { awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin, getLongPollPlugin } = require("@aws-sdk/core/client");
 const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
-const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
+const { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
 exports.$Command = Command;
 exports.__Client = Client;
-const { resolveRegionConfig } = require("@smithy/core/config");
-const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
-const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
-const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
-const { getSchemaSerdePlugin } = require("@smithy/core/schema");
-const { resolveHttpAuthSchemeConfig, defaultSFNHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
-const { getRuntimeConfig } = require("./runtimeConfig");
-const { CreateActivity$, CreateStateMachineAlias$, CreateStateMachine$, DeleteActivity$, DeleteStateMachineAlias$, DeleteStateMachine$, DeleteStateMachineVersion$, DescribeActivity$, DescribeExecution$, DescribeMapRun$, DescribeStateMachineAlias$, DescribeStateMachine$, DescribeStateMachineForExecution$, GetActivityTask$, GetExecutionHistory$, ListActivities$, ListExecutions$, ListMapRuns$, ListStateMachineAliases$, ListStateMachines$, ListStateMachineVersions$, ListTagsForResource$, PublishStateMachineVersion$, RedriveExecution$, SendTaskFailure$, SendTaskHeartbeat$, SendTaskSuccess$, StartExecution$, StartSyncExecution$, StopExecution$, TagResource$, TestState$, UntagResource$, UpdateMapRun$, UpdateStateMachineAlias$, UpdateStateMachine$, ValidateStateMachineDefinition$ } = require("./schemas/schemas_0");
-__exportStar(require("./schemas/schemas_0"), exports);
-__exportStar(require("./models/errors"), exports);
-const { SFNServiceException } = require("./models/SFNServiceException");
-exports.SFNServiceException = SFNServiceException;
+const { resolveDefaultsModeConfig, loadConfig, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require("@smithy/core/config");
+const { BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { parseUrl, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { TypeRegistry, getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveAwsSdkSigV4Config, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require("@aws-sdk/core/httpAuthSchemes");
+const { defaultProvider } = require("@aws-sdk/credential-provider-node");
+const { toUtf8, fromUtf8, toBase64, fromBase64, Hash, calculateBodyLength } = require("@smithy/core/serde");
+const { streamCollector, NodeHttpHandler } = require("@smithy/node-http-handler");
+const { AwsJson1_0Protocol } = require("@aws-sdk/core/protocols");
+
+const defaultSFNHttpAuthSchemeParametersProvider = async (config, context, input) => {
+    return {
+        operation: getSmithyContext(context).operation,
+        region: await normalizeProvider(config.region)() || (() => {
+            throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
+        })(),
+    };
+};
+function createAwsAuthSigv4HttpAuthOption(authParameters) {
+    return {
+        schemeId: "aws.auth#sigv4",
+        signingProperties: {
+            name: "states",
+            region: authParameters.region,
+        },
+        propertiesExtractor: (config, context) => ({
+            signingProperties: {
+                config,
+                context,
+            },
+        }),
+    };
+}
+const defaultSFNHttpAuthSchemeProvider = (authParameters) => {
+    const options = [];
+    switch (authParameters.operation) {
+        default: {
+            options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
+        }
+    }
+    return options;
+};
+const resolveHttpAuthSchemeConfig = (config) => {
+    const config_0 = resolveAwsSdkSigV4Config(config);
+    return Object.assign(config_0, {
+        authSchemePreference: normalizeProvider(config.authSchemePreference ?? []),
+    });
+};
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -31,6 +67,2056 @@ const commonParams = {
     UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
 };
 
+var version = "3.1075.0";
+var packageInfo = {
+	version: version};
+
+const m = "ref";
+const a = -1, b = true, c = "isSet", d = "PartitionResult", e = "booleanEquals", f = "stringEquals", g = "getAttr", h = { [m]: "Endpoint" }, i = { [m]: "Region" }, j = { [m]: d }, k = {}, l = [i];
+const _data = {
+    conditions: [
+        [c, [h]],
+        [c, l],
+        ["aws.partition", l, d],
+        [e, [{ [m]: "UseFIPS" }, b]],
+        [e, [{ [m]: "UseDualStack" }, b]],
+        [f, [i, "us-gov-west-1"]],
+        [e, [{ fn: g, argv: [j, "supportsFIPS"] }, b]],
+        [f, [{ fn: g, argv: [j, "name"] }, "aws-us-gov"]],
+        [e, [{ fn: g, argv: [j, "supportsDualStack"] }, b]]
+    ],
+    results: [
+        [a],
+        [a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
+        [a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
+        [h, k],
+        ["https://states.{Region}.{PartitionResult#dnsSuffix}", k],
+        ["https://states-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", k],
+        [a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
+        ["https://states-fips.{Region}.{PartitionResult#dnsSuffix}", k],
+        [a, "FIPS is enabled but this partition does not support FIPS"],
+        ["https://states.{Region}.{PartitionResult#dualStackDnsSuffix}", k],
+        [a, "DualStack is enabled but this partition does not support DualStack"],
+        [a, "Invalid Configuration: Missing Region"]
+    ]
+};
+const root = 2;
+const r = 100_000_000;
+const nodes = new Int32Array([
+    -1, 1, -1,
+    0, 14, 3,
+    1, 4, r + 11,
+    2, 5, r + 11,
+    3, 9, 6,
+    4, 7, r + 4,
+    7, r + 5, 8,
+    8, r + 9, r + 10,
+    4, 12, 10,
+    5, r + 4, 11,
+    6, r + 7, r + 8,
+    6, 13, r + 6,
+    8, r + 5, r + 6,
+    3, r + 1, 15,
+    4, r + 2, r + 3,
+]);
+const bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
+
+const cache = new EndpointCache({
+    size: 50,
+    params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"],
+});
+const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return cache.get(endpointParams, () => decideEndpoint(bdd, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    }));
+};
+customEndpointFunctions.aws = awsEndpointFunctions;
+
+class SFNServiceException extends ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, SFNServiceException.prototype);
+    }
+}
+
+class ActivityAlreadyExists extends SFNServiceException {
+    name = "ActivityAlreadyExists";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ActivityAlreadyExists",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ActivityAlreadyExists.prototype);
+    }
+}
+class ActivityDoesNotExist extends SFNServiceException {
+    name = "ActivityDoesNotExist";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ActivityDoesNotExist",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ActivityDoesNotExist.prototype);
+    }
+}
+class ActivityLimitExceeded extends SFNServiceException {
+    name = "ActivityLimitExceeded";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ActivityLimitExceeded",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ActivityLimitExceeded.prototype);
+    }
+}
+class ActivityWorkerLimitExceeded extends SFNServiceException {
+    name = "ActivityWorkerLimitExceeded";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ActivityWorkerLimitExceeded",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ActivityWorkerLimitExceeded.prototype);
+    }
+}
+class InvalidEncryptionConfiguration extends SFNServiceException {
+    name = "InvalidEncryptionConfiguration";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidEncryptionConfiguration",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidEncryptionConfiguration.prototype);
+    }
+}
+class InvalidName extends SFNServiceException {
+    name = "InvalidName";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidName",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidName.prototype);
+    }
+}
+class KmsAccessDeniedException extends SFNServiceException {
+    name = "KmsAccessDeniedException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "KmsAccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, KmsAccessDeniedException.prototype);
+    }
+}
+class KmsThrottlingException extends SFNServiceException {
+    name = "KmsThrottlingException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "KmsThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, KmsThrottlingException.prototype);
+    }
+}
+class TooManyTags extends SFNServiceException {
+    name = "TooManyTags";
+    $fault = "client";
+    resourceName;
+    constructor(opts) {
+        super({
+            name: "TooManyTags",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TooManyTags.prototype);
+        this.resourceName = opts.resourceName;
+    }
+}
+class ConflictException extends SFNServiceException {
+    name = "ConflictException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ConflictException.prototype);
+    }
+}
+class InvalidArn extends SFNServiceException {
+    name = "InvalidArn";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidArn",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidArn.prototype);
+    }
+}
+class InvalidDefinition extends SFNServiceException {
+    name = "InvalidDefinition";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidDefinition",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidDefinition.prototype);
+    }
+}
+class InvalidLoggingConfiguration extends SFNServiceException {
+    name = "InvalidLoggingConfiguration";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidLoggingConfiguration",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidLoggingConfiguration.prototype);
+    }
+}
+class InvalidTracingConfiguration extends SFNServiceException {
+    name = "InvalidTracingConfiguration";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidTracingConfiguration",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidTracingConfiguration.prototype);
+    }
+}
+class StateMachineAlreadyExists extends SFNServiceException {
+    name = "StateMachineAlreadyExists";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "StateMachineAlreadyExists",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, StateMachineAlreadyExists.prototype);
+    }
+}
+class StateMachineDeleting extends SFNServiceException {
+    name = "StateMachineDeleting";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "StateMachineDeleting",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, StateMachineDeleting.prototype);
+    }
+}
+class StateMachineLimitExceeded extends SFNServiceException {
+    name = "StateMachineLimitExceeded";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "StateMachineLimitExceeded",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, StateMachineLimitExceeded.prototype);
+    }
+}
+class StateMachineTypeNotSupported extends SFNServiceException {
+    name = "StateMachineTypeNotSupported";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "StateMachineTypeNotSupported",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, StateMachineTypeNotSupported.prototype);
+    }
+}
+class ValidationException extends SFNServiceException {
+    name = "ValidationException";
+    $fault = "client";
+    reason;
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ValidationException.prototype);
+        this.reason = opts.reason;
+    }
+}
+class ResourceNotFound extends SFNServiceException {
+    name = "ResourceNotFound";
+    $fault = "client";
+    resourceName;
+    constructor(opts) {
+        super({
+            name: "ResourceNotFound",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceNotFound.prototype);
+        this.resourceName = opts.resourceName;
+    }
+}
+class ServiceQuotaExceededException extends SFNServiceException {
+    name = "ServiceQuotaExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+    }
+}
+class ExecutionDoesNotExist extends SFNServiceException {
+    name = "ExecutionDoesNotExist";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ExecutionDoesNotExist",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ExecutionDoesNotExist.prototype);
+    }
+}
+class KmsInvalidStateException extends SFNServiceException {
+    name = "KmsInvalidStateException";
+    $fault = "client";
+    kmsKeyState;
+    constructor(opts) {
+        super({
+            name: "KmsInvalidStateException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, KmsInvalidStateException.prototype);
+        this.kmsKeyState = opts.kmsKeyState;
+    }
+}
+class StateMachineDoesNotExist extends SFNServiceException {
+    name = "StateMachineDoesNotExist";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "StateMachineDoesNotExist",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, StateMachineDoesNotExist.prototype);
+    }
+}
+class InvalidToken extends SFNServiceException {
+    name = "InvalidToken";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidToken",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidToken.prototype);
+    }
+}
+class ExecutionLimitExceeded extends SFNServiceException {
+    name = "ExecutionLimitExceeded";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ExecutionLimitExceeded",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ExecutionLimitExceeded.prototype);
+    }
+}
+class ExecutionNotRedrivable extends SFNServiceException {
+    name = "ExecutionNotRedrivable";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ExecutionNotRedrivable",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ExecutionNotRedrivable.prototype);
+    }
+}
+class TaskDoesNotExist extends SFNServiceException {
+    name = "TaskDoesNotExist";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TaskDoesNotExist",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TaskDoesNotExist.prototype);
+    }
+}
+class TaskTimedOut extends SFNServiceException {
+    name = "TaskTimedOut";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TaskTimedOut",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TaskTimedOut.prototype);
+    }
+}
+class InvalidOutput extends SFNServiceException {
+    name = "InvalidOutput";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidOutput",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidOutput.prototype);
+    }
+}
+class ExecutionAlreadyExists extends SFNServiceException {
+    name = "ExecutionAlreadyExists";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ExecutionAlreadyExists",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ExecutionAlreadyExists.prototype);
+    }
+}
+class InvalidExecutionInput extends SFNServiceException {
+    name = "InvalidExecutionInput";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidExecutionInput",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidExecutionInput.prototype);
+    }
+}
+class MissingRequiredParameter extends SFNServiceException {
+    name = "MissingRequiredParameter";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MissingRequiredParameter",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MissingRequiredParameter.prototype);
+    }
+}
+
+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 _EHI = "ExceptionHandlerIndex";
+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 = "InvalidDefinition";
+const _IDR = "InspectionDataRequest";
+const _IDRn = "InspectionDataResponse";
+const _IDn = "InspectionData";
+const _IEC = "InvalidEncryptionConfiguration";
+const _IED = "InspectionErrorDetails";
+const _IEI = "InvalidExecutionInput";
+const _ILC = "InvalidLoggingConfiguration";
+const _IMC = "InspectionMaxConcurrency";
+const _IN = "InvalidName";
+const _IO = "InvalidOutput";
+const _IT = "InvalidToken";
+const _ITC = "InvalidTracingConfiguration";
+const _ITFC = "InspectionToleratedFailureCount";
+const _ITFP = "InspectionToleratedFailurePercentage";
+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 _MEO = "MockErrorOutput";
+const _MI = "MockInput";
+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 _RBIS = "RetryBackoffIntervalSeconds";
+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 _TSC = "TestStateConfiguration";
+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 _TSSN = "TestStateStateName";
+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 _aIB = "afterItemBatcher";
+const _aIP = "afterInputPath";
+const _aIPf = "afterItemsPath";
+const _aIPft = "afterItemsPointer";
+const _aIS = "afterItemSelector";
+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 _cI = "catchIndex";
+const _cT = "clientToken";
+const _cWLLG = "cloudWatchLogsLogGroup";
+const _ca = "cause";
+const _co = "context";
+const _cod = "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 _eCBS = "errorCausedByState";
+const _eCx = "executionCounts";
+const _eD = "errorDetails";
+const _eFED = "executionFailedEventDetails";
+const _eFEDv = "evaluationFailedEventDetails";
+const _eO = "errorOutput";
+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 _fVM = "fieldValidationMode";
+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 _mIFC = "mapIterationFailureCount";
+const _mIFED = "mapIterationFailedEventDetails";
+const _mIRD = "mapItemReaderData";
+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 _mo = "mock";
+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 = "reason";
+const _rA = "roleArn";
+const _rAe = "resourceArn";
+const _rBIS = "retryBackoffIntervalSeconds";
+const _rC = "routingConfiguration";
+const _rCe = "redriveCount";
+const _rD = "redriveDate";
+const _rF = "redriveFilter";
+const _rI = "revisionId";
+const _rIe = "retryIndex";
+const _rN = "resourceName";
+const _rO = "reverseOrder";
+const _rRC = "retrierRetryCount";
+const _rS = "redriveStatus";
+const _rSR = "redriveStatusReason";
+const _rSe = "revealSecrets";
+const _rT = "resourceType";
+const _rW = "resultsWritten";
+const _re = "resource";
+const _reg = "region";
+const _req = "request";
+const _res = "result";
+const _resp = "response";
+const _ru = "running";
+const _s = "smithy.ts.sdk.synthetic.com.amazonaws.sfn";
+const _sC = "statusCode";
+const _sCt = "stateConfiguration";
+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 _sN = "stateName";
+const _se = "severity";
+const _st = "status";
+const _sta = "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";
+const _s_registry = TypeRegistry.for(_s);
+var SFNServiceException$ = [-3, _s, "SFNServiceException", 0, [], []];
+_s_registry.registerError(SFNServiceException$, SFNServiceException);
+const n0_registry = TypeRegistry.for(n0);
+var ActivityAlreadyExists$ = [-3, n0, _AAE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ActivityAlreadyExists$, ActivityAlreadyExists);
+var ActivityDoesNotExist$ = [-3, n0, _ADNE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ActivityDoesNotExist$, ActivityDoesNotExist);
+var ActivityLimitExceeded$ = [-3, n0, _ALE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ActivityLimitExceeded$, ActivityLimitExceeded);
+var ActivityWorkerLimitExceeded$ = [-3, n0, _AWLE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ActivityWorkerLimitExceeded$, ActivityWorkerLimitExceeded);
+var ConflictException$ = [-3, n0, _CE,
+    { [_e]: _c, [_hE]: 409 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ConflictException$, ConflictException);
+var ExecutionAlreadyExists$ = [-3, n0, _EAE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ExecutionAlreadyExists$, ExecutionAlreadyExists);
+var ExecutionDoesNotExist$ = [-3, n0, _EDNE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ExecutionDoesNotExist$, ExecutionDoesNotExist);
+var ExecutionLimitExceeded$ = [-3, n0, _ELE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ExecutionLimitExceeded$, ExecutionLimitExceeded);
+var ExecutionNotRedrivable$ = [-3, n0, _ENR,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ExecutionNotRedrivable$, ExecutionNotRedrivable);
+var InvalidArn$ = [-3, n0, _IA,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidArn$, InvalidArn);
+var InvalidDefinition$ = [-3, n0, _ID,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidDefinition$, InvalidDefinition);
+var InvalidEncryptionConfiguration$ = [-3, n0, _IEC,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidEncryptionConfiguration$, InvalidEncryptionConfiguration);
+var InvalidExecutionInput$ = [-3, n0, _IEI,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidExecutionInput$, InvalidExecutionInput);
+var InvalidLoggingConfiguration$ = [-3, n0, _ILC,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidLoggingConfiguration$, InvalidLoggingConfiguration);
+var InvalidName$ = [-3, n0, _IN,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidName$, InvalidName);
+var InvalidOutput$ = [-3, n0, _IO,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidOutput$, InvalidOutput);
+var InvalidToken$ = [-3, n0, _IT,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidToken$, InvalidToken);
+var InvalidTracingConfiguration$ = [-3, n0, _ITC,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidTracingConfiguration$, InvalidTracingConfiguration);
+var KmsAccessDeniedException$ = [-3, n0, _KADE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(KmsAccessDeniedException$, KmsAccessDeniedException);
+var KmsInvalidStateException$ = [-3, n0, _KISE,
+    { [_e]: _c },
+    [_kKS, _m],
+    [0, 0]
+];
+n0_registry.registerError(KmsInvalidStateException$, KmsInvalidStateException);
+var KmsThrottlingException$ = [-3, n0, _KTE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(KmsThrottlingException$, KmsThrottlingException);
+var MissingRequiredParameter$ = [-3, n0, _MRP,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(MissingRequiredParameter$, MissingRequiredParameter);
+var ResourceNotFound$ = [-3, n0, _RNF,
+    { [_e]: _c, [_hE]: 404 },
+    [_m, _rN],
+    [0, 0]
+];
+n0_registry.registerError(ResourceNotFound$, ResourceNotFound);
+var ServiceQuotaExceededException$ = [-3, n0, _SQEE,
+    { [_e]: _c, [_hE]: 402 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ServiceQuotaExceededException$, ServiceQuotaExceededException);
+var StateMachineAlreadyExists$ = [-3, n0, _SMAE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(StateMachineAlreadyExists$, StateMachineAlreadyExists);
+var StateMachineDeleting$ = [-3, n0, _SMD,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(StateMachineDeleting$, StateMachineDeleting);
+var StateMachineDoesNotExist$ = [-3, n0, _SMDNE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(StateMachineDoesNotExist$, StateMachineDoesNotExist);
+var StateMachineLimitExceeded$ = [-3, n0, _SMLE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(StateMachineLimitExceeded$, StateMachineLimitExceeded);
+var StateMachineTypeNotSupported$ = [-3, n0, _SMTNS,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(StateMachineTypeNotSupported$, StateMachineTypeNotSupported);
+var TaskDoesNotExist$ = [-3, n0, _TDNE,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(TaskDoesNotExist$, TaskDoesNotExist);
+var TaskTimedOut$ = [-3, n0, _TTO,
+    { [_e]: _c },
+    [_m],
+    [0]
+];
+n0_registry.registerError(TaskTimedOut$, TaskTimedOut);
+var TooManyTags$ = [-3, n0, _TMT,
+    { [_e]: _c, [_hE]: 400 },
+    [_m, _rN],
+    [0, 0]
+];
+n0_registry.registerError(TooManyTags$, TooManyTags);
+var ValidationException$ = [-3, n0, _VE,
+    { [_e]: _c, [_hE]: 400 },
+    [_m, _r],
+    [0, 0]
+];
+n0_registry.registerError(ValidationException$, ValidationException);
+const errorTypeRegistries = [
+    _s_registry,
+    n0_registry,
+];
+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 ExceptionHandlerIndex = [0, n0, _EHI, 8, 1];
+var InspectionMaxConcurrency = [0, n0, _IMC, 8, 1];
+var InspectionToleratedFailureCount = [0, n0, _ITFC, 8, 1];
+var InspectionToleratedFailurePercentage = [0, n0, _ITFP, 8, 1];
+var RetryBackoffIntervalSeconds = [0, n0, _RBIS, 8, 1];
+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 TestStateStateName = [0, n0, _TSSN, 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 ActivityFailedEventDetails$ = [3, n0, _AFED,
+    0,
+    [_e, _ca],
+    [[() => SensitiveError, 0], [() => SensitiveCause, 0]]
+];
+var ActivityListItem$ = [3, n0, _ALI,
+    0,
+    [_aA, _n, _cD],
+    [0, 0, 4], 3
+];
+var ActivityScheduledEventDetails$ = [3, n0, _ASED,
+    0,
+    [_re, _i, _iD, _tIS, _hIS],
+    [0, [() => SensitiveData, 0], () => HistoryEventExecutionDataDetails$, 1, 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 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 CreateActivityInput$ = [3, n0, _CAI,
+    0,
+    [_n, _ta, _eC],
+    [0, () => TagList, () => EncryptionConfiguration$], 1
+];
+var CreateActivityOutput$ = [3, n0, _CAO,
+    0,
+    [_aA, _cD],
+    [0, 4], 2
+];
+var CreateStateMachineAliasInput$ = [3, n0, _CSMAI,
+    0,
+    [_n, _rC, _d],
+    [0, () => RoutingConfigurationList, [() => AliasDescription, 0]], 2
+];
+var CreateStateMachineAliasOutput$ = [3, n0, _CSMAO,
+    0,
+    [_sMAA, _cD],
+    [0, 4], 2
+];
+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$], 3
+];
+var CreateStateMachineOutput$ = [3, n0, _CSMO,
+    0,
+    [_sMA, _cD, _sMVA],
+    [0, 4, 0], 2
+];
+var DeleteActivityInput$ = [3, n0, _DAI,
+    0,
+    [_aA],
+    [0], 1
+];
+var DeleteActivityOutput$ = [3, n0, _DAO,
+    0,
+    [],
+    []
+];
+var DeleteStateMachineAliasInput$ = [3, n0, _DSMAI,
+    0,
+    [_sMAA],
+    [0], 1
+];
+var DeleteStateMachineAliasOutput$ = [3, n0, _DSMAO,
+    0,
+    [],
+    []
+];
+var DeleteStateMachineInput$ = [3, n0, _DSMI,
+    0,
+    [_sMA],
+    [0], 1
+];
+var DeleteStateMachineOutput$ = [3, n0, _DSMO,
+    0,
+    [],
+    []
+];
+var DeleteStateMachineVersionInput$ = [3, n0, _DSMVI,
+    0,
+    [_sMVA],
+    [0], 1
+];
+var DeleteStateMachineVersionOutput$ = [3, n0, _DSMVO,
+    0,
+    [],
+    []
+];
+var DescribeActivityInput$ = [3, n0, _DAIe,
+    0,
+    [_aA],
+    [0], 1
+];
+var DescribeActivityOutput$ = [3, n0, _DAOe,
+    0,
+    [_aA, _n, _cD, _eC],
+    [0, 0, 4, () => EncryptionConfiguration$], 3
+];
+var DescribeExecutionInput$ = [3, n0, _DEI,
+    0,
+    [_eA, _iDn],
+    [0, 0], 1
+];
+var DescribeExecutionOutput$ = [3, n0, _DEO,
+    0,
+    [_eA, _sMA, _st, _sD, _n, _sDt, _i, _iD, _o, _oD, _tH, _mRA, _e, _ca, _sMVA, _sMAA, _rCe, _rD, _rS, _rSR],
+    [0, 0, 0, 4, 0, 4, [() => SensitiveData, 0], () => CloudWatchEventsExecutionDataDetails$, [() => SensitiveData, 0], () => CloudWatchEventsExecutionDataDetails$, 0, 0, [() => SensitiveError, 0], [() => SensitiveCause, 0], 0, 0, 1, 4, 0, [() => SensitiveData, 0]], 4
+];
+var DescribeMapRunInput$ = [3, n0, _DMRI,
+    0,
+    [_mRA],
+    [0], 1
+];
+var DescribeMapRunOutput$ = [3, n0, _DMRO,
+    0,
+    [_mRA, _eA, _st, _sD, _mC, _tFP, _tFC, _iC, _eCx, _sDt, _rCe, _rD],
+    [0, 0, 0, 4, 1, 1, 1, () => MapRunItemCounts$, () => MapRunExecutionCounts$, 4, 1, 4], 9
+];
+var DescribeStateMachineAliasInput$ = [3, n0, _DSMAIe,
+    0,
+    [_sMAA],
+    [0], 1
+];
+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], 1
+];
+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]], 5
+];
+var DescribeStateMachineInput$ = [3, n0, _DSMIe,
+    0,
+    [_sMA, _iDn],
+    [0, 0], 1
+];
+var DescribeStateMachineOutput$ = [3, n0, _DSMOe,
+    0,
+    [_sMA, _n, _de, _rA, _ty, _cD, _st, _lC, _tC, _l, _rI, _d, _eC, _vR],
+    [0, 0, [() => Definition, 0], 0, 0, 4, 0, () => LoggingConfiguration$, () => TracingConfiguration$, 0, 0, [() => VersionDescription, 0], () => EncryptionConfiguration$, [() => VariableReferences, 0]], 6
+];
+var EncryptionConfiguration$ = [3, n0, _EC,
+    0,
+    [_ty, _kKI, _kDKRPS],
+    [0, 0, 1], 1
+];
+var EvaluationFailedEventDetails$ = [3, n0, _EFED,
+    0,
+    [_sta, _e, _ca, _lo],
+    [0, [() => SensitiveError, 0], [() => SensitiveCause, 0], [() => EvaluationFailureLocation, 0]], 1
+];
+var ExecutionAbortedEventDetails$ = [3, n0, _EAED,
+    0,
+    [_e, _ca],
+    [[() => SensitiveError, 0], [() => SensitiveCause, 0]]
+];
+var ExecutionFailedEventDetails$ = [3, n0, _EFEDx,
+    0,
+    [_e, _ca],
+    [[() => SensitiveError, 0], [() => SensitiveCause, 0]]
+];
+var ExecutionListItem$ = [3, n0, _ELI,
+    0,
+    [_eA, _sMA, _n, _st, _sD, _sDt, _mRA, _iCt, _sMVA, _sMAA, _rCe, _rD],
+    [0, 0, 0, 0, 4, 4, 0, 1, 0, 0, 1, 4], 5
+];
+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], 1
+];
+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], 1
+];
+var GetExecutionHistoryOutput$ = [3, n0, _GEHO,
+    0,
+    [_ev, _nT],
+    [[() => HistoryEventList, 0], 0], 1
+];
+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]], 3
+];
+var HistoryEventExecutionDataDetails$ = [3, n0, _HEEDD,
+    0,
+    [_t],
+    [2]
+];
+var InspectionData$ = [3, n0, _IDn,
+    8,
+    [_i, _aAf, _aIP, _aP, _res, _aRS, _aRP, _req, _resp, _v, _eD, _aIPf, _aIS, _aIB, _aIPft, _tFC, _tFP, _mC],
+    [[() => SensitiveData, 0], [() => SensitiveData, 0], [() => SensitiveData, 0], [() => SensitiveData, 0], [() => SensitiveData, 0], [() => SensitiveData, 0], [() => SensitiveData, 0], () => InspectionDataRequest$, () => InspectionDataResponse$, [() => SensitiveData, 0], [() => InspectionErrorDetails$, 0], [() => SensitiveData, 0], [() => SensitiveData, 0], [() => SensitiveData, 0], [() => SensitiveData, 0], [() => InspectionToleratedFailureCount, 0], [() => InspectionToleratedFailurePercentage, 0], [() => InspectionMaxConcurrency, 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 InspectionErrorDetails$ = [3, n0, _IED,
+    0,
+    [_cI, _rIe, _rBIS],
+    [[() => ExceptionHandlerIndex, 0], [() => ExceptionHandlerIndex, 0], [() => RetryBackoffIntervalSeconds, 0]]
+];
+var LambdaFunctionFailedEventDetails$ = [3, n0, _LFFED,
+    0,
+    [_e, _ca],
+    [[() => SensitiveError, 0], [() => SensitiveCause, 0]]
+];
+var LambdaFunctionScheduledEventDetails$ = [3, n0, _LFSED,
+    0,
+    [_re, _i, _iD, _tIS, _tCa],
+    [0, [() => SensitiveData, 0], () => HistoryEventExecutionDataDetails$, 1, () => TaskCredentials$], 1
+];
+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], 1
+];
+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], 1
+];
+var ListMapRunsInput$ = [3, n0, _LMRI,
+    0,
+    [_eA, _mR, _nT],
+    [0, 1, 0], 1
+];
+var ListMapRunsOutput$ = [3, n0, _LMRO,
+    0,
+    [_mRa, _nT],
+    [() => MapRunList, 0], 1
+];
+var ListStateMachineAliasesInput$ = [3, n0, _LSMAI,
+    0,
+    [_sMA, _nT, _mR],
+    [0, 0, 1], 1
+];
+var ListStateMachineAliasesOutput$ = [3, n0, _LSMAO,
+    0,
+    [_sMAt, _nT],
+    [() => StateMachineAliasList, 0], 1
+];
+var ListStateMachinesInput$ = [3, n0, _LSMI,
+    0,
+    [_mR, _nT],
+    [1, 0]
+];
+var ListStateMachinesOutput$ = [3, n0, _LSMO,
+    0,
+    [_sMt, _nT],
+    [() => StateMachineList, 0], 1
+];
+var ListStateMachineVersionsInput$ = [3, n0, _LSMVI,
+    0,
+    [_sMA, _nT, _mR],
+    [0, 0, 1], 1
+];
+var ListStateMachineVersionsOutput$ = [3, n0, _LSMVO,
+    0,
+    [_sMV, _nT],
+    [() => StateMachineVersionList, 0], 1
+];
+var ListTagsForResourceInput$ = [3, n0, _LTFRI,
+    0,
+    [_rAe],
+    [0], 1
+];
+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], 8
+];
+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], 8
+];
+var MapRunListItem$ = [3, n0, _MRLI,
+    0,
+    [_eA, _mRA, _sMA, _sD, _sDt],
+    [0, 0, 0, 4, 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 MockErrorOutput$ = [3, n0, _MEO,
+    0,
+    [_e, _ca],
+    [[() => SensitiveError, 0], [() => SensitiveCause, 0]]
+];
+var MockInput$ = [3, n0, _MI,
+    0,
+    [_res, _eO, _fVM],
+    [[() => SensitiveData, 0], [() => MockErrorOutput$, 0], 0]
+];
+var PublishStateMachineVersionInput$ = [3, n0, _PSMVI,
+    0,
+    [_sMA, _rI, _d],
+    [0, 0, [() => VersionDescription, 0]], 1
+];
+var PublishStateMachineVersionOutput$ = [3, n0, _PSMVO,
+    0,
+    [_cD, _sMVA],
+    [4, 0], 2
+];
+var RedriveExecutionInput$ = [3, n0, _REI,
+    0,
+    [_eA, _cT],
+    [0, [0, 4]], 1
+];
+var RedriveExecutionOutput$ = [3, n0, _REO,
+    0,
+    [_rD],
+    [4], 1
+];
+var RoutingConfigurationListItem$ = [3, n0, _RCLI,
+    0,
+    [_sMVA, _w],
+    [0, 1], 2
+];
+var SendTaskFailureInput$ = [3, n0, _STFI,
+    0,
+    [_tT, _e, _ca],
+    [0, [() => SensitiveError, 0], [() => SensitiveCause, 0]], 1
+];
+var SendTaskFailureOutput$ = [3, n0, _STFO,
+    0,
+    [],
+    []
+];
+var SendTaskHeartbeatInput$ = [3, n0, _STHI,
+    0,
+    [_tT],
+    [0], 1
+];
+var SendTaskHeartbeatOutput$ = [3, n0, _STHO,
+    0,
+    [],
+    []
+];
+var SendTaskSuccessInput$ = [3, n0, _STSI,
+    0,
+    [_tT, _o],
+    [0, [() => SensitiveData, 0]], 2
+];
+var SendTaskSuccessOutput$ = [3, n0, _STSO,
+    0,
+    [],
+    []
+];
+var StartExecutionInput$ = [3, n0, _SEI,
+    0,
+    [_sMA, _n, _i, _tH],
+    [0, 0, [() => SensitiveData, 0], 0], 1
+];
+var StartExecutionOutput$ = [3, n0, _SEO,
+    0,
+    [_eA, _sD],
+    [0, 4], 2
+];
+var StartSyncExecutionInput$ = [3, n0, _SSEI,
+    0,
+    [_sMA, _n, _i, _tH, _iDn],
+    [0, 0, [() => SensitiveData, 0], 0, 0], 1
+];
+var StartSyncExecutionOutput$ = [3, n0, _SSEO,
+    0,
+    [_eA, _sD, _sDt, _st, _sMA, _n, _e, _ca, _i, _iD, _o, _oD, _tH, _bD],
+    [0, 4, 4, 0, 0, 0, [() => SensitiveError, 0], [() => SensitiveCause, 0], [() => SensitiveData, 0], () => CloudWatchEventsExecutionDataDetails$, [() => SensitiveData, 0], () => CloudWatchEventsExecutionDataDetails$, 0, () => BillingDetails$], 4
+];
+var StateEnteredEventDetails$ = [3, n0, _SEED,
+    0,
+    [_n, _i, _iD],
+    [0, [() => SensitiveData, 0], () => HistoryEventExecutionDataDetails$], 1
+];
+var StateExitedEventDetails$ = [3, n0, _SEEDt,
+    0,
+    [_n, _o, _oD, _aV, _aVD],
+    [0, [() => SensitiveData, 0], () => HistoryEventExecutionDataDetails$, [() => AssignedVariables, 0], () => AssignedVariablesDetails$], 1
+];
+var StateMachineAliasListItem$ = [3, n0, _SMALI,
+    0,
+    [_sMAA, _cD],
+    [0, 4], 2
+];
+var StateMachineListItem$ = [3, n0, _SMLI,
+    0,
+    [_sMA, _n, _ty, _cD],
+    [0, 0, 0, 4], 4
+];
+var StateMachineVersionListItem$ = [3, n0, _SMVLI,
+    0,
+    [_sMVA, _cD],
+    [0, 4], 2
+];
+var StopExecutionInput$ = [3, n0, _SEIt,
+    0,
+    [_eA, _e, _ca],
+    [0, [() => SensitiveError, 0], [() => SensitiveCause, 0]], 1
+];
+var StopExecutionOutput$ = [3, n0, _SEOt,
+    0,
+    [_sDt],
+    [4], 1
+];
+var Tag$ = [3, n0, _T,
+    0,
+    [_k, _va],
+    [0, 0]
+];
+var TagResourceInput$ = [3, n0, _TRI,
+    0,
+    [_rAe, _ta],
+    [0, () => TagList], 2
+];
+var TagResourceOutput$ = [3, n0, _TRO,
+    0,
+    [],
+    []
+];
+var TaskCredentials$ = [3, n0, _TC,
+    0,
+    [_rA],
+    [0]
+];
+var TaskFailedEventDetails$ = [3, n0, _TFED,
+    0,
+    [_rT, _re, _e, _ca],
+    [0, 0, [() => SensitiveError, 0], [() => SensitiveCause, 0]], 2
+];
+var TaskScheduledEventDetails$ = [3, n0, _TSED,
+    0,
+    [_rT, _re, _reg, _pa, _tIS, _hIS, _tCa],
+    [0, 0, 0, [() => ConnectorParameters, 0], 1, 1, () => TaskCredentials$], 4
+];
+var TaskStartedEventDetails$ = [3, n0, _TSEDa,
+    0,
+    [_rT, _re],
+    [0, 0], 2
+];
+var TaskStartFailedEventDetails$ = [3, n0, _TSFED,
+    0,
+    [_rT, _re, _e, _ca],
+    [0, 0, [() => SensitiveError, 0], [() => SensitiveCause, 0]], 2
+];
+var TaskSubmitFailedEventDetails$ = [3, n0, _TSFEDa,
+    0,
+    [_rT, _re, _e, _ca],
+    [0, 0, [() => SensitiveError, 0], [() => SensitiveCause, 0]], 2
+];
+var TaskSubmittedEventDetails$ = [3, n0, _TSEDas,
+    0,
+    [_rT, _re, _o, _oD],
+    [0, 0, [() => SensitiveData, 0], () => HistoryEventExecutionDataDetails$], 2
+];
+var TaskSucceededEventDetails$ = [3, n0, _TSEDask,
+    0,
+    [_rT, _re, _o, _oD],
+    [0, 0, [() => SensitiveData, 0], () => HistoryEventExecutionDataDetails$], 2
+];
+var TaskTimedOutEventDetails$ = [3, n0, _TTOED,
+    0,
+    [_rT, _re, _e, _ca],
+    [0, 0, [() => SensitiveError, 0], [() => SensitiveCause, 0]], 2
+];
+var TestStateConfiguration$ = [3, n0, _TSC,
+    0,
+    [_rRC, _eCBS, _mIFC, _mIRD],
+    [1, [() => TestStateStateName, 0], 1, [() => SensitiveData, 0]]
+];
+var TestStateInput$ = [3, n0, _TSI,
+    0,
+    [_de, _rA, _i, _iL, _rSe, _v, _sN, _mo, _co, _sCt],
+    [[() => Definition, 0], 0, [() => SensitiveData, 0], 0, 2, [() => SensitiveData, 0], [() => TestStateStateName, 0], [() => MockInput$, 0], [() => SensitiveData, 0], [() => TestStateConfiguration$, 0]], 1
+];
+var TestStateOutput$ = [3, n0, _TSO,
+    0,
+    [_o, _e, _ca, _iDns, _nS, _st],
+    [[() => SensitiveData, 0], [() => SensitiveError, 0], [() => SensitiveCause, 0], [() => InspectionData$, 0], 0, 0]
+];
+var TracingConfiguration$ = [3, n0, _TCr,
+    0,
+    [_en],
+    [2]
+];
+var UntagResourceInput$ = [3, n0, _URI,
+    0,
+    [_rAe, _tK],
+    [0, 64 | 0], 2
+];
+var UntagResourceOutput$ = [3, n0, _URO,
+    0,
+    [],
+    []
+];
+var UpdateMapRunInput$ = [3, n0, _UMRI,
+    0,
+    [_mRA, _mC, _tFP, _tFC],
+    [0, 1, 1, 1], 1
+];
+var UpdateMapRunOutput$ = [3, n0, _UMRO,
+    0,
+    [],
+    []
+];
+var UpdateStateMachineAliasInput$ = [3, n0, _USMAI,
+    0,
+    [_sMAA, _d, _rC],
+    [0, [() => AliasDescription, 0], () => RoutingConfigurationList], 1
+];
+var UpdateStateMachineAliasOutput$ = [3, n0, _USMAO,
+    0,
+    [_uD],
+    [4], 1
+];
+var UpdateStateMachineInput$ = [3, n0, _USMI,
+    0,
+    [_sMA, _de, _rA, _lC, _tC, _p, _vD, _eC],
+    [0, [() => Definition, 0], 0, () => LoggingConfiguration$, () => TracingConfiguration$, 2, [() => VersionDescription, 0], () => EncryptionConfiguration$], 1
+];
+var UpdateStateMachineOutput$ = [3, n0, _USMO,
+    0,
+    [_uD, _rI, _sMVA],
+    [4, 0, 0], 1
+];
+var ValidateStateMachineDefinitionDiagnostic$ = [3, n0, _VSMDD,
+    0,
+    [_se, _cod, _m, _lo],
+    [0, [() => ValidateStateMachineDefinitionCode, 0], [() => ValidateStateMachineDefinitionMessage, 0], [() => ValidateStateMachineDefinitionLocation, 0]], 3
+];
+var ValidateStateMachineDefinitionInput$ = [3, n0, _VSMDI,
+    0,
+    [_de, _ty, _se, _mR],
+    [[() => Definition, 0], 0, 0, 1], 1
+];
+var ValidateStateMachineDefinitionOutput$ = [3, n0, _VSMDO,
+    0,
+    [_res, _di, _t],
+    [0, [() => ValidateStateMachineDefinitionDiagnosticList, 0], 2], 2
+];
+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$
+];
+
+const getRuntimeConfig$1 = (config) => {
+    return {
+        apiVersion: "2016-11-23",
+        base64Decoder: config?.base64Decoder ?? fromBase64,
+        base64Encoder: config?.base64Encoder ?? toBase64,
+        disableHostPrefix: config?.disableHostPrefix ?? false,
+        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
+        extensions: config?.extensions ?? [],
+        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultSFNHttpAuthSchemeProvider,
+        httpAuthSchemes: config?.httpAuthSchemes ?? [
+            {
+                schemeId: "aws.auth#sigv4",
+                identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
+                signer: new AwsSdkSigV4Signer(),
+            },
+        ],
+        logger: config?.logger ?? new NoOpLogger(),
+        protocol: config?.protocol ?? AwsJson1_0Protocol,
+        protocolSettings: config?.protocolSettings ?? {
+            defaultNamespace: "com.amazonaws.sfn",
+            errorTypeRegistries,
+            xmlNamespace: "http://swf.amazonaws.com/doc/2015-07-20/",
+            version: "2016-11-23",
+            serviceTarget: "AWSStepFunctions",
+        },
+        serviceId: config?.serviceId ?? "SFN",
+        urlParser: config?.urlParser ?? parseUrl,
+        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
+        utf8Encoder: config?.utf8Encoder ?? toUtf8,
+    };
+};
+
+const getRuntimeConfig = (config) => {
+    emitWarningIfUnsupportedVersion(process.version);
+    const defaultsMode = resolveDefaultsModeConfig(config);
+    const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
+    const clientSharedValues = getRuntimeConfig$1(config);
+    emitWarningIfUnsupportedVersion$1(process.version);
+    const loaderConfig = {
+        profile: config?.profile,
+        logger: clientSharedValues.logger,
+    };
+    return {
+        ...clientSharedValues,
+        ...config,
+        runtime: "node",
+        defaultsMode,
+        authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
+        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+        credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
+        maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
+        region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
+        requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
+        retryMode: config?.retryMode ??
+            loadConfig({
+                ...NODE_RETRY_MODE_CONFIG_OPTIONS,
+                default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE,
+            }, config),
+        sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
+        streamCollector: config?.streamCollector ?? streamCollector,
+        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig),
+    };
+};
+
 const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
     const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
     let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
@@ -770,63 +2856,306 @@ const ValidateStateMachineDefinitionResultCode = {
     OK: "OK",
 };
 
+exports.ActivityAlreadyExists = ActivityAlreadyExists;
+exports.ActivityAlreadyExists$ = ActivityAlreadyExists$;
+exports.ActivityDoesNotExist = ActivityDoesNotExist;
+exports.ActivityDoesNotExist$ = ActivityDoesNotExist$;
+exports.ActivityFailedEventDetails$ = ActivityFailedEventDetails$;
+exports.ActivityLimitExceeded = ActivityLimitExceeded;
+exports.ActivityLimitExceeded$ = ActivityLimitExceeded$;
+exports.ActivityListItem$ = ActivityListItem$;
+exports.ActivityScheduleFailedEventDetails$ = ActivityScheduleFailedEventDetails$;
+exports.ActivityScheduledEventDetails$ = ActivityScheduledEventDetails$;
+exports.ActivityStartedEventDetails$ = ActivityStartedEventDetails$;
+exports.ActivitySucceededEventDetails$ = ActivitySucceededEventDetails$;
+exports.ActivityTimedOutEventDetails$ = ActivityTimedOutEventDetails$;
+exports.ActivityWorkerLimitExceeded = ActivityWorkerLimitExceeded;
+exports.ActivityWorkerLimitExceeded$ = ActivityWorkerLimitExceeded$;
+exports.AssignedVariablesDetails$ = AssignedVariablesDetails$;
+exports.BillingDetails$ = BillingDetails$;
+exports.CloudWatchEventsExecutionDataDetails$ = CloudWatchEventsExecutionDataDetails$;
+exports.CloudWatchLogsLogGroup$ = CloudWatchLogsLogGroup$;
+exports.ConflictException = ConflictException;
+exports.ConflictException$ = ConflictException$;
+exports.CreateActivity$ = CreateActivity$;
 exports.CreateActivityCommand = CreateActivityCommand;
+exports.CreateActivityInput$ = CreateActivityInput$;
+exports.CreateActivityOutput$ = CreateActivityOutput$;
+exports.CreateStateMachine$ = CreateStateMachine$;
+exports.CreateStateMachineAlias$ = CreateStateMachineAlias$;
 exports.CreateStateMachineAliasCommand = CreateStateMachineAliasCommand;
+exports.CreateStateMachineAliasInput$ = CreateStateMachineAliasInput$;
+exports.CreateStateMachineAliasOutput$ = CreateStateMachineAliasOutput$;
 exports.CreateStateMachineCommand = CreateStateMachineCommand;
+exports.CreateStateMachineInput$ = CreateStateMachineInput$;
+exports.CreateStateMachineOutput$ = CreateStateMachineOutput$;
+exports.DeleteActivity$ = DeleteActivity$;
 exports.DeleteActivityCommand = DeleteActivityCommand;
+exports.DeleteActivityInput$ = DeleteActivityInput$;
+exports.DeleteActivityOutput$ = DeleteActivityOutput$;
+exports.DeleteStateMachine$ = DeleteStateMachine$;
+exports.DeleteStateMachineAlias$ = DeleteStateMachineAlias$;
 exports.DeleteStateMachineAliasCommand = DeleteStateMachineAliasCommand;
+exports.DeleteStateMachineAliasInput$ = DeleteStateMachineAliasInput$;
+exports.DeleteStateMachineAliasOutput$ = DeleteStateMachineAliasOutput$;
 exports.DeleteStateMachineCommand = DeleteStateMachineCommand;
+exports.DeleteStateMachineInput$ = DeleteStateMachineInput$;
+exports.DeleteStateMachineOutput$ = DeleteStateMachineOutput$;
+exports.DeleteStateMachineVersion$ = DeleteStateMachineVersion$;
 exports.DeleteStateMachineVersionCommand = DeleteStateMachineVersionCommand;
+exports.DeleteStateMachineVersionInput$ = DeleteStateMachineVersionInput$;
+exports.DeleteStateMachineVersionOutput$ = DeleteStateMachineVersionOutput$;
+exports.DescribeActivity$ = DescribeActivity$;
 exports.DescribeActivityCommand = DescribeActivityCommand;
+exports.DescribeActivityInput$ = DescribeActivityInput$;
+exports.DescribeActivityOutput$ = DescribeActivityOutput$;
+exports.DescribeExecution$ = DescribeExecution$;
 exports.DescribeExecutionCommand = DescribeExecutionCommand;
+exports.DescribeExecutionInput$ = DescribeExecutionInput$;
+exports.DescribeExecutionOutput$ = DescribeExecutionOutput$;
+exports.DescribeMapRun$ = DescribeMapRun$;
 exports.DescribeMapRunCommand = DescribeMapRunCommand;
+exports.DescribeMapRunInput$ = DescribeMapRunInput$;
+exports.DescribeMapRunOutput$ = DescribeMapRunOutput$;
+exports.DescribeStateMachine$ = DescribeStateMachine$;
+exports.DescribeStateMachineAlias$ = DescribeStateMachineAlias$;
 exports.DescribeStateMachineAliasCommand = DescribeStateMachineAliasCommand;
+exports.DescribeStateMachineAliasInput$ = DescribeStateMachineAliasInput$;
+exports.DescribeStateMachineAliasOutput$ = DescribeStateMachineAliasOutput$;
 exports.DescribeStateMachineCommand = DescribeStateMachineCommand;
+exports.DescribeStateMachineForExecution$ = DescribeStateMachineForExecution$;
 exports.DescribeStateMachineForExecutionCommand = DescribeStateMachineForExecutionCommand;
+exports.DescribeStateMachineForExecutionInput$ = DescribeStateMachineForExecutionInput$;
+exports.DescribeStateMachineForExecutionOutput$ = DescribeStateMachineForExecutionOutput$;
+exports.DescribeStateMachineInput$ = DescribeStateMachineInput$;
+exports.DescribeStateMachineOutput$ = DescribeStateMachineOutput$;
+exports.EncryptionConfiguration$ = EncryptionConfiguration$;
 exports.EncryptionType = EncryptionType;
+exports.EvaluationFailedEventDetails$ = EvaluationFailedEventDetails$;
+exports.ExecutionAbortedEventDetails$ = ExecutionAbortedEventDetails$;
+exports.ExecutionAlreadyExists = ExecutionAlreadyExists;
+exports.ExecutionAlreadyExists$ = ExecutionAlreadyExists$;
+exports.ExecutionDoesNotExist = ExecutionDoesNotExist;
+exports.ExecutionDoesNotExist$ = ExecutionDoesNotExist$;
+exports.ExecutionFailedEventDetails$ = ExecutionFailedEventDetails$;
+exports.ExecutionLimitExceeded = ExecutionLimitExceeded;
+exports.ExecutionLimitExceeded$ = ExecutionLimitExceeded$;
+exports.ExecutionListItem$ = ExecutionListItem$;
+exports.ExecutionNotRedrivable = ExecutionNotRedrivable;
+exports.ExecutionNotRedrivable$ = ExecutionNotRedrivable$;
 exports.ExecutionRedriveFilter = ExecutionRedriveFilter;
 exports.ExecutionRedriveStatus = ExecutionRedriveStatus;
+exports.ExecutionRedrivenEventDetails$ = ExecutionRedrivenEventDetails$;
+exports.ExecutionStartedEventDetails$ = ExecutionStartedEventDetails$;
 exports.ExecutionStatus = ExecutionStatus;
+exports.ExecutionSucceededEventDetails$ = ExecutionSucceededEventDetails$;
+exports.ExecutionTimedOutEventDetails$ = ExecutionTimedOutEventDetails$;
+exports.GetActivityTask$ = GetActivityTask$;
 exports.GetActivityTaskCommand = GetActivityTaskCommand;
+exports.GetActivityTaskInput$ = GetActivityTaskInput$;
+exports.GetActivityTaskOutput$ = GetActivityTaskOutput$;
+exports.GetExecutionHistory$ = GetExecutionHistory$;
 exports.GetExecutionHistoryCommand = GetExecutionHistoryCommand;
+exports.GetExecutionHistoryInput$ = GetExecutionHistoryInput$;
+exports.GetExecutionHistoryOutput$ = GetExecutionHistoryOutput$;
+exports.HistoryEvent$ = HistoryEvent$;
+exports.HistoryEventExecutionDataDetails$ = HistoryEventExecutionDataDetails$;
 exports.HistoryEventType = HistoryEventType;
 exports.IncludedData = IncludedData;
+exports.InspectionData$ = InspectionData$;
+exports.InspectionDataRequest$ = InspectionDataRequest$;
+exports.InspectionDataResponse$ = InspectionDataResponse$;
+exports.InspectionErrorDetails$ = InspectionErrorDetails$;
 exports.InspectionLevel = InspectionLevel;
+exports.InvalidArn = InvalidArn;
+exports.InvalidArn$ = InvalidArn$;
+exports.InvalidDefinition = InvalidDefinition;
+exports.InvalidDefinition$ = InvalidDefinition$;
+exports.InvalidEncryptionConfiguration = InvalidEncryptionConfiguration;
+exports.InvalidEncryptionConfiguration$ = InvalidEncryptionConfiguration$;
+exports.InvalidExecutionInput = InvalidExecutionInput;
+exports.InvalidExecutionInput$ = InvalidExecutionInput$;
+exports.InvalidLoggingConfiguration = InvalidLoggingConfiguration;
+exports.InvalidLoggingConfiguration$ = InvalidLoggingConfiguration$;
+exports.InvalidName = InvalidName;
+exports.InvalidName$ = InvalidName$;
+exports.InvalidOutput = InvalidOutput;
+exports.InvalidOutput$ = InvalidOutput$;
+exports.InvalidToken = InvalidToken;
+exports.InvalidToken$ = InvalidToken$;
+exports.InvalidTracingConfiguration = InvalidTracingConfiguration;
+exports.InvalidTracingConfiguration$ = InvalidTracingConfiguration$;
+exports.KmsAccessDeniedException = KmsAccessDeniedException;
+exports.KmsAccessDeniedException$ = KmsAccessDeniedException$;
+exports.KmsInvalidStateException = KmsInvalidStateException;
+exports.KmsInvalidStateException$ = KmsInvalidStateException$;
 exports.KmsKeyState = KmsKeyState;
+exports.KmsThrottlingException = KmsThrottlingException;
+exports.KmsThrottlingException$ = KmsThrottlingException$;
+exports.LambdaFunctionFailedEventDetails$ = LambdaFunctionFailedEventDetails$;
+exports.LambdaFunctionScheduleFailedEventDetails$ = LambdaFunctionScheduleFailedEventDetails$;
+exports.LambdaFunctionScheduledEventDetails$ = LambdaFunctionScheduledEventDetails$;
+exports.LambdaFunctionStartFailedEventDetails$ = LambdaFunctionStartFailedEventDetails$;
+exports.LambdaFunctionSucceededEventDetails$ = LambdaFunctionSucceededEventDetails$;
+exports.LambdaFunctionTimedOutEventDetails$ = LambdaFunctionTimedOutEventDetails$;
+exports.ListActivities$ = ListActivities$;
 exports.ListActivitiesCommand = ListActivitiesCommand;
+exports.ListActivitiesInput$ = ListActivitiesInput$;
+exports.ListActivitiesOutput$ = ListActivitiesOutput$;
+exports.ListExecutions$ = ListExecutions$;
 exports.ListExecutionsCommand = ListExecutionsCommand;
+exports.ListExecutionsInput$ = ListExecutionsInput$;
+exports.ListExecutionsOutput$ = ListExecutionsOutput$;
+exports.ListMapRuns$ = ListMapRuns$;
 exports.ListMapRunsCommand = ListMapRunsCommand;
+exports.ListMapRunsInput$ = ListMapRunsInput$;
+exports.ListMapRunsOutput$ = ListMapRunsOutput$;
+exports.ListStateMachineAliases$ = ListStateMachineAliases$;
 exports.ListStateMachineAliasesCommand = ListStateMachineAliasesCommand;
+exports.ListStateMachineAliasesInput$ = ListStateMachineAliasesInput$;
+exports.ListStateMachineAliasesOutput$ = ListStateMachineAliasesOutput$;
+exports.ListStateMachineVersions$ = ListStateMachineVersions$;
 exports.ListStateMachineVersionsCommand = ListStateMachineVersionsCommand;
+exports.ListStateMachineVersionsInput$ = ListStateMachineVersionsInput$;
+exports.ListStateMachineVersionsOutput$ = ListStateMachineVersionsOutput$;
+exports.ListStateMachines$ = ListStateMachines$;
 exports.ListStateMachinesCommand = ListStateMachinesCommand;
+exports.ListStateMachinesInput$ = ListStateMachinesInput$;
+exports.ListStateMachinesOutput$ = ListStateMachinesOutput$;
+exports.ListTagsForResource$ = ListTagsForResource$;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
+exports.ListTagsForResourceInput$ = ListTagsForResourceInput$;
+exports.ListTagsForResourceOutput$ = ListTagsForResourceOutput$;
+exports.LogDestination$ = LogDestination$;
 exports.LogLevel = LogLevel;
+exports.LoggingConfiguration$ = LoggingConfiguration$;
+exports.MapIterationEventDetails$ = MapIterationEventDetails$;
+exports.MapRunExecutionCounts$ = MapRunExecutionCounts$;
+exports.MapRunFailedEventDetails$ = MapRunFailedEventDetails$;
+exports.MapRunItemCounts$ = MapRunItemCounts$;
+exports.MapRunListItem$ = MapRunListItem$;
+exports.MapRunRedrivenEventDetails$ = MapRunRedrivenEventDetails$;
+exports.MapRunStartedEventDetails$ = MapRunStartedEventDetails$;
 exports.MapRunStatus = MapRunStatus;
+exports.MapStateStartedEventDetails$ = MapStateStartedEventDetails$;
+exports.MissingRequiredParameter = MissingRequiredParameter;
+exports.MissingRequiredParameter$ = MissingRequiredParameter$;
+exports.MockErrorOutput$ = MockErrorOutput$;
+exports.MockInput$ = MockInput$;
 exports.MockResponseValidationMode = MockResponseValidationMode;
+exports.PublishStateMachineVersion$ = PublishStateMachineVersion$;
 exports.PublishStateMachineVersionCommand = PublishStateMachineVersionCommand;
+exports.PublishStateMachineVersionInput$ = PublishStateMachineVersionInput$;
+exports.PublishStateMachineVersionOutput$ = PublishStateMachineVersionOutput$;
+exports.RedriveExecution$ = RedriveExecution$;
 exports.RedriveExecutionCommand = RedriveExecutionCommand;
+exports.RedriveExecutionInput$ = RedriveExecutionInput$;
+exports.RedriveExecutionOutput$ = RedriveExecutionOutput$;
+exports.ResourceNotFound = ResourceNotFound;
+exports.ResourceNotFound$ = ResourceNotFound$;
+exports.RoutingConfigurationListItem$ = RoutingConfigurationListItem$;
 exports.SFN = SFN;
 exports.SFNClient = SFNClient;
+exports.SFNServiceException = SFNServiceException;
+exports.SFNServiceException$ = SFNServiceException$;
+exports.SendTaskFailure$ = SendTaskFailure$;
 exports.SendTaskFailureCommand = SendTaskFailureCommand;
+exports.SendTaskFailureInput$ = SendTaskFailureInput$;
+exports.SendTaskFailureOutput$ = SendTaskFailureOutput$;
+exports.SendTaskHeartbeat$ = SendTaskHeartbeat$;
 exports.SendTaskHeartbeatCommand = SendTaskHeartbeatCommand;
+exports.SendTaskHeartbeatInput$ = SendTaskHeartbeatInput$;
+exports.SendTaskHeartbeatOutput$ = SendTaskHeartbeatOutput$;
+exports.SendTaskSuccess$ = SendTaskSuccess$;
 exports.SendTaskSuccessCommand = SendTaskSuccessCommand;
+exports.SendTaskSuccessInput$ = SendTaskSuccessInput$;
+exports.SendTaskSuccessOutput$ = SendTaskSuccessOutput$;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException$ = ServiceQuotaExceededException$;
+exports.StartExecution$ = StartExecution$;
 exports.StartExecutionCommand = StartExecutionCommand;
+exports.StartExecutionInput$ = StartExecutionInput$;
+exports.StartExecutionOutput$ = StartExecutionOutput$;
+exports.StartSyncExecution$ = StartSyncExecution$;
 exports.StartSyncExecutionCommand = StartSyncExecutionCommand;
+exports.StartSyncExecutionInput$ = StartSyncExecutionInput$;
+exports.StartSyncExecutionOutput$ = StartSyncExecutionOutput$;
+exports.StateEnteredEventDetails$ = StateEnteredEventDetails$;
+exports.StateExitedEventDetails$ = StateExitedEventDetails$;
+exports.StateMachineAliasListItem$ = StateMachineAliasListItem$;
+exports.StateMachineAlreadyExists = StateMachineAlreadyExists;
+exports.StateMachineAlreadyExists$ = StateMachineAlreadyExists$;
+exports.StateMachineDeleting = StateMachineDeleting;
+exports.StateMachineDeleting$ = StateMachineDeleting$;
+exports.StateMachineDoesNotExist = StateMachineDoesNotExist;
+exports.StateMachineDoesNotExist$ = StateMachineDoesNotExist$;
+exports.StateMachineLimitExceeded = StateMachineLimitExceeded;
+exports.StateMachineLimitExceeded$ = StateMachineLimitExceeded$;
+exports.StateMachineListItem$ = StateMachineListItem$;
 exports.StateMachineStatus = StateMachineStatus;
 exports.StateMachineType = StateMachineType;
+exports.StateMachineTypeNotSupported = StateMachineTypeNotSupported;
+exports.StateMachineTypeNotSupported$ = StateMachineTypeNotSupported$;
+exports.StateMachineVersionListItem$ = StateMachineVersionListItem$;
+exports.StopExecution$ = StopExecution$;
 exports.StopExecutionCommand = StopExecutionCommand;
+exports.StopExecutionInput$ = StopExecutionInput$;
+exports.StopExecutionOutput$ = StopExecutionOutput$;
 exports.SyncExecutionStatus = SyncExecutionStatus;
+exports.Tag$ = Tag$;
+exports.TagResource$ = TagResource$;
 exports.TagResourceCommand = TagResourceCommand;
+exports.TagResourceInput$ = TagResourceInput$;
+exports.TagResourceOutput$ = TagResourceOutput$;
+exports.TaskCredentials$ = TaskCredentials$;
+exports.TaskDoesNotExist = TaskDoesNotExist;
+exports.TaskDoesNotExist$ = TaskDoesNotExist$;
+exports.TaskFailedEventDetails$ = TaskFailedEventDetails$;
+exports.TaskScheduledEventDetails$ = TaskScheduledEventDetails$;
+exports.TaskStartFailedEventDetails$ = TaskStartFailedEventDetails$;
+exports.TaskStartedEventDetails$ = TaskStartedEventDetails$;
+exports.TaskSubmitFailedEventDetails$ = TaskSubmitFailedEventDetails$;
+exports.TaskSubmittedEventDetails$ = TaskSubmittedEventDetails$;
+exports.TaskSucceededEventDetails$ = TaskSucceededEventDetails$;
+exports.TaskTimedOut = TaskTimedOut;
+exports.TaskTimedOut$ = TaskTimedOut$;
+exports.TaskTimedOutEventDetails$ = TaskTimedOutEventDetails$;
 exports.TestExecutionStatus = TestExecutionStatus;
+exports.TestState$ = TestState$;
 exports.TestStateCommand = TestStateCommand;
+exports.TestStateConfiguration$ = TestStateConfiguration$;
+exports.TestStateInput$ = TestStateInput$;
+exports.TestStateOutput$ = TestStateOutput$;
+exports.TooManyTags = TooManyTags;
+exports.TooManyTags$ = TooManyTags$;
+exports.TracingConfiguration$ = TracingConfiguration$;
+exports.UntagResource$ = UntagResource$;
 exports.UntagResourceCommand = UntagResourceCommand;
+exports.UntagResourceInput$ = UntagResourceInput$;
+exports.UntagResourceOutput$ = UntagResourceOutput$;
+exports.UpdateMapRun$ = UpdateMapRun$;
 exports.UpdateMapRunCommand = UpdateMapRunCommand;
+exports.UpdateMapRunInput$ = UpdateMapRunInput$;
+exports.UpdateMapRunOutput$ = UpdateMapRunOutput$;
+exports.UpdateStateMachine$ = UpdateStateMachine$;
+exports.UpdateStateMachineAlias$ = UpdateStateMachineAlias$;
 exports.UpdateStateMachineAliasCommand = UpdateStateMachineAliasCommand;
+exports.UpdateStateMachineAliasInput$ = UpdateStateMachineAliasInput$;
+exports.UpdateStateMachineAliasOutput$ = UpdateStateMachineAliasOutput$;
 exports.UpdateStateMachineCommand = UpdateStateMachineCommand;
+exports.UpdateStateMachineInput$ = UpdateStateMachineInput$;
+exports.UpdateStateMachineOutput$ = UpdateStateMachineOutput$;
+exports.ValidateStateMachineDefinition$ = ValidateStateMachineDefinition$;
 exports.ValidateStateMachineDefinitionCommand = ValidateStateMachineDefinitionCommand;
+exports.ValidateStateMachineDefinitionDiagnostic$ = ValidateStateMachineDefinitionDiagnostic$;
+exports.ValidateStateMachineDefinitionInput$ = ValidateStateMachineDefinitionInput$;
+exports.ValidateStateMachineDefinitionOutput$ = ValidateStateMachineDefinitionOutput$;
 exports.ValidateStateMachineDefinitionResultCode = ValidateStateMachineDefinitionResultCode;
 exports.ValidateStateMachineDefinitionSeverity = ValidateStateMachineDefinitionSeverity;
+exports.ValidationException = ValidationException;
+exports.ValidationException$ = ValidationException$;
 exports.ValidationExceptionReason = ValidationExceptionReason;
+exports.errorTypeRegistries = errorTypeRegistries;
 exports.paginateGetExecutionHistory = paginateGetExecutionHistory;
 exports.paginateListActivities = paginateListActivities;
 exports.paginateListExecutions = paginateListExecutions;