import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
import * as S from "effect/Schema";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type SensitiveBoolean = boolean;
export type TimestampWithTimezoneOffset = string | redacted.Redacted<string>;
export type Polyline = string | redacted.Redacted<string>;
export type PolylineRing = string | redacted.Redacted<string>;
export type TruckRoadType = string | redacted.Redacted<string>;
export type IsolineZoneCategory = string;
export type DistanceMeters = number;
export type Heading = number;
export type SensitiveString = string | redacted.Redacted<string>;
export type MatchingStrategy = string;
export type SideOfStreetMatchingStrategy = string;
export type GeometryFormat = string;
export type ApiKey = string | redacted.Redacted<string>;
export type IsolineOptimizationObjective = string;
export type RoutingObjective = string;
export type DurationSeconds = number;
export type TrafficUsage = string;
export type IsolineTravelMode = string;
export type IsolineEngineType = string | redacted.Redacted<string>;
export type SpeedKilometersPerHour = number;
export type SensitiveInteger = number;
export type WeightKilograms = number;
export type IsolineHazardousCargoType = string | redacted.Redacted<string>;
export type DimensionCentimeters = number;
export type IsolineTruckType = string;
export type TunnelRestrictionCode = string | redacted.Redacted<string>;
export type ValidationExceptionReason = string;
export type RouteMatrixZoneCategory = string | redacted.Redacted<string>;
export type CountryCode = string | redacted.Redacted<string>;
export type SensitiveDouble = number;
export type RouteMatrixTravelMode = string;
export type RouteMatrixHazardousCargoType = string | redacted.Redacted<string>;
export type RouteMatrixTruckType = string | redacted.Redacted<string>;
export type RouteMatrixErrorCode = string;
export type RouteZoneCategory = string | redacted.Redacted<string>;
export type MeasurementSystem = string;
export type LanguageTag = string;
export type RouteLegAdditionalFeature = string | redacted.Redacted<string>;
export type RouteSpanAdditionalFeature = string;
export type CurrencyCode = string;
export type RouteTollVehicleCategory = string | redacted.Redacted<string>;
export type RouteTravelMode = string;
export type RouteEngineType = string | redacted.Redacted<string>;
export type RouteHazardousCargoType = string | redacted.Redacted<string>;
export type RouteTruckType = string | redacted.Redacted<string>;
export type RouteTravelStepType = string;
export type RouteResponseNoticeCode = string;
export type RouteNoticeImpact = string;
export type RouteFerryAfterTravelStepType = string | redacted.Redacted<string>;
export type RouteFerryBeforeTravelStepType = string | redacted.Redacted<string>;
export type RouteFerryNoticeCode = string;
export type CountryCode3 = string | redacted.Redacted<string>;
export type RouteFerryTravelStepType = string | redacted.Redacted<string>;
export type RouteSideOfStreet = string | redacted.Redacted<string>;
export type RoutePedestrianNoticeCode = string;
export type RouteSpanPedestrianAccessAttribute = string | redacted.Redacted<string>;
export type RouteSpanRoadAttribute = string | redacted.Redacted<string>;
export type RouteDirection = string | redacted.Redacted<string>;
export type RouteRoadType = string | redacted.Redacted<string>;
export type RouteSteeringDirection = string | redacted.Redacted<string>;
export type TurnAngle = number;
export type RouteTurnIntensity = string | redacted.Redacted<string>;
export type RoundaboutAngle = number;
export type RoutePedestrianTravelStepType = string;
export type RouteLegTravelMode = string | redacted.Redacted<string>;
export type RouteLegType = string | redacted.Redacted<string>;
export type RouteVehicleIncidentSeverity = string | redacted.Redacted<string>;
export type RouteVehicleIncidentType = string | redacted.Redacted<string>;
export type RouteVehicleNoticeCode = string;
export type RouteWeightConstraintType = string;
export type RouteSpanCarAccessAttribute = string | redacted.Redacted<string>;
export type RouteSpanGateAttribute = string | redacted.Redacted<string>;
export type RouteSpanRailwayCrossingAttribute = string | redacted.Redacted<string>;
export type RouteSpanScooterAccessAttribute = string | redacted.Redacted<string>;
export type RouteSpanTruckAccessAttribute = string | redacted.Redacted<string>;
export type RouteTollPassValidityPeriodType = string | redacted.Redacted<string>;
export type RouteTollPaymentMethod = string | redacted.Redacted<string>;
export type RouteVehicleTravelStepType = string | redacted.Redacted<string>;
export type WaypointOptimizationClusteringAlgorithm = string | redacted.Redacted<string>;
export type DayOfWeek = string | redacted.Redacted<string>;
export type TimeOfDay = string | redacted.Redacted<string>;
export type WaypointId = string;
export type WaypointOptimizationServiceTimeTreatment = string | redacted.Redacted<string>;
export type WaypointOptimizationSequencingObjective = string;
export type WaypointOptimizationTravelMode = string;
export type WaypointOptimizationHazardousCargoType = string | redacted.Redacted<string>;
export type WaypointOptimizationTruckType = string | redacted.Redacted<string>;
export type WaypointIndex = number;
export type WaypointOptimizationConstraint = string | redacted.Redacted<string>;
export type ClusterIndex = number;
export type RoadSnapTravelMode = string;
export type RoadSnapHazardousCargoType = string | redacted.Redacted<string>;
export type RoadSnapNoticeCode = string | redacted.Redacted<string>;
export interface IsolineAllowOptions {
    Hot?: boolean;
    Hov?: boolean;
}
export declare const IsolineAllowOptions: S.Schema<IsolineAllowOptions>;
export type BoundingBox = number[];
export declare const BoundingBox: S.$Array<S.Number>;
export type Position = number[];
export declare const Position: S.$Array<S.Number>;
export type LineString = number[][];
export declare const LineString: S.$Array<S.$Array<S.Number>>;
export interface Corridor {
    LineString: number[][];
    Radius: number;
}
export declare const Corridor: S.Schema<Corridor>;
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 PolylineCorridor {
    Polyline: string | redacted.Redacted<string>;
    Radius: number;
}
export declare const PolylineCorridor: S.Schema<PolylineCorridor>;
export type PolylineRingList = string | redacted.Redacted<string>[];
export declare const PolylineRingList: S.$Array<S.Schema<string | redacted.Redacted<string>>>;
export interface IsolineAvoidanceAreaGeometry {
    BoundingBox?: number[];
    Corridor?: Corridor;
    Polygon?: number[][][];
    PolylineCorridor?: PolylineCorridor;
    PolylinePolygon?: string | redacted.Redacted<string>[];
}
export declare const IsolineAvoidanceAreaGeometry: S.Schema<IsolineAvoidanceAreaGeometry>;
export type IsolineAvoidanceAreaGeometryList = IsolineAvoidanceAreaGeometry[];
export declare const IsolineAvoidanceAreaGeometryList: S.$Array<S.Schema<IsolineAvoidanceAreaGeometry>>;
export interface IsolineAvoidanceArea {
    Except?: IsolineAvoidanceAreaGeometry[];
    Geometry: IsolineAvoidanceAreaGeometry;
}
export declare const IsolineAvoidanceArea: S.Schema<IsolineAvoidanceArea>;
export type IsolineAvoidanceAreaList = IsolineAvoidanceArea[];
export declare const IsolineAvoidanceAreaList: S.$Array<S.Schema<IsolineAvoidanceArea>>;
export type TruckRoadTypeList = string | redacted.Redacted<string>[];
export declare const TruckRoadTypeList: S.$Array<S.Schema<string | redacted.Redacted<string>>>;
export interface IsolineAvoidanceZoneCategory {
    Category?: string;
}
export declare const IsolineAvoidanceZoneCategory: S.Schema<IsolineAvoidanceZoneCategory>;
export type IsolineAvoidanceZoneCategoryList = IsolineAvoidanceZoneCategory[];
export declare const IsolineAvoidanceZoneCategoryList: S.$Array<S.Schema<IsolineAvoidanceZoneCategory>>;
export interface IsolineAvoidanceOptions {
    Areas?: IsolineAvoidanceArea[];
    CarShuttleTrains?: boolean;
    ControlledAccessHighways?: boolean;
    DirtRoads?: boolean;
    Ferries?: boolean;
    SeasonalClosure?: boolean;
    TollRoads?: boolean;
    TollTransponders?: boolean;
    TruckRoadTypes?: string | redacted.Redacted<string>[];
    Tunnels?: boolean;
    UTurns?: boolean;
    ZoneCategories?: IsolineAvoidanceZoneCategory[];
}
export declare const IsolineAvoidanceOptions: S.Schema<IsolineAvoidanceOptions>;
export interface IsolineMatchingOptions {
    NameHint?: string | redacted.Redacted<string>;
    OnRoadThreshold?: number;
    Radius?: number;
    Strategy?: string;
}
export declare const IsolineMatchingOptions: S.Schema<IsolineMatchingOptions>;
export interface IsolineSideOfStreetOptions {
    Position: number[];
    UseWith?: string;
}
export declare const IsolineSideOfStreetOptions: S.Schema<IsolineSideOfStreetOptions>;
export interface IsolineDestinationOptions {
    AvoidActionsForDistance?: number;
    Heading?: number;
    Matching?: IsolineMatchingOptions;
    SideOfStreet?: IsolineSideOfStreetOptions;
}
export declare const IsolineDestinationOptions: S.Schema<IsolineDestinationOptions>;
export interface IsolineGranularityOptions {
    MaxPoints?: number;
    MaxResolution?: number;
}
export declare const IsolineGranularityOptions: S.Schema<IsolineGranularityOptions>;
export interface IsolineOriginOptions {
    AvoidActionsForDistance?: number;
    Heading?: number;
    Matching?: IsolineMatchingOptions;
    SideOfStreet?: IsolineSideOfStreetOptions;
}
export declare const IsolineOriginOptions: S.Schema<IsolineOriginOptions>;
export type DistanceThresholdList = number[];
export declare const DistanceThresholdList: S.$Array<S.Number>;
export type TimeThresholdList = number[];
export declare const TimeThresholdList: S.$Array<S.Number>;
export interface IsolineThresholds {
    Distance?: number[];
    Time?: number[];
}
export declare const IsolineThresholds: S.Schema<IsolineThresholds>;
export interface IsolineTrafficOptions {
    FlowEventThresholdOverride?: number;
    Usage?: string;
}
export declare const IsolineTrafficOptions: S.Schema<IsolineTrafficOptions>;
export interface IsolineVehicleLicensePlate {
    LastCharacter?: string;
}
export declare const IsolineVehicleLicensePlate: S.Schema<IsolineVehicleLicensePlate>;
export interface IsolineCarOptions {
    EngineType?: string | redacted.Redacted<string>;
    LicensePlate?: IsolineVehicleLicensePlate;
    MaxSpeed?: number;
    Occupancy?: number;
}
export declare const IsolineCarOptions: S.Schema<IsolineCarOptions>;
export interface IsolineScooterOptions {
    EngineType?: string | redacted.Redacted<string>;
    LicensePlate?: IsolineVehicleLicensePlate;
    MaxSpeed?: number;
    Occupancy?: number;
}
export declare const IsolineScooterOptions: S.Schema<IsolineScooterOptions>;
export type IsolineHazardousCargoTypeList = string | redacted.Redacted<string>[];
export declare const IsolineHazardousCargoTypeList: S.$Array<S.Schema<string | redacted.Redacted<string>>>;
export interface IsolineTrailerOptions {
    AxleCount?: number;
    TrailerCount?: number;
}
export declare const IsolineTrailerOptions: S.Schema<IsolineTrailerOptions>;
export interface WeightPerAxleGroup {
    Single?: number;
    Tandem?: number;
    Triple?: number;
    Quad?: number;
    Quint?: number;
}
export declare const WeightPerAxleGroup: S.Schema<WeightPerAxleGroup>;
export interface IsolineTruckOptions {
    AxleCount?: number;
    EngineType?: string | redacted.Redacted<string>;
    GrossWeight?: number;
    HazardousCargos?: string | redacted.Redacted<string>[];
    Height?: number;
    HeightAboveFirstAxle?: number;
    KpraLength?: number;
    Length?: number;
    LicensePlate?: IsolineVehicleLicensePlate;
    MaxSpeed?: number;
    Occupancy?: number;
    PayloadCapacity?: number;
    TireCount?: number;
    Trailer?: IsolineTrailerOptions;
    TruckType?: string;
    TunnelRestrictionCode?: string | redacted.Redacted<string>;
    WeightPerAxle?: number;
    WeightPerAxleGroup?: WeightPerAxleGroup;
    Width?: number;
}
export declare const IsolineTruckOptions: S.Schema<IsolineTruckOptions>;
export interface IsolineTravelModeOptions {
    Car?: IsolineCarOptions;
    Scooter?: IsolineScooterOptions;
    Truck?: IsolineTruckOptions;
}
export declare const IsolineTravelModeOptions: S.Schema<IsolineTravelModeOptions>;
export interface CalculateIsolinesRequest {
    Allow?: IsolineAllowOptions;
    ArrivalTime?: string | redacted.Redacted<string>;
    Avoid?: IsolineAvoidanceOptions;
    DepartNow?: boolean;
    DepartureTime?: string | redacted.Redacted<string>;
    Destination?: number[];
    DestinationOptions?: IsolineDestinationOptions;
    IsolineGeometryFormat?: string;
    IsolineGranularity?: IsolineGranularityOptions;
    Key?: string | redacted.Redacted<string>;
    OptimizeIsolineFor?: string;
    OptimizeRoutingFor?: string;
    Origin?: number[];
    OriginOptions?: IsolineOriginOptions;
    Thresholds: IsolineThresholds;
    Traffic?: IsolineTrafficOptions;
    TravelMode?: string;
    TravelModeOptions?: IsolineTravelModeOptions;
}
export declare const CalculateIsolinesRequest: S.Schema<CalculateIsolinesRequest>;
export interface IsolineConnectionGeometry {
    LineString?: number[][];
    Polyline?: string | redacted.Redacted<string>;
}
export declare const IsolineConnectionGeometry: S.Schema<IsolineConnectionGeometry>;
export interface IsolineConnection {
    FromPolygonIndex: number;
    Geometry: IsolineConnectionGeometry;
    ToPolygonIndex: number;
}
export declare const IsolineConnection: S.Schema<IsolineConnection>;
export type IsolineConnectionList = IsolineConnection[];
export declare const IsolineConnectionList: S.$Array<S.Schema<IsolineConnection>>;
export interface IsolineShapeGeometry {
    Polygon?: number[][][];
    PolylinePolygon?: string | redacted.Redacted<string>[];
}
export declare const IsolineShapeGeometry: S.Schema<IsolineShapeGeometry>;
export type IsolineShapeGeometryList = IsolineShapeGeometry[];
export declare const IsolineShapeGeometryList: S.$Array<S.Schema<IsolineShapeGeometry>>;
export interface Isoline {
    Connections: IsolineConnection[];
    DistanceThreshold?: number;
    Geometries: IsolineShapeGeometry[];
    TimeThreshold?: number;
}
export declare const Isoline: S.Schema<Isoline>;
export type IsolineList = Isoline[];
export declare const IsolineList: S.$Array<S.Schema<Isoline>>;
export interface CalculateIsolinesResponse {
    ArrivalTime?: string | redacted.Redacted<string>;
    DepartureTime?: string | redacted.Redacted<string>;
    IsolineGeometryFormat: string;
    Isolines: Isoline[];
    PricingBucket: string;
    SnappedDestination?: number[];
    SnappedOrigin?: number[];
}
export declare const CalculateIsolinesResponse: S.Schema<CalculateIsolinesResponse>;
export interface ValidationExceptionField {
    Name: string;
    Message: string;
}
export declare const ValidationExceptionField: S.Schema<ValidationExceptionField>;
export type ValidationExceptionFieldList = ValidationExceptionField[];
export declare const ValidationExceptionFieldList: S.$Array<S.Schema<ValidationExceptionField>>;
export interface RouteMatrixAllowOptions {
    Hot?: boolean;
    Hov?: boolean;
}
export declare const RouteMatrixAllowOptions: S.Schema<RouteMatrixAllowOptions>;
export interface RouteMatrixAvoidanceAreaGeometry {
    BoundingBox?: number[];
    Polygon?: number[][][];
    PolylinePolygon?: string | redacted.Redacted<string>[];
}
export declare const RouteMatrixAvoidanceAreaGeometry: S.Schema<RouteMatrixAvoidanceAreaGeometry>;
export interface RouteMatrixAvoidanceArea {
    Geometry: RouteMatrixAvoidanceAreaGeometry;
}
export declare const RouteMatrixAvoidanceArea: S.Schema<RouteMatrixAvoidanceArea>;
export type RouteMatrixAvoidanceAreaList = RouteMatrixAvoidanceArea[];
export declare const RouteMatrixAvoidanceAreaList: S.$Array<S.Schema<RouteMatrixAvoidanceArea>>;
export interface RouteMatrixAvoidanceZoneCategory {
    Category?: string | redacted.Redacted<string>;
}
export declare const RouteMatrixAvoidanceZoneCategory: S.Schema<RouteMatrixAvoidanceZoneCategory>;
export type RouteMatrixAvoidanceZoneCategoryList = RouteMatrixAvoidanceZoneCategory[];
export declare const RouteMatrixAvoidanceZoneCategoryList: S.$Array<S.Schema<RouteMatrixAvoidanceZoneCategory>>;
export interface RouteMatrixAvoidanceOptions {
    Areas?: RouteMatrixAvoidanceArea[];
    CarShuttleTrains?: boolean;
    ControlledAccessHighways?: boolean;
    DirtRoads?: boolean;
    Ferries?: boolean;
    TollRoads?: boolean;
    TollTransponders?: boolean;
    TruckRoadTypes?: string | redacted.Redacted<string>[];
    Tunnels?: boolean;
    UTurns?: boolean;
    ZoneCategories?: RouteMatrixAvoidanceZoneCategory[];
}
export declare const RouteMatrixAvoidanceOptions: S.Schema<RouteMatrixAvoidanceOptions>;
export interface RouteMatrixMatchingOptions {
    NameHint?: string | redacted.Redacted<string>;
    OnRoadThreshold?: number;
    Radius?: number;
    Strategy?: string;
}
export declare const RouteMatrixMatchingOptions: S.Schema<RouteMatrixMatchingOptions>;
export interface RouteMatrixSideOfStreetOptions {
    Position: number[];
    UseWith?: string;
}
export declare const RouteMatrixSideOfStreetOptions: S.Schema<RouteMatrixSideOfStreetOptions>;
export interface RouteMatrixDestinationOptions {
    AvoidActionsForDistance?: number;
    Heading?: number;
    Matching?: RouteMatrixMatchingOptions;
    SideOfStreet?: RouteMatrixSideOfStreetOptions;
}
export declare const RouteMatrixDestinationOptions: S.Schema<RouteMatrixDestinationOptions>;
export interface RouteMatrixDestination {
    Options?: RouteMatrixDestinationOptions;
    Position: number[];
}
export declare const RouteMatrixDestination: S.Schema<RouteMatrixDestination>;
export type RouteMatrixDestinationList = RouteMatrixDestination[];
export declare const RouteMatrixDestinationList: S.$Array<S.Schema<RouteMatrixDestination>>;
export type CountryCodeList = string | redacted.Redacted<string>[];
export declare const CountryCodeList: S.$Array<S.Schema<string | redacted.Redacted<string>>>;
export interface RouteMatrixExclusionOptions {
    Countries: string | redacted.Redacted<string>[];
}
export declare const RouteMatrixExclusionOptions: S.Schema<RouteMatrixExclusionOptions>;
export interface RouteMatrixOriginOptions {
    AvoidActionsForDistance?: number;
    Heading?: number;
    Matching?: RouteMatrixMatchingOptions;
    SideOfStreet?: RouteMatrixSideOfStreetOptions;
}
export declare const RouteMatrixOriginOptions: S.Schema<RouteMatrixOriginOptions>;
export interface RouteMatrixOrigin {
    Options?: RouteMatrixOriginOptions;
    Position: number[];
}
export declare const RouteMatrixOrigin: S.Schema<RouteMatrixOrigin>;
export type RouteMatrixOriginList = RouteMatrixOrigin[];
export declare const RouteMatrixOriginList: S.$Array<S.Schema<RouteMatrixOrigin>>;
export interface RouteMatrixAutoCircle {
    Margin?: number;
    MaxRadius?: number;
}
export declare const RouteMatrixAutoCircle: S.Schema<RouteMatrixAutoCircle>;
export interface Circle {
    Center: number[];
    Radius: number;
}
export declare const Circle: S.Schema<Circle>;
export interface RouteMatrixBoundaryGeometry {
    AutoCircle?: RouteMatrixAutoCircle;
    Circle?: Circle;
    BoundingBox?: number[];
    Polygon?: number[][][];
}
export declare const RouteMatrixBoundaryGeometry: S.Schema<RouteMatrixBoundaryGeometry>;
export interface RouteMatrixBoundary {
    Geometry?: RouteMatrixBoundaryGeometry;
    Unbounded?: boolean;
}
export declare const RouteMatrixBoundary: S.Schema<RouteMatrixBoundary>;
export interface RouteMatrixTrafficOptions {
    FlowEventThresholdOverride?: number;
    Usage?: string;
}
export declare const RouteMatrixTrafficOptions: S.Schema<RouteMatrixTrafficOptions>;
export interface RouteMatrixVehicleLicensePlate {
    LastCharacter?: string;
}
export declare const RouteMatrixVehicleLicensePlate: S.Schema<RouteMatrixVehicleLicensePlate>;
export interface RouteMatrixCarOptions {
    LicensePlate?: RouteMatrixVehicleLicensePlate;
    MaxSpeed?: number;
    Occupancy?: number;
}
export declare const RouteMatrixCarOptions: S.Schema<RouteMatrixCarOptions>;
export interface RouteMatrixScooterOptions {
    LicensePlate?: RouteMatrixVehicleLicensePlate;
    MaxSpeed?: number;
    Occupancy?: number;
}
export declare const RouteMatrixScooterOptions: S.Schema<RouteMatrixScooterOptions>;
export type RouteMatrixHazardousCargoTypeList = string | redacted.Redacted<string>[];
export declare const RouteMatrixHazardousCargoTypeList: S.$Array<S.Schema<string | redacted.Redacted<string>>>;
export interface RouteMatrixTrailerOptions {
    TrailerCount?: number;
}
export declare const RouteMatrixTrailerOptions: S.Schema<RouteMatrixTrailerOptions>;
export interface RouteMatrixTruckOptions {
    AxleCount?: number;
    GrossWeight?: number;
    HazardousCargos?: string | redacted.Redacted<string>[];
    Height?: number;
    KpraLength?: number;
    Length?: number;
    LicensePlate?: RouteMatrixVehicleLicensePlate;
    MaxSpeed?: number;
    Occupancy?: number;
    PayloadCapacity?: number;
    Trailer?: RouteMatrixTrailerOptions;
    TruckType?: string | redacted.Redacted<string>;
    TunnelRestrictionCode?: string | redacted.Redacted<string>;
    WeightPerAxle?: number;
    WeightPerAxleGroup?: WeightPerAxleGroup;
    Width?: number;
}
export declare const RouteMatrixTruckOptions: S.Schema<RouteMatrixTruckOptions>;
export interface RouteMatrixTravelModeOptions {
    Car?: RouteMatrixCarOptions;
    Scooter?: RouteMatrixScooterOptions;
    Truck?: RouteMatrixTruckOptions;
}
export declare const RouteMatrixTravelModeOptions: S.Schema<RouteMatrixTravelModeOptions>;
export interface CalculateRouteMatrixRequest {
    Allow?: RouteMatrixAllowOptions;
    Avoid?: RouteMatrixAvoidanceOptions;
    DepartNow?: boolean;
    DepartureTime?: string | redacted.Redacted<string>;
    Destinations: RouteMatrixDestination[];
    Exclude?: RouteMatrixExclusionOptions;
    Key?: string | redacted.Redacted<string>;
    OptimizeRoutingFor?: string;
    Origins: RouteMatrixOrigin[];
    RoutingBoundary?: RouteMatrixBoundary;
    Traffic?: RouteMatrixTrafficOptions;
    TravelMode?: string;
    TravelModeOptions?: RouteMatrixTravelModeOptions;
}
export declare const CalculateRouteMatrixRequest: S.Schema<CalculateRouteMatrixRequest>;
export interface RouteMatrixEntry {
    Distance: number;
    Duration: number;
    Error?: string;
}
export declare const RouteMatrixEntry: S.Schema<RouteMatrixEntry>;
export type RouteMatrixRow = RouteMatrixEntry[];
export declare const RouteMatrixRow: S.$Array<S.Schema<RouteMatrixEntry>>;
export type RouteMatrix = RouteMatrixEntry[][];
export declare const RouteMatrix: S.$Array<S.$Array<S.Schema<RouteMatrixEntry>>>;
export interface CalculateRouteMatrixResponse {
    ErrorCount: number;
    PricingBucket: string;
    RouteMatrix: RouteMatrixEntry[][];
    RoutingBoundary: RouteMatrixBoundary;
}
export declare const CalculateRouteMatrixResponse: S.Schema<CalculateRouteMatrixResponse>;
export interface RouteAllowOptions {
    Hot?: boolean;
    Hov?: boolean;
}
export declare const RouteAllowOptions: S.Schema<RouteAllowOptions>;
export interface RouteAvoidanceAreaGeometry {
    Corridor?: Corridor;
    BoundingBox?: number[];
    Polygon?: number[][][];
    PolylineCorridor?: PolylineCorridor;
    PolylinePolygon?: string | redacted.Redacted<string>[];
}
export declare const RouteAvoidanceAreaGeometry: S.Schema<RouteAvoidanceAreaGeometry>;
export type RouteAvoidanceAreaGeometryList = RouteAvoidanceAreaGeometry[];
export declare const RouteAvoidanceAreaGeometryList: S.$Array<S.Schema<RouteAvoidanceAreaGeometry>>;
export interface RouteAvoidanceArea {
    Except?: RouteAvoidanceAreaGeometry[];
    Geometry: RouteAvoidanceAreaGeometry;
}
export declare const RouteAvoidanceArea: S.Schema<RouteAvoidanceArea>;
export type RouteAvoidanceAreaList = RouteAvoidanceArea[];
export declare const RouteAvoidanceAreaList: S.$Array<S.Schema<RouteAvoidanceArea>>;
export interface RouteAvoidanceZoneCategory {
    Category: string | redacted.Redacted<string>;
}
export declare const RouteAvoidanceZoneCategory: S.Schema<RouteAvoidanceZoneCategory>;
export type RouteAvoidanceZoneCategoryList = RouteAvoidanceZoneCategory[];
export declare const RouteAvoidanceZoneCategoryList: S.$Array<S.Schema<RouteAvoidanceZoneCategory>>;
export interface RouteAvoidanceOptions {
    Areas?: RouteAvoidanceArea[];
    CarShuttleTrains?: boolean;
    ControlledAccessHighways?: boolean;
    DirtRoads?: boolean;
    Ferries?: boolean;
    SeasonalClosure?: boolean;
    TollRoads?: boolean;
    TollTransponders?: boolean;
    TruckRoadTypes?: string | redacted.Redacted<string>[];
    Tunnels?: boolean;
    UTurns?: boolean;
    ZoneCategories?: RouteAvoidanceZoneCategory[];
}
export declare const RouteAvoidanceOptions: S.Schema<RouteAvoidanceOptions>;
export interface RouteMatchingOptions {
    NameHint?: string | redacted.Redacted<string>;
    OnRoadThreshold?: number;
    Radius?: number;
    Strategy?: string;
}
export declare const RouteMatchingOptions: S.Schema<RouteMatchingOptions>;
export interface RouteSideOfStreetOptions {
    Position: number[];
    UseWith?: string;
}
export declare const RouteSideOfStreetOptions: S.Schema<RouteSideOfStreetOptions>;
export interface RouteDestinationOptions {
    AvoidActionsForDistance?: number;
    AvoidUTurns?: boolean;
    Heading?: number;
    Matching?: RouteMatchingOptions;
    SideOfStreet?: RouteSideOfStreetOptions;
    StopDuration?: number;
}
export declare const RouteDestinationOptions: S.Schema<RouteDestinationOptions>;
export interface RouteDriverScheduleInterval {
    DriveDuration: number;
    RestDuration: number;
}
export declare const RouteDriverScheduleInterval: S.Schema<RouteDriverScheduleInterval>;
export type RouteDriverScheduleIntervalList = RouteDriverScheduleInterval[];
export declare const RouteDriverScheduleIntervalList: S.$Array<S.Schema<RouteDriverScheduleInterval>>;
export interface RouteDriverOptions {
    Schedule?: RouteDriverScheduleInterval[];
}
export declare const RouteDriverOptions: S.Schema<RouteDriverOptions>;
export interface RouteExclusionOptions {
    Countries: string | redacted.Redacted<string>[];
}
export declare const RouteExclusionOptions: S.Schema<RouteExclusionOptions>;
export type LanguageTagList = string[];
export declare const LanguageTagList: S.$Array<S.String>;
export type RouteLegAdditionalFeatureList = string | redacted.Redacted<string>[];
export declare const RouteLegAdditionalFeatureList: S.$Array<S.Schema<string | redacted.Redacted<string>>>;
export interface RouteOriginOptions {
    AvoidActionsForDistance?: number;
    AvoidUTurns?: boolean;
    Heading?: number;
    Matching?: RouteMatchingOptions;
    SideOfStreet?: RouteSideOfStreetOptions;
}
export declare const RouteOriginOptions: S.Schema<RouteOriginOptions>;
export type RouteSpanAdditionalFeatureList = string[];
export declare const RouteSpanAdditionalFeatureList: S.$Array<S.String>;
export interface RouteEmissionType {
    Co2EmissionClass?: string | redacted.Redacted<string>;
    Type: string | redacted.Redacted<string>;
}
export declare const RouteEmissionType: S.Schema<RouteEmissionType>;
export interface RouteTollOptions {
    AllTransponders?: boolean;
    AllVignettes?: boolean;
    Currency?: string;
    EmissionType?: RouteEmissionType;
    VehicleCategory?: string | redacted.Redacted<string>;
}
export declare const RouteTollOptions: S.Schema<RouteTollOptions>;
export interface RouteTrafficOptions {
    FlowEventThresholdOverride?: number;
    Usage?: string;
}
export declare const RouteTrafficOptions: S.Schema<RouteTrafficOptions>;
export interface RouteVehicleLicensePlate {
    LastCharacter?: string | redacted.Redacted<string>;
}
export declare const RouteVehicleLicensePlate: S.Schema<RouteVehicleLicensePlate>;
export interface RouteCarOptions {
    EngineType?: string | redacted.Redacted<string>;
    LicensePlate?: RouteVehicleLicensePlate;
    MaxSpeed?: number;
    Occupancy?: number;
}
export declare const RouteCarOptions: S.Schema<RouteCarOptions>;
export interface RoutePedestrianOptions {
    Speed?: number;
}
export declare const RoutePedestrianOptions: S.Schema<RoutePedestrianOptions>;
export interface RouteScooterOptions {
    EngineType?: string | redacted.Redacted<string>;
    LicensePlate?: RouteVehicleLicensePlate;
    MaxSpeed?: number;
    Occupancy?: number;
}
export declare const RouteScooterOptions: S.Schema<RouteScooterOptions>;
export type RouteHazardousCargoTypeList = string | redacted.Redacted<string>[];
export declare const RouteHazardousCargoTypeList: S.$Array<S.Schema<string | redacted.Redacted<string>>>;
export interface RouteTrailerOptions {
    AxleCount?: number;
    TrailerCount?: number;
}
export declare const RouteTrailerOptions: S.Schema<RouteTrailerOptions>;
export interface RouteTruckOptions {
    AxleCount?: number;
    EngineType?: string | redacted.Redacted<string>;
    GrossWeight?: number;
    HazardousCargos?: string | redacted.Redacted<string>[];
    Height?: number;
    HeightAboveFirstAxle?: number;
    KpraLength?: number;
    Length?: number;
    LicensePlate?: RouteVehicleLicensePlate;
    MaxSpeed?: number;
    Occupancy?: number;
    PayloadCapacity?: number;
    TireCount?: number;
    Trailer?: RouteTrailerOptions;
    TruckType?: string | redacted.Redacted<string>;
    TunnelRestrictionCode?: string | redacted.Redacted<string>;
    WeightPerAxle?: number;
    WeightPerAxleGroup?: WeightPerAxleGroup;
    Width?: number;
}
export declare const RouteTruckOptions: S.Schema<RouteTruckOptions>;
export interface RouteTravelModeOptions {
    Car?: RouteCarOptions;
    Pedestrian?: RoutePedestrianOptions;
    Scooter?: RouteScooterOptions;
    Truck?: RouteTruckOptions;
}
export declare const RouteTravelModeOptions: S.Schema<RouteTravelModeOptions>;
export interface RouteWaypoint {
    AvoidActionsForDistance?: number;
    AvoidUTurns?: boolean;
    Heading?: number;
    Matching?: RouteMatchingOptions;
    PassThrough?: boolean;
    Position: number[];
    SideOfStreet?: RouteSideOfStreetOptions;
    StopDuration?: number;
}
export declare const RouteWaypoint: S.Schema<RouteWaypoint>;
export type RouteWaypointList = RouteWaypoint[];
export declare const RouteWaypointList: S.$Array<S.Schema<RouteWaypoint>>;
export interface CalculateRoutesRequest {
    Allow?: RouteAllowOptions;
    ArrivalTime?: string | redacted.Redacted<string>;
    Avoid?: RouteAvoidanceOptions;
    DepartNow?: boolean;
    DepartureTime?: string | redacted.Redacted<string>;
    Destination: number[];
    DestinationOptions?: RouteDestinationOptions;
    Driver?: RouteDriverOptions;
    Exclude?: RouteExclusionOptions;
    InstructionsMeasurementSystem?: string;
    Key?: string | redacted.Redacted<string>;
    Languages?: string[];
    LegAdditionalFeatures?: string | redacted.Redacted<string>[];
    LegGeometryFormat?: string;
    MaxAlternatives?: number;
    OptimizeRoutingFor?: string;
    Origin: number[];
    OriginOptions?: RouteOriginOptions;
    SpanAdditionalFeatures?: string[];
    Tolls?: RouteTollOptions;
    Traffic?: RouteTrafficOptions;
    TravelMode?: string;
    TravelModeOptions?: RouteTravelModeOptions;
    TravelStepType?: string;
    Waypoints?: RouteWaypoint[];
}
export declare const CalculateRoutesRequest: S.Schema<CalculateRoutesRequest>;
export interface RouteResponseNotice {
    Code: string;
    Impact?: string;
}
export declare const RouteResponseNotice: S.Schema<RouteResponseNotice>;
export type RouteResponseNoticeList = RouteResponseNotice[];
export declare const RouteResponseNoticeList: S.$Array<S.Schema<RouteResponseNotice>>;
export interface RouteFerryAfterTravelStep {
    Duration: number;
    Instruction?: string | redacted.Redacted<string>;
    Type: string | redacted.Redacted<string>;
}
export declare const RouteFerryAfterTravelStep: S.Schema<RouteFerryAfterTravelStep>;
export type RouteFerryAfterTravelStepList = RouteFerryAfterTravelStep[];
export declare const RouteFerryAfterTravelStepList: S.$Array<S.Schema<RouteFerryAfterTravelStep>>;
export type Position23 = number[];
export declare const Position23: S.$Array<S.Number>;
export interface RouteFerryPlace {
    Name?: string | redacted.Redacted<string>;
    OriginalPosition?: number[];
    Position: number[];
    WaypointIndex?: number;
}
export declare const RouteFerryPlace: S.Schema<RouteFerryPlace>;
export interface RouteFerryArrival {
    Place: RouteFerryPlace;
    Time?: string | redacted.Redacted<string>;
}
export declare const RouteFerryArrival: S.Schema<RouteFerryArrival>;
export interface RouteFerryBeforeTravelStep {
    Duration: number;
    Instruction?: string | redacted.Redacted<string>;
    Type: string | redacted.Redacted<string>;
}
export declare const RouteFerryBeforeTravelStep: S.Schema<RouteFerryBeforeTravelStep>;
export type RouteFerryBeforeTravelStepList = RouteFerryBeforeTravelStep[];
export declare const RouteFerryBeforeTravelStepList: S.$Array<S.Schema<RouteFerryBeforeTravelStep>>;
export interface RouteFerryDeparture {
    Place: RouteFerryPlace;
    Time?: string | redacted.Redacted<string>;
}
export declare const RouteFerryDeparture: S.Schema<RouteFerryDeparture>;
export interface RouteFerryNotice {
    Code: string;
    Impact?: string;
}
export declare const RouteFerryNotice: S.Schema<RouteFerryNotice>;
export type RouteFerryNoticeList = RouteFerryNotice[];
export declare const RouteFerryNoticeList: S.$Array<S.Schema<RouteFerryNotice>>;
export interface RoutePassThroughPlace {
    OriginalPosition?: number[];
    Position: number[];
    WaypointIndex?: number;
}
export declare const RoutePassThroughPlace: S.Schema<RoutePassThroughPlace>;
export interface RoutePassThroughWaypoint {
    GeometryOffset?: number;
    Place: RoutePassThroughPlace;
}
export declare const RoutePassThroughWaypoint: S.Schema<RoutePassThroughWaypoint>;
export type RoutePassThroughWaypointList = RoutePassThroughWaypoint[];
export declare const RoutePassThroughWaypointList: S.$Array<S.Schema<RoutePassThroughWaypoint>>;
export interface LocalizedString {
    Language?: string;
    Value: string | redacted.Redacted<string>;
}
export declare const LocalizedString: S.Schema<LocalizedString>;
export type LocalizedStringList = LocalizedString[];
export declare const LocalizedStringList: S.$Array<S.Schema<LocalizedString>>;
export interface RouteFerrySpan {
    Country?: string | redacted.Redacted<string>;
    Distance?: number;
    Duration?: number;
    GeometryOffset?: number;
    Names?: LocalizedString[];
    Region?: string | redacted.Redacted<string>;
}
export declare const RouteFerrySpan: S.Schema<RouteFerrySpan>;
export type RouteFerrySpanList = RouteFerrySpan[];
export declare const RouteFerrySpanList: S.$Array<S.Schema<RouteFerrySpan>>;
export interface RouteFerryOverviewSummary {
    Distance: number;
    Duration: number;
}
export declare const RouteFerryOverviewSummary: S.Schema<RouteFerryOverviewSummary>;
export interface RouteFerryTravelOnlySummary {
    Duration: number;
}
export declare const RouteFerryTravelOnlySummary: S.Schema<RouteFerryTravelOnlySummary>;
export interface RouteFerrySummary {
    Overview?: RouteFerryOverviewSummary;
    TravelOnly?: RouteFerryTravelOnlySummary;
}
export declare const RouteFerrySummary: S.Schema<RouteFerrySummary>;
export interface RouteFerryTravelStep {
    Distance?: number;
    Duration: number;
    GeometryOffset?: number;
    Instruction?: string | redacted.Redacted<string>;
    Type: string | redacted.Redacted<string>;
}
export declare const RouteFerryTravelStep: S.Schema<RouteFerryTravelStep>;
export type RouteFerryTravelStepList = RouteFerryTravelStep[];
export declare const RouteFerryTravelStepList: S.$Array<S.Schema<RouteFerryTravelStep>>;
export interface RouteFerryLegDetails {
    AfterTravelSteps: RouteFerryAfterTravelStep[];
    Arrival: RouteFerryArrival;
    BeforeTravelSteps: RouteFerryBeforeTravelStep[];
    Departure: RouteFerryDeparture;
    Notices: RouteFerryNotice[];
    PassThroughWaypoints: RoutePassThroughWaypoint[];
    RouteName?: string | redacted.Redacted<string>;
    Spans: RouteFerrySpan[];
    Summary?: RouteFerrySummary;
    TravelSteps: RouteFerryTravelStep[];
}
export declare const RouteFerryLegDetails: S.Schema<RouteFerryLegDetails>;
export interface RouteLegGeometry {
    LineString?: number[][];
    Polyline?: string | redacted.Redacted<string>;
}
export declare const RouteLegGeometry: S.Schema<RouteLegGeometry>;
export interface RoutePedestrianPlace {
    Name?: string | redacted.Redacted<string>;
    OriginalPosition?: number[];
    Position: number[];
    SideOfStreet?: string | redacted.Redacted<string>;
    WaypointIndex?: number;
}
export declare const RoutePedestrianPlace: S.Schema<RoutePedestrianPlace>;
export interface RoutePedestrianArrival {
    Place: RoutePedestrianPlace;
    Time?: string | redacted.Redacted<string>;
}
export declare const RoutePedestrianArrival: S.Schema<RoutePedestrianArrival>;
export interface RoutePedestrianDeparture {
    Place: RoutePedestrianPlace;
    Time?: string | redacted.Redacted<string>;
}
export declare const RoutePedestrianDeparture: S.Schema<RoutePedestrianDeparture>;
export interface RoutePedestrianNotice {
    Code: string;
    Impact?: string;
}
export declare const RoutePedestrianNotice: S.Schema<RoutePedestrianNotice>;
export type RoutePedestrianNoticeList = RoutePedestrianNotice[];
export declare const RoutePedestrianNoticeList: S.$Array<S.Schema<RoutePedestrianNotice>>;
export interface RouteSpanDynamicSpeedDetails {
    BestCaseSpeed?: number;
    TurnDuration?: number;
    TypicalSpeed?: number;
}
export declare const RouteSpanDynamicSpeedDetails: S.Schema<RouteSpanDynamicSpeedDetails>;
export type IndexList = number[];
export declare const IndexList: S.$Array<S.Number>;
export type RouteSpanPedestrianAccessAttributeList = string | redacted.Redacted<string>[];
export declare const RouteSpanPedestrianAccessAttributeList: S.$Array<S.Schema<string | redacted.Redacted<string>>>;
export type RouteSpanRoadAttributeList = string | redacted.Redacted<string>[];
export declare const RouteSpanRoadAttributeList: S.$Array<S.Schema<string | redacted.Redacted<string>>>;
export interface RouteNumber {
    Direction?: string | redacted.Redacted<string>;
    Language?: string;
    Value: string | redacted.Redacted<string>;
}
export declare const RouteNumber: S.Schema<RouteNumber>;
export type RouteNumberList = RouteNumber[];
export declare const RouteNumberList: S.$Array<S.Schema<RouteNumber>>;
export interface RouteSpanSpeedLimitDetails {
    MaxSpeed?: number;
    Unlimited?: boolean;
}
export declare const RouteSpanSpeedLimitDetails: S.Schema<RouteSpanSpeedLimitDetails>;
export interface RoutePedestrianSpan {
    BestCaseDuration?: number;
    Country?: string | redacted.Redacted<string>;
    Distance?: number;
    Duration?: number;
    DynamicSpeed?: RouteSpanDynamicSpeedDetails;
    FunctionalClassification?: number;
    GeometryOffset?: number;
    Incidents?: number[];
    Names?: LocalizedString[];
    PedestrianAccess?: string | redacted.Redacted<string>[];
    Region?: string | redacted.Redacted<string>;
    RoadAttributes?: string | redacted.Redacted<string>[];
    RouteNumbers?: RouteNumber[];
    SpeedLimit?: RouteSpanSpeedLimitDetails;
    TypicalDuration?: number;
}
export declare const RoutePedestrianSpan: S.Schema<RoutePedestrianSpan>;
export type RoutePedestrianSpanList = RoutePedestrianSpan[];
export declare const RoutePedestrianSpanList: S.$Array<S.Schema<RoutePedestrianSpan>>;
export interface RoutePedestrianOverviewSummary {
    Distance: number;
    Duration: number;
}
export declare const RoutePedestrianOverviewSummary: S.Schema<RoutePedestrianOverviewSummary>;
export interface RoutePedestrianTravelOnlySummary {
    Duration: number;
}
export declare const RoutePedestrianTravelOnlySummary: S.Schema<RoutePedestrianTravelOnlySummary>;
export interface RoutePedestrianSummary {
    Overview?: RoutePedestrianOverviewSummary;
    TravelOnly?: RoutePedestrianTravelOnlySummary;
}
export declare const RoutePedestrianSummary: S.Schema<RoutePedestrianSummary>;
export interface RouteContinueStepDetails {
    Intersection: LocalizedString[];
}
export declare const RouteContinueStepDetails: S.Schema<RouteContinueStepDetails>;
export interface RouteRoad {
    RoadName: LocalizedString[];
    RouteNumber: RouteNumber[];
    Towards: LocalizedString[];
    Type?: string | redacted.Redacted<string>;
}
export declare const RouteRoad: S.Schema<RouteRoad>;
export interface RouteKeepStepDetails {
    Intersection: LocalizedString[];
    SteeringDirection?: string | redacted.Redacted<string>;
    TurnAngle?: number;
    TurnIntensity?: string | redacted.Redacted<string>;
}
export declare const RouteKeepStepDetails: S.Schema<RouteKeepStepDetails>;
export interface RouteRoundaboutEnterStepDetails {
    Intersection: LocalizedString[];
    SteeringDirection?: string | redacted.Redacted<string>;
    TurnAngle?: number;
    TurnIntensity?: string | redacted.Redacted<string>;
}
export declare const RouteRoundaboutEnterStepDetails: S.Schema<RouteRoundaboutEnterStepDetails>;
export interface RouteRoundaboutExitStepDetails {
    Intersection: LocalizedString[];
    RelativeExit?: number;
    RoundaboutAngle?: number;
    SteeringDirection?: string | redacted.Redacted<string>;
}
export declare const RouteRoundaboutExitStepDetails: S.Schema<RouteRoundaboutExitStepDetails>;
export interface RouteRoundaboutPassStepDetails {
    Intersection: LocalizedString[];
    SteeringDirection?: string | redacted.Redacted<string>;
    TurnAngle?: number;
    TurnIntensity?: string | redacted.Redacted<string>;
}
export declare const RouteRoundaboutPassStepDetails: S.Schema<RouteRoundaboutPassStepDetails>;
export interface RouteSignpostLabel {
    RouteNumber?: RouteNumber;
    Text?: LocalizedString;
}
export declare const RouteSignpostLabel: S.Schema<RouteSignpostLabel>;
export type RouteSignpostLabelList = RouteSignpostLabel[];
export declare const RouteSignpostLabelList: S.$Array<S.Schema<RouteSignpostLabel>>;
export interface RouteSignpost {
    Labels: RouteSignpostLabel[];
}
export declare const RouteSignpost: S.Schema<RouteSignpost>;
export interface RouteTurnStepDetails {
    Intersection: LocalizedString[];
    SteeringDirection?: string | redacted.Redacted<string>;
    TurnAngle?: number;
    TurnIntensity?: string | redacted.Redacted<string>;
}
export declare const RouteTurnStepDetails: S.Schema<RouteTurnStepDetails>;
export interface RoutePedestrianTravelStep {
    ContinueStepDetails?: RouteContinueStepDetails;
    CurrentRoad?: RouteRoad;
    Distance?: number;
    Duration: number;
    ExitNumber?: LocalizedString[];
    GeometryOffset?: number;
    Instruction?: string | redacted.Redacted<string>;
    KeepStepDetails?: RouteKeepStepDetails;
    NextRoad?: RouteRoad;
    RoundaboutEnterStepDetails?: RouteRoundaboutEnterStepDetails;
    RoundaboutExitStepDetails?: RouteRoundaboutExitStepDetails;
    RoundaboutPassStepDetails?: RouteRoundaboutPassStepDetails;
    Signpost?: RouteSignpost;
    TurnStepDetails?: RouteTurnStepDetails;
    Type: string;
}
export declare const RoutePedestrianTravelStep: S.Schema<RoutePedestrianTravelStep>;
export type RoutePedestrianTravelStepList = RoutePedestrianTravelStep[];
export declare const RoutePedestrianTravelStepList: S.$Array<S.Schema<RoutePedestrianTravelStep>>;
export interface RoutePedestrianLegDetails {
    Arrival: RoutePedestrianArrival;
    Departure: RoutePedestrianDeparture;
    Notices: RoutePedestrianNotice[];
    PassThroughWaypoints: RoutePassThroughWaypoint[];
    Spans: RoutePedestrianSpan[];
    Summary?: RoutePedestrianSummary;
    TravelSteps: RoutePedestrianTravelStep[];
}
export declare const RoutePedestrianLegDetails: S.Schema<RoutePedestrianLegDetails>;
export interface RouteVehiclePlace {
    Name?: string | redacted.Redacted<string>;
    OriginalPosition?: number[];
    Position: number[];
    SideOfStreet?: string | redacted.Redacted<string>;
    WaypointIndex?: number;
}
export declare const RouteVehiclePlace: S.Schema<RouteVehiclePlace>;
export interface RouteVehicleArrival {
    Place: RouteVehiclePlace;
    Time?: string | redacted.Redacted<string>;
}
export declare const RouteVehicleArrival: S.Schema<RouteVehicleArrival>;
export interface RouteVehicleDeparture {
    Place: RouteVehiclePlace;
    Time?: string | redacted.Redacted<string>;
}
export declare const RouteVehicleDeparture: S.Schema<RouteVehicleDeparture>;
export interface RouteVehicleIncident {
    Description?: string | redacted.Redacted<string>;
    EndTime?: string | redacted.Redacted<string>;
    Severity?: string | redacted.Redacted<string>;
    StartTime?: string | redacted.Redacted<string>;
    Type?: string | redacted.Redacted<string>;
}
export declare const RouteVehicleIncident: S.Schema<RouteVehicleIncident>;
export type RouteVehicleIncidentList = RouteVehicleIncident[];
export declare const RouteVehicleIncidentList: S.$Array<S.Schema<RouteVehicleIncident>>;
export interface RouteNoticeDetailRange {
    Min?: number;
    Max?: number;
}
export declare const RouteNoticeDetailRange: S.Schema<RouteNoticeDetailRange>;
export interface RouteWeightConstraint {
    Type: string;
    Value: number;
}
export declare const RouteWeightConstraint: S.Schema<RouteWeightConstraint>;
export interface RouteViolatedConstraints {
    AllHazardsRestricted?: boolean;
    AxleCount?: RouteNoticeDetailRange;
    HazardousCargos: string | redacted.Redacted<string>[];
    MaxHeight?: number;
    MaxKpraLength?: number;
    MaxLength?: number;
    MaxPayloadCapacity?: number;
    MaxWeight?: RouteWeightConstraint;
    MaxWeightPerAxle?: number;
    MaxWeightPerAxleGroup?: WeightPerAxleGroup;
    MaxWidth?: number;
    Occupancy?: RouteNoticeDetailRange;
    RestrictedTimes?: string;
    TimeDependent?: boolean;
    TrailerCount?: RouteNoticeDetailRange;
    TravelMode?: boolean;
    TruckRoadType?: string;
    TruckType?: string | redacted.Redacted<string>;
    TunnelRestrictionCode?: string | redacted.Redacted<string>;
}
export declare const RouteViolatedConstraints: S.Schema<RouteViolatedConstraints>;
export interface RouteVehicleNoticeDetail {
    Title?: string | redacted.Redacted<string>;
    ViolatedConstraints?: RouteViolatedConstraints;
}
export declare const RouteVehicleNoticeDetail: S.Schema<RouteVehicleNoticeDetail>;
export type RouteVehicleNoticeDetailList = RouteVehicleNoticeDetail[];
export declare const RouteVehicleNoticeDetailList: S.$Array<S.Schema<RouteVehicleNoticeDetail>>;
export interface RouteVehicleNotice {
    Code: string;
    Details: RouteVehicleNoticeDetail[];
    Impact?: string;
}
export declare const RouteVehicleNotice: S.Schema<RouteVehicleNotice>;
export type RouteVehicleNoticeList = RouteVehicleNotice[];
export declare const RouteVehicleNoticeList: S.$Array<S.Schema<RouteVehicleNotice>>;
export type RouteSpanCarAccessAttributeList = string | redacted.Redacted<string>[];
export declare const RouteSpanCarAccessAttributeList: S.$Array<S.Schema<string | redacted.Redacted<string>>>;
export type RouteSpanScooterAccessAttributeList = string | redacted.Redacted<string>[];
export declare const RouteSpanScooterAccessAttributeList: S.$Array<S.Schema<string | redacted.Redacted<string>>>;
export type RouteSpanTruckAccessAttributeList = string | redacted.Redacted<string>[];
export declare const RouteSpanTruckAccessAttributeList: S.$Array<S.Schema<string | redacted.Redacted<string>>>;
export interface RouteVehicleSpan {
    BestCaseDuration?: number;
    CarAccess?: string | redacted.Redacted<string>[];
    Country?: string | redacted.Redacted<string>;
    Distance?: number;
    Duration?: number;
    DynamicSpeed?: RouteSpanDynamicSpeedDetails;
    FunctionalClassification?: number;
    Gate?: string | redacted.Redacted<string>;
    GeometryOffset?: number;
    Incidents?: number[];
    Names?: LocalizedString[];
    Notices?: number[];
    RailwayCrossing?: string | redacted.Redacted<string>;
    Region?: string | redacted.Redacted<string>;
    RoadAttributes?: string | redacted.Redacted<string>[];
    RouteNumbers?: RouteNumber[];
    ScooterAccess?: string | redacted.Redacted<string>[];
    SpeedLimit?: RouteSpanSpeedLimitDetails;
    TollSystems?: number[];
    TruckAccess?: string | redacted.Redacted<string>[];
    TruckRoadTypes?: number[];
    TypicalDuration?: number;
    Zones?: number[];
}
export declare const RouteVehicleSpan: S.Schema<RouteVehicleSpan>;
export type RouteVehicleSpanList = RouteVehicleSpan[];
export declare const RouteVehicleSpanList: S.$Array<S.Schema<RouteVehicleSpan>>;
export interface RouteVehicleOverviewSummary {
    BestCaseDuration?: number;
    Distance: number;
    Duration: number;
    TypicalDuration?: number;
}
export declare const RouteVehicleOverviewSummary: S.Schema<RouteVehicleOverviewSummary>;
export interface RouteVehicleTravelOnlySummary {
    BestCaseDuration?: number;
    Duration: number;
    TypicalDuration?: number;
}
export declare const RouteVehicleTravelOnlySummary: S.Schema<RouteVehicleTravelOnlySummary>;
export interface RouteVehicleSummary {
    Overview?: RouteVehicleOverviewSummary;
    TravelOnly?: RouteVehicleTravelOnlySummary;
}
export declare const RouteVehicleSummary: S.Schema<RouteVehicleSummary>;
export interface RouteTollPaymentSite {
    Name?: string;
    Position: number[];
}
export declare const RouteTollPaymentSite: S.Schema<RouteTollPaymentSite>;
export type RouteTollPaymentSiteList = RouteTollPaymentSite[];
export declare const RouteTollPaymentSiteList: S.$Array<S.Schema<RouteTollPaymentSite>>;
export interface RouteTollPriceValueRange {
    Min: number;
    Max: number;
}
export declare const RouteTollPriceValueRange: S.Schema<RouteTollPriceValueRange>;
export interface RouteTollPrice {
    Currency: string;
    Estimate: boolean;
    PerDuration?: number;
    Range: boolean;
    RangeValue?: RouteTollPriceValueRange;
    Value: number;
}
export declare const RouteTollPrice: S.Schema<RouteTollPrice>;
export interface RouteTollPassValidityPeriod {
    Period: string | redacted.Redacted<string>;
    PeriodCount?: number;
}
export declare const RouteTollPassValidityPeriod: S.Schema<RouteTollPassValidityPeriod>;
export interface RouteTollPass {
    IncludesReturnTrip?: boolean;
    SeniorPass?: boolean;
    TransferCount?: number;
    TripCount?: number;
    ValidityPeriod?: RouteTollPassValidityPeriod;
}
export declare const RouteTollPass: S.Schema<RouteTollPass>;
export type RouteTollPaymentMethodList = string | redacted.Redacted<string>[];
export declare const RouteTollPaymentMethodList: S.$Array<S.Schema<string | redacted.Redacted<string>>>;
export interface RouteTransponder {
    SystemName?: string | redacted.Redacted<string>;
}
export declare const RouteTransponder: S.Schema<RouteTransponder>;
export type RouteTransponderList = RouteTransponder[];
export declare const RouteTransponderList: S.$Array<S.Schema<RouteTransponder>>;
export interface RouteTollRate {
    ApplicableTimes?: string | redacted.Redacted<string>;
    ConvertedPrice?: RouteTollPrice;
    Id: string | redacted.Redacted<string>;
    LocalPrice: RouteTollPrice;
    Name: string | redacted.Redacted<string>;
    Pass?: RouteTollPass;
    PaymentMethods: string | redacted.Redacted<string>[];
    Transponders: RouteTransponder[];
}
export declare const RouteTollRate: S.Schema<RouteTollRate>;
export type RouteTollRateList = RouteTollRate[];
export declare const RouteTollRateList: S.$Array<S.Schema<RouteTollRate>>;
export interface RouteToll {
    Country?: string | redacted.Redacted<string>;
    PaymentSites: RouteTollPaymentSite[];
    Rates: RouteTollRate[];
    Systems: number[];
}
export declare const RouteToll: S.Schema<RouteToll>;
export type RouteTollList = RouteToll[];
export declare const RouteTollList: S.$Array<S.Schema<RouteToll>>;
export interface RouteTollSystem {
    Name?: string | redacted.Redacted<string>;
}
export declare const RouteTollSystem: S.Schema<RouteTollSystem>;
export type RouteTollSystemList = RouteTollSystem[];
export declare const RouteTollSystemList: S.$Array<S.Schema<RouteTollSystem>>;
export interface RouteContinueHighwayStepDetails {
    Intersection: LocalizedString[];
    SteeringDirection?: string | redacted.Redacted<string>;
    TurnAngle?: number;
    TurnIntensity?: string | redacted.Redacted<string>;
}
export declare const RouteContinueHighwayStepDetails: S.Schema<RouteContinueHighwayStepDetails>;
export interface RouteEnterHighwayStepDetails {
    Intersection: LocalizedString[];
    SteeringDirection?: string | redacted.Redacted<string>;
    TurnAngle?: number;
    TurnIntensity?: string | redacted.Redacted<string>;
}
export declare const RouteEnterHighwayStepDetails: S.Schema<RouteEnterHighwayStepDetails>;
export interface RouteExitStepDetails {
    Intersection: LocalizedString[];
    RelativeExit?: number;
    SteeringDirection?: string | redacted.Redacted<string>;
    TurnAngle?: number;
    TurnIntensity?: string | redacted.Redacted<string>;
}
export declare const RouteExitStepDetails: S.Schema<RouteExitStepDetails>;
export interface RouteRampStepDetails {
    Intersection: LocalizedString[];
    SteeringDirection?: string | redacted.Redacted<string>;
    TurnAngle?: number;
    TurnIntensity?: string | redacted.Redacted<string>;
}
export declare const RouteRampStepDetails: S.Schema<RouteRampStepDetails>;
export interface RouteUTurnStepDetails {
    Intersection: LocalizedString[];
    SteeringDirection?: string | redacted.Redacted<string>;
    TurnAngle?: number;
    TurnIntensity?: string | redacted.Redacted<string>;
}
export declare const RouteUTurnStepDetails: S.Schema<RouteUTurnStepDetails>;
export interface RouteVehicleTravelStep {
    ContinueHighwayStepDetails?: RouteContinueHighwayStepDetails;
    ContinueStepDetails?: RouteContinueStepDetails;
    CurrentRoad?: RouteRoad;
    Distance?: number;
    Duration: number;
    EnterHighwayStepDetails?: RouteEnterHighwayStepDetails;
    ExitNumber?: LocalizedString[];
    ExitStepDetails?: RouteExitStepDetails;
    GeometryOffset?: number;
    Instruction?: string | redacted.Redacted<string>;
    KeepStepDetails?: RouteKeepStepDetails;
    NextRoad?: RouteRoad;
    RampStepDetails?: RouteRampStepDetails;
    RoundaboutEnterStepDetails?: RouteRoundaboutEnterStepDetails;
    RoundaboutExitStepDetails?: RouteRoundaboutExitStepDetails;
    RoundaboutPassStepDetails?: RouteRoundaboutPassStepDetails;
    Signpost?: RouteSignpost;
    TurnStepDetails?: RouteTurnStepDetails;
    Type: string | redacted.Redacted<string>;
    UTurnStepDetails?: RouteUTurnStepDetails;
}
export declare const RouteVehicleTravelStep: S.Schema<RouteVehicleTravelStep>;
export type RouteVehicleTravelStepList = RouteVehicleTravelStep[];
export declare const RouteVehicleTravelStepList: S.$Array<S.Schema<RouteVehicleTravelStep>>;
export interface RouteZone {
    Category?: string | redacted.Redacted<string>;
    Name?: string | redacted.Redacted<string>;
}
export declare const RouteZone: S.Schema<RouteZone>;
export type RouteZoneList = RouteZone[];
export declare const RouteZoneList: S.$Array<S.Schema<RouteZone>>;
export interface RouteVehicleLegDetails {
    Arrival: RouteVehicleArrival;
    Departure: RouteVehicleDeparture;
    Incidents: RouteVehicleIncident[];
    Notices: RouteVehicleNotice[];
    PassThroughWaypoints: RoutePassThroughWaypoint[];
    Spans: RouteVehicleSpan[];
    Summary?: RouteVehicleSummary;
    Tolls: RouteToll[];
    TollSystems: RouteTollSystem[];
    TravelSteps: RouteVehicleTravelStep[];
    TruckRoadTypes: string | redacted.Redacted<string>[];
    Zones: RouteZone[];
}
export declare const RouteVehicleLegDetails: S.Schema<RouteVehicleLegDetails>;
export interface RouteLeg {
    FerryLegDetails?: RouteFerryLegDetails;
    Geometry: RouteLegGeometry;
    Language?: string;
    PedestrianLegDetails?: RoutePedestrianLegDetails;
    TravelMode: string | redacted.Redacted<string>;
    Type: string | redacted.Redacted<string>;
    VehicleLegDetails?: RouteVehicleLegDetails;
}
export declare const RouteLeg: S.Schema<RouteLeg>;
export type RouteLegList = RouteLeg[];
export declare const RouteLegList: S.$Array<S.Schema<RouteLeg>>;
export interface RouteMajorRoadLabel {
    RoadName?: LocalizedString;
    RouteNumber?: RouteNumber;
}
export declare const RouteMajorRoadLabel: S.Schema<RouteMajorRoadLabel>;
export type RouteMajorRoadLabelList = RouteMajorRoadLabel[];
export declare const RouteMajorRoadLabelList: S.$Array<S.Schema<RouteMajorRoadLabel>>;
export interface RouteTollPriceSummary {
    Currency: string;
    Estimate: boolean;
    Range: boolean;
    RangeValue?: RouteTollPriceValueRange;
    Value: number;
}
export declare const RouteTollPriceSummary: S.Schema<RouteTollPriceSummary>;
export interface RouteTollSummary {
    Total?: RouteTollPriceSummary;
}
export declare const RouteTollSummary: S.Schema<RouteTollSummary>;
export interface RouteSummary {
    Distance?: number;
    Duration?: number;
    Tolls?: RouteTollSummary;
}
export declare const RouteSummary: S.Schema<RouteSummary>;
export interface Route {
    Legs: RouteLeg[];
    MajorRoadLabels: RouteMajorRoadLabel[];
    Summary?: RouteSummary;
}
export declare const Route: S.Schema<Route>;
export type RouteList = Route[];
export declare const RouteList: S.$Array<S.Schema<Route>>;
export interface CalculateRoutesResponse {
    LegGeometryFormat: string;
    Notices: RouteResponseNotice[];
    PricingBucket: string;
    Routes: Route[];
}
export declare const CalculateRoutesResponse: S.Schema<CalculateRoutesResponse>;
export interface WaypointOptimizationAvoidanceAreaGeometry {
    BoundingBox?: number[];
}
export declare const WaypointOptimizationAvoidanceAreaGeometry: S.Schema<WaypointOptimizationAvoidanceAreaGeometry>;
export interface WaypointOptimizationAvoidanceArea {
    Geometry: WaypointOptimizationAvoidanceAreaGeometry;
}
export declare const WaypointOptimizationAvoidanceArea: S.Schema<WaypointOptimizationAvoidanceArea>;
export type WaypointOptimizationAvoidanceAreaList = WaypointOptimizationAvoidanceArea[];
export declare const WaypointOptimizationAvoidanceAreaList: S.$Array<S.Schema<WaypointOptimizationAvoidanceArea>>;
export interface WaypointOptimizationAvoidanceOptions {
    Areas?: WaypointOptimizationAvoidanceArea[];
    CarShuttleTrains?: boolean;
    ControlledAccessHighways?: boolean;
    DirtRoads?: boolean;
    Ferries?: boolean;
    TollRoads?: boolean;
    Tunnels?: boolean;
    UTurns?: boolean;
}
export declare const WaypointOptimizationAvoidanceOptions: S.Schema<WaypointOptimizationAvoidanceOptions>;
export interface WaypointOptimizationDrivingDistanceOptions {
    DrivingDistance: number;
}
export declare const WaypointOptimizationDrivingDistanceOptions: S.Schema<WaypointOptimizationDrivingDistanceOptions>;
export interface WaypointOptimizationClusteringOptions {
    Algorithm: string | redacted.Redacted<string>;
    DrivingDistanceOptions?: WaypointOptimizationDrivingDistanceOptions;
}
export declare const WaypointOptimizationClusteringOptions: S.Schema<WaypointOptimizationClusteringOptions>;
export interface WaypointOptimizationAccessHoursEntry {
    DayOfWeek: string | redacted.Redacted<string>;
    TimeOfDay: string | redacted.Redacted<string>;
}
export declare const WaypointOptimizationAccessHoursEntry: S.Schema<WaypointOptimizationAccessHoursEntry>;
export interface WaypointOptimizationAccessHours {
    From: WaypointOptimizationAccessHoursEntry;
    To: WaypointOptimizationAccessHoursEntry;
}
export declare const WaypointOptimizationAccessHours: S.Schema<WaypointOptimizationAccessHours>;
export interface WaypointOptimizationSideOfStreetOptions {
    Position: number[];
    UseWith?: string;
}
export declare const WaypointOptimizationSideOfStreetOptions: S.Schema<WaypointOptimizationSideOfStreetOptions>;
export interface WaypointOptimizationDestinationOptions {
    AccessHours?: WaypointOptimizationAccessHours;
    AppointmentTime?: string | redacted.Redacted<string>;
    Heading?: number;
    Id?: string;
    ServiceDuration?: number;
    SideOfStreet?: WaypointOptimizationSideOfStreetOptions;
}
export declare const WaypointOptimizationDestinationOptions: S.Schema<WaypointOptimizationDestinationOptions>;
export interface WaypointOptimizationRestCycleDurations {
    RestDuration: number;
    WorkDuration: number;
}
export declare const WaypointOptimizationRestCycleDurations: S.Schema<WaypointOptimizationRestCycleDurations>;
export interface WaypointOptimizationRestCycles {
    LongCycle: WaypointOptimizationRestCycleDurations;
    ShortCycle: WaypointOptimizationRestCycleDurations;
}
export declare const WaypointOptimizationRestCycles: S.Schema<WaypointOptimizationRestCycles>;
export interface WaypointOptimizationRestProfile {
    Profile: string | redacted.Redacted<string>;
}
export declare const WaypointOptimizationRestProfile: S.Schema<WaypointOptimizationRestProfile>;
export interface WaypointOptimizationDriverOptions {
    RestCycles?: WaypointOptimizationRestCycles;
    RestProfile?: WaypointOptimizationRestProfile;
    TreatServiceTimeAs?: string | redacted.Redacted<string>;
}
export declare const WaypointOptimizationDriverOptions: S.Schema<WaypointOptimizationDriverOptions>;
export interface WaypointOptimizationExclusionOptions {
    Countries: string | redacted.Redacted<string>[];
}
export declare const WaypointOptimizationExclusionOptions: S.Schema<WaypointOptimizationExclusionOptions>;
export interface WaypointOptimizationOriginOptions {
    Id?: string;
}
export declare const WaypointOptimizationOriginOptions: S.Schema<WaypointOptimizationOriginOptions>;
export interface WaypointOptimizationTrafficOptions {
    Usage?: string;
}
export declare const WaypointOptimizationTrafficOptions: S.Schema<WaypointOptimizationTrafficOptions>;
export interface WaypointOptimizationPedestrianOptions {
    Speed?: number;
}
export declare const WaypointOptimizationPedestrianOptions: S.Schema<WaypointOptimizationPedestrianOptions>;
export type WaypointOptimizationHazardousCargoTypeList = string | redacted.Redacted<string>[];
export declare const WaypointOptimizationHazardousCargoTypeList: S.$Array<S.Schema<string | redacted.Redacted<string>>>;
export interface WaypointOptimizationTrailerOptions {
    TrailerCount?: number;
}
export declare const WaypointOptimizationTrailerOptions: S.Schema<WaypointOptimizationTrailerOptions>;
export interface WaypointOptimizationTruckOptions {
    GrossWeight?: number;
    HazardousCargos?: string | redacted.Redacted<string>[];
    Height?: number;
    Length?: number;
    Trailer?: WaypointOptimizationTrailerOptions;
    TruckType?: string | redacted.Redacted<string>;
    TunnelRestrictionCode?: string | redacted.Redacted<string>;
    WeightPerAxle?: number;
    Width?: number;
}
export declare const WaypointOptimizationTruckOptions: S.Schema<WaypointOptimizationTruckOptions>;
export interface WaypointOptimizationTravelModeOptions {
    Pedestrian?: WaypointOptimizationPedestrianOptions;
    Truck?: WaypointOptimizationTruckOptions;
}
export declare const WaypointOptimizationTravelModeOptions: S.Schema<WaypointOptimizationTravelModeOptions>;
export type BeforeWaypointsList = number[];
export declare const BeforeWaypointsList: S.$Array<S.Number>;
export interface WaypointOptimizationWaypoint {
    AccessHours?: WaypointOptimizationAccessHours;
    AppointmentTime?: string | redacted.Redacted<string>;
    Before?: number[];
    Heading?: number;
    Id?: string;
    Position: number[];
    ServiceDuration?: number;
    SideOfStreet?: WaypointOptimizationSideOfStreetOptions;
}
export declare const WaypointOptimizationWaypoint: S.Schema<WaypointOptimizationWaypoint>;
export type WaypointOptimizationWaypointList = WaypointOptimizationWaypoint[];
export declare const WaypointOptimizationWaypointList: S.$Array<S.Schema<WaypointOptimizationWaypoint>>;
export interface OptimizeWaypointsRequest {
    Avoid?: WaypointOptimizationAvoidanceOptions;
    Clustering?: WaypointOptimizationClusteringOptions;
    DepartureTime?: string | redacted.Redacted<string>;
    Destination?: number[];
    DestinationOptions?: WaypointOptimizationDestinationOptions;
    Driver?: WaypointOptimizationDriverOptions;
    Exclude?: WaypointOptimizationExclusionOptions;
    Key?: string | redacted.Redacted<string>;
    OptimizeSequencingFor?: string;
    Origin: number[];
    OriginOptions?: WaypointOptimizationOriginOptions;
    Traffic?: WaypointOptimizationTrafficOptions;
    TravelMode?: string;
    TravelModeOptions?: WaypointOptimizationTravelModeOptions;
    Waypoints?: WaypointOptimizationWaypoint[];
}
export declare const OptimizeWaypointsRequest: S.Schema<OptimizeWaypointsRequest>;
export interface WaypointOptimizationConnection {
    Distance: number;
    From: string;
    RestDuration: number;
    To: string;
    TravelDuration: number;
    WaitDuration: number;
}
export declare const WaypointOptimizationConnection: S.Schema<WaypointOptimizationConnection>;
export type WaypointOptimizationConnectionList = WaypointOptimizationConnection[];
export declare const WaypointOptimizationConnectionList: S.$Array<S.Schema<WaypointOptimizationConnection>>;
export interface WaypointOptimizationFailedConstraint {
    Constraint?: string | redacted.Redacted<string>;
    Reason?: string | redacted.Redacted<string>;
}
export declare const WaypointOptimizationFailedConstraint: S.Schema<WaypointOptimizationFailedConstraint>;
export type WaypointOptimizationFailedConstraintList = WaypointOptimizationFailedConstraint[];
export declare const WaypointOptimizationFailedConstraintList: S.$Array<S.Schema<WaypointOptimizationFailedConstraint>>;
export interface WaypointOptimizationImpedingWaypoint {
    FailedConstraints: WaypointOptimizationFailedConstraint[];
    Id: string;
    Position: number[];
}
export declare const WaypointOptimizationImpedingWaypoint: S.Schema<WaypointOptimizationImpedingWaypoint>;
export type WaypointOptimizationImpedingWaypointList = WaypointOptimizationImpedingWaypoint[];
export declare const WaypointOptimizationImpedingWaypointList: S.$Array<S.Schema<WaypointOptimizationImpedingWaypoint>>;
export interface WaypointOptimizationOptimizedWaypoint {
    ArrivalTime?: string | redacted.Redacted<string>;
    ClusterIndex?: number;
    DepartureTime: string | redacted.Redacted<string>;
    Id: string;
    Position: number[];
}
export declare const WaypointOptimizationOptimizedWaypoint: S.Schema<WaypointOptimizationOptimizedWaypoint>;
export type WaypointOptimizationOptimizedWaypointList = WaypointOptimizationOptimizedWaypoint[];
export declare const WaypointOptimizationOptimizedWaypointList: S.$Array<S.Schema<WaypointOptimizationOptimizedWaypoint>>;
export interface WaypointOptimizationTimeBreakdown {
    RestDuration: number;
    ServiceDuration: number;
    TravelDuration: number;
    WaitDuration: number;
}
export declare const WaypointOptimizationTimeBreakdown: S.Schema<WaypointOptimizationTimeBreakdown>;
export interface OptimizeWaypointsResponse {
    Connections: WaypointOptimizationConnection[];
    Distance: number;
    Duration: number;
    ImpedingWaypoints: WaypointOptimizationImpedingWaypoint[];
    OptimizedWaypoints: WaypointOptimizationOptimizedWaypoint[];
    PricingBucket: string;
    TimeBreakdown: WaypointOptimizationTimeBreakdown;
}
export declare const OptimizeWaypointsResponse: S.Schema<OptimizeWaypointsResponse>;
export interface RoadSnapTracePoint {
    Heading?: number;
    Position: number[];
    Speed?: number;
    Timestamp?: string | redacted.Redacted<string>;
}
export declare const RoadSnapTracePoint: S.Schema<RoadSnapTracePoint>;
export type RoadSnapTracePointList = RoadSnapTracePoint[];
export declare const RoadSnapTracePointList: S.$Array<S.Schema<RoadSnapTracePoint>>;
export type RoadSnapHazardousCargoTypeList = string | redacted.Redacted<string>[];
export declare const RoadSnapHazardousCargoTypeList: S.$Array<S.Schema<string | redacted.Redacted<string>>>;
export interface RoadSnapTrailerOptions {
    TrailerCount?: number;
}
export declare const RoadSnapTrailerOptions: S.Schema<RoadSnapTrailerOptions>;
export interface RoadSnapTruckOptions {
    GrossWeight?: number;
    HazardousCargos?: string | redacted.Redacted<string>[];
    Height?: number;
    Length?: number;
    Trailer?: RoadSnapTrailerOptions;
    TunnelRestrictionCode?: string | redacted.Redacted<string>;
    Width?: number;
}
export declare const RoadSnapTruckOptions: S.Schema<RoadSnapTruckOptions>;
export interface RoadSnapTravelModeOptions {
    Truck?: RoadSnapTruckOptions;
}
export declare const RoadSnapTravelModeOptions: S.Schema<RoadSnapTravelModeOptions>;
export interface SnapToRoadsRequest {
    Key?: string | redacted.Redacted<string>;
    SnappedGeometryFormat?: string;
    SnapRadius?: number;
    TracePoints: RoadSnapTracePoint[];
    TravelMode?: string;
    TravelModeOptions?: RoadSnapTravelModeOptions;
}
export declare const SnapToRoadsRequest: S.Schema<SnapToRoadsRequest>;
export type RoadSnapTracePointIndexList = number[];
export declare const RoadSnapTracePointIndexList: S.$Array<S.Number>;
export interface RoadSnapNotice {
    Code: string | redacted.Redacted<string>;
    Title: string | redacted.Redacted<string>;
    TracePointIndexes: number[];
}
export declare const RoadSnapNotice: S.Schema<RoadSnapNotice>;
export type RoadSnapNoticeList = RoadSnapNotice[];
export declare const RoadSnapNoticeList: S.$Array<S.Schema<RoadSnapNotice>>;
export interface RoadSnapSnappedGeometry {
    LineString?: number[][];
    Polyline?: string | redacted.Redacted<string>;
}
export declare const RoadSnapSnappedGeometry: S.Schema<RoadSnapSnappedGeometry>;
export interface RoadSnapSnappedTracePoint {
    Confidence: number;
    OriginalPosition: number[];
    SnappedPosition: number[];
}
export declare const RoadSnapSnappedTracePoint: S.Schema<RoadSnapSnappedTracePoint>;
export type RoadSnapSnappedTracePointList = RoadSnapSnappedTracePoint[];
export declare const RoadSnapSnappedTracePointList: S.$Array<S.Schema<RoadSnapSnappedTracePoint>>;
export interface SnapToRoadsResponse {
    Notices: RoadSnapNotice[];
    PricingBucket: string;
    SnappedGeometry?: RoadSnapSnappedGeometry;
    SnappedGeometryFormat: string;
    SnappedTracePoints: RoadSnapSnappedTracePoint[];
}
export declare const SnapToRoadsResponse: S.Schema<SnapToRoadsResponse>;
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;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class InternalServerException extends InternalServerException_base {
}
declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
    readonly Message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly Message: S.String;
    readonly Reason: S.String;
    readonly FieldList: S.$Array<S.Schema<ValidationExceptionField>>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
