@wemap/routers 12.10.8 → 12.11.0

package/dist/src/ItineraryInfoManager.d.ts

@@ -0,0 +1,31 @@
+import { Coordinates } from '@wemap/geo';
+import { default as Itinerary } from './model/Itinerary.js';
+import { default as Leg } from './model/Leg.js';
+import { Step } from './model/Step.js';
+import { default as Graph } from './graph/Graph.js';
+import { default as GraphProjection } from './graph/GraphProjection.js';
+export type ItineraryInfo<U extends Coordinates = Coordinates> = {
+    nextStep: Step | null;
+    previousStep: Step | null;
+    projection: GraphProjection<U>;
+    leg: Leg;
+    traveledDistance: number;
+    remainingDistance: number;
+    traveledPercentage: number;
+    remainingPercentage: number;
+};
+declare class ItineraryInfoManager {
+    _itinerary: Itinerary | null;
+    _graph: Graph | null;
+    _steps: Step[];
+    _coordsNextStep: (Step | null)[];
+    _coordsPreviousStep: (Step | null)[];
+    _coordsDistanceTraveled: number[];
+    _coordsLeg: Leg[];
+    _itineraryDistanceWithoutProjections: number;
+    constructor(itinerary?: Itinerary | null);
+    get itinerary(): Itinerary | null;
+    set itinerary(itinerary: Itinerary | null);
+    getInfo<U extends Coordinates = Coordinates>(position: U): ItineraryInfo<U> | null;
+}
+export default ItineraryInfoManager;

package/dist/src/RoutingError.d.ts

@@ -0,0 +1,24 @@
+import { StatusCode } from './StatusCode';
+import { TravelMode } from './model/TravelMode';
+export declare class RoutingError extends Error {
+    code: StatusCode;
+    customMapName?: string | null;
+    constructor(code?: StatusCode, message?: string);
+    static notFound(details?: string): RoutingError;
+}
+export declare class WemapMultiRoutingError extends RoutingError {
+    code: StatusCode;
+    mapName: string | null;
+    constructor(code: StatusCode, mapName: string | null, message?: string);
+    static notFound(mapName: string, details?: string): WemapMultiRoutingError;
+}
+export declare class RemoteRoutingError extends RoutingError {
+    code: StatusCode;
+    routerName: string;
+    constructor(code: StatusCode, routerName: string, message?: string);
+    static notFound(routerName: string, details?: string): RemoteRoutingError;
+    static missingApiKey(routerName: string, details?: string): RemoteRoutingError;
+    static unreachableServer(routerName: string, url: string): RemoteRoutingError;
+    static responseNotParsing(routerName: string, url: string): RemoteRoutingError;
+    static travelModeUnimplemented(routerName: string, travelMode: TravelMode): RemoteRoutingError;
+}

package/{src/StatusCode.ts → dist/src/StatusCode.d.ts}

