minotor 11.1.2 → 11.2.0

package/dist/routing/__tests__/access.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/routing/__tests__/plainRouter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/routing/__tests__/rangeResult.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/routing/__tests__/rangeRouter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/routing/__tests__/rangeState.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/routing/__tests__/raptor.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/routing/__tests__/state.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/routing/access.d.ts

@@ -0,0 +1,55 @@
+import { StopId } from '../stops/stops.js';
+import { StopsIndex } from '../stops/stopsIndex.js';
+import { Duration, Time } from '../timetable/time.js';
+import { Timetable } from '../timetable/timetable.js';
+/**
+ * An access path from the query origin to an initial boarding stop.
+ *
+ * Equivalent origin stops (reached at zero cost) have no `duration`.
+ * Stops reachable via a timed walking transfer carry a `duration` in minutes.
+ */
+export type AccessPoint = {
+    fromStopId: StopId;
+    toStopId: StopId;
+    duration: Duration;
+};
+/**
+ * Collects access paths from a query origin and resolves the set of
+ * distinct departure-time slots for Range RAPTOR.
+ */
+export declare class AccessFinder {
+    private readonly timetable;
+    private readonly stopsIndex;
+    constructor(timetable: Timetable, stopsIndex: StopsIndex);
+    /**
+     * Returns every initial access path from the query origin: equivalent stops
+     * (no duration) plus every stop reachable via a single timed walking transfer
+     * (REQUIRES_MINIMAL_TIME), keeping the shortest walk when multiple origins
+     * can reach the same stop.
+     *
+     * @param origin                  Origin stop ID.
+     * @param fallbackMinTransferTime Transfer time used when a walking transfer
+     *                                has no explicit `minTransferTime` in the timetable data.
+     */
+    collectAccessPaths(queryOrigin: StopId, fallbackMinTransferTime: Duration): AccessPoint[];
+    /**
+     * Collects all distinct origin departure times within `[from, to]`
+     * (inclusive) and, for each slot, the specific access paths that directly
+     * induce it — i.e. paths whose boarded stop has a boardable trip departing
+     * at exactly `depTime + path.duration`.
+     *
+     * Returned array is sorted **latest-first**. The Range RAPTOR outer loop
+     * seeds only the responsible paths for each slot, avoiding redundant
+     * exploration of access stops whose boarding opportunities belong to a
+     * later slot and whose journeys would therefore be dominated by it.
+     *
+  
+     * @param accessPaths Access paths from the origin to initial boarding stops.
+     * @param from        Earliest origin departure time (inclusive).
+     * @param to          Latest origin departure time (inclusive).
+     */
+    collectDepartureTimes(accessPaths: AccessPoint[], from: Time, to: Time): {
+        depTime: Time;
+        legs: AccessPoint[];
+    }[];
+}

package/dist/routing/plainRouter.d.ts

@@ -0,0 +1,21 @@
+import { StopsIndex } from '../stops/stopsIndex.js';
+import { Timetable } from '../timetable/timetable.js';
+import { AccessFinder } from './access.js';
+import { Query } from './query.js';
+import { Raptor } from './raptor.js';
+import { Result } from './result.js';
+export declare class PlainRouter {
+    private readonly timetable;
+    private readonly stopsIndex;
+    private readonly accessFinder;
+    private readonly raptor;
+    constructor(timetable: Timetable, stopsIndex: StopsIndex, accessFinder: AccessFinder, raptor: Raptor);
+    /**
+     * Standard RAPTOR: finds the earliest-arrival journey from `query.from` to
+     * `query.to` for the given departure time.
+     *
+     * @param query The routing query.
+     * @returns A {@link Result} that can reconstruct the best route and arrival times.
+     */
+    route(query: Query): Result;
+}

package/dist/routing/plotter.d.ts

