@aws-sdk/client-kendra-ranking 3.247.0

package/dist-es/protocols/Aws_json1_0.js

@@ -0,0 +1,907 @@
+import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
+import { decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectString as __expectString, limitedParseFloat32 as __limitedParseFloat32, parseEpochTimestamp as __parseEpochTimestamp, serializeFloat as __serializeFloat, throwDefaultError, } from "@aws-sdk/smithy-client";
+import { v4 as generateIdempotencyToken } from "uuid";
+import { KendraRankingServiceException as __BaseException } from "../models/KendraRankingServiceException";
+import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ResourceUnavailableException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
+export const serializeAws_json1_0CreateRescoreExecutionPlanCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.0",
+        "x-amz-target": "AWSKendraRerankingFrontendService.CreateRescoreExecutionPlan",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_0CreateRescoreExecutionPlanRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_0DeleteRescoreExecutionPlanCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.0",
+        "x-amz-target": "AWSKendraRerankingFrontendService.DeleteRescoreExecutionPlan",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_0DeleteRescoreExecutionPlanRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_0DescribeRescoreExecutionPlanCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.0",
+        "x-amz-target": "AWSKendraRerankingFrontendService.DescribeRescoreExecutionPlan",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_0DescribeRescoreExecutionPlanRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_0ListRescoreExecutionPlansCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.0",
+        "x-amz-target": "AWSKendraRerankingFrontendService.ListRescoreExecutionPlans",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_0ListRescoreExecutionPlansRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_0ListTagsForResourceCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.0",
+        "x-amz-target": "AWSKendraRerankingFrontendService.ListTagsForResource",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_0ListTagsForResourceRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_0RescoreCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.0",
+        "x-amz-target": "AWSKendraRerankingFrontendService.Rescore",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_0RescoreRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_0TagResourceCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.0",
+        "x-amz-target": "AWSKendraRerankingFrontendService.TagResource",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_0TagResourceRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_0UntagResourceCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.0",
+        "x-amz-target": "AWSKendraRerankingFrontendService.UntagResource",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_0UntagResourceRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_json1_0UpdateRescoreExecutionPlanCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-amz-json-1.0",
+        "x-amz-target": "AWSKendraRerankingFrontendService.UpdateRescoreExecutionPlan",
+    };
+    let body;
+    body = JSON.stringify(serializeAws_json1_0UpdateRescoreExecutionPlanRequest(input, context));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const deserializeAws_json1_0CreateRescoreExecutionPlanCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_0CreateRescoreExecutionPlanCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_0CreateRescoreExecutionPlanResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_0CreateRescoreExecutionPlanCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.kendraranking#AccessDeniedException":
+            throw await deserializeAws_json1_0AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.kendraranking#ConflictException":
+            throw await deserializeAws_json1_0ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.kendraranking#InternalServerException":
+            throw await deserializeAws_json1_0InternalServerExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.kendraranking#ServiceQuotaExceededException":
+            throw await deserializeAws_json1_0ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.kendraranking#ThrottlingException":
+            throw await deserializeAws_json1_0ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.kendraranking#ValidationException":
+            throw await deserializeAws_json1_0ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_0DeleteRescoreExecutionPlanCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_0DeleteRescoreExecutionPlanCommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_0DeleteRescoreExecutionPlanCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.kendraranking#AccessDeniedException":
+            throw await deserializeAws_json1_0AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.kendraranking#ConflictException":
+            throw await deserializeAws_json1_0ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.kendraranking#InternalServerException":
+            throw await deserializeAws_json1_0InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.kendraranking#ResourceNotFoundException":
+            throw await deserializeAws_json1_0ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.kendraranking#ThrottlingException":
+            throw await deserializeAws_json1_0ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.kendraranking#ValidationException":
+            throw await deserializeAws_json1_0ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_0DescribeRescoreExecutionPlanCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_0DescribeRescoreExecutionPlanCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_0DescribeRescoreExecutionPlanResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_0DescribeRescoreExecutionPlanCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.kendraranking#AccessDeniedException":
+            throw await deserializeAws_json1_0AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.kendraranking#InternalServerException":
+            throw await deserializeAws_json1_0InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.kendraranking#ResourceNotFoundException":
+            throw await deserializeAws_json1_0ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.kendraranking#ThrottlingException":
+            throw await deserializeAws_json1_0ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.kendraranking#ValidationException":
+            throw await deserializeAws_json1_0ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_0ListRescoreExecutionPlansCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_0ListRescoreExecutionPlansCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_0ListRescoreExecutionPlansResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_0ListRescoreExecutionPlansCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.kendraranking#AccessDeniedException":
+            throw await deserializeAws_json1_0AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.kendraranking#InternalServerException":
+            throw await deserializeAws_json1_0InternalServerExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.kendraranking#ThrottlingException":
+            throw await deserializeAws_json1_0ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.kendraranking#ValidationException":
+            throw await deserializeAws_json1_0ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_0ListTagsForResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_0ListTagsForResourceCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_0ListTagsForResourceResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_0ListTagsForResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.kendraranking#AccessDeniedException":
+            throw await deserializeAws_json1_0AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.kendraranking#InternalServerException":
+            throw await deserializeAws_json1_0InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceUnavailableException":
+        case "com.amazonaws.kendraranking#ResourceUnavailableException":
+            throw await deserializeAws_json1_0ResourceUnavailableExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.kendraranking#ThrottlingException":
+            throw await deserializeAws_json1_0ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.kendraranking#ValidationException":
+            throw await deserializeAws_json1_0ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_0RescoreCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_0RescoreCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_0RescoreResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_0RescoreCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.kendraranking#AccessDeniedException":
+            throw await deserializeAws_json1_0AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.kendraranking#ConflictException":
+            throw await deserializeAws_json1_0ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.kendraranking#InternalServerException":
+            throw await deserializeAws_json1_0InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.kendraranking#ResourceNotFoundException":
+            throw await deserializeAws_json1_0ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.kendraranking#ThrottlingException":
+            throw await deserializeAws_json1_0ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.kendraranking#ValidationException":
+            throw await deserializeAws_json1_0ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_0TagResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_0TagResourceCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_0TagResourceResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_0TagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.kendraranking#AccessDeniedException":
+            throw await deserializeAws_json1_0AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.kendraranking#InternalServerException":
+            throw await deserializeAws_json1_0InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceUnavailableException":
+        case "com.amazonaws.kendraranking#ResourceUnavailableException":
+            throw await deserializeAws_json1_0ResourceUnavailableExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.kendraranking#ThrottlingException":
+            throw await deserializeAws_json1_0ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.kendraranking#ValidationException":
+            throw await deserializeAws_json1_0ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_0UntagResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_0UntagResourceCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_json1_0UntagResourceResponse(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_0UntagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.kendraranking#AccessDeniedException":
+            throw await deserializeAws_json1_0AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.kendraranking#InternalServerException":
+            throw await deserializeAws_json1_0InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceUnavailableException":
+        case "com.amazonaws.kendraranking#ResourceUnavailableException":
+            throw await deserializeAws_json1_0ResourceUnavailableExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.kendraranking#ThrottlingException":
+            throw await deserializeAws_json1_0ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.kendraranking#ValidationException":
+            throw await deserializeAws_json1_0ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_json1_0UpdateRescoreExecutionPlanCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_json1_0UpdateRescoreExecutionPlanCommandError(output, context);
+    }
+    await collectBody(output.body, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_json1_0UpdateRescoreExecutionPlanCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.kendraranking#AccessDeniedException":
+            throw await deserializeAws_json1_0AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.kendraranking#ConflictException":
+            throw await deserializeAws_json1_0ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.kendraranking#InternalServerException":
+            throw await deserializeAws_json1_0InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.kendraranking#ResourceNotFoundException":
+            throw await deserializeAws_json1_0ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.kendraranking#ServiceQuotaExceededException":
+            throw await deserializeAws_json1_0ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.kendraranking#ThrottlingException":
+            throw await deserializeAws_json1_0ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.kendraranking#ValidationException":
+            throw await deserializeAws_json1_0ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_json1_0AccessDeniedExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_0AccessDeniedException(body, context);
+    const exception = new AccessDeniedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_0ConflictExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_0ConflictException(body, context);
+    const exception = new ConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_0InternalServerExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_0InternalServerException(body, context);
+    const exception = new InternalServerException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_0ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_0ResourceNotFoundException(body, context);
+    const exception = new ResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_0ResourceUnavailableExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_0ResourceUnavailableException(body, context);
+    const exception = new ResourceUnavailableException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_0ServiceQuotaExceededExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_0ServiceQuotaExceededException(body, context);
+    const exception = new ServiceQuotaExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_0ThrottlingExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_0ThrottlingException(body, context);
+    const exception = new ThrottlingException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const deserializeAws_json1_0ValidationExceptionResponse = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = deserializeAws_json1_0ValidationException(body, context);
+    const exception = new ValidationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
+    });
+    return __decorateServiceException(exception, body);
+};
+const serializeAws_json1_0BodyTokensList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_json1_0CapacityUnitsConfiguration = (input, context) => {
+    return {
+        ...(input.RescoreCapacityUnits != null && { RescoreCapacityUnits: input.RescoreCapacityUnits }),
+    };
+};
+const serializeAws_json1_0CreateRescoreExecutionPlanRequest = (input, context) => {
+    return {
+        ...(input.CapacityUnits != null && {
+            CapacityUnits: serializeAws_json1_0CapacityUnitsConfiguration(input.CapacityUnits, context),
+        }),
+        ClientToken: input.ClientToken ?? generateIdempotencyToken(),
+        ...(input.Description != null && { Description: input.Description }),
+        ...(input.Name != null && { Name: input.Name }),
+        ...(input.Tags != null && { Tags: serializeAws_json1_0TagList(input.Tags, context) }),
+    };
+};
+const serializeAws_json1_0DeleteRescoreExecutionPlanRequest = (input, context) => {
+    return {
+        ...(input.Id != null && { Id: input.Id }),
+    };
+};
+const serializeAws_json1_0DescribeRescoreExecutionPlanRequest = (input, context) => {
+    return {
+        ...(input.Id != null && { Id: input.Id }),
+    };
+};
+const serializeAws_json1_0Document = (input, context) => {
+    return {
+        ...(input.Body != null && { Body: input.Body }),
+        ...(input.GroupId != null && { GroupId: input.GroupId }),
+        ...(input.Id != null && { Id: input.Id }),
+        ...(input.OriginalScore != null && { OriginalScore: __serializeFloat(input.OriginalScore) }),
+        ...(input.Title != null && { Title: input.Title }),
+        ...(input.TokenizedBody != null && {
+            TokenizedBody: serializeAws_json1_0BodyTokensList(input.TokenizedBody, context),
+        }),
+        ...(input.TokenizedTitle != null && {
+            TokenizedTitle: serializeAws_json1_0TitleTokensList(input.TokenizedTitle, context),
+        }),
+    };
+};
+const serializeAws_json1_0DocumentList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_json1_0Document(entry, context);
+    });
+};
+const serializeAws_json1_0ListRescoreExecutionPlansRequest = (input, context) => {
+    return {
+        ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
+        ...(input.NextToken != null && { NextToken: input.NextToken }),
+    };
+};
+const serializeAws_json1_0ListTagsForResourceRequest = (input, context) => {
+    return {
+        ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
+    };
+};
+const serializeAws_json1_0RescoreRequest = (input, context) => {
+    return {
+        ...(input.Documents != null && { Documents: serializeAws_json1_0DocumentList(input.Documents, context) }),
+        ...(input.RescoreExecutionPlanId != null && { RescoreExecutionPlanId: input.RescoreExecutionPlanId }),
+        ...(input.SearchQuery != null && { SearchQuery: input.SearchQuery }),
+    };
+};
+const serializeAws_json1_0Tag = (input, context) => {
+    return {
+        ...(input.Key != null && { Key: input.Key }),
+        ...(input.Value != null && { Value: input.Value }),
+    };
+};
+const serializeAws_json1_0TagKeyList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_json1_0TagList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_json1_0Tag(entry, context);
+    });
+};
+const serializeAws_json1_0TagResourceRequest = (input, context) => {
+    return {
+        ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
+        ...(input.Tags != null && { Tags: serializeAws_json1_0TagList(input.Tags, context) }),
+    };
+};
+const serializeAws_json1_0TitleTokensList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_json1_0UntagResourceRequest = (input, context) => {
+    return {
+        ...(input.ResourceARN != null && { ResourceARN: input.ResourceARN }),
+        ...(input.TagKeys != null && { TagKeys: serializeAws_json1_0TagKeyList(input.TagKeys, context) }),
+    };
+};
+const serializeAws_json1_0UpdateRescoreExecutionPlanRequest = (input, context) => {
+    return {
+        ...(input.CapacityUnits != null && {
+            CapacityUnits: serializeAws_json1_0CapacityUnitsConfiguration(input.CapacityUnits, context),
+        }),
+        ...(input.Description != null && { Description: input.Description }),
+        ...(input.Id != null && { Id: input.Id }),
+        ...(input.Name != null && { Name: input.Name }),
+    };
+};
+const deserializeAws_json1_0AccessDeniedException = (output, context) => {
+    return {
+        Message: __expectString(output.Message),
+    };
+};
+const deserializeAws_json1_0CapacityUnitsConfiguration = (output, context) => {
+    return {
+        RescoreCapacityUnits: __expectInt32(output.RescoreCapacityUnits),
+    };
+};
+const deserializeAws_json1_0ConflictException = (output, context) => {
+    return {
+        Message: __expectString(output.Message),
+    };
+};
+const deserializeAws_json1_0CreateRescoreExecutionPlanResponse = (output, context) => {
+    return {
+        Arn: __expectString(output.Arn),
+        Id: __expectString(output.Id),
+    };
+};
+const deserializeAws_json1_0DescribeRescoreExecutionPlanResponse = (output, context) => {
+    return {
+        Arn: __expectString(output.Arn),
+        CapacityUnits: output.CapacityUnits != null
+            ? deserializeAws_json1_0CapacityUnitsConfiguration(output.CapacityUnits, context)
+            : undefined,
+        CreatedAt: output.CreatedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreatedAt))) : undefined,
+        Description: __expectString(output.Description),
+        ErrorMessage: __expectString(output.ErrorMessage),
+        Id: __expectString(output.Id),
+        Name: __expectString(output.Name),
+        Status: __expectString(output.Status),
+        UpdatedAt: output.UpdatedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.UpdatedAt))) : undefined,
+    };
+};
+const deserializeAws_json1_0InternalServerException = (output, context) => {
+    return {
+        Message: __expectString(output.Message),
+    };
+};
+const deserializeAws_json1_0ListRescoreExecutionPlansResponse = (output, context) => {
+    return {
+        NextToken: __expectString(output.NextToken),
+        SummaryItems: output.SummaryItems != null
+            ? deserializeAws_json1_0RescoreExecutionPlanSummaryList(output.SummaryItems, context)
+            : undefined,
+    };
+};
+const deserializeAws_json1_0ListTagsForResourceResponse = (output, context) => {
+    return {
+        Tags: output.Tags != null ? deserializeAws_json1_0TagList(output.Tags, context) : undefined,
+    };
+};
+const deserializeAws_json1_0RescoreExecutionPlanSummary = (output, context) => {
+    return {
+        CreatedAt: output.CreatedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreatedAt))) : undefined,
+        Id: __expectString(output.Id),
+        Name: __expectString(output.Name),
+        Status: __expectString(output.Status),
+        UpdatedAt: output.UpdatedAt != null ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.UpdatedAt))) : undefined,
+    };
+};
+const deserializeAws_json1_0RescoreExecutionPlanSummaryList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_0RescoreExecutionPlanSummary(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_0RescoreResult = (output, context) => {
+    return {
+        RescoreId: __expectString(output.RescoreId),
+        ResultItems: output.ResultItems != null ? deserializeAws_json1_0RescoreResultItemList(output.ResultItems, context) : undefined,
+    };
+};
+const deserializeAws_json1_0RescoreResultItem = (output, context) => {
+    return {
+        DocumentId: __expectString(output.DocumentId),
+        Score: __limitedParseFloat32(output.Score),
+    };
+};
+const deserializeAws_json1_0RescoreResultItemList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_0RescoreResultItem(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_0ResourceNotFoundException = (output, context) => {
+    return {
+        Message: __expectString(output.Message),
+    };
+};
+const deserializeAws_json1_0ResourceUnavailableException = (output, context) => {
+    return {
+        Message: __expectString(output.Message),
+    };
+};
+const deserializeAws_json1_0ServiceQuotaExceededException = (output, context) => {
+    return {
+        Message: __expectString(output.Message),
+    };
+};
+const deserializeAws_json1_0Tag = (output, context) => {
+    return {
+        Key: __expectString(output.Key),
+        Value: __expectString(output.Value),
+    };
+};
+const deserializeAws_json1_0TagList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_json1_0Tag(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_json1_0TagResourceResponse = (output, context) => {
+    return {};
+};
+const deserializeAws_json1_0ThrottlingException = (output, context) => {
+    return {
+        Message: __expectString(output.Message),
+    };
+};
+const deserializeAws_json1_0UntagResourceResponse = (output, context) => {
+    return {};
+};
+const deserializeAws_json1_0ValidationException = (output, context) => {
+    return {
+        Message: __expectString(output.Message),
+    };
+};
+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"]);
+    }
+};