@aws-sdk/client-sagemaker-geospatial 3.221.0

package/dist-es/models/models_0.js

@@ -0,0 +1,748 @@
+import { SENSITIVE_STRING } from "@aws-sdk/smithy-client";
+import { SageMakerGeospatialServiceException as __BaseException } from "./SageMakerGeospatialServiceException";
+export class AccessDeniedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "AccessDeniedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+        this.Message = opts.Message;
+    }
+}
+export var AlgorithmNameCloudRemoval;
+(function (AlgorithmNameCloudRemoval) {
+    AlgorithmNameCloudRemoval["INTERPOLATION"] = "INTERPOLATION";
+})(AlgorithmNameCloudRemoval || (AlgorithmNameCloudRemoval = {}));
+export var AlgorithmNameGeoMosaic;
+(function (AlgorithmNameGeoMosaic) {
+    AlgorithmNameGeoMosaic["AVERAGE"] = "AVERAGE";
+    AlgorithmNameGeoMosaic["BILINEAR"] = "BILINEAR";
+    AlgorithmNameGeoMosaic["CUBIC"] = "CUBIC";
+    AlgorithmNameGeoMosaic["CUBICSPLINE"] = "CUBICSPLINE";
+    AlgorithmNameGeoMosaic["LANCZOS"] = "LANCZOS";
+    AlgorithmNameGeoMosaic["MAX"] = "MAX";
+    AlgorithmNameGeoMosaic["MED"] = "MED";
+    AlgorithmNameGeoMosaic["MIN"] = "MIN";
+    AlgorithmNameGeoMosaic["MODE"] = "MODE";
+    AlgorithmNameGeoMosaic["NEAR"] = "NEAR";
+    AlgorithmNameGeoMosaic["Q1"] = "Q1";
+    AlgorithmNameGeoMosaic["Q3"] = "Q3";
+    AlgorithmNameGeoMosaic["RMS"] = "RMS";
+    AlgorithmNameGeoMosaic["SUM"] = "SUM";
+})(AlgorithmNameGeoMosaic || (AlgorithmNameGeoMosaic = {}));
+export var AlgorithmNameResampling;
+(function (AlgorithmNameResampling) {
+    AlgorithmNameResampling["AVERAGE"] = "AVERAGE";
+    AlgorithmNameResampling["BILINEAR"] = "BILINEAR";
+    AlgorithmNameResampling["CUBIC"] = "CUBIC";
+    AlgorithmNameResampling["CUBICSPLINE"] = "CUBICSPLINE";
+    AlgorithmNameResampling["LANCZOS"] = "LANCZOS";
+    AlgorithmNameResampling["MAX"] = "MAX";
+    AlgorithmNameResampling["MED"] = "MED";
+    AlgorithmNameResampling["MIN"] = "MIN";
+    AlgorithmNameResampling["MODE"] = "MODE";
+    AlgorithmNameResampling["NEAR"] = "NEAR";
+    AlgorithmNameResampling["Q1"] = "Q1";
+    AlgorithmNameResampling["Q3"] = "Q3";
+    AlgorithmNameResampling["RMS"] = "RMS";
+    AlgorithmNameResampling["SUM"] = "SUM";
+})(AlgorithmNameResampling || (AlgorithmNameResampling = {}));
+export var AreaOfInterestGeometry;
+(function (AreaOfInterestGeometry) {
+    AreaOfInterestGeometry.visit = (value, visitor) => {
+        if (value.PolygonGeometry !== undefined)
+            return visitor.PolygonGeometry(value.PolygonGeometry);
+        if (value.MultiPolygonGeometry !== undefined)
+            return visitor.MultiPolygonGeometry(value.MultiPolygonGeometry);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AreaOfInterestGeometry || (AreaOfInterestGeometry = {}));
+export var AreaOfInterest;
+(function (AreaOfInterest) {
+    AreaOfInterest.visit = (value, visitor) => {
+        if (value.AreaOfInterestGeometry !== undefined)
+            return visitor.AreaOfInterestGeometry(value.AreaOfInterestGeometry);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(AreaOfInterest || (AreaOfInterest = {}));
+export var OutputType;
+(function (OutputType) {
+    OutputType["FLOAT32"] = "FLOAT32";
+    OutputType["FLOAT64"] = "FLOAT64";
+    OutputType["INT16"] = "INT16";
+    OutputType["INT32"] = "INT32";
+    OutputType["UINT16"] = "UINT16";
+})(OutputType || (OutputType = {}));
+export var ComparisonOperator;
+(function (ComparisonOperator) {
+    ComparisonOperator["EQUALS"] = "EQUALS";
+    ComparisonOperator["NOT_EQUALS"] = "NOT_EQUALS";
+    ComparisonOperator["STARTS_WITH"] = "STARTS_WITH";
+})(ComparisonOperator || (ComparisonOperator = {}));
+export class ConflictException extends __BaseException {
+    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;
+    }
+}
+export var DataCollectionType;
+(function (DataCollectionType) {
+    DataCollectionType["PREMIUM"] = "PREMIUM";
+    DataCollectionType["PUBLIC"] = "PUBLIC";
+    DataCollectionType["USER"] = "USER";
+})(DataCollectionType || (DataCollectionType = {}));
+export class InternalServerException extends __BaseException {
+    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;
+    }
+}
+export class ResourceNotFoundException extends __BaseException {
+    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;
+    }
+}
+export class ThrottlingException extends __BaseException {
+    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;
+    }
+}
+export class ValidationException extends __BaseException {
+    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;
+    }
+}
+export var EarthObservationJobExportStatus;
+(function (EarthObservationJobExportStatus) {
+    EarthObservationJobExportStatus["FAILED"] = "FAILED";
+    EarthObservationJobExportStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    EarthObservationJobExportStatus["SUCCEEDED"] = "SUCCEEDED";
+})(EarthObservationJobExportStatus || (EarthObservationJobExportStatus = {}));
+export class ServiceQuotaExceededException extends __BaseException {
+    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;
+    }
+}
+export var EarthObservationJobErrorType;
+(function (EarthObservationJobErrorType) {
+    EarthObservationJobErrorType["CLIENT_ERROR"] = "CLIENT_ERROR";
+    EarthObservationJobErrorType["SERVER_ERROR"] = "SERVER_ERROR";
+})(EarthObservationJobErrorType || (EarthObservationJobErrorType = {}));
+export var ExportErrorType;
+(function (ExportErrorType) {
+    ExportErrorType["CLIENT_ERROR"] = "CLIENT_ERROR";
+    ExportErrorType["SERVER_ERROR"] = "SERVER_ERROR";
+})(ExportErrorType || (ExportErrorType = {}));
+export var MetadataProvider;
+(function (MetadataProvider) {
+    MetadataProvider["PLANET_ORDER"] = "PLANET_ORDER";
+})(MetadataProvider || (MetadataProvider = {}));
+export var EojDataSourceConfigInput;
+(function (EojDataSourceConfigInput) {
+    EojDataSourceConfigInput.visit = (value, visitor) => {
+        if (value.S3Data !== undefined)
+            return visitor.S3Data(value.S3Data);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(EojDataSourceConfigInput || (EojDataSourceConfigInput = {}));
+export var LogicalOperator;
+(function (LogicalOperator) {
+    LogicalOperator["AND"] = "AND";
+})(LogicalOperator || (LogicalOperator = {}));
+export var Property;
+(function (Property) {
+    Property.visit = (value, visitor) => {
+        if (value.EoCloudCover !== undefined)
+            return visitor.EoCloudCover(value.EoCloudCover);
+        if (value.ViewOffNadir !== undefined)
+            return visitor.ViewOffNadir(value.ViewOffNadir);
+        if (value.ViewSunAzimuth !== undefined)
+            return visitor.ViewSunAzimuth(value.ViewSunAzimuth);
+        if (value.ViewSunElevation !== undefined)
+            return visitor.ViewSunElevation(value.ViewSunElevation);
+        if (value.Platform !== undefined)
+            return visitor.Platform(value.Platform);
+        if (value.LandsatCloudCoverLand !== undefined)
+            return visitor.LandsatCloudCoverLand(value.LandsatCloudCoverLand);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(Property || (Property = {}));
+export var Unit;
+(function (Unit) {
+    Unit["METERS"] = "METERS";
+})(Unit || (Unit = {}));
+export var PredefinedResolution;
+(function (PredefinedResolution) {
+    PredefinedResolution["AVERAGE"] = "AVERAGE";
+    PredefinedResolution["HIGHEST"] = "HIGHEST";
+    PredefinedResolution["LOWEST"] = "LOWEST";
+})(PredefinedResolution || (PredefinedResolution = {}));
+export var GroupBy;
+(function (GroupBy) {
+    GroupBy["ALL"] = "ALL";
+    GroupBy["YEARLY"] = "YEARLY";
+})(GroupBy || (GroupBy = {}));
+export var TemporalStatistics;
+(function (TemporalStatistics) {
+    TemporalStatistics["MEAN"] = "MEAN";
+    TemporalStatistics["MEDIAN"] = "MEDIAN";
+    TemporalStatistics["STANDARD_DEVIATION"] = "STANDARD_DEVIATION";
+})(TemporalStatistics || (TemporalStatistics = {}));
+export var ZonalStatistics;
+(function (ZonalStatistics) {
+    ZonalStatistics["MAX"] = "MAX";
+    ZonalStatistics["MEAN"] = "MEAN";
+    ZonalStatistics["MEDIAN"] = "MEDIAN";
+    ZonalStatistics["MIN"] = "MIN";
+    ZonalStatistics["STANDARD_DEVIATION"] = "STANDARD_DEVIATION";
+    ZonalStatistics["SUM"] = "SUM";
+})(ZonalStatistics || (ZonalStatistics = {}));
+export var JobConfigInput;
+(function (JobConfigInput) {
+    JobConfigInput.visit = (value, visitor) => {
+        if (value.BandMathConfig !== undefined)
+            return visitor.BandMathConfig(value.BandMathConfig);
+        if (value.ResamplingConfig !== undefined)
+            return visitor.ResamplingConfig(value.ResamplingConfig);
+        if (value.TemporalStatisticsConfig !== undefined)
+            return visitor.TemporalStatisticsConfig(value.TemporalStatisticsConfig);
+        if (value.CloudRemovalConfig !== undefined)
+            return visitor.CloudRemovalConfig(value.CloudRemovalConfig);
+        if (value.ZonalStatisticsConfig !== undefined)
+            return visitor.ZonalStatisticsConfig(value.ZonalStatisticsConfig);
+        if (value.GeoMosaicConfig !== undefined)
+            return visitor.GeoMosaicConfig(value.GeoMosaicConfig);
+        if (value.StackConfig !== undefined)
+            return visitor.StackConfig(value.StackConfig);
+        if (value.CloudMaskingConfig !== undefined)
+            return visitor.CloudMaskingConfig(value.CloudMaskingConfig);
+        if (value.LandCoverSegmentationConfig !== undefined)
+            return visitor.LandCoverSegmentationConfig(value.LandCoverSegmentationConfig);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(JobConfigInput || (JobConfigInput = {}));
+export var EarthObservationJobStatus;
+(function (EarthObservationJobStatus) {
+    EarthObservationJobStatus["COMPLETED"] = "COMPLETED";
+    EarthObservationJobStatus["DELETED"] = "DELETED";
+    EarthObservationJobStatus["DELETING"] = "DELETING";
+    EarthObservationJobStatus["FAILED"] = "FAILED";
+    EarthObservationJobStatus["INITIALIZING"] = "INITIALIZING";
+    EarthObservationJobStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    EarthObservationJobStatus["STOPPED"] = "STOPPED";
+    EarthObservationJobStatus["STOPPING"] = "STOPPING";
+})(EarthObservationJobStatus || (EarthObservationJobStatus = {}));
+export var TargetOptions;
+(function (TargetOptions) {
+    TargetOptions["INPUT"] = "INPUT";
+    TargetOptions["OUTPUT"] = "OUTPUT";
+})(TargetOptions || (TargetOptions = {}));
+export var SortOrder;
+(function (SortOrder) {
+    SortOrder["ASCENDING"] = "ASCENDING";
+    SortOrder["DESCENDING"] = "DESCENDING";
+})(SortOrder || (SortOrder = {}));
+export var VectorEnrichmentJobExportStatus;
+(function (VectorEnrichmentJobExportStatus) {
+    VectorEnrichmentJobExportStatus["FAILED"] = "FAILED";
+    VectorEnrichmentJobExportStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    VectorEnrichmentJobExportStatus["SUCCEEDED"] = "SUCCEEDED";
+})(VectorEnrichmentJobExportStatus || (VectorEnrichmentJobExportStatus = {}));
+export var VectorEnrichmentJobErrorType;
+(function (VectorEnrichmentJobErrorType) {
+    VectorEnrichmentJobErrorType["CLIENT_ERROR"] = "CLIENT_ERROR";
+    VectorEnrichmentJobErrorType["SERVER_ERROR"] = "SERVER_ERROR";
+})(VectorEnrichmentJobErrorType || (VectorEnrichmentJobErrorType = {}));
+export var VectorEnrichmentJobExportErrorType;
+(function (VectorEnrichmentJobExportErrorType) {
+    VectorEnrichmentJobExportErrorType["CLIENT_ERROR"] = "CLIENT_ERROR";
+    VectorEnrichmentJobExportErrorType["SERVER_ERROR"] = "SERVER_ERROR";
+})(VectorEnrichmentJobExportErrorType || (VectorEnrichmentJobExportErrorType = {}));
+export var VectorEnrichmentJobDataSourceConfigInput;
+(function (VectorEnrichmentJobDataSourceConfigInput) {
+    VectorEnrichmentJobDataSourceConfigInput.visit = (value, visitor) => {
+        if (value.S3Data !== undefined)
+            return visitor.S3Data(value.S3Data);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(VectorEnrichmentJobDataSourceConfigInput || (VectorEnrichmentJobDataSourceConfigInput = {}));
+export var VectorEnrichmentJobDocumentType;
+(function (VectorEnrichmentJobDocumentType) {
+    VectorEnrichmentJobDocumentType["CSV"] = "CSV";
+})(VectorEnrichmentJobDocumentType || (VectorEnrichmentJobDocumentType = {}));
+export var VectorEnrichmentJobConfig;
+(function (VectorEnrichmentJobConfig) {
+    VectorEnrichmentJobConfig.visit = (value, visitor) => {
+        if (value.ReverseGeocodingConfig !== undefined)
+            return visitor.ReverseGeocodingConfig(value.ReverseGeocodingConfig);
+        if (value.MapMatchingConfig !== undefined)
+            return visitor.MapMatchingConfig(value.MapMatchingConfig);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(VectorEnrichmentJobConfig || (VectorEnrichmentJobConfig = {}));
+export var VectorEnrichmentJobStatus;
+(function (VectorEnrichmentJobStatus) {
+    VectorEnrichmentJobStatus["COMPLETED"] = "COMPLETED";
+    VectorEnrichmentJobStatus["DELETED"] = "DELETED";
+    VectorEnrichmentJobStatus["DELETING"] = "DELETING";
+    VectorEnrichmentJobStatus["FAILED"] = "FAILED";
+    VectorEnrichmentJobStatus["INITIALIZING"] = "INITIALIZING";
+    VectorEnrichmentJobStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    VectorEnrichmentJobStatus["STOPPED"] = "STOPPED";
+    VectorEnrichmentJobStatus["STOPPING"] = "STOPPING";
+})(VectorEnrichmentJobStatus || (VectorEnrichmentJobStatus = {}));
+export var VectorEnrichmentJobType;
+(function (VectorEnrichmentJobType) {
+    VectorEnrichmentJobType["MAP_MATCHING"] = "MAP_MATCHING";
+    VectorEnrichmentJobType["REVERSE_GEOCODING"] = "REVERSE_GEOCODING";
+})(VectorEnrichmentJobType || (VectorEnrichmentJobType = {}));
+export const MultiPolygonGeometryInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Coordinates && { Coordinates: obj.Coordinates.map((item) => item.map((item) => SENSITIVE_STRING)) }),
+});
+export const PolygonGeometryInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Coordinates && { Coordinates: obj.Coordinates.map((item) => SENSITIVE_STRING) }),
+});
+export const AreaOfInterestGeometryFilterSensitiveLog = (obj) => {
+    if (obj.PolygonGeometry !== undefined)
+        return { PolygonGeometry: PolygonGeometryInputFilterSensitiveLog(obj.PolygonGeometry) };
+    if (obj.MultiPolygonGeometry !== undefined)
+        return { MultiPolygonGeometry: MultiPolygonGeometryInputFilterSensitiveLog(obj.MultiPolygonGeometry) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const AreaOfInterestFilterSensitiveLog = (obj) => {
+    if (obj.AreaOfInterestGeometry !== undefined)
+        return { AreaOfInterestGeometry: AreaOfInterestGeometryFilterSensitiveLog(obj.AreaOfInterestGeometry) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const AssetValueFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const OperationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CustomIndicesInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const BandMathConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CloudMaskingConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CloudRemovalConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const FilterFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const RasterDataCollectionMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteEarthObservationJobInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteEarthObservationJobOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteVectorEnrichmentJobInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteVectorEnrichmentJobOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ExportS3DataInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const OutputConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ExportEarthObservationJobInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ExportEarthObservationJobOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetEarthObservationJobInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const EarthObservationJobErrorDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ExportErrorDetailsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ExportErrorDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const S3DataInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const EojDataSourceConfigInputFilterSensitiveLog = (obj) => {
+    if (obj.S3Data !== undefined)
+        return { S3Data: S3DataInputFilterSensitiveLog(obj.S3Data) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const EoCloudCoverInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const LandsatCloudCoverLandInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PlatformInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ViewOffNadirInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ViewSunAzimuthInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ViewSunElevationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PropertyFilterSensitiveLog = (obj) => {
+    if (obj.EoCloudCover !== undefined)
+        return { EoCloudCover: EoCloudCoverInputFilterSensitiveLog(obj.EoCloudCover) };
+    if (obj.ViewOffNadir !== undefined)
+        return { ViewOffNadir: ViewOffNadirInputFilterSensitiveLog(obj.ViewOffNadir) };
+    if (obj.ViewSunAzimuth !== undefined)
+        return { ViewSunAzimuth: ViewSunAzimuthInputFilterSensitiveLog(obj.ViewSunAzimuth) };
+    if (obj.ViewSunElevation !== undefined)
+        return { ViewSunElevation: ViewSunElevationInputFilterSensitiveLog(obj.ViewSunElevation) };
+    if (obj.Platform !== undefined)
+        return { Platform: PlatformInputFilterSensitiveLog(obj.Platform) };
+    if (obj.LandsatCloudCoverLand !== undefined)
+        return { LandsatCloudCoverLand: LandsatCloudCoverLandInputFilterSensitiveLog(obj.LandsatCloudCoverLand) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const PropertyFilterFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Property && { Property: PropertyFilterSensitiveLog(obj.Property) }),
+});
+export const PropertyFiltersFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Properties && { Properties: obj.Properties.map((item) => PropertyFilterFilterSensitiveLog(item)) }),
+});
+export const TimeRangeFilterInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const RasterDataCollectionQueryOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.TimeRangeFilter && { TimeRangeFilter: SENSITIVE_STRING }),
+    ...(obj.AreaOfInterest && { AreaOfInterest: AreaOfInterestFilterSensitiveLog(obj.AreaOfInterest) }),
+    ...(obj.PropertyFilters && { PropertyFilters: PropertyFiltersFilterSensitiveLog(obj.PropertyFilters) }),
+});
+export const InputConfigOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.DataSourceConfig && { DataSourceConfig: EojDataSourceConfigInputFilterSensitiveLog(obj.DataSourceConfig) }),
+    ...(obj.RasterDataCollectionQuery && {
+        RasterDataCollectionQuery: RasterDataCollectionQueryOutputFilterSensitiveLog(obj.RasterDataCollectionQuery),
+    }),
+});
+export const GeoMosaicConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const LandCoverSegmentationConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UserDefinedFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const OutputResolutionResamplingInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ResamplingConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const OutputResolutionStackInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const StackConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const TemporalStatisticsConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ZonalStatisticsConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const JobConfigInputFilterSensitiveLog = (obj) => {
+    if (obj.BandMathConfig !== undefined)
+        return { BandMathConfig: BandMathConfigInputFilterSensitiveLog(obj.BandMathConfig) };
+    if (obj.ResamplingConfig !== undefined)
+        return { ResamplingConfig: ResamplingConfigInputFilterSensitiveLog(obj.ResamplingConfig) };
+    if (obj.TemporalStatisticsConfig !== undefined)
+        return { TemporalStatisticsConfig: TemporalStatisticsConfigInputFilterSensitiveLog(obj.TemporalStatisticsConfig) };
+    if (obj.CloudRemovalConfig !== undefined)
+        return { CloudRemovalConfig: CloudRemovalConfigInputFilterSensitiveLog(obj.CloudRemovalConfig) };
+    if (obj.ZonalStatisticsConfig !== undefined)
+        return { ZonalStatisticsConfig: ZonalStatisticsConfigInputFilterSensitiveLog(obj.ZonalStatisticsConfig) };
+    if (obj.GeoMosaicConfig !== undefined)
+        return { GeoMosaicConfig: GeoMosaicConfigInputFilterSensitiveLog(obj.GeoMosaicConfig) };
+    if (obj.StackConfig !== undefined)
+        return { StackConfig: StackConfigInputFilterSensitiveLog(obj.StackConfig) };
+    if (obj.CloudMaskingConfig !== undefined)
+        return { CloudMaskingConfig: CloudMaskingConfigInputFilterSensitiveLog(obj.CloudMaskingConfig) };
+    if (obj.LandCoverSegmentationConfig !== undefined)
+        return {
+            LandCoverSegmentationConfig: LandCoverSegmentationConfigInputFilterSensitiveLog(obj.LandCoverSegmentationConfig),
+        };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const OutputBandFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetEarthObservationJobOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.InputConfig && { InputConfig: InputConfigOutputFilterSensitiveLog(obj.InputConfig) }),
+    ...(obj.JobConfig && { JobConfig: JobConfigInputFilterSensitiveLog(obj.JobConfig) }),
+});
+export const GetTileInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetTileOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListEarthObservationJobInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.NextToken && { NextToken: SENSITIVE_STRING }),
+});
+export const ListEarthObservationJobOutputConfigFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListEarthObservationJobOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.NextToken && { NextToken: SENSITIVE_STRING }),
+});
+export const RasterDataCollectionQueryInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.TimeRangeFilter && { TimeRangeFilter: SENSITIVE_STRING }),
+    ...(obj.AreaOfInterest && { AreaOfInterest: AreaOfInterestFilterSensitiveLog(obj.AreaOfInterest) }),
+    ...(obj.PropertyFilters && { PropertyFilters: PropertyFiltersFilterSensitiveLog(obj.PropertyFilters) }),
+});
+export const InputConfigInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.DataSourceConfig && { DataSourceConfig: EojDataSourceConfigInputFilterSensitiveLog(obj.DataSourceConfig) }),
+    ...(obj.RasterDataCollectionQuery && {
+        RasterDataCollectionQuery: RasterDataCollectionQueryInputFilterSensitiveLog(obj.RasterDataCollectionQuery),
+    }),
+});
+export const StartEarthObservationJobInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.InputConfig && { InputConfig: InputConfigInputFilterSensitiveLog(obj.InputConfig) }),
+    ...(obj.JobConfig && { JobConfig: JobConfigInputFilterSensitiveLog(obj.JobConfig) }),
+});
+export const StartEarthObservationJobOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.InputConfig && { InputConfig: InputConfigOutputFilterSensitiveLog(obj.InputConfig) }),
+    ...(obj.JobConfig && { JobConfig: JobConfigInputFilterSensitiveLog(obj.JobConfig) }),
+});
+export const StopEarthObservationJobInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const StopEarthObservationJobOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const VectorEnrichmentJobS3DataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ExportVectorEnrichmentJobOutputConfigFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ExportVectorEnrichmentJobInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ExportVectorEnrichmentJobOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GeometryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Coordinates && { Coordinates: obj.Coordinates.map((item) => SENSITIVE_STRING) }),
+});
+export const GetRasterDataCollectionInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetRasterDataCollectionOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetVectorEnrichmentJobInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const VectorEnrichmentJobErrorDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const VectorEnrichmentJobExportErrorDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const VectorEnrichmentJobDataSourceConfigInputFilterSensitiveLog = (obj) => {
+    if (obj.S3Data !== undefined)
+        return { S3Data: VectorEnrichmentJobS3DataFilterSensitiveLog(obj.S3Data) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const VectorEnrichmentJobInputConfigFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.DataSourceConfig && {
+        DataSourceConfig: VectorEnrichmentJobDataSourceConfigInputFilterSensitiveLog(obj.DataSourceConfig),
+    }),
+});
+export const MapMatchingConfigFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ReverseGeocodingConfigFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const VectorEnrichmentJobConfigFilterSensitiveLog = (obj) => {
+    if (obj.ReverseGeocodingConfig !== undefined)
+        return { ReverseGeocodingConfig: ReverseGeocodingConfigFilterSensitiveLog(obj.ReverseGeocodingConfig) };
+    if (obj.MapMatchingConfig !== undefined)
+        return { MapMatchingConfig: MapMatchingConfigFilterSensitiveLog(obj.MapMatchingConfig) };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const GetVectorEnrichmentJobOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.InputConfig && { InputConfig: VectorEnrichmentJobInputConfigFilterSensitiveLog(obj.InputConfig) }),
+    ...(obj.JobConfig && { JobConfig: VectorEnrichmentJobConfigFilterSensitiveLog(obj.JobConfig) }),
+});
+export const PropertiesFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ItemSourceFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Geometry && { Geometry: GeometryFilterSensitiveLog(obj.Geometry) }),
+});
+export const ListRasterDataCollectionsInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.NextToken && { NextToken: SENSITIVE_STRING }),
+});
+export const ListRasterDataCollectionsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.NextToken && { NextToken: SENSITIVE_STRING }),
+});
+export const ListTagsForResourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListTagsForResourceResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListVectorEnrichmentJobInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.NextToken && { NextToken: SENSITIVE_STRING }),
+});
+export const ListVectorEnrichmentJobOutputConfigFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListVectorEnrichmentJobOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.NextToken && { NextToken: SENSITIVE_STRING }),
+});
+export const RasterDataCollectionQueryWithBandFilterInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.TimeRangeFilter && { TimeRangeFilter: SENSITIVE_STRING }),
+    ...(obj.AreaOfInterest && { AreaOfInterest: AreaOfInterestFilterSensitiveLog(obj.AreaOfInterest) }),
+    ...(obj.PropertyFilters && { PropertyFilters: PropertyFiltersFilterSensitiveLog(obj.PropertyFilters) }),
+});
+export const SearchRasterDataCollectionInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.RasterDataCollectionQuery && {
+        RasterDataCollectionQuery: RasterDataCollectionQueryWithBandFilterInputFilterSensitiveLog(obj.RasterDataCollectionQuery),
+    }),
+    ...(obj.NextToken && { NextToken: SENSITIVE_STRING }),
+});
+export const SearchRasterDataCollectionOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.NextToken && { NextToken: SENSITIVE_STRING }),
+    ...(obj.Items && { Items: obj.Items.map((item) => ItemSourceFilterSensitiveLog(item)) }),
+});
+export const TagResourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const TagResourceResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UntagResourceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UntagResourceResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const StartVectorEnrichmentJobInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.InputConfig && { InputConfig: VectorEnrichmentJobInputConfigFilterSensitiveLog(obj.InputConfig) }),
+    ...(obj.JobConfig && { JobConfig: VectorEnrichmentJobConfigFilterSensitiveLog(obj.JobConfig) }),
+});
+export const StartVectorEnrichmentJobOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.InputConfig && { InputConfig: VectorEnrichmentJobInputConfigFilterSensitiveLog(obj.InputConfig) }),
+    ...(obj.JobConfig && { JobConfig: VectorEnrichmentJobConfigFilterSensitiveLog(obj.JobConfig) }),
+});
+export const StopVectorEnrichmentJobInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const StopVectorEnrichmentJobOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});