@aws-sdk/client-sagemaker-geospatial 3.928.0 → 3.929.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,9 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
-var uuid = require('@smithy/uuid');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -92,6 +90,7 @@ class SageMakerGeospatialClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -111,14 +110,14 @@ class SageMakerGeospatialClient extends smithyClient.Client {
     }
 }
 
-class SageMakerGeospatialServiceException extends smithyClient.ServiceException {
+let SageMakerGeospatialServiceException$1 = class SageMakerGeospatialServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, SageMakerGeospatialServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends SageMakerGeospatialServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends SageMakerGeospatialServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     Message;
@@ -131,7 +130,7 @@ class AccessDeniedException extends SageMakerGeospatialServiceException {
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const AlgorithmNameCloudRemoval = {
     INTERPOLATION: "INTERPOLATION",
 };
@@ -197,7 +196,7 @@ const ComparisonOperator = {
     NOT_EQUALS: "NOT_EQUALS",
     STARTS_WITH: "STARTS_WITH",
 };
-class ConflictException extends SageMakerGeospatialServiceException {
+let ConflictException$1 = class ConflictException extends SageMakerGeospatialServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     Message;
@@ -212,13 +211,13 @@ class ConflictException extends SageMakerGeospatialServiceException {
         this.Message = opts.Message;
         this.ResourceId = opts.ResourceId;
     }
-}
+};
 const DataCollectionType = {
     PREMIUM: "PREMIUM",
     PUBLIC: "PUBLIC",
     USER: "USER",
 };
-class InternalServerException extends SageMakerGeospatialServiceException {
+let InternalServerException$1 = class InternalServerException extends SageMakerGeospatialServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     Message;
@@ -233,8 +232,8 @@ class InternalServerException extends SageMakerGeospatialServiceException {
         this.Message = opts.Message;
         this.ResourceId = opts.ResourceId;
     }
-}
-class ResourceNotFoundException extends SageMakerGeospatialServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends SageMakerGeospatialServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     Message;
@@ -249,8 +248,8 @@ class ResourceNotFoundException extends SageMakerGeospatialServiceException {
         this.Message = opts.Message;
         this.ResourceId = opts.ResourceId;
     }
-}
-class ThrottlingException extends SageMakerGeospatialServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends SageMakerGeospatialServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     Message;
@@ -265,8 +264,8 @@ class ThrottlingException extends SageMakerGeospatialServiceException {
         this.Message = opts.Message;
         this.ResourceId = opts.ResourceId;
     }
-}
-class ValidationException extends SageMakerGeospatialServiceException {
+};
+let ValidationException$1 = class ValidationException extends SageMakerGeospatialServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     Message;
@@ -281,13 +280,13 @@ class ValidationException extends SageMakerGeospatialServiceException {
         this.Message = opts.Message;
         this.ResourceId = opts.ResourceId;
     }
-}
+};
 const EarthObservationJobExportStatus = {
     FAILED: "FAILED",
     IN_PROGRESS: "IN_PROGRESS",
     SUCCEEDED: "SUCCEEDED",
 };
-class ServiceQuotaExceededException extends SageMakerGeospatialServiceException {
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends SageMakerGeospatialServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     Message;
@@ -302,7 +301,7 @@ class ServiceQuotaExceededException extends SageMakerGeospatialServiceException
         this.Message = opts.Message;
         this.ResourceId = opts.ResourceId;
     }
-}
+};
 const EarthObservationJobErrorType = {
     CLIENT_ERROR: "CLIENT_ERROR",
     SERVER_ERROR: "SERVER_ERROR",
@@ -447,1394 +446,1106 @@ const VectorEnrichmentJobType = {
     MAP_MATCHING: "MAP_MATCHING",
     REVERSE_GEOCODING: "REVERSE_GEOCODING",
 };
-const MultiPolygonGeometryInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Coordinates && { Coordinates: obj.Coordinates.map((item) => item.map((item) => smithyClient.SENSITIVE_STRING)) }),
-});
-const PolygonGeometryInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Coordinates && { Coordinates: obj.Coordinates.map((item) => smithyClient.SENSITIVE_STRING) }),
-});
-const AreaOfInterestGeometryFilterSensitiveLog = (obj) => {
-    if (obj.PolygonGeometry !== undefined)
-        return { PolygonGeometry: PolygonGeometryInputFilterSensitiveLog(obj.PolygonGeometry) };
-    if (obj.MultiPolygonGeometry !== undefined)
-        return { MultiPolygonGeometry: MultiPolygonGeometryInputFilterSensitiveLog(obj.MultiPolygonGeometry) };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const AreaOfInterestFilterSensitiveLog = (obj) => {
-    if (obj.AreaOfInterestGeometry !== undefined)
-        return { AreaOfInterestGeometry: AreaOfInterestGeometryFilterSensitiveLog(obj.AreaOfInterestGeometry) };
-    if (obj.$unknown !== undefined)
-        return { [obj.$unknown[0]]: "UNKNOWN" };
-};
-const TimeRangeFilterOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-const RasterDataCollectionQueryOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.TimeRangeFilter && { TimeRangeFilter: smithyClient.SENSITIVE_STRING }),
-    ...(obj.AreaOfInterest && { AreaOfInterest: AreaOfInterestFilterSensitiveLog(obj.AreaOfInterest) }),
-    ...(obj.PropertyFilters && { PropertyFilters: obj.PropertyFilters }),
-});
-const InputConfigOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.RasterDataCollectionQuery && {
-        RasterDataCollectionQuery: RasterDataCollectionQueryOutputFilterSensitiveLog(obj.RasterDataCollectionQuery),
-    }),
-});
-const GetEarthObservationJobOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.InputConfig && { InputConfig: InputConfigOutputFilterSensitiveLog(obj.InputConfig) }),
-    ...(obj.JobConfig && { JobConfig: obj.JobConfig }),
-});
-const GetTileOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-const ListEarthObservationJobInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.NextToken && { NextToken: smithyClient.SENSITIVE_STRING }),
-});
-const ListEarthObservationJobOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.NextToken && { NextToken: smithyClient.SENSITIVE_STRING }),
-});
-const TimeRangeFilterInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-const RasterDataCollectionQueryInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.TimeRangeFilter && { TimeRangeFilter: smithyClient.SENSITIVE_STRING }),
-    ...(obj.AreaOfInterest && { AreaOfInterest: AreaOfInterestFilterSensitiveLog(obj.AreaOfInterest) }),
-    ...(obj.PropertyFilters && { PropertyFilters: obj.PropertyFilters }),
-});
-const InputConfigInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.RasterDataCollectionQuery && {
-        RasterDataCollectionQuery: RasterDataCollectionQueryInputFilterSensitiveLog(obj.RasterDataCollectionQuery),
-    }),
-});
-const StartEarthObservationJobInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.InputConfig && { InputConfig: InputConfigInputFilterSensitiveLog(obj.InputConfig) }),
-    ...(obj.JobConfig && { JobConfig: obj.JobConfig }),
-});
-const StartEarthObservationJobOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.InputConfig && { InputConfig: InputConfigOutputFilterSensitiveLog(obj.InputConfig) }),
-    ...(obj.JobConfig && { JobConfig: obj.JobConfig }),
-});
-const GeometryFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Coordinates && { Coordinates: obj.Coordinates.map((item) => smithyClient.SENSITIVE_STRING) }),
-});
-const ItemSourceFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Geometry && { Geometry: GeometryFilterSensitiveLog(obj.Geometry) }),
-});
-const ListRasterDataCollectionsInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.NextToken && { NextToken: smithyClient.SENSITIVE_STRING }),
-});
-const ListRasterDataCollectionsOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.NextToken && { NextToken: smithyClient.SENSITIVE_STRING }),
-});
-const ListVectorEnrichmentJobInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.NextToken && { NextToken: smithyClient.SENSITIVE_STRING }),
-});
-const ListVectorEnrichmentJobOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.NextToken && { NextToken: smithyClient.SENSITIVE_STRING }),
-});
-const RasterDataCollectionQueryWithBandFilterInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.TimeRangeFilter && { TimeRangeFilter: smithyClient.SENSITIVE_STRING }),
-    ...(obj.AreaOfInterest && { AreaOfInterest: AreaOfInterestFilterSensitiveLog(obj.AreaOfInterest) }),
-    ...(obj.PropertyFilters && { PropertyFilters: obj.PropertyFilters }),
-});
-const SearchRasterDataCollectionInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.RasterDataCollectionQuery && {
-        RasterDataCollectionQuery: RasterDataCollectionQueryWithBandFilterInputFilterSensitiveLog(obj.RasterDataCollectionQuery),
-    }),
-    ...(obj.NextToken && { NextToken: smithyClient.SENSITIVE_STRING }),
-});
-const SearchRasterDataCollectionOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.NextToken && { NextToken: smithyClient.SENSITIVE_STRING }),
-    ...(obj.Items && { Items: obj.Items.map((item) => ItemSourceFilterSensitiveLog(item)) }),
-});
 
