@aws-sdk/client-sagemaker-geospatial 3.221.0

package/dist-cjs/protocols/Aws_restJson1.js

@@ -0,0 +1,2776 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeAws_restJson1UntagResourceCommand = exports.deserializeAws_restJson1TagResourceCommand = exports.deserializeAws_restJson1StopVectorEnrichmentJobCommand = exports.deserializeAws_restJson1StopEarthObservationJobCommand = exports.deserializeAws_restJson1StartVectorEnrichmentJobCommand = exports.deserializeAws_restJson1StartEarthObservationJobCommand = exports.deserializeAws_restJson1SearchRasterDataCollectionCommand = exports.deserializeAws_restJson1ListVectorEnrichmentJobsCommand = exports.deserializeAws_restJson1ListTagsForResourceCommand = exports.deserializeAws_restJson1ListRasterDataCollectionsCommand = exports.deserializeAws_restJson1ListEarthObservationJobsCommand = exports.deserializeAws_restJson1GetVectorEnrichmentJobCommand = exports.deserializeAws_restJson1GetTileCommand = exports.deserializeAws_restJson1GetRasterDataCollectionCommand = exports.deserializeAws_restJson1GetEarthObservationJobCommand = exports.deserializeAws_restJson1ExportVectorEnrichmentJobCommand = exports.deserializeAws_restJson1ExportEarthObservationJobCommand = exports.deserializeAws_restJson1DeleteVectorEnrichmentJobCommand = exports.deserializeAws_restJson1DeleteEarthObservationJobCommand = exports.serializeAws_restJson1UntagResourceCommand = exports.serializeAws_restJson1TagResourceCommand = exports.serializeAws_restJson1StopVectorEnrichmentJobCommand = exports.serializeAws_restJson1StopEarthObservationJobCommand = exports.serializeAws_restJson1StartVectorEnrichmentJobCommand = exports.serializeAws_restJson1StartEarthObservationJobCommand = exports.serializeAws_restJson1SearchRasterDataCollectionCommand = exports.serializeAws_restJson1ListVectorEnrichmentJobsCommand = exports.serializeAws_restJson1ListTagsForResourceCommand = exports.serializeAws_restJson1ListRasterDataCollectionsCommand = exports.serializeAws_restJson1ListEarthObservationJobsCommand = exports.serializeAws_restJson1GetVectorEnrichmentJobCommand = exports.serializeAws_restJson1GetTileCommand = exports.serializeAws_restJson1GetRasterDataCollectionCommand = exports.serializeAws_restJson1GetEarthObservationJobCommand = exports.serializeAws_restJson1ExportVectorEnrichmentJobCommand = exports.serializeAws_restJson1ExportEarthObservationJobCommand = exports.serializeAws_restJson1DeleteVectorEnrichmentJobCommand = exports.serializeAws_restJson1DeleteEarthObservationJobCommand = void 0;
+const protocol_http_1 = require("@aws-sdk/protocol-http");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const uuid_1 = require("uuid");
+const models_0_1 = require("../models/models_0");
+const SageMakerGeospatialServiceException_1 = require("../models/SageMakerGeospatialServiceException");
+const serializeAws_restJson1DeleteEarthObservationJobCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/earth-observation-jobs/{Arn}";
+    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Arn", () => input.Arn, "{Arn}", false);
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1DeleteEarthObservationJobCommand = serializeAws_restJson1DeleteEarthObservationJobCommand;
+const serializeAws_restJson1DeleteVectorEnrichmentJobCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vector-enrichment-jobs/{Arn}";
+    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Arn", () => input.Arn, "{Arn}", false);
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1DeleteVectorEnrichmentJobCommand = serializeAws_restJson1DeleteVectorEnrichmentJobCommand;
+const serializeAws_restJson1ExportEarthObservationJobCommand = 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 || ""}` + "/export-earth-observation-job";
+    let body;
+    body = JSON.stringify({
+        ...(input.Arn != null && { Arn: input.Arn }),
+        ...(input.ExecutionRoleArn != null && { ExecutionRoleArn: input.ExecutionRoleArn }),
+        ...(input.ExportSourceImages != null && { ExportSourceImages: input.ExportSourceImages }),
+        ...(input.OutputConfig != null && {
+            OutputConfig: serializeAws_restJson1OutputConfigInput(input.OutputConfig, context),
+        }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1ExportEarthObservationJobCommand = serializeAws_restJson1ExportEarthObservationJobCommand;
+const serializeAws_restJson1ExportVectorEnrichmentJobCommand = 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 || ""}` + "/export-vector-enrichment-jobs";
+    let body;
+    body = JSON.stringify({
+        ...(input.Arn != null && { Arn: input.Arn }),
+        ...(input.ExecutionRoleArn != null && { ExecutionRoleArn: input.ExecutionRoleArn }),
+        ...(input.OutputConfig != null && {
+            OutputConfig: serializeAws_restJson1ExportVectorEnrichmentJobOutputConfig(input.OutputConfig, context),
+        }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1ExportVectorEnrichmentJobCommand = serializeAws_restJson1ExportVectorEnrichmentJobCommand;
+const serializeAws_restJson1GetEarthObservationJobCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/earth-observation-jobs/{Arn}";
+    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Arn", () => input.Arn, "{Arn}", false);
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetEarthObservationJobCommand = serializeAws_restJson1GetEarthObservationJobCommand;
+const serializeAws_restJson1GetRasterDataCollectionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/raster-data-collection/{Arn}";
+    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Arn", () => input.Arn, "{Arn}", false);
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetRasterDataCollectionCommand = serializeAws_restJson1GetRasterDataCollectionCommand;
+const serializeAws_restJson1GetTileCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tile/{z}/{x}/{y}";
+    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "x", () => input.x.toString(), "{x}", false);
+    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "y", () => input.y.toString(), "{y}", false);
+    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "z", () => input.z.toString(), "{z}", false);
+    const query = map({
+        ImageAssets: [
+            (0, smithy_client_1.expectNonNull)(input.ImageAssets, `ImageAssets`) != null,
+            () => (input.ImageAssets || []).map((_entry) => _entry),
+        ],
+        Target: [, (0, smithy_client_1.expectNonNull)(input.Target, `Target`)],
+        Arn: [, (0, smithy_client_1.expectNonNull)(input.Arn, `Arn`)],
+        ImageMask: [() => input.ImageMask !== void 0, () => input.ImageMask.toString()],
+        OutputFormat: [, input.OutputFormat],
+        TimeRangeFilter: [, input.TimeRangeFilter],
+        PropertyFilters: [, input.PropertyFilters],
+        OutputDataType: [, input.OutputDataType],
+    });
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetTileCommand = serializeAws_restJson1GetTileCommand;
+const serializeAws_restJson1GetVectorEnrichmentJobCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/vector-enrichment-jobs/{Arn}";
+    resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Arn", () => input.Arn, "{Arn}", false);
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1GetVectorEnrichmentJobCommand = serializeAws_restJson1GetVectorEnrichmentJobCommand;
+const serializeAws_restJson1ListEarthObservationJobsCommand = 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 || ""}` + "/list-earth-observation-jobs";
+    let body;
+    body = JSON.stringify({
+        ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
+        ...(input.NextToken != null && { NextToken: input.NextToken }),
+        ...(input.SortBy != null && { SortBy: input.SortBy }),
+        ...(input.SortOrder != null && { SortOrder: input.SortOrder }),
+        ...(input.StatusEquals != null && { StatusEquals: input.StatusEquals }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListEarthObservationJobsCommand = serializeAws_restJson1ListEarthObservationJobsCommand;
+const serializeAws_restJson1ListRasterDataCollectionsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/raster-data-collections";
+    const query = map({
+        NextToken: [, input.NextToken],
+        MaxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
+    });
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListRasterDataCollectionsCommand = serializeAws_restJson1ListRasterDataCollectionsCommand;
+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 = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListTagsForResourceCommand = serializeAws_restJson1ListTagsForResourceCommand;
+const serializeAws_restJson1ListVectorEnrichmentJobsCommand = 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 || ""}` + "/list-vector-enrichment-jobs";
+    let body;
+    body = JSON.stringify({
+        ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
+        ...(input.NextToken != null && { NextToken: input.NextToken }),
+        ...(input.SortBy != null && { SortBy: input.SortBy }),
+        ...(input.SortOrder != null && { SortOrder: input.SortOrder }),
+        ...(input.StatusEquals != null && { StatusEquals: input.StatusEquals }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1ListVectorEnrichmentJobsCommand = serializeAws_restJson1ListVectorEnrichmentJobsCommand;
+const serializeAws_restJson1SearchRasterDataCollectionCommand = 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 || ""}` + "/search-raster-data-collection";
+    let body;
+    body = JSON.stringify({
+        ...(input.Arn != null && { Arn: input.Arn }),
+        ...(input.NextToken != null && { NextToken: input.NextToken }),
+        ...(input.RasterDataCollectionQuery != null && {
+            RasterDataCollectionQuery: serializeAws_restJson1RasterDataCollectionQueryWithBandFilterInput(input.RasterDataCollectionQuery, context),
+        }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1SearchRasterDataCollectionCommand = serializeAws_restJson1SearchRasterDataCollectionCommand;
+const serializeAws_restJson1StartEarthObservationJobCommand = 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 || ""}` + "/earth-observation-jobs";
+    let body;
+    body = JSON.stringify({
+        ClientToken: input.ClientToken ?? (0, uuid_1.v4)(),
+        ...(input.ExecutionRoleArn != null && { ExecutionRoleArn: input.ExecutionRoleArn }),
+        ...(input.InputConfig != null && {
+            InputConfig: serializeAws_restJson1InputConfigInput(input.InputConfig, context),
+        }),
+        ...(input.JobConfig != null && { JobConfig: serializeAws_restJson1JobConfigInput(input.JobConfig, context) }),
+        ...(input.KmsKeyId != null && { KmsKeyId: input.KmsKeyId }),
+        ...(input.Name != null && { Name: input.Name }),
+        ...(input.Tags != null && { Tags: serializeAws_restJson1Tags(input.Tags, context) }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1StartEarthObservationJobCommand = serializeAws_restJson1StartEarthObservationJobCommand;
+const serializeAws_restJson1StartVectorEnrichmentJobCommand = 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 || ""}` + "/vector-enrichment-jobs";
+    let body;
+    body = JSON.stringify({
+        ClientToken: input.ClientToken ?? (0, uuid_1.v4)(),
+        ...(input.ExecutionRoleArn != null && { ExecutionRoleArn: input.ExecutionRoleArn }),
+        ...(input.InputConfig != null && {
+            InputConfig: serializeAws_restJson1VectorEnrichmentJobInputConfig(input.InputConfig, context),
+        }),
+        ...(input.JobConfig != null && {
+            JobConfig: serializeAws_restJson1VectorEnrichmentJobConfig(input.JobConfig, context),
+        }),
+        ...(input.KmsKeyId != null && { KmsKeyId: input.KmsKeyId }),
+        ...(input.Name != null && { Name: input.Name }),
+        ...(input.Tags != null && { Tags: serializeAws_restJson1Tags(input.Tags, context) }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1StartVectorEnrichmentJobCommand = serializeAws_restJson1StartVectorEnrichmentJobCommand;
+const serializeAws_restJson1StopEarthObservationJobCommand = 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 || ""}` + "/earth-observation-jobs/stop";
+    let body;
+    body = JSON.stringify({
+        ...(input.Arn != null && { Arn: input.Arn }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1StopEarthObservationJobCommand = serializeAws_restJson1StopEarthObservationJobCommand;
+const serializeAws_restJson1StopVectorEnrichmentJobCommand = 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 || ""}` + "/vector-enrichment-jobs/stop";
+    let body;
+    body = JSON.stringify({
+        ...(input.Arn != null && { Arn: input.Arn }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1StopVectorEnrichmentJobCommand = serializeAws_restJson1StopVectorEnrichmentJobCommand;
+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 = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.Tags != null && { Tags: serializeAws_restJson1Tags(input.Tags, context) }),
+    });
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+exports.serializeAws_restJson1TagResourceCommand = serializeAws_restJson1TagResourceCommand;
+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 = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+    const query = map({
+        tagKeys: [
+            (0, smithy_client_1.expectNonNull)(input.TagKeys, `TagKeys`) != null,
+            () => (input.TagKeys || []).map((_entry) => _entry),
+        ],
+    });
+    let body;
+    return new protocol_http_1.HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+exports.serializeAws_restJson1UntagResourceCommand = serializeAws_restJson1UntagResourceCommand;
+const deserializeAws_restJson1DeleteEarthObservationJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteEarthObservationJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+exports.deserializeAws_restJson1DeleteEarthObservationJobCommand = deserializeAws_restJson1DeleteEarthObservationJobCommand;
+const deserializeAws_restJson1DeleteEarthObservationJobCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.sagemakergeospatial#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1DeleteVectorEnrichmentJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteVectorEnrichmentJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+exports.deserializeAws_restJson1DeleteVectorEnrichmentJobCommand = deserializeAws_restJson1DeleteVectorEnrichmentJobCommand;
+const deserializeAws_restJson1DeleteVectorEnrichmentJobCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.sagemakergeospatial#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1ExportEarthObservationJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ExportEarthObservationJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
+    if (data.Arn != null) {
+        contents.Arn = (0, smithy_client_1.expectString)(data.Arn);
+    }
+    if (data.CreationTime != null) {
+        contents.CreationTime = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(data.CreationTime)));
+    }
+    if (data.ExecutionRoleArn != null) {
+        contents.ExecutionRoleArn = (0, smithy_client_1.expectString)(data.ExecutionRoleArn);
+    }
+    if (data.ExportSourceImages != null) {
+        contents.ExportSourceImages = (0, smithy_client_1.expectBoolean)(data.ExportSourceImages);
+    }
+    if (data.ExportStatus != null) {
+        contents.ExportStatus = (0, smithy_client_1.expectString)(data.ExportStatus);
+    }
+    if (data.OutputConfig != null) {
+        contents.OutputConfig = deserializeAws_restJson1OutputConfigInput(data.OutputConfig, context);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1ExportEarthObservationJobCommand = deserializeAws_restJson1ExportEarthObservationJobCommand;
+const deserializeAws_restJson1ExportEarthObservationJobCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.sagemakergeospatial#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.sagemakergeospatial#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1ExportVectorEnrichmentJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ExportVectorEnrichmentJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
+    if (data.Arn != null) {
+        contents.Arn = (0, smithy_client_1.expectString)(data.Arn);
+    }
+    if (data.CreationTime != null) {
+        contents.CreationTime = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(data.CreationTime)));
+    }
+    if (data.ExecutionRoleArn != null) {
+        contents.ExecutionRoleArn = (0, smithy_client_1.expectString)(data.ExecutionRoleArn);
+    }
+    if (data.ExportStatus != null) {
+        contents.ExportStatus = (0, smithy_client_1.expectString)(data.ExportStatus);
+    }
+    if (data.OutputConfig != null) {
+        contents.OutputConfig = deserializeAws_restJson1ExportVectorEnrichmentJobOutputConfig(data.OutputConfig, context);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1ExportVectorEnrichmentJobCommand = deserializeAws_restJson1ExportVectorEnrichmentJobCommand;
+const deserializeAws_restJson1ExportVectorEnrichmentJobCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.sagemakergeospatial#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.sagemakergeospatial#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1GetEarthObservationJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetEarthObservationJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
+    if (data.Arn != null) {
+        contents.Arn = (0, smithy_client_1.expectString)(data.Arn);
+    }
+    if (data.CreationTime != null) {
+        contents.CreationTime = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(data.CreationTime)));
+    }
+    if (data.DurationInSeconds != null) {
+        contents.DurationInSeconds = (0, smithy_client_1.expectInt32)(data.DurationInSeconds);
+    }
+    if (data.ErrorDetails != null) {
+        contents.ErrorDetails = deserializeAws_restJson1EarthObservationJobErrorDetails(data.ErrorDetails, context);
+    }
+    if (data.ExecutionRoleArn != null) {
+        contents.ExecutionRoleArn = (0, smithy_client_1.expectString)(data.ExecutionRoleArn);
+    }
+    if (data.ExportErrorDetails != null) {
+        contents.ExportErrorDetails = deserializeAws_restJson1ExportErrorDetails(data.ExportErrorDetails, context);
+    }
+    if (data.ExportStatus != null) {
+        contents.ExportStatus = (0, smithy_client_1.expectString)(data.ExportStatus);
+    }
+    if (data.InputConfig != null) {
+        contents.InputConfig = deserializeAws_restJson1InputConfigOutput(data.InputConfig, context);
+    }
+    if (data.JobConfig != null) {
+        contents.JobConfig = deserializeAws_restJson1JobConfigInput((0, smithy_client_1.expectUnion)(data.JobConfig), context);
+    }
+    if (data.KmsKeyId != null) {
+        contents.KmsKeyId = (0, smithy_client_1.expectString)(data.KmsKeyId);
+    }
+    if (data.Name != null) {
+        contents.Name = (0, smithy_client_1.expectString)(data.Name);
+    }
+    if (data.OutputBands != null) {
+        contents.OutputBands = deserializeAws_restJson1EarthObservationJobOutputBands(data.OutputBands, context);
+    }
+    if (data.Status != null) {
+        contents.Status = (0, smithy_client_1.expectString)(data.Status);
+    }
+    if (data.Tags != null) {
+        contents.Tags = deserializeAws_restJson1Tags(data.Tags, context);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1GetEarthObservationJobCommand = deserializeAws_restJson1GetEarthObservationJobCommand;
+const deserializeAws_restJson1GetEarthObservationJobCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1GetRasterDataCollectionCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetRasterDataCollectionCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
+    if (data.Arn != null) {
+        contents.Arn = (0, smithy_client_1.expectString)(data.Arn);
+    }
+    if (data.Description != null) {
+        contents.Description = (0, smithy_client_1.expectString)(data.Description);
+    }
+    if (data.DescriptionPageUrl != null) {
+        contents.DescriptionPageUrl = (0, smithy_client_1.expectString)(data.DescriptionPageUrl);
+    }
+    if (data.ImageSourceBands != null) {
+        contents.ImageSourceBands = deserializeAws_restJson1ImageSourceBandList(data.ImageSourceBands, context);
+    }
+    if (data.Name != null) {
+        contents.Name = (0, smithy_client_1.expectString)(data.Name);
+    }
+    if (data.SupportedFilters != null) {
+        contents.SupportedFilters = deserializeAws_restJson1FilterList(data.SupportedFilters, context);
+    }
+    if (data.Tags != null) {
+        contents.Tags = deserializeAws_restJson1Tags(data.Tags, context);
+    }
+    if (data.Type != null) {
+        contents.Type = (0, smithy_client_1.expectString)(data.Type);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1GetRasterDataCollectionCommand = deserializeAws_restJson1GetRasterDataCollectionCommand;
+const deserializeAws_restJson1GetRasterDataCollectionCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1GetTileCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetTileCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = output.body;
+    context.sdkStreamMixin(data);
+    contents.BinaryFile = data;
+    return contents;
+};
+exports.deserializeAws_restJson1GetTileCommand = deserializeAws_restJson1GetTileCommand;
+const deserializeAws_restJson1GetTileCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1GetVectorEnrichmentJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetVectorEnrichmentJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
+    if (data.Arn != null) {
+        contents.Arn = (0, smithy_client_1.expectString)(data.Arn);
+    }
+    if (data.CreationTime != null) {
+        contents.CreationTime = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(data.CreationTime)));
+    }
+    if (data.DurationInSeconds != null) {
+        contents.DurationInSeconds = (0, smithy_client_1.expectInt32)(data.DurationInSeconds);
+    }
+    if (data.ErrorDetails != null) {
+        contents.ErrorDetails = deserializeAws_restJson1VectorEnrichmentJobErrorDetails(data.ErrorDetails, context);
+    }
+    if (data.ExecutionRoleArn != null) {
+        contents.ExecutionRoleArn = (0, smithy_client_1.expectString)(data.ExecutionRoleArn);
+    }
+    if (data.ExportErrorDetails != null) {
+        contents.ExportErrorDetails = deserializeAws_restJson1VectorEnrichmentJobExportErrorDetails(data.ExportErrorDetails, context);
+    }
+    if (data.ExportStatus != null) {
+        contents.ExportStatus = (0, smithy_client_1.expectString)(data.ExportStatus);
+    }
+    if (data.InputConfig != null) {
+        contents.InputConfig = deserializeAws_restJson1VectorEnrichmentJobInputConfig(data.InputConfig, context);
+    }
+    if (data.JobConfig != null) {
+        contents.JobConfig = deserializeAws_restJson1VectorEnrichmentJobConfig((0, smithy_client_1.expectUnion)(data.JobConfig), context);
+    }
+    if (data.KmsKeyId != null) {
+        contents.KmsKeyId = (0, smithy_client_1.expectString)(data.KmsKeyId);
+    }
+    if (data.Name != null) {
+        contents.Name = (0, smithy_client_1.expectString)(data.Name);
+    }
+    if (data.Status != null) {
+        contents.Status = (0, smithy_client_1.expectString)(data.Status);
+    }
+    if (data.Tags != null) {
+        contents.Tags = deserializeAws_restJson1Tags(data.Tags, context);
+    }
+    if (data.Type != null) {
+        contents.Type = (0, smithy_client_1.expectString)(data.Type);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1GetVectorEnrichmentJobCommand = deserializeAws_restJson1GetVectorEnrichmentJobCommand;
+const deserializeAws_restJson1GetVectorEnrichmentJobCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1ListEarthObservationJobsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListEarthObservationJobsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
+    if (data.EarthObservationJobSummaries != null) {
+        contents.EarthObservationJobSummaries = deserializeAws_restJson1EarthObservationJobList(data.EarthObservationJobSummaries, context);
+    }
+    if (data.NextToken != null) {
+        contents.NextToken = (0, smithy_client_1.expectString)(data.NextToken);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1ListEarthObservationJobsCommand = deserializeAws_restJson1ListEarthObservationJobsCommand;
+const deserializeAws_restJson1ListEarthObservationJobsCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1ListRasterDataCollectionsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListRasterDataCollectionsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
+    if (data.NextToken != null) {
+        contents.NextToken = (0, smithy_client_1.expectString)(data.NextToken);
+    }
+    if (data.RasterDataCollectionSummaries != null) {
+        contents.RasterDataCollectionSummaries = deserializeAws_restJson1DataCollectionsList(data.RasterDataCollectionSummaries, context);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1ListRasterDataCollectionsCommand = deserializeAws_restJson1ListRasterDataCollectionsCommand;
+const deserializeAws_restJson1ListRasterDataCollectionsCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+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 = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
+    if (data.Tags != null) {
+        contents.Tags = deserializeAws_restJson1Tags(data.Tags, context);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1ListTagsForResourceCommand = deserializeAws_restJson1ListTagsForResourceCommand;
+const deserializeAws_restJson1ListTagsForResourceCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1ListVectorEnrichmentJobsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListVectorEnrichmentJobsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
+    if (data.NextToken != null) {
+        contents.NextToken = (0, smithy_client_1.expectString)(data.NextToken);
+    }
+    if (data.VectorEnrichmentJobSummaries != null) {
+        contents.VectorEnrichmentJobSummaries = deserializeAws_restJson1VectorEnrichmentJobList(data.VectorEnrichmentJobSummaries, context);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1ListVectorEnrichmentJobsCommand = deserializeAws_restJson1ListVectorEnrichmentJobsCommand;
+const deserializeAws_restJson1ListVectorEnrichmentJobsCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1SearchRasterDataCollectionCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1SearchRasterDataCollectionCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
+    if (data.ApproximateResultCount != null) {
+        contents.ApproximateResultCount = (0, smithy_client_1.expectInt32)(data.ApproximateResultCount);
+    }
+    if (data.Items != null) {
+        contents.Items = deserializeAws_restJson1ItemSourceList(data.Items, context);
+    }
+    if (data.NextToken != null) {
+        contents.NextToken = (0, smithy_client_1.expectString)(data.NextToken);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1SearchRasterDataCollectionCommand = deserializeAws_restJson1SearchRasterDataCollectionCommand;
+const deserializeAws_restJson1SearchRasterDataCollectionCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1StartEarthObservationJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1StartEarthObservationJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
+    if (data.Arn != null) {
+        contents.Arn = (0, smithy_client_1.expectString)(data.Arn);
+    }
+    if (data.CreationTime != null) {
+        contents.CreationTime = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(data.CreationTime)));
+    }
+    if (data.DurationInSeconds != null) {
+        contents.DurationInSeconds = (0, smithy_client_1.expectInt32)(data.DurationInSeconds);
+    }
+    if (data.ExecutionRoleArn != null) {
+        contents.ExecutionRoleArn = (0, smithy_client_1.expectString)(data.ExecutionRoleArn);
+    }
+    if (data.InputConfig != null) {
+        contents.InputConfig = deserializeAws_restJson1InputConfigOutput(data.InputConfig, context);
+    }
+    if (data.JobConfig != null) {
+        contents.JobConfig = deserializeAws_restJson1JobConfigInput((0, smithy_client_1.expectUnion)(data.JobConfig), context);
+    }
+    if (data.KmsKeyId != null) {
+        contents.KmsKeyId = (0, smithy_client_1.expectString)(data.KmsKeyId);
+    }
+    if (data.Name != null) {
+        contents.Name = (0, smithy_client_1.expectString)(data.Name);
+    }
+    if (data.Status != null) {
+        contents.Status = (0, smithy_client_1.expectString)(data.Status);
+    }
+    if (data.Tags != null) {
+        contents.Tags = deserializeAws_restJson1Tags(data.Tags, context);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1StartEarthObservationJobCommand = deserializeAws_restJson1StartEarthObservationJobCommand;
+const deserializeAws_restJson1StartEarthObservationJobCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.sagemakergeospatial#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.sagemakergeospatial#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1StartVectorEnrichmentJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1StartVectorEnrichmentJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
+    if (data.Arn != null) {
+        contents.Arn = (0, smithy_client_1.expectString)(data.Arn);
+    }
+    if (data.CreationTime != null) {
+        contents.CreationTime = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(data.CreationTime)));
+    }
+    if (data.DurationInSeconds != null) {
+        contents.DurationInSeconds = (0, smithy_client_1.expectInt32)(data.DurationInSeconds);
+    }
+    if (data.ExecutionRoleArn != null) {
+        contents.ExecutionRoleArn = (0, smithy_client_1.expectString)(data.ExecutionRoleArn);
+    }
+    if (data.InputConfig != null) {
+        contents.InputConfig = deserializeAws_restJson1VectorEnrichmentJobInputConfig(data.InputConfig, context);
+    }
+    if (data.JobConfig != null) {
+        contents.JobConfig = deserializeAws_restJson1VectorEnrichmentJobConfig((0, smithy_client_1.expectUnion)(data.JobConfig), context);
+    }
+    if (data.KmsKeyId != null) {
+        contents.KmsKeyId = (0, smithy_client_1.expectString)(data.KmsKeyId);
+    }
+    if (data.Name != null) {
+        contents.Name = (0, smithy_client_1.expectString)(data.Name);
+    }
+    if (data.Status != null) {
+        contents.Status = (0, smithy_client_1.expectString)(data.Status);
+    }
+    if (data.Tags != null) {
+        contents.Tags = deserializeAws_restJson1Tags(data.Tags, context);
+    }
+    if (data.Type != null) {
+        contents.Type = (0, smithy_client_1.expectString)(data.Type);
+    }
+    return contents;
+};
+exports.deserializeAws_restJson1StartVectorEnrichmentJobCommand = deserializeAws_restJson1StartVectorEnrichmentJobCommand;
+const deserializeAws_restJson1StartVectorEnrichmentJobCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.sagemakergeospatial#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.sagemakergeospatial#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1StopEarthObservationJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1StopEarthObservationJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+exports.deserializeAws_restJson1StopEarthObservationJobCommand = deserializeAws_restJson1StopEarthObservationJobCommand;
+const deserializeAws_restJson1StopEarthObservationJobCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.sagemakergeospatial#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+const deserializeAws_restJson1StopVectorEnrichmentJobCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1StopVectorEnrichmentJobCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+exports.deserializeAws_restJson1StopVectorEnrichmentJobCommand = deserializeAws_restJson1StopVectorEnrichmentJobCommand;
+const deserializeAws_restJson1StopVectorEnrichmentJobCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.sagemakergeospatial#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+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;
+};
+exports.deserializeAws_restJson1TagResourceCommand = deserializeAws_restJson1TagResourceCommand;
+const deserializeAws_restJson1TagResourceCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+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;
+};
+exports.deserializeAws_restJson1UntagResourceCommand = deserializeAws_restJson1UntagResourceCommand;
+const deserializeAws_restJson1UntagResourceCommandError = 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.sagemakergeospatial#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.sagemakergeospatial#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.sagemakergeospatial#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException,
+                errorCode,
+            });
+    }
+};
+const map = smithy_client_1.map;
+const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.Message != null) {
+        contents.Message = (0, smithy_client_1.expectString)(data.Message);
+    }
+    const exception = new models_0_1.AccessDeniedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.Message != null) {
+        contents.Message = (0, smithy_client_1.expectString)(data.Message);
+    }
+    if (data.ResourceId != null) {
+        contents.ResourceId = (0, smithy_client_1.expectString)(data.ResourceId);
+    }
+    const exception = new models_0_1.ConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.Message != null) {
+        contents.Message = (0, smithy_client_1.expectString)(data.Message);
+    }
+    if (data.ResourceId != null) {
+        contents.ResourceId = (0, smithy_client_1.expectString)(data.ResourceId);
+    }
+    const exception = new models_0_1.InternalServerException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.Message != null) {
+        contents.Message = (0, smithy_client_1.expectString)(data.Message);
+    }
+    if (data.ResourceId != null) {
+        contents.ResourceId = (0, smithy_client_1.expectString)(data.ResourceId);
+    }
+    const exception = new models_0_1.ResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ServiceQuotaExceededExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.Message != null) {
+        contents.Message = (0, smithy_client_1.expectString)(data.Message);
+    }
+    if (data.ResourceId != null) {
+        contents.ResourceId = (0, smithy_client_1.expectString)(data.ResourceId);
+    }
+    const exception = new models_0_1.ServiceQuotaExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.Message != null) {
+        contents.Message = (0, smithy_client_1.expectString)(data.Message);
+    }
+    if (data.ResourceId != null) {
+        contents.ResourceId = (0, smithy_client_1.expectString)(data.ResourceId);
+    }
+    const exception = new models_0_1.ThrottlingException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.Message != null) {
+        contents.Message = (0, smithy_client_1.expectString)(data.Message);
+    }
+    if (data.ResourceId != null) {
+        contents.ResourceId = (0, smithy_client_1.expectString)(data.ResourceId);
+    }
+    const exception = new models_0_1.ValidationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
+};
+const serializeAws_restJson1AreaOfInterest = (input, context) => {
+    return models_0_1.AreaOfInterest.visit(input, {
+        AreaOfInterestGeometry: (value) => ({
+            AreaOfInterestGeometry: serializeAws_restJson1AreaOfInterestGeometry(value, context),
+        }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const serializeAws_restJson1AreaOfInterestGeometry = (input, context) => {
+    return models_0_1.AreaOfInterestGeometry.visit(input, {
+        MultiPolygonGeometry: (value) => ({
+            MultiPolygonGeometry: serializeAws_restJson1MultiPolygonGeometryInput(value, context),
+        }),
+        PolygonGeometry: (value) => ({ PolygonGeometry: serializeAws_restJson1PolygonGeometryInput(value, context) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const serializeAws_restJson1BandMathConfigInput = (input, context) => {
+    return {
+        ...(input.CustomIndices != null && {
+            CustomIndices: serializeAws_restJson1CustomIndicesInput(input.CustomIndices, context),
+        }),
+        ...(input.PredefinedIndices != null && {
+            PredefinedIndices: serializeAws_restJson1StringListInput(input.PredefinedIndices, context),
+        }),
+    };
+};
+const serializeAws_restJson1CloudMaskingConfigInput = (input, context) => {
+    return {};
+};
+const serializeAws_restJson1CloudRemovalConfigInput = (input, context) => {
+    return {
+        ...(input.AlgorithmName != null && { AlgorithmName: input.AlgorithmName }),
+        ...(input.InterpolationValue != null && { InterpolationValue: input.InterpolationValue }),
+        ...(input.TargetBands != null && {
+            TargetBands: serializeAws_restJson1StringListInput(input.TargetBands, context),
+        }),
+    };
+};
+const serializeAws_restJson1CustomIndicesInput = (input, context) => {
+    return {
+        ...(input.Operations != null && {
+            Operations: serializeAws_restJson1OperationsListInput(input.Operations, context),
+        }),
+    };
+};
+const serializeAws_restJson1EoCloudCoverInput = (input, context) => {
+    return {
+        ...(input.LowerBound != null && { LowerBound: (0, smithy_client_1.serializeFloat)(input.LowerBound) }),
+        ...(input.UpperBound != null && { UpperBound: (0, smithy_client_1.serializeFloat)(input.UpperBound) }),
+    };
+};
+const serializeAws_restJson1EojDataSourceConfigInput = (input, context) => {
+    return models_0_1.EojDataSourceConfigInput.visit(input, {
+        S3Data: (value) => ({ S3Data: serializeAws_restJson1S3DataInput(value, context) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const serializeAws_restJson1ExportS3DataInput = (input, context) => {
+    return {
+        ...(input.KmsKeyId != null && { KmsKeyId: input.KmsKeyId }),
+        ...(input.S3Uri != null && { S3Uri: input.S3Uri }),
+    };
+};
+const serializeAws_restJson1ExportVectorEnrichmentJobOutputConfig = (input, context) => {
+    return {
+        ...(input.S3Data != null && { S3Data: serializeAws_restJson1VectorEnrichmentJobS3Data(input.S3Data, context) }),
+    };
+};
+const serializeAws_restJson1GeoMosaicConfigInput = (input, context) => {
+    return {
+        ...(input.AlgorithmName != null && { AlgorithmName: input.AlgorithmName }),
+        ...(input.TargetBands != null && {
+            TargetBands: serializeAws_restJson1StringListInput(input.TargetBands, context),
+        }),
+    };
+};
+const serializeAws_restJson1InputConfigInput = (input, context) => {
+    return {
+        ...(input.DataSourceConfig != null && {
+            DataSourceConfig: serializeAws_restJson1EojDataSourceConfigInput(input.DataSourceConfig, context),
+        }),
+        ...(input.PreviousEarthObservationJobArn != null && {
+            PreviousEarthObservationJobArn: input.PreviousEarthObservationJobArn,
+        }),
+        ...(input.RasterDataCollectionQuery != null && {
+            RasterDataCollectionQuery: serializeAws_restJson1RasterDataCollectionQueryInput(input.RasterDataCollectionQuery, context),
+        }),
+    };
+};
+const serializeAws_restJson1JobConfigInput = (input, context) => {
+    return models_0_1.JobConfigInput.visit(input, {
+        BandMathConfig: (value) => ({ BandMathConfig: serializeAws_restJson1BandMathConfigInput(value, context) }),
+        CloudMaskingConfig: (value) => ({
+            CloudMaskingConfig: serializeAws_restJson1CloudMaskingConfigInput(value, context),
+        }),
+        CloudRemovalConfig: (value) => ({
+            CloudRemovalConfig: serializeAws_restJson1CloudRemovalConfigInput(value, context),
+        }),
+        GeoMosaicConfig: (value) => ({ GeoMosaicConfig: serializeAws_restJson1GeoMosaicConfigInput(value, context) }),
+        LandCoverSegmentationConfig: (value) => ({
+            LandCoverSegmentationConfig: serializeAws_restJson1LandCoverSegmentationConfigInput(value, context),
+        }),
+        ResamplingConfig: (value) => ({ ResamplingConfig: serializeAws_restJson1ResamplingConfigInput(value, context) }),
+        StackConfig: (value) => ({ StackConfig: serializeAws_restJson1StackConfigInput(value, context) }),
+        TemporalStatisticsConfig: (value) => ({
+            TemporalStatisticsConfig: serializeAws_restJson1TemporalStatisticsConfigInput(value, context),
+        }),
+        ZonalStatisticsConfig: (value) => ({
+            ZonalStatisticsConfig: serializeAws_restJson1ZonalStatisticsConfigInput(value, context),
+        }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const serializeAws_restJson1LandCoverSegmentationConfigInput = (input, context) => {
+    return {};
+};
+const serializeAws_restJson1LandsatCloudCoverLandInput = (input, context) => {
+    return {
+        ...(input.LowerBound != null && { LowerBound: (0, smithy_client_1.serializeFloat)(input.LowerBound) }),
+        ...(input.UpperBound != null && { UpperBound: (0, smithy_client_1.serializeFloat)(input.UpperBound) }),
+    };
+};
+const serializeAws_restJson1LinearRing = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1Position(entry, context);
+    });
+};
+const serializeAws_restJson1LinearRings = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1LinearRing(entry, context);
+    });
+};
+const serializeAws_restJson1LinearRingsList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1LinearRings(entry, context);
+    });
+};
+const serializeAws_restJson1MapMatchingConfig = (input, context) => {
+    return {
+        ...(input.IdAttributeName != null && { IdAttributeName: input.IdAttributeName }),
+        ...(input.TimestampAttributeName != null && { TimestampAttributeName: input.TimestampAttributeName }),
+        ...(input.XAttributeName != null && { XAttributeName: input.XAttributeName }),
+        ...(input.YAttributeName != null && { YAttributeName: input.YAttributeName }),
+    };
+};
+const serializeAws_restJson1MultiPolygonGeometryInput = (input, context) => {
+    return {
+        ...(input.Coordinates != null && {
+            Coordinates: serializeAws_restJson1LinearRingsList(input.Coordinates, context),
+        }),
+    };
+};
+const serializeAws_restJson1Operation = (input, context) => {
+    return {
+        ...(input.Equation != null && { Equation: input.Equation }),
+        ...(input.Name != null && { Name: input.Name }),
+        ...(input.OutputType != null && { OutputType: input.OutputType }),
+    };
+};
+const serializeAws_restJson1OperationsListInput = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1Operation(entry, context);
+    });
+};
+const serializeAws_restJson1OutputConfigInput = (input, context) => {
+    return {
+        ...(input.S3Data != null && { S3Data: serializeAws_restJson1ExportS3DataInput(input.S3Data, context) }),
+    };
+};
+const serializeAws_restJson1OutputResolutionResamplingInput = (input, context) => {
+    return {
+        ...(input.UserDefined != null && { UserDefined: serializeAws_restJson1UserDefined(input.UserDefined, context) }),
+    };
+};
+const serializeAws_restJson1OutputResolutionStackInput = (input, context) => {
+    return {
+        ...(input.Predefined != null && { Predefined: input.Predefined }),
+        ...(input.UserDefined != null && { UserDefined: serializeAws_restJson1UserDefined(input.UserDefined, context) }),
+    };
+};
+const serializeAws_restJson1PlatformInput = (input, context) => {
+    return {
+        ...(input.ComparisonOperator != null && { ComparisonOperator: input.ComparisonOperator }),
+        ...(input.Value != null && { Value: input.Value }),
+    };
+};
+const serializeAws_restJson1PolygonGeometryInput = (input, context) => {
+    return {
+        ...(input.Coordinates != null && { Coordinates: serializeAws_restJson1LinearRings(input.Coordinates, context) }),
+    };
+};
+const serializeAws_restJson1Position = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return (0, smithy_client_1.serializeFloat)(entry);
+    });
+};
+const serializeAws_restJson1Property = (input, context) => {
+    return models_0_1.Property.visit(input, {
+        EoCloudCover: (value) => ({ EoCloudCover: serializeAws_restJson1EoCloudCoverInput(value, context) }),
+        LandsatCloudCoverLand: (value) => ({
+            LandsatCloudCoverLand: serializeAws_restJson1LandsatCloudCoverLandInput(value, context),
+        }),
+        Platform: (value) => ({ Platform: serializeAws_restJson1PlatformInput(value, context) }),
+        ViewOffNadir: (value) => ({ ViewOffNadir: serializeAws_restJson1ViewOffNadirInput(value, context) }),
+        ViewSunAzimuth: (value) => ({ ViewSunAzimuth: serializeAws_restJson1ViewSunAzimuthInput(value, context) }),
+        ViewSunElevation: (value) => ({ ViewSunElevation: serializeAws_restJson1ViewSunElevationInput(value, context) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const serializeAws_restJson1PropertyFilter = (input, context) => {
+    return {
+        ...(input.Property != null && { Property: serializeAws_restJson1Property(input.Property, context) }),
+    };
+};
+const serializeAws_restJson1PropertyFilters = (input, context) => {
+    return {
+        ...(input.LogicalOperator != null && { LogicalOperator: input.LogicalOperator }),
+        ...(input.Properties != null && {
+            Properties: serializeAws_restJson1PropertyFiltersList(input.Properties, context),
+        }),
+    };
+};
+const serializeAws_restJson1PropertyFiltersList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1PropertyFilter(entry, context);
+    });
+};
+const serializeAws_restJson1RasterDataCollectionQueryInput = (input, context) => {
+    return {
+        ...(input.AreaOfInterest != null && {
+            AreaOfInterest: serializeAws_restJson1AreaOfInterest(input.AreaOfInterest, context),
+        }),
+        ...(input.PropertyFilters != null && {
+            PropertyFilters: serializeAws_restJson1PropertyFilters(input.PropertyFilters, context),
+        }),
+        ...(input.RasterDataCollectionArn != null && { RasterDataCollectionArn: input.RasterDataCollectionArn }),
+        ...(input.TimeRangeFilter != null && {
+            TimeRangeFilter: serializeAws_restJson1TimeRangeFilterInput(input.TimeRangeFilter, context),
+        }),
+    };
+};
+const serializeAws_restJson1RasterDataCollectionQueryWithBandFilterInput = (input, context) => {
+    return {
+        ...(input.AreaOfInterest != null && {
+            AreaOfInterest: serializeAws_restJson1AreaOfInterest(input.AreaOfInterest, context),
+        }),
+        ...(input.BandFilter != null && { BandFilter: serializeAws_restJson1StringListInput(input.BandFilter, context) }),
+        ...(input.PropertyFilters != null && {
+            PropertyFilters: serializeAws_restJson1PropertyFilters(input.PropertyFilters, context),
+        }),
+        ...(input.TimeRangeFilter != null && {
+            TimeRangeFilter: serializeAws_restJson1TimeRangeFilterInput(input.TimeRangeFilter, context),
+        }),
+    };
+};
+const serializeAws_restJson1ResamplingConfigInput = (input, context) => {
+    return {
+        ...(input.AlgorithmName != null && { AlgorithmName: input.AlgorithmName }),
+        ...(input.OutputResolution != null && {
+            OutputResolution: serializeAws_restJson1OutputResolutionResamplingInput(input.OutputResolution, context),
+        }),
+        ...(input.TargetBands != null && {
+            TargetBands: serializeAws_restJson1StringListInput(input.TargetBands, context),
+        }),
+    };
+};
+const serializeAws_restJson1ReverseGeocodingConfig = (input, context) => {
+    return {
+        ...(input.XAttributeName != null && { XAttributeName: input.XAttributeName }),
+        ...(input.YAttributeName != null && { YAttributeName: input.YAttributeName }),
+    };
+};
+const serializeAws_restJson1S3DataInput = (input, context) => {
+    return {
+        ...(input.KmsKeyId != null && { KmsKeyId: input.KmsKeyId }),
+        ...(input.MetadataProvider != null && { MetadataProvider: input.MetadataProvider }),
+        ...(input.S3Uri != null && { S3Uri: input.S3Uri }),
+    };
+};
+const serializeAws_restJson1StackConfigInput = (input, context) => {
+    return {
+        ...(input.OutputResolution != null && {
+            OutputResolution: serializeAws_restJson1OutputResolutionStackInput(input.OutputResolution, context),
+        }),
+        ...(input.TargetBands != null && {
+            TargetBands: serializeAws_restJson1StringListInput(input.TargetBands, context),
+        }),
+    };
+};
+const serializeAws_restJson1StringListInput = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_restJson1Tags = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = value;
+        return acc;
+    }, {});
+};
+const serializeAws_restJson1TemporalStatisticsConfigInput = (input, context) => {
+    return {
+        ...(input.GroupBy != null && { GroupBy: input.GroupBy }),
+        ...(input.Statistics != null && {
+            Statistics: serializeAws_restJson1TemporalStatisticsListInput(input.Statistics, context),
+        }),
+        ...(input.TargetBands != null && {
+            TargetBands: serializeAws_restJson1StringListInput(input.TargetBands, context),
+        }),
+    };
+};
+const serializeAws_restJson1TemporalStatisticsListInput = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_restJson1TimeRangeFilterInput = (input, context) => {
+    return {
+        ...(input.EndTime != null && { EndTime: Math.round(input.EndTime.getTime() / 1000) }),
+        ...(input.StartTime != null && { StartTime: Math.round(input.StartTime.getTime() / 1000) }),
+    };
+};
+const serializeAws_restJson1UserDefined = (input, context) => {
+    return {
+        ...(input.Unit != null && { Unit: input.Unit }),
+        ...(input.Value != null && { Value: (0, smithy_client_1.serializeFloat)(input.Value) }),
+    };
+};
+const serializeAws_restJson1VectorEnrichmentJobConfig = (input, context) => {
+    return models_0_1.VectorEnrichmentJobConfig.visit(input, {
+        MapMatchingConfig: (value) => ({ MapMatchingConfig: serializeAws_restJson1MapMatchingConfig(value, context) }),
+        ReverseGeocodingConfig: (value) => ({
+            ReverseGeocodingConfig: serializeAws_restJson1ReverseGeocodingConfig(value, context),
+        }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const serializeAws_restJson1VectorEnrichmentJobDataSourceConfigInput = (input, context) => {
+    return models_0_1.VectorEnrichmentJobDataSourceConfigInput.visit(input, {
+        S3Data: (value) => ({ S3Data: serializeAws_restJson1VectorEnrichmentJobS3Data(value, context) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const serializeAws_restJson1VectorEnrichmentJobInputConfig = (input, context) => {
+    return {
+        ...(input.DataSourceConfig != null && {
+            DataSourceConfig: serializeAws_restJson1VectorEnrichmentJobDataSourceConfigInput(input.DataSourceConfig, context),
+        }),
+        ...(input.DocumentType != null && { DocumentType: input.DocumentType }),
+    };
+};
+const serializeAws_restJson1VectorEnrichmentJobS3Data = (input, context) => {
+    return {
+        ...(input.KmsKeyId != null && { KmsKeyId: input.KmsKeyId }),
+        ...(input.S3Uri != null && { S3Uri: input.S3Uri }),
+    };
+};
+const serializeAws_restJson1ViewOffNadirInput = (input, context) => {
+    return {
+        ...(input.LowerBound != null && { LowerBound: (0, smithy_client_1.serializeFloat)(input.LowerBound) }),
+        ...(input.UpperBound != null && { UpperBound: (0, smithy_client_1.serializeFloat)(input.UpperBound) }),
+    };
+};
+const serializeAws_restJson1ViewSunAzimuthInput = (input, context) => {
+    return {
+        ...(input.LowerBound != null && { LowerBound: (0, smithy_client_1.serializeFloat)(input.LowerBound) }),
+        ...(input.UpperBound != null && { UpperBound: (0, smithy_client_1.serializeFloat)(input.UpperBound) }),
+    };
+};
+const serializeAws_restJson1ViewSunElevationInput = (input, context) => {
+    return {
+        ...(input.LowerBound != null && { LowerBound: (0, smithy_client_1.serializeFloat)(input.LowerBound) }),
+        ...(input.UpperBound != null && { UpperBound: (0, smithy_client_1.serializeFloat)(input.UpperBound) }),
+    };
+};
+const serializeAws_restJson1ZonalStatisticsConfigInput = (input, context) => {
+    return {
+        ...(input.Statistics != null && {
+            Statistics: serializeAws_restJson1ZonalStatisticsListInput(input.Statistics, context),
+        }),
+        ...(input.TargetBands != null && {
+            TargetBands: serializeAws_restJson1StringListInput(input.TargetBands, context),
+        }),
+        ...(input.ZoneS3Path != null && { ZoneS3Path: input.ZoneS3Path }),
+    };
+};
+const serializeAws_restJson1ZonalStatisticsListInput = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const deserializeAws_restJson1AreaOfInterest = (output, context) => {
+    if (output.AreaOfInterestGeometry != null) {
+        return {
+            AreaOfInterestGeometry: deserializeAws_restJson1AreaOfInterestGeometry((0, smithy_client_1.expectUnion)(output.AreaOfInterestGeometry), context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const deserializeAws_restJson1AreaOfInterestGeometry = (output, context) => {
+    if (output.MultiPolygonGeometry != null) {
+        return {
+            MultiPolygonGeometry: deserializeAws_restJson1MultiPolygonGeometryInput(output.MultiPolygonGeometry, context),
+        };
+    }
+    if (output.PolygonGeometry != null) {
+        return {
+            PolygonGeometry: deserializeAws_restJson1PolygonGeometryInput(output.PolygonGeometry, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const deserializeAws_restJson1AssetsMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = deserializeAws_restJson1AssetValue(value, context);
+        return acc;
+    }, {});
+};
+const deserializeAws_restJson1AssetValue = (output, context) => {
+    return {
+        Href: (0, smithy_client_1.expectString)(output.Href),
+    };
+};
+const deserializeAws_restJson1BandMathConfigInput = (output, context) => {
+    return {
+        CustomIndices: output.CustomIndices != null
+            ? deserializeAws_restJson1CustomIndicesInput(output.CustomIndices, context)
+            : undefined,
+        PredefinedIndices: output.PredefinedIndices != null
+            ? deserializeAws_restJson1StringListInput(output.PredefinedIndices, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1CloudMaskingConfigInput = (output, context) => {
+    return {};
+};
+const deserializeAws_restJson1CloudRemovalConfigInput = (output, context) => {
+    return {
+        AlgorithmName: (0, smithy_client_1.expectString)(output.AlgorithmName),
+        InterpolationValue: (0, smithy_client_1.expectString)(output.InterpolationValue),
+        TargetBands: output.TargetBands != null ? deserializeAws_restJson1StringListInput(output.TargetBands, context) : undefined,
+    };
+};
+const deserializeAws_restJson1CustomIndicesInput = (output, context) => {
+    return {
+        Operations: output.Operations != null ? deserializeAws_restJson1OperationsListInput(output.Operations, context) : undefined,
+    };
+};
+const deserializeAws_restJson1DataCollectionsList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1RasterDataCollectionMetadata(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1EarthObservationJobErrorDetails = (output, context) => {
+    return {
+        Message: (0, smithy_client_1.expectString)(output.Message),
+        Type: (0, smithy_client_1.expectString)(output.Type),
+    };
+};
+const deserializeAws_restJson1EarthObservationJobList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ListEarthObservationJobOutputConfig(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1EarthObservationJobOutputBands = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1OutputBand(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1EoCloudCoverInput = (output, context) => {
+    return {
+        LowerBound: (0, smithy_client_1.limitedParseFloat32)(output.LowerBound),
+        UpperBound: (0, smithy_client_1.limitedParseFloat32)(output.UpperBound),
+    };
+};
+const deserializeAws_restJson1EojDataSourceConfigInput = (output, context) => {
+    if (output.S3Data != null) {
+        return {
+            S3Data: deserializeAws_restJson1S3DataInput(output.S3Data, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const deserializeAws_restJson1ExportErrorDetails = (output, context) => {
+    return {
+        ExportResults: output.ExportResults != null
+            ? deserializeAws_restJson1ExportErrorDetailsOutput(output.ExportResults, context)
+            : undefined,
+        ExportSourceImages: output.ExportSourceImages != null
+            ? deserializeAws_restJson1ExportErrorDetailsOutput(output.ExportSourceImages, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1ExportErrorDetailsOutput = (output, context) => {
+    return {
+        Message: (0, smithy_client_1.expectString)(output.Message),
+        Type: (0, smithy_client_1.expectString)(output.Type),
+    };
+};
+const deserializeAws_restJson1ExportS3DataInput = (output, context) => {
+    return {
+        KmsKeyId: (0, smithy_client_1.expectString)(output.KmsKeyId),
+        S3Uri: (0, smithy_client_1.expectString)(output.S3Uri),
+    };
+};
+const deserializeAws_restJson1ExportVectorEnrichmentJobOutputConfig = (output, context) => {
+    return {
+        S3Data: output.S3Data != null ? deserializeAws_restJson1VectorEnrichmentJobS3Data(output.S3Data, context) : undefined,
+    };
+};
+const deserializeAws_restJson1Filter = (output, context) => {
+    return {
+        Maximum: (0, smithy_client_1.limitedParseFloat32)(output.Maximum),
+        Minimum: (0, smithy_client_1.limitedParseFloat32)(output.Minimum),
+        Name: (0, smithy_client_1.expectString)(output.Name),
+        Type: (0, smithy_client_1.expectString)(output.Type),
+    };
+};
+const deserializeAws_restJson1FilterList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1Filter(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1Geometry = (output, context) => {
+    return {
+        Coordinates: output.Coordinates != null ? deserializeAws_restJson1LinearRings(output.Coordinates, context) : undefined,
+        Type: (0, smithy_client_1.expectString)(output.Type),
+    };
+};
+const deserializeAws_restJson1GeoMosaicConfigInput = (output, context) => {
+    return {
+        AlgorithmName: (0, smithy_client_1.expectString)(output.AlgorithmName),
+        TargetBands: output.TargetBands != null ? deserializeAws_restJson1StringListInput(output.TargetBands, context) : undefined,
+    };
+};
+const deserializeAws_restJson1ImageSourceBandList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return (0, smithy_client_1.expectString)(entry);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1InputConfigOutput = (output, context) => {
+    return {
+        DataSourceConfig: output.DataSourceConfig != null
+            ? deserializeAws_restJson1EojDataSourceConfigInput((0, smithy_client_1.expectUnion)(output.DataSourceConfig), context)
+            : undefined,
+        PreviousEarthObservationJobArn: (0, smithy_client_1.expectString)(output.PreviousEarthObservationJobArn),
+        RasterDataCollectionQuery: output.RasterDataCollectionQuery != null
+            ? deserializeAws_restJson1RasterDataCollectionQueryOutput(output.RasterDataCollectionQuery, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1ItemSource = (output, context) => {
+    return {
+        Assets: output.Assets != null ? deserializeAws_restJson1AssetsMap(output.Assets, context) : undefined,
+        DateTime: output.DateTime != null ? (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(output.DateTime))) : undefined,
+        Geometry: output.Geometry != null ? deserializeAws_restJson1Geometry(output.Geometry, context) : undefined,
+        Id: (0, smithy_client_1.expectString)(output.Id),
+        Properties: output.Properties != null ? deserializeAws_restJson1Properties(output.Properties, context) : undefined,
+    };
+};
+const deserializeAws_restJson1ItemSourceList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ItemSource(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1JobConfigInput = (output, context) => {
+    if (output.BandMathConfig != null) {
+        return {
+            BandMathConfig: deserializeAws_restJson1BandMathConfigInput(output.BandMathConfig, context),
+        };
+    }
+    if (output.CloudMaskingConfig != null) {
+        return {
+            CloudMaskingConfig: deserializeAws_restJson1CloudMaskingConfigInput(output.CloudMaskingConfig, context),
+        };
+    }
+    if (output.CloudRemovalConfig != null) {
+        return {
+            CloudRemovalConfig: deserializeAws_restJson1CloudRemovalConfigInput(output.CloudRemovalConfig, context),
+        };
+    }
+    if (output.GeoMosaicConfig != null) {
+        return {
+            GeoMosaicConfig: deserializeAws_restJson1GeoMosaicConfigInput(output.GeoMosaicConfig, context),
+        };
+    }
+    if (output.LandCoverSegmentationConfig != null) {
+        return {
+            LandCoverSegmentationConfig: deserializeAws_restJson1LandCoverSegmentationConfigInput(output.LandCoverSegmentationConfig, context),
+        };
+    }
+    if (output.ResamplingConfig != null) {
+        return {
+            ResamplingConfig: deserializeAws_restJson1ResamplingConfigInput(output.ResamplingConfig, context),
+        };
+    }
+    if (output.StackConfig != null) {
+        return {
+            StackConfig: deserializeAws_restJson1StackConfigInput(output.StackConfig, context),
+        };
+    }
+    if (output.TemporalStatisticsConfig != null) {
+        return {
+            TemporalStatisticsConfig: deserializeAws_restJson1TemporalStatisticsConfigInput(output.TemporalStatisticsConfig, context),
+        };
+    }
+    if (output.ZonalStatisticsConfig != null) {
+        return {
+            ZonalStatisticsConfig: deserializeAws_restJson1ZonalStatisticsConfigInput(output.ZonalStatisticsConfig, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const deserializeAws_restJson1LandCoverSegmentationConfigInput = (output, context) => {
+    return {};
+};
+const deserializeAws_restJson1LandsatCloudCoverLandInput = (output, context) => {
+    return {
+        LowerBound: (0, smithy_client_1.limitedParseFloat32)(output.LowerBound),
+        UpperBound: (0, smithy_client_1.limitedParseFloat32)(output.UpperBound),
+    };
+};
+const deserializeAws_restJson1LinearRing = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1Position(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1LinearRings = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1LinearRing(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1LinearRingsList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1LinearRings(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1ListEarthObservationJobOutputConfig = (output, context) => {
+    return {
+        Arn: (0, smithy_client_1.expectString)(output.Arn),
+        CreationTime: output.CreationTime != null
+            ? (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(output.CreationTime)))
+            : undefined,
+        DurationInSeconds: (0, smithy_client_1.expectInt32)(output.DurationInSeconds),
+        Name: (0, smithy_client_1.expectString)(output.Name),
+        OperationType: (0, smithy_client_1.expectString)(output.OperationType),
+        Status: (0, smithy_client_1.expectString)(output.Status),
+        Tags: output.Tags != null ? deserializeAws_restJson1Tags(output.Tags, context) : undefined,
+    };
+};
+const deserializeAws_restJson1ListVectorEnrichmentJobOutputConfig = (output, context) => {
+    return {
+        Arn: (0, smithy_client_1.expectString)(output.Arn),
+        CreationTime: output.CreationTime != null
+            ? (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(output.CreationTime)))
+            : undefined,
+        DurationInSeconds: (0, smithy_client_1.expectInt32)(output.DurationInSeconds),
+        Name: (0, smithy_client_1.expectString)(output.Name),
+        Status: (0, smithy_client_1.expectString)(output.Status),
+        Tags: output.Tags != null ? deserializeAws_restJson1Tags(output.Tags, context) : undefined,
+        Type: (0, smithy_client_1.expectString)(output.Type),
+    };
+};
+const deserializeAws_restJson1MapMatchingConfig = (output, context) => {
+    return {
+        IdAttributeName: (0, smithy_client_1.expectString)(output.IdAttributeName),
+        TimestampAttributeName: (0, smithy_client_1.expectString)(output.TimestampAttributeName),
+        XAttributeName: (0, smithy_client_1.expectString)(output.XAttributeName),
+        YAttributeName: (0, smithy_client_1.expectString)(output.YAttributeName),
+    };
+};
+const deserializeAws_restJson1MultiPolygonGeometryInput = (output, context) => {
+    return {
+        Coordinates: output.Coordinates != null ? deserializeAws_restJson1LinearRingsList(output.Coordinates, context) : undefined,
+    };
+};
+const deserializeAws_restJson1Operation = (output, context) => {
+    return {
+        Equation: (0, smithy_client_1.expectString)(output.Equation),
+        Name: (0, smithy_client_1.expectString)(output.Name),
+        OutputType: (0, smithy_client_1.expectString)(output.OutputType),
+    };
+};
+const deserializeAws_restJson1OperationsListInput = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1Operation(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1OutputBand = (output, context) => {
+    return {
+        BandName: (0, smithy_client_1.expectString)(output.BandName),
+        OutputDataType: (0, smithy_client_1.expectString)(output.OutputDataType),
+    };
+};
+const deserializeAws_restJson1OutputConfigInput = (output, context) => {
+    return {
+        S3Data: output.S3Data != null ? deserializeAws_restJson1ExportS3DataInput(output.S3Data, context) : undefined,
+    };
+};
+const deserializeAws_restJson1OutputResolutionResamplingInput = (output, context) => {
+    return {
+        UserDefined: output.UserDefined != null ? deserializeAws_restJson1UserDefined(output.UserDefined, context) : undefined,
+    };
+};
+const deserializeAws_restJson1OutputResolutionStackInput = (output, context) => {
+    return {
+        Predefined: (0, smithy_client_1.expectString)(output.Predefined),
+        UserDefined: output.UserDefined != null ? deserializeAws_restJson1UserDefined(output.UserDefined, context) : undefined,
+    };
+};
+const deserializeAws_restJson1PlatformInput = (output, context) => {
+    return {
+        ComparisonOperator: (0, smithy_client_1.expectString)(output.ComparisonOperator),
+        Value: (0, smithy_client_1.expectString)(output.Value),
+    };
+};
+const deserializeAws_restJson1PolygonGeometryInput = (output, context) => {
+    return {
+        Coordinates: output.Coordinates != null ? deserializeAws_restJson1LinearRings(output.Coordinates, context) : undefined,
+    };
+};
+const deserializeAws_restJson1Position = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return (0, smithy_client_1.limitedParseDouble)(entry);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1Properties = (output, context) => {
+    return {
+        EoCloudCover: (0, smithy_client_1.limitedParseFloat32)(output.EoCloudCover),
+        LandsatCloudCoverLand: (0, smithy_client_1.limitedParseFloat32)(output.LandsatCloudCoverLand),
+        Platform: (0, smithy_client_1.expectString)(output.Platform),
+        ViewOffNadir: (0, smithy_client_1.limitedParseFloat32)(output.ViewOffNadir),
+        ViewSunAzimuth: (0, smithy_client_1.limitedParseFloat32)(output.ViewSunAzimuth),
+        ViewSunElevation: (0, smithy_client_1.limitedParseFloat32)(output.ViewSunElevation),
+    };
+};
+const deserializeAws_restJson1Property = (output, context) => {
+    if (output.EoCloudCover != null) {
+        return {
+            EoCloudCover: deserializeAws_restJson1EoCloudCoverInput(output.EoCloudCover, context),
+        };
+    }
+    if (output.LandsatCloudCoverLand != null) {
+        return {
+            LandsatCloudCoverLand: deserializeAws_restJson1LandsatCloudCoverLandInput(output.LandsatCloudCoverLand, context),
+        };
+    }
+    if (output.Platform != null) {
+        return {
+            Platform: deserializeAws_restJson1PlatformInput(output.Platform, context),
+        };
+    }
+    if (output.ViewOffNadir != null) {
+        return {
+            ViewOffNadir: deserializeAws_restJson1ViewOffNadirInput(output.ViewOffNadir, context),
+        };
+    }
+    if (output.ViewSunAzimuth != null) {
+        return {
+            ViewSunAzimuth: deserializeAws_restJson1ViewSunAzimuthInput(output.ViewSunAzimuth, context),
+        };
+    }
+    if (output.ViewSunElevation != null) {
+        return {
+            ViewSunElevation: deserializeAws_restJson1ViewSunElevationInput(output.ViewSunElevation, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const deserializeAws_restJson1PropertyFilter = (output, context) => {
+    return {
+        Property: output.Property != null ? deserializeAws_restJson1Property((0, smithy_client_1.expectUnion)(output.Property), context) : undefined,
+    };
+};
+const deserializeAws_restJson1PropertyFilters = (output, context) => {
+    return {
+        LogicalOperator: (0, smithy_client_1.expectString)(output.LogicalOperator),
+        Properties: output.Properties != null ? deserializeAws_restJson1PropertyFiltersList(output.Properties, context) : undefined,
+    };
+};
+const deserializeAws_restJson1PropertyFiltersList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1PropertyFilter(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1RasterDataCollectionMetadata = (output, context) => {
+    return {
+        Arn: (0, smithy_client_1.expectString)(output.Arn),
+        Description: (0, smithy_client_1.expectString)(output.Description),
+        DescriptionPageUrl: (0, smithy_client_1.expectString)(output.DescriptionPageUrl),
+        Name: (0, smithy_client_1.expectString)(output.Name),
+        SupportedFilters: output.SupportedFilters != null
+            ? deserializeAws_restJson1FilterList(output.SupportedFilters, context)
+            : undefined,
+        Tags: output.Tags != null ? deserializeAws_restJson1Tags(output.Tags, context) : undefined,
+        Type: (0, smithy_client_1.expectString)(output.Type),
+    };
+};
+const deserializeAws_restJson1RasterDataCollectionQueryOutput = (output, context) => {
+    return {
+        AreaOfInterest: output.AreaOfInterest != null
+            ? deserializeAws_restJson1AreaOfInterest((0, smithy_client_1.expectUnion)(output.AreaOfInterest), context)
+            : undefined,
+        PropertyFilters: output.PropertyFilters != null
+            ? deserializeAws_restJson1PropertyFilters(output.PropertyFilters, context)
+            : undefined,
+        RasterDataCollectionArn: (0, smithy_client_1.expectString)(output.RasterDataCollectionArn),
+        RasterDataCollectionName: (0, smithy_client_1.expectString)(output.RasterDataCollectionName),
+        TimeRangeFilter: output.TimeRangeFilter != null
+            ? deserializeAws_restJson1TimeRangeFilterInput(output.TimeRangeFilter, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1ResamplingConfigInput = (output, context) => {
+    return {
+        AlgorithmName: (0, smithy_client_1.expectString)(output.AlgorithmName),
+        OutputResolution: output.OutputResolution != null
+            ? deserializeAws_restJson1OutputResolutionResamplingInput(output.OutputResolution, context)
+            : undefined,
+        TargetBands: output.TargetBands != null ? deserializeAws_restJson1StringListInput(output.TargetBands, context) : undefined,
+    };
+};
+const deserializeAws_restJson1ReverseGeocodingConfig = (output, context) => {
+    return {
+        XAttributeName: (0, smithy_client_1.expectString)(output.XAttributeName),
+        YAttributeName: (0, smithy_client_1.expectString)(output.YAttributeName),
+    };
+};
+const deserializeAws_restJson1S3DataInput = (output, context) => {
+    return {
+        KmsKeyId: (0, smithy_client_1.expectString)(output.KmsKeyId),
+        MetadataProvider: (0, smithy_client_1.expectString)(output.MetadataProvider),
+        S3Uri: (0, smithy_client_1.expectString)(output.S3Uri),
+    };
+};
+const deserializeAws_restJson1StackConfigInput = (output, context) => {
+    return {
+        OutputResolution: output.OutputResolution != null
+            ? deserializeAws_restJson1OutputResolutionStackInput(output.OutputResolution, context)
+            : undefined,
+        TargetBands: output.TargetBands != null ? deserializeAws_restJson1StringListInput(output.TargetBands, context) : undefined,
+    };
+};
+const deserializeAws_restJson1StringListInput = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return (0, smithy_client_1.expectString)(entry);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1Tags = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = (0, smithy_client_1.expectString)(value);
+        return acc;
+    }, {});
+};
+const deserializeAws_restJson1TemporalStatisticsConfigInput = (output, context) => {
+    return {
+        GroupBy: (0, smithy_client_1.expectString)(output.GroupBy),
+        Statistics: output.Statistics != null
+            ? deserializeAws_restJson1TemporalStatisticsListInput(output.Statistics, context)
+            : undefined,
+        TargetBands: output.TargetBands != null ? deserializeAws_restJson1StringListInput(output.TargetBands, context) : undefined,
+    };
+};
+const deserializeAws_restJson1TemporalStatisticsListInput = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return (0, smithy_client_1.expectString)(entry);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1TimeRangeFilterInput = (output, context) => {
+    return {
+        EndTime: output.EndTime != null ? (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(output.EndTime))) : undefined,
+        StartTime: output.StartTime != null ? (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseEpochTimestamp)((0, smithy_client_1.expectNumber)(output.StartTime))) : undefined,
+    };
+};
+const deserializeAws_restJson1UserDefined = (output, context) => {
+    return {
+        Unit: (0, smithy_client_1.expectString)(output.Unit),
+        Value: (0, smithy_client_1.limitedParseFloat32)(output.Value),
+    };
+};
+const deserializeAws_restJson1VectorEnrichmentJobConfig = (output, context) => {
+    if (output.MapMatchingConfig != null) {
+        return {
+            MapMatchingConfig: deserializeAws_restJson1MapMatchingConfig(output.MapMatchingConfig, context),
+        };
+    }
+    if (output.ReverseGeocodingConfig != null) {
+        return {
+            ReverseGeocodingConfig: deserializeAws_restJson1ReverseGeocodingConfig(output.ReverseGeocodingConfig, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const deserializeAws_restJson1VectorEnrichmentJobDataSourceConfigInput = (output, context) => {
+    if (output.S3Data != null) {
+        return {
+            S3Data: deserializeAws_restJson1VectorEnrichmentJobS3Data(output.S3Data, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const deserializeAws_restJson1VectorEnrichmentJobErrorDetails = (output, context) => {
+    return {
+        ErrorMessage: (0, smithy_client_1.expectString)(output.ErrorMessage),
+        ErrorType: (0, smithy_client_1.expectString)(output.ErrorType),
+    };
+};
+const deserializeAws_restJson1VectorEnrichmentJobExportErrorDetails = (output, context) => {
+    return {
+        Message: (0, smithy_client_1.expectString)(output.Message),
+        Type: (0, smithy_client_1.expectString)(output.Type),
+    };
+};
+const deserializeAws_restJson1VectorEnrichmentJobInputConfig = (output, context) => {
+    return {
+        DataSourceConfig: output.DataSourceConfig != null
+            ? deserializeAws_restJson1VectorEnrichmentJobDataSourceConfigInput((0, smithy_client_1.expectUnion)(output.DataSourceConfig), context)
+            : undefined,
+        DocumentType: (0, smithy_client_1.expectString)(output.DocumentType),
+    };
+};
+const deserializeAws_restJson1VectorEnrichmentJobList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ListVectorEnrichmentJobOutputConfig(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1VectorEnrichmentJobS3Data = (output, context) => {
+    return {
+        KmsKeyId: (0, smithy_client_1.expectString)(output.KmsKeyId),
+        S3Uri: (0, smithy_client_1.expectString)(output.S3Uri),
+    };
+};
+const deserializeAws_restJson1ViewOffNadirInput = (output, context) => {
+    return {
+        LowerBound: (0, smithy_client_1.limitedParseFloat32)(output.LowerBound),
+        UpperBound: (0, smithy_client_1.limitedParseFloat32)(output.UpperBound),
+    };
+};
+const deserializeAws_restJson1ViewSunAzimuthInput = (output, context) => {
+    return {
+        LowerBound: (0, smithy_client_1.limitedParseFloat32)(output.LowerBound),
+        UpperBound: (0, smithy_client_1.limitedParseFloat32)(output.UpperBound),
+    };
+};
+const deserializeAws_restJson1ViewSunElevationInput = (output, context) => {
+    return {
+        LowerBound: (0, smithy_client_1.limitedParseFloat32)(output.LowerBound),
+        UpperBound: (0, smithy_client_1.limitedParseFloat32)(output.UpperBound),
+    };
+};
+const deserializeAws_restJson1ZonalStatisticsConfigInput = (output, context) => {
+    return {
+        Statistics: output.Statistics != null
+            ? deserializeAws_restJson1ZonalStatisticsListInput(output.Statistics, context)
+            : undefined,
+        TargetBands: output.TargetBands != null ? deserializeAws_restJson1StringListInput(output.TargetBands, context) : undefined,
+        ZoneS3Path: (0, smithy_client_1.expectString)(output.ZoneS3Path),
+    };
+};
+const deserializeAws_restJson1ZonalStatisticsListInput = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return (0, smithy_client_1.expectString)(entry);
+    });
+    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"]);
+    }
+};