minotor 1.0.0

package/dist/gtfs/__tests__/parser.test.d.ts

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

package/dist/gtfs/__tests__/routes.test.d.ts

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

package/dist/gtfs/__tests__/services.test.d.ts

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

package/dist/gtfs/__tests__/stops.test.d.ts

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

package/dist/gtfs/__tests__/time.test.d.ts

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

package/dist/gtfs/__tests__/transfers.test.d.ts

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

package/dist/gtfs/__tests__/trips.test.d.ts

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

package/dist/gtfs/__tests__/utils.test.d.ts

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

package/dist/gtfs/parser.d.ts

@@ -0,0 +1,34 @@
+import { Platform } from '../stops/stops.js';
+import { StopsIndex } from '../stops/stopsIndex.js';
+import { RouteType, Timetable } from '../timetable/timetable.js';
+import { StopEntry } from './stops.js';
+import { Maybe } from './utils.js';
+export type GtfsProfile = {
+    routeTypeParser: (routeType: number) => Maybe<RouteType>;
+    platformParser?: (stopEntry: StopEntry) => Maybe<Platform>;
+};
+export declare class GtfsParser {
+    private path;
+    private profile;
+    constructor(path: string, profile?: GtfsProfile);
+    /**
+     * Parses a GTFS feed to extract all the data relevant to a given day in a transit-planner friendly format.
+     *
+     * @param date The active date.
+     * @param gtfsPath A path to the zipped GTFS feed.
+     * @param gtfsProfile The GTFS profile configuration.
+     * @returns An object containing the timetable and stops map.
+     */
+    parse(date: Date): Promise<{
+        timetable: Timetable;
+        stopsIndex: StopsIndex;
+    }>;
+    /**
+     * Parses a GTFS feed to extract all stops.
+     *
+     * @param gtfsPath A path the zipped GTFS feed.
+     * @param gtfsProfile The GTFS profile configuration.
+     * @returns An object containing the timetable and stops map.
+     */
+    parseStops(): Promise<StopsIndex>;
+}

package/dist/gtfs/profiles/__tests__/ch.test.d.ts

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

package/dist/gtfs/profiles/ch.d.ts

@@ -0,0 +1,2 @@
+import { GtfsProfile } from '../parser.js';
+export declare const chGtfsProfile: GtfsProfile;

package/dist/gtfs/profiles/standard.d.ts

@@ -0,0 +1,2 @@
+import { GtfsProfile } from '../parser.js';
+export declare const standardProfile: GtfsProfile;

package/dist/gtfs/routes.d.ts

@@ -0,0 +1,11 @@
+import { ServiceRoutesMap } from '../timetable/timetable.js';
+import { GtfsProfile } from './parser.js';
+export type GtfsRouteType = number;
+/**
+ * Parses a GTFS routes.txt file and returns a map of all the valid routes.
+ *
+ * @param routesStream A readable stream for the GTFS routes.txt file.
+ * @param profile A configuration object defining the specificities of the GTFS feed.
+ * @returns A map of all the valid routes.
+ */
+export declare const parseRoutes: (routesStream: NodeJS.ReadableStream, profile?: GtfsProfile) => Promise<ServiceRoutesMap>;

package/dist/gtfs/services.d.ts

@@ -0,0 +1,19 @@
+import { DateTime } from 'luxon';
+export type ServiceId = string;
+export type ServiceIds = Set<ServiceId>;
+/**
+ * Parses a GTFS calendar.txt file and finds the service_ids of a given date.
+ *
+ * @param serviceIds A map of the active service ids (will be populated with active service_ids).
+ * @param date The active date.
+ * @param calendarStream A readable stream for the GTFS calendar.txt file.
+ */
+export declare const parseCalendar: (calendarStream: NodeJS.ReadableStream, serviceIds: ServiceIds, date: DateTime) => Promise<void>;
+/**
+ * Parses a gtfs calendar_dates.txt file and finds the service ids valid at a given date.
+ *
+ * @param serviceIds A map of the active service ids (will be populated and filtered).
+ * @param date The active date, in the format "YYYYMMDD".
+ * @param calendarDatesStream A readable stream for the GTFS calendar_dates.txt file.
+ */
+export declare const parseCalendarDates: (calendarDatesStream: NodeJS.ReadableStream, serviceIds: ServiceIds, date: DateTime) => Promise<void>;