-const se_DeleteEarthObservationJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/earth-observation-jobs/{Arn}");
-    b.p("Arn", () => input.Arn, "{Arn}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteVectorEnrichmentJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/vector-enrichment-jobs/{Arn}");
-    b.p("Arn", () => input.Arn, "{Arn}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_ExportEarthObservationJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/export-earth-observation-job");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Arn: [],
-        ClientToken: [true, (_) => _ ?? uuid.v4()],
-        ExecutionRoleArn: [],
-        ExportSourceImages: [],
-        OutputConfig: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ExportVectorEnrichmentJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/export-vector-enrichment-jobs");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Arn: [],
-        ClientToken: [true, (_) => _ ?? uuid.v4()],
-        ExecutionRoleArn: [],
-        OutputConfig: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetEarthObservationJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/earth-observation-jobs/{Arn}");
-    b.p("Arn", () => input.Arn, "{Arn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetRasterDataCollectionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/raster-data-collection/{Arn}");
-    b.p("Arn", () => input.Arn, "{Arn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetTileCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tile/{z}/{x}/{y}");
-    b.p("x", () => input.x.toString(), "{x}", false);
-    b.p("y", () => input.y.toString(), "{y}", false);
-    b.p("z", () => input.z.toString(), "{z}", false);
-    const query = smithyClient.map({
-        [_IA]: [smithyClient.expectNonNull(input.ImageAssets, `ImageAssets`) != null, () => input[_IA] || []],
-        [_T]: [, smithyClient.expectNonNull(input[_T], `Target`)],
-        [_A]: [, smithyClient.expectNonNull(input[_A], `Arn`)],
-        [_IM]: [() => input.ImageMask !== void 0, () => input[_IM].toString()],
-        [_OF]: [, input[_OF]],
-        [_TRF]: [, input[_TRF]],
-        [_PF]: [, input[_PF]],
-        [_ODT]: [, input[_ODT]],
-        [_ERA]: [, input[_ERA]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_GetVectorEnrichmentJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/vector-enrichment-jobs/{Arn}");
-    b.p("Arn", () => input.Arn, "{Arn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_ListEarthObservationJobsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/list-earth-observation-jobs");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        MaxResults: [],
-        NextToken: [],
-        SortBy: [],
-        SortOrder: [],
-        StatusEquals: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_ListRasterDataCollectionsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/raster-data-collections");
-    const query = smithyClient.map({
-        [_NT]: [, input[_NT]],
-        [_MR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{ResourceArn}");
-    b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_ListVectorEnrichmentJobsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/list-vector-enrichment-jobs");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        MaxResults: [],
-        NextToken: [],
-        SortBy: [],
-        SortOrder: [],
-        StatusEquals: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_SearchRasterDataCollectionCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/search-raster-data-collection");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Arn: [],
-        NextToken: [],
-        RasterDataCollectionQuery: (_) => se_RasterDataCollectionQueryWithBandFilterInput(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StartEarthObservationJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/earth-observation-jobs");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ClientToken: [true, (_) => _ ?? uuid.v4()],
-        ExecutionRoleArn: [],
-        InputConfig: (_) => se_InputConfigInput(_),
-        JobConfig: (_) => se_JobConfigInput(_),
-        KmsKeyId: [],
-        Name: [],
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StartVectorEnrichmentJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/vector-enrichment-jobs");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ClientToken: [true, (_) => _ ?? uuid.v4()],
-        ExecutionRoleArn: [],
-        InputConfig: (_) => smithyClient._json(_),
-        JobConfig: (_) => smithyClient._json(_),
-        KmsKeyId: [],
-        Name: [],
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StopEarthObservationJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/earth-observation-jobs/stop");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_StopVectorEnrichmentJobCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/vector-enrichment-jobs/stop");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Arn: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_TagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/tags/{ResourceArn}");
-    b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Tags: (_) => smithyClient._json(_),
-    }));
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/tags/{ResourceArn}");
-    b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
-    const query = smithyClient.map({
-        [_tK]: [smithyClient.expectNonNull(input.TagKeys, `TagKeys`) != null, () => input[_TK] || []],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const de_DeleteEarthObservationJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_DeleteVectorEnrichmentJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_ExportEarthObservationJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        ExecutionRoleArn: smithyClient.expectString,
-        ExportSourceImages: smithyClient.expectBoolean,
-        ExportStatus: smithyClient.expectString,
-        OutputConfig: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ExportVectorEnrichmentJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        ExecutionRoleArn: smithyClient.expectString,
-        ExportStatus: smithyClient.expectString,
-        OutputConfig: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetEarthObservationJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        DurationInSeconds: smithyClient.expectInt32,
-        ErrorDetails: smithyClient._json,
-        ExecutionRoleArn: smithyClient.expectString,
-        ExportErrorDetails: smithyClient._json,
-        ExportStatus: smithyClient.expectString,
-        InputConfig: (_) => de_InputConfigOutput(_),
-        JobConfig: (_) => de_JobConfigInput(core$1.awsExpectUnion(_)),
-        KmsKeyId: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        OutputBands: smithyClient._json,
-        Status: smithyClient.expectString,
-        Tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetRasterDataCollectionCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Arn: smithyClient.expectString,
-        Description: smithyClient.expectString,
-        DescriptionPageUrl: smithyClient.expectString,
-        ImageSourceBands: smithyClient._json,
-        Name: smithyClient.expectString,
-        SupportedFilters: (_) => de_FilterList(_),
-        Tags: smithyClient._json,
-        Type: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetTileCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = output.body;
-    context.sdkStreamMixin(data);
-    contents.BinaryFile = data;
-    return contents;
-};
-const de_GetVectorEnrichmentJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        DurationInSeconds: smithyClient.expectInt32,
-        ErrorDetails: smithyClient._json,
-        ExecutionRoleArn: smithyClient.expectString,
-        ExportErrorDetails: smithyClient._json,
-        ExportStatus: smithyClient.expectString,
-        InputConfig: smithyClient._json,
-        JobConfig: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
-        KmsKeyId: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        Status: smithyClient.expectString,
-        Tags: smithyClient._json,
-        Type: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListEarthObservationJobsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        EarthObservationJobSummaries: (_) => de_EarthObservationJobList(_),
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListRasterDataCollectionsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        NextToken: smithyClient.expectString,
-        RasterDataCollectionSummaries: (_) => de_DataCollectionsList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListVectorEnrichmentJobsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        NextToken: smithyClient.expectString,
-        VectorEnrichmentJobSummaries: (_) => de_VectorEnrichmentJobList(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_SearchRasterDataCollectionCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        ApproximateResultCount: smithyClient.expectInt32,
-        Items: (_) => de_ItemSourceList(_),
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartEarthObservationJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        DurationInSeconds: smithyClient.expectInt32,
-        ExecutionRoleArn: smithyClient.expectString,
-        InputConfig: (_) => de_InputConfigOutput(_),
-        JobConfig: (_) => de_JobConfigInput(core$1.awsExpectUnion(_)),
-        KmsKeyId: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        Status: smithyClient.expectString,
-        Tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StartVectorEnrichmentJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        DurationInSeconds: smithyClient.expectInt32,
-        ExecutionRoleArn: smithyClient.expectString,
-        InputConfig: smithyClient._json,
-        JobConfig: (_) => smithyClient._json(core$1.awsExpectUnion(_)),
-        KmsKeyId: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        Status: smithyClient.expectString,
-        Tags: smithyClient._json,
-        Type: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_StopEarthObservationJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_StopVectorEnrichmentJobCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.sagemakergeospatial#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.sagemakergeospatial#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.sagemakergeospatial#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.sagemakergeospatial#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.sagemakergeospatial#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(SageMakerGeospatialServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-        ResourceId: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-        ResourceId: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-        ResourceId: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-        ResourceId: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ServiceQuotaExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-        ResourceId: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-        ResourceId: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const se_AreaOfInterest = (input, context) => {
-    return exports.AreaOfInterest.visit(input, {
-        AreaOfInterestGeometry: (value) => ({ AreaOfInterestGeometry: se_AreaOfInterestGeometry(value) }),
-        _: (name, value) => ({ [name]: value }),
-    });
-};
-const se_AreaOfInterestGeometry = (input, context) => {
-    return exports.AreaOfInterestGeometry.visit(input, {
-        MultiPolygonGeometry: (value) => ({ MultiPolygonGeometry: se_MultiPolygonGeometryInput(value) }),
-        PolygonGeometry: (value) => ({ PolygonGeometry: se_PolygonGeometryInput(value) }),
-        _: (name, value) => ({ [name]: value }),
-    });
-};
-const se_EoCloudCoverInput = (input, context) => {
-    return smithyClient.take(input, {
-        LowerBound: smithyClient.serializeFloat,
-        UpperBound: smithyClient.serializeFloat,
-    });
-};
-const se_InputConfigInput = (input, context) => {
-    return smithyClient.take(input, {
-        PreviousEarthObservationJobArn: [],
-        RasterDataCollectionQuery: (_) => se_RasterDataCollectionQueryInput(_),
-    });
-};
-const se_JobConfigInput = (input, context) => {
-    return exports.JobConfigInput.visit(input, {
-        BandMathConfig: (value) => ({ BandMathConfig: smithyClient._json(value) }),
-        CloudMaskingConfig: (value) => ({ CloudMaskingConfig: smithyClient._json(value) }),
-        CloudRemovalConfig: (value) => ({ CloudRemovalConfig: smithyClient._json(value) }),
-        GeoMosaicConfig: (value) => ({ GeoMosaicConfig: smithyClient._json(value) }),
-        LandCoverSegmentationConfig: (value) => ({ LandCoverSegmentationConfig: smithyClient._json(value) }),
-        ResamplingConfig: (value) => ({ ResamplingConfig: se_ResamplingConfigInput(value) }),
-        StackConfig: (value) => ({ StackConfig: se_StackConfigInput(value) }),
-        TemporalStatisticsConfig: (value) => ({ TemporalStatisticsConfig: smithyClient._json(value) }),
-        ZonalStatisticsConfig: (value) => ({ ZonalStatisticsConfig: smithyClient._json(value) }),
-        _: (name, value) => ({ [name]: value }),
-    });
-};
-const se_LandsatCloudCoverLandInput = (input, context) => {
-    return smithyClient.take(input, {
-        LowerBound: smithyClient.serializeFloat,
-        UpperBound: smithyClient.serializeFloat,
-    });
-};
-const se_LinearRing = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_Position(entry);
-    });
-};
-const se_LinearRings = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_LinearRing(entry);
-    });
-};
-const se_LinearRingsList = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_LinearRings(entry);
-    });
-};
-const se_MultiPolygonGeometryInput = (input, context) => {
-    return smithyClient.take(input, {
-        Coordinates: (_) => se_LinearRingsList(_),
-    });
-};
-const se_OutputResolutionResamplingInput = (input, context) => {
-    return smithyClient.take(input, {
-        UserDefined: (_) => se_UserDefined(_),
-    });
-};
-const se_OutputResolutionStackInput = (input, context) => {
-    return smithyClient.take(input, {
-        Predefined: [],
-        UserDefined: (_) => se_UserDefined(_),
-    });
-};
-const se_PolygonGeometryInput = (input, context) => {
-    return smithyClient.take(input, {
-        Coordinates: (_) => se_LinearRings(_),
-    });
-};
-const se_Position = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return smithyClient.serializeFloat(entry);
-    });
-};
-const se_Property = (input, context) => {
-    return exports.Property.visit(input, {
-        EoCloudCover: (value) => ({ EoCloudCover: se_EoCloudCoverInput(value) }),
-        LandsatCloudCoverLand: (value) => ({ LandsatCloudCoverLand: se_LandsatCloudCoverLandInput(value) }),
-        Platform: (value) => ({ Platform: smithyClient._json(value) }),
-        ViewOffNadir: (value) => ({ ViewOffNadir: se_ViewOffNadirInput(value) }),
-        ViewSunAzimuth: (value) => ({ ViewSunAzimuth: se_ViewSunAzimuthInput(value) }),
-        ViewSunElevation: (value) => ({ ViewSunElevation: se_ViewSunElevationInput(value) }),
-        _: (name, value) => ({ [name]: value }),
-    });
-};
-const se_PropertyFilter = (input, context) => {
-    return smithyClient.take(input, {
-        Property: (_) => se_Property(_),
-    });
-};
-const se_PropertyFilters = (input, context) => {
-    return smithyClient.take(input, {
-        LogicalOperator: [],
-        Properties: (_) => se_PropertyFiltersList(_),
-    });
-};
-const se_PropertyFiltersList = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_PropertyFilter(entry);
-    });
-};
-const se_RasterDataCollectionQueryInput = (input, context) => {
-    return smithyClient.take(input, {
-        AreaOfInterest: (_) => se_AreaOfInterest(_),
-        PropertyFilters: (_) => se_PropertyFilters(_),
-        RasterDataCollectionArn: [],
-        TimeRangeFilter: (_) => se_TimeRangeFilterInput(_),
-    });
-};
-const se_RasterDataCollectionQueryWithBandFilterInput = (input, context) => {
-    return smithyClient.take(input, {
-        AreaOfInterest: (_) => se_AreaOfInterest(_),
-        BandFilter: smithyClient._json,
-        PropertyFilters: (_) => se_PropertyFilters(_),
-        TimeRangeFilter: (_) => se_TimeRangeFilterInput(_),
-    });
-};
-const se_ResamplingConfigInput = (input, context) => {
-    return smithyClient.take(input, {
-        AlgorithmName: [],
-        OutputResolution: (_) => se_OutputResolutionResamplingInput(_),
-        TargetBands: smithyClient._json,
-    });
-};
-const se_StackConfigInput = (input, context) => {
-    return smithyClient.take(input, {
-        OutputResolution: (_) => se_OutputResolutionStackInput(_),
-        TargetBands: smithyClient._json,
-    });
-};
-const se_TimeRangeFilterInput = (input, context) => {
-    return smithyClient.take(input, {
-        EndTime: (_) => _.getTime() / 1_000,
-        StartTime: (_) => _.getTime() / 1_000,
-    });
-};
-const se_UserDefined = (input, context) => {
-    return smithyClient.take(input, {
-        Unit: [],
-        Value: smithyClient.serializeFloat,
-    });
-};
-const se_ViewOffNadirInput = (input, context) => {
-    return smithyClient.take(input, {
-        LowerBound: smithyClient.serializeFloat,
-        UpperBound: smithyClient.serializeFloat,
-    });
-};
-const se_ViewSunAzimuthInput = (input, context) => {
-    return smithyClient.take(input, {
-        LowerBound: smithyClient.serializeFloat,
-        UpperBound: smithyClient.serializeFloat,
-    });
-};
-const se_ViewSunElevationInput = (input, context) => {
-    return smithyClient.take(input, {
-        LowerBound: smithyClient.serializeFloat,
-        UpperBound: smithyClient.serializeFloat,
-    });
-};
-const de_AreaOfInterest = (output, context) => {
-    if (output.AreaOfInterestGeometry != null) {
-        return {
-            AreaOfInterestGeometry: de_AreaOfInterestGeometry(core$1.awsExpectUnion(output.AreaOfInterestGeometry)),
-        };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
-const de_AreaOfInterestGeometry = (output, context) => {
-    if (output.MultiPolygonGeometry != null) {
-        return {
-            MultiPolygonGeometry: de_MultiPolygonGeometryInput(output.MultiPolygonGeometry),
-        };
-    }
-    if (output.PolygonGeometry != null) {
-        return {
-            PolygonGeometry: de_PolygonGeometryInput(output.PolygonGeometry),
-        };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
-const de_DataCollectionsList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_RasterDataCollectionMetadata(entry);
-    });
-    return retVal;
-};
-const de_EarthObservationJobList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ListEarthObservationJobOutputConfig(entry);
-    });
-    return retVal;
-};
-const de_EoCloudCoverInput = (output, context) => {
-    return smithyClient.take(output, {
-        LowerBound: smithyClient.limitedParseFloat32,
-        UpperBound: smithyClient.limitedParseFloat32,
-    });
-};
-const de_Filter = (output, context) => {
-    return smithyClient.take(output, {
-        Maximum: smithyClient.limitedParseFloat32,
-        Minimum: smithyClient.limitedParseFloat32,
-        Name: smithyClient.expectString,
-        Type: smithyClient.expectString,
-    });
-};
-const de_FilterList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Filter(entry);
-    });
-    return retVal;
-};
-const de_Geometry = (output, context) => {
-    return smithyClient.take(output, {
-        Coordinates: (_) => de_LinearRings(_),
-        Type: smithyClient.expectString,
-    });
-};
-const de_InputConfigOutput = (output, context) => {
-    return smithyClient.take(output, {
-        PreviousEarthObservationJobArn: smithyClient.expectString,
-        RasterDataCollectionQuery: (_) => de_RasterDataCollectionQueryOutput(_),
-    });
-};
-const de_ItemSource = (output, context) => {
-    return smithyClient.take(output, {
-        Assets: smithyClient._json,
-        DateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Geometry: (_) => de_Geometry(_),
-        Id: smithyClient.expectString,
-        Properties: (_) => de_Properties(_),
-    });
-};
-const de_ItemSourceList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ItemSource(entry);
-    });
-    return retVal;
-};
-const de_JobConfigInput = (output, context) => {
-    if (output.BandMathConfig != null) {
-        return {
-            BandMathConfig: smithyClient._json(output.BandMathConfig),
-        };
-    }
-    if (output.CloudMaskingConfig != null) {
-        return {
-            CloudMaskingConfig: smithyClient._json(output.CloudMaskingConfig),
-        };
-    }
-    if (output.CloudRemovalConfig != null) {
-        return {
-            CloudRemovalConfig: smithyClient._json(output.CloudRemovalConfig),
-        };
-    }
-    if (output.GeoMosaicConfig != null) {
-        return {
-            GeoMosaicConfig: smithyClient._json(output.GeoMosaicConfig),
-        };
-    }
-    if (output.LandCoverSegmentationConfig != null) {
-        return {
-            LandCoverSegmentationConfig: smithyClient._json(output.LandCoverSegmentationConfig),
-        };
-    }
-    if (output.ResamplingConfig != null) {
-        return {
-            ResamplingConfig: de_ResamplingConfigInput(output.ResamplingConfig),
-        };
-    }
-    if (output.StackConfig != null) {
-        return {
-            StackConfig: de_StackConfigInput(output.StackConfig),
-        };
-    }
-    if (output.TemporalStatisticsConfig != null) {
-        return {
-            TemporalStatisticsConfig: smithyClient._json(output.TemporalStatisticsConfig),
-        };
-    }
-    if (output.ZonalStatisticsConfig != null) {
-        return {
-            ZonalStatisticsConfig: smithyClient._json(output.ZonalStatisticsConfig),
-        };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
-const de_LandsatCloudCoverLandInput = (output, context) => {
-    return smithyClient.take(output, {
-        LowerBound: smithyClient.limitedParseFloat32,
-        UpperBound: smithyClient.limitedParseFloat32,
-    });
-};
-const de_LinearRing = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Position(entry);
-    });
-    return retVal;
-};
-const de_LinearRings = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_LinearRing(entry);
-    });
-    return retVal;
-};
-const de_LinearRingsList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_LinearRings(entry);
-    });
-    return retVal;
-};
-const de_ListEarthObservationJobOutputConfig = (output, context) => {
-    return smithyClient.take(output, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        DurationInSeconds: smithyClient.expectInt32,
-        Name: smithyClient.expectString,
-        OperationType: smithyClient.expectString,
-        Status: smithyClient.expectString,
-        Tags: smithyClient._json,
-    });
-};
-const de_ListVectorEnrichmentJobOutputConfig = (output, context) => {
-    return smithyClient.take(output, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        DurationInSeconds: smithyClient.expectInt32,
-        Name: smithyClient.expectString,
-        Status: smithyClient.expectString,
-        Tags: smithyClient._json,
-        Type: smithyClient.expectString,
-    });
-};
-const de_MultiPolygonGeometryInput = (output, context) => {
-    return smithyClient.take(output, {
-        Coordinates: (_) => de_LinearRingsList(_),
-    });
-};
-const de_OutputResolutionResamplingInput = (output, context) => {
-    return smithyClient.take(output, {
-        UserDefined: (_) => de_UserDefined(_),
-    });
-};
-const de_OutputResolutionStackInput = (output, context) => {
-    return smithyClient.take(output, {
-        Predefined: smithyClient.expectString,
-        UserDefined: (_) => de_UserDefined(_),
-    });
-};
-const de_PolygonGeometryInput = (output, context) => {
-    return smithyClient.take(output, {
-        Coordinates: (_) => de_LinearRings(_),
-    });
-};
-const de_Position = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return smithyClient.limitedParseDouble(entry);
-    });
-    return retVal;
-};
-const de_Properties = (output, context) => {
-    return smithyClient.take(output, {
-        EoCloudCover: smithyClient.limitedParseFloat32,
-        LandsatCloudCoverLand: smithyClient.limitedParseFloat32,
-        Platform: smithyClient.expectString,
-        ViewOffNadir: smithyClient.limitedParseFloat32,
-        ViewSunAzimuth: smithyClient.limitedParseFloat32,
-        ViewSunElevation: smithyClient.limitedParseFloat32,
-    });
-};
-const de_Property = (output, context) => {
-    if (output.EoCloudCover != null) {
-        return {
-            EoCloudCover: de_EoCloudCoverInput(output.EoCloudCover),
-        };
-    }
-    if (output.LandsatCloudCoverLand != null) {
-        return {
-            LandsatCloudCoverLand: de_LandsatCloudCoverLandInput(output.LandsatCloudCoverLand),
-        };
-    }
-    if (output.Platform != null) {
-        return {
-            Platform: smithyClient._json(output.Platform),
-        };
-    }
-    if (output.ViewOffNadir != null) {
-        return {
-            ViewOffNadir: de_ViewOffNadirInput(output.ViewOffNadir),
-        };
-    }
-    if (output.ViewSunAzimuth != null) {
-        return {
-            ViewSunAzimuth: de_ViewSunAzimuthInput(output.ViewSunAzimuth),
-        };
-    }
-    if (output.ViewSunElevation != null) {
-        return {
-            ViewSunElevation: de_ViewSunElevationInput(output.ViewSunElevation),
-        };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
-const de_PropertyFilter = (output, context) => {
-    return smithyClient.take(output, {
-        Property: (_) => de_Property(core$1.awsExpectUnion(_)),
-    });
-};
-const de_PropertyFilters = (output, context) => {
-    return smithyClient.take(output, {
-        LogicalOperator: smithyClient.expectString,
-        Properties: (_) => de_PropertyFiltersList(_),
-    });
-};
-const de_PropertyFiltersList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_PropertyFilter(entry);
-    });
-    return retVal;
-};
-const de_RasterDataCollectionMetadata = (output, context) => {
-    return smithyClient.take(output, {
-        Arn: smithyClient.expectString,
-        Description: smithyClient.expectString,
-        DescriptionPageUrl: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        SupportedFilters: (_) => de_FilterList(_),
-        Tags: smithyClient._json,
-        Type: smithyClient.expectString,
-    });
-};
-const de_RasterDataCollectionQueryOutput = (output, context) => {
-    return smithyClient.take(output, {
-        AreaOfInterest: (_) => de_AreaOfInterest(core$1.awsExpectUnion(_)),
-        PropertyFilters: (_) => de_PropertyFilters(_),
-        RasterDataCollectionArn: smithyClient.expectString,
-        RasterDataCollectionName: smithyClient.expectString,
-        TimeRangeFilter: (_) => de_TimeRangeFilterOutput(_),
-    });
-};
-const de_ResamplingConfigInput = (output, context) => {
-    return smithyClient.take(output, {
-        AlgorithmName: smithyClient.expectString,
-        OutputResolution: (_) => de_OutputResolutionResamplingInput(_),
-        TargetBands: smithyClient._json,
-    });
-};
-const de_StackConfigInput = (output, context) => {
-    return smithyClient.take(output, {
-        OutputResolution: (_) => de_OutputResolutionStackInput(_),
-        TargetBands: smithyClient._json,
-    });
-};
-const de_TimeRangeFilterOutput = (output, context) => {
-    return smithyClient.take(output, {
-        EndTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-    });
-};
-const de_UserDefined = (output, context) => {
-    return smithyClient.take(output, {
-        Unit: smithyClient.expectString,
-        Value: smithyClient.limitedParseFloat32,
-    });
-};
-const de_VectorEnrichmentJobList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ListVectorEnrichmentJobOutputConfig(entry);
-    });
-    return retVal;
-};
-const de_ViewOffNadirInput = (output, context) => {
-    return smithyClient.take(output, {
-        LowerBound: smithyClient.limitedParseFloat32,
-        UpperBound: smithyClient.limitedParseFloat32,
-    });
-};
-const de_ViewSunAzimuthInput = (output, context) => {
-    return smithyClient.take(output, {
-        LowerBound: smithyClient.limitedParseFloat32,
-        UpperBound: smithyClient.limitedParseFloat32,
-    });
-};
-const de_ViewSunElevationInput = (output, context) => {
-    return smithyClient.take(output, {
-        LowerBound: smithyClient.limitedParseFloat32,
-        UpperBound: smithyClient.limitedParseFloat32,
-    });
-};
-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 _A = "Arn";
+const _ADE = "AccessDeniedException";
+const _AM = "AssetsMap";
+const _AN = "AlgorithmName";
+const _AOI = "AreaOfInterest";
+const _AOIG = "AreaOfInterestGeometry";
+const _ARC = "ApproximateResultCount";
+const _AV = "AssetValue";
+const _As = "Assets";
+const _BF = "BinaryFile";
+const _BFa = "BandFilter";
+const _BMC = "BandMathConfig";
+const _BMCI = "BandMathConfigInput";
+const _BN = "BandName";
+const _C = "Coordinates";
+const _CE = "ConflictException";
+const _CI = "CustomIndices";
+const _CII = "CustomIndicesInput";
+const _CMC = "CloudMaskingConfig";
+const _CMCI = "CloudMaskingConfigInput";
+const _CO = "ComparisonOperator";
+const _CRC = "CloudRemovalConfig";
+const _CRCI = "CloudRemovalConfigInput";
+const _CT = "ClientToken";
+const _CTr = "CreationTime";
+const _D = "Description";
+const _DCL = "DataCollectionsList";
+const _DEOJ = "DeleteEarthObservationJob";
+const _DEOJI = "DeleteEarthObservationJobInput";
+const _DEOJO = "DeleteEarthObservationJobOutput";
+const _DIS = "DurationInSeconds";
+const _DPU = "DescriptionPageUrl";
+const _DSC = "DataSourceConfig";
+const _DT = "DateTime";
+const _DTo = "DocumentType";
+const _DVEJ = "DeleteVectorEnrichmentJob";
+const _DVEJI = "DeleteVectorEnrichmentJobInput";
+const _DVEJO = "DeleteVectorEnrichmentJobOutput";
+const _E = "Equation";
+const _ECC = "EoCloudCover";
+const _ECCI = "EoCloudCoverInput";
+const _ED = "ErrorDetails";
+const _EED = "ExportErrorDetails";
+const _EEDO = "ExportErrorDetailsOutput";
+const _EEOJ = "ExportEarthObservationJob";
+const _EEOJI = "ExportEarthObservationJobInput";
+const _EEOJO = "ExportEarthObservationJobOutput";
+const _EM = "ErrorMessage";
+const _EOJED = "EarthObservationJobErrorDetails";
+const _EOJL = "EarthObservationJobList";
+const _EOJOB = "EarthObservationJobOutputBands";
+const _EOJS = "EarthObservationJobSummaries";
+const _ER = "ExportResults";
 const _ERA = "ExecutionRoleArn";
