@aws-sdk/client-geo-routes 3.683.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,2022 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { GeoRoutesServiceException as __BaseException } from "./GeoRoutesServiceException";
+export declare class AccessDeniedException extends __BaseException {
+  readonly name: "AccessDeniedException";
+  readonly $fault: "client";
+  Message: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<AccessDeniedException, __BaseException>
+  );
+}
+export interface IsolineAllowOptions {
+  Hot?: boolean;
+  Hov?: boolean;
+}
+export interface Corridor {
+  LineString: number[][] | undefined;
+  Radius: number | undefined;
+}
+export interface PolylineCorridor {
+  Polyline: string | undefined;
+  Radius: number | undefined;
+}
+export interface IsolineAvoidanceAreaGeometry {
+  BoundingBox?: number[];
+  Corridor?: Corridor;
+  Polygon?: number[][][];
+  PolylineCorridor?: PolylineCorridor;
+  PolylinePolygon?: string[];
+}
+export interface IsolineAvoidanceArea {
+  Except?: IsolineAvoidanceAreaGeometry[];
+  Geometry: IsolineAvoidanceAreaGeometry | undefined;
+}
+export declare const IsolineZoneCategory: {
+  readonly CONGESTION_PRICING: "CongestionPricing";
+  readonly ENVIRONMENTAL: "Environmental";
+  readonly VIGNETTE: "Vignette";
+};
+export type IsolineZoneCategory =
+  (typeof IsolineZoneCategory)[keyof typeof IsolineZoneCategory];
+export interface IsolineAvoidanceZoneCategory {
+  Category?: IsolineZoneCategory;
+}
+export interface IsolineAvoidanceOptions {
+  Areas?: IsolineAvoidanceArea[];
+  CarShuttleTrains?: boolean;
+  ControlledAccessHighways?: boolean;
+  DirtRoads?: boolean;
+  Ferries?: boolean;
+  SeasonalClosure?: boolean;
+  TollRoads?: boolean;
+  TollTransponders?: boolean;
+  TruckRoadTypes?: string[];
+  Tunnels?: boolean;
+  UTurns?: boolean;
+  ZoneCategories?: IsolineAvoidanceZoneCategory[];
+}
+export declare const MatchingStrategy: {
+  readonly MATCH_ANY: "MatchAny";
+  readonly MATCH_MOST_SIGNIFICANT_ROAD: "MatchMostSignificantRoad";
+};
+export type MatchingStrategy =
+  (typeof MatchingStrategy)[keyof typeof MatchingStrategy];
+export interface IsolineMatchingOptions {
+  NameHint?: string;
+  OnRoadThreshold?: number;
+  Radius?: number;
+  Strategy?: MatchingStrategy;
+}
+export declare const SideOfStreetMatchingStrategy: {
+  readonly ANY_STREET: "AnyStreet";
+  readonly DIVIDED_STREET_ONLY: "DividedStreetOnly";
+};
+export type SideOfStreetMatchingStrategy =
+  (typeof SideOfStreetMatchingStrategy)[keyof typeof SideOfStreetMatchingStrategy];
+export interface IsolineSideOfStreetOptions {
+  Position: number[] | undefined;
+  UseWith?: SideOfStreetMatchingStrategy;
+}
+export interface IsolineDestinationOptions {
+  AvoidActionsForDistance?: number;
+  Heading?: number;
+  Matching?: IsolineMatchingOptions;
+  SideOfStreet?: IsolineSideOfStreetOptions;
+}
+export declare const GeometryFormat: {
+  readonly FLEXIBLE_POLYLINE: "FlexiblePolyline";
+  readonly SIMPLE: "Simple";
+};
+export type GeometryFormat =
+  (typeof GeometryFormat)[keyof typeof GeometryFormat];
+export interface IsolineGranularityOptions {
+  MaxPoints?: number;
+  MaxResolution?: number;
+}
+export declare const IsolineOptimizationObjective: {
+  readonly ACCURATE_CALCULATION: "AccurateCalculation";
+  readonly BALANCED_CALCULATION: "BalancedCalculation";
+  readonly FAST_CALCULATION: "FastCalculation";
+};
+export type IsolineOptimizationObjective =
+  (typeof IsolineOptimizationObjective)[keyof typeof IsolineOptimizationObjective];
+export declare const RoutingObjective: {
+  readonly FASTEST_ROUTE: "FastestRoute";
+  readonly SHORTEST_ROUTE: "ShortestRoute";
+};
+export type RoutingObjective =
+  (typeof RoutingObjective)[keyof typeof RoutingObjective];
+export interface IsolineOriginOptions {
+  AvoidActionsForDistance?: number;
+  Heading?: number;
+  Matching?: IsolineMatchingOptions;
+  SideOfStreet?: IsolineSideOfStreetOptions;
+}
+export interface IsolineThresholds {
+  Distance?: number[];
+  Time?: number[];
+}
+export declare const TrafficUsage: {
+  readonly IGNORE_TRAFFIC_DATA: "IgnoreTrafficData";
+  readonly USE_TRAFFIC_DATA: "UseTrafficData";
+};
+export type TrafficUsage = (typeof TrafficUsage)[keyof typeof TrafficUsage];
+export interface IsolineTrafficOptions {
+  FlowEventThresholdOverride?: number;
+  Usage?: TrafficUsage;
+}
+export declare const IsolineTravelMode: {
+  readonly CAR: "Car";
+  readonly PEDESTRIAN: "Pedestrian";
+  readonly SCOOTER: "Scooter";
+  readonly TRUCK: "Truck";
+};
+export type IsolineTravelMode =
+  (typeof IsolineTravelMode)[keyof typeof IsolineTravelMode];
+export declare const IsolineEngineType: {
+  readonly ELECTRIC: "Electric";
+  readonly INTERNAL_COMBUSTION: "InternalCombustion";
+  readonly PLUGIN_HYBRID: "PluginHybrid";
+};
+export type IsolineEngineType =
+  (typeof IsolineEngineType)[keyof typeof IsolineEngineType];
+export interface IsolineVehicleLicensePlate {
+  LastCharacter?: string;
+}
+export interface IsolineCarOptions {
+  EngineType?: IsolineEngineType;
+  LicensePlate?: IsolineVehicleLicensePlate;
+  MaxSpeed?: number;
+  Occupancy?: number;
+}
+export interface IsolineScooterOptions {
+  EngineType?: IsolineEngineType;
+  LicensePlate?: IsolineVehicleLicensePlate;
+  MaxSpeed?: number;
+  Occupancy?: number;
+}
+export declare const IsolineHazardousCargoType: {
+  readonly COMBUSTIBLE: "Combustible";
+  readonly CORROSIVE: "Corrosive";
+  readonly EXPLOSIVE: "Explosive";
+  readonly FLAMMABLE: "Flammable";
+  readonly GAS: "Gas";
+  readonly HARMFUL_TO_WATER: "HarmfulToWater";
+  readonly ORGANIC: "Organic";
+  readonly OTHER: "Other";
+  readonly POISON: "Poison";
+  readonly POISONOUS_INHALATION: "PoisonousInhalation";
+  readonly RADIOACTIVE: "Radioactive";
+};
+export type IsolineHazardousCargoType =
+  (typeof IsolineHazardousCargoType)[keyof typeof IsolineHazardousCargoType];
+export interface IsolineTrailerOptions {
+  AxleCount?: number;
+  TrailerCount?: number;
+}
+export declare const IsolineTruckType: {
+  readonly LIGHT_TRUCK: "LightTruck";
+  readonly STRAIGHT_TRUCK: "StraightTruck";
+  readonly TRACTOR: "Tractor";
+};
+export type IsolineTruckType =
+  (typeof IsolineTruckType)[keyof typeof IsolineTruckType];
+export interface WeightPerAxleGroup {
+  Single?: number;
+  Tandem?: number;
+  Triple?: number;
+  Quad?: number;
+  Quint?: number;
+}
+export interface IsolineTruckOptions {
+  AxleCount?: number;
+  EngineType?: IsolineEngineType;
+  GrossWeight?: number;
+  HazardousCargos?: IsolineHazardousCargoType[];
+  Height?: number;
+  HeightAboveFirstAxle?: number;
+  KpraLength?: number;
+  Length?: number;
+  LicensePlate?: IsolineVehicleLicensePlate;
+  MaxSpeed?: number;
+  Occupancy?: number;
+  PayloadCapacity?: number;
+  TireCount?: number;
+  Trailer?: IsolineTrailerOptions;
+  TruckType?: IsolineTruckType;
+  TunnelRestrictionCode?: string;
+  WeightPerAxle?: number;
+  WeightPerAxleGroup?: WeightPerAxleGroup;
+  Width?: number;
+}
+export interface IsolineTravelModeOptions {
+  Car?: IsolineCarOptions;
+  Scooter?: IsolineScooterOptions;
+  Truck?: IsolineTruckOptions;
+}
+export interface CalculateIsolinesRequest {
+  Allow?: IsolineAllowOptions;
+  ArrivalTime?: string;
+  Avoid?: IsolineAvoidanceOptions;
+  DepartNow?: boolean;
+  DepartureTime?: string;
+  Destination?: number[];
+  DestinationOptions?: IsolineDestinationOptions;
+  IsolineGeometryFormat?: GeometryFormat;
+  IsolineGranularity?: IsolineGranularityOptions;
+  Key?: string;
+  OptimizeIsolineFor?: IsolineOptimizationObjective;
+  OptimizeRoutingFor?: RoutingObjective;
+  Origin?: number[];
+  OriginOptions?: IsolineOriginOptions;
+  Thresholds: IsolineThresholds | undefined;
+  Traffic?: IsolineTrafficOptions;
+  TravelMode?: IsolineTravelMode;
+  TravelModeOptions?: IsolineTravelModeOptions;
+}
+export interface IsolineConnectionGeometry {
+  LineString?: number[][];
+  Polyline?: string;
+}
+export interface IsolineConnection {
+  FromPolygonIndex: number | undefined;
+  Geometry: IsolineConnectionGeometry | undefined;
+  ToPolygonIndex: number | undefined;
+}
+export interface IsolineShapeGeometry {
+  Polygon?: number[][][];
+  PolylinePolygon?: string[];
+}
+export interface Isoline {
+  Connections: IsolineConnection[] | undefined;
+  DistanceThreshold?: number;
+  Geometries: IsolineShapeGeometry[] | undefined;
+  TimeThreshold?: number;
+}
+export interface CalculateIsolinesResponse {
+  ArrivalTime?: string;
+  DepartureTime?: string;
+  IsolineGeometryFormat: GeometryFormat | undefined;
+  Isolines: Isoline[] | undefined;
+  PricingBucket: string | undefined;
+  SnappedDestination?: number[];
+  SnappedOrigin?: number[];
+}
+export declare class InternalServerException extends __BaseException {
+  readonly name: "InternalServerException";
+  readonly $fault: "server";
+  $retryable: {};
+  Message: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<InternalServerException, __BaseException>
+  );
+}
+export declare class ThrottlingException extends __BaseException {
+  readonly name: "ThrottlingException";
+  readonly $fault: "client";
+  $retryable: {};
+  Message: string | undefined;
+  constructor(
+    opts: __ExceptionOptionType<ThrottlingException, __BaseException>
+  );
+}
+export interface ValidationExceptionField {
+  Name: string | undefined;
+  Message: string | undefined;
+}
+export declare const ValidationExceptionReason: {
+  readonly CANNOT_PARSE: "CannotParse";
+  readonly FIELD_VALIDATION_FAILED: "FieldValidationFailed";
+  readonly MISSING: "Missing";
+  readonly OTHER: "Other";
+  readonly UNKNOWN_FIELD: "UnknownField";
+  readonly UNKNOWN_OPERATION: "UnknownOperation";
+};
+export type ValidationExceptionReason =
+  (typeof ValidationExceptionReason)[keyof typeof ValidationExceptionReason];
+export declare class ValidationException extends __BaseException {
+  readonly name: "ValidationException";
+  readonly $fault: "client";
+  Message: string | undefined;
+  Reason: ValidationExceptionReason | undefined;
+  FieldList: ValidationExceptionField[] | undefined;
+  constructor(
+    opts: __ExceptionOptionType<ValidationException, __BaseException>
+  );
+}
+export interface RouteMatrixAllowOptions {
+  Hot?: boolean;
+  Hov?: boolean;
+}
+export interface RouteMatrixAvoidanceAreaGeometry {
+  BoundingBox?: number[];
+  Polygon?: number[][][];
+  PolylinePolygon?: string[];
+}
+export interface RouteMatrixAvoidanceArea {
+  Geometry: RouteMatrixAvoidanceAreaGeometry | undefined;
+}
+export declare const RouteMatrixZoneCategory: {
+  readonly CONGESTION_PRICING: "CongestionPricing";
+  readonly ENVIRONMENTAL: "Environmental";
+  readonly VIGNETTE: "Vignette";
+};
+export type RouteMatrixZoneCategory =
+  (typeof RouteMatrixZoneCategory)[keyof typeof RouteMatrixZoneCategory];
+export interface RouteMatrixAvoidanceZoneCategory {
+  Category?: RouteMatrixZoneCategory;
+}
+export interface RouteMatrixAvoidanceOptions {
+  Areas?: RouteMatrixAvoidanceArea[];
+  CarShuttleTrains?: boolean;
+  ControlledAccessHighways?: boolean;
+  DirtRoads?: boolean;
+  Ferries?: boolean;
+  TollRoads?: boolean;
+  TollTransponders?: boolean;
+  TruckRoadTypes?: string[];
+  Tunnels?: boolean;
+  UTurns?: boolean;
+  ZoneCategories?: RouteMatrixAvoidanceZoneCategory[];
+}
+export interface RouteMatrixMatchingOptions {
+  NameHint?: string;
+  OnRoadThreshold?: number;
+  Radius?: number;
+  Strategy?: MatchingStrategy;
+}
+export interface RouteMatrixSideOfStreetOptions {
+  Position: number[] | undefined;
+  UseWith?: SideOfStreetMatchingStrategy;
+}
+export interface RouteMatrixDestinationOptions {
+  AvoidActionsForDistance?: number;
+  Heading?: number;
+  Matching?: RouteMatrixMatchingOptions;
+  SideOfStreet?: RouteMatrixSideOfStreetOptions;
+}
+export interface RouteMatrixDestination {
+  Options?: RouteMatrixDestinationOptions;
+  Position: number[] | undefined;
+}
+export interface RouteMatrixExclusionOptions {
+  Countries: string[] | undefined;
+}
+export interface RouteMatrixOriginOptions {
+  AvoidActionsForDistance?: number;
+  Heading?: number;
+  Matching?: RouteMatrixMatchingOptions;
+  SideOfStreet?: RouteMatrixSideOfStreetOptions;
+}
+export interface RouteMatrixOrigin {
+  Options?: RouteMatrixOriginOptions;
+  Position: number[] | undefined;
+}
+export interface RouteMatrixAutoCircle {
+  Margin?: number;
+  MaxRadius?: number;
+}
+export interface Circle {
+  Center: number[] | undefined;
+  Radius: number | undefined;
+}
+export interface RouteMatrixBoundaryGeometry {
+  AutoCircle?: RouteMatrixAutoCircle;
+  Circle?: Circle;
+  BoundingBox?: number[];
+  Polygon?: number[][][];
+}
+export interface RouteMatrixBoundary {
+  Geometry?: RouteMatrixBoundaryGeometry;
+  Unbounded?: boolean;
+}
+export interface RouteMatrixTrafficOptions {
+  FlowEventThresholdOverride?: number;
+  Usage?: TrafficUsage;
+}
+export declare const RouteMatrixTravelMode: {
+  readonly CAR: "Car";
+  readonly PEDESTRIAN: "Pedestrian";
+  readonly SCOOTER: "Scooter";
+  readonly TRUCK: "Truck";
+};
+export type RouteMatrixTravelMode =
+  (typeof RouteMatrixTravelMode)[keyof typeof RouteMatrixTravelMode];
+export interface RouteMatrixVehicleLicensePlate {
+  LastCharacter?: string;
+}
+export interface RouteMatrixCarOptions {
+  LicensePlate?: RouteMatrixVehicleLicensePlate;
+  MaxSpeed?: number;
+  Occupancy?: number;
+}
+export interface RouteMatrixScooterOptions {
+  LicensePlate?: RouteMatrixVehicleLicensePlate;
+  MaxSpeed?: number;
+  Occupancy?: number;
+}
+export declare const RouteMatrixHazardousCargoType: {
+  readonly COMBUSTIBLE: "Combustible";
+  readonly CORROSIVE: "Corrosive";
+  readonly EXPLOSIVE: "Explosive";
+  readonly FLAMMABLE: "Flammable";
+  readonly GAS: "Gas";
+  readonly HARMFUL_TO_WATER: "HarmfulToWater";
+  readonly ORGANIC: "Organic";
+  readonly OTHER: "Other";
+  readonly POISON: "Poison";
+  readonly POISONOUS_INHALATION: "PoisonousInhalation";
+  readonly RADIOACTIVE: "Radioactive";
+};
+export type RouteMatrixHazardousCargoType =
+  (typeof RouteMatrixHazardousCargoType)[keyof typeof RouteMatrixHazardousCargoType];
+export interface RouteMatrixTrailerOptions {
+  TrailerCount?: number;
+}
+export declare const RouteMatrixTruckType: {
+  readonly LIGHT_TRUCK: "LightTruck";
+  readonly STRAIGHT_TRUCK: "StraightTruck";
+  readonly TRACTOR: "Tractor";
+};
+export type RouteMatrixTruckType =
+  (typeof RouteMatrixTruckType)[keyof typeof RouteMatrixTruckType];
+export interface RouteMatrixTruckOptions {
+  AxleCount?: number;
+  GrossWeight?: number;
+  HazardousCargos?: RouteMatrixHazardousCargoType[];
+  Height?: number;
+  KpraLength?: number;
+  Length?: number;
+  LicensePlate?: RouteMatrixVehicleLicensePlate;
+  MaxSpeed?: number;
+  Occupancy?: number;
+  PayloadCapacity?: number;
+  Trailer?: RouteMatrixTrailerOptions;
+  TruckType?: RouteMatrixTruckType;
+  TunnelRestrictionCode?: string;
+  WeightPerAxle?: number;
+  WeightPerAxleGroup?: WeightPerAxleGroup;
+  Width?: number;
+}
+export interface RouteMatrixTravelModeOptions {
+  Car?: RouteMatrixCarOptions;
+  Scooter?: RouteMatrixScooterOptions;
+  Truck?: RouteMatrixTruckOptions;
+}
+export interface CalculateRouteMatrixRequest {
+  Allow?: RouteMatrixAllowOptions;
+  Avoid?: RouteMatrixAvoidanceOptions;
+  DepartNow?: boolean;
+  DepartureTime?: string;
+  Destinations: RouteMatrixDestination[] | undefined;
+  Exclude?: RouteMatrixExclusionOptions;
+  Key?: string;
+  OptimizeRoutingFor?: RoutingObjective;
+  Origins: RouteMatrixOrigin[] | undefined;
+  RoutingBoundary: RouteMatrixBoundary | undefined;
+  Traffic?: RouteMatrixTrafficOptions;
+  TravelMode?: RouteMatrixTravelMode;
+  TravelModeOptions?: RouteMatrixTravelModeOptions;
+}
+export declare const RouteMatrixErrorCode: {
+  readonly NO_MATCH: "NoMatch";
+  readonly NO_MATCH_DESTINATION: "NoMatchDestination";
+  readonly NO_MATCH_ORIGIN: "NoMatchOrigin";
+  readonly NO_ROUTE: "NoRoute";
+  readonly OTHER: "Other";
+  readonly OUT_OF_BOUNDS: "OutOfBounds";
+  readonly OUT_OF_BOUNDS_DESTINATION: "OutOfBoundsDestination";
+  readonly OUT_OF_BOUNDS_ORIGIN: "OutOfBoundsOrigin";
+  readonly VIOLATION: "Violation";
+};
+export type RouteMatrixErrorCode =
+  (typeof RouteMatrixErrorCode)[keyof typeof RouteMatrixErrorCode];
+export interface RouteMatrixEntry {
+  Distance: number | undefined;
+  Duration: number | undefined;
+  Error?: RouteMatrixErrorCode;
+}
+export interface CalculateRouteMatrixResponse {
+  ErrorCount: number | undefined;
+  PricingBucket: string | undefined;
+  RouteMatrix: RouteMatrixEntry[][] | undefined;
+  RoutingBoundary: RouteMatrixBoundary | undefined;
+}
+export interface RouteAllowOptions {
+  Hot?: boolean;
+  Hov?: boolean;
+}
+export interface RouteAvoidanceAreaGeometry {
+  Corridor?: Corridor;
+  BoundingBox?: number[];
+  Polygon?: number[][][];
+  PolylineCorridor?: PolylineCorridor;
+  PolylinePolygon?: string[];
+}
+export interface RouteAvoidanceArea {
+  Except?: RouteAvoidanceAreaGeometry[];
+  Geometry: RouteAvoidanceAreaGeometry | undefined;
+}
+export declare const RouteZoneCategory: {
+  readonly CONGESTION_PRICING: "CongestionPricing";
+  readonly ENVIRONMENTAL: "Environmental";
+  readonly VIGNETTE: "Vignette";
+};
+export type RouteZoneCategory =
+  (typeof RouteZoneCategory)[keyof typeof RouteZoneCategory];
+export interface RouteAvoidanceZoneCategory {
+  Category: RouteZoneCategory | undefined;
+}
+export interface RouteAvoidanceOptions {
+  Areas?: RouteAvoidanceArea[];
+  CarShuttleTrains?: boolean;
+  ControlledAccessHighways?: boolean;
+  DirtRoads?: boolean;
+  Ferries?: boolean;
+  SeasonalClosure?: boolean;
+  TollRoads?: boolean;
+  TollTransponders?: boolean;
+  TruckRoadTypes?: string[];
+  Tunnels?: boolean;
+  UTurns?: boolean;
+  ZoneCategories?: RouteAvoidanceZoneCategory[];
+}
+export interface RouteMatchingOptions {
+  NameHint?: string;
+  OnRoadThreshold?: number;
+  Radius?: number;
+  Strategy?: MatchingStrategy;
+}
+export interface RouteSideOfStreetOptions {
+  Position: number[] | undefined;
+  UseWith?: SideOfStreetMatchingStrategy;
+}
+export interface RouteDestinationOptions {
+  AvoidActionsForDistance?: number;
+  AvoidUTurns?: boolean;
+  Heading?: number;
+  Matching?: RouteMatchingOptions;
+  SideOfStreet?: RouteSideOfStreetOptions;
+  StopDuration?: number;
+}
+export interface RouteDriverScheduleInterval {
+  DriveDuration: number | undefined;
+  RestDuration: number | undefined;
+}
+export interface RouteDriverOptions {
+  Schedule?: RouteDriverScheduleInterval[];
+}
+export interface RouteExclusionOptions {
+  Countries: string[] | undefined;
+}
+export declare const MeasurementSystem: {
+  readonly IMPERIAL: "Imperial";
+  readonly METRIC: "Metric";
+};
+export type MeasurementSystem =
+  (typeof MeasurementSystem)[keyof typeof MeasurementSystem];
+export declare const RouteLegAdditionalFeature: {
+  readonly ELEVATION: "Elevation";
+  readonly INCIDENTS: "Incidents";
+  readonly PASS_THROUGH_WAYPOINTS: "PassThroughWaypoints";
+  readonly SUMMARY: "Summary";
+  readonly TOLLS: "Tolls";
+  readonly TRAVEL_STEP_INSTRUCTIONS: "TravelStepInstructions";
+  readonly TRUCK_ROAD_TYPES: "TruckRoadTypes";
+  readonly TYPICAL_DURATION: "TypicalDuration";
+  readonly ZONES: "Zones";
+};
+export type RouteLegAdditionalFeature =
+  (typeof RouteLegAdditionalFeature)[keyof typeof RouteLegAdditionalFeature];
+export interface RouteOriginOptions {
+  AvoidActionsForDistance?: number;
+  AvoidUTurns?: boolean;
+  Heading?: number;
+  Matching?: RouteMatchingOptions;
+  SideOfStreet?: RouteSideOfStreetOptions;
+}
+export declare const RouteSpanAdditionalFeature: {
+  readonly BEST_CASE_DURATION: "BestCaseDuration";
+  readonly CAR_ACCESS: "CarAccess";
+  readonly CONSUMPTION: "Consumption";
+  readonly COUNTRY: "Country";
+  readonly DISTANCE: "Distance";
+  readonly DURATION: "Duration";
+  readonly DYNAMIC_SPEED: "DynamicSpeed";
+  readonly FUNCTIONAL_CLASSIFICATION: "FunctionalClassification";
+  readonly GATES: "Gates";
+  readonly INCIDENTS: "Incidents";
+  readonly NAMES: "Names";
+  readonly NOTICES: "Notices";
+  readonly PEDESTRIAN_ACCESS: "PedestrianAccess";
+  readonly RAILWAY_CROSSINGS: "RailwayCrossings";
+  readonly REGION: "Region";
+  readonly ROAD_ATTRIBUTES: "RoadAttributes";
+  readonly ROUTE_NUMBERS: "RouteNumbers";
+  readonly SCOOTER_ACCESS: "ScooterAccess";
+  readonly SPEED_LIMIT: "SpeedLimit";
+  readonly TOLL_SYSTEMS: "TollSystems";
+  readonly TRUCK_ACCESS: "TruckAccess";
+  readonly TRUCK_ROAD_TYPES: "TruckRoadTypes";
+  readonly TYPICAL_DURATION: "TypicalDuration";
+  readonly ZONES: "Zones";
+};
+export type RouteSpanAdditionalFeature =
+  (typeof RouteSpanAdditionalFeature)[keyof typeof RouteSpanAdditionalFeature];
+export interface RouteEmissionType {
+  Co2EmissionClass?: string;
+  Type: string | undefined;
+}
+export declare const RouteTollVehicleCategory: {
+  readonly MINIBUS: "Minibus";
+};
+export type RouteTollVehicleCategory =
+  (typeof RouteTollVehicleCategory)[keyof typeof RouteTollVehicleCategory];
+export interface RouteTollOptions {
+  AllTransponders?: boolean;
+  AllVignettes?: boolean;
+  Currency?: string;
+  EmissionType?: RouteEmissionType;
+  VehicleCategory?: RouteTollVehicleCategory;
+}
+export interface RouteTrafficOptions {
+  FlowEventThresholdOverride?: number;
+  Usage?: TrafficUsage;
+}
+export declare const RouteTravelMode: {
+  readonly CAR: "Car";
+  readonly PEDESTRIAN: "Pedestrian";
+  readonly SCOOTER: "Scooter";
+  readonly TRUCK: "Truck";
+};
+export type RouteTravelMode =
+  (typeof RouteTravelMode)[keyof typeof RouteTravelMode];
+export declare const RouteEngineType: {
+  readonly ELECTRIC: "Electric";
+  readonly INTERNAL_COMBUSTION: "InternalCombustion";
+  readonly PLUGIN_HYBRID: "PluginHybrid";
+};
+export type RouteEngineType =
+  (typeof RouteEngineType)[keyof typeof RouteEngineType];
+export interface RouteVehicleLicensePlate {
+  LastCharacter?: string;
+}
+export interface RouteCarOptions {
+  EngineType?: RouteEngineType;
+  LicensePlate?: RouteVehicleLicensePlate;
+  MaxSpeed?: number;
+  Occupancy?: number;
+}
+export interface RoutePedestrianOptions {
+  Speed?: number;
+}
+export interface RouteScooterOptions {
+  EngineType?: RouteEngineType;
+  LicensePlate?: RouteVehicleLicensePlate;
+  MaxSpeed?: number;
+  Occupancy?: number;
+}
+export declare const RouteHazardousCargoType: {
+  readonly COMBUSTIBLE: "Combustible";
+  readonly CORROSIVE: "Corrosive";
+  readonly EXPLOSIVE: "Explosive";
+  readonly FLAMMABLE: "Flammable";
+  readonly GAS: "Gas";
+  readonly HARMFUL_TO_WATER: "HarmfulToWater";
+  readonly ORGANIC: "Organic";
+  readonly OTHER: "Other";
+  readonly POISON: "Poison";
+  readonly POISONOUS_INHALATION: "PoisonousInhalation";
+  readonly RADIOACTIVE: "Radioactive";
+};
+export type RouteHazardousCargoType =
+  (typeof RouteHazardousCargoType)[keyof typeof RouteHazardousCargoType];
+export interface RouteTrailerOptions {
+  AxleCount?: number;
+  TrailerCount?: number;
+}
+export declare const RouteTruckType: {
+  readonly LIGHT_TRUCK: "LightTruck";
+  readonly STRAIGHT_TRUCK: "StraightTruck";
+  readonly TRACTOR: "Tractor";
+};
+export type RouteTruckType =
+  (typeof RouteTruckType)[keyof typeof RouteTruckType];
+export interface RouteTruckOptions {
+  AxleCount?: number;
+  EngineType?: RouteEngineType;
+  GrossWeight?: number;
+  HazardousCargos?: RouteHazardousCargoType[];
+  Height?: number;
+  HeightAboveFirstAxle?: number;
+  KpraLength?: number;
+  Length?: number;
+  LicensePlate?: RouteVehicleLicensePlate;
+  MaxSpeed?: number;
+  Occupancy?: number;
+  PayloadCapacity?: number;
+  TireCount?: number;
+  Trailer?: RouteTrailerOptions;
+  TruckType?: RouteTruckType;
+  TunnelRestrictionCode?: string;
+  WeightPerAxle?: number;
+  WeightPerAxleGroup?: WeightPerAxleGroup;
+  Width?: number;
+}
+export interface RouteTravelModeOptions {
+  Car?: RouteCarOptions;
+  Pedestrian?: RoutePedestrianOptions;
+  Scooter?: RouteScooterOptions;
+  Truck?: RouteTruckOptions;
+}
+export declare const RouteTravelStepType: {
+  readonly DEFAULT: "Default";
+  readonly TURN_BY_TURN: "TurnByTurn";
+};
+export type RouteTravelStepType =
+  (typeof RouteTravelStepType)[keyof typeof RouteTravelStepType];
+export interface RouteWaypoint {
+  AvoidActionsForDistance?: number;
+  AvoidUTurns?: boolean;
+  Heading?: number;
+  Matching?: RouteMatchingOptions;
+  PassThrough?: boolean;
+  Position: number[] | undefined;
+  SideOfStreet?: RouteSideOfStreetOptions;
+  StopDuration?: number;
+}
+export interface CalculateRoutesRequest {
+  Allow?: RouteAllowOptions;
+  ArrivalTime?: string;
+  Avoid?: RouteAvoidanceOptions;
+  DepartNow?: boolean;
+  DepartureTime?: string;
+  Destination: number[] | undefined;
+  DestinationOptions?: RouteDestinationOptions;
+  Driver?: RouteDriverOptions;
+  Exclude?: RouteExclusionOptions;
+  InstructionsMeasurementSystem?: MeasurementSystem;
+  Key?: string;
+  Languages?: string[];
+  LegAdditionalFeatures?: RouteLegAdditionalFeature[];
+  LegGeometryFormat?: GeometryFormat;
+  MaxAlternatives?: number;
+  OptimizeRoutingFor?: RoutingObjective;
+  Origin: number[] | undefined;
+  OriginOptions?: RouteOriginOptions;
+  SpanAdditionalFeatures?: RouteSpanAdditionalFeature[];
+  Tolls?: RouteTollOptions;
+  Traffic?: RouteTrafficOptions;
+  TravelMode?: RouteTravelMode;
+  TravelModeOptions?: RouteTravelModeOptions;
+  TravelStepType?: RouteTravelStepType;
+  Waypoints?: RouteWaypoint[];
+}
+export declare const RouteResponseNoticeCode: {
+  readonly MAIN_LANGUAGE_NOT_FOUND: "MainLanguageNotFound";
+  readonly OTHER: "Other";
+  readonly TRAVEL_TIME_EXCEEDS_DRIVER_WORK_HOURS: "TravelTimeExceedsDriverWorkHours";
+};
+export type RouteResponseNoticeCode =
+  (typeof RouteResponseNoticeCode)[keyof typeof RouteResponseNoticeCode];
+export declare const RouteNoticeImpact: {
+  readonly HIGH: "High";
+  readonly LOW: "Low";
+};
+export type RouteNoticeImpact =
+  (typeof RouteNoticeImpact)[keyof typeof RouteNoticeImpact];
+export interface RouteResponseNotice {
+  Code: RouteResponseNoticeCode | undefined;
+  Impact?: RouteNoticeImpact;
+}
+export declare const RouteFerryAfterTravelStepType: {
+  readonly DEBOARD: "Deboard";
+};
+export type RouteFerryAfterTravelStepType =
+  (typeof RouteFerryAfterTravelStepType)[keyof typeof RouteFerryAfterTravelStepType];
+export interface RouteFerryAfterTravelStep {
+  Duration: number | undefined;
+  Instruction?: string;
+  Type: RouteFerryAfterTravelStepType | undefined;
+}
+export interface RouteFerryPlace {
+  Name?: string;
+  OriginalPosition?: number[];
+  Position: number[] | undefined;
+  WaypointIndex?: number;
+}
+export interface RouteFerryArrival {
+  Place: RouteFerryPlace | undefined;
+  Time?: string;
+}
+export declare const RouteFerryBeforeTravelStepType: {
+  readonly BOARD: "Board";
+};
+export type RouteFerryBeforeTravelStepType =
+  (typeof RouteFerryBeforeTravelStepType)[keyof typeof RouteFerryBeforeTravelStepType];
+export interface RouteFerryBeforeTravelStep {
+  Duration: number | undefined;
+  Instruction?: string;
+  Type: RouteFerryBeforeTravelStepType | undefined;
+}
+export interface RouteFerryDeparture {
+  Place: RouteFerryPlace | undefined;
+  Time?: string;
+}
+export declare const RouteFerryNoticeCode: {
+  readonly ACCURATE_POLYLINE_UNAVAILABLE: "AccuratePolylineUnavailable";
+  readonly NO_SCHEDULE: "NoSchedule";
+  readonly OTHER: "Other";
+  readonly VIOLATED_AVOID_FERRY: "ViolatedAvoidFerry";
+  readonly VIOLATED_AVOID_RAIL_FERRY: "ViolatedAvoidRailFerry";
+};
+export type RouteFerryNoticeCode =
+  (typeof RouteFerryNoticeCode)[keyof typeof RouteFerryNoticeCode];
+export interface RouteFerryNotice {
+  Code: RouteFerryNoticeCode | undefined;
+  Impact?: RouteNoticeImpact;
+}
+export interface RoutePassThroughPlace {
+  OriginalPosition?: number[];
+  Position: number[] | undefined;
+  WaypointIndex?: number;
+}
+export interface RoutePassThroughWaypoint {
+  GeometryOffset?: number;
+  Place: RoutePassThroughPlace | undefined;
+}
+export interface LocalizedString {
+  Language?: string;
+  Value: string | undefined;
+}
+export interface RouteFerrySpan {
+  Country?: string;
+  Distance?: number;
+  Duration?: number;
+  GeometryOffset?: number;
+  Names?: LocalizedString[];
+  Region?: string;
+}
+export interface RouteFerryOverviewSummary {
+  Distance: number | undefined;
+  Duration: number | undefined;
+}
+export interface RouteFerryTravelOnlySummary {
+  Duration: number | undefined;
+}
+export interface RouteFerrySummary {
+  Overview?: RouteFerryOverviewSummary;
+  TravelOnly?: RouteFerryTravelOnlySummary;
+}
+export declare const RouteFerryTravelStepType: {
+  readonly ARRIVE: "Arrive";
+  readonly CONTINUE: "Continue";
+  readonly DEPART: "Depart";
+};
+export type RouteFerryTravelStepType =
+  (typeof RouteFerryTravelStepType)[keyof typeof RouteFerryTravelStepType];
+export interface RouteFerryTravelStep {
+  Distance?: number;
+  Duration: number | undefined;
+  GeometryOffset?: number;
+  Instruction?: string;
+  Type: RouteFerryTravelStepType | undefined;
+}
+export interface RouteFerryLegDetails {
+  AfterTravelSteps: RouteFerryAfterTravelStep[] | undefined;
+  Arrival: RouteFerryArrival | undefined;
+  BeforeTravelSteps: RouteFerryBeforeTravelStep[] | undefined;
+  Departure: RouteFerryDeparture | undefined;
+  Notices: RouteFerryNotice[] | undefined;
+  PassThroughWaypoints: RoutePassThroughWaypoint[] | undefined;
+  RouteName?: string;
+  Spans: RouteFerrySpan[] | undefined;
+  Summary?: RouteFerrySummary;
+  TravelSteps: RouteFerryTravelStep[] | undefined;
+}
+export interface RouteLegGeometry {
+  LineString?: number[][];
+  Polyline?: string;
+}
+export declare const RouteSideOfStreet: {
+  readonly LEFT: "Left";
+  readonly RIGHT: "Right";
+};
+export type RouteSideOfStreet =
+  (typeof RouteSideOfStreet)[keyof typeof RouteSideOfStreet];
+export interface RoutePedestrianPlace {
+  Name?: string;
+  OriginalPosition?: number[];
+  Position: number[] | undefined;
+  SideOfStreet?: RouteSideOfStreet;
+  WaypointIndex?: number;
+}
+export interface RoutePedestrianArrival {
+  Place: RoutePedestrianPlace | undefined;
+  Time?: string;
+}
+export interface RoutePedestrianDeparture {
+  Place: RoutePedestrianPlace | undefined;
+  Time?: string;
+}
+export declare const RoutePedestrianNoticeCode: {
+  readonly ACCURATE_POLYLINE_UNAVAILABLE: "AccuratePolylineUnavailable";
+  readonly OTHER: "Other";
+  readonly VIOLATED_AVOID_DIRT_ROAD: "ViolatedAvoidDirtRoad";
+  readonly VIOLATED_AVOID_TUNNEL: "ViolatedAvoidTunnel";
+  readonly VIOLATED_PEDESTRIAN_OPTION: "ViolatedPedestrianOption";
+};
+export type RoutePedestrianNoticeCode =
+  (typeof RoutePedestrianNoticeCode)[keyof typeof RoutePedestrianNoticeCode];
+export interface RoutePedestrianNotice {
+  Code: RoutePedestrianNoticeCode | undefined;
+  Impact?: RouteNoticeImpact;
+}
+export interface RouteSpanDynamicSpeedDetails {
+  BestCaseSpeed?: number;
+  TurnDuration?: number;
+  TypicalSpeed?: number;
+}
+export declare const RouteSpanPedestrianAccessAttribute: {
+  readonly ALLOWED: "Allowed";
+  readonly INDOORS: "Indoors";
+  readonly NO_THROUGH_TRAFFIC: "NoThroughTraffic";
+  readonly PARK: "Park";
+  readonly STAIRS: "Stairs";
+  readonly TOLL_ROAD: "TollRoad";
+};
+export type RouteSpanPedestrianAccessAttribute =
+  (typeof RouteSpanPedestrianAccessAttribute)[keyof typeof RouteSpanPedestrianAccessAttribute];
+export declare const RouteSpanRoadAttribute: {
+  readonly BRIDGE: "Bridge";
+  readonly BUILT_UP_AREA: "BuiltUpArea";
+  readonly CONTROLLED_ACCESS_HIGHWAY: "ControlledAccessHighway";
+  readonly DIRT_ROAD: "DirtRoad";
+  readonly DIVIDED_ROAD: "DividedRoad";
+  readonly MOTORWAY: "Motorway";
+  readonly PRIVATE_ROAD: "PrivateRoad";
+  readonly RAMP: "Ramp";
+  readonly RIGHT_HAND_TRAFFIC: "RightHandTraffic";
+  readonly ROUNDABOUT: "Roundabout";
+  readonly TUNNEL: "Tunnel";
+  readonly UNDER_CONSTRUCTION: "UnderConstruction";
+};
+export type RouteSpanRoadAttribute =
+  (typeof RouteSpanRoadAttribute)[keyof typeof RouteSpanRoadAttribute];
+export declare const RouteDirection: {
+  readonly EAST: "East";
+  readonly NORTH: "North";
+  readonly SOUTH: "South";
+  readonly WEST: "West";
+};
+export type RouteDirection =
+  (typeof RouteDirection)[keyof typeof RouteDirection];
+export interface RouteNumber {
+  Direction?: RouteDirection;
+  Language?: string;
+  Value: string | undefined;
+}
+export interface RouteSpanSpeedLimitDetails {
+  MaxSpeed?: number;
+  Unlimited?: boolean;
+}
+export interface RoutePedestrianSpan {
+  BestCaseDuration?: number;
+  Country?: string;
+  Distance?: number;
+  Duration?: number;
+  DynamicSpeed?: RouteSpanDynamicSpeedDetails;
+  FunctionalClassification?: number;
+  GeometryOffset?: number;
+  Incidents?: number[];
+  Names?: LocalizedString[];
+  PedestrianAccess?: RouteSpanPedestrianAccessAttribute[];
+  Region?: string;
+  RoadAttributes?: RouteSpanRoadAttribute[];
+  RouteNumbers?: RouteNumber[];
+  SpeedLimit?: RouteSpanSpeedLimitDetails;
+  TypicalDuration?: number;
+}
+export interface RoutePedestrianOverviewSummary {
+  Distance: number | undefined;
+  Duration: number | undefined;
+}
+export interface RoutePedestrianTravelOnlySummary {
+  Duration: number | undefined;
+}
+export interface RoutePedestrianSummary {
+  Overview?: RoutePedestrianOverviewSummary;
+  TravelOnly?: RoutePedestrianTravelOnlySummary;
+}
+export interface RouteContinueStepDetails {
+  Intersection: LocalizedString[] | undefined;
+}
+export declare const RouteRoadType: {
+  readonly HIGHWAY: "Highway";
+  readonly RURAL: "Rural";
+  readonly URBAN: "Urban";
+};
+export type RouteRoadType = (typeof RouteRoadType)[keyof typeof RouteRoadType];
+export interface RouteRoad {
+  RoadName: LocalizedString[] | undefined;
+  RouteNumber: RouteNumber[] | undefined;
+  Towards: LocalizedString[] | undefined;
+  Type?: RouteRoadType;
+}
+export declare const RouteSteeringDirection: {
+  readonly LEFT: "Left";
+  readonly RIGHT: "Right";
+  readonly STRAIGHT: "Straight";
+};
+export type RouteSteeringDirection =
+  (typeof RouteSteeringDirection)[keyof typeof RouteSteeringDirection];
+export declare const RouteTurnIntensity: {
+  readonly SHARP: "Sharp";
+  readonly SLIGHT: "Slight";
+  readonly TYPICAL: "Typical";
+};
+export type RouteTurnIntensity =
+  (typeof RouteTurnIntensity)[keyof typeof RouteTurnIntensity];
+export interface RouteKeepStepDetails {
+  Intersection: LocalizedString[] | undefined;
+  SteeringDirection?: RouteSteeringDirection;
+  TurnAngle?: number;
+  TurnIntensity?: RouteTurnIntensity;
+}
+export interface RouteRoundaboutEnterStepDetails {
+  Intersection: LocalizedString[] | undefined;
+  SteeringDirection?: RouteSteeringDirection;
+  TurnAngle?: number;
+  TurnIntensity?: RouteTurnIntensity;
+}
+export interface RouteRoundaboutExitStepDetails {
+  Intersection: LocalizedString[] | undefined;
+  RelativeExit?: number;
+  RoundaboutAngle?: number;
+  SteeringDirection?: RouteSteeringDirection;
+}
+export interface RouteRoundaboutPassStepDetails {
+  Intersection: LocalizedString[] | undefined;
+  SteeringDirection?: RouteSteeringDirection;
+  TurnAngle?: number;
+  TurnIntensity?: RouteTurnIntensity;
+}
+export interface RouteSignpostLabel {
+  RouteNumber?: RouteNumber;
+  Text?: LocalizedString;
+}
+export interface RouteSignpost {
+  Labels: RouteSignpostLabel[] | undefined;
+}
+export interface RouteTurnStepDetails {
+  Intersection: LocalizedString[] | undefined;
+  SteeringDirection?: RouteSteeringDirection;
+  TurnAngle?: number;
+  TurnIntensity?: RouteTurnIntensity;
+}
+export declare const RoutePedestrianTravelStepType: {
+  readonly ARRIVE: "Arrive";
+  readonly CONTINUE: "Continue";
+  readonly DEPART: "Depart";
+  readonly EXIT: "Exit";
+  readonly KEEP: "Keep";
+  readonly RAMP: "Ramp";
+  readonly ROUNDABOUT_ENTER: "RoundaboutEnter";
+  readonly ROUNDABOUT_EXIT: "RoundaboutExit";
+  readonly ROUNDABOUT_PASS: "RoundaboutPass";
+  readonly TURN: "Turn";
+  readonly U_TURN: "UTurn";
+};
+export type RoutePedestrianTravelStepType =
+  (typeof RoutePedestrianTravelStepType)[keyof typeof RoutePedestrianTravelStepType];
+export interface RoutePedestrianTravelStep {
+  ContinueStepDetails?: RouteContinueStepDetails;
+  CurrentRoad?: RouteRoad;
+  Distance?: number;
+  Duration: number | undefined;
+  ExitNumber?: LocalizedString[];
+  GeometryOffset?: number;
+  Instruction?: string;
+  KeepStepDetails?: RouteKeepStepDetails;
+  NextRoad?: RouteRoad;
+  RoundaboutEnterStepDetails?: RouteRoundaboutEnterStepDetails;
+  RoundaboutExitStepDetails?: RouteRoundaboutExitStepDetails;
+  RoundaboutPassStepDetails?: RouteRoundaboutPassStepDetails;
+  Signpost?: RouteSignpost;
+  TurnStepDetails?: RouteTurnStepDetails;
+  Type: RoutePedestrianTravelStepType | undefined;
+}
+export interface RoutePedestrianLegDetails {
+  Arrival: RoutePedestrianArrival | undefined;
+  Departure: RoutePedestrianDeparture | undefined;
+  Notices: RoutePedestrianNotice[] | undefined;
+  PassThroughWaypoints: RoutePassThroughWaypoint[] | undefined;
+  Spans: RoutePedestrianSpan[] | undefined;
+  Summary?: RoutePedestrianSummary;
+  TravelSteps: RoutePedestrianTravelStep[] | undefined;
+}
+export declare const RouteLegTravelMode: {
+  readonly CAR: "Car";
+  readonly FERRY: "Ferry";
+  readonly PEDESTRIAN: "Pedestrian";
+  readonly SCOOTER: "Scooter";
+  readonly TRUCK: "Truck";
+};
+export type RouteLegTravelMode =
+  (typeof RouteLegTravelMode)[keyof typeof RouteLegTravelMode];
+export declare const RouteLegType: {
+  readonly FERRY: "Ferry";
+  readonly PEDESTRIAN: "Pedestrian";
+  readonly VEHICLE: "Vehicle";
+};
+export type RouteLegType = (typeof RouteLegType)[keyof typeof RouteLegType];
+export interface RouteVehiclePlace {
+  Name?: string;
+  OriginalPosition?: number[];
+  Position: number[] | undefined;
+  SideOfStreet?: RouteSideOfStreet;
+  WaypointIndex?: number;
+}
+export interface RouteVehicleArrival {
+  Place: RouteVehiclePlace | undefined;
+  Time?: string;
+}
+export interface RouteVehicleDeparture {
+  Place: RouteVehiclePlace | undefined;
+  Time?: string;
+}
+export declare const RouteVehicleIncidentSeverity: {
+  readonly CRITICAL: "Critical";
+  readonly HIGH: "High";
+  readonly LOW: "Low";
+  readonly MEDIUM: "Medium";
+};
+export type RouteVehicleIncidentSeverity =
+  (typeof RouteVehicleIncidentSeverity)[keyof typeof RouteVehicleIncidentSeverity];
+export declare const RouteVehicleIncidentType: {
+  readonly ACCIDENT: "Accident";
+  readonly CONGESTION: "Congestion";
+  readonly CONSTRUCTION: "Construction";
+  readonly DISABLED_VEHICLE: "DisabledVehicle";
+  readonly LANE_RESTRICTION: "LaneRestriction";
+  readonly MASS_TRANSIT: "MassTransit";
+  readonly OTHER: "Other";
+  readonly PLANNED_EVENT: "PlannedEvent";
+  readonly ROAD_CLOSURE: "RoadClosure";
+  readonly ROAD_HAZARD: "RoadHazard";
+  readonly WEATHER: "Weather";
+};
+export type RouteVehicleIncidentType =
+  (typeof RouteVehicleIncidentType)[keyof typeof RouteVehicleIncidentType];
+export interface RouteVehicleIncident {
+  Description?: string;
+  EndTime?: string;
+  Severity?: RouteVehicleIncidentSeverity;
+  StartTime?: string;
+  Type?: RouteVehicleIncidentType;
+}
+export declare const RouteVehicleNoticeCode: {
+  readonly ACCURATE_POLYLINE_UNAVAILABLE: "AccuratePolylineUnavailable";
+  readonly OTHER: "Other";
+  readonly POTENTIAL_VIOLATED_AVOID_TOLL_ROAD_USAGE: "PotentialViolatedAvoidTollRoadUsage";
+  readonly POTENTIAL_VIOLATED_CARPOOL_USAGE: "PotentialViolatedCarpoolUsage";
+  readonly POTENTIAL_VIOLATED_TURN_RESTRICTION_USAGE: "PotentialViolatedTurnRestrictionUsage";
+  readonly POTENTIAL_VIOLATED_VEHICLE_RESTRICTION_USAGE: "PotentialViolatedVehicleRestrictionUsage";
+  readonly POTENTIAL_VIOLATED_ZONE_RESTRICTION_USAGE: "PotentialViolatedZoneRestrictionUsage";
+  readonly SEASONAL_CLOSURE: "SeasonalClosure";
+  readonly TOLLS_DATA_TEMPORARILY_UNAVAILABLE: "TollsDataTemporarilyUnavailable";
+  readonly TOLLS_DATA_UNAVAILABLE: "TollsDataUnavailable";
+  readonly TOLL_TRANSPONDER: "TollTransponder";
+  readonly VIOLATED_AVOID_CONTROLLED_ACCESS_HIGHWAY: "ViolatedAvoidControlledAccessHighway";
+  readonly VIOLATED_AVOID_DIFFICULT_TURNS: "ViolatedAvoidDifficultTurns";
+  readonly VIOLATED_AVOID_DIRT_ROAD: "ViolatedAvoidDirtRoad";
+  readonly VIOLATED_AVOID_SEASONAL_CLOSURE: "ViolatedAvoidSeasonalClosure";
+  readonly VIOLATED_AVOID_TOLL_ROAD: "ViolatedAvoidTollRoad";
+  readonly VIOLATED_AVOID_TOLL_TRANSPONDER: "ViolatedAvoidTollTransponder";
+  readonly VIOLATED_AVOID_TRUCK_ROAD_TYPE: "ViolatedAvoidTruckRoadType";
+  readonly VIOLATED_AVOID_TUNNEL: "ViolatedAvoidTunnel";
+  readonly VIOLATED_AVOID_U_TURNS: "ViolatedAvoidUTurns";
+  readonly VIOLATED_BLOCKED_ROAD: "ViolatedBlockedRoad";
+  readonly VIOLATED_CARPOOL: "ViolatedCarpool";
+  readonly VIOLATED_EMERGENCY_GATE: "ViolatedEmergencyGate";
+  readonly VIOLATED_START_DIRECTION: "ViolatedStartDirection";
+  readonly VIOLATED_TURN_RESTRICTION: "ViolatedTurnRestriction";
+  readonly VIOLATED_VEHICLE_RESTRICTION: "ViolatedVehicleRestriction";
+  readonly VIOLATED_ZONE_RESTRICTION: "ViolatedZoneRestriction";
+};
+export type RouteVehicleNoticeCode =
+  (typeof RouteVehicleNoticeCode)[keyof typeof RouteVehicleNoticeCode];
+export interface RouteNoticeDetailRange {
+  Min?: number;
+  Max?: number;
+}
+export declare const RouteWeightConstraintType: {
+  readonly CURRENT: "Current";
+  readonly GROSS: "Gross";
+  readonly UNKNOWN: "Unknown";
+};
+export type RouteWeightConstraintType =
+  (typeof RouteWeightConstraintType)[keyof typeof RouteWeightConstraintType];
+export interface RouteWeightConstraint {
+  Type: RouteWeightConstraintType | undefined;
+  Value: number | undefined;
+}
+export interface RouteViolatedConstraints {
+  AllHazardsRestricted?: boolean;
+  AxleCount?: RouteNoticeDetailRange;
+  HazardousCargos: RouteHazardousCargoType[] | undefined;
+  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?: RouteTruckType;
+  TunnelRestrictionCode?: string;
+}
+export interface RouteVehicleNoticeDetail {
+  Title?: string;
+  ViolatedConstraints?: RouteViolatedConstraints;
+}
+export interface RouteVehicleNotice {
+  Code: RouteVehicleNoticeCode | undefined;
+  Details: RouteVehicleNoticeDetail[] | undefined;
+  Impact?: RouteNoticeImpact;
+}
+export declare const RouteSpanCarAccessAttribute: {
+  readonly ALLOWED: "Allowed";
+  readonly NO_THROUGH_TRAFFIC: "NoThroughTraffic";
+  readonly TOLL_ROAD: "TollRoad";
+};
+export type RouteSpanCarAccessAttribute =
+  (typeof RouteSpanCarAccessAttribute)[keyof typeof RouteSpanCarAccessAttribute];
+export declare const RouteSpanGateAttribute: {
+  readonly EMERGENCY: "Emergency";
+  readonly KEY_ACCESS: "KeyAccess";
+  readonly PERMISSION_REQUIRED: "PermissionRequired";
+};
+export type RouteSpanGateAttribute =
+  (typeof RouteSpanGateAttribute)[keyof typeof RouteSpanGateAttribute];
+export declare const RouteSpanRailwayCrossingAttribute: {
+  readonly PROTECTED: "Protected";
+  readonly UNPROTECTED: "Unprotected";
+};
+export type RouteSpanRailwayCrossingAttribute =
+  (typeof RouteSpanRailwayCrossingAttribute)[keyof typeof RouteSpanRailwayCrossingAttribute];
+export declare const RouteSpanScooterAccessAttribute: {
+  readonly ALLOWED: "Allowed";
+  readonly NO_THROUGH_TRAFFIC: "NoThroughTraffic";
+  readonly TOLL_ROAD: "TollRoad";
+};
+export type RouteSpanScooterAccessAttribute =
+  (typeof RouteSpanScooterAccessAttribute)[keyof typeof RouteSpanScooterAccessAttribute];
+export declare const RouteSpanTruckAccessAttribute: {
+  readonly ALLOWED: "Allowed";
+  readonly NO_THROUGH_TRAFFIC: "NoThroughTraffic";
+  readonly TOLL_ROAD: "TollRoad";
+};
+export type RouteSpanTruckAccessAttribute =
+  (typeof RouteSpanTruckAccessAttribute)[keyof typeof RouteSpanTruckAccessAttribute];
+export interface RouteVehicleSpan {
+  BestCaseDuration?: number;
+  CarAccess?: RouteSpanCarAccessAttribute[];
+  Country?: string;
+  Distance?: number;
+  Duration?: number;
+  DynamicSpeed?: RouteSpanDynamicSpeedDetails;
+  FunctionalClassification?: number;
+  Gate?: RouteSpanGateAttribute;
+  GeometryOffset?: number;
+  Incidents?: number[];
+  Names?: LocalizedString[];
+  Notices?: number[];
+  RailwayCrossing?: RouteSpanRailwayCrossingAttribute;
+  Region?: string;
+  RoadAttributes?: RouteSpanRoadAttribute[];
+  RouteNumbers?: RouteNumber[];
+  ScooterAccess?: RouteSpanScooterAccessAttribute[];
+  SpeedLimit?: RouteSpanSpeedLimitDetails;
+  TollSystems?: number[];
+  TruckAccess?: RouteSpanTruckAccessAttribute[];
+  TruckRoadTypes?: number[];
+  TypicalDuration?: number;
+  Zones?: number[];
+}
+export interface RouteVehicleOverviewSummary {
+  BestCaseDuration?: number;
+  Distance: number | undefined;
+  Duration: number | undefined;
+  TypicalDuration?: number;
+}
+export interface RouteVehicleTravelOnlySummary {
+  BestCaseDuration?: number;
+  Duration: number | undefined;
+  TypicalDuration?: number;
+}
+export interface RouteVehicleSummary {
+  Overview?: RouteVehicleOverviewSummary;
+  TravelOnly?: RouteVehicleTravelOnlySummary;
+}
+export interface RouteTollPaymentSite {
+  Name?: string;
+  Position: number[] | undefined;
+}
+export interface RouteTollPriceValueRange {
+  Min: number | undefined;
+  Max: number | undefined;
+}
+export interface RouteTollPrice {
+  Currency: string | undefined;
+  Estimate: boolean | undefined;
+  PerDuration?: number;
+  Range: boolean | undefined;
+  RangeValue?: RouteTollPriceValueRange;
+  Value: number | undefined;
+}
+export declare const RouteTollPassValidityPeriodType: {
+  readonly ANNUAL: "Annual";
+  readonly DAYS: "Days";
+  readonly EXTENDED_ANNUAL: "ExtendedAnnual";
+  readonly MINUTES: "Minutes";
+  readonly MONTHS: "Months";
+};
+export type RouteTollPassValidityPeriodType =
+  (typeof RouteTollPassValidityPeriodType)[keyof typeof RouteTollPassValidityPeriodType];
+export interface RouteTollPassValidityPeriod {
+  Period: RouteTollPassValidityPeriodType | undefined;
+  PeriodCount?: number;
+}
+export interface RouteTollPass {
+  IncludesReturnTrip?: boolean;
+  SeniorPass?: boolean;
+  TransferCount?: number;
+  TripCount?: number;
+  ValidityPeriod?: RouteTollPassValidityPeriod;
+}
+export declare const RouteTollPaymentMethod: {
+  readonly BANK_CARD: "BankCard";
+  readonly CASH: "Cash";
+  readonly CASH_EXACT: "CashExact";
+  readonly CREDIT_CARD: "CreditCard";
+  readonly PASS_SUBSCRIPTION: "PassSubscription";
+  readonly TRANSPONDER: "Transponder";
+  readonly TRAVEL_CARD: "TravelCard";
+  readonly VIDEO_TOLL: "VideoToll";
+};
+export type RouteTollPaymentMethod =
+  (typeof RouteTollPaymentMethod)[keyof typeof RouteTollPaymentMethod];
+export interface RouteTransponder {
+  SystemName?: string;
+}
+export interface RouteTollRate {
+  ApplicableTimes?: string;
+  ConvertedPrice?: RouteTollPrice;
+  Id: string | undefined;
+  LocalPrice: RouteTollPrice | undefined;
+  Name: string | undefined;
+  Pass?: RouteTollPass;
+  PaymentMethods: RouteTollPaymentMethod[] | undefined;
+  Transponders: RouteTransponder[] | undefined;
+}
+export interface RouteToll {
+  Country?: string;
+  PaymentSites: RouteTollPaymentSite[] | undefined;
+  Rates: RouteTollRate[] | undefined;
+  Systems: number[] | undefined;
+}
+export interface RouteTollSystem {
+  Name?: string;
+}
+export interface RouteContinueHighwayStepDetails {
+  Intersection: LocalizedString[] | undefined;
+  SteeringDirection?: RouteSteeringDirection;
+  TurnAngle?: number;
+  TurnIntensity?: RouteTurnIntensity;
+}
+export interface RouteEnterHighwayStepDetails {
+  Intersection: LocalizedString[] | undefined;
+  SteeringDirection?: RouteSteeringDirection;
+  TurnAngle?: number;
+  TurnIntensity?: RouteTurnIntensity;
+}
+export interface RouteExitStepDetails {
+  Intersection: LocalizedString[] | undefined;
+  RelativeExit?: number;
+  SteeringDirection?: RouteSteeringDirection;
+  TurnAngle?: number;
+  TurnIntensity?: RouteTurnIntensity;
+}
+export interface RouteRampStepDetails {
+  Intersection: LocalizedString[] | undefined;
+  SteeringDirection?: RouteSteeringDirection;
+  TurnAngle?: number;
+  TurnIntensity?: RouteTurnIntensity;
+}
+export declare const RouteVehicleTravelStepType: {
+  readonly ARRIVE: "Arrive";
+  readonly CONTINUE: "Continue";
+  readonly CONTINUE_HIGHWAY: "ContinueHighway";
+  readonly DEPART: "Depart";
+  readonly ENTER_HIGHWAY: "EnterHighway";
+  readonly EXIT: "Exit";
+  readonly KEEP: "Keep";
+  readonly RAMP: "Ramp";
+  readonly ROUNDABOUT_ENTER: "RoundaboutEnter";
+  readonly ROUNDABOUT_EXIT: "RoundaboutExit";
+  readonly ROUNDABOUT_PASS: "RoundaboutPass";
+  readonly TURN: "Turn";
+  readonly U_TURN: "UTurn";
+};
+export type RouteVehicleTravelStepType =
+  (typeof RouteVehicleTravelStepType)[keyof typeof RouteVehicleTravelStepType];
+export interface RouteUTurnStepDetails {
+  Intersection: LocalizedString[] | undefined;
+  SteeringDirection?: RouteSteeringDirection;
+  TurnAngle?: number;
+  TurnIntensity?: RouteTurnIntensity;
+}
+export interface RouteVehicleTravelStep {
+  ContinueHighwayStepDetails?: RouteContinueHighwayStepDetails;
+  ContinueStepDetails?: RouteContinueStepDetails;
+  CurrentRoad?: RouteRoad;
+  Distance?: number;
+  Duration: number | undefined;
+  EnterHighwayStepDetails?: RouteEnterHighwayStepDetails;
+  ExitNumber?: LocalizedString[];
+  ExitStepDetails?: RouteExitStepDetails;
+  GeometryOffset?: number;
+  Instruction?: string;
+  KeepStepDetails?: RouteKeepStepDetails;
+  NextRoad?: RouteRoad;
+  RampStepDetails?: RouteRampStepDetails;
+  RoundaboutEnterStepDetails?: RouteRoundaboutEnterStepDetails;
+  RoundaboutExitStepDetails?: RouteRoundaboutExitStepDetails;
+  RoundaboutPassStepDetails?: RouteRoundaboutPassStepDetails;
+  Signpost?: RouteSignpost;
+  TurnStepDetails?: RouteTurnStepDetails;
+  Type: RouteVehicleTravelStepType | undefined;
+  UTurnStepDetails?: RouteUTurnStepDetails;
+}
+export interface RouteZone {
+  Category?: RouteZoneCategory;
+  Name?: string;
+}
+export interface RouteVehicleLegDetails {
+  Arrival: RouteVehicleArrival | undefined;
+  Departure: RouteVehicleDeparture | undefined;
+  Incidents: RouteVehicleIncident[] | undefined;
+  Notices: RouteVehicleNotice[] | undefined;
+  PassThroughWaypoints: RoutePassThroughWaypoint[] | undefined;
+  Spans: RouteVehicleSpan[] | undefined;
+  Summary?: RouteVehicleSummary;
+  Tolls: RouteToll[] | undefined;
+  TollSystems: RouteTollSystem[] | undefined;
+  TravelSteps: RouteVehicleTravelStep[] | undefined;
+  TruckRoadTypes: string[] | undefined;
+  Zones: RouteZone[] | undefined;
+}
+export interface RouteLeg {
+  FerryLegDetails?: RouteFerryLegDetails;
+  Geometry: RouteLegGeometry | undefined;
+  Language?: string;
+  PedestrianLegDetails?: RoutePedestrianLegDetails;
+  TravelMode: RouteLegTravelMode | undefined;
+  Type: RouteLegType | undefined;
+  VehicleLegDetails?: RouteVehicleLegDetails;
+}
+export interface RouteMajorRoadLabel {
+  RoadName?: LocalizedString;
+  RouteNumber?: RouteNumber;
+}
+export interface RouteTollPriceSummary {
+  Currency: string | undefined;
+  Estimate: boolean | undefined;
+  Range: boolean | undefined;
+  RangeValue?: RouteTollPriceValueRange;
+  Value: number | undefined;
+}
+export interface RouteTollSummary {
+  Total?: RouteTollPriceSummary;
+}
+export interface RouteSummary {
+  Distance?: number;
+  Duration?: number;
+  Tolls?: RouteTollSummary;
+}
+export interface Route {
+  Legs: RouteLeg[] | undefined;
+  MajorRoadLabels: RouteMajorRoadLabel[] | undefined;
+  Summary?: RouteSummary;
+}
+export interface CalculateRoutesResponse {
+  LegGeometryFormat: GeometryFormat | undefined;
+  Notices: RouteResponseNotice[] | undefined;
+  PricingBucket: string | undefined;
+  Routes: Route[] | undefined;
+}
+export declare const DayOfWeek: {
+  readonly FRIDAY: "Friday";
+  readonly MONDAY: "Monday";
+  readonly SATURDAY: "Saturday";
+  readonly SUNDAY: "Sunday";
+  readonly THURSDAY: "Thursday";
+  readonly TUESDAY: "Tuesday";
+  readonly WEDNESDAY: "Wednesday";
+};
+export type DayOfWeek = (typeof DayOfWeek)[keyof typeof DayOfWeek];
+export interface WaypointOptimizationAvoidanceAreaGeometry {
+  BoundingBox?: number[];
+}
+export interface WaypointOptimizationAvoidanceArea {
+  Geometry: WaypointOptimizationAvoidanceAreaGeometry | undefined;
+}
+export interface WaypointOptimizationAvoidanceOptions {
+  Areas?: WaypointOptimizationAvoidanceArea[];
+  CarShuttleTrains?: boolean;
+  ControlledAccessHighways?: boolean;
+  DirtRoads?: boolean;
+  Ferries?: boolean;
+  TollRoads?: boolean;
+  Tunnels?: boolean;
+  UTurns?: boolean;
+}
+export interface WaypointOptimizationAccessHoursEntry {
+  DayOfWeek: DayOfWeek | undefined;
+  TimeOfDay: string | undefined;
+}
+export interface WaypointOptimizationAccessHours {
+  From: WaypointOptimizationAccessHoursEntry | undefined;
+  To: WaypointOptimizationAccessHoursEntry | undefined;
+}
+export interface WaypointOptimizationSideOfStreetOptions {
+  Position: number[] | undefined;
+  UseWith?: SideOfStreetMatchingStrategy;
+}
+export interface WaypointOptimizationDestinationOptions {
+  AccessHours?: WaypointOptimizationAccessHours;
+  AppointmentTime?: string;
+  Heading?: number;
+  Id?: string;
+  ServiceDuration?: number;
+  SideOfStreet?: WaypointOptimizationSideOfStreetOptions;
+}
+export interface WaypointOptimizationRestCycleDurations {
+  RestDuration: number | undefined;
+  WorkDuration: number | undefined;
+}
+export interface WaypointOptimizationRestCycles {
+  LongCycle: WaypointOptimizationRestCycleDurations | undefined;
+  ShortCycle: WaypointOptimizationRestCycleDurations | undefined;
+}
+export interface WaypointOptimizationRestProfile {
+  Profile: string | undefined;
+}
+export declare const WaypointOptimizationServiceTimeTreatment: {
+  readonly REST: "Rest";
+  readonly WORK: "Work";
+};
+export type WaypointOptimizationServiceTimeTreatment =
+  (typeof WaypointOptimizationServiceTimeTreatment)[keyof typeof WaypointOptimizationServiceTimeTreatment];
+export interface WaypointOptimizationDriverOptions {
+  RestCycles?: WaypointOptimizationRestCycles;
+  RestProfile?: WaypointOptimizationRestProfile;
+  TreatServiceTimeAs?: WaypointOptimizationServiceTimeTreatment;
+}
+export interface WaypointOptimizationExclusionOptions {
+  Countries: string[] | undefined;
+}
+export declare const WaypointOptimizationSequencingObjective: {
+  readonly FASTEST_ROUTE: "FastestRoute";
+  readonly SHORTEST_ROUTE: "ShortestRoute";
+};
+export type WaypointOptimizationSequencingObjective =
+  (typeof WaypointOptimizationSequencingObjective)[keyof typeof WaypointOptimizationSequencingObjective];
+export interface WaypointOptimizationOriginOptions {
+  Id?: string;
+}
+export interface WaypointOptimizationTrafficOptions {
+  Usage?: TrafficUsage;
+}
+export declare const WaypointOptimizationTravelMode: {
+  readonly CAR: "Car";
+  readonly PEDESTRIAN: "Pedestrian";
+  readonly SCOOTER: "Scooter";
+  readonly TRUCK: "Truck";
+};
+export type WaypointOptimizationTravelMode =
+  (typeof WaypointOptimizationTravelMode)[keyof typeof WaypointOptimizationTravelMode];
+export interface WaypointOptimizationPedestrianOptions {
+  Speed?: number;
+}
+export declare const WaypointOptimizationHazardousCargoType: {
+  readonly COMBUSTIBLE: "Combustible";
+  readonly CORROSIVE: "Corrosive";
+  readonly EXPLOSIVE: "Explosive";
+  readonly FLAMMABLE: "Flammable";
+  readonly GAS: "Gas";
+  readonly HARMFUL_TO_WATER: "HarmfulToWater";
+  readonly ORGANIC: "Organic";
+  readonly OTHER: "Other";
+  readonly POISON: "Poison";
+  readonly POISONOUS_INHALATION: "PoisonousInhalation";
+  readonly RADIOACTIVE: "Radioactive";
+};
+export type WaypointOptimizationHazardousCargoType =
+  (typeof WaypointOptimizationHazardousCargoType)[keyof typeof WaypointOptimizationHazardousCargoType];
+export interface WaypointOptimizationTrailerOptions {
+  TrailerCount?: number;
+}
+export declare const WaypointOptimizationTruckType: {
+  readonly STRAIGHT_TRUCK: "StraightTruck";
+  readonly TRACTOR: "Tractor";
+};
+export type WaypointOptimizationTruckType =
+  (typeof WaypointOptimizationTruckType)[keyof typeof WaypointOptimizationTruckType];
+export interface WaypointOptimizationTruckOptions {
+  GrossWeight?: number;
+  HazardousCargos?: WaypointOptimizationHazardousCargoType[];
+  Height?: number;
+  Length?: number;
+  Trailer?: WaypointOptimizationTrailerOptions;
+  TruckType?: WaypointOptimizationTruckType;
+  TunnelRestrictionCode?: string;
+  WeightPerAxle?: number;
+  Width?: number;
+}
+export interface WaypointOptimizationTravelModeOptions {
+  Pedestrian?: WaypointOptimizationPedestrianOptions;
+  Truck?: WaypointOptimizationTruckOptions;
+}
+export interface WaypointOptimizationWaypoint {
+  AccessHours?: WaypointOptimizationAccessHours;
+  AppointmentTime?: string;
+  Before?: number[];
+  Heading?: number;
+  Id?: string;
+  Position: number[] | undefined;
+  ServiceDuration?: number;
+  SideOfStreet?: WaypointOptimizationSideOfStreetOptions;
+}
+export interface OptimizeWaypointsRequest {
+  Avoid?: WaypointOptimizationAvoidanceOptions;
+  DepartureTime?: string;
+  Destination?: number[];
+  DestinationOptions?: WaypointOptimizationDestinationOptions;
+  Driver?: WaypointOptimizationDriverOptions;
+  Exclude?: WaypointOptimizationExclusionOptions;
+  Key?: string;
+  OptimizeSequencingFor?: WaypointOptimizationSequencingObjective;
+  Origin: number[] | undefined;
+  OriginOptions?: WaypointOptimizationOriginOptions;
+  Traffic?: WaypointOptimizationTrafficOptions;
+  TravelMode?: WaypointOptimizationTravelMode;
+  TravelModeOptions?: WaypointOptimizationTravelModeOptions;
+  Waypoints?: WaypointOptimizationWaypoint[];
+}
+export interface WaypointOptimizationConnection {
+  Distance: number | undefined;
+  From: string | undefined;
+  RestDuration: number | undefined;
+  To: string | undefined;
+  TravelDuration: number | undefined;
+  WaitDuration: number | undefined;
+}
+export declare const WaypointOptimizationConstraint: {
+  readonly ACCESS_HOURS: "AccessHours";
+  readonly APPOINTMENT_TIME: "AppointmentTime";
+  readonly BEFORE: "Before";
+  readonly HEADING: "Heading";
+  readonly SERVICE_DURATION: "ServiceDuration";
+  readonly SIDE_OF_STREET: "SideOfStreet";
+};
+export type WaypointOptimizationConstraint =
+  (typeof WaypointOptimizationConstraint)[keyof typeof WaypointOptimizationConstraint];
+export interface WaypointOptimizationFailedConstraint {
+  Constraint?: WaypointOptimizationConstraint;
+  Reason?: string;
+}
+export interface WaypointOptimizationImpedingWaypoint {
+  FailedConstraints: WaypointOptimizationFailedConstraint[] | undefined;
+  Id: string | undefined;
+  Position: number[] | undefined;
+}
+export interface WaypointOptimizationOptimizedWaypoint {
+  ArrivalTime?: string;
+  DepartureTime: string | undefined;
+  Id: string | undefined;
+  Position: number[] | undefined;
+}
+export interface WaypointOptimizationTimeBreakdown {
+  RestDuration: number | undefined;
+  ServiceDuration: number | undefined;
+  TravelDuration: number | undefined;
+  WaitDuration: number | undefined;
+}
+export interface OptimizeWaypointsResponse {
+  Connections: WaypointOptimizationConnection[] | undefined;
+  Distance: number | undefined;
+  Duration: number | undefined;
+  ImpedingWaypoints: WaypointOptimizationImpedingWaypoint[] | undefined;
+  OptimizedWaypoints: WaypointOptimizationOptimizedWaypoint[] | undefined;
+  PricingBucket: string | undefined;
+  TimeBreakdown: WaypointOptimizationTimeBreakdown | undefined;
+}
+export interface RoadSnapTracePoint {
+  Heading?: number;
+  Position: number[] | undefined;
+  Speed?: number;
+  Timestamp?: string;
+}
+export declare const RoadSnapTravelMode: {
+  readonly CAR: "Car";
+  readonly PEDESTRIAN: "Pedestrian";
+  readonly SCOOTER: "Scooter";
+  readonly TRUCK: "Truck";
+};
+export type RoadSnapTravelMode =
+  (typeof RoadSnapTravelMode)[keyof typeof RoadSnapTravelMode];
+export declare const RoadSnapHazardousCargoType: {
+  readonly COMBUSTIBLE: "Combustible";
+  readonly CORROSIVE: "Corrosive";
+  readonly EXPLOSIVE: "Explosive";
+  readonly FLAMMABLE: "Flammable";
+  readonly GAS: "Gas";
+  readonly HARMFUL_TO_WATER: "HarmfulToWater";
+  readonly ORGANIC: "Organic";
+  readonly OTHER: "Other";
+  readonly POISON: "Poison";
+  readonly POISONOUS_INHALATION: "PoisonousInhalation";
+  readonly RADIOACTIVE: "Radioactive";
+};
+export type RoadSnapHazardousCargoType =
+  (typeof RoadSnapHazardousCargoType)[keyof typeof RoadSnapHazardousCargoType];
+export interface RoadSnapTrailerOptions {
+  TrailerCount?: number;
+}
+export interface RoadSnapTruckOptions {
+  GrossWeight?: number;
+  HazardousCargos?: RoadSnapHazardousCargoType[];
+  Height?: number;
+  Length?: number;
+  Trailer?: RoadSnapTrailerOptions;
+  TunnelRestrictionCode?: string;
+  Width?: number;
+}
+export interface RoadSnapTravelModeOptions {
+  Truck?: RoadSnapTruckOptions;
+}
+export interface SnapToRoadsRequest {
+  Key?: string;
+  SnappedGeometryFormat?: GeometryFormat;
+  SnapRadius?: number;
+  TracePoints: RoadSnapTracePoint[] | undefined;
+  TravelMode?: RoadSnapTravelMode;
+  TravelModeOptions?: RoadSnapTravelModeOptions;
+}
+export declare const RoadSnapNoticeCode: {
+  readonly TRACE_POINTS_HEADING_IGNORED: "TracePointsHeadingIgnored";
+  readonly TRACE_POINTS_IGNORED: "TracePointsIgnored";
+  readonly TRACE_POINTS_MOVED_BY_LARGE_DISTANCE: "TracePointsMovedByLargeDistance";
+  readonly TRACE_POINTS_NOT_MATCHED: "TracePointsNotMatched";
+  readonly TRACE_POINTS_OUT_OF_SEQUENCE: "TracePointsOutOfSequence";
+  readonly TRACE_POINTS_SPEED_ESTIMATED: "TracePointsSpeedEstimated";
+  readonly TRACE_POINTS_SPEED_IGNORED: "TracePointsSpeedIgnored";
+};
+export type RoadSnapNoticeCode =
+  (typeof RoadSnapNoticeCode)[keyof typeof RoadSnapNoticeCode];
+export interface RoadSnapNotice {
+  Code: RoadSnapNoticeCode | undefined;
+  Title: string | undefined;
+  TracePointIndexes: number[] | undefined;
+}
+export interface RoadSnapSnappedGeometry {
+  LineString?: number[][];
+  Polyline?: string;
+}
+export interface RoadSnapSnappedTracePoint {
+  Confidence: number | undefined;
+  OriginalPosition: number[] | undefined;
+  SnappedPosition: number[] | undefined;
+}
+export interface SnapToRoadsResponse {
+  Notices: RoadSnapNotice[] | undefined;
+  PricingBucket: string | undefined;
+  SnappedGeometry?: RoadSnapSnappedGeometry;
+  SnappedGeometryFormat: GeometryFormat | undefined;
+  SnappedTracePoints: RoadSnapSnappedTracePoint[] | undefined;
+}
+export declare const CorridorFilterSensitiveLog: (obj: Corridor) => any;
+export declare const PolylineCorridorFilterSensitiveLog: (
+  obj: PolylineCorridor
+) => any;
+export declare const IsolineAvoidanceAreaGeometryFilterSensitiveLog: (
+  obj: IsolineAvoidanceAreaGeometry
+) => any;
+export declare const IsolineAvoidanceAreaFilterSensitiveLog: (
+  obj: IsolineAvoidanceArea
+) => any;
+export declare const IsolineAvoidanceOptionsFilterSensitiveLog: (
+  obj: IsolineAvoidanceOptions
+) => any;
+export declare const IsolineMatchingOptionsFilterSensitiveLog: (
+  obj: IsolineMatchingOptions
+) => any;
+export declare const IsolineSideOfStreetOptionsFilterSensitiveLog: (
+  obj: IsolineSideOfStreetOptions
+) => any;
+export declare const IsolineDestinationOptionsFilterSensitiveLog: (
+  obj: IsolineDestinationOptions
+) => any;
+export declare const IsolineOriginOptionsFilterSensitiveLog: (
+  obj: IsolineOriginOptions
+) => any;
+export declare const CalculateIsolinesRequestFilterSensitiveLog: (
+  obj: CalculateIsolinesRequest
+) => any;
+export declare const IsolineConnectionGeometryFilterSensitiveLog: (
+  obj: IsolineConnectionGeometry
+) => any;
+export declare const IsolineConnectionFilterSensitiveLog: (
+  obj: IsolineConnection
+) => any;
+export declare const IsolineShapeGeometryFilterSensitiveLog: (
+  obj: IsolineShapeGeometry
+) => any;
+export declare const IsolineFilterSensitiveLog: (obj: Isoline) => any;
+export declare const CalculateIsolinesResponseFilterSensitiveLog: (
+  obj: CalculateIsolinesResponse
+) => any;
+export declare const RouteMatrixAvoidanceAreaGeometryFilterSensitiveLog: (
+  obj: RouteMatrixAvoidanceAreaGeometry
+) => any;
+export declare const RouteMatrixAvoidanceAreaFilterSensitiveLog: (
+  obj: RouteMatrixAvoidanceArea
+) => any;
+export declare const RouteMatrixAvoidanceOptionsFilterSensitiveLog: (
+  obj: RouteMatrixAvoidanceOptions
+) => any;
+export declare const RouteMatrixMatchingOptionsFilterSensitiveLog: (
+  obj: RouteMatrixMatchingOptions
+) => any;
+export declare const RouteMatrixSideOfStreetOptionsFilterSensitiveLog: (
+  obj: RouteMatrixSideOfStreetOptions
+) => any;
+export declare const RouteMatrixDestinationOptionsFilterSensitiveLog: (
+  obj: RouteMatrixDestinationOptions
+) => any;
+export declare const RouteMatrixDestinationFilterSensitiveLog: (
+  obj: RouteMatrixDestination
+) => any;
+export declare const RouteMatrixOriginOptionsFilterSensitiveLog: (
+  obj: RouteMatrixOriginOptions
+) => any;
+export declare const RouteMatrixOriginFilterSensitiveLog: (
+  obj: RouteMatrixOrigin
+) => any;
+export declare const CircleFilterSensitiveLog: (obj: Circle) => any;
+export declare const RouteMatrixBoundaryGeometryFilterSensitiveLog: (
+  obj: RouteMatrixBoundaryGeometry
+) => any;
+export declare const RouteMatrixBoundaryFilterSensitiveLog: (
+  obj: RouteMatrixBoundary
+) => any;
+export declare const CalculateRouteMatrixRequestFilterSensitiveLog: (
+  obj: CalculateRouteMatrixRequest
+) => any;
+export declare const CalculateRouteMatrixResponseFilterSensitiveLog: (
+  obj: CalculateRouteMatrixResponse
+) => any;
+export declare const RouteAvoidanceAreaGeometryFilterSensitiveLog: (
+  obj: RouteAvoidanceAreaGeometry
+) => any;
+export declare const RouteAvoidanceAreaFilterSensitiveLog: (
+  obj: RouteAvoidanceArea
+) => any;
+export declare const RouteAvoidanceOptionsFilterSensitiveLog: (
+  obj: RouteAvoidanceOptions
+) => any;
+export declare const RouteMatchingOptionsFilterSensitiveLog: (
+  obj: RouteMatchingOptions
+) => any;
+export declare const RouteSideOfStreetOptionsFilterSensitiveLog: (
+  obj: RouteSideOfStreetOptions
+) => any;
+export declare const RouteDestinationOptionsFilterSensitiveLog: (
+  obj: RouteDestinationOptions
+) => any;
+export declare const RouteOriginOptionsFilterSensitiveLog: (
+  obj: RouteOriginOptions
+) => any;
+export declare const RouteWaypointFilterSensitiveLog: (
+  obj: RouteWaypoint
+) => any;
+export declare const CalculateRoutesRequestFilterSensitiveLog: (
+  obj: CalculateRoutesRequest
+) => any;
+export declare const RouteFerryPlaceFilterSensitiveLog: (
+  obj: RouteFerryPlace
+) => any;
+export declare const RouteFerryArrivalFilterSensitiveLog: (
+  obj: RouteFerryArrival
+) => any;
+export declare const RouteFerryDepartureFilterSensitiveLog: (
+  obj: RouteFerryDeparture
+) => any;
+export declare const RoutePassThroughPlaceFilterSensitiveLog: (
+  obj: RoutePassThroughPlace
+) => any;
+export declare const RoutePassThroughWaypointFilterSensitiveLog: (
+  obj: RoutePassThroughWaypoint
+) => any;
+export declare const RouteFerryLegDetailsFilterSensitiveLog: (
+  obj: RouteFerryLegDetails
+) => any;
+export declare const RouteLegGeometryFilterSensitiveLog: (
+  obj: RouteLegGeometry
+) => any;
+export declare const RoutePedestrianPlaceFilterSensitiveLog: (
+  obj: RoutePedestrianPlace
+) => any;
+export declare const RoutePedestrianArrivalFilterSensitiveLog: (
+  obj: RoutePedestrianArrival
+) => any;
+export declare const RoutePedestrianDepartureFilterSensitiveLog: (
+  obj: RoutePedestrianDeparture
+) => any;
+export declare const RoutePedestrianLegDetailsFilterSensitiveLog: (
+  obj: RoutePedestrianLegDetails
+) => any;
+export declare const RouteVehiclePlaceFilterSensitiveLog: (
+  obj: RouteVehiclePlace
+) => any;
+export declare const RouteVehicleArrivalFilterSensitiveLog: (
+  obj: RouteVehicleArrival
+) => any;
+export declare const RouteVehicleDepartureFilterSensitiveLog: (
+  obj: RouteVehicleDeparture
+) => any;
+export declare const RouteTollPaymentSiteFilterSensitiveLog: (
+  obj: RouteTollPaymentSite
+) => any;
+export declare const RouteTollFilterSensitiveLog: (obj: RouteToll) => any;
+export declare const RouteVehicleLegDetailsFilterSensitiveLog: (
+  obj: RouteVehicleLegDetails
+) => any;
+export declare const RouteLegFilterSensitiveLog: (obj: RouteLeg) => any;
+export declare const RouteFilterSensitiveLog: (obj: Route) => any;
+export declare const CalculateRoutesResponseFilterSensitiveLog: (
+  obj: CalculateRoutesResponse
+) => any;
+export declare const WaypointOptimizationAvoidanceAreaGeometryFilterSensitiveLog: (
+  obj: WaypointOptimizationAvoidanceAreaGeometry
+) => any;
+export declare const WaypointOptimizationAvoidanceAreaFilterSensitiveLog: (
+  obj: WaypointOptimizationAvoidanceArea
+) => any;
+export declare const WaypointOptimizationAvoidanceOptionsFilterSensitiveLog: (
+  obj: WaypointOptimizationAvoidanceOptions
+) => any;
+export declare const WaypointOptimizationSideOfStreetOptionsFilterSensitiveLog: (
+  obj: WaypointOptimizationSideOfStreetOptions
+) => any;
+export declare const WaypointOptimizationDestinationOptionsFilterSensitiveLog: (
+  obj: WaypointOptimizationDestinationOptions
+) => any;
+export declare const WaypointOptimizationWaypointFilterSensitiveLog: (
+  obj: WaypointOptimizationWaypoint
+) => any;
+export declare const OptimizeWaypointsRequestFilterSensitiveLog: (
+  obj: OptimizeWaypointsRequest
+) => any;
+export declare const WaypointOptimizationImpedingWaypointFilterSensitiveLog: (
+  obj: WaypointOptimizationImpedingWaypoint
+) => any;
+export declare const WaypointOptimizationOptimizedWaypointFilterSensitiveLog: (
+  obj: WaypointOptimizationOptimizedWaypoint
+) => any;
+export declare const OptimizeWaypointsResponseFilterSensitiveLog: (
+  obj: OptimizeWaypointsResponse
+) => any;
+export declare const RoadSnapTracePointFilterSensitiveLog: (
+  obj: RoadSnapTracePoint
+) => any;
+export declare const SnapToRoadsRequestFilterSensitiveLog: (
+  obj: SnapToRoadsRequest
+) => any;
+export declare const RoadSnapSnappedGeometryFilterSensitiveLog: (
+  obj: RoadSnapSnappedGeometry
+) => any;
+export declare const RoadSnapSnappedTracePointFilterSensitiveLog: (
+  obj: RoadSnapSnappedTracePoint
+) => any;
+export declare const SnapToRoadsResponseFilterSensitiveLog: (
+  obj: SnapToRoadsResponse
+) => any;