package/dist/gtfs/stops.d.ts

@@ -0,0 +1,20 @@
+import { Latitude, Longitude, Platform, StopId, StopsMap } from '../stops/stops.js';
+import { Maybe } from './utils.js';
+export type StopIds = Set<StopId>;
+export type GtfsLocationType = 0 | 1 | 2 | 3 | 4;
+export type StopEntry = {
+    stop_id: StopId;
+    stop_name: string;
+    stop_lat?: Latitude;
+    stop_lon?: Longitude;
+    location_type?: GtfsLocationType;
+    parent_station?: StopId;
+    platform_code?: Platform;
+};
+/**
+ * Parses the stops.txt file from a GTFS feed.
+ *
+ * @param stopsStream The readable stream containing the stops data.
+ * @return A mapping of stop IDs to corresponding stop details.
+ */
+export declare const parseStops: (stopsStream: NodeJS.ReadableStream, platformParser?: (stopEntry: StopEntry) => Maybe<Platform>, validStops?: StopIds) => Promise<StopsMap>;

package/dist/gtfs/time.d.ts

@@ -0,0 +1,17 @@
+import { DateTime } from 'luxon';
+import { Time } from '../timetable/time.js';
+export type GtfsDate = number;
+export type GtfsTime = string;
+export declare const toGtfsDate: (date: DateTime) => GtfsDate;
+/**
+ * Converts a time string in the format 'HH:mm:ss' to a Time object
+ * (number of seconds since midnight).
+ *
+ * This method splits the input time string into hours, minutes, and seconds,
+ * and then calculates the total number of seconds.
+ *
+ * @param time - A string representing the time in 'HH:mm:ss' format.
+ * @returns The GTFS time as the number of seconds since midnight.
+ * @throws An error if the input time string is not in the correct format.
+ */
+export declare const toTime: (time: GtfsTime) => Time;

package/dist/gtfs/transfers.d.ts

@@ -0,0 +1,22 @@
+import { StopId } from '../stops/stops.js';
+import { ServiceRouteId, Transfer } from '../timetable/timetable.js';
+import { TripId } from './trips.js';
+export type GtfsTransferType = 0 | 1 | 2 | 3 | 4 | 5;
+export type TransfersMap = Map<StopId, Transfer[]>;
+export type TransferEntry = {
+    from_stop_id?: StopId;
+    to_stop_id?: StopId;
+    from_trip_id?: TripId;
+    to_trip_id?: TripId;
+    from_route_id?: ServiceRouteId;
+    to_route_id?: ServiceRouteId;
+    transfer_type: GtfsTransferType;
+    min_transfer_time?: number;
+};
+/**
+ * Parses the transfers.txt file from a GTFS feed.
+ *
+ * @param stopsStream The readable stream containing the stops data.
+ * @return A mapping of stop IDs to corresponding stop details.
+ */
+export declare const parseTransfers: (transfersStream: NodeJS.ReadableStream) => Promise<TransfersMap>;

package/dist/gtfs/trips.d.ts