+const _ES = "ExportStatus";
+const _ESDI = "ExportS3DataInput";
+const _ESI = "ExportSourceImages";
+const _ET = "EndTime";
+const _ETr = "ErrorType";
+const _EVEJ = "ExportVectorEnrichmentJob";
+const _EVEJI = "ExportVectorEnrichmentJobInput";
+const _EVEJO = "ExportVectorEnrichmentJobOutput";
+const _EVEJOC = "ExportVectorEnrichmentJobOutputConfig";
+const _F = "Filter";
+const _FL = "FilterList";
+const _G = "Geometry";
+const _GB = "GroupBy";
+const _GEOJ = "GetEarthObservationJob";
+const _GEOJI = "GetEarthObservationJobInput";
+const _GEOJO = "GetEarthObservationJobOutput";
+const _GMC = "GeoMosaicConfig";
+const _GMCI = "GeoMosaicConfigInput";
+const _GRDC = "GetRasterDataCollection";
+const _GRDCI = "GetRasterDataCollectionInput";
+const _GRDCO = "GetRasterDataCollectionOutput";
+const _GT = "GetTile";
+const _GTI = "GetTileInput";
+const _GTO = "GetTileOutput";
+const _GVEJ = "GetVectorEnrichmentJob";
+const _GVEJI = "GetVectorEnrichmentJobInput";
+const _GVEJO = "GetVectorEnrichmentJobOutput";
+const _H = "Href";
+const _I = "Id";
 const _IA = "ImageAssets";
