import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.ts";
import * as T from "../traits.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type Arn = string;
export type KmsKey = string;
export type EarthObservationJobArn = string;
export type DataCollectionArn = string;
export type ComparisonOperator = string;
export type LogicalOperator = string;
export type OutputType = string;
export type Unit = string;
export type AlgorithmNameResampling = string;
export type GroupBy = string;
export type TemporalStatistics = string;
export type AlgorithmNameCloudRemoval = string;
export type S3Uri = string;
export type ZonalStatistics = string;
export type AlgorithmNameGeoMosaic = string;
export type PredefinedResolution = string;
export type ExecutionRoleArn = string;
export type EarthObservationJobStatus = string;
export type EarthObservationJobErrorType = string;
export type EarthObservationJobExportStatus = string;
export type ExportErrorType = string;
export type SortOrder = string;
export type NextToken = string | redacted.Redacted<string>;
export type TargetOptions = string;
export type DataCollectionType = string;
export type VectorEnrichmentJobDocumentType = string;
export type VectorEnrichmentJobArn = string;
export type VectorEnrichmentJobType = string;
export type VectorEnrichmentJobStatus = string;
export type VectorEnrichmentJobErrorType = string;
export type VectorEnrichmentJobExportStatus = string;
export type VectorEnrichmentJobExportErrorType = string;
export interface ListTagsForResourceRequest {
    ResourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export type Tags = {
    [key: string]: string | undefined;
};
export declare const Tags: S.$Record<S.String, S.optional<S.String>>;
export interface ListTagsForResourceResponse {
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export interface TagResourceRequest {
    ResourceArn: string;
    Tags: {
        [key: string]: string | undefined;
    };
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type TagKeyList = string[];
export declare const TagKeyList: S.$Array<S.String>;
export interface UntagResourceRequest {
    ResourceArn: string;
    TagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
export interface TimeRangeFilterInput {
    StartTime: Date;
    EndTime: Date;
}
export declare const TimeRangeFilterInput: S.Schema<TimeRangeFilterInput>;
export type Position = number[];
export declare const Position: S.$Array<S.Number>;
export type LinearRing = number[][];
export declare const LinearRing: S.$Array<S.$Array<S.Number>>;
export type LinearRings = number[][][];
export declare const LinearRings: S.$Array<S.$Array<S.$Array<S.Number>>>;
export interface PolygonGeometryInput {
    Coordinates: number[][][];
}
export declare const PolygonGeometryInput: S.Schema<PolygonGeometryInput>;
export type LinearRingsList = number[][][][];
export declare const LinearRingsList: S.$Array<S.$Array<S.$Array<S.$Array<S.Number>>>>;
export interface MultiPolygonGeometryInput {
    Coordinates: number[][][][];
}
export declare const MultiPolygonGeometryInput: S.Schema<MultiPolygonGeometryInput>;
export type AreaOfInterestGeometry = {
    PolygonGeometry: PolygonGeometryInput;
    MultiPolygonGeometry?: never;
} | {
    PolygonGeometry?: never;
    MultiPolygonGeometry: MultiPolygonGeometryInput;
};
export declare const AreaOfInterestGeometry: S.Union<readonly [S.Struct<{
    readonly PolygonGeometry: S.Schema<PolygonGeometryInput>;
}>, S.Struct<{
    readonly MultiPolygonGeometry: S.Schema<MultiPolygonGeometryInput>;
}>]>;
export type AreaOfInterest = {
    AreaOfInterestGeometry: AreaOfInterestGeometry;
};
export declare const AreaOfInterest: S.Union<readonly [S.Struct<{
    readonly AreaOfInterestGeometry: S.Union<readonly [S.Struct<{
        readonly PolygonGeometry: S.Schema<PolygonGeometryInput>;
    }>, S.Struct<{
        readonly MultiPolygonGeometry: S.Schema<MultiPolygonGeometryInput>;
    }>]>;
}>]>;
export interface EoCloudCoverInput {
    LowerBound: number;
    UpperBound: number;
}
export declare const EoCloudCoverInput: S.Schema<EoCloudCoverInput>;
export interface ViewOffNadirInput {
    LowerBound: number;
    UpperBound: number;
}
export declare const ViewOffNadirInput: S.Schema<ViewOffNadirInput>;
export interface ViewSunAzimuthInput {
    LowerBound: number;
    UpperBound: number;
}
export declare const ViewSunAzimuthInput: S.Schema<ViewSunAzimuthInput>;
export interface ViewSunElevationInput {
    LowerBound: number;
    UpperBound: number;
}
export declare const ViewSunElevationInput: S.Schema<ViewSunElevationInput>;
export interface PlatformInput {
    Value: string;
    ComparisonOperator?: string;
}
export declare const PlatformInput: S.Schema<PlatformInput>;
export interface LandsatCloudCoverLandInput {
    LowerBound: number;
    UpperBound: number;
}
export declare const LandsatCloudCoverLandInput: S.Schema<LandsatCloudCoverLandInput>;
export type Property = {
    EoCloudCover: EoCloudCoverInput;
    ViewOffNadir?: never;
    ViewSunAzimuth?: never;
    ViewSunElevation?: never;
    Platform?: never;
    LandsatCloudCoverLand?: never;
} | {
    EoCloudCover?: never;
    ViewOffNadir: ViewOffNadirInput;
    ViewSunAzimuth?: never;
    ViewSunElevation?: never;
    Platform?: never;
    LandsatCloudCoverLand?: never;
} | {
    EoCloudCover?: never;
    ViewOffNadir?: never;
    ViewSunAzimuth: ViewSunAzimuthInput;
    ViewSunElevation?: never;
    Platform?: never;
    LandsatCloudCoverLand?: never;
} | {
    EoCloudCover?: never;
    ViewOffNadir?: never;
    ViewSunAzimuth?: never;
    ViewSunElevation: ViewSunElevationInput;
    Platform?: never;
    LandsatCloudCoverLand?: never;
} | {
    EoCloudCover?: never;
    ViewOffNadir?: never;
    ViewSunAzimuth?: never;
    ViewSunElevation?: never;
    Platform: PlatformInput;
    LandsatCloudCoverLand?: never;
} | {
    EoCloudCover?: never;
    ViewOffNadir?: never;
    ViewSunAzimuth?: never;
    ViewSunElevation?: never;
    Platform?: never;
    LandsatCloudCoverLand: LandsatCloudCoverLandInput;
};
export declare const Property: S.Union<readonly [S.Struct<{
    readonly EoCloudCover: S.Schema<EoCloudCoverInput>;
}>, S.Struct<{
    readonly ViewOffNadir: S.Schema<ViewOffNadirInput>;
}>, S.Struct<{
    readonly ViewSunAzimuth: S.Schema<ViewSunAzimuthInput>;
}>, S.Struct<{
    readonly ViewSunElevation: S.Schema<ViewSunElevationInput>;
}>, S.Struct<{
    readonly Platform: S.Schema<PlatformInput>;
}>, S.Struct<{
    readonly LandsatCloudCoverLand: S.Schema<LandsatCloudCoverLandInput>;
}>]>;
export interface PropertyFilter {
    Property: Property;
}
export declare const PropertyFilter: S.Schema<PropertyFilter>;
export type PropertyFiltersList = PropertyFilter[];
export declare const PropertyFiltersList: S.$Array<S.Schema<PropertyFilter>>;
export interface PropertyFilters {
    Properties?: PropertyFilter[];
    LogicalOperator?: string;
}
export declare const PropertyFilters: S.Schema<PropertyFilters>;
export interface RasterDataCollectionQueryInput {
    RasterDataCollectionArn: string;
    TimeRangeFilter: TimeRangeFilterInput;
    AreaOfInterest?: AreaOfInterest;
    PropertyFilters?: PropertyFilters;
}
export declare const RasterDataCollectionQueryInput: S.Schema<RasterDataCollectionQueryInput>;
export interface InputConfigInput {
    PreviousEarthObservationJobArn?: string;
    RasterDataCollectionQuery?: RasterDataCollectionQueryInput;
}
export declare const InputConfigInput: S.Schema<InputConfigInput>;
export type StringListInput = string[];
export declare const StringListInput: S.$Array<S.String>;
export interface Operation {
    Name: string;
    Equation: string;
    OutputType?: string;
}
export declare const Operation: S.Schema<Operation>;
export type OperationsListInput = Operation[];
export declare const OperationsListInput: S.$Array<S.Schema<Operation>>;
export interface CustomIndicesInput {
    Operations?: Operation[];
}
export declare const CustomIndicesInput: S.Schema<CustomIndicesInput>;
export interface BandMathConfigInput {
    PredefinedIndices?: string[];
    CustomIndices?: CustomIndicesInput;
}
export declare const BandMathConfigInput: S.Schema<BandMathConfigInput>;
export interface UserDefined {
    Value: number;
    Unit: string;
}
export declare const UserDefined: S.Schema<UserDefined>;
export interface OutputResolutionResamplingInput {
    UserDefined: UserDefined;
}
export declare const OutputResolutionResamplingInput: S.Schema<OutputResolutionResamplingInput>;
export interface ResamplingConfigInput {
    OutputResolution: OutputResolutionResamplingInput;
    AlgorithmName?: string;
    TargetBands?: string[];
}
export declare const ResamplingConfigInput: S.Schema<ResamplingConfigInput>;
export type TemporalStatisticsListInput = string[];
export declare const TemporalStatisticsListInput: S.$Array<S.String>;
export interface TemporalStatisticsConfigInput {
    GroupBy?: string;
    Statistics: string[];
    TargetBands?: string[];
}
export declare const TemporalStatisticsConfigInput: S.Schema<TemporalStatisticsConfigInput>;
export interface CloudRemovalConfigInput {
    AlgorithmName?: string;
    InterpolationValue?: string;
    TargetBands?: string[];
}
export declare const CloudRemovalConfigInput: S.Schema<CloudRemovalConfigInput>;
export type ZonalStatisticsListInput = string[];
export declare const ZonalStatisticsListInput: S.$Array<S.String>;
export interface ZonalStatisticsConfigInput {
    ZoneS3Path: string;
    Statistics: string[];
    TargetBands?: string[];
    ZoneS3PathKmsKeyId?: string;
}
export declare const ZonalStatisticsConfigInput: S.Schema<ZonalStatisticsConfigInput>;
export interface GeoMosaicConfigInput {
    AlgorithmName?: string;
    TargetBands?: string[];
}
export declare const GeoMosaicConfigInput: S.Schema<GeoMosaicConfigInput>;
export interface OutputResolutionStackInput {
    Predefined?: string;
    UserDefined?: UserDefined;
}
export declare const OutputResolutionStackInput: S.Schema<OutputResolutionStackInput>;
export interface StackConfigInput {
    OutputResolution?: OutputResolutionStackInput;
    TargetBands?: string[];
}
export declare const StackConfigInput: S.Schema<StackConfigInput>;
export interface CloudMaskingConfigInput {
}
export declare const CloudMaskingConfigInput: S.Schema<CloudMaskingConfigInput>;
export interface LandCoverSegmentationConfigInput {
}
export declare const LandCoverSegmentationConfigInput: S.Schema<LandCoverSegmentationConfigInput>;
export type JobConfigInput = {
    BandMathConfig: BandMathConfigInput;
    ResamplingConfig?: never;
    TemporalStatisticsConfig?: never;
    CloudRemovalConfig?: never;
    ZonalStatisticsConfig?: never;
    GeoMosaicConfig?: never;
    StackConfig?: never;
    CloudMaskingConfig?: never;
    LandCoverSegmentationConfig?: never;
} | {
    BandMathConfig?: never;
    ResamplingConfig: ResamplingConfigInput;
    TemporalStatisticsConfig?: never;
    CloudRemovalConfig?: never;
    ZonalStatisticsConfig?: never;
    GeoMosaicConfig?: never;
    StackConfig?: never;
    CloudMaskingConfig?: never;
    LandCoverSegmentationConfig?: never;
} | {
    BandMathConfig?: never;
    ResamplingConfig?: never;
    TemporalStatisticsConfig: TemporalStatisticsConfigInput;
    CloudRemovalConfig?: never;
    ZonalStatisticsConfig?: never;
    GeoMosaicConfig?: never;
    StackConfig?: never;
    CloudMaskingConfig?: never;
    LandCoverSegmentationConfig?: never;
} | {
    BandMathConfig?: never;
    ResamplingConfig?: never;
    TemporalStatisticsConfig?: never;
    CloudRemovalConfig: CloudRemovalConfigInput;
    ZonalStatisticsConfig?: never;
    GeoMosaicConfig?: never;
    StackConfig?: never;
    CloudMaskingConfig?: never;
    LandCoverSegmentationConfig?: never;
} | {
    BandMathConfig?: never;
    ResamplingConfig?: never;
    TemporalStatisticsConfig?: never;
    CloudRemovalConfig?: never;
    ZonalStatisticsConfig: ZonalStatisticsConfigInput;
    GeoMosaicConfig?: never;
    StackConfig?: never;
    CloudMaskingConfig?: never;
    LandCoverSegmentationConfig?: never;
} | {
    BandMathConfig?: never;
    ResamplingConfig?: never;
    TemporalStatisticsConfig?: never;
    CloudRemovalConfig?: never;
    ZonalStatisticsConfig?: never;
    GeoMosaicConfig: GeoMosaicConfigInput;
    StackConfig?: never;
    CloudMaskingConfig?: never;
    LandCoverSegmentationConfig?: never;
} | {
    BandMathConfig?: never;
    ResamplingConfig?: never;
    TemporalStatisticsConfig?: never;
    CloudRemovalConfig?: never;
    ZonalStatisticsConfig?: never;
    GeoMosaicConfig?: never;
    StackConfig: StackConfigInput;
    CloudMaskingConfig?: never;
    LandCoverSegmentationConfig?: never;
} | {
    BandMathConfig?: never;
    ResamplingConfig?: never;
    TemporalStatisticsConfig?: never;
    CloudRemovalConfig?: never;
    ZonalStatisticsConfig?: never;
    GeoMosaicConfig?: never;
    StackConfig?: never;
    CloudMaskingConfig: CloudMaskingConfigInput;
    LandCoverSegmentationConfig?: never;
} | {
    BandMathConfig?: never;
    ResamplingConfig?: never;
    TemporalStatisticsConfig?: never;
    CloudRemovalConfig?: never;
    ZonalStatisticsConfig?: never;
    GeoMosaicConfig?: never;
    StackConfig?: never;
    CloudMaskingConfig?: never;
    LandCoverSegmentationConfig: LandCoverSegmentationConfigInput;
};
export declare const JobConfigInput: S.Union<readonly [S.Struct<{
    readonly BandMathConfig: S.Schema<BandMathConfigInput>;
}>, S.Struct<{
    readonly ResamplingConfig: S.Schema<ResamplingConfigInput>;
}>, S.Struct<{
    readonly TemporalStatisticsConfig: S.Schema<TemporalStatisticsConfigInput>;
}>, S.Struct<{
    readonly CloudRemovalConfig: S.Schema<CloudRemovalConfigInput>;
}>, S.Struct<{
    readonly ZonalStatisticsConfig: S.Schema<ZonalStatisticsConfigInput>;
}>, S.Struct<{
    readonly GeoMosaicConfig: S.Schema<GeoMosaicConfigInput>;
}>, S.Struct<{
    readonly StackConfig: S.Schema<StackConfigInput>;
}>, S.Struct<{
    readonly CloudMaskingConfig: S.Schema<CloudMaskingConfigInput>;
}>, S.Struct<{
    readonly LandCoverSegmentationConfig: S.Schema<LandCoverSegmentationConfigInput>;
}>]>;
export interface StartEarthObservationJobInput {
    Name: string;
    ClientToken?: string;
    KmsKeyId?: string;
    InputConfig: InputConfigInput;
    JobConfig: JobConfigInput;
    ExecutionRoleArn: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const StartEarthObservationJobInput: S.Schema<StartEarthObservationJobInput>;
export interface TimeRangeFilterOutput {
    StartTime: Date;
    EndTime: Date;
}
export declare const TimeRangeFilterOutput: S.Schema<TimeRangeFilterOutput>;
export interface RasterDataCollectionQueryOutput {
    RasterDataCollectionArn: string;
    RasterDataCollectionName: string;
    TimeRangeFilter: TimeRangeFilterOutput;
    AreaOfInterest?: AreaOfInterest;
    PropertyFilters?: PropertyFilters;
}
export declare const RasterDataCollectionQueryOutput: S.Schema<RasterDataCollectionQueryOutput>;
export interface InputConfigOutput {
    PreviousEarthObservationJobArn?: string;
    RasterDataCollectionQuery?: RasterDataCollectionQueryOutput;
}
export declare const InputConfigOutput: S.Schema<InputConfigOutput>;
export interface StartEarthObservationJobOutput {
    Name: string;
    Arn: string;
    CreationTime: Date;
    DurationInSeconds: number;
    Status: string;
    KmsKeyId?: string;
    InputConfig?: InputConfigOutput;
    JobConfig: JobConfigInput;
    ExecutionRoleArn: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const StartEarthObservationJobOutput: S.Schema<StartEarthObservationJobOutput>;
export interface GetEarthObservationJobInput {
    Arn: string;
}
export declare const GetEarthObservationJobInput: S.Schema<GetEarthObservationJobInput>;
export interface OutputBand {
    BandName: string;
    OutputDataType: string;
}
export declare const OutputBand: S.Schema<OutputBand>;
export type EarthObservationJobOutputBands = OutputBand[];
export declare const EarthObservationJobOutputBands: S.$Array<S.Schema<OutputBand>>;
export interface EarthObservationJobErrorDetails {
    Type?: string;
    Message?: string;
}
export declare const EarthObservationJobErrorDetails: S.Schema<EarthObservationJobErrorDetails>;
export interface ExportErrorDetailsOutput {
    Type?: string;
    Message?: string;
}
export declare const ExportErrorDetailsOutput: S.Schema<ExportErrorDetailsOutput>;
export interface ExportErrorDetails {
    ExportResults?: ExportErrorDetailsOutput;
    ExportSourceImages?: ExportErrorDetailsOutput;
}
export declare const ExportErrorDetails: S.Schema<ExportErrorDetails>;
export interface GetEarthObservationJobOutput {
    Arn: string;
    Name: string;
    CreationTime: Date;
    DurationInSeconds: number;
    Status: string;
    KmsKeyId?: string;
    InputConfig: InputConfigOutput;
    JobConfig: JobConfigInput;
    OutputBands?: OutputBand[];
    ExecutionRoleArn?: string;
    ErrorDetails?: EarthObservationJobErrorDetails;
    ExportStatus?: string;
    ExportErrorDetails?: ExportErrorDetails;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const GetEarthObservationJobOutput: S.Schema<GetEarthObservationJobOutput>;
export interface DeleteEarthObservationJobInput {
    Arn: string;
}
export declare const DeleteEarthObservationJobInput: S.Schema<DeleteEarthObservationJobInput>;
export interface DeleteEarthObservationJobOutput {
}
export declare const DeleteEarthObservationJobOutput: S.Schema<DeleteEarthObservationJobOutput>;
export interface ListEarthObservationJobInput {
    StatusEquals?: string;
    SortOrder?: string;
    SortBy?: string;
    NextToken?: string | redacted.Redacted<string>;
    MaxResults?: number;
}
export declare const ListEarthObservationJobInput: S.Schema<ListEarthObservationJobInput>;
export interface ListEarthObservationJobOutputConfig {
    Arn: string;
    Name: string;
    CreationTime: Date;
    DurationInSeconds: number;
    Status: string;
    OperationType: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListEarthObservationJobOutputConfig: S.Schema<ListEarthObservationJobOutputConfig>;
export type EarthObservationJobList = ListEarthObservationJobOutputConfig[];
export declare const EarthObservationJobList: S.$Array<S.Schema<ListEarthObservationJobOutputConfig>>;
export interface ListEarthObservationJobOutput {
    EarthObservationJobSummaries: ListEarthObservationJobOutputConfig[];
    NextToken?: string | redacted.Redacted<string>;
}
export declare const ListEarthObservationJobOutput: S.Schema<ListEarthObservationJobOutput>;
export interface ExportS3DataInput {
    S3Uri: string;
    KmsKeyId?: string;
}
export declare const ExportS3DataInput: S.Schema<ExportS3DataInput>;
export interface OutputConfigInput {
    S3Data: ExportS3DataInput;
}
export declare const OutputConfigInput: S.Schema<OutputConfigInput>;
export interface ExportEarthObservationJobInput {
    Arn: string;
    ClientToken?: string;
    ExecutionRoleArn: string;
    OutputConfig: OutputConfigInput;
    ExportSourceImages?: boolean;
}
export declare const ExportEarthObservationJobInput: S.Schema<ExportEarthObservationJobInput>;
export interface ExportEarthObservationJobOutput {
    Arn: string;
    CreationTime: Date;
    ExportStatus: string;
    ExecutionRoleArn: string;
    OutputConfig: OutputConfigInput;
    ExportSourceImages?: boolean;
}
export declare const ExportEarthObservationJobOutput: S.Schema<ExportEarthObservationJobOutput>;
export interface GetTileInput {
    x: number;
    y: number;
    z: number;
    ImageAssets: string[];
    Target: string;
    Arn: string;
    ImageMask?: boolean;
    OutputFormat?: string;
    TimeRangeFilter?: string;
    PropertyFilters?: string;
    OutputDataType?: string;
    ExecutionRoleArn?: string;
}
export declare const GetTileInput: S.Schema<GetTileInput>;
export interface GetTileOutput {
    BinaryFile?: T.StreamingOutputBody;
}
export declare const GetTileOutput: S.Schema<GetTileOutput>;
export interface StopEarthObservationJobInput {
    Arn: string;
}
export declare const StopEarthObservationJobInput: S.Schema<StopEarthObservationJobInput>;
export interface StopEarthObservationJobOutput {
}
export declare const StopEarthObservationJobOutput: S.Schema<StopEarthObservationJobOutput>;
export interface GetRasterDataCollectionInput {
    Arn: string;
}
export declare const GetRasterDataCollectionInput: S.Schema<GetRasterDataCollectionInput>;
export interface Filter {
    Name: string;
    Type: string;
    Minimum?: number;
    Maximum?: number;
}
export declare const Filter: S.Schema<Filter>;
export type FilterList = Filter[];
export declare const FilterList: S.$Array<S.Schema<Filter>>;
export type ImageSourceBandList = string[];
export declare const ImageSourceBandList: S.$Array<S.String>;
export interface GetRasterDataCollectionOutput {
    Name: string;
    Arn: string;
    Type: string;
    Description: string;
    DescriptionPageUrl: string;
    SupportedFilters: Filter[];
    ImageSourceBands: string[];
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const GetRasterDataCollectionOutput: S.Schema<GetRasterDataCollectionOutput>;
export interface ListRasterDataCollectionsInput {
    NextToken?: string | redacted.Redacted<string>;
    MaxResults?: number;
}
export declare const ListRasterDataCollectionsInput: S.Schema<ListRasterDataCollectionsInput>;
export interface RasterDataCollectionMetadata {
    Name: string;
    Arn: string;
    Type: string;
    Description: string;
    DescriptionPageUrl?: string;
    SupportedFilters: Filter[];
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const RasterDataCollectionMetadata: S.Schema<RasterDataCollectionMetadata>;
export type DataCollectionsList = RasterDataCollectionMetadata[];
export declare const DataCollectionsList: S.$Array<S.Schema<RasterDataCollectionMetadata>>;
export interface ListRasterDataCollectionsOutput {
    RasterDataCollectionSummaries: RasterDataCollectionMetadata[];
    NextToken?: string | redacted.Redacted<string>;
}
export declare const ListRasterDataCollectionsOutput: S.Schema<ListRasterDataCollectionsOutput>;
export interface RasterDataCollectionQueryWithBandFilterInput {
    TimeRangeFilter: TimeRangeFilterInput;
    AreaOfInterest?: AreaOfInterest;
    PropertyFilters?: PropertyFilters;
    BandFilter?: string[];
}
export declare const RasterDataCollectionQueryWithBandFilterInput: S.Schema<RasterDataCollectionQueryWithBandFilterInput>;
export interface SearchRasterDataCollectionInput {
    Arn: string;
    RasterDataCollectionQuery: RasterDataCollectionQueryWithBandFilterInput;
    NextToken?: string | redacted.Redacted<string>;
}
export declare const SearchRasterDataCollectionInput: S.Schema<SearchRasterDataCollectionInput>;
export interface Geometry {
    Type: string;
    Coordinates: number[][][];
}
export declare const Geometry: S.Schema<Geometry>;
export interface AssetValue {
    Href?: string;
}
export declare const AssetValue: S.Schema<AssetValue>;
export type AssetsMap = {
    [key: string]: AssetValue | undefined;
};
export declare const AssetsMap: S.$Record<S.String, S.optional<S.Schema<AssetValue>>>;
export interface Properties {
    EoCloudCover?: number;
    ViewOffNadir?: number;
    ViewSunAzimuth?: number;
    ViewSunElevation?: number;
    Platform?: string;
    LandsatCloudCoverLand?: number;
}
export declare const Properties: S.Schema<Properties>;
export interface ItemSource {
    Id: string;
    Geometry: Geometry;
    Assets?: {
        [key: string]: AssetValue | undefined;
    };
    DateTime: Date;
    Properties?: Properties;
}
export declare const ItemSource: S.Schema<ItemSource>;
export type ItemSourceList = ItemSource[];
export declare const ItemSourceList: S.$Array<S.Schema<ItemSource>>;
export interface SearchRasterDataCollectionOutput {
    ApproximateResultCount: number;
    NextToken?: string | redacted.Redacted<string>;
    Items?: ItemSource[];
}
export declare const SearchRasterDataCollectionOutput: S.Schema<SearchRasterDataCollectionOutput>;
export interface VectorEnrichmentJobS3Data {
    S3Uri: string;
    KmsKeyId?: string;
}
export declare const VectorEnrichmentJobS3Data: S.Schema<VectorEnrichmentJobS3Data>;
export type VectorEnrichmentJobDataSourceConfigInput = {
    S3Data: VectorEnrichmentJobS3Data;
};
export declare const VectorEnrichmentJobDataSourceConfigInput: S.Union<readonly [S.Struct<{
    readonly S3Data: S.Schema<VectorEnrichmentJobS3Data>;
}>]>;
export interface VectorEnrichmentJobInputConfig {
    DocumentType: string;
    DataSourceConfig: VectorEnrichmentJobDataSourceConfigInput;
}
export declare const VectorEnrichmentJobInputConfig: S.Schema<VectorEnrichmentJobInputConfig>;
export interface ReverseGeocodingConfig {
    YAttributeName: string;
    XAttributeName: string;
}
export declare const ReverseGeocodingConfig: S.Schema<ReverseGeocodingConfig>;
export interface MapMatchingConfig {
    IdAttributeName: string;
    YAttributeName: string;
    XAttributeName: string;
    TimestampAttributeName: string;
}
export declare const MapMatchingConfig: S.Schema<MapMatchingConfig>;
export type VectorEnrichmentJobConfig = {
    ReverseGeocodingConfig: ReverseGeocodingConfig;
    MapMatchingConfig?: never;
} | {
    ReverseGeocodingConfig?: never;
    MapMatchingConfig: MapMatchingConfig;
};
export declare const VectorEnrichmentJobConfig: S.Union<readonly [S.Struct<{
    readonly ReverseGeocodingConfig: S.Schema<ReverseGeocodingConfig>;
}>, S.Struct<{
    readonly MapMatchingConfig: S.Schema<MapMatchingConfig>;
}>]>;
export interface StartVectorEnrichmentJobInput {
    Name: string;
    ClientToken?: string;
    KmsKeyId?: string;
    InputConfig: VectorEnrichmentJobInputConfig;
    JobConfig: VectorEnrichmentJobConfig;
    ExecutionRoleArn: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const StartVectorEnrichmentJobInput: S.Schema<StartVectorEnrichmentJobInput>;
export interface StartVectorEnrichmentJobOutput {
    Name: string;
    Arn: string;
    Type: string;
    CreationTime: Date;
    DurationInSeconds: number;
    Status: string;
    KmsKeyId?: string;
    InputConfig: VectorEnrichmentJobInputConfig;
    JobConfig: VectorEnrichmentJobConfig;
    ExecutionRoleArn: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const StartVectorEnrichmentJobOutput: S.Schema<StartVectorEnrichmentJobOutput>;
export interface GetVectorEnrichmentJobInput {
    Arn: string;
}
export declare const GetVectorEnrichmentJobInput: S.Schema<GetVectorEnrichmentJobInput>;
export interface VectorEnrichmentJobErrorDetails {
    ErrorType?: string;
    ErrorMessage?: string;
}
export declare const VectorEnrichmentJobErrorDetails: S.Schema<VectorEnrichmentJobErrorDetails>;
export interface VectorEnrichmentJobExportErrorDetails {
    Type?: string;
    Message?: string;
}
export declare const VectorEnrichmentJobExportErrorDetails: S.Schema<VectorEnrichmentJobExportErrorDetails>;
export interface GetVectorEnrichmentJobOutput {
    Arn: string;
    Type: string;
    Name: string;
    CreationTime: Date;
    DurationInSeconds: number;
    Status: string;
    KmsKeyId?: string;
    InputConfig: VectorEnrichmentJobInputConfig;
    JobConfig: VectorEnrichmentJobConfig;
    ExecutionRoleArn: string;
    ErrorDetails?: VectorEnrichmentJobErrorDetails;
    ExportStatus?: string;
    ExportErrorDetails?: VectorEnrichmentJobExportErrorDetails;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const GetVectorEnrichmentJobOutput: S.Schema<GetVectorEnrichmentJobOutput>;
export interface DeleteVectorEnrichmentJobInput {
    Arn: string;
}
export declare const DeleteVectorEnrichmentJobInput: S.Schema<DeleteVectorEnrichmentJobInput>;
export interface DeleteVectorEnrichmentJobOutput {
}
export declare const DeleteVectorEnrichmentJobOutput: S.Schema<DeleteVectorEnrichmentJobOutput>;
export interface ListVectorEnrichmentJobInput {
    StatusEquals?: string;
    SortOrder?: string;
    SortBy?: string;
    NextToken?: string | redacted.Redacted<string>;
    MaxResults?: number;
}
export declare const ListVectorEnrichmentJobInput: S.Schema<ListVectorEnrichmentJobInput>;
export interface ListVectorEnrichmentJobOutputConfig {
    Arn: string;
    Name: string;
    Type: string;
    CreationTime: Date;
    DurationInSeconds: number;
    Status: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListVectorEnrichmentJobOutputConfig: S.Schema<ListVectorEnrichmentJobOutputConfig>;
export type VectorEnrichmentJobList = ListVectorEnrichmentJobOutputConfig[];
export declare const VectorEnrichmentJobList: S.$Array<S.Schema<ListVectorEnrichmentJobOutputConfig>>;
export interface ListVectorEnrichmentJobOutput {
    VectorEnrichmentJobSummaries: ListVectorEnrichmentJobOutputConfig[];
    NextToken?: string | redacted.Redacted<string>;
}
export declare const ListVectorEnrichmentJobOutput: S.Schema<ListVectorEnrichmentJobOutput>;
export interface ExportVectorEnrichmentJobOutputConfig {
    S3Data: VectorEnrichmentJobS3Data;
}
export declare const ExportVectorEnrichmentJobOutputConfig: S.Schema<ExportVectorEnrichmentJobOutputConfig>;
export interface ExportVectorEnrichmentJobInput {
    Arn: string;
    ClientToken?: string;
    ExecutionRoleArn: string;
    OutputConfig: ExportVectorEnrichmentJobOutputConfig;
}
export declare const ExportVectorEnrichmentJobInput: S.Schema<ExportVectorEnrichmentJobInput>;
export interface ExportVectorEnrichmentJobOutput {
    Arn: string;
    CreationTime: Date;
    ExecutionRoleArn: string;
    ExportStatus: string;
    OutputConfig: ExportVectorEnrichmentJobOutputConfig;
}
export declare const ExportVectorEnrichmentJobOutput: S.Schema<ExportVectorEnrichmentJobOutput>;
export interface StopVectorEnrichmentJobInput {
    Arn: string;
}
export declare const StopVectorEnrichmentJobInput: S.Schema<StopVectorEnrichmentJobInput>;
export interface StopVectorEnrichmentJobOutput {
}
export declare const StopVectorEnrichmentJobOutput: S.Schema<StopVectorEnrichmentJobOutput>;
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly Message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
    readonly Message: S.String;
    readonly ResourceId: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class InternalServerException extends InternalServerException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly Message: S.String;
    readonly ResourceId: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
    readonly Message: S.String;
    readonly ResourceId: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly Message: S.String;
    readonly ResourceId: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
    readonly Message: S.String;
    readonly ResourceId: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ConflictException extends ConflictException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly Message: S.String;
    readonly ResourceId: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
});
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
export type ListTagsForResourceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists the tags attached to the resource.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * The resource you want to tag.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * The resource you want to untag.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type StartEarthObservationJobError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Use this operation to create an Earth observation job.
 */
export declare const startEarthObservationJob: API.OperationMethod<StartEarthObservationJobInput, StartEarthObservationJobOutput, StartEarthObservationJobError, Credentials | Region | HttpClient.HttpClient>;
export type GetEarthObservationJobError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Get the details for a previously initiated Earth Observation job.
 */
export declare const getEarthObservationJob: API.OperationMethod<GetEarthObservationJobInput, GetEarthObservationJobOutput, GetEarthObservationJobError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteEarthObservationJobError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Use this operation to delete an Earth Observation job.
 */
export declare const deleteEarthObservationJob: API.OperationMethod<DeleteEarthObservationJobInput, DeleteEarthObservationJobOutput, DeleteEarthObservationJobError, Credentials | Region | HttpClient.HttpClient>;
export type ListEarthObservationJobsError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Use this operation to get a list of the Earth Observation jobs associated with the calling Amazon Web Services account.
 */
export declare const listEarthObservationJobs: API.OperationMethod<ListEarthObservationJobInput, ListEarthObservationJobOutput, ListEarthObservationJobsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListEarthObservationJobInput) => stream.Stream<ListEarthObservationJobOutput, ListEarthObservationJobsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListEarthObservationJobInput) => stream.Stream<ListEarthObservationJobOutputConfig, ListEarthObservationJobsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ExportEarthObservationJobError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Use this operation to export results of an Earth Observation job and optionally source images used as input to the EOJ to an Amazon S3 location.
 */
export declare const exportEarthObservationJob: API.OperationMethod<ExportEarthObservationJobInput, ExportEarthObservationJobOutput, ExportEarthObservationJobError, Credentials | Region | HttpClient.HttpClient>;
export type GetTileError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Gets a web mercator tile for the given Earth Observation job.
 */
export declare const getTile: API.OperationMethod<GetTileInput, GetTileOutput, GetTileError, Credentials | Region | HttpClient.HttpClient>;
export type StopEarthObservationJobError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Use this operation to stop an existing earth observation job.
 */
export declare const stopEarthObservationJob: API.OperationMethod<StopEarthObservationJobInput, StopEarthObservationJobOutput, StopEarthObservationJobError, Credentials | Region | HttpClient.HttpClient>;
export type GetRasterDataCollectionError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Use this operation to get details of a specific raster data collection.
 */
export declare const getRasterDataCollection: API.OperationMethod<GetRasterDataCollectionInput, GetRasterDataCollectionOutput, GetRasterDataCollectionError, Credentials | Region | HttpClient.HttpClient>;
export type ListRasterDataCollectionsError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Use this operation to get raster data collections.
 */
export declare const listRasterDataCollections: API.OperationMethod<ListRasterDataCollectionsInput, ListRasterDataCollectionsOutput, ListRasterDataCollectionsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListRasterDataCollectionsInput) => stream.Stream<ListRasterDataCollectionsOutput, ListRasterDataCollectionsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListRasterDataCollectionsInput) => stream.Stream<RasterDataCollectionMetadata, ListRasterDataCollectionsError, Credentials | Region | HttpClient.HttpClient>;
};
export type SearchRasterDataCollectionError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Allows you run image query on a specific raster data collection to get a list of the satellite imagery matching the selected filters.
 */
export declare const searchRasterDataCollection: API.OperationMethod<SearchRasterDataCollectionInput, SearchRasterDataCollectionOutput, SearchRasterDataCollectionError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: SearchRasterDataCollectionInput) => stream.Stream<SearchRasterDataCollectionOutput, SearchRasterDataCollectionError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: SearchRasterDataCollectionInput) => stream.Stream<unknown, SearchRasterDataCollectionError, Credentials | Region | HttpClient.HttpClient>;
};
export type StartVectorEnrichmentJobError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a Vector Enrichment job for the supplied job type. Currently, there are two supported job types: reverse geocoding and map matching.
 */
export declare const startVectorEnrichmentJob: API.OperationMethod<StartVectorEnrichmentJobInput, StartVectorEnrichmentJobOutput, StartVectorEnrichmentJobError, Credentials | Region | HttpClient.HttpClient>;
export type GetVectorEnrichmentJobError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves details of a Vector Enrichment Job for a given job Amazon Resource Name (ARN).
 */
export declare const getVectorEnrichmentJob: API.OperationMethod<GetVectorEnrichmentJobInput, GetVectorEnrichmentJobOutput, GetVectorEnrichmentJobError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteVectorEnrichmentJobError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Use this operation to delete a Vector Enrichment job.
 */
export declare const deleteVectorEnrichmentJob: API.OperationMethod<DeleteVectorEnrichmentJobInput, DeleteVectorEnrichmentJobOutput, DeleteVectorEnrichmentJobError, Credentials | Region | HttpClient.HttpClient>;
export type ListVectorEnrichmentJobsError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves a list of vector enrichment jobs.
 */
export declare const listVectorEnrichmentJobs: API.OperationMethod<ListVectorEnrichmentJobInput, ListVectorEnrichmentJobOutput, ListVectorEnrichmentJobsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListVectorEnrichmentJobInput) => stream.Stream<ListVectorEnrichmentJobOutput, ListVectorEnrichmentJobsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListVectorEnrichmentJobInput) => stream.Stream<ListVectorEnrichmentJobOutputConfig, ListVectorEnrichmentJobsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ExportVectorEnrichmentJobError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Use this operation to copy results of a Vector Enrichment job to an Amazon S3 location.
 */
export declare const exportVectorEnrichmentJob: API.OperationMethod<ExportVectorEnrichmentJobInput, ExportVectorEnrichmentJobOutput, ExportVectorEnrichmentJobError, Credentials | Region | HttpClient.HttpClient>;
export type StopVectorEnrichmentJobError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Stops the Vector Enrichment job for a given job ARN.
 */
export declare const stopVectorEnrichmentJob: API.OperationMethod<StopVectorEnrichmentJobInput, StopVectorEnrichmentJobOutput, StopVectorEnrichmentJobError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=sagemaker-geospatial.d.ts.map