@@ -0,0 +1,26 @@
+import { RoutesAdjacency, ServiceRouteId, ServiceRoutesMap, StopsAdjacency } from '../timetable/timetable.js';
+import { ServiceIds } from './services.js';
+import { StopIds } from './stops.js';
+import { TransfersMap } from './transfers.js';
+export type TripId = string;
+export type TripIdsMap = Map<TripId, ServiceRouteId>;
+export type GtfsPickupDropOffType = '' | 0 | 1 | 2 | 3;
+/**
+ * Parses the trips.txt file from a GTFS feed
+ *
+ * @param tripsStream The readable stream containing the trips data.
+ * @param serviceIds A mapping of service IDs to corresponding route IDs.
+ * @param routeIds A mapping of route IDs to route details.
+ * @returns A mapping of trip IDs to corresponding route IDs.
+ */
+export declare const parseTrips: (tripsStream: NodeJS.ReadableStream, serviceIds: ServiceIds, routeIds: ServiceRoutesMap) => Promise<TripIdsMap>;
+export declare const buildStopsAdjacencyStructure: (validStops: StopIds, routes: RoutesAdjacency, transfersMap: TransfersMap) => StopsAdjacency;
+/**
+ * Parses the stop_times.txt data from a GTFS feed.
+ *
+ * @param stopTimesStream The readable stream containing the stop times data.
+ * @param validTripIds A map of valid trip IDs to corresponding route IDs.
+ * @param validStopIds A map of valid stop IDs.
+ * @returns A mapping of route IDs to route details. The routes return corresponds to the set of trips from GTFS that share the same stop list.
+ */
+export declare const parseStopTimes: (stopTimesStream: NodeJS.ReadableStream, validTripIds: TripIdsMap, validStopIds: StopIds) => Promise<RoutesAdjacency>;

package/dist/gtfs/utils.d.ts

@@ -0,0 +1,21 @@
+import { Parser } from 'csv-parse';
+export type Maybe<T> = T | undefined;
+/**
+ * Generates a simple hash from a string.
+ *
+ * This function computes a hash for a given string by iterating over each
+ * character and applying bitwise operations to accumulate a hash value.
+ * The final hash is then converted to a base-36 string and padded to
+ * ensure a minimum length of 6 characters.
+ *
+ * @param str - The input string to hash.
+ * @returns A hashed string representation of the input.
+ */
+export declare const hash: (str: string) => string;
+/**
+ * Parses a CSV stream with a sensible configuration for GTFS feeds.
+ *
+ * @param stream The CSV stream.
+ * @returns A parser from the csv-parse library.
+ */
+export declare const parseCsv: (stream: NodeJS.ReadableStream) => Parser;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { GtfsParser, GtfsProfile } from './gtfs/parser.js';
+import { chGtfsProfile } from './gtfs/profiles/ch.js';
+import { Plotter } from './routing/plotter.js';
+import { Query } from './routing/query.js';
+import { Result } from './routing/result.js';
+import { Route } from './routing/route.js';
+import { Router } from './routing/router.js';
+import { StopsIndex } from './stops/stopsIndex.js';
+import { Time } from './timetable/time.js';
+import { Timetable } from './timetable/timetable.js';
+export { chGtfsProfile, GtfsParser, GtfsProfile, Plotter, Query, Result, Route, Router, StopsIndex, Time, Timetable, };

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

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

package/dist/routing/plotter.d.ts

@@ -0,0 +1,11 @@
+import { Result } from './result.js';
+export declare class Plotter {
+    private result;
+    constructor(result: Result);
+    /**
+     * Plots the path three as a DOT for debugging purposes.
+     *
+     * @returns A string representing the DOT graph of the path tree.
+     */
+    plotDotGraph(): string;
+}

package/dist/routing/query.d.ts

@@ -0,0 +1,35 @@
+import { StopId } from '../stops/stops.js';
+import { Duration } from '../timetable/duration.js';
+import { Time } from '../timetable/time.js';
+import { RouteType } from '../timetable/timetable.js';
+export declare class Query {
+    from: StopId;
+    to: StopId[];
+    departureTime: Time;
+    lastDepartureTime?: Time;
+    options: {
+        maxTransfers: number;
+        minTransferTime: Duration;
+        transportModes: RouteType[];
+    };
+    constructor(builder: typeof Query.Builder.prototype);
+    static Builder: {
+        new (): {
+            fromValue: StopId;
+            toValue: StopId[];
+            departureTimeValue: Time;
+            optionsValue: {
+                maxTransfers: number;
+                minTransferTime: Duration;
+                transportModes: RouteType[];
+            };
+            from(from: StopId): /*elided*/ any;
+            to(to: StopId | StopId[]): /*elided*/ any;
+            departureTime(departureTime: Time): /*elided*/ any;
+            maxTransfers(maxTransfers: number): /*elided*/ any;
+            minTransferTime(minTransferTime: Duration): /*elided*/ any;
+            transportModes(transportModes: RouteType[]): /*elided*/ any;
+            build(): Query;
+        };
+    };
+}