+const _IAN = "IdAttributeName";
+const _IC = "InputConfig";
+const _ICI = "InputConfigInput";
+const _ICO = "InputConfigOutput";
 const _IM = "ImageMask";
+const _IS = "ItemSource";
+const _ISB = "ImageSourceBands";
+const _ISE = "InternalServerException";
+const _ISL = "ItemSourceList";
+const _IV = "InterpolationValue";
+const _It = "Items";
+const _JC = "JobConfig";
+const _JCI = "JobConfigInput";
+const _KKI = "KmsKeyId";
+const _LB = "LowerBound";
+const _LCCL = "LandsatCloudCoverLand";
+const _LCCLI = "LandsatCloudCoverLandInput";
+const _LCSC = "LandCoverSegmentationConfig";
+const _LCSCI = "LandCoverSegmentationConfigInput";
+const _LEOJ = "ListEarthObservationJobs";
+const _LEOJI = "ListEarthObservationJobInput";
+const _LEOJO = "ListEarthObservationJobOutput";
+const _LEOJOC = "ListEarthObservationJobOutputConfig";
+const _LO = "LogicalOperator";
+const _LR = "LinearRing";
+const _LRDC = "ListRasterDataCollections";
+const _LRDCI = "ListRasterDataCollectionsInput";
+const _LRDCO = "ListRasterDataCollectionsOutput";
+const _LRL = "LinearRingsList";
+const _LRi = "LinearRings";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _LVEJ = "ListVectorEnrichmentJobs";
+const _LVEJI = "ListVectorEnrichmentJobInput";
+const _LVEJO = "ListVectorEnrichmentJobOutput";
+const _LVEJOC = "ListVectorEnrichmentJobOutputConfig";
+const _M = "Message";
+const _MMC = "MapMatchingConfig";
+const _MPG = "MultiPolygonGeometry";
+const _MPGI = "MultiPolygonGeometryInput";
 const _MR = "MaxResults";
+const _Ma = "Maximum";
+const _Mi = "Minimum";
+const _N = "Name";
 const _NT = "NextToken";
+const _O = "Operations";
+const _OB = "OutputBands";
+const _OBu = "OutputBand";
+const _OC = "OutputConfig";
+const _OCI = "OutputConfigInput";
 const _ODT = "OutputDataType";
 const _OF = "OutputFormat";
+const _OLI = "OperationsListInput";
+const _OR = "OutputResolution";
+const _ORRI = "OutputResolutionResamplingInput";
+const _ORSI = "OutputResolutionStackInput";
+const _OT = "OperationType";
+const _OTu = "OutputType";
+const _Op = "Operation";
+const _P = "Properties";
+const _PEOJA = "PreviousEarthObservationJobArn";
 const _PF = "PropertyFilters";
