@aws-sdk/client-docdb-elastic 3.221.0

package/dist-es/protocols/Aws_restJson1.js

@@ -0,0 +1,1168 @@
+import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
+import { decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map as __map, resolvedPath as __resolvedPath, strictParseInt32 as __strictParseInt32, throwDefaultError, } from "@aws-sdk/smithy-client";
+import { v4 as generateIdempotencyToken } from "uuid";
+import { DocDBElasticServiceException as __BaseException } from "../models/DocDBElasticServiceException";
+import { AccessDeniedException, ConflictException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
+export const serializeAws_restJson1CreateClusterCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/cluster";
+    let body;
+    body = JSON.stringify({
+        ...(input.adminUserName != null && { adminUserName: input.adminUserName }),
+        ...(input.adminUserPassword != null && { adminUserPassword: input.adminUserPassword }),
+        ...(input.authType != null && { authType: input.authType }),
+        clientToken: input.clientToken ?? generateIdempotencyToken(),
+        ...(input.clusterName != null && { clusterName: input.clusterName }),
+        ...(input.kmsKeyId != null && { kmsKeyId: input.kmsKeyId }),
+        ...(input.preferredMaintenanceWindow != null && { preferredMaintenanceWindow: input.preferredMaintenanceWindow }),
+        ...(input.shardCapacity != null && { shardCapacity: input.shardCapacity }),
+        ...(input.shardCount != null && { shardCount: input.shardCount }),
+        ...(input.subnetIds != null && { subnetIds: serializeAws_restJson1StringList(input.subnetIds, context) }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+        ...(input.vpcSecurityGroupIds != null && {
+            vpcSecurityGroupIds: serializeAws_restJson1StringList(input.vpcSecurityGroupIds, context),
+        }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1CreateClusterSnapshotCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/cluster-snapshot";
+    let body;
+    body = JSON.stringify({
+        ...(input.clusterArn != null && { clusterArn: input.clusterArn }),
+        ...(input.snapshotName != null && { snapshotName: input.snapshotName }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1DeleteClusterCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/cluster/{clusterArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "clusterArn", () => input.clusterArn, "{clusterArn}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1DeleteClusterSnapshotCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/cluster-snapshot/{snapshotArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "snapshotArn", () => input.snapshotArn, "{snapshotArn}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1GetClusterCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/cluster/{clusterArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "clusterArn", () => input.clusterArn, "{clusterArn}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1GetClusterSnapshotCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/cluster-snapshot/{snapshotArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "snapshotArn", () => input.snapshotArn, "{snapshotArn}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1ListClustersCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/clusters";
+    const query = map({
+        nextToken: [, input.nextToken],
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const serializeAws_restJson1ListClusterSnapshotsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/cluster-snapshots";
+    const query = map({
+        clusterArn: [, input.clusterArn],
+        nextToken: [, input.nextToken],
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const serializeAws_restJson1ListTagsForResourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1RestoreClusterFromSnapshotCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/cluster-snapshot/{snapshotArn}/restore";
+    resolvedPath = __resolvedPath(resolvedPath, input, "snapshotArn", () => input.snapshotArn, "{snapshotArn}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.clusterName != null && { clusterName: input.clusterName }),
+        ...(input.kmsKeyId != null && { kmsKeyId: input.kmsKeyId }),
+        ...(input.subnetIds != null && { subnetIds: serializeAws_restJson1StringList(input.subnetIds, context) }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+        ...(input.vpcSecurityGroupIds != null && {
+            vpcSecurityGroupIds: serializeAws_restJson1StringList(input.vpcSecurityGroupIds, context),
+        }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1TagResourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UntagResourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    const query = map({
+        tagKeys: [
+            __expectNonNull(input.tagKeys, `tagKeys`) != null,
+            () => (input.tagKeys || []).map((_entry) => _entry),
+        ],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const serializeAws_restJson1UpdateClusterCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/cluster/{clusterArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "clusterArn", () => input.clusterArn, "{clusterArn}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.adminUserPassword != null && { adminUserPassword: input.adminUserPassword }),
+        ...(input.authType != null && { authType: input.authType }),
+        clientToken: input.clientToken ?? generateIdempotencyToken(),
+        ...(input.preferredMaintenanceWindow != null && { preferredMaintenanceWindow: input.preferredMaintenanceWindow }),
+        ...(input.shardCapacity != null && { shardCapacity: input.shardCapacity }),
+        ...(input.shardCount != null && { shardCount: input.shardCount }),
+        ...(input.subnetIds != null && { subnetIds: serializeAws_restJson1StringList(input.subnetIds, context) }),
+        ...(input.vpcSecurityGroupIds != null && {
+            vpcSecurityGroupIds: serializeAws_restJson1StringList(input.vpcSecurityGroupIds, context),
+        }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const deserializeAws_restJson1CreateClusterCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateClusterCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.cluster != null) {
+        contents.cluster = deserializeAws_restJson1Cluster(data.cluster, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1CreateClusterCommandError = 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.docdbelastic#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.docdbelastic#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.docdbelastic#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.docdbelastic#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.docdbelastic#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.docdbelastic#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1CreateClusterSnapshotCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateClusterSnapshotCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.snapshot != null) {
+        contents.snapshot = deserializeAws_restJson1ClusterSnapshot(data.snapshot, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1CreateClusterSnapshotCommandError = 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.docdbelastic#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.docdbelastic#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.docdbelastic#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.docdbelastic#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.docdbelastic#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.docdbelastic#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.docdbelastic#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteClusterCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteClusterCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.cluster != null) {
+        contents.cluster = deserializeAws_restJson1Cluster(data.cluster, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1DeleteClusterCommandError = 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.docdbelastic#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.docdbelastic#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.docdbelastic#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.docdbelastic#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.docdbelastic#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.docdbelastic#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteClusterSnapshotCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteClusterSnapshotCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.snapshot != null) {
+        contents.snapshot = deserializeAws_restJson1ClusterSnapshot(data.snapshot, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1DeleteClusterSnapshotCommandError = 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.docdbelastic#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.docdbelastic#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.docdbelastic#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.docdbelastic#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.docdbelastic#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.docdbelastic#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1GetClusterCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetClusterCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.cluster != null) {
+        contents.cluster = deserializeAws_restJson1Cluster(data.cluster, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1GetClusterCommandError = 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.docdbelastic#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.docdbelastic#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.docdbelastic#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.docdbelastic#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.docdbelastic#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1GetClusterSnapshotCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetClusterSnapshotCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.snapshot != null) {
+        contents.snapshot = deserializeAws_restJson1ClusterSnapshot(data.snapshot, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1GetClusterSnapshotCommandError = 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.docdbelastic#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.docdbelastic#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.docdbelastic#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.docdbelastic#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.docdbelastic#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1ListClustersCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListClustersCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.clusters != null) {
+        contents.clusters = deserializeAws_restJson1ClusterList(data.clusters, context);
+    }
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListClustersCommandError = 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.docdbelastic#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.docdbelastic#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.docdbelastic#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.docdbelastic#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1ListClusterSnapshotsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListClusterSnapshotsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
+    }
+    if (data.snapshots != null) {
+        contents.snapshots = deserializeAws_restJson1ClusterSnapshotList(data.snapshots, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListClusterSnapshotsCommandError = 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.docdbelastic#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.docdbelastic#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.docdbelastic#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.docdbelastic#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListTagsForResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagMap(data.tags, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.docdbelastic#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.docdbelastic#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.docdbelastic#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.docdbelastic#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1RestoreClusterFromSnapshotCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1RestoreClusterFromSnapshotCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.cluster != null) {
+        contents.cluster = deserializeAws_restJson1Cluster(data.cluster, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1RestoreClusterFromSnapshotCommandError = 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.docdbelastic#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.docdbelastic#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.docdbelastic#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.docdbelastic#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.docdbelastic#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.docdbelastic#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.docdbelastic#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1TagResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1TagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.docdbelastic#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.docdbelastic#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.docdbelastic#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.docdbelastic#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UntagResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1UntagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.docdbelastic#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.docdbelastic#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.docdbelastic#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.docdbelastic#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1UpdateClusterCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateClusterCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.cluster != null) {
+        contents.cluster = deserializeAws_restJson1Cluster(data.cluster, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1UpdateClusterCommandError = 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.docdbelastic#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.docdbelastic#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.docdbelastic#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.docdbelastic#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.docdbelastic#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.docdbelastic#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+const map = __map;
+const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = __expectString(data.message);
+    }
+    const exception = new AccessDeniedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = __expectString(data.message);
+    }
+    if (data.resourceId != null) {
+        contents.resourceId = __expectString(data.resourceId);
+    }
+    if (data.resourceType != null) {
+        contents.resourceType = __expectString(data.resourceType);
+    }
+    const exception = new ConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = __expectString(data.message);
+    }
+    const exception = new InternalServerException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = __expectString(data.message);
+    }
+    if (data.resourceId != null) {
+        contents.resourceId = __expectString(data.resourceId);
+    }
+    if (data.resourceType != null) {
+        contents.resourceType = __expectString(data.resourceType);
+    }
+    const exception = new ResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ServiceQuotaExceededExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = __expectString(data.message);
+    }
+    const exception = new ServiceQuotaExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({
+        retryAfterSeconds: [
+            () => void 0 !== parsedOutput.headers["retry-after"],
+            () => __strictParseInt32(parsedOutput.headers["retry-after"]),
+        ],
+    });
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = __expectString(data.message);
+    }
+    const exception = new ThrottlingException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.fieldList != null) {
+        contents.fieldList = deserializeAws_restJson1ValidationExceptionFieldList(data.fieldList, context);
+    }
+    if (data.message != null) {
+        contents.message = __expectString(data.message);
+    }
+    if (data.reason != null) {
+        contents.reason = __expectString(data.reason);
+    }
+    const exception = new ValidationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const serializeAws_restJson1StringList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_restJson1TagMap = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = value;
+        return acc;
+    }, {});
+};
+const deserializeAws_restJson1Cluster = (output, context) => {
+    return {
+        adminUserName: __expectString(output.adminUserName),
+        authType: __expectString(output.authType),
+        clusterArn: __expectString(output.clusterArn),
+        clusterEndpoint: __expectString(output.clusterEndpoint),
+        clusterName: __expectString(output.clusterName),
+        createTime: __expectString(output.createTime),
+        kmsKeyId: __expectString(output.kmsKeyId),
+        preferredMaintenanceWindow: __expectString(output.preferredMaintenanceWindow),
+        shardCapacity: __expectInt32(output.shardCapacity),
+        shardCount: __expectInt32(output.shardCount),
+        status: __expectString(output.status),
+        subnetIds: output.subnetIds != null ? deserializeAws_restJson1StringList(output.subnetIds, context) : undefined,
+        vpcSecurityGroupIds: output.vpcSecurityGroupIds != null
+            ? deserializeAws_restJson1StringList(output.vpcSecurityGroupIds, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1ClusterInList = (output, context) => {
+    return {
+        clusterArn: __expectString(output.clusterArn),
+        clusterName: __expectString(output.clusterName),
+        status: __expectString(output.status),
+    };
+};
+const deserializeAws_restJson1ClusterList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ClusterInList(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1ClusterSnapshot = (output, context) => {
+    return {
+        adminUserName: __expectString(output.adminUserName),
+        clusterArn: __expectString(output.clusterArn),
+        clusterCreationTime: __expectString(output.clusterCreationTime),
+        kmsKeyId: __expectString(output.kmsKeyId),
+        snapshotArn: __expectString(output.snapshotArn),
+        snapshotCreationTime: __expectString(output.snapshotCreationTime),
+        snapshotName: __expectString(output.snapshotName),
+        status: __expectString(output.status),
+        subnetIds: output.subnetIds != null ? deserializeAws_restJson1StringList(output.subnetIds, context) : undefined,
+        vpcSecurityGroupIds: output.vpcSecurityGroupIds != null
+            ? deserializeAws_restJson1StringList(output.vpcSecurityGroupIds, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1ClusterSnapshotInList = (output, context) => {
+    return {
+        clusterArn: __expectString(output.clusterArn),
+        snapshotArn: __expectString(output.snapshotArn),
+        snapshotCreationTime: __expectString(output.snapshotCreationTime),
+        snapshotName: __expectString(output.snapshotName),
+        status: __expectString(output.status),
+    };
+};
+const deserializeAws_restJson1ClusterSnapshotList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ClusterSnapshotInList(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1StringList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return __expectString(entry);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1TagMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = __expectString(value);
+        return acc;
+    }, {});
+};
+const deserializeAws_restJson1ValidationExceptionField = (output, context) => {
+    return {
+        message: __expectString(output.message),
+        name: __expectString(output.name),
+    };
+};
+const deserializeAws_restJson1ValidationExceptionFieldList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ValidationExceptionField(entry, context);
+    });
+    return retVal;
+};
+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 isSerializableHeaderValue = (value) => value !== undefined &&
+    value !== null &&
+    value !== "" &&
+    (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
+    (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+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"]);
+    }
+};