@@ -1,5 +1,4 @@
-// https://developers.google.com/actions-center/reference/grpc-api/status_codes
-export enum StatusCode {
+export declare enum StatusCode {
     OK = 0,
     CANCELLED = 1,
     UNKNOWN = 2,
@@ -9,4 +8,4 @@ export enum StatusCode {
     INTERNAL = 13,
     UNAVAILABLE = 14,
     UNAUTHENTICATED = 16
-}
+}

package/dist/src/Utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get route duration
+ * @param {Number} speed in km/h
+ * @returns {Number} duration in seconds
+ */
+export declare function getDurationFromLength(length: number, speed?: number): number;

package/dist/src/graph/Edge.d.ts

@@ -0,0 +1,38 @@
+import { Level_t } from '@wemap/geo';
+import { default as Vertex } from './Vertex.js';
+export type EdgeSmoothness = 'excellent' | 'good' | 'intermediate' | 'bad' | 'horrible';
+export type EdgeSurface = 'asphalt' | 'compacted' | 'concrete' | 'grass' | 'gravel' | 'ground' | 'metal' | 'paving_stones' | 'wood';
+export type EdgeWheelchair = 'yes' | 'no' | 'designated';
+export type EdgeProperties = {
+    name?: string;
+    externalId?: string | number;
+    isOneway?: boolean;
+    areStairs?: boolean;
+    isElevator?: boolean;
+    areEscalators?: boolean;
+    isMovingWalkway?: boolean;
+    needTicket?: boolean;
+    incline?: 'up' | 'down';
+    wheelchair?: EdgeWheelchair;
+    smoothness?: EdgeSmoothness;
+    surface?: EdgeSurface;
+};
+/**
+ * An Edge is a segment composed of two Vertex
+ * An edge is mostly issued from an OsmWay, but this is not always the case.
+ * For example, edges created by mapmatching.
+ */
+export default class Edge {
+    vertex1: Vertex;
+    vertex2: Vertex;
+    properties: EdgeProperties;
+    readonly id: number;
+    static currentUniqueId: number;
+    readonly level: Level_t;
+    /** Edge bearing from vertex1 to vertex2 */
+    readonly bearing: number;
+    readonly length: number;
+    constructor(vertex1: Vertex, vertex2: Vertex, properties?: EdgeProperties, id?: number);
+    static getEdgeByVertices(edges: Edge[], vertex1: Vertex, vertex2: Vertex): Edge | undefined;
+    reverseProperties(): void;
+}

package/dist/src/graph/Graph.d.ts

@@ -0,0 +1,40 @@
+import { BoundingBox, Coordinates, UserPosition, Level_t } from '@wemap/geo';
+import { default as Edge } from './Edge.js';
+import { default as GraphProjection } from './GraphProjection.js';
+import { default as Vertex } from './Vertex.js';
+import { CompressedGeoGraphJson, GeoGraphJson } from '../types.js';
+import { GraphProjectionOptions } from './GraphProjectionOptions.js';
+declare class Graph {
+    readonly vertices: Vertex[];
+    readonly edges: Edge[];
+    /**
+     * exitVertices are vertices that have at least one indoor edge and one outdoor edge
+     * They are stored because the Level model cannot handle an indoor and outdoor state like [null, 1] or [null, [1,2]]
+     * This vertices are used to cover the projection case:
+     * - if projection origin is null, an exit vertex can be used
+     * - if projection origin is not null, the intersection level with an exit vertex can be used
+     */
+    readonly exitVertices: Set<Vertex>;
+    constructor(vertices: Vertex[], edges: Edge[]);
+    getEdgeByVertices(vertex1: Vertex, vertex2: Vertex): Edge | undefined;
+    getVertexByCoords(coords: Coordinates): Vertex | undefined;
+    static getVertexByCoords(vertices: Vertex[], coords: Coordinates): Vertex | undefined;
+    getVertexByName(name: string): Vertex | undefined;
+    getEdgeByName(name: string): Edge | undefined;
+    getBoundingBox(extendedMeasure?: number): BoundingBox | null;
+    getProjection<U extends (Coordinates | UserPosition)>(origin: U, options?: GraphProjectionOptions): GraphProjection<U> | null;
+    toJson(): GeoGraphJson;
+    static fromJson(json: GeoGraphJson): Graph;
+    /** @deprecated */
+    toCompressedJson(): CompressedGeoGraphJson;
+    /** @deprecated */
+    static fromCompressedJson(json: CompressedGeoGraphJson): Graph;
+    static fromCoordinatesSegments(segments: Coordinates[][]): Graph;
+    /**
+     * Create edges From MultiLevel Itinerary for a given level
+     * @param useMultiLevelEdges use segments which intersect both levels (stairs, elevators...)
+     */
+    getEdgesAtLevel(targetLevel: Level_t, useMultiLevelEdges?: boolean): Edge[];
+    toDetailedString(): string;
+}
+export default Graph;

package/dist/src/graph/GraphProjection.d.ts

@@ -0,0 +1,11 @@
+import { Coordinates, UserPosition } from '@wemap/geo';
+import { default as Edge } from './Edge.js';
+import { default as Vertex } from './Vertex.js';
+declare class GraphProjection<U extends Coordinates | UserPosition = Coordinates> {
+    readonly origin: U;
+    readonly distanceFromNearestElement: number;
+    readonly coords: U;
+    readonly nearestElement: Vertex | Edge;
+    constructor(origin: U, distanceFromNearestElement: number, coords: U, nearestElement: Vertex | Edge);
+}
+export default GraphProjection;

package/dist/src/graph/GraphProjectionOptions.d.ts

@@ -0,0 +1,7 @@
+import { default as Edge } from './Edge.js';
+export type GraphProjectionOptions = {
+    maxDistance?: number;
+    maxBearingAngle?: number;
+    useMultiLevelSegments?: boolean;
+    acceptEdgeFn?: (edge: Edge) => boolean;
+};

package/dist/src/graph/GraphRoute.d.ts

@@ -0,0 +1,19 @@
+import { Coordinates } from '@wemap/geo';
+import { default as Graph } from './Graph.js';
+import { default as Edge } from './Edge.js';
+import { default as Vertex } from './Vertex.js';
+/**
+ * GraphRoute is an oriented graph
+ */
+declare class GraphRoute extends Graph {
+    start: Coordinates;
+    end: Coordinates;
+    vertices: Vertex[];
+    edges: Edge[];
+    edgesWeights: number[];
+    constructor(start: Coordinates, end: Coordinates, vertices: Vertex[], edges: Edge[], edgesWeights: number[]);
+    reverse(): GraphRoute;
+    static fromCoordinates(start: Coordinates, end: Coordinates, coordinates: Coordinates[]): GraphRoute;
+    get hasRoute(): boolean;
+}
+export default GraphRoute;

package/dist/src/graph/GraphRouter.d.ts

@@ -0,0 +1,20 @@
+import { Coordinates } from '@wemap/geo';
+import { default as Vertex } from './Vertex.js';
+import { default as GraphRoute } from './GraphRoute.js';
+import { default as GraphRouterEngine, GraphRouterEngineResults } from './GraphRouterEngine.js';
+import { GraphRouterOptions } from './GraphRouterOptions.js';
+export declare class GraphRouterResults extends GraphRouterEngineResults {
+    sourceProjection: [Coordinates, Vertex | null];
+    targetsProjections: [Coordinates, Vertex | null][];
+    constructor(engineResults: GraphRouterEngineResults, sourceProjection: [Coordinates, Vertex | null], targetsProjections: [Coordinates, Vertex | null][]);
+    static createEmpty(source: Coordinates, targets: Coordinates[]): GraphRouterResults;
+    routeVertices(to?: Coordinates | Vertex): Vertex[];
+    weightedDistance(to?: Coordinates | Vertex): number | null;
+    route(to?: Coordinates | Vertex): GraphRoute;
+}
+declare class GraphRouter extends GraphRouterEngine {
+    calculateShortestPathToMultipleDestinations(source: Coordinates, targets: Coordinates[], options?: GraphRouterOptions): GraphRouterResults;
+    calculateShortestPath(source: Coordinates, target: Coordinates, options?: GraphRouterOptions): GraphRouterResults;
+    getShortestTrip(waypoints: Coordinates[], options?: GraphRouterOptions, tspTempCoeff?: number): GraphRoute[];
+}
+export default GraphRouter;

package/dist/src/graph/GraphRouterEngine.d.ts

@@ -0,0 +1,80 @@
+import { default as Edge } from './Edge.js';
+import { default as Graph } from './Graph.js';
+import { default as GraphRoute } from './GraphRoute.js';
+import { GraphRouterOptions } from './GraphRouterOptions.js';
+import { default as Vertex } from './Vertex.js';
+export declare class GraphRouterEngineResults {
+    prev: Array<Vertex | null>;
+    dist: number[];
+    source: Vertex;
+    targets: Vertex[];
+    edges: Edge[];
+    constructor(prev: Array<Vertex | null>, dist: number[], source: Vertex, targets: Vertex[], edges: Edge[]);
+    routeVertices(to?: Vertex, list?: Vertex[]): Vertex[];
+    weightedDistance(to?: Vertex): number | null;
+    route(to?: Vertex): GraphRoute;
+    toGeoJson(graph: Graph): {
+        type: string;
+        features: ({
+            type: string;
+            properties: {
+                name?: string | undefined;
+                externalId?: string | number | undefined;
+                isGate?: boolean | undefined;
+                isSubwayEntrance?: boolean | undefined;
+                subwayEntranceRef?: string | undefined;
+                level?: number | [number, number] | undefined;
+                dist: string | number;
+                prev?: number | undefined;
+                id: number;
+            };
+            geometry: {
+                type: string;
+                coordinates: number[];
+            };
+        } | {
+            type: string;
+            properties: {
+                name?: string | undefined;
+                externalId?: string | number | undefined;
+                isOneway?: boolean | undefined;
+                areStairs?: boolean | undefined;
+                isElevator?: boolean | undefined;
+                areEscalators?: boolean | undefined;
+                isMovingWalkway?: boolean | undefined;
+                needTicket?: boolean | undefined;
+                incline?: "up" | "down" | undefined;
+                wheelchair?: import('./Edge.js').EdgeWheelchair | undefined;
+                smoothness?: import('./Edge.js').EdgeSmoothness | undefined;
+                surface?: import('./Edge.js').EdgeSurface | undefined;
+                level?: number | [number, number] | undefined;
+                id: number;
+            };
+            geometry: {
+                type: string;
+                coordinates: number[][];
+            };
+        })[];
+    };
+}
+export default class GraphRouterEngine {
+    readonly graph: Graph;
+    disabledEdges: Set<Edge>;
+    constructor(graph: Graph);
+    calculateShortestPathToMultipleDestinationsByVertex(source: Vertex, targets: Vertex[], options?: GraphRouterOptions, inputVertices?: Vertex[], inputEdges?: Edge[]): GraphRouterEngineResults;
+    calculateShortestPathByVertex(source: Vertex, target: Vertex, options?: GraphRouterOptions, inputVertices?: Vertex[], inputEdges?: Edge[]): GraphRouterEngineResults;
+    calculateComponents(): Vertex[][];
+    toGeoJson(): {
+        type: string;
+        features: {
+            type: string;
+            geometry: {
+                type: string;
+                coordinates: number[][][];
+            };
+            properties: {
+                stroke: string;
+            };
+        }[];
+    };
+}

package/{src/graph/GraphRouterOptions.ts → dist/src/graph/GraphRouterOptions.d.ts}

@@ -1,18 +1,17 @@
-import Edge from './Edge.js'
-
+import { default as Edge } from './Edge.js';
 export type GraphRouterOptions = {
     input: GraphRouterOptionsJson;
-    projectionMaxDistance?: number; // in meters
+    projectionMaxDistance?: number;
     weightEdgeFn?: (edge: Edge) => number;
     acceptEdgeFn?: (edge: Edge) => boolean;
     useMultiLevelSegments?: boolean;
-}
-
+};
 export type GraphRouterOptionsJson = {
     avoidStairs?: boolean;
     avoidEscalators?: boolean;
     avoidElevators?: boolean;
     avoidMovingWalkways?: boolean;
     avoidTicketRestrictedAreas?: boolean;
-    projectionMaxDistance?: number; // in meters
-}
+    isWheelchair?: boolean;
+    projectionMaxDistance?: number;
+};