-const _T = "Target";
+const _PFL = "PropertyFiltersList";
+const _PFr = "PropertyFilter";
+const _PG = "PolygonGeometry";
+const _PGI = "PolygonGeometryInput";
+const _PI = "PredefinedIndices";
+const _PIl = "PlatformInput";
+const _Pl = "Platform";
+const _Po = "Position";
+const _Pr = "Predefined";
+const _Pro = "Property";
+const _RA = "ResourceArn";
+const _RC = "ResamplingConfig";
+const _RCI = "ResamplingConfigInput";
+const _RDCA = "RasterDataCollectionArn";
+const _RDCM = "RasterDataCollectionMetadata";
+const _RDCN = "RasterDataCollectionName";
+const _RDCQ = "RasterDataCollectionQuery";
+const _RDCQI = "RasterDataCollectionQueryInput";
+const _RDCQO = "RasterDataCollectionQueryOutput";
+const _RDCQWBFI = "RasterDataCollectionQueryWithBandFilterInput";
+const _RDCS = "RasterDataCollectionSummaries";
+const _RGC = "ReverseGeocodingConfig";
+const _RI = "ResourceId";
+const _RNFE = "ResourceNotFoundException";
+const _S = "Status";
+const _SB = "SortBy";
+const _SC = "StackConfig";
+const _SCI = "StackConfigInput";
+const _SD = "S3Data";
+const _SE = "StatusEquals";
+const _SEOJ = "StartEarthObservationJob";
+const _SEOJI = "StartEarthObservationJobInput";
+const _SEOJIt = "StopEarthObservationJobInput";
+const _SEOJO = "StartEarthObservationJobOutput";
+const _SEOJOt = "StopEarthObservationJobOutput";
+const _SEOJt = "StopEarthObservationJob";
+const _SF = "SupportedFilters";
+const _SO = "SortOrder";
+const _SQEE = "ServiceQuotaExceededException";
+const _SRDC = "SearchRasterDataCollection";
+const _SRDCI = "SearchRasterDataCollectionInput";
+const _SRDCO = "SearchRasterDataCollectionOutput";
+const _ST = "StartTime";
+const _SU = "S3Uri";
+const _SVEJ = "StartVectorEnrichmentJob";
+const _SVEJI = "StartVectorEnrichmentJobInput";
+const _SVEJIt = "StopVectorEnrichmentJobInput";
+const _SVEJO = "StartVectorEnrichmentJobOutput";
+const _SVEJOt = "StopVectorEnrichmentJobOutput";
+const _SVEJt = "StopVectorEnrichmentJob";
+const _St = "Statistics";
+const _T = "Type";
+const _TAN = "TimestampAttributeName";
+const _TB = "TargetBands";
+const _TE = "ThrottlingException";
 const _TK = "TagKeys";
+const _TR = "TagResource";
 const _TRF = "TimeRangeFilter";
+const _TRFI = "TimeRangeFilterInput";
+const _TRFO = "TimeRangeFilterOutput";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _TSC = "TemporalStatisticsConfig";
+const _TSCI = "TemporalStatisticsConfigInput";
+const _Ta = "Tags";
+const _Tar = "Target";
+const _U = "Unit";
+const _UB = "UpperBound";
+const _UD = "UserDefined";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _V = "Value";
+const _VE = "ValidationException";
+const _VEJC = "VectorEnrichmentJobConfig";
+const _VEJDSCI = "VectorEnrichmentJobDataSourceConfigInput";
+const _VEJED = "VectorEnrichmentJobErrorDetails";
+const _VEJEED = "VectorEnrichmentJobExportErrorDetails";
+const _VEJIC = "VectorEnrichmentJobInputConfig";
+const _VEJL = "VectorEnrichmentJobList";
+const _VEJS = "VectorEnrichmentJobSummaries";
+const _VEJSD = "VectorEnrichmentJobS3Data";
+const _VON = "ViewOffNadir";
+const _VONI = "ViewOffNadirInput";
+const _VSA = "ViewSunAzimuth";
+const _VSAI = "ViewSunAzimuthInput";
+const _VSE = "ViewSunElevation";
+const _VSEI = "ViewSunElevationInput";
+const _XAN = "XAttributeName";
+const _YAN = "YAttributeName";
+const _ZSC = "ZonalStatisticsConfig";
+const _ZSCI = "ZonalStatisticsConfigInput";
+const _ZSP = "ZoneS3Path";
+const _ZSPKKI = "ZoneS3PathKmsKeyId";
+const _ab = "application/x-binary";
+const _c = "client";
+const _e = "error";
+const _h = "http";
+const _hE = "httpError";
+const _hQ = "httpQuery";
+const _mT = "mediaType";
+const _s = "streaming";
+const _se = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.sagemakergeospatial";
 const _tK = "tagKeys";
