export interface IsolineAllowOptions {
    /** Allow Hot (High Occupancy Toll) lanes while calculating an isoline. Default value: false */
    Hot?: boolean;
    /** Allow Hov (High Occupancy vehicle) lanes while calculating an isoline. Default value: false */
    Hov?: boolean;
}
export interface IsolineAvoidanceOptions {
    /** Areas to be avoided. */
    Areas?: any[];
    /** Avoid car-shuttle-trains while calculating an isoline. */
    CarShuttleTrains?: boolean;
    /** Avoid controlled access highways while calculating an isoline. */
    ControlledAccessHighways?: boolean;
    /** Avoid dirt roads while calculating an isoline. */
    DirtRoads?: boolean;
    /** Avoid ferries while calculating an isoline. */
    Ferries?: boolean;
    /** Avoid roads that have seasonal closure while calculating an isoline. */
    SeasonalClosure?: boolean;
    /** Avoids roads where the specified toll transponders are the only mode of payment. */
    TollRoads?: boolean;
    /** Avoids roads where the specified toll transponders are the only mode of payment. */
    TollTransponders?: boolean;
    /** Truck road type identifiers. BK1 through BK4 apply only to Sweden. A2,A4,B2,B4,C,D,ET2,ET4 apply only to Mexico. There are currently no other supported values as of 26th April 2024. */
    TruckRoadTypes?: string[];
    /** Avoid tunnels while calculating an isoline. */
    Tunnels?: boolean;
    /** Avoid U-turns for calculation on highways and motorways. */
    UTurns?: boolean;
    /** Zone categories to be avoided. */
    ZoneCategories?: any[];
}
export interface IsolineMatchingOptions {
    /** Attempts to match the provided position to a road similar to the provided name. */
    NameHint?: string;
    /** If the distance to a highway/bridge/tunnel/sliproad is within threshold, the waypoint will be snapped to the highway/bridge/tunnel/sliproad. Unit: meters */
    OnRoadThreshold?: number;
    /** Considers all roads within the provided radius to match the provided destination to. The roads that are considered are determined by the provided Strategy. Unit: Meters */
    Radius?: number;
    /** Strategy that defines matching of the position onto the road network. MatchAny considers all roads possible, whereas MatchMostSignificantRoad matches to the most significant road. */
    Strategy?: 'MatchAny' | 'MatchMostSignificantRoad';
}
export interface IsolineSideOfStreetOptions {
    /** Position defined as [longitude, latitude]. */
    Position: any[];
    /** Strategy that defines when the side of street position should be used. AnyStreet will always use the provided position. Default Value: DividedStreetOnly */
    UseWith?: 'AnyStreet' | 'DividedStreetOnly';
}
export interface IsolineDestinationOptions {
    /** Avoids actions for the provided distance. This is typically to consider for users in moving vehicles who may not have sufficient time to make an action at an origin or a destination. */
    AvoidActionsForDistance?: number;
    /** GPS Heading at the position. */
    Heading?: number;
    /** Options to configure matching the provided position to the road network. */
    Matching?: IsolineMatchingOptions;
    /** Options to configure matching the provided position to a side of the street. */
    SideOfStreet?: IsolineSideOfStreetOptions;
}
export interface IsolineGranularityOptions {
    /** Maximum number of points of returned Isoline. */
    MaxPoints?: number;
    /** Maximum resolution of the returned isoline. Unit: meters */
    MaxResolution?: number;
}
export interface IsolineOriginOptions {
    /** Avoids actions for the provided distance. This is typically to consider for users in moving vehicles who may not have sufficient time to make an action at an origin or a destination. */
    AvoidActionsForDistance?: number;
    /** GPS Heading at the position. */
    Heading?: number;
    /** Options to configure matching the provided position to the road network. */
    Matching?: IsolineMatchingOptions;
    /** Options to configure matching the provided position to a side of the street. */
    SideOfStreet?: IsolineSideOfStreetOptions;
}
export interface IsolineThresholds {
    /** Distance to be used for the isoline calculation. */
    Distance?: number[];
    /** Time to be used for the isoline calculation. */
    Time?: number[];
}
export interface IsolineTrafficOptions {
    /** Duration for which flow traffic is considered valid. For this period, the flow traffic is used over historical traffic data. Flow traffic refers to congestion, which changes very quickly. Duration in  */
    FlowEventThresholdOverride?: number;
    /** Determines if traffic should be used or ignored while calculating the route. Default Value: UseTrafficData */
    Usage?: 'IgnoreTrafficData' | 'UseTrafficData';
}
export interface IsolineCarOptions {
    /** Engine type of the vehicle. */
    EngineType?: 'Electric' | 'InternalCombustion' | 'PluginHybrid';
    /** The vehicle License Plate. */
    LicensePlate?: any;
    /** Maximum speed. Unit: KilometersPerHour */
    MaxSpeed?: number;
    /** The number of occupants in the vehicle. Default Value: 1 */
    Occupancy?: number;
}
export interface IsolineScooterOptions {
    /** Engine type of the vehicle. */
    EngineType?: 'Electric' | 'InternalCombustion' | 'PluginHybrid';
    /** The vehicle License Plate. */
    LicensePlate?: any;
    /** Maximum speed specified. Unit: KilometersPerHour */
    MaxSpeed?: number;
    /** The number of occupants in the vehicle. Default Value: 1 */
    Occupancy?: number;
}
export interface IsolineTruckOptions {
    /** Total number of axles of the vehicle. */
    AxleCount?: number;
    /** Engine type of the vehicle. */
    EngineType?: 'Electric' | 'InternalCombustion' | 'PluginHybrid';
    /** Gross weight of the vehicle including trailers, and goods at capacity. Unit: Kilograms */
    GrossWeight?: number;
    /** List of Hazardous cargo contained in the vehicle. */
    HazardousCargos?: any[];
    /** Height of the vehicle. Unit: centimeters */
    Height?: number;
    /** Height of the vehicle above its first axle. Unit: centimeters */
    HeightAboveFirstAxle?: number;
    /** Kingpin to rear axle length of the vehicle. Unit: centimeters */
    KpraLength?: number;
    /** Length of the vehicle. Unit: centimeters */
    Length?: number;
    /** The vehicle License Plate. */
    LicensePlate?: any;
    /** Maximum speed specified. Unit: KilometersPerHour */
    MaxSpeed?: number;
    /** The number of occupants in the vehicle. Default Value: 1 */
    Occupancy?: number;
    /** Payload capacity of the vehicle and trailers attached. Unit: kilograms */
    PayloadCapacity?: number;
    /** Number of tires on the vehicle. */
    TireCount?: number;
    /** Trailer options corresponding to the vehicle. */
    Trailer?: any;
    /** Type of the truck. */
    TruckType?: 'LightTruck' | 'StraightTruck' | 'Tractor';
    /** The tunnel restriction code. Tunnel categories in this list indicate the restrictions which apply to certain tunnels in Great Britain. They relate to the types of dangerous goods that can be transport */
    TunnelRestrictionCode?: string;
    /** Heaviest weight per axle irrespective of the axle type or the axle group. Meant for usage in countries where the differences in axle types or axle groups are not distinguished. Unit: Kilograms */
    WeightPerAxle?: number;
    /** Specifies the total weight for the specified axle group. Meant for usage in countries that have different regulations based on the axle group type. Unit: Kilograms */
    WeightPerAxleGroup?: any;
    /** Width of the vehicle. Unit: centimeters */
    Width?: number;
}
export interface IsolineTravelModeOptions {
    /** Travel mode options when the provided travel mode is "Car" */
    Car?: IsolineCarOptions;
    /** Travel mode options when the provided travel mode is Scooter When travel mode is set to Scooter, then the avoidance option ControlledAccessHighways defaults to true. */
    Scooter?: IsolineScooterOptions;
    /** Travel mode options when the provided travel mode is "Truck" */
    Truck?: IsolineTruckOptions;
}
export interface RouteMatrixAllowOptions {
    /** Allow Hot (High Occupancy Toll) lanes while calculating the route. Default value: false */
    Hot?: boolean;
    /** Allow Hov (High Occupancy vehicle) lanes while calculating the route. Default value: false */
    Hov?: boolean;
}
export interface RouteMatrixAvoidanceOptions {
    /** Areas to be avoided. */
    Areas?: any[];
    /** Avoid car-shuttle-trains while calculating the route. */
    CarShuttleTrains?: boolean;
    /** Avoid controlled access highways while calculating the route. */
    ControlledAccessHighways?: boolean;
    /** Avoid dirt roads while calculating the route. */
    DirtRoads?: boolean;
    /** Avoid ferries while calculating the route. */
    Ferries?: boolean;
    /** Avoids roads where the specified toll transponders are the only mode of payment. */
    TollRoads?: boolean;
    /** Avoids roads where the specified toll transponders are the only mode of payment. */
    TollTransponders?: boolean;
    /** Truck road type identifiers. BK1 through BK4 apply only to Sweden. A2,A4,B2,B4,C,D,ET2,ET4 apply only to Mexico. There are currently no other supported values as of 26th April 2024. */
    TruckRoadTypes?: string[];
    /** Avoid tunnels while calculating the route. */
    Tunnels?: boolean;
    /** Avoid U-turns for calculation on highways and motorways. */
    UTurns?: boolean;
    /** Zone categories to be avoided. */
    ZoneCategories?: any[];
}
export interface RouteMatrixDestination {
    /** Destination related options. */
    Options?: any;
    /** Position defined as [longitude, latitude]. */
    Position: any[];
}
export interface RouteMatrixExclusionOptions {
    /** List of countries to be avoided defined by two-letter or three-letter country codes. */
    Countries: string[];
}
export interface RouteMatrixOrigin {
    /** Origin related options. */
    Options?: any;
    /** Position defined as [longitude, latitude]. */
    Position: any[];
}
export interface RouteMatrixBoundaryGeometry {
    /** Provides the circle that was used while calculating the route. */
    AutoCircle?: any;
    /** Geometry defined as a circle. When request routing boundary was set as AutoCircle, the response routing boundary will return Circle derived from the AutoCircle settings. */
    Circle?: any;
    /** Geometry defined as a bounding box. The first pair represents the X and Y coordinates (longitude and latitude,) of the southwest corner of the bounding box; the second pair represents the X and Y coor */
    BoundingBox?: any[];
    /** Geometry defined as a polygon with only one linear ring. */
    Polygon?: any[];
}
export interface RouteMatrixBoundary {
    /** Geometry of the area to be avoided. */
    Geometry?: RouteMatrixBoundaryGeometry;
    /** No restrictions in terms of a routing boundary, and is typically used for longer routes. */
    Unbounded?: boolean;
}
export interface RouteMatrixTrafficOptions {
    /** Duration for which flow traffic is considered valid. For this period, the flow traffic is used over historical traffic data. Flow traffic refers to congestion, which changes very quickly. Duration in  */
    FlowEventThresholdOverride?: number;
    /** Determines if traffic should be used or ignored while calculating the route. Default Value: UseTrafficData */
    Usage?: 'IgnoreTrafficData' | 'UseTrafficData';
}
export interface RouteMatrixCarOptions {
    /** The vehicle License Plate. */
    LicensePlate?: any;
    /** Maximum speed Unit: KilometersPerHour */
    MaxSpeed?: number;
    /** The number of occupants in the vehicle. Default Value: 1 */
    Occupancy?: number;
}
export interface RouteMatrixScooterOptions {
    /** The vehicle License Plate. */
    LicensePlate?: any;
    /** Maximum speed. Unit: KilometersPerHour */
    MaxSpeed?: number;
    /** The number of occupants in the vehicle. Default Value: 1 */
    Occupancy?: number;
}
export interface RouteMatrixTruckOptions {
    /** Total number of axles of the vehicle. */
    AxleCount?: number;
    /** Gross weight of the vehicle including trailers, and goods at capacity. Unit: Kilograms */
    GrossWeight?: number;
    /** List of Hazardous cargo contained in the vehicle. */
    HazardousCargos?: any[];
    /** Height of the vehicle. Unit: centimeters */
    Height?: number;
    /** Kingpin to rear axle length of the vehicle Unit: centimeters */
    KpraLength?: number;
    /** Length of the vehicle. Unit: centimeters */
    Length?: number;
    /** The vehicle License Plate. */
    LicensePlate?: any;
    /** Maximum speed Unit: KilometersPerHour */
    MaxSpeed?: number;
    /** The number of occupants in the vehicle. Default Value: 1 */
    Occupancy?: number;
    /** Payload capacity of the vehicle and trailers attached. Unit: kilograms */
    PayloadCapacity?: number;
    /** Trailer options corresponding to the vehicle. */
    Trailer?: any;
    /** Type of the truck. */
    TruckType?: 'LightTruck' | 'StraightTruck' | 'Tractor';
    /** The tunnel restriction code. Tunnel categories in this list indicate the restrictions which apply to certain tunnels in Great Britain. They relate to the types of dangerous goods that can be transport */
    TunnelRestrictionCode?: string;
    /** Heaviest weight per axle irrespective of the axle type or the axle group. Meant for usage in countries where the differences in axle types or axle groups are not distinguished. Unit: Kilograms */
    WeightPerAxle?: number;
    /** Specifies the total weight for the specified axle group. Meant for usage in countries that have different regulations based on the axle group type. */
    WeightPerAxleGroup?: any;
    /** Width of the vehicle. Unit: centimeters */
    Width?: number;
}
export interface RouteMatrixTravelModeOptions {
    /** Travel mode options when the provided travel mode is "Car" */
    Car?: RouteMatrixCarOptions;
    /** Travel mode options when the provided travel mode is Scooter When travel mode is set to Scooter, then the avoidance option ControlledAccessHighways defaults to true. */
    Scooter?: RouteMatrixScooterOptions;
    /** Travel mode options when the provided travel mode is "Truck" */
    Truck?: RouteMatrixTruckOptions;
}
export interface RouteAllowOptions {
    /** Allow Hot (High Occupancy Toll) lanes while calculating the route. Default value: false */
    Hot?: boolean;
    /** Allow Hov (High Occupancy vehicle) lanes while calculating the route. Default value: false */
    Hov?: boolean;
}
export interface RouteAvoidanceOptions {
    /** Areas to be avoided. */
    Areas?: any[];
    /** Avoid car-shuttle-trains while calculating the route. */
    CarShuttleTrains?: boolean;
    /** Avoid controlled access highways while calculating the route. */
    ControlledAccessHighways?: boolean;
    /** Avoid dirt roads while calculating the route. */
    DirtRoads?: boolean;
    /** Avoid ferries while calculating the route. */
    Ferries?: boolean;
    /** Avoid roads that have seasonal closure while calculating the route. */
    SeasonalClosure?: boolean;
    /** Avoids roads where the specified toll transponders are the only mode of payment. */
    TollRoads?: boolean;
    /** Avoids roads where the specified toll transponders are the only mode of payment. */
    TollTransponders?: boolean;
    /** Truck road type identifiers. BK1 through BK4 apply only to Sweden. A2,A4,B2,B4,C,D,ET2,ET4 apply only to Mexico. There are currently no other supported values as of 26th April 2024. */
    TruckRoadTypes?: string[];
    /** Avoid tunnels while calculating the route. */
    Tunnels?: boolean;
    /** Avoid U-turns for calculation on highways and motorways. */
    UTurns?: boolean;
    /** Zone categories to be avoided. */
    ZoneCategories?: any[];
}
export interface RouteMatchingOptions {
    /** Attempts to match the provided position to a road similar to the provided name. */
    NameHint?: string;
    /** If the distance to a highway/bridge/tunnel/sliproad is within threshold, the waypoint will be snapped to the highway/bridge/tunnel/sliproad. Unit: meters */
    OnRoadThreshold?: number;
    /** Considers all roads within the provided radius to match the provided destination to. The roads that are considered are determined by the provided Strategy. Unit: Meters */
    Radius?: number;
    /** Strategy that defines matching of the position onto the road network. MatchAny considers all roads possible, whereas MatchMostSignificantRoad matches to the most significant road. */
    Strategy?: 'MatchAny' | 'MatchMostSignificantRoad';
}
export interface RouteSideOfStreetOptions {
    /** Position defined as [longitude, latitude]. */
    Position: any[];
    /** Strategy that defines when the side of street position should be used. Default Value: DividedStreetOnly */
    UseWith?: 'AnyStreet' | 'DividedStreetOnly';
}
export interface RouteDestinationOptions {
    /** Avoids actions for the provided distance. This is typically to consider for users in moving vehicles who may not have sufficient time to make an action at an origin or a destination. */
    AvoidActionsForDistance?: number;
    /** Avoid U-turns for calculation on highways and motorways. */
    AvoidUTurns?: boolean;
    /** GPS Heading at the position. */
    Heading?: number;
    /** Options to configure matching the provided position to the road network. */
    Matching?: RouteMatchingOptions;
    /** Options to configure matching the provided position to a side of the street. */
    SideOfStreet?: RouteSideOfStreetOptions;
    /** Duration of the stop. Unit: seconds */
    StopDuration?: number;
}
export interface RouteDriverOptions {
    /** Driver work-rest schedule. Stops are added to fulfil the provided rest schedule. */
    Schedule?: any[];
}
export interface RouteExclusionOptions {
    /** List of countries to be avoided defined by two-letter or three-letter country codes. */
    Countries: string[];
}
export interface RouteOriginOptions {
    /** Avoids actions for the provided distance. This is typically to consider for users in moving vehicles who may not have sufficient time to make an action at an origin or a destination. */
    AvoidActionsForDistance?: number;
    /** Avoid U-turns for calculation on highways and motorways. */
    AvoidUTurns?: boolean;
    /** GPS Heading at the position. */
    Heading?: number;
    /** Options to configure matching the provided position to the road network. */
    Matching?: RouteMatchingOptions;
    /** Options to configure matching the provided position to a side of the street. */
    SideOfStreet?: RouteSideOfStreetOptions;
}
export interface RouteEmissionType {
    /** The CO 2 emission classes. */
    Co2EmissionClass?: string;
    /** Type of the emission. Valid values: Euro1, Euro2, Euro3, Euro4, Euro5, Euro6, EuroEev */
    Type: string;
}
export interface RouteTollOptions {
    /** Specifies if the user has valid transponder with access to all toll systems. This impacts toll calculation, and if true the price with transponders is used. */
    AllTransponders?: boolean;
    /** Specifies if the user has valid vignettes with access for all toll roads. If a user has a vignette for a toll road, then toll cost for that road is omitted since no further payment is necessary. */
    AllVignettes?: boolean;
    /** Currency code corresponding to the price. This is the same as Currency specified in the request. */
    Currency?: string;
    /** Emission type of the vehicle for toll cost calculation. Valid values: Euro1, Euro2, Euro3, Euro4, Euro5, Euro6, EuroEev */
    EmissionType?: RouteEmissionType;
    /** Vehicle category for toll cost calculation. */
    VehicleCategory?: 'Minibus';
}
export interface RouteTrafficOptions {
    /** Duration for which flow traffic is considered valid. For this period, the flow traffic is used over historical traffic data. Flow traffic refers to congestion, which changes very quickly. Duration in  */
    FlowEventThresholdOverride?: number;
    /** Determines if traffic should be used or ignored while calculating the route. Default Value: UseTrafficData */
    Usage?: 'IgnoreTrafficData' | 'UseTrafficData';
}
export interface RouteCarOptions {
    /** Engine type of the vehicle. */
    EngineType?: 'Electric' | 'InternalCombustion' | 'PluginHybrid';
    /** The vehicle License Plate. */
    LicensePlate?: any;
    /** Maximum speed specified. Unit: KilometersPerHour */
    MaxSpeed?: number;
    /** The number of occupants in the vehicle. Default Value: 1 */
    Occupancy?: number;
}
export interface RoutePedestrianOptions {
    /** Walking speed in Kilometers per hour. */
    Speed?: number;
}
export interface RouteScooterOptions {
    /** Engine type of the vehicle. */
    EngineType?: 'Electric' | 'InternalCombustion' | 'PluginHybrid';
    /** The vehicle License Plate. */
    LicensePlate?: any;
    /** Maximum speed Unit: KilometersPerHour */
    MaxSpeed?: number;
    /** The number of occupants in the vehicle. Default Value: 1 */
    Occupancy?: number;
}
export interface RouteTruckOptions {
    /** Total number of axles of the vehicle. */
    AxleCount?: number;
    /** Engine type of the vehicle. */
    EngineType?: 'Electric' | 'InternalCombustion' | 'PluginHybrid';
    /** Gross weight of the vehicle including trailers, and goods at capacity. Unit: Kilograms */
    GrossWeight?: number;
    /** List of Hazardous cargo contained in the vehicle. */
    HazardousCargos?: any[];
    /** Height of the vehicle. Unit: centimeters */
    Height?: number;
    /** Height of the vehicle above its first axle. Unit: centimeters */
    HeightAboveFirstAxle?: number;
    /** Kingpin to rear axle length of the vehicle. Unit: centimeters */
    KpraLength?: number;
    /** Length of the vehicle. Unit: c */
    Length?: number;
    /** The vehicle License Plate. */
    LicensePlate?: any;
    /** Maximum speed Unit: KilometersPerHour */
    MaxSpeed?: number;
    /** The number of occupants in the vehicle. Default Value: 1 */
    Occupancy?: number;
    /** Payload capacity of the vehicle and trailers attached. Unit: kilograms */
    PayloadCapacity?: number;
    /** Number of tires on the vehicle. */
    TireCount?: number;
    /** Trailer options corresponding to the vehicle. */
    Trailer?: any;
    /** Type of the truck. */
    TruckType?: 'LightTruck' | 'StraightTruck' | 'Tractor';
    /** The tunnel restriction code. Tunnel categories in this list indicate the restrictions which apply to certain tunnels in Great Britain. They relate to the types of dangerous goods that can be transport */
    TunnelRestrictionCode?: string;
    /** Heaviest weight per axle irrespective of the axle type or the axle group. Meant for usage in countries where the differences in axle types or axle groups are not distinguished. Unit: Kilograms */
    WeightPerAxle?: number;
    /** Specifies the total weight for the specified axle group. Meant for usage in countries that have different regulations based on the axle group type. Unit: Kilograms */
    WeightPerAxleGroup?: any;
    /** Width of the vehicle. Unit: centimeters */
    Width?: number;
}
export interface RouteTravelModeOptions {
    /** Travel mode options when the provided travel mode is "Car" */
    Car?: RouteCarOptions;
    /** Travel mode options when the provided travel mode is "Pedestrian" */
    Pedestrian?: RoutePedestrianOptions;
    /** Travel mode options when the provided travel mode is Scooter When travel mode is set to Scooter, then the avoidance option ControlledAccessHighways defaults to true. */
    Scooter?: RouteScooterOptions;
    /** Travel mode options when the provided travel mode is "Truck" */
    Truck?: RouteTruckOptions;
}
export interface RouteWaypoint {
    /** Avoids actions for the provided distance. This is typically to consider for users in moving vehicles who may not have sufficient time to make an action at an origin or a destination. */
    AvoidActionsForDistance?: number;
    /** Avoid U-turns for calculation on highways and motorways. */
    AvoidUTurns?: boolean;
    /** GPS Heading at the position. */
    Heading?: number;
    /** Options to configure matching the provided position to the road network. */
    Matching?: any;
    /** If the waypoint should not be treated as a stop. If yes, the waypoint is passed through and doesn't split the route into different legs. */
    PassThrough?: boolean;
    /** Position defined as [longitude, latitude]. */
    Position: any[];
    /** Options to configure matching the provided position to a side of the street. */
    SideOfStreet?: any;
    /** Duration of the stop. Unit: seconds */
    StopDuration?: number;
}
export interface WaypointOptimizationAvoidanceOptions {
    /** Areas to be avoided. */
    Areas?: any[];
    /** Avoidance options for cars-shuttles-trains. */
    CarShuttleTrains?: boolean;
    /** Avoid controlled access highways while calculating the route. */
    ControlledAccessHighways?: boolean;
    /** Avoid dirt roads while calculating the route. */
    DirtRoads?: boolean;
    /** Avoidance options for ferries. */
    Ferries?: boolean;
    /** Avoids roads where the specified toll transponders are the only mode of payment. */
    TollRoads?: boolean;
    /** Avoid tunnels while calculating the route. */
    Tunnels?: boolean;
    /** Avoid U-turns for calculation on highways and motorways. */
    UTurns?: boolean;
}
export interface WaypointOptimizationDrivingDistanceOptions {
    /** DrivingDistance assigns all the waypoints that are within driving distance of each other into a single cluster. */
    DrivingDistance: number;
}
export interface WaypointOptimizationClusteringOptions {
    /** The algorithm to be used. DrivingDistance assigns all the waypoints that are within driving distance of each other into a single cluster. TopologySegment assigns all the waypoints that are within the  */
    Algorithm: 'DrivingDistance' | 'TopologySegment';
    /** Driving distance options to be used when the clustering algorithm is DrivingDistance. */
    DrivingDistanceOptions?: WaypointOptimizationDrivingDistanceOptions;
}
export interface WaypointOptimizationAccessHours {
    /** Contains the ID of the starting waypoint in this connection. */
    From: any;
    /** Contains the ID of the ending waypoint in this connection. */
    To: any;
}
export interface WaypointOptimizationSideOfStreetOptions {
    /** Position defined as [longitude, latitude]. */
    Position: any[];
    /** Strategy that defines when the side of street position should be used. AnyStreet will always use the provided position. Default Value: DividedStreetOnly */
    UseWith?: 'AnyStreet' | 'DividedStreetOnly';
}
export interface WaypointOptimizationDestinationOptions {
    /** Access hours corresponding to when a waypoint can be visited. */
    AccessHours?: WaypointOptimizationAccessHours;
    /** Appointment time at the destination. */
    AppointmentTime?: string;
    /** GPS Heading at the position. */
    Heading?: number;
    /** The waypoint Id. */
    Id?: string;
    /** Service time spent at the destination. At an appointment, the service time should be the appointment duration. Unit: seconds */
    ServiceDuration?: number;
    /** Options to configure matching the provided position to a side of the street. */
    SideOfStreet?: WaypointOptimizationSideOfStreetOptions;
}
export interface WaypointOptimizationRestCycles {
    /** Long cycle for a driver work-rest schedule. */
    LongCycle: any;
    /** Short cycle for a driver work-rest schedule */
    ShortCycle: any;
}
export interface WaypointOptimizationRestProfile {
    /** Pre defined rest profiles for a driver schedule. The only currently supported profile is EU. */
    Profile: string;
}
export interface WaypointOptimizationDriverOptions {
    /** Driver work-rest schedules defined by a short and long cycle. A rest needs to be taken after the short work duration. The short cycle can be repeated until you hit the long work duration, at which poi */
    RestCycles?: WaypointOptimizationRestCycles;
    /** Pre defined rest profiles for a driver schedule. The only currently supported profile is EU. */
    RestProfile?: WaypointOptimizationRestProfile;
    /** If the service time provided at a waypoint/destination should be considered as rest or work. This contributes to the total time breakdown returned within the response. */
    TreatServiceTimeAs?: 'Rest' | 'Work';
}
export interface WaypointOptimizationExclusionOptions {
    /** List of countries to be avoided defined by two-letter or three-letter country codes. */
    Countries: string[];
}
export interface WaypointOptimizationOriginOptions {
    /** The Origin Id. */
    Id?: string;
}
export interface WaypointOptimizationTrafficOptions {
    /** Determines if traffic should be used or ignored while calculating the route. Default Value: UseTrafficData */
    Usage?: 'IgnoreTrafficData' | 'UseTrafficData';
}
export interface WaypointOptimizationPedestrianOptions {
    /** Walking speed. Unit: KilometersPerHour */
    Speed?: number;
}
export interface WaypointOptimizationTruckOptions {
    /** Gross weight of the vehicle including trailers, and goods at capacity. Unit: Kilograms */
    GrossWeight?: number;
    /** List of Hazardous cargo contained in the vehicle. */
    HazardousCargos?: any[];
    /** Height of the vehicle. Unit: centimeters */
    Height?: number;
    /** Length of the vehicle. Unit: centimeters */
    Length?: number;
    /** Trailer options corresponding to the vehicle. */
    Trailer?: any;
    /** Type of the truck. */
    TruckType?: 'StraightTruck' | 'Tractor';
    /** The tunnel restriction code. Tunnel categories in this list indicate the restrictions which apply to certain tunnels in Great Britain. They relate to the types of dangerous goods that can be transport */
    TunnelRestrictionCode?: string;
    /** Heaviest weight per axle irrespective of the axle type or the axle group. Meant for usage in countries where the differences in axle types or axle groups are not distinguished. Unit: Kilograms */
    WeightPerAxle?: number;
    /** Width of the vehicle. Unit: centimeters */
    Width?: number;
}
export interface WaypointOptimizationTravelModeOptions {
    /** Travel mode options when the provided travel mode is "Pedestrian" */
    Pedestrian?: WaypointOptimizationPedestrianOptions;
    /** Travel mode options when the provided travel mode is "Truck" */
    Truck?: WaypointOptimizationTruckOptions;
}
export interface WaypointOptimizationWaypoint {
    /** Access hours corresponding to when a waypoint can be visited. */
    AccessHours?: any;
    /** Appointment time at the waypoint. */
    AppointmentTime?: string;
    /** Constraint defining what waypoints are to be visited after this waypoint. */
    Before?: any[];
    /** GPS Heading at the position. */
    Heading?: number;
    /** The waypoint Id. */
    Id?: string;
    /** Position defined as [longitude, latitude]. */
    Position: any[];
    /** Service time spent at the waypoint. At an appointment, the service time should be the appointment duration. Unit: seconds */
    ServiceDuration?: number;
    /** Options to configure matching the provided position to a side of the street. */
    SideOfStreet?: any;
}
export interface RoadSnapTracePoint {
    /** GPS Heading at the position. */
    Heading?: number;
    /** Position defined as [longitude, latitude]. */
    Position: any[];
    /** Speed at the specified trace point . Unit: KilometersPerHour */
    Speed?: number;
    /** Timestamp of the event. */
    Timestamp?: string;
}
export interface RoadSnapTruckOptions {
    /** Gross weight of the vehicle including trailers, and goods at capacity. Unit: Kilograms */
    GrossWeight?: number;
    /** List of Hazardous cargos contained in the vehicle. */
    HazardousCargos?: any[];
    /** Height of the vehicle. Unit: centimeters */
    Height?: number;
    /** Length of the vehicle. Unit: centimeters */
    Length?: number;
    /** Trailer options corresponding to the vehicle. */
    Trailer?: any;
    /** The tunnel restriction code. Tunnel categories in this list indicate the restrictions which apply to certain tunnels in Great Britain. They relate to the types of dangerous goods that can be transport */
    TunnelRestrictionCode?: string;
    /** Width of the vehicle in centimenters. */
    Width?: number;
}
export interface RoadSnapTravelModeOptions {
    /** Travel mode options when the provided travel mode is "Truck". */
    Truck?: RoadSnapTruckOptions;
}
export interface CalculateIsolinesInput {
    /** Threshold to be used for the isoline calculation. Up to 3 thresholds per provided type can be requested. You incur a calculation charge for each threshold. Using a large amount of thresholds in a requ */
    Thresholds: IsolineThresholds;
    /** Features that are allowed while calculating an isoline. */
    Allow?: IsolineAllowOptions;
    /** Time of arrival at the destination. Time format: YYYY-MM-DDThh:mm:ss.sssZ | YYYY-MM-DDThh:mm:ss.sss+hh:mm Examples: 2020-04-22T17:57:24Z 2020-04-22T17:57:24+02:00 */
    ArrivalTime?: string;
    /** Features that are avoided while calculating a route. Avoidance is on a best-case basis. If an avoidance can't be satisfied for a particular case, it violates the avoidance and the returned response pr */
    Avoid?: IsolineAvoidanceOptions;
    /** Uses the current time as the time of departure. */
    DepartNow?: boolean;
    /** Time of departure from thr origin. Time format:YYYY-MM-DDThh:mm:ss.sssZ | YYYY-MM-DDThh:mm:ss.sss+hh:mm Examples: 2020-04-22T17:57:24Z 2020-04-22T17:57:24+02:00 */
    DepartureTime?: string;
    /** The final position for the route. In the World Geodetic System (WGS 84) format: [longitude, latitude]. */
    Destination?: number[];
    /** Destination related options. */
    DestinationOptions?: IsolineDestinationOptions;
    /** The format of the returned IsolineGeometry. Default Value:FlexiblePolyline */
    IsolineGeometryFormat?: 'FlexiblePolyline' | 'Simple';
    /** Defines the granularity of the returned Isoline. */
    IsolineGranularity?: IsolineGranularityOptions;
    /** Optional: The API key to be used for authorization. Either an API key or valid SigV4 signature must be provided when making a request. */
    Key?: string;
    /** Specifies the optimization criteria for when calculating an isoline. AccurateCalculation generates an isoline of higher granularity that is more precise. FastCalculation generates an isoline faster by */
    OptimizeIsolineFor?: 'AccurateCalculation' | 'BalancedCalculation' | 'FastCalculation';
    /** Specifies the optimization criteria for calculating a route. Default Value: FastestRoute */
    OptimizeRoutingFor?: 'FastestRoute' | 'ShortestRoute';
    /** The start position for the route. */
    Origin?: number[];
    /** Origin related options. */
    OriginOptions?: IsolineOriginOptions;
    /** Traffic related options. */
    Traffic?: IsolineTrafficOptions;
    /** Specifies the mode of transport when calculating a route. Used in estimating the speed of travel and road compatibility. The mode Scooter also applies to motorcycles, set to Scooter when wanted to cal */
    TravelMode?: 'Car' | 'Pedestrian' | 'Scooter' | 'Truck';
    /** Travel mode related options for the provided travel mode. */
    TravelModeOptions?: IsolineTravelModeOptions;
}
export interface CalculateRouteMatrixInput {
    /** List of destinations for the route. Route calculations are billed for each origin and destination pair. If you use a large matrix of origins and destinations, your costs will increase accordingly. See */
    Destinations: RouteMatrixDestination[];
    /** The position in longitude and latitude for the origin. Route calculations are billed for each origin and destination pair. Using a large amount of Origins in a request can lead you to incur unexpected */
    Origins: RouteMatrixOrigin[];
    /** Boundary within which the matrix is to be calculated. All data, origins and destinations outside the boundary are considered invalid. When request routing boundary was set as AutoCircle, the response  */
    RoutingBoundary: RouteMatrixBoundary;
    /** Features that are allowed while calculating a route. */
    Allow?: RouteMatrixAllowOptions;
    /** Features that are avoided while calculating a route. Avoidance is on a best-case basis. If an avoidance can't be satisfied for a particular case, it violates the avoidance and the returned response pr */
    Avoid?: RouteMatrixAvoidanceOptions;
    /** Uses the current time as the time of departure. */
    DepartNow?: boolean;
    /** Time of departure from thr origin. Time format:YYYY-MM-DDThh:mm:ss.sssZ | YYYY-MM-DDThh:mm:ss.sss+hh:mm Examples: 2020-04-22T17:57:24Z 2020-04-22T17:57:24+02:00 */
    DepartureTime?: string;
    /** Features to be strictly excluded while calculating the route. */
    Exclude?: RouteMatrixExclusionOptions;
    /** Optional: The API key to be used for authorization. Either an API key or valid SigV4 signature must be provided when making a request. */
    Key?: string;
    /** Specifies the optimization criteria for calculating a route. Default Value: FastestRoute */
    OptimizeRoutingFor?: 'FastestRoute' | 'ShortestRoute';
    /** Traffic related options. */
    Traffic?: RouteMatrixTrafficOptions;
    /** Specifies the mode of transport when calculating a route. Used in estimating the speed of travel and road compatibility. Default Value: Car */
    TravelMode?: 'Car' | 'Pedestrian' | 'Scooter' | 'Truck';
    /** Travel mode related options for the provided travel mode. */
    TravelModeOptions?: RouteMatrixTravelModeOptions;
}
export interface CalculateRoutesInput {
    /** The final position for the route. In the World Geodetic System (WGS 84) format: [longitude, latitude]. */
    Destination: number[];
    /** The start position for the route. */
    Origin: number[];
    /** Features that are allowed while calculating a route. */
    Allow?: RouteAllowOptions;
    /** Time of arrival at the destination. Time format:YYYY-MM-DDThh:mm:ss.sssZ | YYYY-MM-DDThh:mm:ss.sss+hh:mm Examples: 2020-04-22T17:57:24Z 2020-04-22T17:57:24+02:00 */
    ArrivalTime?: string;
    /** Features that are avoided while calculating a route. Avoidance is on a best-case basis. If an avoidance can't be satisfied for a particular case, it violates the avoidance and the returned response pr */
    Avoid?: RouteAvoidanceOptions;
    /** Uses the current time as the time of departure. */
    DepartNow?: boolean;
    /** Time of departure from thr origin. Time format:YYYY-MM-DDThh:mm:ss.sssZ | YYYY-MM-DDThh:mm:ss.sss+hh:mm Examples: 2020-04-22T17:57:24Z 2020-04-22T17:57:24+02:00 */
    DepartureTime?: string;
    /** Destination related options. */
    DestinationOptions?: RouteDestinationOptions;
    /** Driver related options. */
    Driver?: RouteDriverOptions;
    /** Features to be strictly excluded while calculating the route. */
    Exclude?: RouteExclusionOptions;
    /** Measurement system to be used for instructions within steps in the response. */
    InstructionsMeasurementSystem?: 'Metric' | 'Imperial';
    /** Optional: The API key to be used for authorization. Either an API key or valid SigV4 signature must be provided when making a request. */
    Key?: string;
    /** List of languages for instructions within steps in the response. Instructions in the requested language are returned only if they are available. */
    Languages?: string[];
    /** A list of optional additional parameters such as timezone that can be requested for each result. Elevation: Retrieves the elevation information for each location. Incidents: Provides information on tr */
    LegAdditionalFeatures?: 'Elevation' | 'Incidents' | 'PassThroughWaypoints' | 'Summary' | 'Tolls' | 'TravelStepInstructions' | 'TruckRoadTypes' | 'TypicalDuration' | 'Zones'[];
    /** Specifies the format of the geometry returned for each leg of the route. You can choose between two different geometry encoding formats. FlexiblePolyline: A compact and precise encoding format for the */
    LegGeometryFormat?: 'FlexiblePolyline' | 'Simple';
    /** Maximum number of alternative routes to be provided in the response, if available. */
    MaxAlternatives?: number;
    /** Specifies the optimization criteria for calculating a route. Default Value: FastestRoute */
    OptimizeRoutingFor?: 'FastestRoute' | 'ShortestRoute';
    /** Origin related options. */
    OriginOptions?: RouteOriginOptions;
    /** A list of optional features such as SpeedLimit that can be requested for a Span. A span is a section of a Leg for which the requested features have the same values. */
    SpanAdditionalFeatures?: 'BestCaseDuration' | 'CarAccess' | 'Country' | 'Distance' | 'Duration' | 'DynamicSpeed' | 'FunctionalClassification' | 'Gates' | 'Incidents' | 'Names' | 'Notices' | 'PedestrianAccess' | 'RailwayCrossings' | 'Region' | 'RoadAttributes' | 'RouteNumbers' | 'ScooterAccess' | 'SpeedLimit' | 'TollSystems' | 'TruckAccess' | 'TruckRoadTypes' | 'TypicalDuration' | 'Zones' | 'Consumption'[];
    /** Toll related options. */
    Tolls?: RouteTollOptions;
    /** Traffic related options. */
    Traffic?: RouteTrafficOptions;
    /** Specifies the mode of transport when calculating a route. Used in estimating the speed of travel and road compatibility. Default Value: Car */
    TravelMode?: 'Car' | 'Pedestrian' | 'Scooter' | 'Truck';
    /** Travel mode related options for the provided travel mode. */
    TravelModeOptions?: RouteTravelModeOptions;
    /** Type of step returned by the response. Default provides basic steps intended for web based applications. TurnByTurn provides detailed instructions with more granularity intended for a turn based navig */
    TravelStepType?: 'Default' | 'TurnByTurn';
    /** List of waypoints between the Origin and Destination. */
    Waypoints?: RouteWaypoint[];
}
export interface OptimizeWaypointsInput {
    /** The start position for the route. */
    Origin: number[];
    /** Features that are avoided. Avoidance is on a best-case basis. If an avoidance can't be satisfied for a particular case, this setting is ignored. */
    Avoid?: WaypointOptimizationAvoidanceOptions;
    /** Clustering allows you to specify how nearby waypoints can be clustered to improve the optimized sequence. */
    Clustering?: WaypointOptimizationClusteringOptions;
    /** Departure time from the waypoint. Time format:YYYY-MM-DDThh:mm:ss.sssZ | YYYY-MM-DDThh:mm:ss.sss+hh:mm Examples: 2020-04-22T17:57:24Z 2020-04-22T17:57:24+02:00 */
    DepartureTime?: string;
    /** The final position for the route in the World Geodetic System (WGS 84) format: [longitude, latitude]. */
    Destination?: number[];
    /** Destination related options. */
    DestinationOptions?: WaypointOptimizationDestinationOptions;
    /** Driver related options. */
    Driver?: WaypointOptimizationDriverOptions;
    /** Features to be strictly excluded while calculating the route. */
    Exclude?: WaypointOptimizationExclusionOptions;
    /** Optional: The API key to be used for authorization. Either an API key or valid SigV4 signature must be provided when making a request. */
    Key?: string;
    /** Specifies the optimization criteria for the calculated sequence. Default Value: FastestRoute. */
    OptimizeSequencingFor?: 'FastestRoute' | 'ShortestRoute';
    /** Origin related options. */
    OriginOptions?: WaypointOptimizationOriginOptions;
    /** Traffic-related options. */
    Traffic?: WaypointOptimizationTrafficOptions;
    /** Specifies the mode of transport when calculating a route. Used in estimating the speed of travel and road compatibility. Default Value: Car */
    TravelMode?: 'Car' | 'Pedestrian' | 'Scooter' | 'Truck';
    /** Travel mode related options for the provided travel mode. */
    TravelModeOptions?: WaypointOptimizationTravelModeOptions;
    /** List of waypoints between the Origin and Destination. */
    Waypoints?: WaypointOptimizationWaypoint[];
}
export interface SnapToRoadsInput {
    /** List of trace points to be snapped onto the road network. */
    TracePoints: RoadSnapTracePoint[];
    /** Optional: The API key to be used for authorization. Either an API key or valid SigV4 signature must be provided when making a request. */
    Key?: string;
    /** Chooses what the returned SnappedGeometry format should be. Default Value: FlexiblePolyline */
    SnappedGeometryFormat?: 'FlexiblePolyline' | 'Simple';
    /** The radius around the provided tracepoint that is considered for snapping. Unit: meters Default value: 300 */
    SnapRadius?: number;
    /** Specifies the mode of transport when calculating a route. Used in estimating the speed of travel and road compatibility. Default Value: Car */
    TravelMode?: 'Car' | 'Pedestrian' | 'Scooter' | 'Truck';
    /** Travel mode related options for the provided travel mode. */
    TravelModeOptions?: RoadSnapTravelModeOptions;
}
/** Geo Routes service binding for Step Functions SDK integrations. */
export declare class GeoRoutes {
    constructor();
    calculateIsolines<T>(params: CalculateIsolinesInput): Promise<T>;
    calculateRouteMatrix<T>(params: CalculateRouteMatrixInput): Promise<T>;
    calculateRoutes<T>(params: CalculateRoutesInput): Promise<T>;
    optimizeWaypoints<T>(params: OptimizeWaypointsInput): Promise<T>;
    snapToRoads<T>(params: SnapToRoadsInput): Promise<T>;
}
//# sourceMappingURL=GeoRoutes.d.ts.map