package/dist/src/graph/GraphRouterOptionsBuilder.d.ts

@@ -0,0 +1,23 @@
+import { GraphRouterOptionsJson, GraphRouterOptions } from './GraphRouterOptions.js';
+export default class GraphRouterOptionsBuilder {
+    avoidStairs: boolean;
+    avoidEscalators: boolean;
+    avoidElevators: boolean;
+    avoidMovingWalkways: boolean;
+    avoidTicketRestrictedAreas: boolean;
+    useMultiLevelSegments: boolean;
+    projectionMaxDistance?: number;
+    isWheelchair: boolean;
+    static DEFAULT: GraphRouterOptions;
+    static WITHOUT_STAIRS: GraphRouterOptions;
+    static WHEELCHAIR: GraphRouterOptions;
+    setAvoidStairs(avoidStairs: boolean): this;
+    setAvoidEscalators(avoidEscalators: boolean): this;
+    setAvoidElevators(avoidElevators: boolean): this;
+    setAvoidMovingWalkways(avoidMovingWalkways: boolean): this;
+    setAvoidTicketRestrictedAreas(avoidTicketRestrictedAreas: boolean): this;
+    setUseMultiLevelSegments(useMultiLevelSegments: boolean): this;
+    setIsWheelchair(isWheelchair: boolean): this;
+    static fromJson(options: GraphRouterOptionsJson): GraphRouterOptions;
+    build(): GraphRouterOptions;
+}