+const _x = "x";
+const _y = "y";
+const _z = "z";
+const n0 = "com.amazonaws.sagemakergeospatial";
+var BinaryFile = [
+    0,
+    n0,
+    _BF,
+    {
+        [_mT]: _ab,
+        [_s]: 1,
+    },
+    42,
+];
+var NextToken = [0, n0, _NT, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var AssetValue = [3, n0, _AV, 0, [_H], [0]];
+var BandMathConfigInput = [
+    3,
+    n0,
+    _BMCI,
+    0,
+    [_PI, _CI],
+    [64 | 0, () => CustomIndicesInput],
+];
+var CloudMaskingConfigInput = [3, n0, _CMCI, 0, [], []];
+var CloudRemovalConfigInput = [3, n0, _CRCI, 0, [_AN, _IV, _TB], [0, 0, 64 | 0]];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_M, _RI],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CustomIndicesInput = [3, n0, _CII, 0, [_O], [() => OperationsListInput]];
+var DeleteEarthObservationJobInput = [3, n0, _DEOJI, 0, [_A], [[0, 1]]];
+var DeleteEarthObservationJobOutput = [3, n0, _DEOJO, 0, [], []];
+var DeleteVectorEnrichmentJobInput = [3, n0, _DVEJI, 0, [_A], [[0, 1]]];
+var DeleteVectorEnrichmentJobOutput = [3, n0, _DVEJO, 0, [], []];
+var EarthObservationJobErrorDetails = [3, n0, _EOJED, 0, [_T, _M], [0, 0]];
+var EoCloudCoverInput = [3, n0, _ECCI, 0, [_LB, _UB], [1, 1]];
+var ExportEarthObservationJobInput = [
+    3,
+    n0,
+    _EEOJI,
+    0,
+    [_A, _CT, _ERA, _OC, _ESI],
+    [0, [0, 4], 0, () => OutputConfigInput, 2],
+];
+var ExportEarthObservationJobOutput = [
+    3,
+    n0,
+    _EEOJO,
+    0,
+    [_A, _CTr, _ES, _ERA, _OC, _ESI],
+    [0, 5, 0, 0, () => OutputConfigInput, 2],
+];
+var ExportErrorDetails = [
+    3,
+    n0,
+    _EED,
+    0,
+    [_ER, _ESI],
+    [() => ExportErrorDetailsOutput, () => ExportErrorDetailsOutput],
+];
+var ExportErrorDetailsOutput = [3, n0, _EEDO, 0, [_T, _M], [0, 0]];
+var ExportS3DataInput = [3, n0, _ESDI, 0, [_SU, _KKI], [0, 0]];
+var ExportVectorEnrichmentJobInput = [
+    3,
+    n0,
+    _EVEJI,
+    0,
+    [_A, _CT, _ERA, _OC],
+    [0, [0, 4], 0, () => ExportVectorEnrichmentJobOutputConfig],
+];
+var ExportVectorEnrichmentJobOutput = [
+    3,
+    n0,
+    _EVEJO,
+    0,
+    [_A, _CTr, _ERA, _ES, _OC],
+    [0, 5, 0, 0, () => ExportVectorEnrichmentJobOutputConfig],
+];
+var ExportVectorEnrichmentJobOutputConfig = [
+    3,
+    n0,
+    _EVEJOC,
+    0,
+    [_SD],
+    [() => VectorEnrichmentJobS3Data],
+];
+var Filter = [3, n0, _F, 0, [_N, _T, _Mi, _Ma], [0, 0, 1, 1]];
+var Geometry = [3, n0, _G, 0, [_T, _C], [0, [() => LinearRings, 0]]];
+var GeoMosaicConfigInput = [3, n0, _GMCI, 0, [_AN, _TB], [0, 64 | 0]];
+var GetEarthObservationJobInput = [3, n0, _GEOJI, 0, [_A], [[0, 1]]];
+var GetEarthObservationJobOutput = [
+    3,
+    n0,
+    _GEOJO,
+    0,
+    [_A, _N, _CTr, _DIS, _S, _KKI, _IC, _JC, _OB, _ERA, _ED, _ES, _EED, _Ta],
+    [
+        0,
+        0,
+        5,
+        1,
+        0,
+        0,
+        [() => InputConfigOutput, 0],
+        () => JobConfigInput,
+        () => EarthObservationJobOutputBands,
+        0,
+        () => EarthObservationJobErrorDetails,
+        0,
+        () => ExportErrorDetails,
+        128 | 0,
+    ],
+];
+var GetRasterDataCollectionInput = [3, n0, _GRDCI, 0, [_A], [[0, 1]]];
+var GetRasterDataCollectionOutput = [
+    3,
+    n0,
+    _GRDCO,
+    0,
+    [_N, _A, _T, _D, _DPU, _SF, _ISB, _Ta],
+    [0, 0, 0, 0, 0, () => FilterList, 64 | 0, 128 | 0],
+];
+var GetTileInput = [
+    3,
+    n0,
+    _GTI,
+    0,
+    [_x, _y, _z, _IA, _Tar, _A, _IM, _OF, _TRF, _PF, _ODT, _ERA],
+    [
+        [1, 1],
+        [1, 1],
+        [1, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _IA,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _Tar,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _A,
+            },
+        ],
+        [
+            2,
+            {
+                [_hQ]: _IM,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _OF,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _TRF,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _PF,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _ODT,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _ERA,
+            },
+        ],
+    ],
+];
+var GetTileOutput = [3, n0, _GTO, 0, [_BF], [[() => BinaryFile, 16]]];
+var GetVectorEnrichmentJobInput = [3, n0, _GVEJI, 0, [_A], [[0, 1]]];
+var GetVectorEnrichmentJobOutput = [
+    3,
+    n0,
+    _GVEJO,
+    0,
+    [_A, _T, _N, _CTr, _DIS, _S, _KKI, _IC, _JC, _ERA, _ED, _ES, _EED, _Ta],
+    [
+        0,
+        0,
+        0,
+        5,
+        1,
+        0,
+        0,
+        () => VectorEnrichmentJobInputConfig,
+        () => VectorEnrichmentJobConfig,
+        0,
+        () => VectorEnrichmentJobErrorDetails,
+        0,
+        () => VectorEnrichmentJobExportErrorDetails,
+        128 | 0,
+    ],
+];
+var InputConfigInput = [
+    3,
+    n0,
+    _ICI,
+    0,
+    [_PEOJA, _RDCQ],
+    [0, [() => RasterDataCollectionQueryInput, 0]],
+];
+var InputConfigOutput = [
+    3,
+    n0,
+    _ICO,
+    0,
+    [_PEOJA, _RDCQ],
+    [0, [() => RasterDataCollectionQueryOutput, 0]],
+];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+    },
+    [_M, _RI],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var ItemSource = [
+    3,
+    n0,
+    _IS,
+    0,
+    [_I, _G, _As, _DT, _P],
+    [0, [() => Geometry, 0], () => AssetsMap, 4, () => Properties],
+];
+var LandCoverSegmentationConfigInput = [3, n0, _LCSCI, 0, [], []];
+var LandsatCloudCoverLandInput = [3, n0, _LCCLI, 0, [_LB, _UB], [1, 1]];
+var ListEarthObservationJobInput = [
+    3,
+    n0,
+    _LEOJI,
+    0,
+    [_SE, _SO, _SB, _NT, _MR],
+    [0, 0, 0, [() => NextToken, 0], 1],
+];
+var ListEarthObservationJobOutput = [
+    3,
+    n0,
+    _LEOJO,
+    0,
+    [_EOJS, _NT],
+    [() => EarthObservationJobList, [() => NextToken, 0]],
+];
+var ListEarthObservationJobOutputConfig = [
+    3,
+    n0,
+    _LEOJOC,
+    0,
+    [_A, _N, _CTr, _DIS, _S, _OT, _Ta],
+    [0, 0, 5, 1, 0, 0, 128 | 0],
+];
+var ListRasterDataCollectionsInput = [
+    3,
+    n0,
+    _LRDCI,
+    0,
+    [_NT, _MR],
+    [
+        [
+            () => NextToken,
+            {
+                [_hQ]: _NT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _MR,
+            },
+        ],
+    ],
+];
+var ListRasterDataCollectionsOutput = [
+    3,
+    n0,
+    _LRDCO,
+    0,
+    [_RDCS, _NT],
+    [() => DataCollectionsList, [() => NextToken, 0]],
+];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_RA], [[0, 1]]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_Ta], [128 | 0]];
+var ListVectorEnrichmentJobInput = [
+    3,
+    n0,
+    _LVEJI,
+    0,
+    [_SE, _SO, _SB, _NT, _MR],
+    [0, 0, 0, [() => NextToken, 0], 1],
+];
+var ListVectorEnrichmentJobOutput = [
+    3,
+    n0,
+    _LVEJO,
+    0,
+    [_VEJS, _NT],
+    [() => VectorEnrichmentJobList, [() => NextToken, 0]],
+];
+var ListVectorEnrichmentJobOutputConfig = [
+    3,
+    n0,
+    _LVEJOC,
+    0,
+    [_A, _N, _T, _CTr, _DIS, _S, _Ta],
+    [0, 0, 0, 5, 1, 0, 128 | 0],
+];
+var MapMatchingConfig = [3, n0, _MMC, 0, [_IAN, _YAN, _XAN, _TAN], [0, 0, 0, 0]];
+var MultiPolygonGeometryInput = [3, n0, _MPGI, 0, [_C], [[() => LinearRingsList, 0]]];
+var Operation = [3, n0, _Op, 0, [_N, _E, _OTu], [0, 0, 0]];
+var OutputBand = [3, n0, _OBu, 0, [_BN, _ODT], [0, 0]];
+var OutputConfigInput = [3, n0, _OCI, 0, [_SD], [() => ExportS3DataInput]];
+var OutputResolutionResamplingInput = [3, n0, _ORRI, 0, [_UD], [() => UserDefined]];
+var OutputResolutionStackInput = [3, n0, _ORSI, 0, [_Pr, _UD], [0, () => UserDefined]];
+var PlatformInput = [3, n0, _PIl, 0, [_V, _CO], [0, 0]];
+var PolygonGeometryInput = [3, n0, _PGI, 0, [_C], [[() => LinearRings, 0]]];
+var Properties = [3, n0, _P, 0, [_ECC, _VON, _VSA, _VSE, _Pl, _LCCL], [1, 1, 1, 1, 0, 1]];
+var PropertyFilter = [3, n0, _PFr, 0, [_Pro], [() => Property]];
+var PropertyFilters = [3, n0, _PF, 0, [_P, _LO], [() => PropertyFiltersList, 0]];
+var RasterDataCollectionMetadata = [
+    3,
+    n0,
+    _RDCM,
+    0,
+    [_N, _A, _T, _D, _DPU, _SF, _Ta],
+    [0, 0, 0, 0, 0, () => FilterList, 128 | 0],
+];
+var RasterDataCollectionQueryInput = [
+    3,
+    n0,
+    _RDCQI,
+    0,
+    [_RDCA, _TRF, _AOI, _PF],
+    [0, [() => TimeRangeFilterInput, 0], [() => AreaOfInterest, 0], () => PropertyFilters],
+];
+var RasterDataCollectionQueryOutput = [
+    3,
+    n0,
+    _RDCQO,
+    0,
+    [_RDCA, _RDCN, _TRF, _AOI, _PF],
+    [0, 0, [() => TimeRangeFilterOutput, 0], [() => AreaOfInterest, 0], () => PropertyFilters],
+];
+var RasterDataCollectionQueryWithBandFilterInput = [
+    3,
+    n0,
+    _RDCQWBFI,
+    0,
+    [_TRF, _AOI, _PF, _BFa],
+    [[() => TimeRangeFilterInput, 0], [() => AreaOfInterest, 0], () => PropertyFilters, 64 | 0],
+];
+var ResamplingConfigInput = [
+    3,
+    n0,
+    _RCI,
+    0,
+    [_OR, _AN, _TB],
+    [() => OutputResolutionResamplingInput, 0, 64 | 0],
+];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_M, _RI],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var ReverseGeocodingConfig = [3, n0, _RGC, 0, [_YAN, _XAN], [0, 0]];
+var SearchRasterDataCollectionInput = [
+    3,
+    n0,
+    _SRDCI,
+    0,
+    [_A, _RDCQ, _NT],
+    [0, [() => RasterDataCollectionQueryWithBandFilterInput, 0], [() => NextToken, 0]],
+];
+var SearchRasterDataCollectionOutput = [
+    3,
+    n0,
+    _SRDCO,
+    0,
+    [_ARC, _NT, _It],
+    [1, [() => NextToken, 0], [() => ItemSourceList, 0]],
+];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_M, _RI],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var StackConfigInput = [
+    3,
+    n0,
+    _SCI,
+    0,
+    [_OR, _TB],
+    [() => OutputResolutionStackInput, 64 | 0],
+];
+var StartEarthObservationJobInput = [
+    3,
+    n0,
+    _SEOJI,
+    0,
+    [_N, _CT, _KKI, _IC, _JC, _ERA, _Ta],
+    [0, [0, 4], 0, [() => InputConfigInput, 0], () => JobConfigInput, 0, 128 | 0],
+];
+var StartEarthObservationJobOutput = [
+    3,
+    n0,
+    _SEOJO,
+    0,
+    [_N, _A, _CTr, _DIS, _S, _KKI, _IC, _JC, _ERA, _Ta],
+    [0, 0, 5, 1, 0, 0, [() => InputConfigOutput, 0], () => JobConfigInput, 0, 128 | 0],
+];
+var StartVectorEnrichmentJobInput = [
+    3,
+    n0,
+    _SVEJI,
+    0,
+    [_N, _CT, _KKI, _IC, _JC, _ERA, _Ta],
+    [0, [0, 4], 0, () => VectorEnrichmentJobInputConfig, () => VectorEnrichmentJobConfig, 0, 128 | 0],
+];
+var StartVectorEnrichmentJobOutput = [
+    3,
+    n0,
+    _SVEJO,
+    0,
+    [_N, _A, _T, _CTr, _DIS, _S, _KKI, _IC, _JC, _ERA, _Ta],
+    [0, 0, 0, 5, 1, 0, 0, () => VectorEnrichmentJobInputConfig, () => VectorEnrichmentJobConfig, 0, 128 | 0],
+];
+var StopEarthObservationJobInput = [3, n0, _SEOJIt, 0, [_A], [0]];
+var StopEarthObservationJobOutput = [3, n0, _SEOJOt, 0, [], []];
+var StopVectorEnrichmentJobInput = [3, n0, _SVEJIt, 0, [_A], [0]];
+var StopVectorEnrichmentJobOutput = [3, n0, _SVEJOt, 0, [], []];
+var TagResourceRequest = [3, n0, _TRR, 0, [_RA, _Ta], [[0, 1], 128 | 0]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var TemporalStatisticsConfigInput = [
+    3,
+    n0,
+    _TSCI,
+    0,
+    [_GB, _St, _TB],
+    [0, 64 | 0, 64 | 0],
+];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_M, _RI],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var TimeRangeFilterInput = [3, n0, _TRFI, 8, [_ST, _ET], [4, 4]];
+var TimeRangeFilterOutput = [3, n0, _TRFO, 8, [_ST, _ET], [5, 5]];
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_RA, _TK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UserDefined = [3, n0, _UD, 0, [_V, _U], [1, 0]];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M, _RI],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var VectorEnrichmentJobErrorDetails = [3, n0, _VEJED, 0, [_ETr, _EM], [0, 0]];
+var VectorEnrichmentJobExportErrorDetails = [3, n0, _VEJEED, 0, [_T, _M], [0, 0]];
+var VectorEnrichmentJobInputConfig = [
+    3,
+    n0,
+    _VEJIC,
+    0,
+    [_DTo, _DSC],
+    [0, () => VectorEnrichmentJobDataSourceConfigInput],
+];
+var VectorEnrichmentJobS3Data = [3, n0, _VEJSD, 0, [_SU, _KKI], [0, 0]];
+var ViewOffNadirInput = [3, n0, _VONI, 0, [_LB, _UB], [1, 1]];
+var ViewSunAzimuthInput = [3, n0, _VSAI, 0, [_LB, _UB], [1, 1]];
+var ViewSunElevationInput = [3, n0, _VSEI, 0, [_LB, _UB], [1, 1]];
+var ZonalStatisticsConfigInput = [
+    3,
+    n0,
+    _ZSCI,
+    0,
+    [_ZSP, _St, _TB, _ZSPKKI],
+    [0, 64 | 0, 64 | 0, 0],
+];
+var SageMakerGeospatialServiceException = [
+    -3,
+    _sm,
+    "SageMakerGeospatialServiceException",
+    0,
+    [],
+    [],
+];
+schema.TypeRegistry.for(_sm).registerError(SageMakerGeospatialServiceException, SageMakerGeospatialServiceException$1);
+var DataCollectionsList = [1, n0, _DCL, 0, () => RasterDataCollectionMetadata];
+var EarthObservationJobList = [1, n0, _EOJL, 0, () => ListEarthObservationJobOutputConfig];
+var EarthObservationJobOutputBands = [1, n0, _EOJOB, 0, () => OutputBand];
+var FilterList = [1, n0, _FL, 0, () => Filter];
+var ItemSourceList = [1, n0, _ISL, 0, [() => ItemSource, 0]];
+var LinearRing = [1, n0, _LR, 0, [() => Position, 0]];
+var LinearRings = [1, n0, _LRi, 0, [() => LinearRing, 0]];
+var LinearRingsList = [1, n0, _LRL, 0, [() => LinearRings, 0]];
+var OperationsListInput = [1, n0, _OLI, 0, () => Operation];
+var Position = [1, n0, _Po, 8, 1];
+var PropertyFiltersList = [1, n0, _PFL, 0, () => PropertyFilter];
+var VectorEnrichmentJobList = [1, n0, _VEJL, 0, () => ListVectorEnrichmentJobOutputConfig];
+var AssetsMap = [2, n0, _AM, 0, 0, () => AssetValue];
+var AreaOfInterest = [3, n0, _AOI, 0, [_AOIG], [[() => AreaOfInterestGeometry, 0]]];
+var AreaOfInterestGeometry = [
+    3,
+    n0,
+    _AOIG,
+    0,
+    [_PG, _MPG],
+    [
+        [() => PolygonGeometryInput, 0],
+        [() => MultiPolygonGeometryInput, 0],
+    ],
+];
+var JobConfigInput = [
+    3,
+    n0,
+    _JCI,
+    0,
+    [_BMC, _RC, _TSC, _CRC, _ZSC, _GMC, _SC, _CMC, _LCSC],
+    [
+        () => BandMathConfigInput,
+        () => ResamplingConfigInput,
+        () => TemporalStatisticsConfigInput,
+        () => CloudRemovalConfigInput,
+        () => ZonalStatisticsConfigInput,
+        () => GeoMosaicConfigInput,
+        () => StackConfigInput,
+        () => CloudMaskingConfigInput,
+        () => LandCoverSegmentationConfigInput,
+    ],
+];
+var Property = [
+    3,
+    n0,
+    _Pro,
+    0,
+    [_ECC, _VON, _VSA, _VSE, _Pl, _LCCL],
+    [
+        () => EoCloudCoverInput,
+        () => ViewOffNadirInput,
+        () => ViewSunAzimuthInput,
+        () => ViewSunElevationInput,
+        () => PlatformInput,
+        () => LandsatCloudCoverLandInput,
+    ],
+];
+var VectorEnrichmentJobConfig = [
+    3,
+    n0,
+    _VEJC,
+    0,
+    [_RGC, _MMC],
+    [() => ReverseGeocodingConfig, () => MapMatchingConfig],
+];
+var VectorEnrichmentJobDataSourceConfigInput = [
+    3,
+    n0,
+    _VEJDSCI,
+    0,
+    [_SD],
+    [() => VectorEnrichmentJobS3Data],
+];
+var DeleteEarthObservationJob = [
+    9,
+    n0,
+    _DEOJ,
+    {
+        [_h]: ["DELETE", "/earth-observation-jobs/{Arn}", 200],
+    },
+    () => DeleteEarthObservationJobInput,
+    () => DeleteEarthObservationJobOutput,
+];
+var DeleteVectorEnrichmentJob = [
+    9,
+    n0,
+    _DVEJ,
+    {
+        [_h]: ["DELETE", "/vector-enrichment-jobs/{Arn}", 200],
+    },
+    () => DeleteVectorEnrichmentJobInput,
+    () => DeleteVectorEnrichmentJobOutput,
+];
+var ExportEarthObservationJob = [
+    9,
+    n0,
+    _EEOJ,
+    {
+        [_h]: ["POST", "/export-earth-observation-job", 200],
+    },
+    () => ExportEarthObservationJobInput,
+    () => ExportEarthObservationJobOutput,
+];
+var ExportVectorEnrichmentJob = [
+    9,
+    n0,
+    _EVEJ,
+    {
+        [_h]: ["POST", "/export-vector-enrichment-jobs", 200],
+    },
+    () => ExportVectorEnrichmentJobInput,
+    () => ExportVectorEnrichmentJobOutput,
+];
+var GetEarthObservationJob = [
+    9,
+    n0,
+    _GEOJ,
+    {
+        [_h]: ["GET", "/earth-observation-jobs/{Arn}", 200],
+    },
+    () => GetEarthObservationJobInput,
+    () => GetEarthObservationJobOutput,
+];
+var GetRasterDataCollection = [
+    9,
+    n0,
+    _GRDC,
+    {
+        [_h]: ["GET", "/raster-data-collection/{Arn}", 200],
+    },
+    () => GetRasterDataCollectionInput,
+    () => GetRasterDataCollectionOutput,
+];
+var GetTile = [
+    9,
+    n0,
+    _GT,
+    {
+        [_h]: ["GET", "/tile/{z}/{x}/{y}", 200],
+    },
+    () => GetTileInput,
+    () => GetTileOutput,
+];
+var GetVectorEnrichmentJob = [
+    9,
+    n0,
+    _GVEJ,
+    {
+        [_h]: ["GET", "/vector-enrichment-jobs/{Arn}", 200],
+    },
+    () => GetVectorEnrichmentJobInput,
+    () => GetVectorEnrichmentJobOutput,
+];
+var ListEarthObservationJobs = [
+    9,
+    n0,
+    _LEOJ,
+    {
+        [_h]: ["POST", "/list-earth-observation-jobs", 200],
+    },
+    () => ListEarthObservationJobInput,
+    () => ListEarthObservationJobOutput,
+];
+var ListRasterDataCollections = [
+    9,
+    n0,
+    _LRDC,
+    {
+        [_h]: ["GET", "/raster-data-collections", 200],
+    },
+    () => ListRasterDataCollectionsInput,
+    () => ListRasterDataCollectionsOutput,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["GET", "/tags/{ResourceArn}", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var ListVectorEnrichmentJobs = [
+    9,
+    n0,
+    _LVEJ,
+    {
+        [_h]: ["POST", "/list-vector-enrichment-jobs", 200],
+    },
+    () => ListVectorEnrichmentJobInput,
+    () => ListVectorEnrichmentJobOutput,
+];
+var SearchRasterDataCollection = [
+    9,
+    n0,
+    _SRDC,
+    {
+        [_h]: ["POST", "/search-raster-data-collection", 200],
+    },
+    () => SearchRasterDataCollectionInput,
+    () => SearchRasterDataCollectionOutput,
+];
+var StartEarthObservationJob = [
+    9,
+    n0,
+    _SEOJ,
+    {
+        [_h]: ["POST", "/earth-observation-jobs", 200],
+    },
+    () => StartEarthObservationJobInput,
+    () => StartEarthObservationJobOutput,
+];
+var StartVectorEnrichmentJob = [
+    9,
+    n0,
+    _SVEJ,
+    {
+        [_h]: ["POST", "/vector-enrichment-jobs", 200],
+    },
+    () => StartVectorEnrichmentJobInput,
+    () => StartVectorEnrichmentJobOutput,
+];
+var StopEarthObservationJob = [
+    9,
+    n0,
+    _SEOJt,
+    {
+        [_h]: ["POST", "/earth-observation-jobs/stop", 200],
+    },
+    () => StopEarthObservationJobInput,
+    () => StopEarthObservationJobOutput,
+];
+var StopVectorEnrichmentJob = [
+    9,
+    n0,
+    _SVEJt,
+    {
+        [_h]: ["POST", "/vector-enrichment-jobs/stop", 200],
+    },
+    () => StopVectorEnrichmentJobInput,
+    () => StopVectorEnrichmentJobOutput,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_h]: ["PUT", "/tags/{ResourceArn}", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["DELETE", "/tags/{ResourceArn}", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
 
 class DeleteEarthObservationJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "DeleteEarthObservationJob", {})
     .n("SageMakerGeospatialClient", "DeleteEarthObservationJobCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteEarthObservationJobCommand)
-    .de(de_DeleteEarthObservationJobCommand)
+    .sc(DeleteEarthObservationJob)
     .build() {
 }
 
@@ -1842,16 +1553,11 @@ class DeleteVectorEnrichmentJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "DeleteVectorEnrichmentJob", {})
     .n("SageMakerGeospatialClient", "DeleteVectorEnrichmentJobCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteVectorEnrichmentJobCommand)
-    .de(de_DeleteVectorEnrichmentJobCommand)
+    .sc(DeleteVectorEnrichmentJob)
     .build() {
 }
 
@@ -1859,16 +1565,11 @@ class ExportEarthObservationJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "ExportEarthObservationJob", {})
     .n("SageMakerGeospatialClient", "ExportEarthObservationJobCommand")
-    .f(void 0, void 0)
-    .ser(se_ExportEarthObservationJobCommand)
-    .de(de_ExportEarthObservationJobCommand)
+    .sc(ExportEarthObservationJob)
     .build() {
 }
 
@@ -1876,16 +1577,11 @@ class ExportVectorEnrichmentJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "ExportVectorEnrichmentJob", {})
     .n("SageMakerGeospatialClient", "ExportVectorEnrichmentJobCommand")
-    .f(void 0, void 0)
-    .ser(se_ExportVectorEnrichmentJobCommand)
-    .de(de_ExportVectorEnrichmentJobCommand)
+    .sc(ExportVectorEnrichmentJob)
     .build() {
 }
 
@@ -1893,16 +1589,11 @@ class GetEarthObservationJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "GetEarthObservationJob", {})
     .n("SageMakerGeospatialClient", "GetEarthObservationJobCommand")
-    .f(void 0, GetEarthObservationJobOutputFilterSensitiveLog)
-    .ser(se_GetEarthObservationJobCommand)
-    .de(de_GetEarthObservationJobCommand)
+    .sc(GetEarthObservationJob)
     .build() {
 }
 
@@ -1910,16 +1601,11 @@ class GetRasterDataCollectionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "GetRasterDataCollection", {})
     .n("SageMakerGeospatialClient", "GetRasterDataCollectionCommand")
