@ndlib/ndlib-cdk2 1.0.8 → 1.0.9

package/lib/internal-lambdas/sourceWatcherLambda/src/node_modules/@aws-sdk/client-codepipeline/dist-es/protocols/Aws_json1_1.js

@@ -0,0 +1,4225 @@
+import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
+import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, throwDefaultError, } from "@aws-sdk/smithy-client";
+import { v4 as generateIdempotencyToken } from "uuid";
+import { CodePipelineServiceException as __BaseException } from "../models/CodePipelineServiceException";
+import { ActionNotFoundException, ActionTypeNotFoundException, ApprovalAlreadyCompletedException, ConcurrentModificationException, ConflictException, DuplicatedStopRequestException, InvalidActionDeclarationException, InvalidApprovalTokenException, InvalidArnException, InvalidBlockerDeclarationException, InvalidClientTokenException, InvalidJobException, InvalidJobStateException, InvalidNextTokenException, InvalidNonceException, InvalidStageDeclarationException, InvalidStructureException, InvalidTagsException, InvalidWebhookAuthenticationParametersException, InvalidWebhookFilterPatternException, JobNotFoundException, LimitExceededException, NotLatestPipelineExecutionException, OutputVariablesSizeExceededException, PipelineExecutionNotFoundException, PipelineExecutionNotStoppableException, PipelineNameInUseException, PipelineNotFoundException, PipelineVersionNotFoundException, RequestFailedException, ResourceNotFoundException, StageNotFoundException, StageNotRetryableException, TooManyTagsException, ValidationException, WebhookNotFoundException, } from "../models/models_0";
+export const serializeAws_json1_1AcknowledgeJobCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.AcknowledgeJob",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1AcknowledgeJobInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1AcknowledgeThirdPartyJobCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.AcknowledgeThirdPartyJob",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1AcknowledgeThirdPartyJobInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1CreateCustomActionTypeCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.CreateCustomActionType",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1CreateCustomActionTypeInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1CreatePipelineCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.CreatePipeline",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1CreatePipelineInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1DeleteCustomActionTypeCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.DeleteCustomActionType",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1DeleteCustomActionTypeInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1DeletePipelineCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.DeletePipeline",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1DeletePipelineInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1DeleteWebhookCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.DeleteWebhook",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1DeleteWebhookInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1DeregisterWebhookWithThirdPartyCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.DeregisterWebhookWithThirdParty",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1DeregisterWebhookWithThirdPartyInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1DisableStageTransitionCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.DisableStageTransition",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1DisableStageTransitionInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1EnableStageTransitionCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.EnableStageTransition",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1EnableStageTransitionInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1GetActionTypeCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.GetActionType",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1GetActionTypeInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1GetJobDetailsCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.GetJobDetails",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1GetJobDetailsInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1GetPipelineCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.GetPipeline",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1GetPipelineInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1GetPipelineExecutionCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.GetPipelineExecution",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1GetPipelineExecutionInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1GetPipelineStateCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.GetPipelineState",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1GetPipelineStateInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1GetThirdPartyJobDetailsCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.GetThirdPartyJobDetails",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1GetThirdPartyJobDetailsInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1ListActionExecutionsCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.ListActionExecutions",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1ListActionExecutionsInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1ListActionTypesCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.ListActionTypes",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1ListActionTypesInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1ListPipelineExecutionsCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.ListPipelineExecutions",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1ListPipelineExecutionsInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1ListPipelinesCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.ListPipelines",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1ListPipelinesInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1ListTagsForResourceCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.ListTagsForResource",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1ListTagsForResourceInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1ListWebhooksCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.ListWebhooks",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1ListWebhooksInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1PollForJobsCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.PollForJobs",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1PollForJobsInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1PollForThirdPartyJobsCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.PollForThirdPartyJobs",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1PollForThirdPartyJobsInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1PutActionRevisionCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.PutActionRevision",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1PutActionRevisionInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1PutApprovalResultCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.PutApprovalResult",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1PutApprovalResultInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1PutJobFailureResultCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.PutJobFailureResult",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1PutJobFailureResultInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1PutJobSuccessResultCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.PutJobSuccessResult",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1PutJobSuccessResultInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1PutThirdPartyJobFailureResultCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.PutThirdPartyJobFailureResult",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1PutThirdPartyJobFailureResultInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1PutThirdPartyJobSuccessResultCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.PutThirdPartyJobSuccessResult",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1PutThirdPartyJobSuccessResultInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1PutWebhookCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.PutWebhook",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1PutWebhookInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1RegisterWebhookWithThirdPartyCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.RegisterWebhookWithThirdParty",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1RegisterWebhookWithThirdPartyInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1RetryStageExecutionCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.RetryStageExecution",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1RetryStageExecutionInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1StartPipelineExecutionCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.StartPipelineExecution",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1StartPipelineExecutionInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1StopPipelineExecutionCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.StopPipelineExecution",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1StopPipelineExecutionInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1TagResourceCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.TagResource",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1TagResourceInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1UntagResourceCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.UntagResource",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1UntagResourceInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1UpdateActionTypeCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.UpdateActionType",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1UpdateActionTypeInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_1UpdatePipelineCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": "CodePipeline_20150709.UpdatePipeline",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_1UpdatePipelineInput(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const deserializeAws_json1_1AcknowledgeJobCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1AcknowledgeJobCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1AcknowledgeJobOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1AcknowledgeJobCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidNonceException":
+        case "com.amazonaws.codepipeline#InvalidNonceException":
+            throw await deserializeAws_json1_1InvalidNonceExceptionResponse(parsedOutput, context);
+        case "JobNotFoundException":
+        case "com.amazonaws.codepipeline#JobNotFoundException":
+            throw await deserializeAws_json1_1JobNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1AcknowledgeThirdPartyJobCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1AcknowledgeThirdPartyJobCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1AcknowledgeThirdPartyJobOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1AcknowledgeThirdPartyJobCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidClientTokenException":
+        case "com.amazonaws.codepipeline#InvalidClientTokenException":
+            throw await deserializeAws_json1_1InvalidClientTokenExceptionResponse(parsedOutput, context);
+        case "InvalidNonceException":
+        case "com.amazonaws.codepipeline#InvalidNonceException":
+            throw await deserializeAws_json1_1InvalidNonceExceptionResponse(parsedOutput, context);
+        case "JobNotFoundException":
+        case "com.amazonaws.codepipeline#JobNotFoundException":
+            throw await deserializeAws_json1_1JobNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1CreateCustomActionTypeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1CreateCustomActionTypeCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1CreateCustomActionTypeOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1CreateCustomActionTypeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConcurrentModificationException":
+        case "com.amazonaws.codepipeline#ConcurrentModificationException":
+            throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
+        case "InvalidTagsException":
+        case "com.amazonaws.codepipeline#InvalidTagsException":
+            throw await deserializeAws_json1_1InvalidTagsExceptionResponse(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.codepipeline#LimitExceededException":
+            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+        case "TooManyTagsException":
+        case "com.amazonaws.codepipeline#TooManyTagsException":
+            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1CreatePipelineCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1CreatePipelineCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1CreatePipelineOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1CreatePipelineCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConcurrentModificationException":
+        case "com.amazonaws.codepipeline#ConcurrentModificationException":
+            throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
+        case "InvalidActionDeclarationException":
+        case "com.amazonaws.codepipeline#InvalidActionDeclarationException":
+            throw await deserializeAws_json1_1InvalidActionDeclarationExceptionResponse(parsedOutput, context);
+        case "InvalidBlockerDeclarationException":
+        case "com.amazonaws.codepipeline#InvalidBlockerDeclarationException":
+            throw await deserializeAws_json1_1InvalidBlockerDeclarationExceptionResponse(parsedOutput, context);
+        case "InvalidStageDeclarationException":
+        case "com.amazonaws.codepipeline#InvalidStageDeclarationException":
+            throw await deserializeAws_json1_1InvalidStageDeclarationExceptionResponse(parsedOutput, context);
+        case "InvalidStructureException":
+        case "com.amazonaws.codepipeline#InvalidStructureException":
+            throw await deserializeAws_json1_1InvalidStructureExceptionResponse(parsedOutput, context);
+        case "InvalidTagsException":
+        case "com.amazonaws.codepipeline#InvalidTagsException":
+            throw await deserializeAws_json1_1InvalidTagsExceptionResponse(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.codepipeline#LimitExceededException":
+            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+        case "PipelineNameInUseException":
+        case "com.amazonaws.codepipeline#PipelineNameInUseException":
+            throw await deserializeAws_json1_1PipelineNameInUseExceptionResponse(parsedOutput, context);
+        case "TooManyTagsException":
+        case "com.amazonaws.codepipeline#TooManyTagsException":
+            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1DeleteCustomActionTypeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1DeleteCustomActionTypeCommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1DeleteCustomActionTypeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConcurrentModificationException":
+        case "com.amazonaws.codepipeline#ConcurrentModificationException":
+            throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1DeletePipelineCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1DeletePipelineCommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1DeletePipelineCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConcurrentModificationException":
+        case "com.amazonaws.codepipeline#ConcurrentModificationException":
+            throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1DeleteWebhookCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1DeleteWebhookCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1DeleteWebhookOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1DeleteWebhookCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConcurrentModificationException":
+        case "com.amazonaws.codepipeline#ConcurrentModificationException":
+            throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1DeregisterWebhookWithThirdPartyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1DeregisterWebhookWithThirdPartyCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1DeregisterWebhookWithThirdPartyOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1DeregisterWebhookWithThirdPartyCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        case "WebhookNotFoundException":
+        case "com.amazonaws.codepipeline#WebhookNotFoundException":
+            throw await deserializeAws_json1_1WebhookNotFoundExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1DisableStageTransitionCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1DisableStageTransitionCommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1DisableStageTransitionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "PipelineNotFoundException":
+        case "com.amazonaws.codepipeline#PipelineNotFoundException":
+            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+        case "StageNotFoundException":
+        case "com.amazonaws.codepipeline#StageNotFoundException":
+            throw await deserializeAws_json1_1StageNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1EnableStageTransitionCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1EnableStageTransitionCommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1EnableStageTransitionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "PipelineNotFoundException":
+        case "com.amazonaws.codepipeline#PipelineNotFoundException":
+            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+        case "StageNotFoundException":
+        case "com.amazonaws.codepipeline#StageNotFoundException":
+            throw await deserializeAws_json1_1StageNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1GetActionTypeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1GetActionTypeCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1GetActionTypeOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1GetActionTypeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ActionTypeNotFoundException":
+        case "com.amazonaws.codepipeline#ActionTypeNotFoundException":
+            throw await deserializeAws_json1_1ActionTypeNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1GetJobDetailsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1GetJobDetailsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1GetJobDetailsOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1GetJobDetailsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "JobNotFoundException":
+        case "com.amazonaws.codepipeline#JobNotFoundException":
+            throw await deserializeAws_json1_1JobNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1GetPipelineCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1GetPipelineCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1GetPipelineOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1GetPipelineCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "PipelineNotFoundException":
+        case "com.amazonaws.codepipeline#PipelineNotFoundException":
+            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+        case "PipelineVersionNotFoundException":
+        case "com.amazonaws.codepipeline#PipelineVersionNotFoundException":
+            throw await deserializeAws_json1_1PipelineVersionNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1GetPipelineExecutionCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1GetPipelineExecutionCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1GetPipelineExecutionOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1GetPipelineExecutionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "PipelineExecutionNotFoundException":
+        case "com.amazonaws.codepipeline#PipelineExecutionNotFoundException":
+            throw await deserializeAws_json1_1PipelineExecutionNotFoundExceptionResponse(parsedOutput, context);
+        case "PipelineNotFoundException":
+        case "com.amazonaws.codepipeline#PipelineNotFoundException":
+            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1GetPipelineStateCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1GetPipelineStateCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1GetPipelineStateOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1GetPipelineStateCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "PipelineNotFoundException":
+        case "com.amazonaws.codepipeline#PipelineNotFoundException":
+            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1GetThirdPartyJobDetailsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1GetThirdPartyJobDetailsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1GetThirdPartyJobDetailsOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1GetThirdPartyJobDetailsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidClientTokenException":
+        case "com.amazonaws.codepipeline#InvalidClientTokenException":
+            throw await deserializeAws_json1_1InvalidClientTokenExceptionResponse(parsedOutput, context);
+        case "InvalidJobException":
+        case "com.amazonaws.codepipeline#InvalidJobException":
+            throw await deserializeAws_json1_1InvalidJobExceptionResponse(parsedOutput, context);
+        case "JobNotFoundException":
+        case "com.amazonaws.codepipeline#JobNotFoundException":
+            throw await deserializeAws_json1_1JobNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1ListActionExecutionsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1ListActionExecutionsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1ListActionExecutionsOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1ListActionExecutionsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidNextTokenException":
+        case "com.amazonaws.codepipeline#InvalidNextTokenException":
+            throw await deserializeAws_json1_1InvalidNextTokenExceptionResponse(parsedOutput, context);
+        case "PipelineExecutionNotFoundException":
+        case "com.amazonaws.codepipeline#PipelineExecutionNotFoundException":
+            throw await deserializeAws_json1_1PipelineExecutionNotFoundExceptionResponse(parsedOutput, context);
+        case "PipelineNotFoundException":
+        case "com.amazonaws.codepipeline#PipelineNotFoundException":
+            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1ListActionTypesCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1ListActionTypesCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1ListActionTypesOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1ListActionTypesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidNextTokenException":
+        case "com.amazonaws.codepipeline#InvalidNextTokenException":
+            throw await deserializeAws_json1_1InvalidNextTokenExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1ListPipelineExecutionsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1ListPipelineExecutionsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1ListPipelineExecutionsOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1ListPipelineExecutionsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidNextTokenException":
+        case "com.amazonaws.codepipeline#InvalidNextTokenException":
+            throw await deserializeAws_json1_1InvalidNextTokenExceptionResponse(parsedOutput, context);
+        case "PipelineNotFoundException":
+        case "com.amazonaws.codepipeline#PipelineNotFoundException":
+            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1ListPipelinesCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1ListPipelinesCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1ListPipelinesOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1ListPipelinesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidNextTokenException":
+        case "com.amazonaws.codepipeline#InvalidNextTokenException":
+            throw await deserializeAws_json1_1InvalidNextTokenExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1ListTagsForResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1ListTagsForResourceCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1ListTagsForResourceOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1ListTagsForResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidArnException":
+        case "com.amazonaws.codepipeline#InvalidArnException":
+            throw await deserializeAws_json1_1InvalidArnExceptionResponse(parsedOutput, context);
+        case "InvalidNextTokenException":
+        case "com.amazonaws.codepipeline#InvalidNextTokenException":
+            throw await deserializeAws_json1_1InvalidNextTokenExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.codepipeline#ResourceNotFoundException":
+            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1ListWebhooksCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1ListWebhooksCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1ListWebhooksOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1ListWebhooksCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidNextTokenException":
+        case "com.amazonaws.codepipeline#InvalidNextTokenException":
+            throw await deserializeAws_json1_1InvalidNextTokenExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1PollForJobsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1PollForJobsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1PollForJobsOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1PollForJobsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ActionTypeNotFoundException":
+        case "com.amazonaws.codepipeline#ActionTypeNotFoundException":
+            throw await deserializeAws_json1_1ActionTypeNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1PollForThirdPartyJobsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1PollForThirdPartyJobsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1PollForThirdPartyJobsOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1PollForThirdPartyJobsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ActionTypeNotFoundException":
+        case "com.amazonaws.codepipeline#ActionTypeNotFoundException":
+            throw await deserializeAws_json1_1ActionTypeNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1PutActionRevisionCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1PutActionRevisionCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1PutActionRevisionOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1PutActionRevisionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ActionNotFoundException":
+        case "com.amazonaws.codepipeline#ActionNotFoundException":
+            throw await deserializeAws_json1_1ActionNotFoundExceptionResponse(parsedOutput, context);
+        case "PipelineNotFoundException":
+        case "com.amazonaws.codepipeline#PipelineNotFoundException":
+            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+        case "StageNotFoundException":
+        case "com.amazonaws.codepipeline#StageNotFoundException":
+            throw await deserializeAws_json1_1StageNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1PutApprovalResultCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1PutApprovalResultCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1PutApprovalResultOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1PutApprovalResultCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ActionNotFoundException":
+        case "com.amazonaws.codepipeline#ActionNotFoundException":
+            throw await deserializeAws_json1_1ActionNotFoundExceptionResponse(parsedOutput, context);
+        case "ApprovalAlreadyCompletedException":
+        case "com.amazonaws.codepipeline#ApprovalAlreadyCompletedException":
+            throw await deserializeAws_json1_1ApprovalAlreadyCompletedExceptionResponse(parsedOutput, context);
+        case "InvalidApprovalTokenException":
+        case "com.amazonaws.codepipeline#InvalidApprovalTokenException":
+            throw await deserializeAws_json1_1InvalidApprovalTokenExceptionResponse(parsedOutput, context);
+        case "PipelineNotFoundException":
+        case "com.amazonaws.codepipeline#PipelineNotFoundException":
+            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+        case "StageNotFoundException":
+        case "com.amazonaws.codepipeline#StageNotFoundException":
+            throw await deserializeAws_json1_1StageNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1PutJobFailureResultCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1PutJobFailureResultCommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1PutJobFailureResultCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidJobStateException":
+        case "com.amazonaws.codepipeline#InvalidJobStateException":
+            throw await deserializeAws_json1_1InvalidJobStateExceptionResponse(parsedOutput, context);
+        case "JobNotFoundException":
+        case "com.amazonaws.codepipeline#JobNotFoundException":
+            throw await deserializeAws_json1_1JobNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1PutJobSuccessResultCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1PutJobSuccessResultCommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1PutJobSuccessResultCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidJobStateException":
+        case "com.amazonaws.codepipeline#InvalidJobStateException":
+            throw await deserializeAws_json1_1InvalidJobStateExceptionResponse(parsedOutput, context);
+        case "JobNotFoundException":
+        case "com.amazonaws.codepipeline#JobNotFoundException":
+            throw await deserializeAws_json1_1JobNotFoundExceptionResponse(parsedOutput, context);
+        case "OutputVariablesSizeExceededException":
+        case "com.amazonaws.codepipeline#OutputVariablesSizeExceededException":
+            throw await deserializeAws_json1_1OutputVariablesSizeExceededExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1PutThirdPartyJobFailureResultCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1PutThirdPartyJobFailureResultCommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1PutThirdPartyJobFailureResultCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidClientTokenException":
+        case "com.amazonaws.codepipeline#InvalidClientTokenException":
+            throw await deserializeAws_json1_1InvalidClientTokenExceptionResponse(parsedOutput, context);
+        case "InvalidJobStateException":
+        case "com.amazonaws.codepipeline#InvalidJobStateException":
+            throw await deserializeAws_json1_1InvalidJobStateExceptionResponse(parsedOutput, context);
+        case "JobNotFoundException":
+        case "com.amazonaws.codepipeline#JobNotFoundException":
+            throw await deserializeAws_json1_1JobNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1PutThirdPartyJobSuccessResultCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1PutThirdPartyJobSuccessResultCommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1PutThirdPartyJobSuccessResultCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidClientTokenException":
+        case "com.amazonaws.codepipeline#InvalidClientTokenException":
+            throw await deserializeAws_json1_1InvalidClientTokenExceptionResponse(parsedOutput, context);
+        case "InvalidJobStateException":
+        case "com.amazonaws.codepipeline#InvalidJobStateException":
+            throw await deserializeAws_json1_1InvalidJobStateExceptionResponse(parsedOutput, context);
+        case "JobNotFoundException":
+        case "com.amazonaws.codepipeline#JobNotFoundException":
+            throw await deserializeAws_json1_1JobNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1PutWebhookCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1PutWebhookCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1PutWebhookOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1PutWebhookCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConcurrentModificationException":
+        case "com.amazonaws.codepipeline#ConcurrentModificationException":
+            throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
+        case "InvalidTagsException":
+        case "com.amazonaws.codepipeline#InvalidTagsException":
+            throw await deserializeAws_json1_1InvalidTagsExceptionResponse(parsedOutput, context);
+        case "InvalidWebhookAuthenticationParametersException":
+        case "com.amazonaws.codepipeline#InvalidWebhookAuthenticationParametersException":
+            throw await deserializeAws_json1_1InvalidWebhookAuthenticationParametersExceptionResponse(parsedOutput, context);
+        case "InvalidWebhookFilterPatternException":
+        case "com.amazonaws.codepipeline#InvalidWebhookFilterPatternException":
+            throw await deserializeAws_json1_1InvalidWebhookFilterPatternExceptionResponse(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.codepipeline#LimitExceededException":
+            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+        case "PipelineNotFoundException":
+        case "com.amazonaws.codepipeline#PipelineNotFoundException":
+            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+        case "TooManyTagsException":
+        case "com.amazonaws.codepipeline#TooManyTagsException":
+            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1RegisterWebhookWithThirdPartyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1RegisterWebhookWithThirdPartyCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1RegisterWebhookWithThirdPartyOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1RegisterWebhookWithThirdPartyCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        case "WebhookNotFoundException":
+        case "com.amazonaws.codepipeline#WebhookNotFoundException":
+            throw await deserializeAws_json1_1WebhookNotFoundExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1RetryStageExecutionCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1RetryStageExecutionCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1RetryStageExecutionOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1RetryStageExecutionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.codepipeline#ConflictException":
+            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+        case "NotLatestPipelineExecutionException":
+        case "com.amazonaws.codepipeline#NotLatestPipelineExecutionException":
+            throw await deserializeAws_json1_1NotLatestPipelineExecutionExceptionResponse(parsedOutput, context);
+        case "PipelineNotFoundException":
+        case "com.amazonaws.codepipeline#PipelineNotFoundException":
+            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+        case "StageNotFoundException":
+        case "com.amazonaws.codepipeline#StageNotFoundException":
+            throw await deserializeAws_json1_1StageNotFoundExceptionResponse(parsedOutput, context);
+        case "StageNotRetryableException":
+        case "com.amazonaws.codepipeline#StageNotRetryableException":
+            throw await deserializeAws_json1_1StageNotRetryableExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1StartPipelineExecutionCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1StartPipelineExecutionCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1StartPipelineExecutionOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1StartPipelineExecutionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.codepipeline#ConflictException":
+            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+        case "PipelineNotFoundException":
+        case "com.amazonaws.codepipeline#PipelineNotFoundException":
+            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1StopPipelineExecutionCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1StopPipelineExecutionCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1StopPipelineExecutionOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1StopPipelineExecutionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.codepipeline#ConflictException":
+            throw await deserializeAws_json1_1ConflictExceptionResponse(parsedOutput, context);
+        case "DuplicatedStopRequestException":
+        case "com.amazonaws.codepipeline#DuplicatedStopRequestException":
+            throw await deserializeAws_json1_1DuplicatedStopRequestExceptionResponse(parsedOutput, context);
+        case "PipelineExecutionNotStoppableException":
+        case "com.amazonaws.codepipeline#PipelineExecutionNotStoppableException":
+            throw await deserializeAws_json1_1PipelineExecutionNotStoppableExceptionResponse(parsedOutput, context);
+        case "PipelineNotFoundException":
+        case "com.amazonaws.codepipeline#PipelineNotFoundException":
+            throw await deserializeAws_json1_1PipelineNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1TagResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1TagResourceCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1TagResourceOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1TagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConcurrentModificationException":
+        case "com.amazonaws.codepipeline#ConcurrentModificationException":
+            throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
+        case "InvalidArnException":
+        case "com.amazonaws.codepipeline#InvalidArnException":
+            throw await deserializeAws_json1_1InvalidArnExceptionResponse(parsedOutput, context);
+        case "InvalidTagsException":
+        case "com.amazonaws.codepipeline#InvalidTagsException":
+            throw await deserializeAws_json1_1InvalidTagsExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.codepipeline#ResourceNotFoundException":
+            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "TooManyTagsException":
+        case "com.amazonaws.codepipeline#TooManyTagsException":
+            throw await deserializeAws_json1_1TooManyTagsExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1UntagResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1UntagResourceCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1UntagResourceOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1UntagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConcurrentModificationException":
+        case "com.amazonaws.codepipeline#ConcurrentModificationException":
+            throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
+        case "InvalidArnException":
+        case "com.amazonaws.codepipeline#InvalidArnException":
+            throw await deserializeAws_json1_1InvalidArnExceptionResponse(parsedOutput, context);
+        case "InvalidTagsException":
+        case "com.amazonaws.codepipeline#InvalidTagsException":
+            throw await deserializeAws_json1_1InvalidTagsExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.codepipeline#ResourceNotFoundException":
+            throw await deserializeAws_json1_1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1UpdateActionTypeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1UpdateActionTypeCommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1UpdateActionTypeCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ActionTypeNotFoundException":
+        case "com.amazonaws.codepipeline#ActionTypeNotFoundException":
+            throw await deserializeAws_json1_1ActionTypeNotFoundExceptionResponse(parsedOutput, context);
+        case "RequestFailedException":
+        case "com.amazonaws.codepipeline#RequestFailedException":
+            throw await deserializeAws_json1_1RequestFailedExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_1UpdatePipelineCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_1UpdatePipelineCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_1UpdatePipelineOutput(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_1UpdatePipelineCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InvalidActionDeclarationException":
+        case "com.amazonaws.codepipeline#InvalidActionDeclarationException":
+            throw await deserializeAws_json1_1InvalidActionDeclarationExceptionResponse(parsedOutput, context);
+        case "InvalidBlockerDeclarationException":
+        case "com.amazonaws.codepipeline#InvalidBlockerDeclarationException":
+            throw await deserializeAws_json1_1InvalidBlockerDeclarationExceptionResponse(parsedOutput, context);
+        case "InvalidStageDeclarationException":
+        case "com.amazonaws.codepipeline#InvalidStageDeclarationException":
+            throw await deserializeAws_json1_1InvalidStageDeclarationExceptionResponse(parsedOutput, context);
+        case "InvalidStructureException":
+        case "com.amazonaws.codepipeline#InvalidStructureException":
+            throw await deserializeAws_json1_1InvalidStructureExceptionResponse(parsedOutput, context);
+        case "LimitExceededException":
+        case "com.amazonaws.codepipeline#LimitExceededException":
+            throw await deserializeAws_json1_1LimitExceededExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.codepipeline#ValidationException":
+            throw await deserializeAws_json1_1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_json1_1ActionNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1ActionNotFoundException(body, context);
+    const exception = new ActionNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1ActionTypeNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1ActionTypeNotFoundException(body, context);
+    const exception = new ActionTypeNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1ApprovalAlreadyCompletedExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1ApprovalAlreadyCompletedException(body, context);
+    const exception = new ApprovalAlreadyCompletedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1ConcurrentModificationExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1ConcurrentModificationException(body, context);
+    const exception = new ConcurrentModificationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1ConflictExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1ConflictException(body, context);
+    const exception = new ConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1DuplicatedStopRequestExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1DuplicatedStopRequestException(body, context);
+    const exception = new DuplicatedStopRequestException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1InvalidActionDeclarationExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1InvalidActionDeclarationException(body, context);
+    const exception = new InvalidActionDeclarationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1InvalidApprovalTokenExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1InvalidApprovalTokenException(body, context);
+    const exception = new InvalidApprovalTokenException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1InvalidArnExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1InvalidArnException(body, context);
+    const exception = new InvalidArnException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1InvalidBlockerDeclarationExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1InvalidBlockerDeclarationException(body, context);
+    const exception = new InvalidBlockerDeclarationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1InvalidClientTokenExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1InvalidClientTokenException(body, context);
+    const exception = new InvalidClientTokenException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1InvalidJobExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1InvalidJobException(body, context);
+    const exception = new InvalidJobException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1InvalidJobStateExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1InvalidJobStateException(body, context);
+    const exception = new InvalidJobStateException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1InvalidNextTokenExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1InvalidNextTokenException(body, context);
+    const exception = new InvalidNextTokenException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1InvalidNonceExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1InvalidNonceException(body, context);
+    const exception = new InvalidNonceException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1InvalidStageDeclarationExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1InvalidStageDeclarationException(body, context);
+    const exception = new InvalidStageDeclarationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1InvalidStructureExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1InvalidStructureException(body, context);
+    const exception = new InvalidStructureException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1InvalidTagsExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1InvalidTagsException(body, context);
+    const exception = new InvalidTagsException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1InvalidWebhookAuthenticationParametersExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1InvalidWebhookAuthenticationParametersException(body, context);
+    const exception = new InvalidWebhookAuthenticationParametersException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1InvalidWebhookFilterPatternExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1InvalidWebhookFilterPatternException(body, context);
+    const exception = new InvalidWebhookFilterPatternException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1JobNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1JobNotFoundException(body, context);
+    const exception = new JobNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1LimitExceededExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1LimitExceededException(body, context);
+    const exception = new LimitExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1NotLatestPipelineExecutionExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1NotLatestPipelineExecutionException(body, context);
+    const exception = new NotLatestPipelineExecutionException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1OutputVariablesSizeExceededExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1OutputVariablesSizeExceededException(body, context);
+    const exception = new OutputVariablesSizeExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1PipelineExecutionNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1PipelineExecutionNotFoundException(body, context);
+    const exception = new PipelineExecutionNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1PipelineExecutionNotStoppableExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1PipelineExecutionNotStoppableException(body, context);
+    const exception = new PipelineExecutionNotStoppableException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1PipelineNameInUseExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1PipelineNameInUseException(body, context);
+    const exception = new PipelineNameInUseException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1PipelineNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1PipelineNotFoundException(body, context);
+    const exception = new PipelineNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1PipelineVersionNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1PipelineVersionNotFoundException(body, context);
+    const exception = new PipelineVersionNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1RequestFailedExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1RequestFailedException(body, context);
+    const exception = new RequestFailedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1ResourceNotFoundException(body, context);
+    const exception = new ResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1StageNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1StageNotFoundException(body, context);
+    const exception = new StageNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1StageNotRetryableExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1StageNotRetryableException(body, context);
+    const exception = new StageNotRetryableException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1TooManyTagsExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1TooManyTagsException(body, context);
+    const exception = new TooManyTagsException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1ValidationExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1ValidationException(body, context);
+    const exception = new ValidationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_1WebhookNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_1WebhookNotFoundException(body, context);
+    const exception = new WebhookNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const serializeAws_json1_1AcknowledgeJobInput = (input, context) => {
+    return {
+        ...(input.jobId != null && { jobId: input.jobId }),
+        ...(input.nonce != null && { nonce: input.nonce }),
+    };
+};
+const serializeAws_json1_1AcknowledgeThirdPartyJobInput = (input, context) => {
+    return {
+        ...(input.clientToken != null && { clientToken: input.clientToken }),
+        ...(input.jobId != null && { jobId: input.jobId }),
+        ...(input.nonce != null && { nonce: input.nonce }),
+    };
+};
+const serializeAws_json1_1ActionConfigurationMap = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = value;
+        return acc;
+    }, {});
+};
+const serializeAws_json1_1ActionConfigurationProperty = (input, context) => {
+    return {
+        ...(input.description != null && { description: input.description }),
+        ...(input.key != null && { key: input.key }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.queryable != null && { queryable: input.queryable }),
+        ...(input.required != null && { required: input.required }),
+        ...(input.secret != null && { secret: input.secret }),
+        ...(input.type != null && { type: input.type }),
+    };
+};
+const serializeAws_json1_1ActionConfigurationPropertyList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_json1_1ActionConfigurationProperty(entry, context);
+    });
+};
+const serializeAws_json1_1ActionDeclaration = (input, context) => {
+    return {
+        ...(input.actionTypeId != null && { actionTypeId: serializeAws_json1_1ActionTypeId(input.actionTypeId, context) }),
+        ...(input.configuration != null && {
+            configuration: serializeAws_json1_1ActionConfigurationMap(input.configuration, context),
+        }),
+        ...(input.inputArtifacts != null && {
+            inputArtifacts: serializeAws_json1_1InputArtifactList(input.inputArtifacts, context),
+        }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.namespace != null && { namespace: input.namespace }),
+        ...(input.outputArtifacts != null && {
+            outputArtifacts: serializeAws_json1_1OutputArtifactList(input.outputArtifacts, context),
+        }),
+        ...(input.region != null && { region: input.region }),
+        ...(input.roleArn != null && { roleArn: input.roleArn }),
+        ...(input.runOrder != null && { runOrder: input.runOrder }),
+    };
+};
+const serializeAws_json1_1ActionExecutionFilter = (input, context) => {
+    return {
+        ...(input.pipelineExecutionId != null && { pipelineExecutionId: input.pipelineExecutionId }),
+    };
+};
+const serializeAws_json1_1ActionRevision = (input, context) => {
+    return {
+        ...(input.created != null && { created: Math.round(input.created.getTime() / 1000) }),
+        ...(input.revisionChangeId != null && { revisionChangeId: input.revisionChangeId }),
+        ...(input.revisionId != null && { revisionId: input.revisionId }),
+    };
+};
+const serializeAws_json1_1ActionTypeArtifactDetails = (input, context) => {
+    return {
+        ...(input.maximumCount != null && { maximumCount: input.maximumCount }),
+        ...(input.minimumCount != null && { minimumCount: input.minimumCount }),
+    };
+};
+const serializeAws_json1_1ActionTypeDeclaration = (input, context) => {
+    return {
+        ...(input.description != null && { description: input.description }),
+        ...(input.executor != null && { executor: serializeAws_json1_1ActionTypeExecutor(input.executor, context) }),
+        ...(input.id != null && { id: serializeAws_json1_1ActionTypeIdentifier(input.id, context) }),
+        ...(input.inputArtifactDetails != null && {
+            inputArtifactDetails: serializeAws_json1_1ActionTypeArtifactDetails(input.inputArtifactDetails, context),
+        }),
+        ...(input.outputArtifactDetails != null && {
+            outputArtifactDetails: serializeAws_json1_1ActionTypeArtifactDetails(input.outputArtifactDetails, context),
+        }),
+        ...(input.permissions != null && {
+            permissions: serializeAws_json1_1ActionTypePermissions(input.permissions, context),
+        }),
+        ...(input.properties != null && {
+            properties: serializeAws_json1_1ActionTypeProperties(input.properties, context),
+        }),
+        ...(input.urls != null && { urls: serializeAws_json1_1ActionTypeUrls(input.urls, context) }),
+    };
+};
+const serializeAws_json1_1ActionTypeExecutor = (input, context) => {
+    return {
+        ...(input.configuration != null && {
+            configuration: serializeAws_json1_1ExecutorConfiguration(input.configuration, context),
+        }),
+        ...(input.jobTimeout != null && { jobTimeout: input.jobTimeout }),
+        ...(input.policyStatementsTemplate != null && { policyStatementsTemplate: input.policyStatementsTemplate }),
+        ...(input.type != null && { type: input.type }),
+    };
+};
+const serializeAws_json1_1ActionTypeId = (input, context) => {
+    return {
+        ...(input.category != null && { category: input.category }),
+        ...(input.owner != null && { owner: input.owner }),
+        ...(input.provider != null && { provider: input.provider }),
+        ...(input.version != null && { version: input.version }),
+    };
+};
+const serializeAws_json1_1ActionTypeIdentifier = (input, context) => {
+    return {
+        ...(input.category != null && { category: input.category }),
+        ...(input.owner != null && { owner: input.owner }),
+        ...(input.provider != null && { provider: input.provider }),
+        ...(input.version != null && { version: input.version }),
+    };
+};
+const serializeAws_json1_1ActionTypePermissions = (input, context) => {
+    return {
+        ...(input.allowedAccounts != null && {
+            allowedAccounts: serializeAws_json1_1AllowedAccounts(input.allowedAccounts, context),
+        }),
+    };
+};
+const serializeAws_json1_1ActionTypeProperties = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_json1_1ActionTypeProperty(entry, context);
+    });
+};
+const serializeAws_json1_1ActionTypeProperty = (input, context) => {
+    return {
+        ...(input.description != null && { description: input.description }),
+        ...(input.key != null && { key: input.key }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.noEcho != null && { noEcho: input.noEcho }),
+        ...(input.optional != null && { optional: input.optional }),
+        ...(input.queryable != null && { queryable: input.queryable }),
+    };
+};
+const serializeAws_json1_1ActionTypeSettings = (input, context) => {
+    return {
+        ...(input.entityUrlTemplate != null && { entityUrlTemplate: input.entityUrlTemplate }),
+        ...(input.executionUrlTemplate != null && { executionUrlTemplate: input.executionUrlTemplate }),
+        ...(input.revisionUrlTemplate != null && { revisionUrlTemplate: input.revisionUrlTemplate }),
+        ...(input.thirdPartyConfigurationUrl != null && { thirdPartyConfigurationUrl: input.thirdPartyConfigurationUrl }),
+    };
+};
+const serializeAws_json1_1ActionTypeUrls = (input, context) => {
+    return {
+        ...(input.configurationUrl != null && { configurationUrl: input.configurationUrl }),
+        ...(input.entityUrlTemplate != null && { entityUrlTemplate: input.entityUrlTemplate }),
+        ...(input.executionUrlTemplate != null && { executionUrlTemplate: input.executionUrlTemplate }),
+        ...(input.revisionUrlTemplate != null && { revisionUrlTemplate: input.revisionUrlTemplate }),
+    };
+};
+const serializeAws_json1_1AllowedAccounts = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_json1_1ApprovalResult = (input, context) => {
+    return {
+        ...(input.status != null && { status: input.status }),
+        ...(input.summary != null && { summary: input.summary }),
+    };
+};
+const serializeAws_json1_1ArtifactDetails = (input, context) => {
+    return {
+        ...(input.maximumCount != null && { maximumCount: input.maximumCount }),
+        ...(input.minimumCount != null && { minimumCount: input.minimumCount }),
+    };
+};
+const serializeAws_json1_1ArtifactStore = (input, context) => {
+    return {
+        ...(input.encryptionKey != null && {
+            encryptionKey: serializeAws_json1_1EncryptionKey(input.encryptionKey, context),
+        }),
+        ...(input.location != null && { location: input.location }),
+        ...(input.type != null && { type: input.type }),
+    };
+};
+const serializeAws_json1_1ArtifactStoreMap = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = serializeAws_json1_1ArtifactStore(value, context);
+        return acc;
+    }, {});
+};
+const serializeAws_json1_1BlockerDeclaration = (input, context) => {
+    return {
+        ...(input.name != null && { name: input.name }),
+        ...(input.type != null && { type: input.type }),
+    };
+};
+const serializeAws_json1_1CreateCustomActionTypeInput = (input, context) => {
+    return {
+        ...(input.category != null && { category: input.category }),
+        ...(input.configurationProperties != null && {
+            configurationProperties: serializeAws_json1_1ActionConfigurationPropertyList(input.configurationProperties, context),
+        }),
+        ...(input.inputArtifactDetails != null && {
+            inputArtifactDetails: serializeAws_json1_1ArtifactDetails(input.inputArtifactDetails, context),
+        }),
+        ...(input.outputArtifactDetails != null && {
+            outputArtifactDetails: serializeAws_json1_1ArtifactDetails(input.outputArtifactDetails, context),
+        }),
+        ...(input.provider != null && { provider: input.provider }),
+        ...(input.settings != null && { settings: serializeAws_json1_1ActionTypeSettings(input.settings, context) }),
+        ...(input.tags != null && { tags: serializeAws_json1_1TagList(input.tags, context) }),
+        ...(input.version != null && { version: input.version }),
+    };
+};
+const serializeAws_json1_1CreatePipelineInput = (input, context) => {
+    return {
+        ...(input.pipeline != null && { pipeline: serializeAws_json1_1PipelineDeclaration(input.pipeline, context) }),
+        ...(input.tags != null && { tags: serializeAws_json1_1TagList(input.tags, context) }),
+    };
+};
+const serializeAws_json1_1CurrentRevision = (input, context) => {
+    return {
+        ...(input.changeIdentifier != null && { changeIdentifier: input.changeIdentifier }),
+        ...(input.created != null && { created: Math.round(input.created.getTime() / 1000) }),
+        ...(input.revision != null && { revision: input.revision }),
+        ...(input.revisionSummary != null && { revisionSummary: input.revisionSummary }),
+    };
+};
+const serializeAws_json1_1DeleteCustomActionTypeInput = (input, context) => {
+    return {
+        ...(input.category != null && { category: input.category }),
+        ...(input.provider != null && { provider: input.provider }),
+        ...(input.version != null && { version: input.version }),
+    };
+};
+const serializeAws_json1_1DeletePipelineInput = (input, context) => {
+    return {
+        ...(input.name != null && { name: input.name }),
+    };
+};
+const serializeAws_json1_1DeleteWebhookInput = (input, context) => {
+    return {
+        ...(input.name != null && { name: input.name }),
+    };
+};
+const serializeAws_json1_1DeregisterWebhookWithThirdPartyInput = (input, context) => {
+    return {
+        ...(input.webhookName != null && { webhookName: input.webhookName }),
+    };
+};
+const serializeAws_json1_1DisableStageTransitionInput = (input, context) => {
+    return {
+        ...(input.pipelineName != null && { pipelineName: input.pipelineName }),
+        ...(input.reason != null && { reason: input.reason }),
+        ...(input.stageName != null && { stageName: input.stageName }),
+        ...(input.transitionType != null && { transitionType: input.transitionType }),
+    };
+};
+const serializeAws_json1_1EnableStageTransitionInput = (input, context) => {
+    return {
+        ...(input.pipelineName != null && { pipelineName: input.pipelineName }),
+        ...(input.stageName != null && { stageName: input.stageName }),
+        ...(input.transitionType != null && { transitionType: input.transitionType }),
+    };
+};
+const serializeAws_json1_1EncryptionKey = (input, context) => {
+    return {
+        ...(input.id != null && { id: input.id }),
+        ...(input.type != null && { type: input.type }),
+    };
+};
+const serializeAws_json1_1ExecutionDetails = (input, context) => {
+    return {
+        ...(input.externalExecutionId != null && { externalExecutionId: input.externalExecutionId }),
+        ...(input.percentComplete != null && { percentComplete: input.percentComplete }),
+        ...(input.summary != null && { summary: input.summary }),
+    };
+};
+const serializeAws_json1_1ExecutorConfiguration = (input, context) => {
+    return {
+        ...(input.jobWorkerExecutorConfiguration != null && {
+            jobWorkerExecutorConfiguration: serializeAws_json1_1JobWorkerExecutorConfiguration(input.jobWorkerExecutorConfiguration, context),
+        }),
+        ...(input.lambdaExecutorConfiguration != null && {
+            lambdaExecutorConfiguration: serializeAws_json1_1LambdaExecutorConfiguration(input.lambdaExecutorConfiguration, context),
+        }),
+    };
+};
+const serializeAws_json1_1FailureDetails = (input, context) => {
+    return {
+        ...(input.externalExecutionId != null && { externalExecutionId: input.externalExecutionId }),
+        ...(input.message != null && { message: input.message }),
+        ...(input.type != null && { type: input.type }),
+    };
+};
+const serializeAws_json1_1GetActionTypeInput = (input, context) => {
+    return {
+        ...(input.category != null && { category: input.category }),
+        ...(input.owner != null && { owner: input.owner }),
+        ...(input.provider != null && { provider: input.provider }),
+        ...(input.version != null && { version: input.version }),
+    };
+};
+const serializeAws_json1_1GetJobDetailsInput = (input, context) => {
+    return {
+        ...(input.jobId != null && { jobId: input.jobId }),
+    };
+};
+const serializeAws_json1_1GetPipelineExecutionInput = (input, context) => {
+    return {
+        ...(input.pipelineExecutionId != null && { pipelineExecutionId: input.pipelineExecutionId }),
+        ...(input.pipelineName != null && { pipelineName: input.pipelineName }),
+    };
+};
+const serializeAws_json1_1GetPipelineInput = (input, context) => {
+    return {
+        ...(input.name != null && { name: input.name }),
+        ...(input.version != null && { version: input.version }),
+    };
+};
+const serializeAws_json1_1GetPipelineStateInput = (input, context) => {
+    return {
+        ...(input.name != null && { name: input.name }),
+    };
+};
+const serializeAws_json1_1GetThirdPartyJobDetailsInput = (input, context) => {
+    return {
+        ...(input.clientToken != null && { clientToken: input.clientToken }),
+        ...(input.jobId != null && { jobId: input.jobId }),
+    };
+};
+const serializeAws_json1_1InputArtifact = (input, context) => {
+    return {
+        ...(input.name != null && { name: input.name }),
+    };
+};
+const serializeAws_json1_1InputArtifactList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_json1_1InputArtifact(entry, context);
+    });
+};
+const serializeAws_json1_1JobWorkerExecutorConfiguration = (input, context) => {
+    return {
+        ...(input.pollingAccounts != null && {
+            pollingAccounts: serializeAws_json1_1PollingAccountList(input.pollingAccounts, context),
+        }),
+        ...(input.pollingServicePrincipals != null && {
+            pollingServicePrincipals: serializeAws_json1_1PollingServicePrincipalList(input.pollingServicePrincipals, context),
+        }),
+    };
+};
+const serializeAws_json1_1LambdaExecutorConfiguration = (input, context) => {
+    return {
+        ...(input.lambdaFunctionArn != null && { lambdaFunctionArn: input.lambdaFunctionArn }),
+    };
+};
+const serializeAws_json1_1ListActionExecutionsInput = (input, context) => {
+    return {
+        ...(input.filter != null && { filter: serializeAws_json1_1ActionExecutionFilter(input.filter, context) }),
+        ...(input.maxResults != null && { maxResults: input.maxResults }),
+        ...(input.nextToken != null && { nextToken: input.nextToken }),
+        ...(input.pipelineName != null && { pipelineName: input.pipelineName }),
+    };
+};
+const serializeAws_json1_1ListActionTypesInput = (input, context) => {
+    return {
+        ...(input.actionOwnerFilter != null && { actionOwnerFilter: input.actionOwnerFilter }),
+        ...(input.nextToken != null && { nextToken: input.nextToken }),
+        ...(input.regionFilter != null && { regionFilter: input.regionFilter }),
+    };
+};
+const serializeAws_json1_1ListPipelineExecutionsInput = (input, context) => {
+    return {
+        ...(input.maxResults != null && { maxResults: input.maxResults }),
+        ...(input.nextToken != null && { nextToken: input.nextToken }),
+        ...(input.pipelineName != null && { pipelineName: input.pipelineName }),
+    };
+};
+const serializeAws_json1_1ListPipelinesInput = (input, context) => {
+    return {
+        ...(input.maxResults != null && { maxResults: input.maxResults }),
+        ...(input.nextToken != null && { nextToken: input.nextToken }),
+    };
+};
+const serializeAws_json1_1ListTagsForResourceInput = (input, context) => {
+    return {
+        ...(input.maxResults != null && { maxResults: input.maxResults }),
+        ...(input.nextToken != null && { nextToken: input.nextToken }),
+        ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
+    };
+};
+const serializeAws_json1_1ListWebhooksInput = (input, context) => {
+    return {
+        ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
+        ...(input.NextToken != null && { NextToken: input.NextToken }),
+    };
+};
+const serializeAws_json1_1OutputArtifact = (input, context) => {
+    return {
+        ...(input.name != null && { name: input.name }),
+    };
+};
+const serializeAws_json1_1OutputArtifactList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_json1_1OutputArtifact(entry, context);
+    });
+};
+const serializeAws_json1_1OutputVariablesMap = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = value;
+        return acc;
+    }, {});
+};
+const serializeAws_json1_1PipelineDeclaration = (input, context) => {
+    return {
+        ...(input.artifactStore != null && {
+            artifactStore: serializeAws_json1_1ArtifactStore(input.artifactStore, context),
+        }),
+        ...(input.artifactStores != null && {
+            artifactStores: serializeAws_json1_1ArtifactStoreMap(input.artifactStores, context),
+        }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.roleArn != null && { roleArn: input.roleArn }),
+        ...(input.stages != null && { stages: serializeAws_json1_1PipelineStageDeclarationList(input.stages, context) }),
+        ...(input.version != null && { version: input.version }),
+    };
+};
+const serializeAws_json1_1PipelineStageDeclarationList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_json1_1StageDeclaration(entry, context);
+    });
+};
+const serializeAws_json1_1PollForJobsInput = (input, context) => {
+    return {
+        ...(input.actionTypeId != null && { actionTypeId: serializeAws_json1_1ActionTypeId(input.actionTypeId, context) }),
+        ...(input.maxBatchSize != null && { maxBatchSize: input.maxBatchSize }),
+        ...(input.queryParam != null && { queryParam: serializeAws_json1_1QueryParamMap(input.queryParam, context) }),
+    };
+};
+const serializeAws_json1_1PollForThirdPartyJobsInput = (input, context) => {
+    return {
+        ...(input.actionTypeId != null && { actionTypeId: serializeAws_json1_1ActionTypeId(input.actionTypeId, context) }),
+        ...(input.maxBatchSize != null && { maxBatchSize: input.maxBatchSize }),
+    };
+};
+const serializeAws_json1_1PollingAccountList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_json1_1PollingServicePrincipalList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_json1_1PutActionRevisionInput = (input, context) => {
+    return {
+        ...(input.actionName != null && { actionName: input.actionName }),
+        ...(input.actionRevision != null && {
+            actionRevision: serializeAws_json1_1ActionRevision(input.actionRevision, context),
+        }),
+        ...(input.pipelineName != null && { pipelineName: input.pipelineName }),
+        ...(input.stageName != null && { stageName: input.stageName }),
+    };
+};
+const serializeAws_json1_1PutApprovalResultInput = (input, context) => {
+    return {
+        ...(input.actionName != null && { actionName: input.actionName }),
+        ...(input.pipelineName != null && { pipelineName: input.pipelineName }),
+        ...(input.result != null && { result: serializeAws_json1_1ApprovalResult(input.result, context) }),
+        ...(input.stageName != null && { stageName: input.stageName }),
+        ...(input.token != null && { token: input.token }),
+    };
+};
+const serializeAws_json1_1PutJobFailureResultInput = (input, context) => {
+    return {
+        ...(input.failureDetails != null && {
+            failureDetails: serializeAws_json1_1FailureDetails(input.failureDetails, context),
+        }),
+        ...(input.jobId != null && { jobId: input.jobId }),
+    };
+};
+const serializeAws_json1_1PutJobSuccessResultInput = (input, context) => {
+    return {
+        ...(input.continuationToken != null && { continuationToken: input.continuationToken }),
+        ...(input.currentRevision != null && {
+            currentRevision: serializeAws_json1_1CurrentRevision(input.currentRevision, context),
+        }),
+        ...(input.executionDetails != null && {
+            executionDetails: serializeAws_json1_1ExecutionDetails(input.executionDetails, context),
+        }),
+        ...(input.jobId != null && { jobId: input.jobId }),
+        ...(input.outputVariables != null && {
+            outputVariables: serializeAws_json1_1OutputVariablesMap(input.outputVariables, context),
+        }),
+    };
+};
+const serializeAws_json1_1PutThirdPartyJobFailureResultInput = (input, context) => {
+    return {
+        ...(input.clientToken != null && { clientToken: input.clientToken }),
+        ...(input.failureDetails != null && {
+            failureDetails: serializeAws_json1_1FailureDetails(input.failureDetails, context),
+        }),
+        ...(input.jobId != null && { jobId: input.jobId }),
+    };
+};
+const serializeAws_json1_1PutThirdPartyJobSuccessResultInput = (input, context) => {
+    return {
+        ...(input.clientToken != null && { clientToken: input.clientToken }),
+        ...(input.continuationToken != null && { continuationToken: input.continuationToken }),
+        ...(input.currentRevision != null && {
+            currentRevision: serializeAws_json1_1CurrentRevision(input.currentRevision, context),
+        }),
+        ...(input.executionDetails != null && {
+            executionDetails: serializeAws_json1_1ExecutionDetails(input.executionDetails, context),
+        }),
+        ...(input.jobId != null && { jobId: input.jobId }),
+    };
+};
+const serializeAws_json1_1PutWebhookInput = (input, context) => {
+    return {
+        ...(input.tags != null && { tags: serializeAws_json1_1TagList(input.tags, context) }),
+        ...(input.webhook != null && { webhook: serializeAws_json1_1WebhookDefinition(input.webhook, context) }),
+    };
+};
+const serializeAws_json1_1QueryParamMap = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = value;
+        return acc;
+    }, {});
+};
+const serializeAws_json1_1RegisterWebhookWithThirdPartyInput = (input, context) => {
+    return {
+        ...(input.webhookName != null && { webhookName: input.webhookName }),
+    };
+};
+const serializeAws_json1_1RetryStageExecutionInput = (input, context) => {
+    return {
+        ...(input.pipelineExecutionId != null && { pipelineExecutionId: input.pipelineExecutionId }),
+        ...(input.pipelineName != null && { pipelineName: input.pipelineName }),
+        ...(input.retryMode != null && { retryMode: input.retryMode }),
+        ...(input.stageName != null && { stageName: input.stageName }),
+    };
+};
+const serializeAws_json1_1StageActionDeclarationList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_json1_1ActionDeclaration(entry, context);
+    });
+};
+const serializeAws_json1_1StageBlockerDeclarationList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_json1_1BlockerDeclaration(entry, context);
+    });
+};
+const serializeAws_json1_1StageDeclaration = (input, context) => {
+    return {
+        ...(input.actions != null && { actions: serializeAws_json1_1StageActionDeclarationList(input.actions, context) }),
+        ...(input.blockers != null && {
+            blockers: serializeAws_json1_1StageBlockerDeclarationList(input.blockers, context),
+        }),
+        ...(input.name != null && { name: input.name }),
+    };
+};
+const serializeAws_json1_1StartPipelineExecutionInput = (input, context) => {
+    return {
+        clientRequestToken: input.clientRequestToken ?? generateIdempotencyToken(),
+        ...(input.name != null && { name: input.name }),
+    };
+};
+const serializeAws_json1_1StopPipelineExecutionInput = (input, context) => {
+    return {
+        ...(input.abandon != null && { abandon: input.abandon }),
+        ...(input.pipelineExecutionId != null && { pipelineExecutionId: input.pipelineExecutionId }),
+        ...(input.pipelineName != null && { pipelineName: input.pipelineName }),
+        ...(input.reason != null && { reason: input.reason }),
+    };
+};
+const serializeAws_json1_1Tag = (input, context) => {
+    return {
+        ...(input.key != null && { key: input.key }),
+        ...(input.value != null && { value: input.value }),
+    };
+};
+const serializeAws_json1_1TagKeyList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_json1_1TagList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_json1_1Tag(entry, context);
+    });
+};
+const serializeAws_json1_1TagResourceInput = (input, context) => {
+    return {
+        ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
+        ...(input.tags != null && { tags: serializeAws_json1_1TagList(input.tags, context) }),
+    };
+};
+const serializeAws_json1_1UntagResourceInput = (input, context) => {
+    return {
+        ...(input.resourceArn != null && { resourceArn: input.resourceArn }),
+        ...(input.tagKeys != null && { tagKeys: serializeAws_json1_1TagKeyList(input.tagKeys, context) }),
+    };
+};
+const serializeAws_json1_1UpdateActionTypeInput = (input, context) => {
+    return {
+        ...(input.actionType != null && {
+            actionType: serializeAws_json1_1ActionTypeDeclaration(input.actionType, context),
+        }),
+    };
+};
+const serializeAws_json1_1UpdatePipelineInput = (input, context) => {
+    return {
+        ...(input.pipeline != null && { pipeline: serializeAws_json1_1PipelineDeclaration(input.pipeline, context) }),
+    };
+};
+const serializeAws_json1_1WebhookAuthConfiguration = (input, context) => {
+    return {
+        ...(input.AllowedIPRange != null && { AllowedIPRange: input.AllowedIPRange }),
+        ...(input.SecretToken != null && { SecretToken: input.SecretToken }),
+    };
+};
+const serializeAws_json1_1WebhookDefinition = (input, context) => {
+    return {
+        ...(input.authentication != null && { authentication: input.authentication }),
+        ...(input.authenticationConfiguration != null && {
+            authenticationConfiguration: serializeAws_json1_1WebhookAuthConfiguration(input.authenticationConfiguration, context),
+        }),
+        ...(input.filters != null && { filters: serializeAws_json1_1WebhookFilters(input.filters, context) }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.targetAction != null && { targetAction: input.targetAction }),
+        ...(input.targetPipeline != null && { targetPipeline: input.targetPipeline }),
+    };
+};
+const serializeAws_json1_1WebhookFilterRule = (input, context) => {
+    return {
+        ...(input.jsonPath != null && { jsonPath: input.jsonPath }),
+        ...(input.matchEquals != null && { matchEquals: input.matchEquals }),
+    };
+};
+const serializeAws_json1_1WebhookFilters = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_json1_1WebhookFilterRule(entry, context);
+    });
+};
+const deserializeAws_json1_1AcknowledgeJobOutput = (output, context) => {
+    return {
+        status: __expectString(output.status),
+    };
+};
+const deserializeAws_json1_1AcknowledgeThirdPartyJobOutput = (output, context) => {
+    return {
+        status: __expectString(output.status),
+    };
+};
+const deserializeAws_json1_1ActionConfiguration = (output, context) => {
+    return {
+        configuration: output.configuration != null
+            ? deserializeAws_json1_1ActionConfigurationMap(output.configuration, context)
+            : undefined,
+    };
+};
+const deserializeAws_json1_1ActionConfigurationMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = __expectString(value);
+        return acc;
+    }, {});
+};
+const deserializeAws_json1_1ActionConfigurationProperty = (output, context) => {
+    return {
+        description: __expectString(output.description),
+        key: __expectBoolean(output.key),
+        name: __expectString(output.name),
+        queryable: __expectBoolean(output.queryable),
+        required: __expectBoolean(output.required),
+        secret: __expectBoolean(output.secret),
+        type: __expectString(output.type),
+    };
+};
+const deserializeAws_json1_1ActionConfigurationPropertyList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1ActionConfigurationProperty(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1ActionContext = (output, context) => {
+    return {
+        actionExecutionId: __expectString(output.actionExecutionId),
+        name: __expectString(output.name),
+    };
+};
+const deserializeAws_json1_1ActionDeclaration = (output, context) => {
+    return {
+        actionTypeId: output.actionTypeId != null ? deserializeAws_json1_1ActionTypeId(output.actionTypeId, context) : undefined,
+        configuration: output.configuration != null
+            ? deserializeAws_json1_1ActionConfigurationMap(output.configuration, context)
+            : undefined,
+        inputArtifacts: output.inputArtifacts != null
+            ? deserializeAws_json1_1InputArtifactList(output.inputArtifacts, context)
+            : undefined,
+        name: __expectString(output.name),
+        namespace: __expectString(output.namespace),
+        outputArtifacts: output.outputArtifacts != null
+            ? deserializeAws_json1_1OutputArtifactList(output.outputArtifacts, context)
+            : undefined,
+        region: __expectString(output.region),
+        roleArn: __expectString(output.roleArn),
+        runOrder: __expectInt32(output.runOrder),
+    };
+};
+const deserializeAws_json1_1ActionExecution = (output, context) => {
+    return {
+        actionExecutionId: __expectString(output.actionExecutionId),
+        errorDetails: output.errorDetails != null ? deserializeAws_json1_1ErrorDetails(output.errorDetails, context) : undefined,
+        externalExecutionId: __expectString(output.externalExecutionId),
+        externalExecutionUrl: __expectString(output.externalExecutionUrl),
+        lastStatusChange: output.lastStatusChange != null
+            ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.lastStatusChange)))
+            : undefined,
+        lastUpdatedBy: __expectString(output.lastUpdatedBy),
+        percentComplete: __expectInt32(output.percentComplete),
+        status: __expectString(output.status),
+        summary: __expectString(output.summary),
+        token: __expectString(output.token),
+    };
+};
+const deserializeAws_json1_1ActionExecutionDetail = (output, context) => {
+    return {
+        actionExecutionId: __expectString(output.actionExecutionId),
+        actionName: __expectString(output.actionName),
+        input: output.input != null ? deserializeAws_json1_1ActionExecutionInput(output.input, context) : undefined,
+        lastUpdateTime: output.lastUpdateTime != null
+            ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.lastUpdateTime)))
+            : undefined,
+        output: output.output != null ? deserializeAws_json1_1ActionExecutionOutput(output.output, context) : undefined,
+        pipelineExecutionId: __expectString(output.pipelineExecutionId),
+        pipelineVersion: __expectInt32(output.pipelineVersion),
+        stageName: __expectString(output.stageName),
+        startTime: output.startTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.startTime))) : undefined,
+        status: __expectString(output.status),
+    };
+};
+const deserializeAws_json1_1ActionExecutionDetailList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1ActionExecutionDetail(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1ActionExecutionInput = (output, context) => {
+    return {
+        actionTypeId: output.actionTypeId != null ? deserializeAws_json1_1ActionTypeId(output.actionTypeId, context) : undefined,
+        configuration: output.configuration != null
+            ? deserializeAws_json1_1ActionConfigurationMap(output.configuration, context)
+            : undefined,
+        inputArtifacts: output.inputArtifacts != null
+            ? deserializeAws_json1_1ArtifactDetailList(output.inputArtifacts, context)
+            : undefined,
+        namespace: __expectString(output.namespace),
+        region: __expectString(output.region),
+        resolvedConfiguration: output.resolvedConfiguration != null
+            ? deserializeAws_json1_1ResolvedActionConfigurationMap(output.resolvedConfiguration, context)
+            : undefined,
+        roleArn: __expectString(output.roleArn),
+    };
+};
+const deserializeAws_json1_1ActionExecutionOutput = (output, context) => {
+    return {
+        executionResult: output.executionResult != null
+            ? deserializeAws_json1_1ActionExecutionResult(output.executionResult, context)
+            : undefined,
+        outputArtifacts: output.outputArtifacts != null
+            ? deserializeAws_json1_1ArtifactDetailList(output.outputArtifacts, context)
+            : undefined,
+        outputVariables: output.outputVariables != null
+            ? deserializeAws_json1_1OutputVariablesMap(output.outputVariables, context)
+            : undefined,
+    };
+};
+const deserializeAws_json1_1ActionExecutionResult = (output, context) => {
+    return {
+        externalExecutionId: __expectString(output.externalExecutionId),
+        externalExecutionSummary: __expectString(output.externalExecutionSummary),
+        externalExecutionUrl: __expectString(output.externalExecutionUrl),
+    };
+};
+const deserializeAws_json1_1ActionNotFoundException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1ActionRevision = (output, context) => {
+    return {
+        created: output.created != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.created))) : undefined,
+        revisionChangeId: __expectString(output.revisionChangeId),
+        revisionId: __expectString(output.revisionId),
+    };
+};
+const deserializeAws_json1_1ActionState = (output, context) => {
+    return {
+        actionName: __expectString(output.actionName),
+        currentRevision: output.currentRevision != null
+            ? deserializeAws_json1_1ActionRevision(output.currentRevision, context)
+            : undefined,
+        entityUrl: __expectString(output.entityUrl),
+        latestExecution: output.latestExecution != null
+            ? deserializeAws_json1_1ActionExecution(output.latestExecution, context)
+            : undefined,
+        revisionUrl: __expectString(output.revisionUrl),
+    };
+};
+const deserializeAws_json1_1ActionStateList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1ActionState(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1ActionType = (output, context) => {
+    return {
+        actionConfigurationProperties: output.actionConfigurationProperties != null
+            ? deserializeAws_json1_1ActionConfigurationPropertyList(output.actionConfigurationProperties, context)
+            : undefined,
+        id: output.id != null ? deserializeAws_json1_1ActionTypeId(output.id, context) : undefined,
+        inputArtifactDetails: output.inputArtifactDetails != null
+            ? deserializeAws_json1_1ArtifactDetails(output.inputArtifactDetails, context)
+            : undefined,
+        outputArtifactDetails: output.outputArtifactDetails != null
+            ? deserializeAws_json1_1ArtifactDetails(output.outputArtifactDetails, context)
+            : undefined,
+        settings: output.settings != null ? deserializeAws_json1_1ActionTypeSettings(output.settings, context) : undefined,
+    };
+};
+const deserializeAws_json1_1ActionTypeArtifactDetails = (output, context) => {
+    return {
+        maximumCount: __expectInt32(output.maximumCount),
+        minimumCount: __expectInt32(output.minimumCount),
+    };
+};
+const deserializeAws_json1_1ActionTypeDeclaration = (output, context) => {
+    return {
+        description: __expectString(output.description),
+        executor: output.executor != null ? deserializeAws_json1_1ActionTypeExecutor(output.executor, context) : undefined,
+        id: output.id != null ? deserializeAws_json1_1ActionTypeIdentifier(output.id, context) : undefined,
+        inputArtifactDetails: output.inputArtifactDetails != null
+            ? deserializeAws_json1_1ActionTypeArtifactDetails(output.inputArtifactDetails, context)
+            : undefined,
+        outputArtifactDetails: output.outputArtifactDetails != null
+            ? deserializeAws_json1_1ActionTypeArtifactDetails(output.outputArtifactDetails, context)
+            : undefined,
+        permissions: output.permissions != null ? deserializeAws_json1_1ActionTypePermissions(output.permissions, context) : undefined,
+        properties: output.properties != null ? deserializeAws_json1_1ActionTypeProperties(output.properties, context) : undefined,
+        urls: output.urls != null ? deserializeAws_json1_1ActionTypeUrls(output.urls, context) : undefined,
+    };
+};
+const deserializeAws_json1_1ActionTypeExecutor = (output, context) => {
+    return {
+        configuration: output.configuration != null
+            ? deserializeAws_json1_1ExecutorConfiguration(output.configuration, context)
+            : undefined,
+        jobTimeout: __expectInt32(output.jobTimeout),
+        policyStatementsTemplate: __expectString(output.policyStatementsTemplate),
+        type: __expectString(output.type),
+    };
+};
+const deserializeAws_json1_1ActionTypeId = (output, context) => {
+    return {
+        category: __expectString(output.category),
+        owner: __expectString(output.owner),
+        provider: __expectString(output.provider),
+        version: __expectString(output.version),
+    };
+};
+const deserializeAws_json1_1ActionTypeIdentifier = (output, context) => {
+    return {
+        category: __expectString(output.category),
+        owner: __expectString(output.owner),
+        provider: __expectString(output.provider),
+        version: __expectString(output.version),
+    };
+};
+const deserializeAws_json1_1ActionTypeList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1ActionType(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1ActionTypeNotFoundException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1ActionTypePermissions = (output, context) => {
+    return {
+        allowedAccounts: output.allowedAccounts != null
+            ? deserializeAws_json1_1AllowedAccounts(output.allowedAccounts, context)
+            : undefined,
+    };
+};
+const deserializeAws_json1_1ActionTypeProperties = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1ActionTypeProperty(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1ActionTypeProperty = (output, context) => {
+    return {
+        description: __expectString(output.description),
+        key: __expectBoolean(output.key),
+        name: __expectString(output.name),
+        noEcho: __expectBoolean(output.noEcho),
+        optional: __expectBoolean(output.optional),
+        queryable: __expectBoolean(output.queryable),
+    };
+};
+const deserializeAws_json1_1ActionTypeSettings = (output, context) => {
+    return {
+        entityUrlTemplate: __expectString(output.entityUrlTemplate),
+        executionUrlTemplate: __expectString(output.executionUrlTemplate),
+        revisionUrlTemplate: __expectString(output.revisionUrlTemplate),
+        thirdPartyConfigurationUrl: __expectString(output.thirdPartyConfigurationUrl),
+    };
+};
+const deserializeAws_json1_1ActionTypeUrls = (output, context) => {
+    return {
+        configurationUrl: __expectString(output.configurationUrl),
+        entityUrlTemplate: __expectString(output.entityUrlTemplate),
+        executionUrlTemplate: __expectString(output.executionUrlTemplate),
+        revisionUrlTemplate: __expectString(output.revisionUrlTemplate),
+    };
+};
+const deserializeAws_json1_1AllowedAccounts = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return __expectString(entry);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1ApprovalAlreadyCompletedException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1Artifact = (output, context) => {
+    return {
+        location: output.location != null ? deserializeAws_json1_1ArtifactLocation(output.location, context) : undefined,
+        name: __expectString(output.name),
+        revision: __expectString(output.revision),
+    };
+};
+const deserializeAws_json1_1ArtifactDetail = (output, context) => {
+    return {
+        name: __expectString(output.name),
+        s3location: output.s3location != null ? deserializeAws_json1_1S3Location(output.s3location, context) : undefined,
+    };
+};
+const deserializeAws_json1_1ArtifactDetailList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1ArtifactDetail(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1ArtifactDetails = (output, context) => {
+    return {
+        maximumCount: __expectInt32(output.maximumCount),
+        minimumCount: __expectInt32(output.minimumCount),
+    };
+};
+const deserializeAws_json1_1ArtifactList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1Artifact(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1ArtifactLocation = (output, context) => {
+    return {
+        s3Location: output.s3Location != null ? deserializeAws_json1_1S3ArtifactLocation(output.s3Location, context) : undefined,
+        type: __expectString(output.type),
+    };
+};
+const deserializeAws_json1_1ArtifactRevision = (output, context) => {
+    return {
+        created: output.created != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.created))) : undefined,
+        name: __expectString(output.name),
+        revisionChangeIdentifier: __expectString(output.revisionChangeIdentifier),
+        revisionId: __expectString(output.revisionId),
+        revisionSummary: __expectString(output.revisionSummary),
+        revisionUrl: __expectString(output.revisionUrl),
+    };
+};
+const deserializeAws_json1_1ArtifactRevisionList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1ArtifactRevision(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1ArtifactStore = (output, context) => {
+    return {
+        encryptionKey: output.encryptionKey != null ? deserializeAws_json1_1EncryptionKey(output.encryptionKey, context) : undefined,
+        location: __expectString(output.location),
+        type: __expectString(output.type),
+    };
+};
+const deserializeAws_json1_1ArtifactStoreMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = deserializeAws_json1_1ArtifactStore(value, context);
+        return acc;
+    }, {});
+};
+const deserializeAws_json1_1AWSSessionCredentials = (output, context) => {
+    return {
+        accessKeyId: __expectString(output.accessKeyId),
+        secretAccessKey: __expectString(output.secretAccessKey),
+        sessionToken: __expectString(output.sessionToken),
+    };
+};
+const deserializeAws_json1_1BlockerDeclaration = (output, context) => {
+    return {
+        name: __expectString(output.name),
+        type: __expectString(output.type),
+    };
+};
+const deserializeAws_json1_1ConcurrentModificationException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1ConflictException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1CreateCustomActionTypeOutput = (output, context) => {
+    return {
+        actionType: output.actionType != null ? deserializeAws_json1_1ActionType(output.actionType, context) : undefined,
+        tags: output.tags != null ? deserializeAws_json1_1TagList(output.tags, context) : undefined,
+    };
+};
+const deserializeAws_json1_1CreatePipelineOutput = (output, context) => {
+    return {
+        pipeline: output.pipeline != null ? deserializeAws_json1_1PipelineDeclaration(output.pipeline, context) : undefined,
+        tags: output.tags != null ? deserializeAws_json1_1TagList(output.tags, context) : undefined,
+    };
+};
+const deserializeAws_json1_1DeleteWebhookOutput = (output, context) => {
+    return {};
+};
+const deserializeAws_json1_1DeregisterWebhookWithThirdPartyOutput = (output, context) => {
+    return {};
+};
+const deserializeAws_json1_1DuplicatedStopRequestException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1EncryptionKey = (output, context) => {
+    return {
+        id: __expectString(output.id),
+        type: __expectString(output.type),
+    };
+};
+const deserializeAws_json1_1ErrorDetails = (output, context) => {
+    return {
+        code: __expectString(output.code),
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1ExecutionTrigger = (output, context) => {
+    return {
+        triggerDetail: __expectString(output.triggerDetail),
+        triggerType: __expectString(output.triggerType),
+    };
+};
+const deserializeAws_json1_1ExecutorConfiguration = (output, context) => {
+    return {
+        jobWorkerExecutorConfiguration: output.jobWorkerExecutorConfiguration != null
+            ? deserializeAws_json1_1JobWorkerExecutorConfiguration(output.jobWorkerExecutorConfiguration, context)
+            : undefined,
+        lambdaExecutorConfiguration: output.lambdaExecutorConfiguration != null
+            ? deserializeAws_json1_1LambdaExecutorConfiguration(output.lambdaExecutorConfiguration, context)
+            : undefined,
+    };
+};
+const deserializeAws_json1_1GetActionTypeOutput = (output, context) => {
+    return {
+        actionType: output.actionType != null ? deserializeAws_json1_1ActionTypeDeclaration(output.actionType, context) : undefined,
+    };
+};
+const deserializeAws_json1_1GetJobDetailsOutput = (output, context) => {
+    return {
+        jobDetails: output.jobDetails != null ? deserializeAws_json1_1JobDetails(output.jobDetails, context) : undefined,
+    };
+};
+const deserializeAws_json1_1GetPipelineExecutionOutput = (output, context) => {
+    return {
+        pipelineExecution: output.pipelineExecution != null
+            ? deserializeAws_json1_1PipelineExecution(output.pipelineExecution, context)
+            : undefined,
+    };
+};
+const deserializeAws_json1_1GetPipelineOutput = (output, context) => {
+    return {
+        metadata: output.metadata != null ? deserializeAws_json1_1PipelineMetadata(output.metadata, context) : undefined,
+        pipeline: output.pipeline != null ? deserializeAws_json1_1PipelineDeclaration(output.pipeline, context) : undefined,
+    };
+};
+const deserializeAws_json1_1GetPipelineStateOutput = (output, context) => {
+    return {
+        created: output.created != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.created))) : undefined,
+        pipelineName: __expectString(output.pipelineName),
+        pipelineVersion: __expectInt32(output.pipelineVersion),
+        stageStates: output.stageStates != null ? deserializeAws_json1_1StageStateList(output.stageStates, context) : undefined,
+        updated: output.updated != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updated))) : undefined,
+    };
+};
+const deserializeAws_json1_1GetThirdPartyJobDetailsOutput = (output, context) => {
+    return {
+        jobDetails: output.jobDetails != null ? deserializeAws_json1_1ThirdPartyJobDetails(output.jobDetails, context) : undefined,
+    };
+};
+const deserializeAws_json1_1InputArtifact = (output, context) => {
+    return {
+        name: __expectString(output.name),
+    };
+};
+const deserializeAws_json1_1InputArtifactList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1InputArtifact(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1InvalidActionDeclarationException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1InvalidApprovalTokenException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1InvalidArnException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1InvalidBlockerDeclarationException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1InvalidClientTokenException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1InvalidJobException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1InvalidJobStateException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1InvalidNextTokenException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1InvalidNonceException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1InvalidStageDeclarationException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1InvalidStructureException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1InvalidTagsException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1InvalidWebhookAuthenticationParametersException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1InvalidWebhookFilterPatternException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1Job = (output, context) => {
+    return {
+        accountId: __expectString(output.accountId),
+        data: output.data != null ? deserializeAws_json1_1JobData(output.data, context) : undefined,
+        id: __expectString(output.id),
+        nonce: __expectString(output.nonce),
+    };
+};
+const deserializeAws_json1_1JobData = (output, context) => {
+    return {
+        actionConfiguration: output.actionConfiguration != null
+            ? deserializeAws_json1_1ActionConfiguration(output.actionConfiguration, context)
+            : undefined,
+        actionTypeId: output.actionTypeId != null ? deserializeAws_json1_1ActionTypeId(output.actionTypeId, context) : undefined,
+        artifactCredentials: output.artifactCredentials != null
+            ? deserializeAws_json1_1AWSSessionCredentials(output.artifactCredentials, context)
+            : undefined,
+        continuationToken: __expectString(output.continuationToken),
+        encryptionKey: output.encryptionKey != null ? deserializeAws_json1_1EncryptionKey(output.encryptionKey, context) : undefined,
+        inputArtifacts: output.inputArtifacts != null ? deserializeAws_json1_1ArtifactList(output.inputArtifacts, context) : undefined,
+        outputArtifacts: output.outputArtifacts != null ? deserializeAws_json1_1ArtifactList(output.outputArtifacts, context) : undefined,
+        pipelineContext: output.pipelineContext != null
+            ? deserializeAws_json1_1PipelineContext(output.pipelineContext, context)
+            : undefined,
+    };
+};
+const deserializeAws_json1_1JobDetails = (output, context) => {
+    return {
+        accountId: __expectString(output.accountId),
+        data: output.data != null ? deserializeAws_json1_1JobData(output.data, context) : undefined,
+        id: __expectString(output.id),
+    };
+};
+const deserializeAws_json1_1JobList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1Job(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1JobNotFoundException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1JobWorkerExecutorConfiguration = (output, context) => {
+    return {
+        pollingAccounts: output.pollingAccounts != null
+            ? deserializeAws_json1_1PollingAccountList(output.pollingAccounts, context)
+            : undefined,
+        pollingServicePrincipals: output.pollingServicePrincipals != null
+            ? deserializeAws_json1_1PollingServicePrincipalList(output.pollingServicePrincipals, context)
+            : undefined,
+    };
+};
+const deserializeAws_json1_1LambdaExecutorConfiguration = (output, context) => {
+    return {
+        lambdaFunctionArn: __expectString(output.lambdaFunctionArn),
+    };
+};
+const deserializeAws_json1_1LimitExceededException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1ListActionExecutionsOutput = (output, context) => {
+    return {
+        actionExecutionDetails: output.actionExecutionDetails != null
+            ? deserializeAws_json1_1ActionExecutionDetailList(output.actionExecutionDetails, context)
+            : undefined,
+        nextToken: __expectString(output.nextToken),
+    };
+};
+const deserializeAws_json1_1ListActionTypesOutput = (output, context) => {
+    return {
+        actionTypes: output.actionTypes != null ? deserializeAws_json1_1ActionTypeList(output.actionTypes, context) : undefined,
+        nextToken: __expectString(output.nextToken),
+    };
+};
+const deserializeAws_json1_1ListPipelineExecutionsOutput = (output, context) => {
+    return {
+        nextToken: __expectString(output.nextToken),
+        pipelineExecutionSummaries: output.pipelineExecutionSummaries != null
+            ? deserializeAws_json1_1PipelineExecutionSummaryList(output.pipelineExecutionSummaries, context)
+            : undefined,
+    };
+};
+const deserializeAws_json1_1ListPipelinesOutput = (output, context) => {
+    return {
+        nextToken: __expectString(output.nextToken),
+        pipelines: output.pipelines != null ? deserializeAws_json1_1PipelineList(output.pipelines, context) : undefined,
+    };
+};
+const deserializeAws_json1_1ListTagsForResourceOutput = (output, context) => {
+    return {
+        nextToken: __expectString(output.nextToken),
+        tags: output.tags != null ? deserializeAws_json1_1TagList(output.tags, context) : undefined,
+    };
+};
+const deserializeAws_json1_1ListWebhookItem = (output, context) => {
+    return {
+        arn: __expectString(output.arn),
+        definition: output.definition != null ? deserializeAws_json1_1WebhookDefinition(output.definition, context) : undefined,
+        errorCode: __expectString(output.errorCode),
+        errorMessage: __expectString(output.errorMessage),
+        lastTriggered: output.lastTriggered != null
+            ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.lastTriggered)))
+            : undefined,
+        tags: output.tags != null ? deserializeAws_json1_1TagList(output.tags, context) : undefined,
+        url: __expectString(output.url),
+    };
+};
+const deserializeAws_json1_1ListWebhooksOutput = (output, context) => {
+    return {
+        NextToken: __expectString(output.NextToken),
+        webhooks: output.webhooks != null ? deserializeAws_json1_1WebhookList(output.webhooks, context) : undefined,
+    };
+};
+const deserializeAws_json1_1NotLatestPipelineExecutionException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1OutputArtifact = (output, context) => {
+    return {
+        name: __expectString(output.name),
+    };
+};
+const deserializeAws_json1_1OutputArtifactList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1OutputArtifact(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1OutputVariablesMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = __expectString(value);
+        return acc;
+    }, {});
+};
+const deserializeAws_json1_1OutputVariablesSizeExceededException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1PipelineContext = (output, context) => {
+    return {
+        action: output.action != null ? deserializeAws_json1_1ActionContext(output.action, context) : undefined,
+        pipelineArn: __expectString(output.pipelineArn),
+        pipelineExecutionId: __expectString(output.pipelineExecutionId),
+        pipelineName: __expectString(output.pipelineName),
+        stage: output.stage != null ? deserializeAws_json1_1StageContext(output.stage, context) : undefined,
+    };
+};
+const deserializeAws_json1_1PipelineDeclaration = (output, context) => {
+    return {
+        artifactStore: output.artifactStore != null ? deserializeAws_json1_1ArtifactStore(output.artifactStore, context) : undefined,
+        artifactStores: output.artifactStores != null
+            ? deserializeAws_json1_1ArtifactStoreMap(output.artifactStores, context)
+            : undefined,
+        name: __expectString(output.name),
+        roleArn: __expectString(output.roleArn),
+        stages: output.stages != null ? deserializeAws_json1_1PipelineStageDeclarationList(output.stages, context) : undefined,
+        version: __expectInt32(output.version),
+    };
+};
+const deserializeAws_json1_1PipelineExecution = (output, context) => {
+    return {
+        artifactRevisions: output.artifactRevisions != null
+            ? deserializeAws_json1_1ArtifactRevisionList(output.artifactRevisions, context)
+            : undefined,
+        pipelineExecutionId: __expectString(output.pipelineExecutionId),
+        pipelineName: __expectString(output.pipelineName),
+        pipelineVersion: __expectInt32(output.pipelineVersion),
+        status: __expectString(output.status),
+        statusSummary: __expectString(output.statusSummary),
+    };
+};
+const deserializeAws_json1_1PipelineExecutionNotFoundException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1PipelineExecutionNotStoppableException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1PipelineExecutionSummary = (output, context) => {
+    return {
+        lastUpdateTime: output.lastUpdateTime != null
+            ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.lastUpdateTime)))
+            : undefined,
+        pipelineExecutionId: __expectString(output.pipelineExecutionId),
+        sourceRevisions: output.sourceRevisions != null
+            ? deserializeAws_json1_1SourceRevisionList(output.sourceRevisions, context)
+            : undefined,
+        startTime: output.startTime != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.startTime))) : undefined,
+        status: __expectString(output.status),
+        stopTrigger: output.stopTrigger != null ? deserializeAws_json1_1StopExecutionTrigger(output.stopTrigger, context) : undefined,
+        trigger: output.trigger != null ? deserializeAws_json1_1ExecutionTrigger(output.trigger, context) : undefined,
+    };
+};
+const deserializeAws_json1_1PipelineExecutionSummaryList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1PipelineExecutionSummary(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1PipelineList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1PipelineSummary(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1PipelineMetadata = (output, context) => {
+    return {
+        created: output.created != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.created))) : undefined,
+        pipelineArn: __expectString(output.pipelineArn),
+        updated: output.updated != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updated))) : undefined,
+    };
+};
+const deserializeAws_json1_1PipelineNameInUseException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1PipelineNotFoundException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1PipelineStageDeclarationList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1StageDeclaration(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1PipelineSummary = (output, context) => {
+    return {
+        created: output.created != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.created))) : undefined,
+        name: __expectString(output.name),
+        updated: output.updated != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.updated))) : undefined,
+        version: __expectInt32(output.version),
+    };
+};
+const deserializeAws_json1_1PipelineVersionNotFoundException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1PollForJobsOutput = (output, context) => {
+    return {
+        jobs: output.jobs != null ? deserializeAws_json1_1JobList(output.jobs, context) : undefined,
+    };
+};
+const deserializeAws_json1_1PollForThirdPartyJobsOutput = (output, context) => {
+    return {
+        jobs: output.jobs != null ? deserializeAws_json1_1ThirdPartyJobList(output.jobs, context) : undefined,
+    };
+};
+const deserializeAws_json1_1PollingAccountList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return __expectString(entry);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1PollingServicePrincipalList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return __expectString(entry);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1PutActionRevisionOutput = (output, context) => {
+    return {
+        newRevision: __expectBoolean(output.newRevision),
+        pipelineExecutionId: __expectString(output.pipelineExecutionId),
+    };
+};
+const deserializeAws_json1_1PutApprovalResultOutput = (output, context) => {
+    return {
+        approvedAt: output.approvedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.approvedAt))) : undefined,
+    };
+};
+const deserializeAws_json1_1PutWebhookOutput = (output, context) => {
+    return {
+        webhook: output.webhook != null ? deserializeAws_json1_1ListWebhookItem(output.webhook, context) : undefined,
+    };
+};
+const deserializeAws_json1_1RegisterWebhookWithThirdPartyOutput = (output, context) => {
+    return {};
+};
+const deserializeAws_json1_1RequestFailedException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1ResolvedActionConfigurationMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = __expectString(value);
+        return acc;
+    }, {});
+};
+const deserializeAws_json1_1ResourceNotFoundException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1RetryStageExecutionOutput = (output, context) => {
+    return {
+        pipelineExecutionId: __expectString(output.pipelineExecutionId),
+    };
+};
+const deserializeAws_json1_1S3ArtifactLocation = (output, context) => {
+    return {
+        bucketName: __expectString(output.bucketName),
+        objectKey: __expectString(output.objectKey),
+    };
+};
+const deserializeAws_json1_1S3Location = (output, context) => {
+    return {
+        bucket: __expectString(output.bucket),
+        key: __expectString(output.key),
+    };
+};
+const deserializeAws_json1_1SourceRevision = (output, context) => {
+    return {
+        actionName: __expectString(output.actionName),
+        revisionId: __expectString(output.revisionId),
+        revisionSummary: __expectString(output.revisionSummary),
+        revisionUrl: __expectString(output.revisionUrl),
+    };
+};
+const deserializeAws_json1_1SourceRevisionList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1SourceRevision(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1StageActionDeclarationList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1ActionDeclaration(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1StageBlockerDeclarationList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1BlockerDeclaration(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1StageContext = (output, context) => {
+    return {
+        name: __expectString(output.name),
+    };
+};
+const deserializeAws_json1_1StageDeclaration = (output, context) => {
+    return {
+        actions: output.actions != null ? deserializeAws_json1_1StageActionDeclarationList(output.actions, context) : undefined,
+        blockers: output.blockers != null ? deserializeAws_json1_1StageBlockerDeclarationList(output.blockers, context) : undefined,
+        name: __expectString(output.name),
+    };
+};
+const deserializeAws_json1_1StageExecution = (output, context) => {
+    return {
+        pipelineExecutionId: __expectString(output.pipelineExecutionId),
+        status: __expectString(output.status),
+    };
+};
+const deserializeAws_json1_1StageNotFoundException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1StageNotRetryableException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1StageState = (output, context) => {
+    return {
+        actionStates: output.actionStates != null ? deserializeAws_json1_1ActionStateList(output.actionStates, context) : undefined,
+        inboundExecution: output.inboundExecution != null
+            ? deserializeAws_json1_1StageExecution(output.inboundExecution, context)
+            : undefined,
+        inboundTransitionState: output.inboundTransitionState != null
+            ? deserializeAws_json1_1TransitionState(output.inboundTransitionState, context)
+            : undefined,
+        latestExecution: output.latestExecution != null
+            ? deserializeAws_json1_1StageExecution(output.latestExecution, context)
+            : undefined,
+        stageName: __expectString(output.stageName),
+    };
+};
+const deserializeAws_json1_1StageStateList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1StageState(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1StartPipelineExecutionOutput = (output, context) => {
+    return {
+        pipelineExecutionId: __expectString(output.pipelineExecutionId),
+    };
+};
+const deserializeAws_json1_1StopExecutionTrigger = (output, context) => {
+    return {
+        reason: __expectString(output.reason),
+    };
+};
+const deserializeAws_json1_1StopPipelineExecutionOutput = (output, context) => {
+    return {
+        pipelineExecutionId: __expectString(output.pipelineExecutionId),
+    };
+};
+const deserializeAws_json1_1Tag = (output, context) => {
+    return {
+        key: __expectString(output.key),
+        value: __expectString(output.value),
+    };
+};
+const deserializeAws_json1_1TagList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1Tag(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1TagResourceOutput = (output, context) => {
+    return {};
+};
+const deserializeAws_json1_1ThirdPartyJob = (output, context) => {
+    return {
+        clientId: __expectString(output.clientId),
+        jobId: __expectString(output.jobId),
+    };
+};
+const deserializeAws_json1_1ThirdPartyJobData = (output, context) => {
+    return {
+        actionConfiguration: output.actionConfiguration != null
+            ? deserializeAws_json1_1ActionConfiguration(output.actionConfiguration, context)
+            : undefined,
+        actionTypeId: output.actionTypeId != null ? deserializeAws_json1_1ActionTypeId(output.actionTypeId, context) : undefined,
+        artifactCredentials: output.artifactCredentials != null
+            ? deserializeAws_json1_1AWSSessionCredentials(output.artifactCredentials, context)
+            : undefined,
+        continuationToken: __expectString(output.continuationToken),
+        encryptionKey: output.encryptionKey != null ? deserializeAws_json1_1EncryptionKey(output.encryptionKey, context) : undefined,
+        inputArtifacts: output.inputArtifacts != null ? deserializeAws_json1_1ArtifactList(output.inputArtifacts, context) : undefined,
+        outputArtifacts: output.outputArtifacts != null ? deserializeAws_json1_1ArtifactList(output.outputArtifacts, context) : undefined,
+        pipelineContext: output.pipelineContext != null
+            ? deserializeAws_json1_1PipelineContext(output.pipelineContext, context)
+            : undefined,
+    };
+};
+const deserializeAws_json1_1ThirdPartyJobDetails = (output, context) => {
+    return {
+        data: output.data != null ? deserializeAws_json1_1ThirdPartyJobData(output.data, context) : undefined,
+        id: __expectString(output.id),
+        nonce: __expectString(output.nonce),
+    };
+};
+const deserializeAws_json1_1ThirdPartyJobList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1ThirdPartyJob(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1TooManyTagsException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1TransitionState = (output, context) => {
+    return {
+        disabledReason: __expectString(output.disabledReason),
+        enabled: __expectBoolean(output.enabled),
+        lastChangedAt: output.lastChangedAt != null
+            ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.lastChangedAt)))
+            : undefined,
+        lastChangedBy: __expectString(output.lastChangedBy),
+    };
+};
+const deserializeAws_json1_1UntagResourceOutput = (output, context) => {
+    return {};
+};
+const deserializeAws_json1_1UpdatePipelineOutput = (output, context) => {
+    return {
+        pipeline: output.pipeline != null ? deserializeAws_json1_1PipelineDeclaration(output.pipeline, context) : undefined,
+    };
+};
+const deserializeAws_json1_1ValidationException = (output, context) => {
+    return {
+        message: __expectString(output.message),
+    };
+};
+const deserializeAws_json1_1WebhookAuthConfiguration = (output, context) => {
+    return {
+        AllowedIPRange: __expectString(output.AllowedIPRange),
+        SecretToken: __expectString(output.SecretToken),
+    };
+};
+const deserializeAws_json1_1WebhookDefinition = (output, context) => {
+    return {
+        authentication: __expectString(output.authentication),
+        authenticationConfiguration: output.authenticationConfiguration != null
+            ? deserializeAws_json1_1WebhookAuthConfiguration(output.authenticationConfiguration, context)
+            : undefined,
+        filters: output.filters != null ? deserializeAws_json1_1WebhookFilters(output.filters, context) : undefined,
+        name: __expectString(output.name),
+        targetAction: __expectString(output.targetAction),
+        targetPipeline: __expectString(output.targetPipeline),
+    };
+};
+const deserializeAws_json1_1WebhookFilterRule = (output, context) => {
+    return {
+        jsonPath: __expectString(output.jsonPath),
+        matchEquals: __expectString(output.matchEquals),
+    };
+};
+const deserializeAws_json1_1WebhookFilters = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1WebhookFilterRule(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1WebhookList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_1ListWebhookItem(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_1WebhookNotFoundException = (output, context) => {
+    return {};
+};
+const deserializeMetadata = (output) => ({
+    httpStatusCode: output.statusCode,
+    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+    extendedRequestId: output.headers["x-amz-id-2"],
+    cfId: output.headers["x-amz-cf-id"],
+});
+const collectBody = (streamBody = new Uint8Array(), context) => {
+    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);
+};
+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;
+        if (typeof cleanValue === "number") {
+            cleanValue = cleanValue.toString();
+        }
+        if (cleanValue.indexOf(",") >= 0) {
+            cleanValue = cleanValue.split(",")[0];
+        }
+        if (cleanValue.indexOf(":") >= 0) {
+            cleanValue = cleanValue.split(":")[0];
+        }
+        if (cleanValue.indexOf("#") >= 0) {
+            cleanValue = cleanValue.split("#")[1];
+        }
+        return cleanValue;
+    };
+    const headerKey = findKey(output.headers, "x-amzn-errortype");
+    if (headerKey !== undefined) {
+        return sanitizeErrorCode(output.headers[headerKey]);
+    }
+    if (data.code !== undefined) {
+        return sanitizeErrorCode(data.code);
+    }
+    if (data["__type"] !== undefined) {
+        return sanitizeErrorCode(data["__type"]);
+    }
+};