export type CalculateIsolinesError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Calculates areas that can be reached within specified time or distance thresholds from a given point. For example, you can use this operation to determine the area within a 30-minute drive of a store location, find neighborhoods within walking distance of a school, or identify delivery zones based on drive time.
 *
 * Isolines (also known as isochrones for time-based calculations) are useful for various applications including:
 *
 * - Service area visualization - Show customers the area you can serve within promised delivery times
 *
 * - Site selection - Analyze potential business locations based on population within travel distance
 *
 * - Site selection - Determine areas that can be reached within specified response times
 *
 * Route preferences such as avoiding toll roads or ferries are treated as preferences rather than absolute restrictions. If a viable route cannot be calculated while honoring all preferences, some may be ignored.
 *
 * For more information, see Calculate isolines in the *Amazon Location Service Developer Guide*.
 */
export declare const calculateIsolines: API.OperationMethod<CalculateIsolinesRequest, CalculateIsolinesResponse, CalculateIsolinesError, Credentials | Region | HttpClient.HttpClient>;
export type CalculateRouteMatrixError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Use `CalculateRouteMatrix` to compute results for all pairs of Origins to Destinations. Each row corresponds to one entry in Origins. Each entry in the row corresponds to the route from that entry in Origins to an entry in Destinations positions.
 *
 * For more information, see Calculate route matrix in the *Amazon Location Service Developer Guide*.
 */