-    .f(void 0, void 0)
-    .ser(se_GetRasterDataCollectionCommand)
-    .de(de_GetRasterDataCollectionCommand)
+    .sc(GetRasterDataCollection)
     .build() {
 }
 
@@ -1927,16 +1613,11 @@ class GetTileCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "GetTile", {})
     .n("SageMakerGeospatialClient", "GetTileCommand")
-    .f(void 0, GetTileOutputFilterSensitiveLog)
-    .ser(se_GetTileCommand)
-    .de(de_GetTileCommand)
+    .sc(GetTile)
     .build() {
 }
 
@@ -1944,16 +1625,11 @@ class GetVectorEnrichmentJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "GetVectorEnrichmentJob", {})
     .n("SageMakerGeospatialClient", "GetVectorEnrichmentJobCommand")
-    .f(void 0, void 0)
-    .ser(se_GetVectorEnrichmentJobCommand)
-    .de(de_GetVectorEnrichmentJobCommand)
+    .sc(GetVectorEnrichmentJob)
     .build() {
 }
 
@@ -1961,16 +1637,11 @@ class ListEarthObservationJobsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "ListEarthObservationJobs", {})
     .n("SageMakerGeospatialClient", "ListEarthObservationJobsCommand")
-    .f(ListEarthObservationJobInputFilterSensitiveLog, ListEarthObservationJobOutputFilterSensitiveLog)
-    .ser(se_ListEarthObservationJobsCommand)
-    .de(de_ListEarthObservationJobsCommand)
+    .sc(ListEarthObservationJobs)
     .build() {
 }
 