package/dist/routing/result.d.ts

@@ -0,0 +1,28 @@
+import { StopId } from '../stops/stops.js';
+import { StopsIndex } from '../umdIndex.js';
+import { Query } from './query.js';
+import { Route } from './route.js';
+import { ReachingTime, TripLeg } from './router.js';
+export declare class Result {
+    private readonly query;
+    private readonly earliestArrivals;
+    readonly earliestArrivalsPerRound: Map<StopId, TripLeg>[];
+    private readonly stopsIndex;
+    constructor(query: Query, earliestArrivals: Map<StopId, ReachingTime>, earliestArrivalsPerRound: Map<StopId, TripLeg>[], stopsIndex: StopsIndex);
+    /**
+     * Reconstructs the best route to a stop.
+     * (to any stop reachable in less time / transfers than the destination(s) of the query)
+     *
+     * @param to The destination stop. Defaults to the destination of the original query.
+     * @returns a route to the destination stop if it exists.
+     */
+    bestRoute(to?: StopId | StopId[]): Route | undefined;
+    /**
+     * Returns the arrival time at any stop reachable in less time / transfers than the destination(s) of the query)
+     *
+     * @param stop The target stop for which to return the arrival time.
+     * @param maxTransfers The optional maximum number of transfers allowed.
+     * @returns The arrival time if the target stop is reachable, otherwise undefined.
+     */
+    arrivalAt(stop: StopId, maxTransfers?: number): ReachingTime | undefined;
+}

package/dist/routing/route.d.ts

@@ -0,0 +1,25 @@
+import { Stop } from '../stops/stops.js';
+import { Duration } from '../timetable/duration.js';
+import { Time } from '../timetable/time.js';
+import { ServiceRoute } from '../timetable/timetable.js';
+export type BaseLeg = {
+    from: Stop;
+    to: Stop;
+};
+export type Transfer = BaseLeg & {
+    minTransferTime?: Duration;
+};
+export type VehicleLeg = BaseLeg & {
+    route: ServiceRoute;
+    departureTime: Time;
+    arrivalTime: Time;
+};
+export type Leg = Transfer | VehicleLeg;
+export declare class Route {
+    legs: Leg[];
+    constructor(legs: Leg[]);
+    departureTime(): Time;
+    arrivalTime(): Time;
+    totalDuration(): Duration;
+    print(): string;
+}

package/dist/routing/router.d.ts

@@ -0,0 +1,33 @@
+import { StopId } from '../stops/stops.js';
+import { Time } from '../timetable/time.js';
+import { Timetable } from '../timetable/timetable.js';
+import { StopsIndex } from '../umdIndex.js';
+import { Query } from './query.js';
+import { Result } from './result.js';
+import { Leg } from './route.js';
+export type TripLeg = ReachingTime & {
+    leg?: Leg;
+};
+export type ReachingTime = {
+    time: Time;
+    legNumber: number;
+    origin: StopId;
+};
+export declare class Router {
+    private readonly timetable;
+    private readonly stopsIndex;
+    constructor(timetable: Timetable, stopsIndex: StopsIndex);
+    /**
+     * Evaluates possible transfers for a given query on a transport
+     * network, updating the earliest arrivals at various stops and marking new
+     * stops that can be reached through these transfers.
+     */
+    private considerTransfers;
+    /**
+     * The main Raptor algorithm implementation.
+     *
+     * @param query The query containing the main parameters for the routing.
+     * @returns A result object containing data structures allowing to reconstruct routes and .
+     */
+    route(query: Query): Result;
+}