export declare const calculateRouteMatrix: API.OperationMethod<CalculateRouteMatrixRequest, CalculateRouteMatrixResponse, CalculateRouteMatrixError, Credentials | Region | HttpClient.HttpClient>;
export type CalculateRoutesError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * `CalculateRoutes` computes routes given the following required parameters: `Origin` and `Destination`.
 *
 * For more information, see Calculate routes in the *Amazon Location Service Developer Guide*.
 */
export declare const calculateRoutes: API.OperationMethod<CalculateRoutesRequest, CalculateRoutesResponse, CalculateRoutesError, Credentials | Region | HttpClient.HttpClient>;
export type OptimizeWaypointsError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * `OptimizeWaypoints` calculates the optimal order to travel between a set of waypoints to minimize either the travel time or the distance travelled during the journey, based on road network restrictions and the traffic pattern data.
 *
 * For more information, see Optimize waypoints in the *Amazon Location Service Developer Guide*.
 */
export declare const optimizeWaypoints: API.OperationMethod<OptimizeWaypointsRequest, OptimizeWaypointsResponse, OptimizeWaypointsError, Credentials | Region | HttpClient.HttpClient>;
export type SnapToRoadsError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * `SnapToRoads` matches GPS trace to roads most likely traveled on.
 *
 * For more information, see Snap to Roads in the *Amazon Location Service Developer Guide*.
 */
export declare const snapToRoads: API.OperationMethod<SnapToRoadsRequest, SnapToRoadsResponse, SnapToRoadsError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=geo-routes.d.ts.map