@@ -1978,16 +1649,11 @@ class ListRasterDataCollectionsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "ListRasterDataCollections", {})
     .n("SageMakerGeospatialClient", "ListRasterDataCollectionsCommand")
-    .f(ListRasterDataCollectionsInputFilterSensitiveLog, ListRasterDataCollectionsOutputFilterSensitiveLog)
-    .ser(se_ListRasterDataCollectionsCommand)
-    .de(de_ListRasterDataCollectionsCommand)
+    .sc(ListRasterDataCollections)
     .build() {
 }
 
@@ -1995,16 +1661,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "ListTagsForResource", {})
     .n("SageMakerGeospatialClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -2012,16 +1673,11 @@ class ListVectorEnrichmentJobsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "ListVectorEnrichmentJobs", {})
     .n("SageMakerGeospatialClient", "ListVectorEnrichmentJobsCommand")
-    .f(ListVectorEnrichmentJobInputFilterSensitiveLog, ListVectorEnrichmentJobOutputFilterSensitiveLog)
-    .ser(se_ListVectorEnrichmentJobsCommand)
-    .de(de_ListVectorEnrichmentJobsCommand)
+    .sc(ListVectorEnrichmentJobs)
     .build() {
 }
 
@@ -2029,16 +1685,11 @@ class SearchRasterDataCollectionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "SearchRasterDataCollection", {})
     .n("SageMakerGeospatialClient", "SearchRasterDataCollectionCommand")
-    .f(SearchRasterDataCollectionInputFilterSensitiveLog, SearchRasterDataCollectionOutputFilterSensitiveLog)
-    .ser(se_SearchRasterDataCollectionCommand)
-    .de(de_SearchRasterDataCollectionCommand)
+    .sc(SearchRasterDataCollection)
     .build() {
 }
 
@@ -2046,16 +1697,11 @@ class StartEarthObservationJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "StartEarthObservationJob", {})
     .n("SageMakerGeospatialClient", "StartEarthObservationJobCommand")
-    .f(StartEarthObservationJobInputFilterSensitiveLog, StartEarthObservationJobOutputFilterSensitiveLog)
-    .ser(se_StartEarthObservationJobCommand)
-    .de(de_StartEarthObservationJobCommand)
+    .sc(StartEarthObservationJob)
     .build() {
 }
 
@@ -2063,16 +1709,11 @@ class StartVectorEnrichmentJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "StartVectorEnrichmentJob", {})
     .n("SageMakerGeospatialClient", "StartVectorEnrichmentJobCommand")
-    .f(void 0, void 0)
-    .ser(se_StartVectorEnrichmentJobCommand)
-    .de(de_StartVectorEnrichmentJobCommand)
+    .sc(StartVectorEnrichmentJob)
     .build() {
 }
 
@@ -2080,16 +1721,11 @@ class StopEarthObservationJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "StopEarthObservationJob", {})
     .n("SageMakerGeospatialClient", "StopEarthObservationJobCommand")
-    .f(void 0, void 0)
-    .ser(se_StopEarthObservationJobCommand)
-    .de(de_StopEarthObservationJobCommand)
+    .sc(StopEarthObservationJob)
     .build() {
 }
 
@@ -2097,16 +1733,11 @@ class StopVectorEnrichmentJobCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "StopVectorEnrichmentJob", {})
     .n("SageMakerGeospatialClient", "StopVectorEnrichmentJobCommand")
-    .f(void 0, void 0)
-    .ser(se_StopVectorEnrichmentJobCommand)
-    .de(de_StopVectorEnrichmentJobCommand)
+    .sc(StopVectorEnrichmentJob)
     .build() {
 }
 
@@ -2114,16 +1745,11 @@ class TagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "TagResource", {})
     .n("SageMakerGeospatialClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -2131,16 +1757,11 @@ class UntagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("SageMakerGeospatial", "UntagResource", {})
     .n("SageMakerGeospatialClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -2185,14 +1806,12 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.AlgorithmNameCloudRemoval = AlgorithmNameCloudRemoval;
 exports.AlgorithmNameGeoMosaic = AlgorithmNameGeoMosaic;
 exports.AlgorithmNameResampling = AlgorithmNameResampling;
-exports.AreaOfInterestFilterSensitiveLog = AreaOfInterestFilterSensitiveLog;
-exports.AreaOfInterestGeometryFilterSensitiveLog = AreaOfInterestGeometryFilterSensitiveLog;
 exports.ComparisonOperator = ComparisonOperator;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.DataCollectionType = DataCollectionType;
 exports.DeleteEarthObservationJobCommand = DeleteEarthObservationJobCommand;
 exports.DeleteVectorEnrichmentJobCommand = DeleteVectorEnrichmentJobCommand;
@@ -2202,60 +1821,37 @@ exports.EarthObservationJobStatus = EarthObservationJobStatus;
 exports.ExportEarthObservationJobCommand = ExportEarthObservationJobCommand;
 exports.ExportErrorType = ExportErrorType;
 exports.ExportVectorEnrichmentJobCommand = ExportVectorEnrichmentJobCommand;
-exports.GeometryFilterSensitiveLog = GeometryFilterSensitiveLog;
 exports.GetEarthObservationJobCommand = GetEarthObservationJobCommand;
-exports.GetEarthObservationJobOutputFilterSensitiveLog = GetEarthObservationJobOutputFilterSensitiveLog;
 exports.GetRasterDataCollectionCommand = GetRasterDataCollectionCommand;
 exports.GetTileCommand = GetTileCommand;
-exports.GetTileOutputFilterSensitiveLog = GetTileOutputFilterSensitiveLog;
 exports.GetVectorEnrichmentJobCommand = GetVectorEnrichmentJobCommand;
 exports.GroupBy = GroupBy;
-exports.InputConfigInputFilterSensitiveLog = InputConfigInputFilterSensitiveLog;
-exports.InputConfigOutputFilterSensitiveLog = InputConfigOutputFilterSensitiveLog;
-exports.InternalServerException = InternalServerException;
-exports.ItemSourceFilterSensitiveLog = ItemSourceFilterSensitiveLog;
-exports.ListEarthObservationJobInputFilterSensitiveLog = ListEarthObservationJobInputFilterSensitiveLog;
-exports.ListEarthObservationJobOutputFilterSensitiveLog = ListEarthObservationJobOutputFilterSensitiveLog;
+exports.InternalServerException = InternalServerException$1;
 exports.ListEarthObservationJobsCommand = ListEarthObservationJobsCommand;
 exports.ListRasterDataCollectionsCommand = ListRasterDataCollectionsCommand;
-exports.ListRasterDataCollectionsInputFilterSensitiveLog = ListRasterDataCollectionsInputFilterSensitiveLog;
-exports.ListRasterDataCollectionsOutputFilterSensitiveLog = ListRasterDataCollectionsOutputFilterSensitiveLog;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
-exports.ListVectorEnrichmentJobInputFilterSensitiveLog = ListVectorEnrichmentJobInputFilterSensitiveLog;
-exports.ListVectorEnrichmentJobOutputFilterSensitiveLog = ListVectorEnrichmentJobOutputFilterSensitiveLog;
 exports.ListVectorEnrichmentJobsCommand = ListVectorEnrichmentJobsCommand;
 exports.LogicalOperator = LogicalOperator;
-exports.MultiPolygonGeometryInputFilterSensitiveLog = MultiPolygonGeometryInputFilterSensitiveLog;
 exports.OutputType = OutputType;
-exports.PolygonGeometryInputFilterSensitiveLog = PolygonGeometryInputFilterSensitiveLog;
 exports.PredefinedResolution = PredefinedResolution;
-exports.RasterDataCollectionQueryInputFilterSensitiveLog = RasterDataCollectionQueryInputFilterSensitiveLog;
-exports.RasterDataCollectionQueryOutputFilterSensitiveLog = RasterDataCollectionQueryOutputFilterSensitiveLog;
-exports.RasterDataCollectionQueryWithBandFilterInputFilterSensitiveLog = RasterDataCollectionQueryWithBandFilterInputFilterSensitiveLog;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.SageMakerGeospatial = SageMakerGeospatial;
 exports.SageMakerGeospatialClient = SageMakerGeospatialClient;
-exports.SageMakerGeospatialServiceException = SageMakerGeospatialServiceException;
+exports.SageMakerGeospatialServiceException = SageMakerGeospatialServiceException$1;
 exports.SearchRasterDataCollectionCommand = SearchRasterDataCollectionCommand;
-exports.SearchRasterDataCollectionInputFilterSensitiveLog = SearchRasterDataCollectionInputFilterSensitiveLog;
-exports.SearchRasterDataCollectionOutputFilterSensitiveLog = SearchRasterDataCollectionOutputFilterSensitiveLog;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.SortOrder = SortOrder;
 exports.StartEarthObservationJobCommand = StartEarthObservationJobCommand;
-exports.StartEarthObservationJobInputFilterSensitiveLog = StartEarthObservationJobInputFilterSensitiveLog;
-exports.StartEarthObservationJobOutputFilterSensitiveLog = StartEarthObservationJobOutputFilterSensitiveLog;
 exports.StartVectorEnrichmentJobCommand = StartVectorEnrichmentJobCommand;
 exports.StopEarthObservationJobCommand = StopEarthObservationJobCommand;
 exports.StopVectorEnrichmentJobCommand = StopVectorEnrichmentJobCommand;
 exports.TagResourceCommand = TagResourceCommand;
 exports.TargetOptions = TargetOptions;
 exports.TemporalStatistics = TemporalStatistics;
-exports.ThrottlingException = ThrottlingException;
-exports.TimeRangeFilterInputFilterSensitiveLog = TimeRangeFilterInputFilterSensitiveLog;
-exports.TimeRangeFilterOutputFilterSensitiveLog = TimeRangeFilterOutputFilterSensitiveLog;
+exports.ThrottlingException = ThrottlingException$1;
 exports.Unit = Unit;
 exports.UntagResourceCommand = UntagResourceCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.VectorEnrichmentJobDocumentType = VectorEnrichmentJobDocumentType;
 exports.VectorEnrichmentJobErrorType = VectorEnrichmentJobErrorType;
 exports.VectorEnrichmentJobExportErrorType = VectorEnrichmentJobExportErrorType;