@aws-sdk/client-sfn 3.183.0 → 3.186.0

package/dist-es/protocols/Aws_json1_0.js

@@ -1,1579 +1,2003 @@
+import { __assign, __awaiter, __generator } from "tslib";
 import { HttpRequest as __HttpRequest, isValidHostname as __isValidHostname, } from "@aws-sdk/protocol-http";
 import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, throwDefaultError, } from "@aws-sdk/smithy-client";
 import { ActivityDoesNotExist, ActivityLimitExceeded, ActivityWorkerLimitExceeded, ExecutionAlreadyExists, ExecutionDoesNotExist, ExecutionLimitExceeded, InvalidArn, InvalidDefinition, InvalidExecutionInput, InvalidLoggingConfiguration, InvalidName, InvalidOutput, InvalidToken, InvalidTracingConfiguration, MissingRequiredParameter, ResourceNotFound, StateMachineAlreadyExists, StateMachineDeleting, StateMachineDoesNotExist, StateMachineLimitExceeded, StateMachineTypeNotSupported, TaskDoesNotExist, TaskTimedOut, TooManyTags, } from "../models/models_0";
 import { SFNServiceException as __BaseException } from "../models/SFNServiceException";
-export const serializeAws_json1_0CreateActivityCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.CreateActivity",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0CreateActivityInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0CreateStateMachineCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.CreateStateMachine",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0CreateStateMachineInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0DeleteActivityCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.DeleteActivity",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0DeleteActivityInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0DeleteStateMachineCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.DeleteStateMachine",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0DeleteStateMachineInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0DescribeActivityCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.DescribeActivity",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0DescribeActivityInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0DescribeExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.DescribeExecution",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0DescribeExecutionInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0DescribeStateMachineCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.DescribeStateMachine",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0DescribeStateMachineInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0DescribeStateMachineForExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.DescribeStateMachineForExecution",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0DescribeStateMachineForExecutionInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0GetActivityTaskCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.GetActivityTask",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0GetActivityTaskInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0GetExecutionHistoryCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.GetExecutionHistory",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0GetExecutionHistoryInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0ListActivitiesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.ListActivities",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0ListActivitiesInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0ListExecutionsCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.ListExecutions",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0ListExecutionsInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0ListStateMachinesCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.ListStateMachines",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0ListStateMachinesInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0ListTagsForResourceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.ListTagsForResource",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0ListTagsForResourceInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0SendTaskFailureCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.SendTaskFailure",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0SendTaskFailureInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0SendTaskHeartbeatCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.SendTaskHeartbeat",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0SendTaskHeartbeatInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0SendTaskSuccessCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.SendTaskSuccess",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0SendTaskSuccessInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0StartExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.StartExecution",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0StartExecutionInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0StartSyncExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.StartSyncExecution",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0StartSyncExecutionInput(input, context));
-    let { hostname: resolvedHostname } = await context.endpoint();
-    if (context.disableHostPrefix !== true) {
-        resolvedHostname = "sync-" + resolvedHostname;
-        if (!__isValidHostname(resolvedHostname)) {
-            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+export var serializeAws_json1_0CreateActivityCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.CreateActivity",
+        };
+        body = JSON.stringify(serializeAws_json1_0CreateActivityInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0CreateStateMachineCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.CreateStateMachine",
+        };
+        body = JSON.stringify(serializeAws_json1_0CreateStateMachineInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0DeleteActivityCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.DeleteActivity",
+        };
+        body = JSON.stringify(serializeAws_json1_0DeleteActivityInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0DeleteStateMachineCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.DeleteStateMachine",
+        };
+        body = JSON.stringify(serializeAws_json1_0DeleteStateMachineInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0DescribeActivityCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.DescribeActivity",
+        };
+        body = JSON.stringify(serializeAws_json1_0DescribeActivityInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0DescribeExecutionCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.DescribeExecution",
+        };
+        body = JSON.stringify(serializeAws_json1_0DescribeExecutionInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0DescribeStateMachineCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.DescribeStateMachine",
+        };
+        body = JSON.stringify(serializeAws_json1_0DescribeStateMachineInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0DescribeStateMachineForExecutionCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.DescribeStateMachineForExecution",
+        };
+        body = JSON.stringify(serializeAws_json1_0DescribeStateMachineForExecutionInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0GetActivityTaskCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.GetActivityTask",
+        };
+        body = JSON.stringify(serializeAws_json1_0GetActivityTaskInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0GetExecutionHistoryCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.GetExecutionHistory",
+        };
+        body = JSON.stringify(serializeAws_json1_0GetExecutionHistoryInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0ListActivitiesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.ListActivities",
+        };
+        body = JSON.stringify(serializeAws_json1_0ListActivitiesInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0ListExecutionsCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.ListExecutions",
+        };
+        body = JSON.stringify(serializeAws_json1_0ListExecutionsInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0ListStateMachinesCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.ListStateMachines",
+        };
+        body = JSON.stringify(serializeAws_json1_0ListStateMachinesInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0ListTagsForResourceCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.ListTagsForResource",
+        };
+        body = JSON.stringify(serializeAws_json1_0ListTagsForResourceInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0SendTaskFailureCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.SendTaskFailure",
+        };
+        body = JSON.stringify(serializeAws_json1_0SendTaskFailureInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0SendTaskHeartbeatCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.SendTaskHeartbeat",
+        };
+        body = JSON.stringify(serializeAws_json1_0SendTaskHeartbeatInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0SendTaskSuccessCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.SendTaskSuccess",
+        };
+        body = JSON.stringify(serializeAws_json1_0SendTaskSuccessInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0StartExecutionCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.StartExecution",
+        };
+        body = JSON.stringify(serializeAws_json1_0StartExecutionInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
+export var serializeAws_json1_0StartSyncExecutionCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body, resolvedHostname;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                headers = {
+                    "content-type": "application/x-amz-json-1.0",
+                    "x-amz-target": "AWSStepFunctions.StartSyncExecution",
+                };
+                body = JSON.stringify(serializeAws_json1_0StartSyncExecutionInput(input, context));
+                return [4, context.endpoint()];
+            case 1:
+                resolvedHostname = (_a.sent()).hostname;
+                if (context.disableHostPrefix !== true) {
+                    resolvedHostname = "sync-" + resolvedHostname;
+                    if (!__isValidHostname(resolvedHostname)) {
+                        throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+                    }
+                }
+                return [2, buildHttpRpcRequest(context, headers, "/", resolvedHostname, body)];
         }
-    }
-    return buildHttpRpcRequest(context, headers, "/", resolvedHostname, body);
-};
-export const serializeAws_json1_0StopExecutionCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.StopExecution",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0StopExecutionInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0TagResourceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.TagResource",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0TagResourceInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0UntagResourceCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.UntagResource",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0UntagResourceInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const serializeAws_json1_0UpdateStateMachineCommand = async (input, context) => {
-    const headers = {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": "AWSStepFunctions.UpdateStateMachine",
-    };
-    let body;
-    body = JSON.stringify(serializeAws_json1_0UpdateStateMachineInput(input, context));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-export const deserializeAws_json1_0CreateActivityCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0CreateActivityCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0CreateActivityOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0CreateActivityCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ActivityLimitExceeded":
-        case "com.amazonaws.sfn#ActivityLimitExceeded":
-            throw await deserializeAws_json1_0ActivityLimitExceededResponse(parsedOutput, context);
-        case "InvalidName":
-        case "com.amazonaws.sfn#InvalidName":
-            throw await deserializeAws_json1_0InvalidNameResponse(parsedOutput, context);
-        case "TooManyTags":
-        case "com.amazonaws.sfn#TooManyTags":
-            throw await deserializeAws_json1_0TooManyTagsResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0CreateStateMachineCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0CreateStateMachineCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0CreateStateMachineOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0CreateStateMachineCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        case "InvalidDefinition":
-        case "com.amazonaws.sfn#InvalidDefinition":
-            throw await deserializeAws_json1_0InvalidDefinitionResponse(parsedOutput, context);
-        case "InvalidLoggingConfiguration":
-        case "com.amazonaws.sfn#InvalidLoggingConfiguration":
-            throw await deserializeAws_json1_0InvalidLoggingConfigurationResponse(parsedOutput, context);
-        case "InvalidName":
-        case "com.amazonaws.sfn#InvalidName":
-            throw await deserializeAws_json1_0InvalidNameResponse(parsedOutput, context);
-        case "InvalidTracingConfiguration":
-        case "com.amazonaws.sfn#InvalidTracingConfiguration":
-            throw await deserializeAws_json1_0InvalidTracingConfigurationResponse(parsedOutput, context);
-        case "StateMachineAlreadyExists":
-        case "com.amazonaws.sfn#StateMachineAlreadyExists":
-            throw await deserializeAws_json1_0StateMachineAlreadyExistsResponse(parsedOutput, context);
-        case "StateMachineDeleting":
-        case "com.amazonaws.sfn#StateMachineDeleting":
-            throw await deserializeAws_json1_0StateMachineDeletingResponse(parsedOutput, context);
-        case "StateMachineLimitExceeded":
-        case "com.amazonaws.sfn#StateMachineLimitExceeded":
-            throw await deserializeAws_json1_0StateMachineLimitExceededResponse(parsedOutput, context);
-        case "StateMachineTypeNotSupported":
-        case "com.amazonaws.sfn#StateMachineTypeNotSupported":
-            throw await deserializeAws_json1_0StateMachineTypeNotSupportedResponse(parsedOutput, context);
-        case "TooManyTags":
-        case "com.amazonaws.sfn#TooManyTags":
-            throw await deserializeAws_json1_0TooManyTagsResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0DeleteActivityCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0DeleteActivityCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0DeleteActivityOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0DeleteActivityCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0DeleteStateMachineCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0DeleteStateMachineCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0DeleteStateMachineOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0DeleteStateMachineCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0DescribeActivityCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0DescribeActivityCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0DescribeActivityOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0DescribeActivityCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ActivityDoesNotExist":
-        case "com.amazonaws.sfn#ActivityDoesNotExist":
-            throw await deserializeAws_json1_0ActivityDoesNotExistResponse(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0DescribeExecutionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0DescribeExecutionCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0DescribeExecutionOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0DescribeExecutionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ExecutionDoesNotExist":
-        case "com.amazonaws.sfn#ExecutionDoesNotExist":
-            throw await deserializeAws_json1_0ExecutionDoesNotExistResponse(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0DescribeStateMachineCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0DescribeStateMachineCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0DescribeStateMachineOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0DescribeStateMachineCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        case "StateMachineDoesNotExist":
-        case "com.amazonaws.sfn#StateMachineDoesNotExist":
-            throw await deserializeAws_json1_0StateMachineDoesNotExistResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0DescribeStateMachineForExecutionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0DescribeStateMachineForExecutionCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0DescribeStateMachineForExecutionOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0DescribeStateMachineForExecutionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ExecutionDoesNotExist":
-        case "com.amazonaws.sfn#ExecutionDoesNotExist":
-            throw await deserializeAws_json1_0ExecutionDoesNotExistResponse(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0GetActivityTaskCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0GetActivityTaskCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0GetActivityTaskOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0GetActivityTaskCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ActivityDoesNotExist":
-        case "com.amazonaws.sfn#ActivityDoesNotExist":
-            throw await deserializeAws_json1_0ActivityDoesNotExistResponse(parsedOutput, context);
-        case "ActivityWorkerLimitExceeded":
-        case "com.amazonaws.sfn#ActivityWorkerLimitExceeded":
-            throw await deserializeAws_json1_0ActivityWorkerLimitExceededResponse(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0GetExecutionHistoryCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0GetExecutionHistoryCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0GetExecutionHistoryOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0GetExecutionHistoryCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ExecutionDoesNotExist":
-        case "com.amazonaws.sfn#ExecutionDoesNotExist":
-            throw await deserializeAws_json1_0ExecutionDoesNotExistResponse(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await deserializeAws_json1_0InvalidTokenResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0ListActivitiesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0ListActivitiesCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0ListActivitiesOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0ListActivitiesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await deserializeAws_json1_0InvalidTokenResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0ListExecutionsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0ListExecutionsCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0ListExecutionsOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0ListExecutionsCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await deserializeAws_json1_0InvalidTokenResponse(parsedOutput, context);
-        case "StateMachineDoesNotExist":
-        case "com.amazonaws.sfn#StateMachineDoesNotExist":
-            throw await deserializeAws_json1_0StateMachineDoesNotExistResponse(parsedOutput, context);
-        case "StateMachineTypeNotSupported":
-        case "com.amazonaws.sfn#StateMachineTypeNotSupported":
-            throw await deserializeAws_json1_0StateMachineTypeNotSupportedResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0ListStateMachinesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0ListStateMachinesCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0ListStateMachinesOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0ListStateMachinesCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await deserializeAws_json1_0InvalidTokenResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0ListTagsForResourceCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0ListTagsForResourceOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0ListTagsForResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        case "ResourceNotFound":
-        case "com.amazonaws.sfn#ResourceNotFound":
-            throw await deserializeAws_json1_0ResourceNotFoundResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0SendTaskFailureCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0SendTaskFailureCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0SendTaskFailureOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0SendTaskFailureCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await deserializeAws_json1_0InvalidTokenResponse(parsedOutput, context);
-        case "TaskDoesNotExist":
-        case "com.amazonaws.sfn#TaskDoesNotExist":
-            throw await deserializeAws_json1_0TaskDoesNotExistResponse(parsedOutput, context);
-        case "TaskTimedOut":
-        case "com.amazonaws.sfn#TaskTimedOut":
-            throw await deserializeAws_json1_0TaskTimedOutResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0SendTaskHeartbeatCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0SendTaskHeartbeatCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0SendTaskHeartbeatOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0SendTaskHeartbeatCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await deserializeAws_json1_0InvalidTokenResponse(parsedOutput, context);
-        case "TaskDoesNotExist":
-        case "com.amazonaws.sfn#TaskDoesNotExist":
-            throw await deserializeAws_json1_0TaskDoesNotExistResponse(parsedOutput, context);
-        case "TaskTimedOut":
-        case "com.amazonaws.sfn#TaskTimedOut":
-            throw await deserializeAws_json1_0TaskTimedOutResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0SendTaskSuccessCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0SendTaskSuccessCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0SendTaskSuccessOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0SendTaskSuccessCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidOutput":
-        case "com.amazonaws.sfn#InvalidOutput":
-            throw await deserializeAws_json1_0InvalidOutputResponse(parsedOutput, context);
-        case "InvalidToken":
-        case "com.amazonaws.sfn#InvalidToken":
-            throw await deserializeAws_json1_0InvalidTokenResponse(parsedOutput, context);
-        case "TaskDoesNotExist":
-        case "com.amazonaws.sfn#TaskDoesNotExist":
-            throw await deserializeAws_json1_0TaskDoesNotExistResponse(parsedOutput, context);
-        case "TaskTimedOut":
-        case "com.amazonaws.sfn#TaskTimedOut":
-            throw await deserializeAws_json1_0TaskTimedOutResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0StartExecutionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0StartExecutionCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0StartExecutionOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0StartExecutionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ExecutionAlreadyExists":
-        case "com.amazonaws.sfn#ExecutionAlreadyExists":
-            throw await deserializeAws_json1_0ExecutionAlreadyExistsResponse(parsedOutput, context);
-        case "ExecutionLimitExceeded":
-        case "com.amazonaws.sfn#ExecutionLimitExceeded":
-            throw await deserializeAws_json1_0ExecutionLimitExceededResponse(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        case "InvalidExecutionInput":
-        case "com.amazonaws.sfn#InvalidExecutionInput":
-            throw await deserializeAws_json1_0InvalidExecutionInputResponse(parsedOutput, context);
-        case "InvalidName":
-        case "com.amazonaws.sfn#InvalidName":
-            throw await deserializeAws_json1_0InvalidNameResponse(parsedOutput, context);
-        case "StateMachineDeleting":
-        case "com.amazonaws.sfn#StateMachineDeleting":
-            throw await deserializeAws_json1_0StateMachineDeletingResponse(parsedOutput, context);
-        case "StateMachineDoesNotExist":
-        case "com.amazonaws.sfn#StateMachineDoesNotExist":
-            throw await deserializeAws_json1_0StateMachineDoesNotExistResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0StartSyncExecutionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0StartSyncExecutionCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0StartSyncExecutionOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0StartSyncExecutionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        case "InvalidExecutionInput":
-        case "com.amazonaws.sfn#InvalidExecutionInput":
-            throw await deserializeAws_json1_0InvalidExecutionInputResponse(parsedOutput, context);
-        case "InvalidName":
-        case "com.amazonaws.sfn#InvalidName":
-            throw await deserializeAws_json1_0InvalidNameResponse(parsedOutput, context);
-        case "StateMachineDeleting":
-        case "com.amazonaws.sfn#StateMachineDeleting":
-            throw await deserializeAws_json1_0StateMachineDeletingResponse(parsedOutput, context);
-        case "StateMachineDoesNotExist":
-        case "com.amazonaws.sfn#StateMachineDoesNotExist":
-            throw await deserializeAws_json1_0StateMachineDoesNotExistResponse(parsedOutput, context);
-        case "StateMachineTypeNotSupported":
-        case "com.amazonaws.sfn#StateMachineTypeNotSupported":
-            throw await deserializeAws_json1_0StateMachineTypeNotSupportedResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0StopExecutionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0StopExecutionCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0StopExecutionOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0StopExecutionCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "ExecutionDoesNotExist":
-        case "com.amazonaws.sfn#ExecutionDoesNotExist":
-            throw await deserializeAws_json1_0ExecutionDoesNotExistResponse(parsedOutput, context);
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0TagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0TagResourceCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0TagResourceOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0TagResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        case "ResourceNotFound":
-        case "com.amazonaws.sfn#ResourceNotFound":
-            throw await deserializeAws_json1_0ResourceNotFoundResponse(parsedOutput, context);
-        case "TooManyTags":
-        case "com.amazonaws.sfn#TooManyTags":
-            throw await deserializeAws_json1_0TooManyTagsResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0UntagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0UntagResourceCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0UntagResourceOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0UntagResourceCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        case "ResourceNotFound":
-        case "com.amazonaws.sfn#ResourceNotFound":
-            throw await deserializeAws_json1_0ResourceNotFoundResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-export const deserializeAws_json1_0UpdateStateMachineCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return deserializeAws_json1_0UpdateStateMachineCommandError(output, context);
-    }
-    const data = await parseBody(output.body, context);
-    let contents = {};
-    contents = deserializeAws_json1_0UpdateStateMachineOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return Promise.resolve(response);
-};
-const deserializeAws_json1_0UpdateStateMachineCommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await parseErrorBody(output.body, context),
-    };
-    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InvalidArn":
-        case "com.amazonaws.sfn#InvalidArn":
-            throw await deserializeAws_json1_0InvalidArnResponse(parsedOutput, context);
-        case "InvalidDefinition":
-        case "com.amazonaws.sfn#InvalidDefinition":
-            throw await deserializeAws_json1_0InvalidDefinitionResponse(parsedOutput, context);
-        case "InvalidLoggingConfiguration":
-        case "com.amazonaws.sfn#InvalidLoggingConfiguration":
-            throw await deserializeAws_json1_0InvalidLoggingConfigurationResponse(parsedOutput, context);
-        case "InvalidTracingConfiguration":
-        case "com.amazonaws.sfn#InvalidTracingConfiguration":
-            throw await deserializeAws_json1_0InvalidTracingConfigurationResponse(parsedOutput, context);
-        case "MissingRequiredParameter":
-        case "com.amazonaws.sfn#MissingRequiredParameter":
-            throw await deserializeAws_json1_0MissingRequiredParameterResponse(parsedOutput, context);
-        case "StateMachineDeleting":
-        case "com.amazonaws.sfn#StateMachineDeleting":
-            throw await deserializeAws_json1_0StateMachineDeletingResponse(parsedOutput, context);
-        case "StateMachineDoesNotExist":
-        case "com.amazonaws.sfn#StateMachineDoesNotExist":
-            throw await deserializeAws_json1_0StateMachineDoesNotExistResponse(parsedOutput, context);
-        default:
-            const parsedBody = parsedOutput.body;
-            throwDefaultError({
-                output,
-                parsedBody,
-                exceptionCtor: __BaseException,
-                errorCode,
-            });
-    }
-};
-const deserializeAws_json1_0ActivityDoesNotExistResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0ActivityDoesNotExist(body, context);
-    const exception = new ActivityDoesNotExist({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0ActivityLimitExceededResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0ActivityLimitExceeded(body, context);
-    const exception = new ActivityLimitExceeded({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0ActivityWorkerLimitExceededResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0ActivityWorkerLimitExceeded(body, context);
-    const exception = new ActivityWorkerLimitExceeded({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0ExecutionAlreadyExistsResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0ExecutionAlreadyExists(body, context);
-    const exception = new ExecutionAlreadyExists({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0ExecutionDoesNotExistResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0ExecutionDoesNotExist(body, context);
-    const exception = new ExecutionDoesNotExist({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0ExecutionLimitExceededResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0ExecutionLimitExceeded(body, context);
-    const exception = new ExecutionLimitExceeded({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0InvalidArnResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0InvalidArn(body, context);
-    const exception = new InvalidArn({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0InvalidDefinitionResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0InvalidDefinition(body, context);
-    const exception = new InvalidDefinition({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0InvalidExecutionInputResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0InvalidExecutionInput(body, context);
-    const exception = new InvalidExecutionInput({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0InvalidLoggingConfigurationResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0InvalidLoggingConfiguration(body, context);
-    const exception = new InvalidLoggingConfiguration({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0InvalidNameResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0InvalidName(body, context);
-    const exception = new InvalidName({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0InvalidOutputResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0InvalidOutput(body, context);
-    const exception = new InvalidOutput({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0InvalidTokenResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0InvalidToken(body, context);
-    const exception = new InvalidToken({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0InvalidTracingConfigurationResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0InvalidTracingConfiguration(body, context);
-    const exception = new InvalidTracingConfiguration({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0MissingRequiredParameterResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0MissingRequiredParameter(body, context);
-    const exception = new MissingRequiredParameter({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0ResourceNotFoundResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0ResourceNotFound(body, context);
-    const exception = new ResourceNotFound({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0StateMachineAlreadyExistsResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0StateMachineAlreadyExists(body, context);
-    const exception = new StateMachineAlreadyExists({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
     });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0StateMachineDeletingResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0StateMachineDeleting(body, context);
-    const exception = new StateMachineDeleting({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
+}); };
+export var serializeAws_json1_0StopExecutionCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.StopExecution",
+        };
+        body = JSON.stringify(serializeAws_json1_0StopExecutionInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0StateMachineDoesNotExistResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0StateMachineDoesNotExist(body, context);
-    const exception = new StateMachineDoesNotExist({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
+}); };
+export var serializeAws_json1_0TagResourceCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.TagResource",
+        };
+        body = JSON.stringify(serializeAws_json1_0TagResourceInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0StateMachineLimitExceededResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0StateMachineLimitExceeded(body, context);
-    const exception = new StateMachineLimitExceeded({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
+}); };
+export var serializeAws_json1_0UntagResourceCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.UntagResource",
+        };
+        body = JSON.stringify(serializeAws_json1_0UntagResourceInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0StateMachineTypeNotSupportedResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0StateMachineTypeNotSupported(body, context);
-    const exception = new StateMachineTypeNotSupported({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
+}); };
+export var serializeAws_json1_0UpdateStateMachineCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-amz-json-1.0",
+            "x-amz-target": "AWSStepFunctions.UpdateStateMachine",
+        };
+        body = JSON.stringify(serializeAws_json1_0UpdateStateMachineInput(input, context));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0TaskDoesNotExistResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0TaskDoesNotExist(body, context);
-    const exception = new TaskDoesNotExist({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
+}); };
+export var deserializeAws_json1_0CreateActivityCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0CreateActivityCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0CreateActivityOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
     });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0TaskTimedOutResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0TaskTimedOut(body, context);
-    const exception = new TaskTimedOut({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
+}); };
+var deserializeAws_json1_0CreateActivityCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ActivityLimitExceeded": return [3, 2];
+                    case "com.amazonaws.sfn#ActivityLimitExceeded": return [3, 2];
+                    case "InvalidName": return [3, 4];
+                    case "com.amazonaws.sfn#InvalidName": return [3, 4];
+                    case "TooManyTags": return [3, 6];
+                    case "com.amazonaws.sfn#TooManyTags": return [3, 6];
+                }
+                return [3, 8];
+            case 2: return [4, deserializeAws_json1_0ActivityLimitExceededResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0InvalidNameResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_json1_0TooManyTagsResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 9;
+            case 9: return [2];
+        }
     });
-    return __decorateServiceException(exception, body);
-};
-const deserializeAws_json1_0TooManyTagsResponse = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = deserializeAws_json1_0TooManyTags(body, context);
-    const exception = new TooManyTags({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
+}); };
+export var deserializeAws_json1_0CreateStateMachineCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0CreateStateMachineCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0CreateStateMachineOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
     });
-    return __decorateServiceException(exception, body);
-};
-const serializeAws_json1_0CloudWatchLogsLogGroup = (input, context) => {
-    return {
-        ...(input.logGroupArn != null && { logGroupArn: input.logGroupArn }),
-    };
+}); };
+var deserializeAws_json1_0CreateStateMachineCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidArn": return [3, 2];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 2];
+                    case "InvalidDefinition": return [3, 4];
+                    case "com.amazonaws.sfn#InvalidDefinition": return [3, 4];
+                    case "InvalidLoggingConfiguration": return [3, 6];
+                    case "com.amazonaws.sfn#InvalidLoggingConfiguration": return [3, 6];
+                    case "InvalidName": return [3, 8];
+                    case "com.amazonaws.sfn#InvalidName": return [3, 8];
+                    case "InvalidTracingConfiguration": return [3, 10];
+                    case "com.amazonaws.sfn#InvalidTracingConfiguration": return [3, 10];
+                    case "StateMachineAlreadyExists": return [3, 12];
+                    case "com.amazonaws.sfn#StateMachineAlreadyExists": return [3, 12];
+                    case "StateMachineDeleting": return [3, 14];
+                    case "com.amazonaws.sfn#StateMachineDeleting": return [3, 14];
+                    case "StateMachineLimitExceeded": return [3, 16];
+                    case "com.amazonaws.sfn#StateMachineLimitExceeded": return [3, 16];
+                    case "StateMachineTypeNotSupported": return [3, 18];
+                    case "com.amazonaws.sfn#StateMachineTypeNotSupported": return [3, 18];
+                    case "TooManyTags": return [3, 20];
+                    case "com.amazonaws.sfn#TooManyTags": return [3, 20];
+                }
+                return [3, 22];
+            case 2: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0InvalidDefinitionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_json1_0InvalidLoggingConfigurationResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_json1_0InvalidNameResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10: return [4, deserializeAws_json1_0InvalidTracingConfigurationResponse(parsedOutput, context)];
+            case 11: throw _d.sent();
+            case 12: return [4, deserializeAws_json1_0StateMachineAlreadyExistsResponse(parsedOutput, context)];
+            case 13: throw _d.sent();
+            case 14: return [4, deserializeAws_json1_0StateMachineDeletingResponse(parsedOutput, context)];
+            case 15: throw _d.sent();
+            case 16: return [4, deserializeAws_json1_0StateMachineLimitExceededResponse(parsedOutput, context)];
+            case 17: throw _d.sent();
+            case 18: return [4, deserializeAws_json1_0StateMachineTypeNotSupportedResponse(parsedOutput, context)];
+            case 19: throw _d.sent();
+            case 20: return [4, deserializeAws_json1_0TooManyTagsResponse(parsedOutput, context)];
+            case 21: throw _d.sent();
+            case 22:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 23;
+            case 23: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0DeleteActivityCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0DeleteActivityCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0DeleteActivityOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0DeleteActivityCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidArn": return [3, 2];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 2];
+                }
+                return [3, 4];
+            case 2: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 5;
+            case 5: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0DeleteStateMachineCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0DeleteStateMachineCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0DeleteStateMachineOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0DeleteStateMachineCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidArn": return [3, 2];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 2];
+                }
+                return [3, 4];
+            case 2: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 5;
+            case 5: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0DescribeActivityCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0DescribeActivityCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0DescribeActivityOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0DescribeActivityCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ActivityDoesNotExist": return [3, 2];
+                    case "com.amazonaws.sfn#ActivityDoesNotExist": return [3, 2];
+                    case "InvalidArn": return [3, 4];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_json1_0ActivityDoesNotExistResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0DescribeExecutionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0DescribeExecutionCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0DescribeExecutionOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0DescribeExecutionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ExecutionDoesNotExist": return [3, 2];
+                    case "com.amazonaws.sfn#ExecutionDoesNotExist": return [3, 2];
+                    case "InvalidArn": return [3, 4];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_json1_0ExecutionDoesNotExistResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0DescribeStateMachineCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0DescribeStateMachineCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0DescribeStateMachineOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0DescribeStateMachineCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidArn": return [3, 2];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 2];
+                    case "StateMachineDoesNotExist": return [3, 4];
+                    case "com.amazonaws.sfn#StateMachineDoesNotExist": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0StateMachineDoesNotExistResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0DescribeStateMachineForExecutionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0DescribeStateMachineForExecutionCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0DescribeStateMachineForExecutionOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0DescribeStateMachineForExecutionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ExecutionDoesNotExist": return [3, 2];
+                    case "com.amazonaws.sfn#ExecutionDoesNotExist": return [3, 2];
+                    case "InvalidArn": return [3, 4];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_json1_0ExecutionDoesNotExistResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0GetActivityTaskCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0GetActivityTaskCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0GetActivityTaskOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0GetActivityTaskCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ActivityDoesNotExist": return [3, 2];
+                    case "com.amazonaws.sfn#ActivityDoesNotExist": return [3, 2];
+                    case "ActivityWorkerLimitExceeded": return [3, 4];
+                    case "com.amazonaws.sfn#ActivityWorkerLimitExceeded": return [3, 4];
+                    case "InvalidArn": return [3, 6];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 6];
+                }
+                return [3, 8];
+            case 2: return [4, deserializeAws_json1_0ActivityDoesNotExistResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0ActivityWorkerLimitExceededResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 9;
+            case 9: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0GetExecutionHistoryCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0GetExecutionHistoryCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0GetExecutionHistoryOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0GetExecutionHistoryCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ExecutionDoesNotExist": return [3, 2];
+                    case "com.amazonaws.sfn#ExecutionDoesNotExist": return [3, 2];
+                    case "InvalidArn": return [3, 4];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 4];
+                    case "InvalidToken": return [3, 6];
+                    case "com.amazonaws.sfn#InvalidToken": return [3, 6];
+                }
+                return [3, 8];
+            case 2: return [4, deserializeAws_json1_0ExecutionDoesNotExistResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_json1_0InvalidTokenResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 9;
+            case 9: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0ListActivitiesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0ListActivitiesCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0ListActivitiesOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0ListActivitiesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidToken": return [3, 2];
+                    case "com.amazonaws.sfn#InvalidToken": return [3, 2];
+                }
+                return [3, 4];
+            case 2: return [4, deserializeAws_json1_0InvalidTokenResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 5;
+            case 5: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0ListExecutionsCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0ListExecutionsCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0ListExecutionsOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0ListExecutionsCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidArn": return [3, 2];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 2];
+                    case "InvalidToken": return [3, 4];
+                    case "com.amazonaws.sfn#InvalidToken": return [3, 4];
+                    case "StateMachineDoesNotExist": return [3, 6];
+                    case "com.amazonaws.sfn#StateMachineDoesNotExist": return [3, 6];
+                    case "StateMachineTypeNotSupported": return [3, 8];
+                    case "com.amazonaws.sfn#StateMachineTypeNotSupported": return [3, 8];
+                }
+                return [3, 10];
+            case 2: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0InvalidTokenResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_json1_0StateMachineDoesNotExistResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_json1_0StateMachineTypeNotSupportedResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 11;
+            case 11: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0ListStateMachinesCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0ListStateMachinesCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0ListStateMachinesOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0ListStateMachinesCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidToken": return [3, 2];
+                    case "com.amazonaws.sfn#InvalidToken": return [3, 2];
+                }
+                return [3, 4];
+            case 2: return [4, deserializeAws_json1_0InvalidTokenResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 5;
+            case 5: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0ListTagsForResourceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0ListTagsForResourceCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0ListTagsForResourceOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0ListTagsForResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidArn": return [3, 2];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 2];
+                    case "ResourceNotFound": return [3, 4];
+                    case "com.amazonaws.sfn#ResourceNotFound": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0ResourceNotFoundResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0SendTaskFailureCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0SendTaskFailureCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0SendTaskFailureOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0SendTaskFailureCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidToken": return [3, 2];
+                    case "com.amazonaws.sfn#InvalidToken": return [3, 2];
+                    case "TaskDoesNotExist": return [3, 4];
+                    case "com.amazonaws.sfn#TaskDoesNotExist": return [3, 4];
+                    case "TaskTimedOut": return [3, 6];
+                    case "com.amazonaws.sfn#TaskTimedOut": return [3, 6];
+                }
+                return [3, 8];
+            case 2: return [4, deserializeAws_json1_0InvalidTokenResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0TaskDoesNotExistResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_json1_0TaskTimedOutResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 9;
+            case 9: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0SendTaskHeartbeatCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0SendTaskHeartbeatCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0SendTaskHeartbeatOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0SendTaskHeartbeatCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidToken": return [3, 2];
+                    case "com.amazonaws.sfn#InvalidToken": return [3, 2];
+                    case "TaskDoesNotExist": return [3, 4];
+                    case "com.amazonaws.sfn#TaskDoesNotExist": return [3, 4];
+                    case "TaskTimedOut": return [3, 6];
+                    case "com.amazonaws.sfn#TaskTimedOut": return [3, 6];
+                }
+                return [3, 8];
+            case 2: return [4, deserializeAws_json1_0InvalidTokenResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0TaskDoesNotExistResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_json1_0TaskTimedOutResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 9;
+            case 9: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0SendTaskSuccessCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0SendTaskSuccessCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0SendTaskSuccessOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0SendTaskSuccessCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidOutput": return [3, 2];
+                    case "com.amazonaws.sfn#InvalidOutput": return [3, 2];
+                    case "InvalidToken": return [3, 4];
+                    case "com.amazonaws.sfn#InvalidToken": return [3, 4];
+                    case "TaskDoesNotExist": return [3, 6];
+                    case "com.amazonaws.sfn#TaskDoesNotExist": return [3, 6];
+                    case "TaskTimedOut": return [3, 8];
+                    case "com.amazonaws.sfn#TaskTimedOut": return [3, 8];
+                }
+                return [3, 10];
+            case 2: return [4, deserializeAws_json1_0InvalidOutputResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0InvalidTokenResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_json1_0TaskDoesNotExistResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_json1_0TaskTimedOutResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 11;
+            case 11: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0StartExecutionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0StartExecutionCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0StartExecutionOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0StartExecutionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ExecutionAlreadyExists": return [3, 2];
+                    case "com.amazonaws.sfn#ExecutionAlreadyExists": return [3, 2];
+                    case "ExecutionLimitExceeded": return [3, 4];
+                    case "com.amazonaws.sfn#ExecutionLimitExceeded": return [3, 4];
+                    case "InvalidArn": return [3, 6];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 6];
+                    case "InvalidExecutionInput": return [3, 8];
+                    case "com.amazonaws.sfn#InvalidExecutionInput": return [3, 8];
+                    case "InvalidName": return [3, 10];
+                    case "com.amazonaws.sfn#InvalidName": return [3, 10];
+                    case "StateMachineDeleting": return [3, 12];
+                    case "com.amazonaws.sfn#StateMachineDeleting": return [3, 12];
+                    case "StateMachineDoesNotExist": return [3, 14];
+                    case "com.amazonaws.sfn#StateMachineDoesNotExist": return [3, 14];
+                }
+                return [3, 16];
+            case 2: return [4, deserializeAws_json1_0ExecutionAlreadyExistsResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0ExecutionLimitExceededResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_json1_0InvalidExecutionInputResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10: return [4, deserializeAws_json1_0InvalidNameResponse(parsedOutput, context)];
+            case 11: throw _d.sent();
+            case 12: return [4, deserializeAws_json1_0StateMachineDeletingResponse(parsedOutput, context)];
+            case 13: throw _d.sent();
+            case 14: return [4, deserializeAws_json1_0StateMachineDoesNotExistResponse(parsedOutput, context)];
+            case 15: throw _d.sent();
+            case 16:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 17;
+            case 17: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0StartSyncExecutionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0StartSyncExecutionCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0StartSyncExecutionOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0StartSyncExecutionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidArn": return [3, 2];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 2];
+                    case "InvalidExecutionInput": return [3, 4];
+                    case "com.amazonaws.sfn#InvalidExecutionInput": return [3, 4];
+                    case "InvalidName": return [3, 6];
+                    case "com.amazonaws.sfn#InvalidName": return [3, 6];
+                    case "StateMachineDeleting": return [3, 8];
+                    case "com.amazonaws.sfn#StateMachineDeleting": return [3, 8];
+                    case "StateMachineDoesNotExist": return [3, 10];
+                    case "com.amazonaws.sfn#StateMachineDoesNotExist": return [3, 10];
+                    case "StateMachineTypeNotSupported": return [3, 12];
+                    case "com.amazonaws.sfn#StateMachineTypeNotSupported": return [3, 12];
+                }
+                return [3, 14];
+            case 2: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0InvalidExecutionInputResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_json1_0InvalidNameResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_json1_0StateMachineDeletingResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10: return [4, deserializeAws_json1_0StateMachineDoesNotExistResponse(parsedOutput, context)];
+            case 11: throw _d.sent();
+            case 12: return [4, deserializeAws_json1_0StateMachineTypeNotSupportedResponse(parsedOutput, context)];
+            case 13: throw _d.sent();
+            case 14:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 15;
+            case 15: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0StopExecutionCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0StopExecutionCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0StopExecutionOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0StopExecutionCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ExecutionDoesNotExist": return [3, 2];
+                    case "com.amazonaws.sfn#ExecutionDoesNotExist": return [3, 2];
+                    case "InvalidArn": return [3, 4];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_json1_0ExecutionDoesNotExistResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0TagResourceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0TagResourceCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0TagResourceOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0TagResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidArn": return [3, 2];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 2];
+                    case "ResourceNotFound": return [3, 4];
+                    case "com.amazonaws.sfn#ResourceNotFound": return [3, 4];
+                    case "TooManyTags": return [3, 6];
+                    case "com.amazonaws.sfn#TooManyTags": return [3, 6];
+                }
+                return [3, 8];
+            case 2: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0ResourceNotFoundResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_json1_0TooManyTagsResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 9;
+            case 9: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0UntagResourceCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0UntagResourceCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0UntagResourceOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0UntagResourceCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidArn": return [3, 2];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 2];
+                    case "ResourceNotFound": return [3, 4];
+                    case "com.amazonaws.sfn#ResourceNotFound": return [3, 4];
+                }
+                return [3, 6];
+            case 2: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0ResourceNotFoundResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 7;
+            case 7: return [2];
+        }
+    });
+}); };
+export var deserializeAws_json1_0UpdateStateMachineCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_json1_0UpdateStateMachineCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_json1_0UpdateStateMachineOutput(data, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_json1_0UpdateStateMachineCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, errorCode, _b, parsedBody;
+    var _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _c = {};
+                return [4, parseErrorBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_c.body = _d.sent(), _c)]));
+                errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "InvalidArn": return [3, 2];
+                    case "com.amazonaws.sfn#InvalidArn": return [3, 2];
+                    case "InvalidDefinition": return [3, 4];
+                    case "com.amazonaws.sfn#InvalidDefinition": return [3, 4];
+                    case "InvalidLoggingConfiguration": return [3, 6];
+                    case "com.amazonaws.sfn#InvalidLoggingConfiguration": return [3, 6];
+                    case "InvalidTracingConfiguration": return [3, 8];
+                    case "com.amazonaws.sfn#InvalidTracingConfiguration": return [3, 8];
+                    case "MissingRequiredParameter": return [3, 10];
+                    case "com.amazonaws.sfn#MissingRequiredParameter": return [3, 10];
+                    case "StateMachineDeleting": return [3, 12];
+                    case "com.amazonaws.sfn#StateMachineDeleting": return [3, 12];
+                    case "StateMachineDoesNotExist": return [3, 14];
+                    case "com.amazonaws.sfn#StateMachineDoesNotExist": return [3, 14];
+                }
+                return [3, 16];
+            case 2: return [4, deserializeAws_json1_0InvalidArnResponse(parsedOutput, context)];
+            case 3: throw _d.sent();
+            case 4: return [4, deserializeAws_json1_0InvalidDefinitionResponse(parsedOutput, context)];
+            case 5: throw _d.sent();
+            case 6: return [4, deserializeAws_json1_0InvalidLoggingConfigurationResponse(parsedOutput, context)];
+            case 7: throw _d.sent();
+            case 8: return [4, deserializeAws_json1_0InvalidTracingConfigurationResponse(parsedOutput, context)];
+            case 9: throw _d.sent();
+            case 10: return [4, deserializeAws_json1_0MissingRequiredParameterResponse(parsedOutput, context)];
+            case 11: throw _d.sent();
+            case 12: return [4, deserializeAws_json1_0StateMachineDeletingResponse(parsedOutput, context)];
+            case 13: throw _d.sent();
+            case 14: return [4, deserializeAws_json1_0StateMachineDoesNotExistResponse(parsedOutput, context)];
+            case 15: throw _d.sent();
+            case 16:
+                parsedBody = parsedOutput.body;
+                throwDefaultError({
+                    output: output,
+                    parsedBody: parsedBody,
+                    exceptionCtor: __BaseException,
+                    errorCode: errorCode,
+                });
+                _d.label = 17;
+            case 17: return [2];
+        }
+    });
+}); };
+var deserializeAws_json1_0ActivityDoesNotExistResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0ActivityDoesNotExist(body, context);
+        exception = new ActivityDoesNotExist(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0ActivityLimitExceededResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0ActivityLimitExceeded(body, context);
+        exception = new ActivityLimitExceeded(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0ActivityWorkerLimitExceededResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0ActivityWorkerLimitExceeded(body, context);
+        exception = new ActivityWorkerLimitExceeded(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0ExecutionAlreadyExistsResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0ExecutionAlreadyExists(body, context);
+        exception = new ExecutionAlreadyExists(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0ExecutionDoesNotExistResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0ExecutionDoesNotExist(body, context);
+        exception = new ExecutionDoesNotExist(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0ExecutionLimitExceededResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0ExecutionLimitExceeded(body, context);
+        exception = new ExecutionLimitExceeded(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0InvalidArnResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0InvalidArn(body, context);
+        exception = new InvalidArn(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0InvalidDefinitionResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0InvalidDefinition(body, context);
+        exception = new InvalidDefinition(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0InvalidExecutionInputResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0InvalidExecutionInput(body, context);
+        exception = new InvalidExecutionInput(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0InvalidLoggingConfigurationResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0InvalidLoggingConfiguration(body, context);
+        exception = new InvalidLoggingConfiguration(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0InvalidNameResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0InvalidName(body, context);
+        exception = new InvalidName(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0InvalidOutputResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0InvalidOutput(body, context);
+        exception = new InvalidOutput(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0InvalidTokenResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0InvalidToken(body, context);
+        exception = new InvalidToken(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0InvalidTracingConfigurationResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0InvalidTracingConfiguration(body, context);
+        exception = new InvalidTracingConfiguration(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0MissingRequiredParameterResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0MissingRequiredParameter(body, context);
+        exception = new MissingRequiredParameter(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0ResourceNotFoundResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0ResourceNotFound(body, context);
+        exception = new ResourceNotFound(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0StateMachineAlreadyExistsResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0StateMachineAlreadyExists(body, context);
+        exception = new StateMachineAlreadyExists(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0StateMachineDeletingResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0StateMachineDeleting(body, context);
+        exception = new StateMachineDeleting(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0StateMachineDoesNotExistResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0StateMachineDoesNotExist(body, context);
+        exception = new StateMachineDoesNotExist(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0StateMachineLimitExceededResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0StateMachineLimitExceeded(body, context);
+        exception = new StateMachineLimitExceeded(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0StateMachineTypeNotSupportedResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0StateMachineTypeNotSupported(body, context);
+        exception = new StateMachineTypeNotSupported(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0TaskDoesNotExistResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0TaskDoesNotExist(body, context);
+        exception = new TaskDoesNotExist(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0TaskTimedOutResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0TaskTimedOut(body, context);
+        exception = new TaskTimedOut(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var deserializeAws_json1_0TooManyTagsResponse = function (parsedOutput, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, deserialized, exception;
+    return __generator(this, function (_a) {
+        body = parsedOutput.body;
+        deserialized = deserializeAws_json1_0TooManyTags(body, context);
+        exception = new TooManyTags(__assign({ $metadata: deserializeMetadata(parsedOutput) }, deserialized));
+        return [2, __decorateServiceException(exception, body)];
+    });
+}); };
+var serializeAws_json1_0CloudWatchLogsLogGroup = function (input, context) {
+    return __assign({}, (input.logGroupArn != null && { logGroupArn: input.logGroupArn }));
 };
-const serializeAws_json1_0CreateActivityInput = (input, context) => {
-    return {
-        ...(input.name != null && { name: input.name }),
-        ...(input.tags != null && { tags: serializeAws_json1_0TagList(input.tags, context) }),
-    };
+var serializeAws_json1_0CreateActivityInput = function (input, context) {
+    return __assign(__assign({}, (input.name != null && { name: input.name })), (input.tags != null && { tags: serializeAws_json1_0TagList(input.tags, context) }));
 };
-const serializeAws_json1_0CreateStateMachineInput = (input, context) => {
-    return {
-        ...(input.definition != null && { definition: input.definition }),
-        ...(input.loggingConfiguration != null && {
-            loggingConfiguration: serializeAws_json1_0LoggingConfiguration(input.loggingConfiguration, context),
-        }),
-        ...(input.name != null && { name: input.name }),
-        ...(input.roleArn != null && { roleArn: input.roleArn }),
-        ...(input.tags != null && { tags: serializeAws_json1_0TagList(input.tags, context) }),
-        ...(input.tracingConfiguration != null && {
-            tracingConfiguration: serializeAws_json1_0TracingConfiguration(input.tracingConfiguration, context),
-        }),
-        ...(input.type != null && { type: input.type }),
-    };
+var serializeAws_json1_0CreateStateMachineInput = function (input, context) {
+    return __assign(__assign(__assign(__assign(__assign(__assign(__assign({}, (input.definition != null && { definition: input.definition })), (input.loggingConfiguration != null && {
+        loggingConfiguration: serializeAws_json1_0LoggingConfiguration(input.loggingConfiguration, context),
+    })), (input.name != null && { name: input.name })), (input.roleArn != null && { roleArn: input.roleArn })), (input.tags != null && { tags: serializeAws_json1_0TagList(input.tags, context) })), (input.tracingConfiguration != null && {
+        tracingConfiguration: serializeAws_json1_0TracingConfiguration(input.tracingConfiguration, context),
+    })), (input.type != null && { type: input.type }));
 };
-const serializeAws_json1_0DeleteActivityInput = (input, context) => {
-    return {
-        ...(input.activityArn != null && { activityArn: input.activityArn }),
-    };
+var serializeAws_json1_0DeleteActivityInput = function (input, context) {
+    return __assign({}, (input.activityArn != null && { activityArn: input.activityArn }));
 };
-const serializeAws_json1_0DeleteStateMachineInput = (input, context) => {
-    return {
-        ...(input.stateMachineArn != null && { stateMachineArn: input.stateMachineArn }),
-    };
+var serializeAws_json1_0DeleteStateMachineInput = function (input, context) {
+    return __assign({}, (input.stateMachineArn != null && { stateMachineArn: input.stateMachineArn }));
 };
-const serializeAws_json1_0DescribeActivityInput = (input, context) => {
-    return {
-        ...(input.activityArn != null && { activityArn: input.activityArn }),
-    };
+var serializeAws_json1_0DescribeActivityInput = function (input, context) {
+    return __assign({}, (input.activityArn != null && { activityArn: input.activityArn }));
 };
-const serializeAws_json1_0DescribeExecutionInput = (input, context) => {
-    return {
-        ...(input.executionArn != null && { executionArn: input.executionArn }),
-    };
+var serializeAws_json1_0DescribeExecutionInput = function (input, context) {
+    return __assign({}, (input.executionArn != null && { executionArn: input.executionArn }));
 };
-const serializeAws_json1_0DescribeStateMachineForExecutionInput = (input, context) => {
-    return {
-        ...(input.executionArn != null && { executionArn: input.executionArn }),
-    };
+var serializeAws_json1_0DescribeStateMachineForExecutionInput = function (input, context) {
+    return __assign({}, (input.executionArn != null && { executionArn: input.executionArn }));
 };
-const serializeAws_json1_0DescribeStateMachineInput = (input, context) => {
-    return {
-        ...(input.stateMachineArn != null && { stateMachineArn: input.stateMachineArn }),
-    };
+var serializeAws_json1_0DescribeStateMachineInput = function (input, context) {
+    return __assign({}, (input.stateMachineArn != null && { stateMachineArn: input.stateMachineArn }));
 };
-const serializeAws_json1_0GetActivityTaskInput = (input, context) => {
-    return {
-        ...(input.activityArn != null && { activityArn: input.activityArn }),
-        ...(input.workerName != null && { workerName: input.workerName }),
-    };
+var serializeAws_json1_0GetActivityTaskInput = function (input, context) {
+    return __assign(__assign({}, (input.activityArn != null && { activityArn: input.activityArn })), (input.workerName != null && { workerName: input.workerName }));
 };
-const serializeAws_json1_0GetExecutionHistoryInput = (input, context) => {
-    return {
-        ...(input.executionArn != null && { executionArn: input.executionArn }),
-        ...(input.includeExecutionData != null && { includeExecutionData: input.includeExecutionData }),
-        ...(input.maxResults != null && { maxResults: input.maxResults }),
-        ...(input.nextToken != null && { nextToken: input.nextToken }),
-        ...(input.reverseOrder != null && { reverseOrder: input.reverseOrder }),
-    };
+var serializeAws_json1_0GetExecutionHistoryInput = function (input, context) {
+    return __assign(__assign(__assign(__assign(__assign({}, (input.executionArn != null && { executionArn: input.executionArn })), (input.includeExecutionData != null && { includeExecutionData: input.includeExecutionData })), (input.maxResults != null && { maxResults: input.maxResults })), (input.nextToken != null && { nextToken: input.nextToken })), (input.reverseOrder != null && { reverseOrder: input.reverseOrder }));
 };
-const serializeAws_json1_0ListActivitiesInput = (input, context) => {
-    return {
-        ...(input.maxResults != null && { maxResults: input.maxResults }),
-        ...(input.nextToken != null && { nextToken: input.nextToken }),
-    };
+var serializeAws_json1_0ListActivitiesInput = function (input, context) {
+    return __assign(__assign({}, (input.maxResults != null && { maxResults: input.maxResults })), (input.nextToken != null && { nextToken: input.nextToken }));
 };
-const serializeAws_json1_0ListExecutionsInput = (input, context) => {
-    return {
-        ...(input.maxResults != null && { maxResults: input.maxResults }),
-        ...(input.nextToken != null && { nextToken: input.nextToken }),
-        ...(input.stateMachineArn != null && { stateMachineArn: input.stateMachineArn }),
-        ...(input.statusFilter != null && { statusFilter: input.statusFilter }),
-    };
+var serializeAws_json1_0ListExecutionsInput = function (input, context) {
+    return __assign(__assign(__assign(__assign({}, (input.maxResults != null && { maxResults: input.maxResults })), (input.nextToken != null && { nextToken: input.nextToken })), (input.stateMachineArn != null && { stateMachineArn: input.stateMachineArn })), (input.statusFilter != null && { statusFilter: input.statusFilter }));
 };
-const serializeAws_json1_0ListStateMachinesInput = (input, context) => {
-    return {
-        ...(input.maxResults != null && { maxResults: input.maxResults }),
-        ...(input.nextToken != null && { nextToken: input.nextToken }),
-    };
+var serializeAws_json1_0ListStateMachinesInput = function (input, context) {
+    return __assign(__assign({}, (input.maxResults != null && { maxResults: input.maxResults })), (input.nextToken != null && { nextToken: input.nextToken }));
 };
-const serializeAws_json1_0ListTagsForResourceInput = (input, context) => {
-    return {
-        ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
-    };
+var serializeAws_json1_0ListTagsForResourceInput = function (input, context) {
+    return __assign({}, (input.resourceArn != null && { resourceArn: input.resourceArn }));
 };
-const serializeAws_json1_0LogDestination = (input, context) => {
-    return {
-        ...(input.cloudWatchLogsLogGroup != null && {
-            cloudWatchLogsLogGroup: serializeAws_json1_0CloudWatchLogsLogGroup(input.cloudWatchLogsLogGroup, context),
-        }),
-    };
+var serializeAws_json1_0LogDestination = function (input, context) {
+    return __assign({}, (input.cloudWatchLogsLogGroup != null && {
+        cloudWatchLogsLogGroup: serializeAws_json1_0CloudWatchLogsLogGroup(input.cloudWatchLogsLogGroup, context),
+    }));
 };
-const serializeAws_json1_0LogDestinationList = (input, context) => {
+var serializeAws_json1_0LogDestinationList = function (input, context) {
     return input
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return serializeAws_json1_0LogDestination(entry, context);
     });
 };
-const serializeAws_json1_0LoggingConfiguration = (input, context) => {
-    return {
-        ...(input.destinations != null && {
-            destinations: serializeAws_json1_0LogDestinationList(input.destinations, context),
-        }),
-        ...(input.includeExecutionData != null && { includeExecutionData: input.includeExecutionData }),
-        ...(input.level != null && { level: input.level }),
-    };
+var serializeAws_json1_0LoggingConfiguration = function (input, context) {
+    return __assign(__assign(__assign({}, (input.destinations != null && {
+        destinations: serializeAws_json1_0LogDestinationList(input.destinations, context),
+    })), (input.includeExecutionData != null && { includeExecutionData: input.includeExecutionData })), (input.level != null && { level: input.level }));
 };
-const serializeAws_json1_0SendTaskFailureInput = (input, context) => {
-    return {
-        ...(input.cause != null && { cause: input.cause }),
-        ...(input.error != null && { error: input.error }),
-        ...(input.taskToken != null && { taskToken: input.taskToken }),
-    };
+var serializeAws_json1_0SendTaskFailureInput = function (input, context) {
+    return __assign(__assign(__assign({}, (input.cause != null && { cause: input.cause })), (input.error != null && { error: input.error })), (input.taskToken != null && { taskToken: input.taskToken }));
 };
-const serializeAws_json1_0SendTaskHeartbeatInput = (input, context) => {
-    return {
-        ...(input.taskToken != null && { taskToken: input.taskToken }),
-    };
+var serializeAws_json1_0SendTaskHeartbeatInput = function (input, context) {
+    return __assign({}, (input.taskToken != null && { taskToken: input.taskToken }));
 };
-const serializeAws_json1_0SendTaskSuccessInput = (input, context) => {
-    return {
-        ...(input.output != null && { output: input.output }),
-        ...(input.taskToken != null && { taskToken: input.taskToken }),
-    };
+var serializeAws_json1_0SendTaskSuccessInput = function (input, context) {
+    return __assign(__assign({}, (input.output != null && { output: input.output })), (input.taskToken != null && { taskToken: input.taskToken }));
 };
-const serializeAws_json1_0StartExecutionInput = (input, context) => {
-    return {
-        ...(input.input != null && { input: input.input }),
-        ...(input.name != null && { name: input.name }),
-        ...(input.stateMachineArn != null && { stateMachineArn: input.stateMachineArn }),
-        ...(input.traceHeader != null && { traceHeader: input.traceHeader }),
-    };
+var serializeAws_json1_0StartExecutionInput = function (input, context) {
+    return __assign(__assign(__assign(__assign({}, (input.input != null && { input: input.input })), (input.name != null && { name: input.name })), (input.stateMachineArn != null && { stateMachineArn: input.stateMachineArn })), (input.traceHeader != null && { traceHeader: input.traceHeader }));
 };
-const serializeAws_json1_0StartSyncExecutionInput = (input, context) => {
-    return {
-        ...(input.input != null && { input: input.input }),
-        ...(input.name != null && { name: input.name }),
-        ...(input.stateMachineArn != null && { stateMachineArn: input.stateMachineArn }),
-        ...(input.traceHeader != null && { traceHeader: input.traceHeader }),
-    };
+var serializeAws_json1_0StartSyncExecutionInput = function (input, context) {
+    return __assign(__assign(__assign(__assign({}, (input.input != null && { input: input.input })), (input.name != null && { name: input.name })), (input.stateMachineArn != null && { stateMachineArn: input.stateMachineArn })), (input.traceHeader != null && { traceHeader: input.traceHeader }));
 };
-const serializeAws_json1_0StopExecutionInput = (input, context) => {
-    return {
-        ...(input.cause != null && { cause: input.cause }),
-        ...(input.error != null && { error: input.error }),
-        ...(input.executionArn != null && { executionArn: input.executionArn }),
-    };
+var serializeAws_json1_0StopExecutionInput = function (input, context) {
+    return __assign(__assign(__assign({}, (input.cause != null && { cause: input.cause })), (input.error != null && { error: input.error })), (input.executionArn != null && { executionArn: input.executionArn }));
 };
-const serializeAws_json1_0Tag = (input, context) => {
-    return {
-        ...(input.key != null && { key: input.key }),
-        ...(input.value != null && { value: input.value }),
-    };
+var serializeAws_json1_0Tag = function (input, context) {
+    return __assign(__assign({}, (input.key != null && { key: input.key })), (input.value != null && { value: input.value }));
 };
-const serializeAws_json1_0TagKeyList = (input, context) => {
+var serializeAws_json1_0TagKeyList = function (input, context) {
     return input
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return entry;
     });
 };
-const serializeAws_json1_0TagList = (input, context) => {
+var serializeAws_json1_0TagList = function (input, context) {
     return input
-        .filter((e) => e != null)
-        .map((entry) => {
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         return serializeAws_json1_0Tag(entry, context);
     });
 };
-const serializeAws_json1_0TagResourceInput = (input, context) => {
-    return {
-        ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
-        ...(input.tags != null && { tags: serializeAws_json1_0TagList(input.tags, context) }),
-    };
+var serializeAws_json1_0TagResourceInput = function (input, context) {
+    return __assign(__assign({}, (input.resourceArn != null && { resourceArn: input.resourceArn })), (input.tags != null && { tags: serializeAws_json1_0TagList(input.tags, context) }));
 };
-const serializeAws_json1_0TracingConfiguration = (input, context) => {
-    return {
-        ...(input.enabled != null && { enabled: input.enabled }),
-    };
+var serializeAws_json1_0TracingConfiguration = function (input, context) {
+    return __assign({}, (input.enabled != null && { enabled: input.enabled }));
 };
-const serializeAws_json1_0UntagResourceInput = (input, context) => {
-    return {
-        ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
-        ...(input.tagKeys != null && { tagKeys: serializeAws_json1_0TagKeyList(input.tagKeys, context) }),
-    };
+var serializeAws_json1_0UntagResourceInput = function (input, context) {
+    return __assign(__assign({}, (input.resourceArn != null && { resourceArn: input.resourceArn })), (input.tagKeys != null && { tagKeys: serializeAws_json1_0TagKeyList(input.tagKeys, context) }));
 };
-const serializeAws_json1_0UpdateStateMachineInput = (input, context) => {
-    return {
-        ...(input.definition != null && { definition: input.definition }),
-        ...(input.loggingConfiguration != null && {
-            loggingConfiguration: serializeAws_json1_0LoggingConfiguration(input.loggingConfiguration, context),
-        }),
-        ...(input.roleArn != null && { roleArn: input.roleArn }),
-        ...(input.stateMachineArn != null && { stateMachineArn: input.stateMachineArn }),
-        ...(input.tracingConfiguration != null && {
-            tracingConfiguration: serializeAws_json1_0TracingConfiguration(input.tracingConfiguration, context),
-        }),
-    };
+var serializeAws_json1_0UpdateStateMachineInput = function (input, context) {
+    return __assign(__assign(__assign(__assign(__assign({}, (input.definition != null && { definition: input.definition })), (input.loggingConfiguration != null && {
+        loggingConfiguration: serializeAws_json1_0LoggingConfiguration(input.loggingConfiguration, context),
+    })), (input.roleArn != null && { roleArn: input.roleArn })), (input.stateMachineArn != null && { stateMachineArn: input.stateMachineArn })), (input.tracingConfiguration != null && {
+        tracingConfiguration: serializeAws_json1_0TracingConfiguration(input.tracingConfiguration, context),
+    }));
 };
-const deserializeAws_json1_0ActivityDoesNotExist = (output, context) => {
+var deserializeAws_json1_0ActivityDoesNotExist = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0ActivityFailedEventDetails = (output, context) => {
+var deserializeAws_json1_0ActivityFailedEventDetails = function (output, context) {
     return {
         cause: __expectString(output.cause),
         error: __expectString(output.error),
     };
 };
-const deserializeAws_json1_0ActivityLimitExceeded = (output, context) => {
+var deserializeAws_json1_0ActivityLimitExceeded = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0ActivityList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_json1_0ActivityList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -1581,7 +2005,7 @@ const deserializeAws_json1_0ActivityList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_0ActivityListItem = (output, context) => {
+var deserializeAws_json1_0ActivityListItem = function (output, context) {
     return {
         activityArn: __expectString(output.activityArn),
         creationDate: output.creationDate != null
@@ -1590,7 +2014,7 @@ const deserializeAws_json1_0ActivityListItem = (output, context) => {
         name: __expectString(output.name),
     };
 };
-const deserializeAws_json1_0ActivityScheduledEventDetails = (output, context) => {
+var deserializeAws_json1_0ActivityScheduledEventDetails = function (output, context) {
     return {
         heartbeatInSeconds: __expectLong(output.heartbeatInSeconds),
         input: __expectString(output.input),
@@ -1601,18 +2025,18 @@ const deserializeAws_json1_0ActivityScheduledEventDetails = (output, context) =>
         timeoutInSeconds: __expectLong(output.timeoutInSeconds),
     };
 };
-const deserializeAws_json1_0ActivityScheduleFailedEventDetails = (output, context) => {
+var deserializeAws_json1_0ActivityScheduleFailedEventDetails = function (output, context) {
     return {
         cause: __expectString(output.cause),
         error: __expectString(output.error),
     };
 };
-const deserializeAws_json1_0ActivityStartedEventDetails = (output, context) => {
+var deserializeAws_json1_0ActivityStartedEventDetails = function (output, context) {
     return {
         workerName: __expectString(output.workerName),
     };
 };
-const deserializeAws_json1_0ActivitySucceededEventDetails = (output, context) => {
+var deserializeAws_json1_0ActivitySucceededEventDetails = function (output, context) {
     return {
         output: __expectString(output.output),
         outputDetails: output.outputDetails != null
@@ -1620,34 +2044,34 @@ const deserializeAws_json1_0ActivitySucceededEventDetails = (output, context) =>
             : undefined,
     };
 };
-const deserializeAws_json1_0ActivityTimedOutEventDetails = (output, context) => {
+var deserializeAws_json1_0ActivityTimedOutEventDetails = function (output, context) {
     return {
         cause: __expectString(output.cause),
         error: __expectString(output.error),
     };
 };
-const deserializeAws_json1_0ActivityWorkerLimitExceeded = (output, context) => {
+var deserializeAws_json1_0ActivityWorkerLimitExceeded = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0BillingDetails = (output, context) => {
+var deserializeAws_json1_0BillingDetails = function (output, context) {
     return {
         billedDurationInMilliseconds: __expectLong(output.billedDurationInMilliseconds),
         billedMemoryUsedInMB: __expectLong(output.billedMemoryUsedInMB),
     };
 };
-const deserializeAws_json1_0CloudWatchEventsExecutionDataDetails = (output, context) => {
+var deserializeAws_json1_0CloudWatchEventsExecutionDataDetails = function (output, context) {
     return {
         included: __expectBoolean(output.included),
     };
 };
-const deserializeAws_json1_0CloudWatchLogsLogGroup = (output, context) => {
+var deserializeAws_json1_0CloudWatchLogsLogGroup = function (output, context) {
     return {
         logGroupArn: __expectString(output.logGroupArn),
     };
 };
-const deserializeAws_json1_0CreateActivityOutput = (output, context) => {
+var deserializeAws_json1_0CreateActivityOutput = function (output, context) {
     return {
         activityArn: __expectString(output.activityArn),
         creationDate: output.creationDate != null
@@ -1655,7 +2079,7 @@ const deserializeAws_json1_0CreateActivityOutput = (output, context) => {
             : undefined,
     };
 };
-const deserializeAws_json1_0CreateStateMachineOutput = (output, context) => {
+var deserializeAws_json1_0CreateStateMachineOutput = function (output, context) {
     return {
         creationDate: output.creationDate != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.creationDate)))
@@ -1663,13 +2087,13 @@ const deserializeAws_json1_0CreateStateMachineOutput = (output, context) => {
         stateMachineArn: __expectString(output.stateMachineArn),
     };
 };
-const deserializeAws_json1_0DeleteActivityOutput = (output, context) => {
+var deserializeAws_json1_0DeleteActivityOutput = function (output, context) {
     return {};
 };
-const deserializeAws_json1_0DeleteStateMachineOutput = (output, context) => {
+var deserializeAws_json1_0DeleteStateMachineOutput = function (output, context) {
     return {};
 };
-const deserializeAws_json1_0DescribeActivityOutput = (output, context) => {
+var deserializeAws_json1_0DescribeActivityOutput = function (output, context) {
     return {
         activityArn: __expectString(output.activityArn),
         creationDate: output.creationDate != null
@@ -1678,7 +2102,7 @@ const deserializeAws_json1_0DescribeActivityOutput = (output, context) => {
         name: __expectString(output.name),
     };
 };
-const deserializeAws_json1_0DescribeExecutionOutput = (output, context) => {
+var deserializeAws_json1_0DescribeExecutionOutput = function (output, context) {
     return {
         executionArn: __expectString(output.executionArn),
         input: __expectString(output.input),
@@ -1697,7 +2121,7 @@ const deserializeAws_json1_0DescribeExecutionOutput = (output, context) => {
         traceHeader: __expectString(output.traceHeader),
     };
 };
-const deserializeAws_json1_0DescribeStateMachineForExecutionOutput = (output, context) => {
+var deserializeAws_json1_0DescribeStateMachineForExecutionOutput = function (output, context) {
     return {
         definition: __expectString(output.definition),
         loggingConfiguration: output.loggingConfiguration != null
@@ -1712,7 +2136,7 @@ const deserializeAws_json1_0DescribeStateMachineForExecutionOutput = (output, co
         updateDate: output.updateDate != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updateDate))) : undefined,
     };
 };
-const deserializeAws_json1_0DescribeStateMachineOutput = (output, context) => {
+var deserializeAws_json1_0DescribeStateMachineOutput = function (output, context) {
     return {
         creationDate: output.creationDate != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.creationDate)))
@@ -1731,37 +2155,37 @@ const deserializeAws_json1_0DescribeStateMachineOutput = (output, context) => {
         type: __expectString(output.type),
     };
 };
-const deserializeAws_json1_0ExecutionAbortedEventDetails = (output, context) => {
+var deserializeAws_json1_0ExecutionAbortedEventDetails = function (output, context) {
     return {
         cause: __expectString(output.cause),
         error: __expectString(output.error),
     };
 };
-const deserializeAws_json1_0ExecutionAlreadyExists = (output, context) => {
+var deserializeAws_json1_0ExecutionAlreadyExists = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0ExecutionDoesNotExist = (output, context) => {
+var deserializeAws_json1_0ExecutionDoesNotExist = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0ExecutionFailedEventDetails = (output, context) => {
+var deserializeAws_json1_0ExecutionFailedEventDetails = function (output, context) {
     return {
         cause: __expectString(output.cause),
         error: __expectString(output.error),
     };
 };
-const deserializeAws_json1_0ExecutionLimitExceeded = (output, context) => {
+var deserializeAws_json1_0ExecutionLimitExceeded = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0ExecutionList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_json1_0ExecutionList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -1769,7 +2193,7 @@ const deserializeAws_json1_0ExecutionList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_0ExecutionListItem = (output, context) => {
+var deserializeAws_json1_0ExecutionListItem = function (output, context) {
     return {
         executionArn: __expectString(output.executionArn),
         name: __expectString(output.name),
@@ -1779,7 +2203,7 @@ const deserializeAws_json1_0ExecutionListItem = (output, context) => {
         stopDate: output.stopDate != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.stopDate))) : undefined,
     };
 };
-const deserializeAws_json1_0ExecutionStartedEventDetails = (output, context) => {
+var deserializeAws_json1_0ExecutionStartedEventDetails = function (output, context) {
     return {
         input: __expectString(output.input),
         inputDetails: output.inputDetails != null
@@ -1788,7 +2212,7 @@ const deserializeAws_json1_0ExecutionStartedEventDetails = (output, context) =>
         roleArn: __expectString(output.roleArn),
     };
 };
-const deserializeAws_json1_0ExecutionSucceededEventDetails = (output, context) => {
+var deserializeAws_json1_0ExecutionSucceededEventDetails = function (output, context) {
     return {
         output: __expectString(output.output),
         outputDetails: output.outputDetails != null
@@ -1796,25 +2220,25 @@ const deserializeAws_json1_0ExecutionSucceededEventDetails = (output, context) =
             : undefined,
     };
 };
-const deserializeAws_json1_0ExecutionTimedOutEventDetails = (output, context) => {
+var deserializeAws_json1_0ExecutionTimedOutEventDetails = function (output, context) {
     return {
         cause: __expectString(output.cause),
         error: __expectString(output.error),
     };
 };
-const deserializeAws_json1_0GetActivityTaskOutput = (output, context) => {
+var deserializeAws_json1_0GetActivityTaskOutput = function (output, context) {
     return {
         input: __expectString(output.input),
         taskToken: __expectString(output.taskToken),
     };
 };
-const deserializeAws_json1_0GetExecutionHistoryOutput = (output, context) => {
+var deserializeAws_json1_0GetExecutionHistoryOutput = function (output, context) {
     return {
         events: output.events != null ? deserializeAws_json1_0HistoryEventList(output.events, context) : undefined,
         nextToken: __expectString(output.nextToken),
     };
 };
-const deserializeAws_json1_0HistoryEvent = (output, context) => {
+var deserializeAws_json1_0HistoryEvent = function (output, context) {
     return {
         activityFailedEventDetails: output.activityFailedEventDetails != null
             ? deserializeAws_json1_0ActivityFailedEventDetails(output.activityFailedEventDetails, context)
@@ -1918,15 +2342,15 @@ const deserializeAws_json1_0HistoryEvent = (output, context) => {
         type: __expectString(output.type),
     };
 };
-const deserializeAws_json1_0HistoryEventExecutionDataDetails = (output, context) => {
+var deserializeAws_json1_0HistoryEventExecutionDataDetails = function (output, context) {
     return {
         truncated: __expectBoolean(output.truncated),
     };
 };
-const deserializeAws_json1_0HistoryEventList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_json1_0HistoryEventList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -1934,53 +2358,53 @@ const deserializeAws_json1_0HistoryEventList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_0InvalidArn = (output, context) => {
+var deserializeAws_json1_0InvalidArn = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0InvalidDefinition = (output, context) => {
+var deserializeAws_json1_0InvalidDefinition = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0InvalidExecutionInput = (output, context) => {
+var deserializeAws_json1_0InvalidExecutionInput = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0InvalidLoggingConfiguration = (output, context) => {
+var deserializeAws_json1_0InvalidLoggingConfiguration = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0InvalidName = (output, context) => {
+var deserializeAws_json1_0InvalidName = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0InvalidOutput = (output, context) => {
+var deserializeAws_json1_0InvalidOutput = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0InvalidToken = (output, context) => {
+var deserializeAws_json1_0InvalidToken = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0InvalidTracingConfiguration = (output, context) => {
+var deserializeAws_json1_0InvalidTracingConfiguration = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0LambdaFunctionFailedEventDetails = (output, context) => {
+var deserializeAws_json1_0LambdaFunctionFailedEventDetails = function (output, context) {
     return {
         cause: __expectString(output.cause),
         error: __expectString(output.error),
     };
 };
-const deserializeAws_json1_0LambdaFunctionScheduledEventDetails = (output, context) => {
+var deserializeAws_json1_0LambdaFunctionScheduledEventDetails = function (output, context) {
     return {
         input: __expectString(output.input),
         inputDetails: output.inputDetails != null
@@ -1990,19 +2414,19 @@ const deserializeAws_json1_0LambdaFunctionScheduledEventDetails = (output, conte
         timeoutInSeconds: __expectLong(output.timeoutInSeconds),
     };
 };
-const deserializeAws_json1_0LambdaFunctionScheduleFailedEventDetails = (output, context) => {
+var deserializeAws_json1_0LambdaFunctionScheduleFailedEventDetails = function (output, context) {
     return {
         cause: __expectString(output.cause),
         error: __expectString(output.error),
     };
 };
-const deserializeAws_json1_0LambdaFunctionStartFailedEventDetails = (output, context) => {
+var deserializeAws_json1_0LambdaFunctionStartFailedEventDetails = function (output, context) {
     return {
         cause: __expectString(output.cause),
         error: __expectString(output.error),
     };
 };
-const deserializeAws_json1_0LambdaFunctionSucceededEventDetails = (output, context) => {
+var deserializeAws_json1_0LambdaFunctionSucceededEventDetails = function (output, context) {
     return {
         output: __expectString(output.output),
         outputDetails: output.outputDetails != null
@@ -2010,46 +2434,46 @@ const deserializeAws_json1_0LambdaFunctionSucceededEventDetails = (output, conte
             : undefined,
     };
 };
-const deserializeAws_json1_0LambdaFunctionTimedOutEventDetails = (output, context) => {
+var deserializeAws_json1_0LambdaFunctionTimedOutEventDetails = function (output, context) {
     return {
         cause: __expectString(output.cause),
         error: __expectString(output.error),
     };
 };
-const deserializeAws_json1_0ListActivitiesOutput = (output, context) => {
+var deserializeAws_json1_0ListActivitiesOutput = function (output, context) {
     return {
         activities: output.activities != null ? deserializeAws_json1_0ActivityList(output.activities, context) : undefined,
         nextToken: __expectString(output.nextToken),
     };
 };
-const deserializeAws_json1_0ListExecutionsOutput = (output, context) => {
+var deserializeAws_json1_0ListExecutionsOutput = function (output, context) {
     return {
         executions: output.executions != null ? deserializeAws_json1_0ExecutionList(output.executions, context) : undefined,
         nextToken: __expectString(output.nextToken),
     };
 };
-const deserializeAws_json1_0ListStateMachinesOutput = (output, context) => {
+var deserializeAws_json1_0ListStateMachinesOutput = function (output, context) {
     return {
         nextToken: __expectString(output.nextToken),
         stateMachines: output.stateMachines != null ? deserializeAws_json1_0StateMachineList(output.stateMachines, context) : undefined,
     };
 };
-const deserializeAws_json1_0ListTagsForResourceOutput = (output, context) => {
+var deserializeAws_json1_0ListTagsForResourceOutput = function (output, context) {
     return {
         tags: output.tags != null ? deserializeAws_json1_0TagList(output.tags, context) : undefined,
     };
 };
-const deserializeAws_json1_0LogDestination = (output, context) => {
+var deserializeAws_json1_0LogDestination = function (output, context) {
     return {
         cloudWatchLogsLogGroup: output.cloudWatchLogsLogGroup != null
             ? deserializeAws_json1_0CloudWatchLogsLogGroup(output.cloudWatchLogsLogGroup, context)
             : undefined,
     };
 };
-const deserializeAws_json1_0LogDestinationList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_json1_0LogDestinationList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -2057,51 +2481,51 @@ const deserializeAws_json1_0LogDestinationList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_0LoggingConfiguration = (output, context) => {
+var deserializeAws_json1_0LoggingConfiguration = function (output, context) {
     return {
         destinations: output.destinations != null ? deserializeAws_json1_0LogDestinationList(output.destinations, context) : undefined,
         includeExecutionData: __expectBoolean(output.includeExecutionData),
         level: __expectString(output.level),
     };
 };
-const deserializeAws_json1_0MapIterationEventDetails = (output, context) => {
+var deserializeAws_json1_0MapIterationEventDetails = function (output, context) {
     return {
         index: __expectInt32(output.index),
         name: __expectString(output.name),
     };
 };
-const deserializeAws_json1_0MapStateStartedEventDetails = (output, context) => {
+var deserializeAws_json1_0MapStateStartedEventDetails = function (output, context) {
     return {
         length: __expectInt32(output.length),
     };
 };
-const deserializeAws_json1_0MissingRequiredParameter = (output, context) => {
+var deserializeAws_json1_0MissingRequiredParameter = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0ResourceNotFound = (output, context) => {
+var deserializeAws_json1_0ResourceNotFound = function (output, context) {
     return {
         message: __expectString(output.message),
         resourceName: __expectString(output.resourceName),
     };
 };
-const deserializeAws_json1_0SendTaskFailureOutput = (output, context) => {
+var deserializeAws_json1_0SendTaskFailureOutput = function (output, context) {
     return {};
 };
-const deserializeAws_json1_0SendTaskHeartbeatOutput = (output, context) => {
+var deserializeAws_json1_0SendTaskHeartbeatOutput = function (output, context) {
     return {};
 };
-const deserializeAws_json1_0SendTaskSuccessOutput = (output, context) => {
+var deserializeAws_json1_0SendTaskSuccessOutput = function (output, context) {
     return {};
 };
-const deserializeAws_json1_0StartExecutionOutput = (output, context) => {
+var deserializeAws_json1_0StartExecutionOutput = function (output, context) {
     return {
         executionArn: __expectString(output.executionArn),
         startDate: output.startDate != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.startDate))) : undefined,
     };
 };
-const deserializeAws_json1_0StartSyncExecutionOutput = (output, context) => {
+var deserializeAws_json1_0StartSyncExecutionOutput = function (output, context) {
     return {
         billingDetails: output.billingDetails != null ? deserializeAws_json1_0BillingDetails(output.billingDetails, context) : undefined,
         cause: __expectString(output.cause),
@@ -2123,7 +2547,7 @@ const deserializeAws_json1_0StartSyncExecutionOutput = (output, context) => {
         traceHeader: __expectString(output.traceHeader),
     };
 };
-const deserializeAws_json1_0StateEnteredEventDetails = (output, context) => {
+var deserializeAws_json1_0StateEnteredEventDetails = function (output, context) {
     return {
         input: __expectString(output.input),
         inputDetails: output.inputDetails != null
@@ -2132,7 +2556,7 @@ const deserializeAws_json1_0StateEnteredEventDetails = (output, context) => {
         name: __expectString(output.name),
     };
 };
-const deserializeAws_json1_0StateExitedEventDetails = (output, context) => {
+var deserializeAws_json1_0StateExitedEventDetails = function (output, context) {
     return {
         name: __expectString(output.name),
         output: __expectString(output.output),
@@ -2141,30 +2565,30 @@ const deserializeAws_json1_0StateExitedEventDetails = (output, context) => {
             : undefined,
     };
 };
-const deserializeAws_json1_0StateMachineAlreadyExists = (output, context) => {
+var deserializeAws_json1_0StateMachineAlreadyExists = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0StateMachineDeleting = (output, context) => {
+var deserializeAws_json1_0StateMachineDeleting = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0StateMachineDoesNotExist = (output, context) => {
+var deserializeAws_json1_0StateMachineDoesNotExist = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0StateMachineLimitExceeded = (output, context) => {
+var deserializeAws_json1_0StateMachineLimitExceeded = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0StateMachineList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_json1_0StateMachineList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -2172,7 +2596,7 @@ const deserializeAws_json1_0StateMachineList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_0StateMachineListItem = (output, context) => {
+var deserializeAws_json1_0StateMachineListItem = function (output, context) {
     return {
         creationDate: output.creationDate != null
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.creationDate)))
@@ -2182,26 +2606,26 @@ const deserializeAws_json1_0StateMachineListItem = (output, context) => {
         type: __expectString(output.type),
     };
 };
-const deserializeAws_json1_0StateMachineTypeNotSupported = (output, context) => {
+var deserializeAws_json1_0StateMachineTypeNotSupported = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0StopExecutionOutput = (output, context) => {
+var deserializeAws_json1_0StopExecutionOutput = function (output, context) {
     return {
         stopDate: output.stopDate != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.stopDate))) : undefined,
     };
 };
-const deserializeAws_json1_0Tag = (output, context) => {
+var deserializeAws_json1_0Tag = function (output, context) {
     return {
         key: __expectString(output.key),
         value: __expectString(output.value),
     };
 };
-const deserializeAws_json1_0TagList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
+var deserializeAws_json1_0TagList = function (output, context) {
+    var retVal = (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
         if (entry === null) {
             return null;
         }
@@ -2209,15 +2633,15 @@ const deserializeAws_json1_0TagList = (output, context) => {
     });
     return retVal;
 };
-const deserializeAws_json1_0TagResourceOutput = (output, context) => {
+var deserializeAws_json1_0TagResourceOutput = function (output, context) {
     return {};
 };
-const deserializeAws_json1_0TaskDoesNotExist = (output, context) => {
+var deserializeAws_json1_0TaskDoesNotExist = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0TaskFailedEventDetails = (output, context) => {
+var deserializeAws_json1_0TaskFailedEventDetails = function (output, context) {
     return {
         cause: __expectString(output.cause),
         error: __expectString(output.error),
@@ -2225,7 +2649,7 @@ const deserializeAws_json1_0TaskFailedEventDetails = (output, context) => {
         resourceType: __expectString(output.resourceType),
     };
 };
-const deserializeAws_json1_0TaskScheduledEventDetails = (output, context) => {
+var deserializeAws_json1_0TaskScheduledEventDetails = function (output, context) {
     return {
         heartbeatInSeconds: __expectLong(output.heartbeatInSeconds),
         parameters: __expectString(output.parameters),
@@ -2235,13 +2659,13 @@ const deserializeAws_json1_0TaskScheduledEventDetails = (output, context) => {
         timeoutInSeconds: __expectLong(output.timeoutInSeconds),
     };
 };
-const deserializeAws_json1_0TaskStartedEventDetails = (output, context) => {
+var deserializeAws_json1_0TaskStartedEventDetails = function (output, context) {
     return {
         resource: __expectString(output.resource),
         resourceType: __expectString(output.resourceType),
     };
 };
-const deserializeAws_json1_0TaskStartFailedEventDetails = (output, context) => {
+var deserializeAws_json1_0TaskStartFailedEventDetails = function (output, context) {
     return {
         cause: __expectString(output.cause),
         error: __expectString(output.error),
@@ -2249,7 +2673,7 @@ const deserializeAws_json1_0TaskStartFailedEventDetails = (output, context) => {
         resourceType: __expectString(output.resourceType),
     };
 };
-const deserializeAws_json1_0TaskSubmitFailedEventDetails = (output, context) => {
+var deserializeAws_json1_0TaskSubmitFailedEventDetails = function (output, context) {
     return {
         cause: __expectString(output.cause),
         error: __expectString(output.error),
@@ -2257,7 +2681,7 @@ const deserializeAws_json1_0TaskSubmitFailedEventDetails = (output, context) =>
         resourceType: __expectString(output.resourceType),
     };
 };
-const deserializeAws_json1_0TaskSubmittedEventDetails = (output, context) => {
+var deserializeAws_json1_0TaskSubmittedEventDetails = function (output, context) {
     return {
         output: __expectString(output.output),
         outputDetails: output.outputDetails != null
@@ -2267,7 +2691,7 @@ const deserializeAws_json1_0TaskSubmittedEventDetails = (output, context) => {
         resourceType: __expectString(output.resourceType),
     };
 };
-const deserializeAws_json1_0TaskSucceededEventDetails = (output, context) => {
+var deserializeAws_json1_0TaskSucceededEventDetails = function (output, context) {
     return {
         output: __expectString(output.output),
         outputDetails: output.outputDetails != null
@@ -2277,12 +2701,12 @@ const deserializeAws_json1_0TaskSucceededEventDetails = (output, context) => {
         resourceType: __expectString(output.resourceType),
     };
 };
-const deserializeAws_json1_0TaskTimedOut = (output, context) => {
+var deserializeAws_json1_0TaskTimedOut = function (output, context) {
     return {
         message: __expectString(output.message),
     };
 };
-const deserializeAws_json1_0TaskTimedOutEventDetails = (output, context) => {
+var deserializeAws_json1_0TaskTimedOutEventDetails = function (output, context) {
     return {
         cause: __expectString(output.cause),
         error: __expectString(output.error),
@@ -2290,71 +2714,94 @@ const deserializeAws_json1_0TaskTimedOutEventDetails = (output, context) => {
         resourceType: __expectString(output.resourceType),
     };
 };
-const deserializeAws_json1_0TooManyTags = (output, context) => {
+var deserializeAws_json1_0TooManyTags = function (output, context) {
     return {
         message: __expectString(output.message),
         resourceName: __expectString(output.resourceName),
     };
 };
-const deserializeAws_json1_0TracingConfiguration = (output, context) => {
+var deserializeAws_json1_0TracingConfiguration = function (output, context) {
     return {
         enabled: __expectBoolean(output.enabled),
     };
 };
-const deserializeAws_json1_0UntagResourceOutput = (output, context) => {
+var deserializeAws_json1_0UntagResourceOutput = function (output, context) {
     return {};
 };
-const deserializeAws_json1_0UpdateStateMachineOutput = (output, context) => {
+var deserializeAws_json1_0UpdateStateMachineOutput = function (output, context) {
     return {
         updateDate: output.updateDate != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updateDate))) : undefined,
     };
 };
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
-const collectBody = (streamBody = new Uint8Array(), context) => {
+var deserializeMetadata = function (output) {
+    var _a, _b;
+    return ({
+        httpStatusCode: output.statusCode,
+        requestId: (_b = (_a = output.headers["x-amzn-requestid"]) !== null && _a !== void 0 ? _a : output.headers["x-amzn-request-id"]) !== null && _b !== void 0 ? _b : output.headers["x-amz-request-id"],
+        extendedRequestId: output.headers["x-amz-id-2"],
+        cfId: output.headers["x-amz-cf-id"],
+    });
+};
+var collectBody = function (streamBody, context) {
+    if (streamBody === void 0) { streamBody = new Uint8Array(); }
     if (streamBody instanceof Uint8Array) {
         return Promise.resolve(streamBody);
     }
     return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
 };
-const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
-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 __HttpRequest(contents);
+var collectBodyString = function (streamBody, context) {
+    return collectBody(streamBody, context).then(function (body) { return context.utf8Encoder(body); });
+};
+var buildHttpRpcRequest = function (context, headers, path, resolvedHostname, body) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, hostname, _b, protocol, port, basePath, contents;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4, context.endpoint()];
+            case 1:
+                _a = _c.sent(), hostname = _a.hostname, _b = _a.protocol, protocol = _b === void 0 ? "https" : _b, port = _a.port, basePath = _a.path;
+                contents = {
+                    protocol: protocol,
+                    hostname: hostname,
+                    port: port,
+                    method: "POST",
+                    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+                    headers: headers,
+                };
+                if (resolvedHostname !== undefined) {
+                    contents.hostname = resolvedHostname;
+                }
+                if (body !== undefined) {
+                    contents.body = body;
+                }
+                return [2, new __HttpRequest(contents)];
+        }
+    });
+}); };
+var parseBody = function (streamBody, context) {
+    return collectBodyString(streamBody, context).then(function (encoded) {
+        if (encoded.length) {
+            return JSON.parse(encoded);
+        }
+        return {};
+    });
 };
-const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
-    if (encoded.length) {
-        return JSON.parse(encoded);
-    }
-    return {};
-});
-const parseErrorBody = async (errorBody, context) => {
-    const value = await parseBody(errorBody, context);
-    value.message = value.message ?? value.Message;
-    return value;
-};
-const loadRestJsonErrorCode = (output, data) => {
-    const findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());
-    const sanitizeErrorCode = (rawValue) => {
-        let cleanValue = rawValue;
+var parseErrorBody = function (errorBody, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var value;
+    var _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4, parseBody(errorBody, context)];
+            case 1:
+                value = _b.sent();
+                value.message = (_a = value.message) !== null && _a !== void 0 ? _a : value.Message;
+                return [2, value];
+        }
+    });
+}); };
+var loadRestJsonErrorCode = function (output, data) {
+    var findKey = function (object, key) { return Object.keys(object).find(function (k) { return k.toLowerCase() === key.toLowerCase(); }); };
+    var sanitizeErrorCode = function (rawValue) {
+        var cleanValue = rawValue;
         if (typeof cleanValue === "number") {
             cleanValue = cleanValue.toString();
         }
@@ -2369,7 +2816,7 @@ const loadRestJsonErrorCode = (output, data) => {
         }
         return cleanValue;
     };
-    const headerKey = findKey(output.headers, "x-amzn-errortype");
+    var headerKey = findKey(output.headers, "x-amzn-errortype");
     if (headerKey !== undefined) {
         return sanitizeErrorCode(output.headers[headerKey]);
     }