package/dist/stops/__tests__/io.test.d.ts

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

package/dist/stops/__tests__/stopFinder.test.d.ts

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

package/dist/stops/i18n.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Generates a list of accent variants for a given term.
+ *
+ * This function takes a term and generates a list of alternative spellings
+ * by replacing characters with their accented variants and vice versa.
+ *
+ * @param term - The input term for which to generate accent variants.
+ * @returns An array of strings containing the original term and its accent variants.
+ */
+export declare const generateAccentVariants: (term: string) => string[];

package/dist/stops/io.d.ts

@@ -0,0 +1,4 @@
+import { StopsMap as ProtoStopsMap } from './proto/stops.js';
+import { StopsMap } from './stops.js';
+export declare const serializeStopsMap: (stopsMap: StopsMap) => ProtoStopsMap;
+export declare const deserializeStopsMap: (protoStopsMap: ProtoStopsMap) => StopsMap;

package/dist/stops/proto/stops.d.ts

@@ -0,0 +1,53 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "minotor.stops";
+export declare enum LocationType {
+    SIMPLE_STOP_OR_PLATFORM = 0,
+    STATION = 1,
+    ENTRANCE_EXIT = 2,
+    GENERIC_NODE = 3,
+    BOARDING_AREA = 4,
+    UNRECOGNIZED = -1
+}
+export declare function locationTypeFromJSON(object: any): LocationType;
+export declare function locationTypeToJSON(object: LocationType): string;
+export interface Stop {
+    name: string;
+    lat?: number | undefined;
+    lon?: number | undefined;
+    children: string[];
+    parent?: string | undefined;
+    locationType: LocationType;
+    platform?: string | undefined;
+}
+export interface StopsMap {
+    version: string;
+    stops: {
+        [key: string]: Stop;
+    };
+}
+export interface StopsMap_StopsEntry {
+    key: string;
+    value: Stop | undefined;
+}
+export declare const Stop: MessageFns<Stop>;
+export declare const StopsMap: MessageFns<StopsMap>;
+export declare const StopsMap_StopsEntry: MessageFns<StopsMap_StopsEntry>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

package/dist/stops/stops.d.ts

@@ -0,0 +1,16 @@
+export type StopId = string;
+export type Platform = string;
+export type Latitude = number;
+export type Longitude = number;
+export type LocationType = 'SIMPLE_STOP_OR_PLATFORM' | 'STATION' | 'ENTRANCE_EXIT' | 'GENERIC_NODE' | 'BOARDING_AREA';
+export type Stop = {
+    id: StopId;
+    name: string;
+    lat?: Latitude;
+    lon?: Longitude;
+    children: StopId[];
+    parent?: StopId;
+    locationType: LocationType;
+    platform?: Platform;
+};
+export type StopsMap = Map<StopId, Stop>;

package/dist/stops/stopsIndex.d.ts

@@ -0,0 +1,52 @@
+import { Stop, StopId, StopsMap } from './stops.js';
+/**
+ * The StopMap class provides functionality to search for public transport stops
+ * by name or geographic location. It leverages text search and geospatial indexing
+ * to efficiently find stops based on user queries.
+ */
+export declare class StopsIndex {
+    private readonly stopsMap;
+    private readonly textIndex;
+    private readonly geoIndex;
+    private readonly stopPoints;
+    constructor(stopsMap: StopsMap);
+    /**
+     * Deserializes a binary representation of the stops.
+     *
+     * @param {Uint8Array} data - The binary data to deserialize.
+     * @returns {StopsMap} - The deserialized StopFinder.
+     */
+    static fromData(data: Uint8Array): StopsIndex;
+    /**
+     * Serializes the stops into a binary protobuf.
+     *
+     * @returns {Uint8Array} - The serialized binary data.
+     */
+    serialize(): Uint8Array;
+    /**
+     * Finds stops by their name using a text search.
+     *
+     * @param query - The name or partial name of the stop to search for.
+     * @param maxResults - The maximum number of results to return (default is 5).
+     * @returns An array of Stop objects that match the search query.
+     */
+    findStopsByName(query: string, maxResults?: number): Stop[];
+    /**
+     * Finds stops by their geographic location using latitude and longitude.
+     *
+     * @param lat - The latitude of the location to search near.
+     * @param lon - The longitude of the location to search near.
+     * @param maxResults - The maximum number of results to return (default is 10).
+     * @param radius - The search radius in kilometers (default is 0.5).
+     * @returns An array of Stop objects that are closest to the specified location.
+     */
+    findStopsByLocation(lat: number, lon: number, maxResults?: number, radius?: number): Stop[];
+    /**
+     * Finds a stop by its ID.
+     *
+     * @param id - The ID of the stop to search for.
+     * @returns The Stop object that matches the specified ID, or undefined if not found.
+     */
+    findStopById(id: StopId): Stop | undefined;
+    equivalentStops(id: StopId): StopId[];
+}