@@ -30,6 +30,10 @@ export declare class Plotter {
      * Generates a unique node ID for a transfer edge oval.
      */
     private transferEdgeNodeId;
+    /**
+     * Generates a unique node ID for a walking access edge oval.
+     */
+    private accessEdgeNodeId;
     /**
      * Generates a unique node ID for a continuation edge oval.
      */
@@ -70,6 +74,11 @@ export declare class Plotter {
      * Creates a vehicle edge with route information oval in the middle.
      */
     private createVehicleEdge;
+    /**
+     * Creates a walking access leg as a dashed oval connecting the query origin
+     * to the initial boarding stop.
+     */
+    private createAccessEdge;
     /**
      * Creates a transfer edge with transfer information oval in the middle.
      */

package/dist/routing/query.d.ts

@@ -5,12 +5,27 @@ export type QueryOptions = {
     maxTransfers: number;
     minTransferTime: Duration;
     transportModes: Set<RouteType>;
+    /**
+     * Maximum time (in minutes) the traveler is willing to wait at the first
+     * boarding stop before the first transit vehicle departs.
+     *
+     * When set, any trip that would require waiting longer than this duration
+     * after arriving at the stop is skipped for the first boarding leg.
+     * Undefined means no limit.
+     */
+    maxInitialWaitingTime?: Duration;
 };
+/**
+ * A routing query for standard RAPTOR.
+ *
+ * Finds the earliest-arrival journey from `from` to `to` for a single
+ * departure time.  Use {@link RangeQuery} (and `router.rangeRoute()`) when
+ * you want all Pareto-optimal journeys within a departure-time window.
+ */
 export declare class Query {
     from: StopId;
     to: Set<StopId>;
     departureTime: Time;
-    lastDepartureTime?: Time;
     options: QueryOptions;
     constructor(builder: typeof Query.Builder.prototype);
     static Builder: {
@@ -18,23 +33,19 @@ export declare class Query {
             fromValue: StopId;
             toValue: Set<StopId>;
             departureTimeValue: Time;
-            optionsValue: {
-                maxTransfers: number;
-                minTransferTime: Duration;
-                transportModes: Set<RouteType>;
-            };
+            optionsValue: QueryOptions;
             /**
              * Sets the starting stop.
              */
             from(from: StopId): /*elided*/ any;
             /**
-             * Sets the destination stops(s), routing will stop when all the provided stops are reached.
+             * Sets the destination stop(s).
+             * Routing stops as soon as all provided stops have been reached.
              */
             to(to: StopId | Set<StopId>): /*elided*/ any;
             /**
-             * Sets the departure time for the query as minutes since midnight.
-             * Note that the router will favor routes that depart shortly after the provided departure time,
-             * even if a later route might arrive at the same time.
+             * Sets the departure time in minutes from midnight.
+             * The router favours trips departing shortly after this time.
              */
             departureTime(departureTime: Time): /*elided*/ any;
             /**
@@ -42,15 +53,123 @@ export declare class Query {
              */
             maxTransfers(maxTransfers: number): /*elided*/ any;
             /**
-             * Sets the minimum transfer time (in minutes)
-             * to use when no transfer time is provided in the data.
+             * Sets the fallback minimum transfer time (in minutes) used when the
+             * timetable data does not specify one for a particular transfer.
              */
             minTransferTime(minTransferTime: Duration): /*elided*/ any;
             /**
-             * Sets the transport modes to consider.
+             * Restricts routing to the given transport modes.
              */
             transportModes(transportModes: Set<RouteType>): /*elided*/ any;
+            /**
+             * Sets the maximum time (in minutes) the traveler is willing to wait at
+             * the first boarding stop before the first transit vehicle departs.
+             *
+             * When set, any trip that would require waiting longer than this duration
+             * after arriving at the stop is not considered for the first boarding leg.
+             */
+            maxInitialWaitingTime(maxInitialWaitingTime: Duration): /*elided*/ any;
             build(): Query;
         };
     };
 }
+/**
+ * Options specific to a {@link RangeQuery}.
+ */
+export type RangeQueryOptions = {
+    /**
+     * When `true`, a full RAPTOR pass is run at `lastDepartureTime + 1` before
+     * the main departure-time loop (the *boundary run*).
+     *
+     * The boundary run seeds the shared Pareto labels with the best arrival
+     * achievable by departing just after the window closes.  Any in-window
+     * journey whose arrival is no better than what that post-window departure
+     * achieves is therefore suppressed — you only see journeys that are still
+     * worth taking given that a later departure exists.
+     *
+     * **Timetable use-case** (`boundaryRun: true`): the window is a *display
+     * filter*.  A journey at 10:55 that arrives at 12:30 is hidden when an
+     * 11:05 departure arrives at 12:00 — the router pre-empts the dominated
+     * option on the caller's behalf.
+     *
+     * **Isochrone / accessibility use-case** (`boundaryRun: false`, the
+     * default): the window is a hard constraint.  Every Pareto-optimal journey
+     * whose departure falls strictly within `[departureTime, lastDepartureTime]`
+     * is returned, regardless of what might be available just outside the
+     * window.
+     *
+     * @default false
+     */
+    optimizeBeyondLatestDeparture: boolean;
+};
+/**
+ * A routing query for Range RAPTOR.
+ *
+ * Extends {@link Query} with a required `lastDepartureTime` that defines the
+ * upper bound of the departure-time window.  `router.rangeRoute()` returns
+ * all Pareto-optimal journeys departing in
+ * `[departureTime, lastDepartureTime]`.
+ *
+ */
+export declare class RangeQuery extends Query {
+    /** Upper bound of the departure-time window (minutes from midnight). */
+    readonly lastDepartureTime: Time;
+    /** Options specific to Range RAPTOR behavior. */
+    readonly rangeOptions: RangeQueryOptions;
+    constructor(builder: typeof RangeQuery.Builder.prototype);
+    static Builder: {
+        new (): {
+            lastDepartureTimeValue: Time;
+            rangeOptionsValue: RangeQueryOptions;
+            /**
+             * Sets the upper bound of the departure-time window.
+             */
+            lastDepartureTime(time: Time): /*elided*/ any;
+            /**
+             * Overrides individual Range RAPTOR options.
+             * Unspecified fields keep their defaults.
+             */
+            rangeOptions(options: Partial<RangeQueryOptions>): /*elided*/ any;
+            build(): RangeQuery;
+            fromValue: StopId;
+            toValue: Set<StopId>;
+            departureTimeValue: Time;
+            optionsValue: QueryOptions;
+            /**
+             * Sets the starting stop.
+             */
+            from(from: StopId): /*elided*/ any;
+            /**
+             * Sets the destination stop(s).
+             * Routing stops as soon as all provided stops have been reached.
+             */
+            to(to: StopId | Set<StopId>): /*elided*/ any;
+            /**
+             * Sets the departure time in minutes from midnight.
+             * The router favours trips departing shortly after this time.
+             */
+            departureTime(departureTime: Time): /*elided*/ any;
+            /**
+             * Sets the maximum number of transfers allowed.
+             */
+            maxTransfers(maxTransfers: number): /*elided*/ any;
+            /**
+             * Sets the fallback minimum transfer time (in minutes) used when the
+             * timetable data does not specify one for a particular transfer.
+             */
+            minTransferTime(minTransferTime: Duration): /*elided*/ any;
+            /**
+             * Restricts routing to the given transport modes.
+             */
+            transportModes(transportModes: Set<RouteType>): /*elided*/ any;
+            /**
+             * Sets the maximum time (in minutes) the traveler is willing to wait at
+             * the first boarding stop before the first transit vehicle departs.
+             *
+             * When set, any trip that would require waiting longer than this duration
+             * after arriving at the stop is not considered for the first boarding leg.
+             */
+            maxInitialWaitingTime(maxInitialWaitingTime: Duration): /*elided*/ any;
+        };
+    };
+}

package/dist/routing/rangeResult.d.ts

@@ -0,0 +1,155 @@
+import { StopId } from '../stops/stops.js';
+import { Duration, Time } from '../timetable/time.js';
+import { Result } from './result.js';
+import { Route } from './route.js';
+import { Arrival } from './state.js';
+/**
+ * A single departure-time iteration that produced at least one Pareto-optimal
+ * journey to this result's destination set.
+ */
+export type ParetoRun = {
+    /** Departure time from the origin (minutes from midnight) for this run. */
+    readonly departureTime: Time;
+    /** Full RAPTOR result for this departure time — use it to reconstruct routes. */
+    readonly result: Result;
+};
+/**
+ * An {@link Arrival} enriched with the travel duration from the origin.
+ *
+ * Returned by duration-based methods on {@link RangeResult} so callers
+ * receive both the absolute arrival time with transfer count *and* the total
+ * travel time that was optimized over.
+ */
+export type ArrivalWithDuration = Arrival & {
+    /** Total travel time from origin departure to stop arrival (minutes). */
+    readonly duration: Duration;
+};
+/**
+ * The result of a Range RAPTOR query.
+ *
+ * Contains the complete Pareto-optimal set of journeys for a resolved
+ * destination set.
+ *
+ * **Pareto dominance**: journey J1 dominates J2 iff
+ *   `τdep(J1) ≥ τdep(J2)  AND  τarr(J1) ≤ τarr(J2)`
+ * (with at least one strict inequality).
+ *
+ * Runs are ordered **latest-departure-first**: each successive run departs
+ * strictly earlier *and* arrives strictly earlier than the previous one,
+ * forming the classic staircase Pareto frontier.
+ *
+ * Destination handling is delegated to {@link Result}, which expands
+ * equivalent stops when reconstructing routes or looking up arrivals.
+ */
+export declare class RangeResult {
+    private readonly _runs;
+    private readonly _destinations;
+    constructor(runs: ParetoRun[], destinations: ReadonlySet<StopId>);
+    /** The resolved destination stop IDs for this result. */
+    get destinations(): ReadonlySet<StopId>;
+    private normalizeTargets;
+    /**
+     * Returns all non-dominated routes to this result's default destination set,
+     * ordered from the earliest departure to the latest departure.
+     *
+     * Each route in the list departs strictly earlier *and* arrives strictly
+     * earlier than its predecessor.
+     */
+    getRoutes(): Route[];
+    /**
+     * The route that arrives **earliest** at the given stop(s) across all
+     * Pareto-optimal runs.
+     *
+     * When two runs achieve the same arrival time at the target, the one with
+     * the **later departure** is preferred — you wait at the origin rather than
+     * at a transit stop.
+     *
+     * Defaults to this result's own destination stop(s) when `to` is omitted.
+     *
+     * @param to Optional destination stop ID or set of stop IDs.
+     * @returns The reconstructed {@link Route} with the earliest arrival,
+     *          or `undefined` if the target is unreachable in every run.
+     */
+    bestRoute(to?: StopId | Set<StopId>): Route | undefined;
+    /**
+     * The route with the **latest possible departure** from the origin among all
+     * Pareto-optimal journeys in the window.
+     *
+     * This is the journey that lets you leave the origin as late as possible.
+     * It does **not** necessarily achieve the earliest arrival — for that, use
+     * {@link bestRoute}. For the shortest travel duration, use
+     * {@link fastestRoute}.
+     *
+     * Defaults to this result's own destination stop(s) when `to` is omitted.
+     *
+     * @param to Optional destination stop ID or set of stop IDs.
+     * @returns The reconstructed {@link Route} with the latest departure,
+     *          or `undefined` if the target is unreachable in every run.
+     */
+    latestDepartureRoute(to?: StopId | Set<StopId>): Route | undefined;
+    /**
+     * Reconstructs the **fastest** route to the given stop(s) — the journey with
+     * the shortest travel duration (arrival time − origin departure time) across
+     * all Pareto-optimal runs.
+     *
+     * Unlike {@link bestRoute}, which returns the route that departs as late as
+     * possible while still arriving early, this method minimizes total time
+     * spent traveling.
+     *
+     * Defaults to this result's own destination stop(s) when `to` is omitted.
+     *
+     * @param to Optional destination stop ID or set of stop IDs.
+     * @returns The reconstructed fastest {@link Route}, or `undefined` if the
+     *          target is unreachable in every run.
+     */
+    fastestRoute(to?: StopId | Set<StopId>): Route | undefined;
+    /** Number of Pareto-optimal journeys found. */
+    get size(): number;
+    /**
+     * Earliest achievable arrival at a stop across all Pareto-optimal runs.
+     *
+     * Useful for isochrone / accessibility analysis: given this result's
+     * departure-time frontier, how early can you reach stop `s` regardless of
+     * which specific trip you take?
+     *
+     * Equivalent stops are handled by {@link Result.arrivalAt}.
+     *
+     * @param stop         The target stop ID.
+     * @param maxTransfers Optional upper bound on the number of transfers.
+     */
+    earliestArrivalAt(stop: StopId, maxTransfers?: number): Arrival | undefined;
+    /**
+     * Shortest travel duration to reach a stop across all Pareto-optimal runs.
+     *
+     * For each run, duration is measured from the run's origin departure time to
+     * the earliest arrival at `stop` within that run. The minimum across all
+     * runs is returned.
+     *
+     * Equivalent stops are handled by {@link Result.arrivalAt}.
+     *
+     * Duration is **not** monotone along the Pareto frontier — a run that
+     * departs later may still travel faster — so every run is checked. In
+     * practice the Pareto frontier is small, so this is O(runs).
+     *
+     * Returns `undefined` if `stop` is unreachable in every run.
+     *
+     * @param stop         The target stop ID.
+     * @param maxTransfers Optional upper bound on the number of transfers.
+     */
+    shortestDurationTo(stop: StopId, maxTransfers?: number): ArrivalWithDuration | undefined;
+    /**
+     * Shortest travel duration to **every reachable stop** across all
+     * Pareto-optimal runs, as a single `Map<StopId, DurationArrival>`.
+     */
+    allShortestDurations(): Map<StopId, ArrivalWithDuration>;
+    /**
+     * Earliest achievable arrival at **every reachable stop** across all
+     * Pareto-optimal runs, as a single `Map<StopId, Arrival>`.
+     */
+    allEarliestArrivals(): Map<StopId, Arrival>;
+    /**
+     * Iterates over all Pareto-optimal `(departureTime, result)` pairs,
+     * ordered from the latest departure to the earliest departure.
+     */
+    [Symbol.iterator](): IterableIterator<ParetoRun>;
+}

package/dist/routing/rangeRouter.d.ts

@@ -0,0 +1,24 @@
+import { StopsIndex } from '../stops/stopsIndex.js';
+import { Timetable } from '../timetable/timetable.js';
+import { AccessFinder } from './access.js';
+import { RangeQuery } from './query.js';
+import { RangeResult } from './rangeResult.js';
+import { Raptor } from './raptor.js';
+export declare class RangeRouter {
+    private readonly timetable;
+    private readonly stopsIndex;
+    private readonly accessFinder;
+    private readonly raptor;
+    constructor(timetable: Timetable, stopsIndex: StopsIndex, accessFinder: AccessFinder, raptor: Raptor);
+    /**
+     * Range RAPTOR: finds all Pareto-optimal journeys within the departure-time
+     * window `[query.departureTime, query.lastDepartureTime]`.
+     *
+     * A journey is Pareto-optimal iff no journey departing no earlier arrives no
+     * later. Runs are ordered latest-departure-first in the returned result.
+     *
+     * @param query A {@link RangeQuery} with both `departureTime` and `lastDepartureTime` set.
+     * @returns A {@link RangeResult} exposing the full Pareto frontier.
+     */
+    rangeRoute(query: RangeQuery): RangeResult;
+}

package/dist/routing/rangeState.d.ts

@@ -0,0 +1,83 @@
+import { StopId } from '../stops/stops.js';
+import { Time } from '../timetable/time.js';
+import type { IRaptorState } from './raptor.js';
+import { RoutingEdge, RoutingState } from './state.js';
+/**
+ * RAPTOR state for Range RAPTOR mode, implementing {@link IRaptorState}.
+ *
+ * Holds both the cross-run shared labels (carried over from one departure-time
+ * iteration to the next, latest → earliest) and a reference to the current
+ * per-iteration {@link RoutingState} (swapped via {@link setCurrentRun}).
+ *
+ * Concretely, `roundLabels[k][p]` is the best known arrival at stop `p` using
+ * at most `k` transit legs, across **all departure times tried so far**.
+ *
+ * @see https://www.microsoft.com/en-us/research/wp-content/uploads/2012/01/raptor_alenex.pdf
+ */
+export declare class RangeRaptorState implements IRaptorState {
+    /**
+     * `roundLabels[k]` is a flat `Uint16Array` of size `nbStops`.
+     * `roundLabels[k][p]` = best arrival time (minutes from midnight) at stop `p`
+     * in round `k`, across all departure-time iterations processed so far.
+     * Pre-filled with `UNREACHED_TIME`; updated in-place as better arrivals are found.
+     */
+    readonly roundLabels: Uint16Array[];
+    /**
+     * The latest departure time of the range query.
+     */
+    readonly latestDeparture: Time;
+    /**
+     * Global best arrival at any destination stop across all runs and rounds.
+     * Used for destination-pruning inside scan methods so that routes that cannot
+     * beat the already-known best are skipped early.
+     */
+    private _destinationBest;
+    /**
+     * Sparse change-tracking for `initRound`.
+     *
+     * `changedInRound[k]` is the list of stops whose round-k label was improved
+     * (via `tryImprove`) since the last call to `initRound(k + 1)`.  When
+     * `initRound(k + 1)` runs, it only visits these stops instead of scanning
+     * all `nbStops` entries, reducing the work from O(nbStops × rounds ×
+     * departureTimes) to O(changedStops × rounds × departureTimes).
+     *
+     * Duplicates are allowed and harmless — a stop that appears twice merely
+     * receives a redundant (no-op) min-update on the second visit.  The list is
+     * cleared inside `initRound` immediately after processing.
+     */
+    private readonly changedInRound;
+    private currentRun;
+    constructor(maxRounds: number, nbStops: number, latestDeparture: Time);
+    /**
+     * Swaps in a fresh {@link RoutingState} for the next departure-time iteration
+     * and seeds the shared round-0 labels from its access arrivals.
+     *
+     * Must be called before every `runRaptor` invocation.
+     */
+    setCurrentRun(routingState: RoutingState): void;
+    get origins(): StopId[];
+    get graph(): (RoutingEdge | undefined)[][];
+    arrivalTime(stop: StopId): Time;
+    /**
+     * Uses the cross-run shared label for `round`, which is always at least as
+     * tight as the per-run arrival and therefore provides stronger pruning.
+     */
+    improvementBound(round: number, stop: StopId): Time;
+    /**
+     * Global best arrival at any destination across all departure-time iterations.
+     * Always at least as tight as the per-run `destinationBest`.
+     */
+    get destinationBest(): Time;
+    isDestination(stop: StopId): boolean;
+    /** Updates both the per-run state and the cross-run shared labels. */
+    updateArrival(stop: StopId, time: Time, round: number): void;
+    /**
+     * initialized round `k` from round `k-1`: τk(p) ← min(τk(p), τk-1(p)).
+     *
+     * Must be called at the very start of each RAPTOR round before routes are
+     * scanned.  After this call, `roundLabels[k][p]` is the minimum arrival at
+     * stop `p` achievable with **at most** k transit legs from any departure time
+     * tried so far — which is exactly the tightest valid pruning bound for round k.
+     */
+    initRound(round: number): void;
+}

package/dist/routing/raptor.d.ts

@@ -0,0 +1,96 @@
+import { StopId } from '../stops/stops.js';
+import { Time } from '../timetable/time.js';
+import { Timetable } from '../timetable/timetable.js';
+import { QueryOptions } from './query.js';
+import { RoutingEdge } from './state.js';
+/**
+ * Common interface for all variants of RAPTOR routing.
+ */
+export interface IRaptorState {
+    /** Origin stop IDs for this run. */
+    readonly origins: StopId[];
+    /** Per-round routing graph; `graph[round][stop]` is the best edge used to reach `stop`. */
+    readonly graph: (RoutingEdge | undefined)[][];
+    /** Per-run earliest arrival at a stop. Used for boarding decisions. */
+    arrivalTime(stop: StopId): Time;
+    /**
+     * Tightest known upper bound on the arrival time at `stop` in `round`.
+     */
+    improvementBound(round: number, stop: StopId): Time;
+    /**
+     * Best known arrival time at any destination.
+     */
+    readonly destinationBest: Time;
+    /** Returns `true` if `stop` is one of the query's destination stops. */
+    isDestination(stop: StopId): boolean;
+    /**
+     * Records a new arrival at `stop`, updating all relevant state.
+     *
+     * In Range RAPTOR mode this also updates the cross-run shared labels.
+     */
+    updateArrival(stop: StopId, time: Time, round: number): void;
+    /**
+     * Propagates labels from round `k-1` into round `k` before routes are scanned.
+     * No-op in standard RAPTOR mode.
+     */
+    initRound(round: number): void;
+}
+/**
+ * Encapsulates the core RAPTOR algorithm, operating on a {@link Timetable} and
+ * an {@link IRaptorState} provided by the caller.
+ *
+ * @see https://www.microsoft.com/en-us/research/wp-content/uploads/2012/01/raptor_alenex.pdf
+ */
+export declare class Raptor {
+    private readonly timetable;
+    constructor(timetable: Timetable);
+    run(options: QueryOptions, state: IRaptorState): void;
+    /**
+     * Finds trip continuations for the given marked stops and edges at the current round.
+     * @param markedStops The set of marked stops.
+     * @param edgesAtCurrentRound The array of edges at the current round, indexed by stop ID.
+     * @returns An array of trip continuations.
+     */
+    private findTripContinuations;
+    /**
+     * Scans a route for an in-seat trip continuation.
+     *
+     * The boarded trip and entry stop are fixed, so there is no need to probe for
+     * earlier boardings.
+     *
+     * @param route The route to scan
+     * @param hopOnStopIndex The stop index where the continuation begins
+     * @param round The current RAPTOR round
+     * @param routingState Current routing state
+     * @param tripContinuation The in-seat continuation descriptor
+     * @param shared Optional shared state for Range RAPTOR mode
+     */
+    private scanRouteContinuation;
+    /**
+     * Scans a route using the standard RAPTOR boarding logic.
+     *
+     * Iterates through all stops from the hop-on point, maintaining the current
+     * best trip and improving arrival times when possible. At each marked stop it
+     * also checks whether an earlier (or first) trip can be boarded, upgrading the
+     * active trip when one is found.
+     *
+     * @param route The route to scan
+     * @param hopOnStopIndex The stop index where passengers can first board
+     * @param round The current RAPTOR round
+     * @param state Current routing state
+     * @param options Query options (minTransferTime, etc.)
+     */
+    private scanRoute;
+    /**
+     * Processes all currently marked stops to find available transfers
+     * and determines if using these transfers would result in earlier arrival times
+     * at destination stops. It handles different transfer types including in-seat
+     * transfers and walking transfers with appropriate minimum transfer times.
+     *
+     * @param options  Query options (minTransferTime, etc.)
+     * @param round The current round number in the RAPTOR algorithm
+     * @param markedStops The set of currently marked stops
+     * @param state Current routing state
+     */
+    private considerTransfers;
+}