package/dist/src/graph/GraphRouterOptionsFactors.d.ts

@@ -0,0 +1,8 @@
+import { EdgeSmoothness, EdgeSurface } from './Edge.js';
+export type ProfileType = 'wheelchair' | 'default';
+export declare const SPEEDS: {
+    readonly DEFAULT: 4;
+    readonly WHEELCHAIR: 3;
+};
+export declare const SMOOTHNESS_FACTORS: Record<ProfileType, Record<EdgeSmoothness, number>>;
+export declare const SURFACE_FACTORS: Record<ProfileType, Record<EdgeSurface, number>>;

package/dist/src/graph/NoRouteFoundError.d.ts

@@ -0,0 +1,12 @@
+import { Coordinates } from '@wemap/geo';
+import { default as Vertex } from './Vertex.js';
+declare class NoRouteFoundError extends Error {
+    start: Vertex | Coordinates;
+    end: Vertex | Coordinates | (Coordinates | Vertex)[];
+    details: string | null;
+    constructor(start: Vertex | Coordinates, end: Vertex | Coordinates | (Coordinates | Vertex)[], details?: string | null);
+    get startStr(): string;
+    get endStr(): string;
+    get message(): string;
+}
+export default NoRouteFoundError;

package/dist/src/graph/Vertex.d.ts