package/dist/timetable/__tests__/io.test.d.ts

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

package/dist/timetable/__tests__/timetable.test.d.ts

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

package/dist/timetable/duration.d.ts

@@ -0,0 +1,51 @@
+export declare class Duration {
+    private totalSeconds;
+    private constructor();
+    /**
+     * Creates a Duration instance from a given number of seconds.
+     *
+     * @param seconds - The number of seconds for the duration.
+     * @returns A Duration instance representing the specified duration.
+     */
+    static fromSeconds(seconds: number): Duration;
+    /**
+     * Creates a Duration instance from a given number of minutes.
+     *
+     * @param minutes - The number of minutes for the duration.
+     * @returns A Duration instance representing the specified duration.
+     */
+    static fromMinutes(minutes: number): Duration;
+    /**
+     * Gets a Duration instance representing zero duration (0 hours, 0 minutes, 0 seconds).
+     *
+     * @returns A Duration instance representing zero duration.
+     */
+    static zero(): Duration;
+    /**
+     * Converts the duration instance to a string in "HH:MM:SS" format.
+     *
+     * @returns A string representing the duration.
+     */
+    toString(): string;
+    /**
+     * Gets the duration as the number of seconds.
+     *
+     * @returns The duration in seconds.
+     */
+    toSeconds(): number;
+    /**
+     * Adds another Duration to this instance and returns the result as a new Duration.
+     *
+     * @param other - The other Duration to add.
+     * @returns A new Duration instance representing the sum.
+     */
+    add(other: Duration): Duration;
+    /**
+     * Subtracts another Duration from this instance and returns the result as a new Duration.
+     * If the result would be negative, it returns a Duration of 0 seconds.
+     *
+     * @param other - The other Duration to subtract.
+     * @returns A new Duration instance representing the difference.
+     */
+    subtract(other: Duration): Duration;
+}

package/dist/timetable/io.d.ts

@@ -0,0 +1,8 @@
+import { RoutesAdjacency as ProtoRoutesAdjacency, ServiceRoutesMap as ProtoServiceRoutesMap, StopsAdjacency as ProtoStopsAdjacency } from './proto/timetable.js';
+import { RoutesAdjacency, ServiceRoutesMap, StopsAdjacency } from './timetable.js';
+export declare const serializeStopsAdjacency: (stopsAdjacency: StopsAdjacency) => ProtoStopsAdjacency;
+export declare const serializeRoutesAdjacency: (routesAdjacency: RoutesAdjacency) => ProtoRoutesAdjacency;
+export declare const serializeServiceRoutesMap: (serviceRoutesMap: ServiceRoutesMap) => ProtoServiceRoutesMap;
+export declare const deserializeStopsAdjacency: (protoStopsAdjacency: ProtoStopsAdjacency) => StopsAdjacency;
+export declare const deserializeRoutesAdjacency: (protoRoutesAdjacency: ProtoRoutesAdjacency) => RoutesAdjacency;
+export declare const deserializeServiceRoutesMap: (protoServiceRoutesMap: ProtoServiceRoutesMap) => ServiceRoutesMap;