@aws-sdk/client-sagemaker-geospatial 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,3274 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SageMakerGeospatialServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./SageMakerGeospatialClient"), exports);
-tslib_1.__exportStar(require("./SageMakerGeospatial"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var SageMakerGeospatialServiceException_1 = require("./models/SageMakerGeospatialServiceException");
-Object.defineProperty(exports, "SageMakerGeospatialServiceException", { enumerable: true, get: function () { return SageMakerGeospatialServiceException_1.SageMakerGeospatialServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AccessDeniedException: () => AccessDeniedException,
+  AlgorithmNameCloudRemoval: () => AlgorithmNameCloudRemoval,
+  AlgorithmNameGeoMosaic: () => AlgorithmNameGeoMosaic,
+  AlgorithmNameResampling: () => AlgorithmNameResampling,
+  AreaOfInterest: () => AreaOfInterest,
+  AreaOfInterestFilterSensitiveLog: () => AreaOfInterestFilterSensitiveLog,
+  AreaOfInterestGeometry: () => AreaOfInterestGeometry,
+  AreaOfInterestGeometryFilterSensitiveLog: () => AreaOfInterestGeometryFilterSensitiveLog,
+  ComparisonOperator: () => ComparisonOperator,
+  ConflictException: () => ConflictException,
+  DataCollectionType: () => DataCollectionType,
+  DeleteEarthObservationJobCommand: () => DeleteEarthObservationJobCommand,
+  DeleteVectorEnrichmentJobCommand: () => DeleteVectorEnrichmentJobCommand,
+  EarthObservationJobErrorType: () => EarthObservationJobErrorType,
+  EarthObservationJobExportStatus: () => EarthObservationJobExportStatus,
+  EarthObservationJobStatus: () => EarthObservationJobStatus,
+  ExportEarthObservationJobCommand: () => ExportEarthObservationJobCommand,
+  ExportErrorType: () => ExportErrorType,
+  ExportVectorEnrichmentJobCommand: () => ExportVectorEnrichmentJobCommand,
+  GeometryFilterSensitiveLog: () => GeometryFilterSensitiveLog,
+  GetEarthObservationJobCommand: () => GetEarthObservationJobCommand,
+  GetEarthObservationJobOutputFilterSensitiveLog: () => GetEarthObservationJobOutputFilterSensitiveLog,
+  GetRasterDataCollectionCommand: () => GetRasterDataCollectionCommand,
+  GetTileCommand: () => GetTileCommand,
+  GetTileOutputFilterSensitiveLog: () => GetTileOutputFilterSensitiveLog,
+  GetVectorEnrichmentJobCommand: () => GetVectorEnrichmentJobCommand,
+  GroupBy: () => GroupBy,
+  InputConfigInputFilterSensitiveLog: () => InputConfigInputFilterSensitiveLog,
+  InputConfigOutputFilterSensitiveLog: () => InputConfigOutputFilterSensitiveLog,
+  InternalServerException: () => InternalServerException,
+  ItemSourceFilterSensitiveLog: () => ItemSourceFilterSensitiveLog,
+  JobConfigInput: () => JobConfigInput,
+  ListEarthObservationJobInputFilterSensitiveLog: () => ListEarthObservationJobInputFilterSensitiveLog,
+  ListEarthObservationJobOutputFilterSensitiveLog: () => ListEarthObservationJobOutputFilterSensitiveLog,
+  ListEarthObservationJobsCommand: () => ListEarthObservationJobsCommand,
+  ListRasterDataCollectionsCommand: () => ListRasterDataCollectionsCommand,
+  ListRasterDataCollectionsInputFilterSensitiveLog: () => ListRasterDataCollectionsInputFilterSensitiveLog,
+  ListRasterDataCollectionsOutputFilterSensitiveLog: () => ListRasterDataCollectionsOutputFilterSensitiveLog,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  ListVectorEnrichmentJobInputFilterSensitiveLog: () => ListVectorEnrichmentJobInputFilterSensitiveLog,
+  ListVectorEnrichmentJobOutputFilterSensitiveLog: () => ListVectorEnrichmentJobOutputFilterSensitiveLog,
+  ListVectorEnrichmentJobsCommand: () => ListVectorEnrichmentJobsCommand,
+  LogicalOperator: () => LogicalOperator,
+  MultiPolygonGeometryInputFilterSensitiveLog: () => MultiPolygonGeometryInputFilterSensitiveLog,
+  OutputType: () => OutputType,
+  PolygonGeometryInputFilterSensitiveLog: () => PolygonGeometryInputFilterSensitiveLog,
+  PredefinedResolution: () => PredefinedResolution,
+  Property: () => Property,
+  RasterDataCollectionQueryInputFilterSensitiveLog: () => RasterDataCollectionQueryInputFilterSensitiveLog,
+  RasterDataCollectionQueryOutputFilterSensitiveLog: () => RasterDataCollectionQueryOutputFilterSensitiveLog,
+  RasterDataCollectionQueryWithBandFilterInputFilterSensitiveLog: () => RasterDataCollectionQueryWithBandFilterInputFilterSensitiveLog,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  SageMakerGeospatial: () => SageMakerGeospatial,
+  SageMakerGeospatialClient: () => SageMakerGeospatialClient,
+  SageMakerGeospatialServiceException: () => SageMakerGeospatialServiceException,
+  SearchRasterDataCollectionCommand: () => SearchRasterDataCollectionCommand,
+  SearchRasterDataCollectionInputFilterSensitiveLog: () => SearchRasterDataCollectionInputFilterSensitiveLog,
+  SearchRasterDataCollectionOutputFilterSensitiveLog: () => SearchRasterDataCollectionOutputFilterSensitiveLog,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  SortOrder: () => SortOrder,
+  StartEarthObservationJobCommand: () => StartEarthObservationJobCommand,
+  StartEarthObservationJobInputFilterSensitiveLog: () => StartEarthObservationJobInputFilterSensitiveLog,
+  StartEarthObservationJobOutputFilterSensitiveLog: () => StartEarthObservationJobOutputFilterSensitiveLog,
+  StartVectorEnrichmentJobCommand: () => StartVectorEnrichmentJobCommand,
+  StopEarthObservationJobCommand: () => StopEarthObservationJobCommand,
+  StopVectorEnrichmentJobCommand: () => StopVectorEnrichmentJobCommand,
+  TagResourceCommand: () => TagResourceCommand,
+  TargetOptions: () => TargetOptions,
+  TemporalStatistics: () => TemporalStatistics,
+  ThrottlingException: () => ThrottlingException,
+  TimeRangeFilterInputFilterSensitiveLog: () => TimeRangeFilterInputFilterSensitiveLog,
+  TimeRangeFilterOutputFilterSensitiveLog: () => TimeRangeFilterOutputFilterSensitiveLog,
+  Unit: () => Unit,
+  UntagResourceCommand: () => UntagResourceCommand,
+  ValidationException: () => ValidationException,
+  VectorEnrichmentJobConfig: () => VectorEnrichmentJobConfig,
+  VectorEnrichmentJobDataSourceConfigInput: () => VectorEnrichmentJobDataSourceConfigInput,
+  VectorEnrichmentJobDocumentType: () => VectorEnrichmentJobDocumentType,
+  VectorEnrichmentJobErrorType: () => VectorEnrichmentJobErrorType,
+  VectorEnrichmentJobExportErrorType: () => VectorEnrichmentJobExportErrorType,
+  VectorEnrichmentJobExportStatus: () => VectorEnrichmentJobExportStatus,
+  VectorEnrichmentJobStatus: () => VectorEnrichmentJobStatus,
+  VectorEnrichmentJobType: () => VectorEnrichmentJobType,
+  ZonalStatistics: () => ZonalStatistics,
+  __Client: () => import_smithy_client.Client,
+  paginateListEarthObservationJobs: () => paginateListEarthObservationJobs,
+  paginateListRasterDataCollections: () => paginateListRasterDataCollections,
+  paginateListVectorEnrichmentJobs: () => paginateListVectorEnrichmentJobs,
+  paginateSearchRasterDataCollection: () => paginateSearchRasterDataCollection
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/SageMakerGeospatialClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "sagemaker-geospatial"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/SageMakerGeospatialClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/SageMakerGeospatialClient.ts
+var _SageMakerGeospatialClient = class _SageMakerGeospatialClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_SageMakerGeospatialClient, "SageMakerGeospatialClient");
+var SageMakerGeospatialClient = _SageMakerGeospatialClient;
+
+// src/SageMakerGeospatial.ts
+
+
+// src/commands/DeleteEarthObservationJobCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@aws-sdk/core");
+var import_core2 = require("@smithy/core");
+
+var import_uuid = require("uuid");
+
+// src/models/models_0.ts
+
+
+// src/models/SageMakerGeospatialServiceException.ts
+
+var _SageMakerGeospatialServiceException = class _SageMakerGeospatialServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _SageMakerGeospatialServiceException.prototype);
+  }
+};
+__name(_SageMakerGeospatialServiceException, "SageMakerGeospatialServiceException");
+var SageMakerGeospatialServiceException = _SageMakerGeospatialServiceException;
+
+// src/models/models_0.ts
+var _AccessDeniedException = class _AccessDeniedException extends SageMakerGeospatialServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var AlgorithmNameCloudRemoval = {
+  /**
+   * INTERPOLATION
+   */
+  INTERPOLATION: "INTERPOLATION"
+};
+var AlgorithmNameGeoMosaic = {
+  /**
+   * AVERAGE
+   */
+  AVERAGE: "AVERAGE",
+  /**
+   * BILINEAR
+   */
+  BILINEAR: "BILINEAR",
+  /**
+   * CUBIC
+   */
+  CUBIC: "CUBIC",
+  /**
+   * CUBICSPLINE
+   */
+  CUBICSPLINE: "CUBICSPLINE",
+  /**
+   * LANCZOS
+   */
+  LANCZOS: "LANCZOS",
+  /**
+   * MAX
+   */
+  MAX: "MAX",
+  /**
+   * MED
+   */
+  MED: "MED",
+  /**
+   * MIN
+   */
+  MIN: "MIN",
+  /**
+   * MODE
+   */
+  MODE: "MODE",
+  /**
+   * NEAR
+   */
+  NEAR: "NEAR",
+  /**
+   * Q1
+   */
+  Q1: "Q1",
+  /**
+   * Q3
+   */
+  Q3: "Q3",
+  /**
+   * RMS
+   */
+  RMS: "RMS",
+  /**
+   * SUM
+   */
+  SUM: "SUM"
+};
+var AlgorithmNameResampling = {
+  /**
+   * AVERAGE
+   */
+  AVERAGE: "AVERAGE",
+  /**
+   * BILINEAR
+   */
+  BILINEAR: "BILINEAR",
+  /**
+   * CUBIC
+   */
+  CUBIC: "CUBIC",
+  /**
+   * CUBICSPLINE
+   */
+  CUBICSPLINE: "CUBICSPLINE",
+  /**
+   * LANCZOS
+   */
+  LANCZOS: "LANCZOS",
+  /**
+   * MAX
+   */
+  MAX: "MAX",
+  /**
+   * MED
+   */
+  MED: "MED",
+  /**
+   * MIN
+   */
+  MIN: "MIN",
+  /**
+   * MODE
+   */
+  MODE: "MODE",
+  /**
+   * NEAR
+   */
+  NEAR: "NEAR",
+  /**
+   * Q1
+   */
+  Q1: "Q1",
+  /**
+   * Q3
+   */
+  Q3: "Q3",
+  /**
+   * RMS
+   */
+  RMS: "RMS",
+  /**
+   * SUM
+   */
+  SUM: "SUM"
+};
+var AreaOfInterestGeometry;
+((AreaOfInterestGeometry2) => {
+  AreaOfInterestGeometry2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.PolygonGeometry !== void 0)
+      return visitor.PolygonGeometry(value.PolygonGeometry);
+    if (value.MultiPolygonGeometry !== void 0)
+      return visitor.MultiPolygonGeometry(value.MultiPolygonGeometry);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(AreaOfInterestGeometry || (AreaOfInterestGeometry = {}));
+var AreaOfInterest;
+((AreaOfInterest2) => {
+  AreaOfInterest2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.AreaOfInterestGeometry !== void 0)
+      return visitor.AreaOfInterestGeometry(value.AreaOfInterestGeometry);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(AreaOfInterest || (AreaOfInterest = {}));
+var OutputType = {
+  /**
+   * FLOAT32
+   */
+  FLOAT32: "FLOAT32",
+  /**
+   * FLOAT64
+   */
+  FLOAT64: "FLOAT64",
+  /**
+   * INT16
+   */
+  INT16: "INT16",
+  /**
+   * INT32
+   */
+  INT32: "INT32",
+  /**
+   * UINT16
+   */
+  UINT16: "UINT16"
+};
+var ComparisonOperator = {
+  /**
+   * EQUALS
+   */
+  EQUALS: "EQUALS",
+  /**
+   * NOT_EQUALS
+   */
+  NOT_EQUALS: "NOT_EQUALS",
+  /**
+   * STARTS_WITH
+   */
+  STARTS_WITH: "STARTS_WITH"
+};
+var _ConflictException = class _ConflictException extends SageMakerGeospatialServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.Message = opts.Message;
+    this.ResourceId = opts.ResourceId;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var DataCollectionType = {
+  /**
+   * PREMIUM
+   */
+  PREMIUM: "PREMIUM",
+  /**
+   * PUBLIC
+   */
+  PUBLIC: "PUBLIC",
+  /**
+   * USER
+   */
+  USER: "USER"
+};
+var _InternalServerException = class _InternalServerException extends SageMakerGeospatialServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServerException.prototype);
+    this.Message = opts.Message;
+    this.ResourceId = opts.ResourceId;
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends SageMakerGeospatialServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.Message = opts.Message;
+    this.ResourceId = opts.ResourceId;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _ThrottlingException = class _ThrottlingException extends SageMakerGeospatialServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+    this.Message = opts.Message;
+    this.ResourceId = opts.ResourceId;
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var _ValidationException = class _ValidationException extends SageMakerGeospatialServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+    this.Message = opts.Message;
+    this.ResourceId = opts.ResourceId;
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var EarthObservationJobExportStatus = {
+  /**
+   * FAILED
+   */
+  FAILED: "FAILED",
+  /**
+   * IN_PROGRESS
+   */
+  IN_PROGRESS: "IN_PROGRESS",
+  /**
+   * SUCCEEDED
+   */
+  SUCCEEDED: "SUCCEEDED"
+};
+var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends SageMakerGeospatialServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+    this.Message = opts.Message;
+    this.ResourceId = opts.ResourceId;
+  }
+};
+__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
+var ServiceQuotaExceededException = _ServiceQuotaExceededException;
+var EarthObservationJobErrorType = {
+  /**
+   * CLIENT_ERROR
+   */
+  CLIENT_ERROR: "CLIENT_ERROR",
+  /**
+   * SERVER_ERROR
+   */
+  SERVER_ERROR: "SERVER_ERROR"
+};
+var ExportErrorType = {
+  /**
+   * CLIENT_ERROR
+   */
+  CLIENT_ERROR: "CLIENT_ERROR",
+  /**
+   * SERVER_ERROR
+   */
+  SERVER_ERROR: "SERVER_ERROR"
+};
+var LogicalOperator = {
+  /**
+   * AND
+   */
+  AND: "AND"
+};
+var Property;
+((Property2) => {
+  Property2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.EoCloudCover !== void 0)
+      return visitor.EoCloudCover(value.EoCloudCover);
+    if (value.ViewOffNadir !== void 0)
+      return visitor.ViewOffNadir(value.ViewOffNadir);
+    if (value.ViewSunAzimuth !== void 0)
+      return visitor.ViewSunAzimuth(value.ViewSunAzimuth);
+    if (value.ViewSunElevation !== void 0)
+      return visitor.ViewSunElevation(value.ViewSunElevation);
+    if (value.Platform !== void 0)
+      return visitor.Platform(value.Platform);
+    if (value.LandsatCloudCoverLand !== void 0)
+      return visitor.LandsatCloudCoverLand(value.LandsatCloudCoverLand);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(Property || (Property = {}));
+var Unit = {
+  /**
+   * METERS
+   */
+  METERS: "METERS"
+};
+var PredefinedResolution = {
+  /**
+   * AVERAGE
+   */
+  AVERAGE: "AVERAGE",
+  /**
+   * HIGHEST
+   */
+  HIGHEST: "HIGHEST",
+  /**
+   * LOWEST
+   */
+  LOWEST: "LOWEST"
+};
+var GroupBy = {
+  /**
+   * ALL
+   */
+  ALL: "ALL",
+  /**
+   * YEARLY
+   */
+  YEARLY: "YEARLY"
+};
+var TemporalStatistics = {
+  /**
+   * MEAN
+   */
+  MEAN: "MEAN",
+  /**
+   * MEDIAN
+   */
+  MEDIAN: "MEDIAN",
+  /**
+   * STANDARD_DEVIATION
+   */
+  STANDARD_DEVIATION: "STANDARD_DEVIATION"
+};
+var ZonalStatistics = {
+  /**
+   * MAX
+   */
+  MAX: "MAX",
+  /**
+   * MEAN
+   */
+  MEAN: "MEAN",
+  /**
+   * MEDIAN
+   */
+  MEDIAN: "MEDIAN",
+  /**
+   * MIN
+   */
+  MIN: "MIN",
+  /**
+   * STANDARD_DEVIATION
+   */
+  STANDARD_DEVIATION: "STANDARD_DEVIATION",
+  /**
+   * SUM
+   */
+  SUM: "SUM"
+};
+var JobConfigInput;
+((JobConfigInput2) => {
+  JobConfigInput2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.BandMathConfig !== void 0)
+      return visitor.BandMathConfig(value.BandMathConfig);
+    if (value.ResamplingConfig !== void 0)
+      return visitor.ResamplingConfig(value.ResamplingConfig);
+    if (value.TemporalStatisticsConfig !== void 0)
+      return visitor.TemporalStatisticsConfig(value.TemporalStatisticsConfig);
+    if (value.CloudRemovalConfig !== void 0)
+      return visitor.CloudRemovalConfig(value.CloudRemovalConfig);
+    if (value.ZonalStatisticsConfig !== void 0)
+      return visitor.ZonalStatisticsConfig(value.ZonalStatisticsConfig);
+    if (value.GeoMosaicConfig !== void 0)
+      return visitor.GeoMosaicConfig(value.GeoMosaicConfig);
+    if (value.StackConfig !== void 0)
+      return visitor.StackConfig(value.StackConfig);
+    if (value.CloudMaskingConfig !== void 0)
+      return visitor.CloudMaskingConfig(value.CloudMaskingConfig);
+    if (value.LandCoverSegmentationConfig !== void 0)
+      return visitor.LandCoverSegmentationConfig(value.LandCoverSegmentationConfig);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(JobConfigInput || (JobConfigInput = {}));
+var EarthObservationJobStatus = {
+  /**
+   * COMPLETED
+   */
+  COMPLETED: "COMPLETED",
+  /**
+   * DELETED
+   */
+  DELETED: "DELETED",
+  /**
+   * DELETING
+   */
+  DELETING: "DELETING",
+  /**
+   * FAILED
+   */
+  FAILED: "FAILED",
+  /**
+   * INITIALIZING
+   */
+  INITIALIZING: "INITIALIZING",
+  /**
+   * IN_PROGRESS
+   */
+  IN_PROGRESS: "IN_PROGRESS",
+  /**
+   * STOPPED
+   */
+  STOPPED: "STOPPED",
+  /**
+   * STOPPING
+   */
+  STOPPING: "STOPPING"
+};
+var TargetOptions = {
+  /**
+   * INPUT
+   */
+  INPUT: "INPUT",
+  /**
+   * OUTPUT
+   */
+  OUTPUT: "OUTPUT"
+};
+var SortOrder = {
+  /**
+   * ASCENDING
+   */
+  ASCENDING: "ASCENDING",
+  /**
+   * DESCENDING
+   */
+  DESCENDING: "DESCENDING"
+};
+var VectorEnrichmentJobExportStatus = {
+  FAILED: "FAILED",
+  IN_PROGRESS: "IN_PROGRESS",
+  SUCCEEDED: "SUCCEEDED"
+};
+var VectorEnrichmentJobErrorType = {
+  /**
+   * CLIENT_ERROR
+   */
+  CLIENT_ERROR: "CLIENT_ERROR",
+  /**
+   * SERVER_ERROR
+   */
+  SERVER_ERROR: "SERVER_ERROR"
+};
+var VectorEnrichmentJobExportErrorType = {
+  CLIENT_ERROR: "CLIENT_ERROR",
+  SERVER_ERROR: "SERVER_ERROR"
+};
+var VectorEnrichmentJobDataSourceConfigInput;
+((VectorEnrichmentJobDataSourceConfigInput3) => {
+  VectorEnrichmentJobDataSourceConfigInput3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.S3Data !== void 0)
+      return visitor.S3Data(value.S3Data);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(VectorEnrichmentJobDataSourceConfigInput || (VectorEnrichmentJobDataSourceConfigInput = {}));
+var VectorEnrichmentJobDocumentType = {
+  CSV: "CSV"
+};
+var VectorEnrichmentJobConfig;
+((VectorEnrichmentJobConfig3) => {
+  VectorEnrichmentJobConfig3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.ReverseGeocodingConfig !== void 0)
+      return visitor.ReverseGeocodingConfig(value.ReverseGeocodingConfig);
+    if (value.MapMatchingConfig !== void 0)
+      return visitor.MapMatchingConfig(value.MapMatchingConfig);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(VectorEnrichmentJobConfig || (VectorEnrichmentJobConfig = {}));
+var VectorEnrichmentJobStatus = {
+  COMPLETED: "COMPLETED",
+  DELETED: "DELETED",
+  DELETING: "DELETING",
+  FAILED: "FAILED",
+  INITIALIZING: "INITIALIZING",
+  IN_PROGRESS: "IN_PROGRESS",
+  STOPPED: "STOPPED",
+  STOPPING: "STOPPING"
+};
+var VectorEnrichmentJobType = {
+  MAP_MATCHING: "MAP_MATCHING",
+  REVERSE_GEOCODING: "REVERSE_GEOCODING"
+};
+var MultiPolygonGeometryInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Coordinates && { Coordinates: obj.Coordinates.map((item) => item.map((item2) => import_smithy_client.SENSITIVE_STRING)) }
+}), "MultiPolygonGeometryInputFilterSensitiveLog");
+var PolygonGeometryInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Coordinates && { Coordinates: obj.Coordinates.map((item) => import_smithy_client.SENSITIVE_STRING) }
+}), "PolygonGeometryInputFilterSensitiveLog");
+var AreaOfInterestGeometryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.PolygonGeometry !== void 0)
+    return { PolygonGeometry: PolygonGeometryInputFilterSensitiveLog(obj.PolygonGeometry) };
+  if (obj.MultiPolygonGeometry !== void 0)
+    return { MultiPolygonGeometry: MultiPolygonGeometryInputFilterSensitiveLog(obj.MultiPolygonGeometry) };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "AreaOfInterestGeometryFilterSensitiveLog");
+var AreaOfInterestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
+  if (obj.AreaOfInterestGeometry !== void 0)
+    return { AreaOfInterestGeometry: AreaOfInterestGeometryFilterSensitiveLog(obj.AreaOfInterestGeometry) };
+  if (obj.$unknown !== void 0)
+    return { [obj.$unknown[0]]: "UNKNOWN" };
+}, "AreaOfInterestFilterSensitiveLog");
+var TimeRangeFilterOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "TimeRangeFilterOutputFilterSensitiveLog");
+var RasterDataCollectionQueryOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.TimeRangeFilter && { TimeRangeFilter: import_smithy_client.SENSITIVE_STRING },
+  ...obj.AreaOfInterest && { AreaOfInterest: AreaOfInterestFilterSensitiveLog(obj.AreaOfInterest) },
+  ...obj.PropertyFilters && { PropertyFilters: obj.PropertyFilters }
+}), "RasterDataCollectionQueryOutputFilterSensitiveLog");
+var InputConfigOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.RasterDataCollectionQuery && {
+    RasterDataCollectionQuery: RasterDataCollectionQueryOutputFilterSensitiveLog(obj.RasterDataCollectionQuery)
+  }
+}), "InputConfigOutputFilterSensitiveLog");
+var GetEarthObservationJobOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.InputConfig && { InputConfig: InputConfigOutputFilterSensitiveLog(obj.InputConfig) },
+  ...obj.JobConfig && { JobConfig: obj.JobConfig }
+}), "GetEarthObservationJobOutputFilterSensitiveLog");
+var GetTileOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "GetTileOutputFilterSensitiveLog");
+var ListEarthObservationJobInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
+}), "ListEarthObservationJobInputFilterSensitiveLog");
+var ListEarthObservationJobOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
+}), "ListEarthObservationJobOutputFilterSensitiveLog");
+var TimeRangeFilterInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "TimeRangeFilterInputFilterSensitiveLog");
+var RasterDataCollectionQueryInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.TimeRangeFilter && { TimeRangeFilter: import_smithy_client.SENSITIVE_STRING },
+  ...obj.AreaOfInterest && { AreaOfInterest: AreaOfInterestFilterSensitiveLog(obj.AreaOfInterest) },
+  ...obj.PropertyFilters && { PropertyFilters: obj.PropertyFilters }
+}), "RasterDataCollectionQueryInputFilterSensitiveLog");
+var InputConfigInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.RasterDataCollectionQuery && {
+    RasterDataCollectionQuery: RasterDataCollectionQueryInputFilterSensitiveLog(obj.RasterDataCollectionQuery)
+  }
+}), "InputConfigInputFilterSensitiveLog");
+var StartEarthObservationJobInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.InputConfig && { InputConfig: InputConfigInputFilterSensitiveLog(obj.InputConfig) },
+  ...obj.JobConfig && { JobConfig: obj.JobConfig }
+}), "StartEarthObservationJobInputFilterSensitiveLog");
+var StartEarthObservationJobOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.InputConfig && { InputConfig: InputConfigOutputFilterSensitiveLog(obj.InputConfig) },
+  ...obj.JobConfig && { JobConfig: obj.JobConfig }
+}), "StartEarthObservationJobOutputFilterSensitiveLog");
+var GeometryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Coordinates && { Coordinates: obj.Coordinates.map((item) => import_smithy_client.SENSITIVE_STRING) }
+}), "GeometryFilterSensitiveLog");
+var ItemSourceFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Geometry && { Geometry: GeometryFilterSensitiveLog(obj.Geometry) }
+}), "ItemSourceFilterSensitiveLog");
+var ListRasterDataCollectionsInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
+}), "ListRasterDataCollectionsInputFilterSensitiveLog");
+var ListRasterDataCollectionsOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
+}), "ListRasterDataCollectionsOutputFilterSensitiveLog");
+var ListVectorEnrichmentJobInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
+}), "ListVectorEnrichmentJobInputFilterSensitiveLog");
+var ListVectorEnrichmentJobOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
+}), "ListVectorEnrichmentJobOutputFilterSensitiveLog");
+var RasterDataCollectionQueryWithBandFilterInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.TimeRangeFilter && { TimeRangeFilter: import_smithy_client.SENSITIVE_STRING },
+  ...obj.AreaOfInterest && { AreaOfInterest: AreaOfInterestFilterSensitiveLog(obj.AreaOfInterest) },
+  ...obj.PropertyFilters && { PropertyFilters: obj.PropertyFilters }
+}), "RasterDataCollectionQueryWithBandFilterInputFilterSensitiveLog");
+var SearchRasterDataCollectionInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.RasterDataCollectionQuery && {
+    RasterDataCollectionQuery: RasterDataCollectionQueryWithBandFilterInputFilterSensitiveLog(
+      obj.RasterDataCollectionQuery
+    )
+  },
+  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
+}), "SearchRasterDataCollectionInputFilterSensitiveLog");
+var SearchRasterDataCollectionOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING },
+  ...obj.Items && { Items: obj.Items.map((item) => ItemSourceFilterSensitiveLog(item)) }
+}), "SearchRasterDataCollectionOutputFilterSensitiveLog");
+
+// src/protocols/Aws_restJson1.ts
+var se_DeleteEarthObservationJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.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();
+}, "se_DeleteEarthObservationJobCommand");
+var se_DeleteVectorEnrichmentJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.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();
+}, "se_DeleteVectorEnrichmentJobCommand");
+var se_ExportEarthObservationJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/export-earth-observation-job");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Arn: [],
+      ClientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      ExecutionRoleArn: [],
+      ExportSourceImages: [],
+      OutputConfig: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ExportEarthObservationJobCommand");
+var se_ExportVectorEnrichmentJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/export-vector-enrichment-jobs");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Arn: [],
+      ClientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      ExecutionRoleArn: [],
+      OutputConfig: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ExportVectorEnrichmentJobCommand");
+var se_GetEarthObservationJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.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();
+}, "se_GetEarthObservationJobCommand");
+var se_GetRasterDataCollectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.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();
+}, "se_GetRasterDataCollectionCommand");
+var se_GetTileCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.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 = (0, import_smithy_client.map)({
+    [_IA]: [
+      (0, import_smithy_client.expectNonNull)(input.ImageAssets, `ImageAssets`) != null,
+      () => (input[_IA] || []).map((_entry) => _entry)
+    ],
+    [_T]: [, (0, import_smithy_client.expectNonNull)(input[_T], `Target`)],
+    [_A]: [, (0, import_smithy_client.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();
+}, "se_GetTileCommand");
+var se_GetVectorEnrichmentJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.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();
+}, "se_GetVectorEnrichmentJobCommand");
+var se_ListEarthObservationJobsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/list-earth-observation-jobs");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      MaxResults: [],
+      NextToken: [],
+      SortBy: [],
+      SortOrder: [],
+      StatusEquals: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListEarthObservationJobsCommand");
+var se_ListRasterDataCollectionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/raster-data-collections");
+  const query = (0, import_smithy_client.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();
+}, "se_ListRasterDataCollectionsCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.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();
+}, "se_ListTagsForResourceCommand");
+var se_ListVectorEnrichmentJobsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/list-vector-enrichment-jobs");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      MaxResults: [],
+      NextToken: [],
+      SortBy: [],
+      SortOrder: [],
+      StatusEquals: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListVectorEnrichmentJobsCommand");
+var se_SearchRasterDataCollectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/search-raster-data-collection");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Arn: [],
+      NextToken: [],
+      RasterDataCollectionQuery: (_) => se_RasterDataCollectionQueryWithBandFilterInput(_, context)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_SearchRasterDataCollectionCommand");
+var se_StartEarthObservationJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/earth-observation-jobs");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      ClientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      ExecutionRoleArn: [],
+      InputConfig: (_) => se_InputConfigInput(_, context),
+      JobConfig: (_) => se_JobConfigInput(_, context),
+      KmsKeyId: [],
+      Name: [],
+      Tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartEarthObservationJobCommand");
+var se_StartVectorEnrichmentJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/vector-enrichment-jobs");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      ClientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      ExecutionRoleArn: [],
+      InputConfig: (_) => (0, import_smithy_client._json)(_),
+      JobConfig: (_) => (0, import_smithy_client._json)(_),
+      KmsKeyId: [],
+      Name: [],
+      Tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartVectorEnrichmentJobCommand");
+var se_StopEarthObservationJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/earth-observation-jobs/stop");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StopEarthObservationJobCommand");
+var se_StopVectorEnrichmentJobCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/vector-enrichment-jobs/stop");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      Arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StopVectorEnrichmentJobCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.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(
+    (0, import_smithy_client.take)(input, {
+      Tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{ResourceArn}");
+  b.p("ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
+  const query = (0, import_smithy_client.map)({
+    [_tK]: [
+      (0, import_smithy_client.expectNonNull)(input.TagKeys, `TagKeys`) != null,
+      () => (input[_TK] || []).map((_entry) => _entry)
+    ]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UntagResourceCommand");
+var de_DeleteEarthObservationJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteEarthObservationJobCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteEarthObservationJobCommand");
+var de_DeleteEarthObservationJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.sagemakergeospatial#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteEarthObservationJobCommandError");
+var de_DeleteVectorEnrichmentJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteVectorEnrichmentJobCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteVectorEnrichmentJobCommand");
+var de_DeleteVectorEnrichmentJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.sagemakergeospatial#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteVectorEnrichmentJobCommandError");
+var de_ExportEarthObservationJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ExportEarthObservationJobCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    ExecutionRoleArn: import_smithy_client.expectString,
+    ExportSourceImages: import_smithy_client.expectBoolean,
+    ExportStatus: import_smithy_client.expectString,
+    OutputConfig: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ExportEarthObservationJobCommand");
+var de_ExportEarthObservationJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.sagemakergeospatial#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.sagemakergeospatial#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ExportEarthObservationJobCommandError");
+var de_ExportVectorEnrichmentJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ExportVectorEnrichmentJobCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    ExecutionRoleArn: import_smithy_client.expectString,
+    ExportStatus: import_smithy_client.expectString,
+    OutputConfig: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ExportVectorEnrichmentJobCommand");
+var de_ExportVectorEnrichmentJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.sagemakergeospatial#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.sagemakergeospatial#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ExportVectorEnrichmentJobCommandError");
+var de_GetEarthObservationJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetEarthObservationJobCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    DurationInSeconds: import_smithy_client.expectInt32,
+    ErrorDetails: import_smithy_client._json,
+    ExecutionRoleArn: import_smithy_client.expectString,
+    ExportErrorDetails: import_smithy_client._json,
+    ExportStatus: import_smithy_client.expectString,
+    InputConfig: (_) => de_InputConfigOutput(_, context),
+    JobConfig: (_) => de_JobConfigInput((0, import_core.awsExpectUnion)(_), context),
+    KmsKeyId: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    OutputBands: import_smithy_client._json,
+    Status: import_smithy_client.expectString,
+    Tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetEarthObservationJobCommand");
+var de_GetEarthObservationJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetEarthObservationJobCommandError");
+var de_GetRasterDataCollectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetRasterDataCollectionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: import_smithy_client.expectString,
+    Description: import_smithy_client.expectString,
+    DescriptionPageUrl: import_smithy_client.expectString,
+    ImageSourceBands: import_smithy_client._json,
+    Name: import_smithy_client.expectString,
+    SupportedFilters: (_) => de_FilterList(_, context),
+    Tags: import_smithy_client._json,
+    Type: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetRasterDataCollectionCommand");
+var de_GetRasterDataCollectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetRasterDataCollectionCommandError");
+var de_GetTileCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetTileCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = output.body;
+  context.sdkStreamMixin(data);
+  contents.BinaryFile = data;
+  return contents;
+}, "de_GetTileCommand");
+var de_GetTileCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetTileCommandError");
+var de_GetVectorEnrichmentJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetVectorEnrichmentJobCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    DurationInSeconds: import_smithy_client.expectInt32,
+    ErrorDetails: import_smithy_client._json,
+    ExecutionRoleArn: import_smithy_client.expectString,
+    ExportErrorDetails: import_smithy_client._json,
+    ExportStatus: import_smithy_client.expectString,
+    InputConfig: import_smithy_client._json,
+    JobConfig: (_) => (0, import_smithy_client._json)((0, import_core.awsExpectUnion)(_)),
+    KmsKeyId: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    Tags: import_smithy_client._json,
+    Type: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetVectorEnrichmentJobCommand");
+var de_GetVectorEnrichmentJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetVectorEnrichmentJobCommandError");
+var de_ListEarthObservationJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListEarthObservationJobsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    EarthObservationJobSummaries: (_) => de_EarthObservationJobList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListEarthObservationJobsCommand");
+var de_ListEarthObservationJobsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListEarthObservationJobsCommandError");
+var de_ListRasterDataCollectionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListRasterDataCollectionsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: import_smithy_client.expectString,
+    RasterDataCollectionSummaries: (_) => de_DataCollectionsList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListRasterDataCollectionsCommand");
+var de_ListRasterDataCollectionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListRasterDataCollectionsCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_ListVectorEnrichmentJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListVectorEnrichmentJobsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: import_smithy_client.expectString,
+    VectorEnrichmentJobSummaries: (_) => de_VectorEnrichmentJobList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListVectorEnrichmentJobsCommand");
+var de_ListVectorEnrichmentJobsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListVectorEnrichmentJobsCommandError");
+var de_SearchRasterDataCollectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_SearchRasterDataCollectionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    ApproximateResultCount: import_smithy_client.expectInt32,
+    Items: (_) => de_ItemSourceList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_SearchRasterDataCollectionCommand");
+var de_SearchRasterDataCollectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_SearchRasterDataCollectionCommandError");
+var de_StartEarthObservationJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StartEarthObservationJobCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    DurationInSeconds: import_smithy_client.expectInt32,
+    ExecutionRoleArn: import_smithy_client.expectString,
+    InputConfig: (_) => de_InputConfigOutput(_, context),
+    JobConfig: (_) => de_JobConfigInput((0, import_core.awsExpectUnion)(_), context),
+    KmsKeyId: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    Tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StartEarthObservationJobCommand");
+var de_StartEarthObservationJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.sagemakergeospatial#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.sagemakergeospatial#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartEarthObservationJobCommandError");
+var de_StartVectorEnrichmentJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StartVectorEnrichmentJobCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    DurationInSeconds: import_smithy_client.expectInt32,
+    ExecutionRoleArn: import_smithy_client.expectString,
+    InputConfig: import_smithy_client._json,
+    JobConfig: (_) => (0, import_smithy_client._json)((0, import_core.awsExpectUnion)(_)),
+    KmsKeyId: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    Tags: import_smithy_client._json,
+    Type: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StartVectorEnrichmentJobCommand");
+var de_StartVectorEnrichmentJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.sagemakergeospatial#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.sagemakergeospatial#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartVectorEnrichmentJobCommandError");
+var de_StopEarthObservationJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StopEarthObservationJobCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_StopEarthObservationJobCommand");
+var de_StopEarthObservationJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.sagemakergeospatial#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StopEarthObservationJobCommandError");
+var de_StopVectorEnrichmentJobCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StopVectorEnrichmentJobCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_StopVectorEnrichmentJobCommand");
+var de_StopVectorEnrichmentJobCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.sagemakergeospatial#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StopVectorEnrichmentJobCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.sagemakergeospatial#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.sagemakergeospatial#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.sagemakergeospatial#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.sagemakergeospatial#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.sagemakergeospatial#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(SageMakerGeospatialServiceException);
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessDeniedExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString,
+    ResourceId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ConflictExceptionRes");
+var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString,
+    ResourceId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString,
+    ResourceId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString,
+    ResourceId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServiceQuotaExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceQuotaExceededExceptionRes");
+var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString,
+    ResourceId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThrottlingExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    Message: import_smithy_client.expectString,
+    ResourceId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ValidationExceptionRes");
+var se_AreaOfInterest = /* @__PURE__ */ __name((input, context) => {
+  return AreaOfInterest.visit(input, {
+    AreaOfInterestGeometry: (value) => ({ AreaOfInterestGeometry: se_AreaOfInterestGeometry(value, context) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_AreaOfInterest");
+var se_AreaOfInterestGeometry = /* @__PURE__ */ __name((input, context) => {
+  return AreaOfInterestGeometry.visit(input, {
+    MultiPolygonGeometry: (value) => ({ MultiPolygonGeometry: se_MultiPolygonGeometryInput(value, context) }),
+    PolygonGeometry: (value) => ({ PolygonGeometry: se_PolygonGeometryInput(value, context) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_AreaOfInterestGeometry");
+var se_EoCloudCoverInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    LowerBound: import_smithy_client.serializeFloat,
+    UpperBound: import_smithy_client.serializeFloat
+  });
+}, "se_EoCloudCoverInput");
+var se_InputConfigInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    PreviousEarthObservationJobArn: [],
+    RasterDataCollectionQuery: (_) => se_RasterDataCollectionQueryInput(_, context)
+  });
+}, "se_InputConfigInput");
+var se_JobConfigInput = /* @__PURE__ */ __name((input, context) => {
+  return JobConfigInput.visit(input, {
+    BandMathConfig: (value) => ({ BandMathConfig: (0, import_smithy_client._json)(value) }),
+    CloudMaskingConfig: (value) => ({ CloudMaskingConfig: (0, import_smithy_client._json)(value) }),
+    CloudRemovalConfig: (value) => ({ CloudRemovalConfig: (0, import_smithy_client._json)(value) }),
+    GeoMosaicConfig: (value) => ({ GeoMosaicConfig: (0, import_smithy_client._json)(value) }),
+    LandCoverSegmentationConfig: (value) => ({ LandCoverSegmentationConfig: (0, import_smithy_client._json)(value) }),
+    ResamplingConfig: (value) => ({ ResamplingConfig: se_ResamplingConfigInput(value, context) }),
+    StackConfig: (value) => ({ StackConfig: se_StackConfigInput(value, context) }),
+    TemporalStatisticsConfig: (value) => ({ TemporalStatisticsConfig: (0, import_smithy_client._json)(value) }),
+    ZonalStatisticsConfig: (value) => ({ ZonalStatisticsConfig: (0, import_smithy_client._json)(value) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_JobConfigInput");
+var se_LandsatCloudCoverLandInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    LowerBound: import_smithy_client.serializeFloat,
+    UpperBound: import_smithy_client.serializeFloat
+  });
+}, "se_LandsatCloudCoverLandInput");
+var se_LinearRing = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_Position(entry, context);
+  });
+}, "se_LinearRing");
+var se_LinearRings = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_LinearRing(entry, context);
+  });
+}, "se_LinearRings");
+var se_LinearRingsList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_LinearRings(entry, context);
+  });
+}, "se_LinearRingsList");
+var se_MultiPolygonGeometryInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Coordinates: (_) => se_LinearRingsList(_, context)
+  });
+}, "se_MultiPolygonGeometryInput");
+var se_OutputResolutionResamplingInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    UserDefined: (_) => se_UserDefined(_, context)
+  });
+}, "se_OutputResolutionResamplingInput");
+var se_OutputResolutionStackInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Predefined: [],
+    UserDefined: (_) => se_UserDefined(_, context)
+  });
+}, "se_OutputResolutionStackInput");
+var se_PolygonGeometryInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Coordinates: (_) => se_LinearRings(_, context)
+  });
+}, "se_PolygonGeometryInput");
+var se_Position = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client.serializeFloat)(entry);
+  });
+}, "se_Position");
+var se_Property = /* @__PURE__ */ __name((input, context) => {
+  return Property.visit(input, {
+    EoCloudCover: (value) => ({ EoCloudCover: se_EoCloudCoverInput(value, context) }),
+    LandsatCloudCoverLand: (value) => ({ LandsatCloudCoverLand: se_LandsatCloudCoverLandInput(value, context) }),
+    Platform: (value) => ({ Platform: (0, import_smithy_client._json)(value) }),
+    ViewOffNadir: (value) => ({ ViewOffNadir: se_ViewOffNadirInput(value, context) }),
+    ViewSunAzimuth: (value) => ({ ViewSunAzimuth: se_ViewSunAzimuthInput(value, context) }),
+    ViewSunElevation: (value) => ({ ViewSunElevation: se_ViewSunElevationInput(value, context) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_Property");
+var se_PropertyFilter = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Property: (_) => se_Property(_, context)
+  });
+}, "se_PropertyFilter");
+var se_PropertyFilters = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    LogicalOperator: [],
+    Properties: (_) => se_PropertyFiltersList(_, context)
+  });
+}, "se_PropertyFilters");
+var se_PropertyFiltersList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_PropertyFilter(entry, context);
+  });
+}, "se_PropertyFiltersList");
+var se_RasterDataCollectionQueryInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AreaOfInterest: (_) => se_AreaOfInterest(_, context),
+    PropertyFilters: (_) => se_PropertyFilters(_, context),
+    RasterDataCollectionArn: [],
+    TimeRangeFilter: (_) => se_TimeRangeFilterInput(_, context)
+  });
+}, "se_RasterDataCollectionQueryInput");
+var se_RasterDataCollectionQueryWithBandFilterInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AreaOfInterest: (_) => se_AreaOfInterest(_, context),
+    BandFilter: import_smithy_client._json,
+    PropertyFilters: (_) => se_PropertyFilters(_, context),
+    TimeRangeFilter: (_) => se_TimeRangeFilterInput(_, context)
+  });
+}, "se_RasterDataCollectionQueryWithBandFilterInput");
+var se_ResamplingConfigInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AlgorithmName: [],
+    OutputResolution: (_) => se_OutputResolutionResamplingInput(_, context),
+    TargetBands: import_smithy_client._json
+  });
+}, "se_ResamplingConfigInput");
+var se_StackConfigInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    OutputResolution: (_) => se_OutputResolutionStackInput(_, context),
+    TargetBands: import_smithy_client._json
+  });
+}, "se_StackConfigInput");
+var se_TimeRangeFilterInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    EndTime: (_) => Math.round(_.getTime() / 1e3),
+    StartTime: (_) => Math.round(_.getTime() / 1e3)
+  });
+}, "se_TimeRangeFilterInput");
+var se_UserDefined = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Unit: [],
+    Value: import_smithy_client.serializeFloat
+  });
+}, "se_UserDefined");
+var se_ViewOffNadirInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    LowerBound: import_smithy_client.serializeFloat,
+    UpperBound: import_smithy_client.serializeFloat
+  });
+}, "se_ViewOffNadirInput");
+var se_ViewSunAzimuthInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    LowerBound: import_smithy_client.serializeFloat,
+    UpperBound: import_smithy_client.serializeFloat
+  });
+}, "se_ViewSunAzimuthInput");
+var se_ViewSunElevationInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    LowerBound: import_smithy_client.serializeFloat,
+    UpperBound: import_smithy_client.serializeFloat
+  });
+}, "se_ViewSunElevationInput");
+var de_AreaOfInterest = /* @__PURE__ */ __name((output, context) => {
+  if (output.AreaOfInterestGeometry != null) {
+    return {
+      AreaOfInterestGeometry: de_AreaOfInterestGeometry((0, import_core.awsExpectUnion)(output.AreaOfInterestGeometry), context)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_AreaOfInterest");
+var de_AreaOfInterestGeometry = /* @__PURE__ */ __name((output, context) => {
+  if (output.MultiPolygonGeometry != null) {
+    return {
+      MultiPolygonGeometry: de_MultiPolygonGeometryInput(output.MultiPolygonGeometry, context)
+    };
+  }
+  if (output.PolygonGeometry != null) {
+    return {
+      PolygonGeometry: de_PolygonGeometryInput(output.PolygonGeometry, context)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_AreaOfInterestGeometry");
+var de_DataCollectionsList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_RasterDataCollectionMetadata(entry, context);
+  });
+  return retVal;
+}, "de_DataCollectionsList");
+var de_EarthObservationJobList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ListEarthObservationJobOutputConfig(entry, context);
+  });
+  return retVal;
+}, "de_EarthObservationJobList");
+var de_EoCloudCoverInput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LowerBound: import_smithy_client.limitedParseFloat32,
+    UpperBound: import_smithy_client.limitedParseFloat32
+  });
+}, "de_EoCloudCoverInput");
+var de_Filter = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Maximum: import_smithy_client.limitedParseFloat32,
+    Minimum: import_smithy_client.limitedParseFloat32,
+    Name: import_smithy_client.expectString,
+    Type: import_smithy_client.expectString
+  });
+}, "de_Filter");
+var de_FilterList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Filter(entry, context);
+  });
+  return retVal;
+}, "de_FilterList");
+var de_Geometry = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Coordinates: (_) => de_LinearRings(_, context),
+    Type: import_smithy_client.expectString
+  });
+}, "de_Geometry");
+var de_InputConfigOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    PreviousEarthObservationJobArn: import_smithy_client.expectString,
+    RasterDataCollectionQuery: (_) => de_RasterDataCollectionQueryOutput(_, context)
+  });
+}, "de_InputConfigOutput");
+var de_ItemSource = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Assets: import_smithy_client._json,
+    DateTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Geometry: (_) => de_Geometry(_, context),
+    Id: import_smithy_client.expectString,
+    Properties: (_) => de_Properties(_, context)
+  });
+}, "de_ItemSource");
+var de_ItemSourceList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ItemSource(entry, context);
+  });
+  return retVal;
+}, "de_ItemSourceList");
+var de_JobConfigInput = /* @__PURE__ */ __name((output, context) => {
+  if (output.BandMathConfig != null) {
+    return {
+      BandMathConfig: (0, import_smithy_client._json)(output.BandMathConfig)
+    };
+  }
+  if (output.CloudMaskingConfig != null) {
+    return {
+      CloudMaskingConfig: (0, import_smithy_client._json)(output.CloudMaskingConfig)
+    };
+  }
+  if (output.CloudRemovalConfig != null) {
+    return {
+      CloudRemovalConfig: (0, import_smithy_client._json)(output.CloudRemovalConfig)
+    };
+  }
+  if (output.GeoMosaicConfig != null) {
+    return {
+      GeoMosaicConfig: (0, import_smithy_client._json)(output.GeoMosaicConfig)
+    };
+  }
+  if (output.LandCoverSegmentationConfig != null) {
+    return {
+      LandCoverSegmentationConfig: (0, import_smithy_client._json)(output.LandCoverSegmentationConfig)
+    };
+  }
+  if (output.ResamplingConfig != null) {
+    return {
+      ResamplingConfig: de_ResamplingConfigInput(output.ResamplingConfig, context)
+    };
+  }
+  if (output.StackConfig != null) {
+    return {
+      StackConfig: de_StackConfigInput(output.StackConfig, context)
+    };
+  }
+  if (output.TemporalStatisticsConfig != null) {
+    return {
+      TemporalStatisticsConfig: (0, import_smithy_client._json)(output.TemporalStatisticsConfig)
+    };
+  }
+  if (output.ZonalStatisticsConfig != null) {
+    return {
+      ZonalStatisticsConfig: (0, import_smithy_client._json)(output.ZonalStatisticsConfig)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_JobConfigInput");
+var de_LandsatCloudCoverLandInput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LowerBound: import_smithy_client.limitedParseFloat32,
+    UpperBound: import_smithy_client.limitedParseFloat32
+  });
+}, "de_LandsatCloudCoverLandInput");
+var de_LinearRing = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Position(entry, context);
+  });
+  return retVal;
+}, "de_LinearRing");
+var de_LinearRings = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LinearRing(entry, context);
+  });
+  return retVal;
+}, "de_LinearRings");
+var de_LinearRingsList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_LinearRings(entry, context);
+  });
+  return retVal;
+}, "de_LinearRingsList");
+var de_ListEarthObservationJobOutputConfig = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    DurationInSeconds: import_smithy_client.expectInt32,
+    Name: import_smithy_client.expectString,
+    OperationType: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    Tags: import_smithy_client._json
+  });
+}, "de_ListEarthObservationJobOutputConfig");
+var de_ListVectorEnrichmentJobOutputConfig = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    DurationInSeconds: import_smithy_client.expectInt32,
+    Name: import_smithy_client.expectString,
+    Status: import_smithy_client.expectString,
+    Tags: import_smithy_client._json,
+    Type: import_smithy_client.expectString
+  });
+}, "de_ListVectorEnrichmentJobOutputConfig");
+var de_MultiPolygonGeometryInput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Coordinates: (_) => de_LinearRingsList(_, context)
+  });
+}, "de_MultiPolygonGeometryInput");
+var de_OutputResolutionResamplingInput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    UserDefined: (_) => de_UserDefined(_, context)
+  });
+}, "de_OutputResolutionResamplingInput");
+var de_OutputResolutionStackInput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Predefined: import_smithy_client.expectString,
+    UserDefined: (_) => de_UserDefined(_, context)
+  });
+}, "de_OutputResolutionStackInput");
+var de_PolygonGeometryInput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Coordinates: (_) => de_LinearRings(_, context)
+  });
+}, "de_PolygonGeometryInput");
+var de_Position = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client.limitedParseDouble)(entry);
+  });
+  return retVal;
+}, "de_Position");
+var de_Properties = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    EoCloudCover: import_smithy_client.limitedParseFloat32,
+    LandsatCloudCoverLand: import_smithy_client.limitedParseFloat32,
+    Platform: import_smithy_client.expectString,
+    ViewOffNadir: import_smithy_client.limitedParseFloat32,
+    ViewSunAzimuth: import_smithy_client.limitedParseFloat32,
+    ViewSunElevation: import_smithy_client.limitedParseFloat32
+  });
+}, "de_Properties");
+var de_Property = /* @__PURE__ */ __name((output, context) => {
+  if (output.EoCloudCover != null) {
+    return {
+      EoCloudCover: de_EoCloudCoverInput(output.EoCloudCover, context)
+    };
+  }
+  if (output.LandsatCloudCoverLand != null) {
+    return {
+      LandsatCloudCoverLand: de_LandsatCloudCoverLandInput(output.LandsatCloudCoverLand, context)
+    };
+  }
+  if (output.Platform != null) {
+    return {
+      Platform: (0, import_smithy_client._json)(output.Platform)
+    };
+  }
+  if (output.ViewOffNadir != null) {
+    return {
+      ViewOffNadir: de_ViewOffNadirInput(output.ViewOffNadir, context)
+    };
+  }
+  if (output.ViewSunAzimuth != null) {
+    return {
+      ViewSunAzimuth: de_ViewSunAzimuthInput(output.ViewSunAzimuth, context)
+    };
+  }
+  if (output.ViewSunElevation != null) {
+    return {
+      ViewSunElevation: de_ViewSunElevationInput(output.ViewSunElevation, context)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_Property");
+var de_PropertyFilter = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Property: (_) => de_Property((0, import_core.awsExpectUnion)(_), context)
+  });
+}, "de_PropertyFilter");
+var de_PropertyFilters = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LogicalOperator: import_smithy_client.expectString,
+    Properties: (_) => de_PropertyFiltersList(_, context)
+  });
+}, "de_PropertyFilters");
+var de_PropertyFiltersList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_PropertyFilter(entry, context);
+  });
+  return retVal;
+}, "de_PropertyFiltersList");
+var de_RasterDataCollectionMetadata = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: import_smithy_client.expectString,
+    Description: import_smithy_client.expectString,
+    DescriptionPageUrl: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    SupportedFilters: (_) => de_FilterList(_, context),
+    Tags: import_smithy_client._json,
+    Type: import_smithy_client.expectString
+  });
+}, "de_RasterDataCollectionMetadata");
+var de_RasterDataCollectionQueryOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AreaOfInterest: (_) => de_AreaOfInterest((0, import_core.awsExpectUnion)(_), context),
+    PropertyFilters: (_) => de_PropertyFilters(_, context),
+    RasterDataCollectionArn: import_smithy_client.expectString,
+    RasterDataCollectionName: import_smithy_client.expectString,
+    TimeRangeFilter: (_) => de_TimeRangeFilterOutput(_, context)
+  });
+}, "de_RasterDataCollectionQueryOutput");
+var de_ResamplingConfigInput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AlgorithmName: import_smithy_client.expectString,
+    OutputResolution: (_) => de_OutputResolutionResamplingInput(_, context),
+    TargetBands: import_smithy_client._json
+  });
+}, "de_ResamplingConfigInput");
+var de_StackConfigInput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    OutputResolution: (_) => de_OutputResolutionStackInput(_, context),
+    TargetBands: import_smithy_client._json
+  });
+}, "de_StackConfigInput");
+var de_TimeRangeFilterOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    EndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_TimeRangeFilterOutput");
+var de_UserDefined = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Unit: import_smithy_client.expectString,
+    Value: import_smithy_client.limitedParseFloat32
+  });
+}, "de_UserDefined");
+var de_VectorEnrichmentJobList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ListVectorEnrichmentJobOutputConfig(entry, context);
+  });
+  return retVal;
+}, "de_VectorEnrichmentJobList");
+var de_ViewOffNadirInput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LowerBound: import_smithy_client.limitedParseFloat32,
+    UpperBound: import_smithy_client.limitedParseFloat32
+  });
+}, "de_ViewOffNadirInput");
+var de_ViewSunAzimuthInput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LowerBound: import_smithy_client.limitedParseFloat32,
+    UpperBound: import_smithy_client.limitedParseFloat32
+  });
+}, "de_ViewSunAzimuthInput");
+var de_ViewSunElevationInput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    LowerBound: import_smithy_client.limitedParseFloat32,
+    UpperBound: import_smithy_client.limitedParseFloat32
+  });
+}, "de_ViewSunElevationInput");
+var deserializeMetadata = /* @__PURE__ */ __name((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"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var _A = "Arn";
+var _ERA = "ExecutionRoleArn";
+var _IA = "ImageAssets";
+var _IM = "ImageMask";
+var _MR = "MaxResults";
+var _NT = "NextToken";
+var _ODT = "OutputDataType";
+var _OF = "OutputFormat";
+var _PF = "PropertyFilters";
+var _T = "Target";
+var _TK = "TagKeys";
+var _TRF = "TimeRangeFilter";
+var _tK = "tagKeys";
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/DeleteEarthObservationJobCommand.ts
+var _DeleteEarthObservationJobCommand = class _DeleteEarthObservationJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "DeleteEarthObservationJob", {}).n("SageMakerGeospatialClient", "DeleteEarthObservationJobCommand").f(void 0, void 0).ser(se_DeleteEarthObservationJobCommand).de(de_DeleteEarthObservationJobCommand).build() {
+};
+__name(_DeleteEarthObservationJobCommand, "DeleteEarthObservationJobCommand");
+var DeleteEarthObservationJobCommand = _DeleteEarthObservationJobCommand;
+
+// src/commands/DeleteVectorEnrichmentJobCommand.ts
+
+
+
+
+var _DeleteVectorEnrichmentJobCommand = class _DeleteVectorEnrichmentJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "DeleteVectorEnrichmentJob", {}).n("SageMakerGeospatialClient", "DeleteVectorEnrichmentJobCommand").f(void 0, void 0).ser(se_DeleteVectorEnrichmentJobCommand).de(de_DeleteVectorEnrichmentJobCommand).build() {
+};
+__name(_DeleteVectorEnrichmentJobCommand, "DeleteVectorEnrichmentJobCommand");
+var DeleteVectorEnrichmentJobCommand = _DeleteVectorEnrichmentJobCommand;
+
+// src/commands/ExportEarthObservationJobCommand.ts
+
+
+
+
+var _ExportEarthObservationJobCommand = class _ExportEarthObservationJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "ExportEarthObservationJob", {}).n("SageMakerGeospatialClient", "ExportEarthObservationJobCommand").f(void 0, void 0).ser(se_ExportEarthObservationJobCommand).de(de_ExportEarthObservationJobCommand).build() {
+};
+__name(_ExportEarthObservationJobCommand, "ExportEarthObservationJobCommand");
+var ExportEarthObservationJobCommand = _ExportEarthObservationJobCommand;
+
+// src/commands/ExportVectorEnrichmentJobCommand.ts
+
+
+
+
+var _ExportVectorEnrichmentJobCommand = class _ExportVectorEnrichmentJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "ExportVectorEnrichmentJob", {}).n("SageMakerGeospatialClient", "ExportVectorEnrichmentJobCommand").f(void 0, void 0).ser(se_ExportVectorEnrichmentJobCommand).de(de_ExportVectorEnrichmentJobCommand).build() {
+};
+__name(_ExportVectorEnrichmentJobCommand, "ExportVectorEnrichmentJobCommand");
+var ExportVectorEnrichmentJobCommand = _ExportVectorEnrichmentJobCommand;
+
+// src/commands/GetEarthObservationJobCommand.ts
+
+
+
+
+var _GetEarthObservationJobCommand = class _GetEarthObservationJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "GetEarthObservationJob", {}).n("SageMakerGeospatialClient", "GetEarthObservationJobCommand").f(void 0, GetEarthObservationJobOutputFilterSensitiveLog).ser(se_GetEarthObservationJobCommand).de(de_GetEarthObservationJobCommand).build() {
+};
+__name(_GetEarthObservationJobCommand, "GetEarthObservationJobCommand");
+var GetEarthObservationJobCommand = _GetEarthObservationJobCommand;
+
+// src/commands/GetRasterDataCollectionCommand.ts
+
+
+
+
+var _GetRasterDataCollectionCommand = class _GetRasterDataCollectionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "GetRasterDataCollection", {}).n("SageMakerGeospatialClient", "GetRasterDataCollectionCommand").f(void 0, void 0).ser(se_GetRasterDataCollectionCommand).de(de_GetRasterDataCollectionCommand).build() {
+};
+__name(_GetRasterDataCollectionCommand, "GetRasterDataCollectionCommand");
+var GetRasterDataCollectionCommand = _GetRasterDataCollectionCommand;
+
+// src/commands/GetTileCommand.ts
+
+
+
+
+var _GetTileCommand = class _GetTileCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "GetTile", {}).n("SageMakerGeospatialClient", "GetTileCommand").f(void 0, GetTileOutputFilterSensitiveLog).ser(se_GetTileCommand).de(de_GetTileCommand).build() {
+};
+__name(_GetTileCommand, "GetTileCommand");
+var GetTileCommand = _GetTileCommand;
+
+// src/commands/GetVectorEnrichmentJobCommand.ts
+
+
+
+
+var _GetVectorEnrichmentJobCommand = class _GetVectorEnrichmentJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "GetVectorEnrichmentJob", {}).n("SageMakerGeospatialClient", "GetVectorEnrichmentJobCommand").f(void 0, void 0).ser(se_GetVectorEnrichmentJobCommand).de(de_GetVectorEnrichmentJobCommand).build() {
+};
+__name(_GetVectorEnrichmentJobCommand, "GetVectorEnrichmentJobCommand");
+var GetVectorEnrichmentJobCommand = _GetVectorEnrichmentJobCommand;
+
+// src/commands/ListEarthObservationJobsCommand.ts
+
+
+
+
+var _ListEarthObservationJobsCommand = class _ListEarthObservationJobsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "ListEarthObservationJobs", {}).n("SageMakerGeospatialClient", "ListEarthObservationJobsCommand").f(ListEarthObservationJobInputFilterSensitiveLog, ListEarthObservationJobOutputFilterSensitiveLog).ser(se_ListEarthObservationJobsCommand).de(de_ListEarthObservationJobsCommand).build() {
+};
+__name(_ListEarthObservationJobsCommand, "ListEarthObservationJobsCommand");
+var ListEarthObservationJobsCommand = _ListEarthObservationJobsCommand;
+
+// src/commands/ListRasterDataCollectionsCommand.ts
+
+
+
+
+var _ListRasterDataCollectionsCommand = class _ListRasterDataCollectionsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "ListRasterDataCollections", {}).n("SageMakerGeospatialClient", "ListRasterDataCollectionsCommand").f(ListRasterDataCollectionsInputFilterSensitiveLog, ListRasterDataCollectionsOutputFilterSensitiveLog).ser(se_ListRasterDataCollectionsCommand).de(de_ListRasterDataCollectionsCommand).build() {
+};
+__name(_ListRasterDataCollectionsCommand, "ListRasterDataCollectionsCommand");
+var ListRasterDataCollectionsCommand = _ListRasterDataCollectionsCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "ListTagsForResource", {}).n("SageMakerGeospatialClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/ListVectorEnrichmentJobsCommand.ts
+
+
+
+
+var _ListVectorEnrichmentJobsCommand = class _ListVectorEnrichmentJobsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "ListVectorEnrichmentJobs", {}).n("SageMakerGeospatialClient", "ListVectorEnrichmentJobsCommand").f(ListVectorEnrichmentJobInputFilterSensitiveLog, ListVectorEnrichmentJobOutputFilterSensitiveLog).ser(se_ListVectorEnrichmentJobsCommand).de(de_ListVectorEnrichmentJobsCommand).build() {
+};
+__name(_ListVectorEnrichmentJobsCommand, "ListVectorEnrichmentJobsCommand");
+var ListVectorEnrichmentJobsCommand = _ListVectorEnrichmentJobsCommand;
+
+// src/commands/SearchRasterDataCollectionCommand.ts
+
+
+
+
+var _SearchRasterDataCollectionCommand = class _SearchRasterDataCollectionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "SearchRasterDataCollection", {}).n("SageMakerGeospatialClient", "SearchRasterDataCollectionCommand").f(SearchRasterDataCollectionInputFilterSensitiveLog, SearchRasterDataCollectionOutputFilterSensitiveLog).ser(se_SearchRasterDataCollectionCommand).de(de_SearchRasterDataCollectionCommand).build() {
+};
+__name(_SearchRasterDataCollectionCommand, "SearchRasterDataCollectionCommand");
+var SearchRasterDataCollectionCommand = _SearchRasterDataCollectionCommand;
+
+// src/commands/StartEarthObservationJobCommand.ts
+
+
+
+
+var _StartEarthObservationJobCommand = class _StartEarthObservationJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "StartEarthObservationJob", {}).n("SageMakerGeospatialClient", "StartEarthObservationJobCommand").f(StartEarthObservationJobInputFilterSensitiveLog, StartEarthObservationJobOutputFilterSensitiveLog).ser(se_StartEarthObservationJobCommand).de(de_StartEarthObservationJobCommand).build() {
+};
+__name(_StartEarthObservationJobCommand, "StartEarthObservationJobCommand");
+var StartEarthObservationJobCommand = _StartEarthObservationJobCommand;
+
+// src/commands/StartVectorEnrichmentJobCommand.ts
+
+
+
+
+var _StartVectorEnrichmentJobCommand = class _StartVectorEnrichmentJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "StartVectorEnrichmentJob", {}).n("SageMakerGeospatialClient", "StartVectorEnrichmentJobCommand").f(void 0, void 0).ser(se_StartVectorEnrichmentJobCommand).de(de_StartVectorEnrichmentJobCommand).build() {
+};
+__name(_StartVectorEnrichmentJobCommand, "StartVectorEnrichmentJobCommand");
+var StartVectorEnrichmentJobCommand = _StartVectorEnrichmentJobCommand;
+
+// src/commands/StopEarthObservationJobCommand.ts
+
+
+
+
+var _StopEarthObservationJobCommand = class _StopEarthObservationJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "StopEarthObservationJob", {}).n("SageMakerGeospatialClient", "StopEarthObservationJobCommand").f(void 0, void 0).ser(se_StopEarthObservationJobCommand).de(de_StopEarthObservationJobCommand).build() {
+};
+__name(_StopEarthObservationJobCommand, "StopEarthObservationJobCommand");
+var StopEarthObservationJobCommand = _StopEarthObservationJobCommand;
+
+// src/commands/StopVectorEnrichmentJobCommand.ts
+
+
+
+
+var _StopVectorEnrichmentJobCommand = class _StopVectorEnrichmentJobCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "StopVectorEnrichmentJob", {}).n("SageMakerGeospatialClient", "StopVectorEnrichmentJobCommand").f(void 0, void 0).ser(se_StopVectorEnrichmentJobCommand).de(de_StopVectorEnrichmentJobCommand).build() {
+};
+__name(_StopVectorEnrichmentJobCommand, "StopVectorEnrichmentJobCommand");
+var StopVectorEnrichmentJobCommand = _StopVectorEnrichmentJobCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "TagResource", {}).n("SageMakerGeospatialClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SageMakerGeospatial", "UntagResource", {}).n("SageMakerGeospatialClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/SageMakerGeospatial.ts
+var commands = {
+  DeleteEarthObservationJobCommand,
+  DeleteVectorEnrichmentJobCommand,
+  ExportEarthObservationJobCommand,
+  ExportVectorEnrichmentJobCommand,
+  GetEarthObservationJobCommand,
+  GetRasterDataCollectionCommand,
+  GetTileCommand,
+  GetVectorEnrichmentJobCommand,
+  ListEarthObservationJobsCommand,
+  ListRasterDataCollectionsCommand,
+  ListTagsForResourceCommand,
+  ListVectorEnrichmentJobsCommand,
+  SearchRasterDataCollectionCommand,
+  StartEarthObservationJobCommand,
+  StartVectorEnrichmentJobCommand,
+  StopEarthObservationJobCommand,
+  StopVectorEnrichmentJobCommand,
+  TagResourceCommand,
+  UntagResourceCommand
+};
+var _SageMakerGeospatial = class _SageMakerGeospatial extends SageMakerGeospatialClient {
+};
+__name(_SageMakerGeospatial, "SageMakerGeospatial");
+var SageMakerGeospatial = _SageMakerGeospatial;
+(0, import_smithy_client.createAggregatedClient)(commands, SageMakerGeospatial);
+
+// src/pagination/ListEarthObservationJobsPaginator.ts
+var import_core3 = require("@smithy/core");
+var paginateListEarthObservationJobs = (0, import_core3.createPaginator)(SageMakerGeospatialClient, ListEarthObservationJobsCommand, "NextToken", "NextToken", "");
+
+// src/pagination/ListRasterDataCollectionsPaginator.ts
+var import_core4 = require("@smithy/core");
+var paginateListRasterDataCollections = (0, import_core4.createPaginator)(SageMakerGeospatialClient, ListRasterDataCollectionsCommand, "NextToken", "NextToken", "");
+
+// src/pagination/ListVectorEnrichmentJobsPaginator.ts
+var import_core5 = require("@smithy/core");
+var paginateListVectorEnrichmentJobs = (0, import_core5.createPaginator)(SageMakerGeospatialClient, ListVectorEnrichmentJobsCommand, "NextToken", "NextToken", "");
+
+// src/pagination/SearchRasterDataCollectionPaginator.ts
+var import_core6 = require("@smithy/core");
+var paginateSearchRasterDataCollection = (0, import_core6.createPaginator)(SageMakerGeospatialClient, SearchRasterDataCollectionCommand, "NextToken", "NextToken", "");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccessDeniedException,
+  AlgorithmNameCloudRemoval,
+  AlgorithmNameGeoMosaic,
+  AlgorithmNameResampling,
+  AreaOfInterest,
+  AreaOfInterestFilterSensitiveLog,
+  AreaOfInterestGeometry,
+  AreaOfInterestGeometryFilterSensitiveLog,
+  ComparisonOperator,
+  ConflictException,
+  DataCollectionType,
+  DeleteEarthObservationJobCommand,
+  DeleteVectorEnrichmentJobCommand,
+  EarthObservationJobErrorType,
+  EarthObservationJobExportStatus,
+  EarthObservationJobStatus,
+  ExportEarthObservationJobCommand,
+  ExportErrorType,
+  ExportVectorEnrichmentJobCommand,
+  GeometryFilterSensitiveLog,
+  GetEarthObservationJobCommand,
+  GetEarthObservationJobOutputFilterSensitiveLog,
+  GetRasterDataCollectionCommand,
+  GetTileCommand,
+  GetTileOutputFilterSensitiveLog,
+  GetVectorEnrichmentJobCommand,
+  GroupBy,
+  InputConfigInputFilterSensitiveLog,
+  InputConfigOutputFilterSensitiveLog,
+  InternalServerException,
+  ItemSourceFilterSensitiveLog,
+  JobConfigInput,
+  ListEarthObservationJobInputFilterSensitiveLog,
+  ListEarthObservationJobOutputFilterSensitiveLog,
+  ListEarthObservationJobsCommand,
+  ListRasterDataCollectionsCommand,
+  ListRasterDataCollectionsInputFilterSensitiveLog,
+  ListRasterDataCollectionsOutputFilterSensitiveLog,
+  ListTagsForResourceCommand,
+  ListVectorEnrichmentJobInputFilterSensitiveLog,
+  ListVectorEnrichmentJobOutputFilterSensitiveLog,
+  ListVectorEnrichmentJobsCommand,
+  LogicalOperator,
+  MultiPolygonGeometryInputFilterSensitiveLog,
+  OutputType,
+  PolygonGeometryInputFilterSensitiveLog,
+  PredefinedResolution,
+  Property,
+  RasterDataCollectionQueryInputFilterSensitiveLog,
+  RasterDataCollectionQueryOutputFilterSensitiveLog,
+  RasterDataCollectionQueryWithBandFilterInputFilterSensitiveLog,
+  ResourceNotFoundException,
+  SageMakerGeospatial,
+  SageMakerGeospatialClient,
+  SageMakerGeospatialServiceException,
+  SearchRasterDataCollectionCommand,
+  SearchRasterDataCollectionInputFilterSensitiveLog,
+  SearchRasterDataCollectionOutputFilterSensitiveLog,
+  ServiceQuotaExceededException,
+  SortOrder,
+  StartEarthObservationJobCommand,
+  StartEarthObservationJobInputFilterSensitiveLog,
+  StartEarthObservationJobOutputFilterSensitiveLog,
+  StartVectorEnrichmentJobCommand,
+  StopEarthObservationJobCommand,
+  StopVectorEnrichmentJobCommand,
+  TagResourceCommand,
+  TargetOptions,
+  TemporalStatistics,
+  ThrottlingException,
+  TimeRangeFilterInputFilterSensitiveLog,
+  TimeRangeFilterOutputFilterSensitiveLog,
+  Unit,
+  UntagResourceCommand,
+  ValidationException,
+  VectorEnrichmentJobConfig,
+  VectorEnrichmentJobDataSourceConfigInput,
+  VectorEnrichmentJobDocumentType,
+  VectorEnrichmentJobErrorType,
+  VectorEnrichmentJobExportErrorType,
+  VectorEnrichmentJobExportStatus,
+  VectorEnrichmentJobStatus,
+  VectorEnrichmentJobType,
+  ZonalStatistics,
+  __Client,
+  paginateListEarthObservationJobs,
+  paginateListRasterDataCollections,
+  paginateListVectorEnrichmentJobs,
+  paginateSearchRasterDataCollection
+});