@@ -0,0 +1,19 @@
+import { Coordinates } from '@wemap/geo';
+import { GraphVertexJson } from '../types.js';
+export type VertexProperties = {
+    name?: string;
+    externalId?: string | number;
+    isGate?: boolean;
+    isSubwayEntrance?: boolean;
+    subwayEntranceRef?: string;
+};
+export default class Vertex {
+    coords: Coordinates;
+    properties: VertexProperties;
+    id: number;
+    constructor(coords: Coordinates, properties?: VertexProperties);
+    distanceTo(other: Vertex): number;
+    bearingTo(other: Vertex): number;
+    toJson(): GraphVertexJson;
+    static fromJson(json: GraphVertexJson): Vertex;
+}

package/dist/src/model/Itinerary.d.ts

@@ -0,0 +1,81 @@
+import { FeatureCollection } from 'geojson';
+import { Coordinates, CoordinatesJson } from '@wemap/geo';
+import { Point2_t, Vector3_t } from '@wemap/maths';
+import { default as Graph } from '../graph/Graph.js';
+import { default as Leg, LegJson } from './Leg.js';
+import { TransitMode } from './TransitMode.js';
+import { Step } from './Step.js';
+import { default as GraphRoute } from '../graph/GraphRoute.js';
+export type ItineraryCommon = {
+    startTime?: number;
+    endTime?: number;
+};
+export type ItineraryJson = {
+    transitMode: TransitMode;
+    origin: CoordinatesJson;
+    destination: CoordinatesJson;
+    distance: number;
+    duration: number;
+    legs: LegJson[];
+} & ItineraryCommon;
+export type ItineraryConstructor = {
+    origin: Coordinates;
+    destination: Coordinates;
+    duration?: number;
+    legs: Leg[];
+} & ItineraryCommon;
+/**
+ * Main attributes are:
+ * nodes: the ordered list of Node
+ * edges: the ordered list of Edge
+ * start: the start point (Coordinates)
+ * end: the end point (Coordinates)
+ * length: the route length
+ */
+export default class Itinerary {
+    origin: Coordinates;
+    destination: Coordinates;
+    duration: number;
+    readonly legs: Leg[];
+    private _transitMode;
+    startTime: number | null;
+    endTime: number | null;
+    private _coords;
+    private _distance;
+    constructor({ origin, destination, duration, legs, startTime, endTime }: ItineraryConstructor);
+    set coords(_: Coordinates[]);
+    get coords(): Coordinates[];
+    set steps(_: Step[]);
+    get steps(): Step[];
+    set transitMode(_: TransitMode);
+    get transitMode(): TransitMode;
+    set distance(_: number);
+    get distance(): number;
+    toGraph(): Graph;
+    static fromItineraries(...itineraries: Itinerary[]): Itinerary;
+    /**
+     * Convert lat/lng/level? points to Itinerary
+     */
+    static fromOrderedPointsArray(points: (Point2_t | Vector3_t)[], start: (Point2_t | Vector3_t), end: (Point2_t | Vector3_t)): Itinerary;
+    /**
+     * Convert ordered Coordinates to Itinerary
+     */
+    static fromOrderedCoordinates(coords: Coordinates[], origin: Coordinates, destination: Coordinates, transitMode?: TransitMode): Itinerary;
+    static equals(obj1: Itinerary, obj2: Itinerary): boolean;
+    equals(obj: Itinerary): boolean;
+    toJson(): ItineraryJson;
+    static fromJson(json: ItineraryJson): Itinerary;
+    static fromGraphRoute(graphRoute: GraphRoute, transitMode?: TransitMode): Itinerary;
+    multiplyLevel(levelFactor: number): void;
+    forceUnknownLevelTo0(): void;
+    toGeoJson(): FeatureCollection;
+    /**
+     * TODO: Remove it in router v3
+     * Update steps info thanks to the coordinates of the whole itinerary.
+     * This method will update:
+     * - all steps number
+     * - first/last steps
+     * - previousBearing/nextBearing/angle of first and last step of each leg
+     */
+    updateStepsFromLegs(): void;
+}

package/dist/src/model/Leg.d.ts

@@ -0,0 +1,66 @@
+import { Coordinates, CoordinatesCompressedJson } from '@wemap/geo';
+import { default as Graph } from '../graph/Graph.js';
+import { default as GraphRoute } from '../graph/GraphRoute.js';
+import { TransitMode } from './TransitMode.js';
+import { Step, StepJson } from './Step.js';
+export type Destination = {
+    name: string | null;
+    coords: Coordinates;
+};
+export type DestinationConstructor = {
+    name?: string;
+    coords: Coordinates;
+};
+export type DestinationJson = {
+    name?: string;
+    coords: CoordinatesCompressedJson;
+};
+export type TransportInfo = {
+    name: string;
+    routeColor?: string;
+    routeTextColor?: string;
+    directionName?: string;
+};
+type LegCommon = {
+    transitMode: TransitMode;
+    startTime?: number;
+    endTime?: number;
+    transportInfo?: TransportInfo;
+};
+type LegConstructor = {
+    start: DestinationConstructor;
+    end: DestinationConstructor;
+    coords: Coordinates[];
+    steps?: Step[];
+    duration?: number;
+} & LegCommon;
+export type LegJson = {
+    start: DestinationJson;
+    end: DestinationJson;
+    coords: CoordinatesCompressedJson[];
+    steps: StepJson[];
+    distance: number;
+    duration: number;
+} & LegCommon;
+export default class Leg {
+    start: Destination;
+    end: Destination;
+    coords: Coordinates[];
+    distance: number;
+    transitMode: TransitMode;
+    duration: number;
+    startTime: number | null;
+    endTime: number | null;
+    steps: Step[];
+    transportInfo: TransportInfo | null;
+    constructor({ start, end, coords, transitMode, duration, startTime, endTime, transportInfo, steps }: LegConstructor);
+    isPublicTransport(): boolean;
+    toGraph(): Graph;
+    static equals(obj1: Leg, obj2: Leg): boolean;
+    equals(obj: Leg): boolean;
+    toJson(): LegJson;
+    static fromJson(json: LegJson): Leg;
+    static fromGraphRoute(graphRoute: GraphRoute, transitMode?: TransitMode): Leg;
+    multiplyLevel(levelFactor: number): void;
+}
+export {};

package/dist/src/model/LevelChange.d.ts

@@ -0,0 +1,7 @@
+export type LevelChangeType = 'elevator' | 'escalator' | 'stairs' | 'moving walkway' | 'incline plane';
+export type LevelChange = {
+    direction: 'up' | 'down';
+    difference: number;
+    type?: LevelChangeType;
+};
+export declare function areLevelChangeEquals(l1: LevelChange, l2: LevelChange): boolean;

package/dist/src/model/RouterRequest.d.ts

@@ -0,0 +1,42 @@
+import { Coordinates } from '@wemap/geo';
+import { TravelMode, TravelModePreference } from './TravelMode';
+export type RouterRequest = {
+    origin: Coordinates;
+    destination: Coordinates;
+    travelMode: TravelMode;
+    travelModePreference?: TravelModePreference;
+    provideItineraryAlternatives?: boolean;
+    waypoints?: Coordinates[];
+    optimizeWaypoints?: boolean;
+    itineraryModifiers?: {
+        avoidStairs?: boolean;
+        avoidEscalators?: boolean;
+        avoidElevators?: boolean;
+        avoidMovingWalkways?: boolean;
+        avoidTicketRestrictedAreas?: boolean;
+        isWheelchair?: boolean;
+    };
+    output?: {
+        distanceAndDurationOnly?: boolean;
+    };
+};
+export declare function routerRequestToJson(routerRequest: RouterRequest): {
+    travelMode: TravelMode;
+    travelModePreference?: TravelModePreference | undefined;
+    provideItineraryAlternatives?: boolean | undefined;
+    optimizeWaypoints?: boolean | undefined;
+    itineraryModifiers?: {
+        avoidStairs?: boolean | undefined;
+        avoidEscalators?: boolean | undefined;
+        avoidElevators?: boolean | undefined;
+        avoidMovingWalkways?: boolean | undefined;
+        avoidTicketRestrictedAreas?: boolean | undefined;
+        isWheelchair?: boolean | undefined;
+    } | undefined;
+    output?: {
+        distanceAndDurationOnly?: boolean | undefined;
+    } | undefined;
+    waypoints?: import('@wemap/geo').CoordinatesJson[] | undefined;
+    origin: import('@wemap/geo').CoordinatesJson;
+    destination: import('@wemap/geo').CoordinatesJson;
+};

package/dist/src/model/Step.d.ts

@@ -0,0 +1,42 @@
+import { Coordinates, CoordinatesCompressedJson } from '@wemap/geo';
+import { LevelChange } from './LevelChange.js';
+import { StepExtra } from './StepExtra.js';
+export type Step = {
+    firstStep: boolean;
+    lastStep: boolean;
+    number: number;
+    angle: number;
+    previousBearing: number;
+    nextBearing: number;
+    distance: number;
+    duration: number;
+    readonly coords: Coordinates;
+    readonly name: string | null;
+    readonly levelChange: LevelChange | null;
+    readonly extras: StepExtra | null;
+};
+export type StepJson = {
+    firstStep?: boolean;
+    lastStep?: boolean;
+    number: number;
+    coords: CoordinatesCompressedJson;
+    name?: string;
+    angle: number;
+    previousBearing: number;
+    nextBearing: number;
+    distance: number;
+    duration: number;
+    levelChange?: LevelChange;
+    extras?: StepExtra;
+};
+export type MinStepInfo = {
+    coords: Coordinates;
+    name?: string;
+    levelChange?: LevelChange;
+    extras?: StepExtra;
+    distance?: number;
+    duration?: number;
+};
+export declare function stepToJson(step: Step): StepJson;
+export declare function jsonToStep(json: StepJson): Step;
+export declare function stepEquals(step1: Step, step2: Step): boolean;

package/dist/src/model/StepExtra.d.ts

@@ -0,0 +1,3 @@
+export type StepExtra = {
+    [key: string]: number | string | boolean | null;
+};

package/dist/src/model/StepsBuilder.d.ts

@@ -0,0 +1,16 @@
+import { Coordinates } from '@wemap/geo';
+import { Step, MinStepInfo } from './Step.js';
+import { default as GraphRoute } from '../graph/GraphRoute.js';
+export default class StepsBuilder {
+    private start;
+    private end;
+    private pathCoords;
+    private stepsInfo;
+    setStart(start: Coordinates): this;
+    setEnd(end: Coordinates): this;
+    setPathCoords(pathCoords: Coordinates[]): this;
+    setStepsInfo(stepsInfo: MinStepInfo[]): this;
+    addStepInfo(stepInfo: MinStepInfo): this;
+    setGraphRoute(graphRoute: GraphRoute): this;
+    build(): Step[];
+}