@motionstudies/core 0.1.0-alpha.0

package/domain/operations.js

@@ -0,0 +1,191 @@
+function canonicalLineName(value) {
+    return value
+        .toLocaleLowerCase('en-GB')
+        .replace(/\bline\b/g, '')
+        .replace(/[^a-z0-9]+/g, '');
+}
+function canonicalDestination(value) {
+    return value
+        .toLocaleLowerCase('en-GB')
+        .replace(/\b(?:underground|rail|dlr|tram) station\b/g, '')
+        .replace(/[^a-z0-9]+/g, '');
+}
+export function operationsServiceTime(snapshot, timeZone) {
+    const parts = new Intl.DateTimeFormat('en-GB', {
+        timeZone,
+        hourCycle: 'h23',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+    }).formatToParts(new Date(snapshot.metadata.scheduledAt));
+    const value = (type) => Number(parts.find((part) => part.type === type)?.value ?? 0);
+    return value('hour') * 3600 + value('minute') * 60 + value('second');
+}
+export function operationsAgeSeconds(snapshot, now = Date.now()) {
+    return Math.max(0, Math.round((now - Date.parse(snapshot.metadata.collectedAt)) / 1000));
+}
+function templateMatch(train, vehicle, stopIndexes) {
+    if (canonicalLineName(train.route) !== canonicalLineName(vehicle.lineId) &&
+        canonicalLineName(train.route) !== canonicalLineName(vehicle.lineName)) {
+        return undefined;
+    }
+    const anchors = [];
+    let afterPosition = -1;
+    for (const prediction of vehicle.predictions) {
+        const stopIndex = stopIndexes.get(prediction.stopId.toLocaleUpperCase('en-GB'));
+        if (stopIndex === undefined)
+            continue;
+        const position = train.stops.findIndex(([candidate], index) => index > afterPosition && candidate === stopIndex);
+        if (position < 0)
+            continue;
+        anchors.push({ position, secondsToStop: prediction.secondsToStop });
+        afterPosition = position;
+    }
+    if (!anchors.length)
+        return undefined;
+    const destination = canonicalDestination(vehicle.destinationName ?? '');
+    const headsign = canonicalDestination(train.headsign);
+    const destinationScore = destination && headsign &&
+        (destination === headsign || destination.includes(headsign) || headsign.includes(destination))
+        ? 25
+        : 0;
+    return {
+        train,
+        anchors,
+        score: anchors.length * 100 + destinationScore,
+    };
+}
+function timeBetweenAnchors(train, from, to, position, serviceTime) {
+    if (from.position === to.position)
+        return serviceTime + from.secondsToStop;
+    const scheduledFrom = train.stops[from.position]?.[1] ?? from.position;
+    const scheduledTo = train.stops[to.position]?.[1] ?? to.position;
+    const scheduledAt = train.stops[position]?.[1] ?? position;
+    const scheduledDuration = scheduledTo - scheduledFrom;
+    const ratio = scheduledDuration > 0
+        ? (scheduledAt - scheduledFrom) / scheduledDuration
+        : (position - from.position) / (to.position - from.position);
+    return Math.round(serviceTime +
+        from.secondsToStop +
+        (to.secondsToStop - from.secondsToStop) * Math.max(0, Math.min(1, ratio)));
+}
+function observedTrain(match, vehicle, serviceTime) {
+    const { train, anchors } = match;
+    const first = anchors[0];
+    const last = anchors.at(-1);
+    const startPosition = Math.max(0, first.position - 1);
+    let endPosition = last.position;
+    if (endPosition === startPosition) {
+        endPosition = Math.min(train.stops.length - 1, startPosition + 1);
+    }
+    if (endPosition <= startPosition)
+        return undefined;
+    const anchorByPosition = new Map(anchors.map((anchor) => [anchor.position, anchor]));
+    if (startPosition < first.position) {
+        const scheduledDuration = Math.max(30, (train.stops[first.position]?.[1] ?? 0) -
+            (train.stops[startPosition]?.[2] ?? 0));
+        anchorByPosition.set(startPosition, {
+            position: startPosition,
+            secondsToStop: Math.min(0, first.secondsToStop - scheduledDuration),
+        });
+    }
+    if (!anchorByPosition.has(endPosition)) {
+        const scheduledDuration = Math.max(30, (train.stops[endPosition]?.[1] ?? 0) -
+            (train.stops[first.position]?.[1] ?? 0));
+        anchorByPosition.set(endPosition, {
+            position: endPosition,
+            secondsToStop: first.secondsToStop + scheduledDuration,
+        });
+    }
+    const sortedAnchors = [...anchorByPosition.values()].sort((left, right) => left.position - right.position);
+    const stops = train.stops
+        .slice(startPosition, endPosition + 1)
+        .map(([stopIndex], offset) => {
+        const position = startPosition + offset;
+        const exact = anchorByPosition.get(position);
+        let seconds = exact ? serviceTime + exact.secondsToStop : serviceTime;
+        if (!exact) {
+            const nextAnchorIndex = sortedAnchors.findIndex((anchor) => anchor.position > position);
+            const nextAnchor = sortedAnchors[nextAnchorIndex];
+            const previousAnchor = sortedAnchors[nextAnchorIndex - 1];
+            if (previousAnchor && nextAnchor) {
+                seconds = timeBetweenAnchors(train, previousAnchor, nextAnchor, position, serviceTime);
+            }
+        }
+        return [stopIndex, seconds, seconds];
+    });
+    if (stops.length < 2)
+        return undefined;
+    return {
+        id: `observed:${vehicle.id}`,
+        route: train.route,
+        headsign: vehicle.destinationName?.trim() || train.headsign,
+        shortName: vehicle.lineName,
+        category: train.category,
+        mode: vehicle.modeName || train.mode,
+        start: stops[0][1],
+        end: stops.at(-1)[2],
+        stops,
+        pathSegments: train.pathSegments?.slice(startPosition, endPosition),
+        operations: {
+            kind: 'prediction-derived',
+            observedAt: vehicle.observedAt,
+            vehicleId: vehicle.id,
+        },
+    };
+}
+export function projectOperationsOntoNetwork(reference, operations, serviceTime) {
+    const stopIndexes = new Map();
+    reference.stops.forEach((stop, index) => {
+        if (stop[4])
+            stopIndexes.set(stop[4].toLocaleUpperCase('en-GB'), index);
+    });
+    const trainsByLine = new Map();
+    for (const train of reference.trains) {
+        const line = canonicalLineName(train.route);
+        const candidates = trainsByLine.get(line);
+        if (candidates)
+            candidates.push(train);
+        else
+            trainsByLine.set(line, [train]);
+    }
+    const trains = [];
+    for (const vehicle of operations.vehicles) {
+        const lineKeys = new Set([
+            canonicalLineName(vehicle.lineId),
+            canonicalLineName(vehicle.lineName),
+        ]);
+        let match;
+        for (const line of lineKeys) {
+            for (const train of trainsByLine.get(line) ?? []) {
+                const candidate = templateMatch(train, vehicle, stopIndexes);
+                if (candidate && (!match || candidate.score > match.score)) {
+                    match = candidate;
+                }
+            }
+        }
+        if (!match)
+            continue;
+        const train = observedTrain(match, vehicle, serviceTime);
+        if (train)
+            trains.push(train);
+    }
+    return {
+        serviceTime,
+        matchedVehicleCount: trains.length,
+        unmatchedVehicleCount: operations.vehicles.length - trains.length,
+        snapshot: {
+            ...reference,
+            metadata: {
+                ...reference.metadata,
+                windowStart: 0,
+                windowEnd: 86_400,
+                focusTime: serviceTime,
+                retrievedAt: operations.metadata.collectedAt,
+                model: operations.metadata.model,
+                note: 'Observed arrival predictions projected between matched stops on the static route geometry; not GPS.',
+            },
+            trains,
+        },
+    };
+}

package/domain/realtime.d.ts

@@ -0,0 +1,41 @@
+import type { NetworkSnapshot } from './network.ts';
+export type RealtimeTripRelationship = 'scheduled' | 'cancelled' | 'deleted' | 'added';
+export interface RealtimeStopUpdate {
+    readonly stopPosition?: number;
+    readonly stopId?: string;
+    readonly stopSequence?: number;
+    readonly scheduleRelationship?: 'scheduled' | 'skipped' | 'no-data';
+    readonly arrivalDelay?: number;
+    readonly departureDelay?: number;
+}
+export interface RealtimeTripUpdate {
+    readonly tripId: string;
+    readonly startDate?: string;
+    readonly scheduleRelationship?: RealtimeTripRelationship;
+    readonly delaySeconds?: number;
+    readonly stopTimeUpdates?: readonly RealtimeStopUpdate[];
+}
+export interface RealtimeSnapshot {
+    readonly metadata: {
+        readonly kind: 'fixture' | 'live';
+        readonly generatedAt: string;
+        readonly receivedAt?: string;
+        readonly staticFeedVersion: string;
+        readonly serviceDate: string;
+        readonly sourceUrl: string;
+        readonly model: string;
+    };
+    readonly updates: readonly RealtimeTripUpdate[];
+}
+export interface RealtimeApplication {
+    readonly network: NetworkSnapshot;
+    readonly compatible: boolean;
+    readonly reason?: 'feed-version' | 'service-date';
+    readonly summary: {
+        readonly adjusted: number;
+        readonly cancelled: number;
+        readonly skippedStops: number;
+        readonly unmatched: number;
+    };
+}
+export declare function applyRealtimeSnapshot(network: NetworkSnapshot, realtime: RealtimeSnapshot): RealtimeApplication;

package/domain/realtime.js

@@ -0,0 +1,116 @@
+const emptySummary = () => ({
+    adjusted: 0,
+    cancelled: 0,
+    skippedStops: 0,
+    unmatched: 0,
+});
+function exactStopPosition(network, train, update) {
+    if (update.stopPosition !== undefined &&
+        Number.isInteger(update.stopPosition) &&
+        update.stopPosition >= 0 &&
+        update.stopPosition < train.stops.length) {
+        return update.stopPosition;
+    }
+    if (!update.stopId)
+        return undefined;
+    const position = train.stops.findIndex(([stopIndex]) => network.stops[stopIndex]?.[4] === update.stopId);
+    return position < 0 ? undefined : position;
+}
+function adjustTrain(network, train, update, generatedAt) {
+    if (update.scheduleRelationship === 'cancelled' ||
+        update.scheduleRelationship === 'deleted') {
+        return {
+            ...train,
+            realtime: {
+                status: 'cancelled',
+                delaySeconds: update.delaySeconds ?? 0,
+                skippedStops: 0,
+                generatedAt,
+            },
+        };
+    }
+    const updatesByPosition = new Map();
+    for (const stopUpdate of update.stopTimeUpdates ?? []) {
+        const position = exactStopPosition(network, train, stopUpdate);
+        if (position !== undefined)
+            updatesByPosition.set(position, stopUpdate);
+    }
+    let carriedDelay = update.delaySeconds ?? 0;
+    const retainedOriginalPositions = [];
+    const stops = [];
+    let skippedStops = 0;
+    train.stops.forEach((stop, position) => {
+        const stopUpdate = updatesByPosition.get(position);
+        if (stopUpdate?.scheduleRelationship === 'skipped') {
+            skippedStops += 1;
+            return;
+        }
+        const arrivalDelay = stopUpdate?.arrivalDelay ?? carriedDelay;
+        const departureDelay = stopUpdate?.departureDelay ?? arrivalDelay;
+        carriedDelay = departureDelay;
+        retainedOriginalPositions.push(position);
+        stops.push([stop[0], stop[1] + arrivalDelay, stop[2] + departureDelay]);
+    });
+    const pathSegments = train.pathSegments
+        ? retainedOriginalPositions.slice(1).map((position, index) => {
+            const previousPosition = retainedOriginalPositions[index];
+            return position === previousPosition + 1
+                ? (train.pathSegments?.[previousPosition] ?? null)
+                : null;
+        })
+        : undefined;
+    const delaySeconds = carriedDelay;
+    return {
+        ...train,
+        start: stops[0]?.[1] ?? train.start + delaySeconds,
+        end: stops.at(-1)?.[2] ?? train.end + delaySeconds,
+        stops,
+        pathSegments,
+        realtime: {
+            status: 'adjusted',
+            delaySeconds,
+            skippedStops,
+            generatedAt,
+        },
+    };
+}
+export function applyRealtimeSnapshot(network, realtime) {
+    if (realtime.metadata.staticFeedVersion !== network.metadata.feedVersion) {
+        return {
+            network,
+            compatible: false,
+            reason: 'feed-version',
+            summary: emptySummary(),
+        };
+    }
+    if (realtime.metadata.serviceDate !== network.metadata.serviceDate) {
+        return {
+            network,
+            compatible: false,
+            reason: 'service-date',
+            summary: emptySummary(),
+        };
+    }
+    const updates = new Map(realtime.updates.map((update) => [update.tripId, update]));
+    const matched = new Set();
+    const summary = emptySummary();
+    const trains = network.trains.map((train) => {
+        const update = updates.get(train.id);
+        if (!update || update.scheduleRelationship === 'added')
+            return train;
+        matched.add(train.id);
+        const adjusted = adjustTrain(network, train, update, realtime.metadata.generatedAt);
+        if (adjusted.realtime?.status === 'cancelled')
+            summary.cancelled += 1;
+        else
+            summary.adjusted += 1;
+        summary.skippedStops += adjusted.realtime?.skippedStops ?? 0;
+        return adjusted;
+    });
+    summary.unmatched = realtime.updates.length - matched.size;
+    return {
+        network: { ...network, trains },
+        compatible: true,
+        summary,
+    };
+}

package/domain/road-day.d.ts

@@ -0,0 +1,65 @@
+import { type RoadTrafficConditions } from './road.ts';
+export type NationalRoadSiteValue = readonly [
+    siteIndex: number,
+    lightFlowPerHour: number,
+    lightSpeedKmh: number,
+    heavyFlowPerHour: number,
+    heavySpeedKmh: number
+];
+export interface NationalRoadSection {
+    readonly id: string;
+    readonly road: string;
+    readonly direction: 'positive' | 'negative';
+    readonly fromSiteIndex: number;
+    readonly toSiteIndex: number;
+    readonly distanceKm: number;
+}
+export interface NationalRoadMinuteChunk {
+    readonly windowStart: number;
+    readonly windowEnd: number;
+    readonly minutes: readonly (readonly [
+        time: number,
+        values: readonly NationalRoadSiteValue[]
+    ])[];
+}
+export interface NationalRoadChunkDescriptor {
+    readonly id: string;
+    readonly windowStart: number;
+    readonly windowEnd: number;
+    readonly path: string;
+    readonly minuteCount: number;
+    readonly valueCount: number;
+}
+export interface NationalRoadStudyManifest {
+    readonly metadata: {
+        readonly publisher: string;
+        readonly serviceDate: string;
+        readonly windowStart: number;
+        readonly windowEnd: number;
+        readonly sourceUrl: string;
+        readonly measurementSiteTableVersion: number;
+        readonly measurementKind: 'recorded';
+        readonly model: string;
+        readonly sampleIntervalSeconds: number;
+        readonly acceptedSites: number;
+        readonly sections: number;
+        readonly minimumSiteCoverage: number;
+        readonly firstMeasurementTime: string;
+        readonly lastMeasurementTime: string;
+        readonly completeMinutes: number;
+    };
+    readonly siteIds: readonly string[];
+    readonly sections: readonly NationalRoadSection[];
+    readonly chunks: readonly NationalRoadChunkDescriptor[];
+}
+export interface NationalRoadStudySnapshot {
+    readonly metadata: NationalRoadStudyManifest['metadata'];
+    readonly siteIds: readonly string[];
+    readonly sections: readonly NationalRoadSection[];
+    readonly minutes: NationalRoadMinuteChunk['minutes'];
+}
+export declare function roadChunkForTime(manifest: NationalRoadStudyManifest, time: number): NationalRoadChunkDescriptor;
+export declare function adjacentRoadChunks(manifest: NationalRoadStudyManifest, current: NationalRoadChunkDescriptor): readonly NationalRoadChunkDescriptor[];
+export declare function roadSnapshotForChunk(manifest: NationalRoadStudyManifest, chunk?: NationalRoadMinuteChunk): NationalRoadStudySnapshot;
+export declare function nationalRoadConditionsAtTime(snapshot: NationalRoadStudySnapshot, siteIndex: number, time: number): RoadTrafficConditions;
+export declare function reconstructedNationalVehicleCount(snapshot: NationalRoadStudySnapshot, time: number, road?: string): number;

package/domain/road-day.js

@@ -0,0 +1,76 @@
+import { trafficDensity } from './road.js';
+export function roadChunkForTime(manifest, time) {
+    const last = manifest.chunks.at(-1);
+    const match = manifest.chunks.find((chunk) => time >= chunk.windowStart &&
+        (time < chunk.windowEnd || (chunk === last && time <= chunk.windowEnd)));
+    return match ?? (time < manifest.metadata.windowStart ? manifest.chunks[0] : last);
+}
+export function adjacentRoadChunks(manifest, current) {
+    const index = manifest.chunks.findIndex((chunk) => chunk.id === current.id);
+    return manifest.chunks.slice(Math.max(0, index - 1), index + 2);
+}
+export function roadSnapshotForChunk(manifest, chunk) {
+    return {
+        metadata: manifest.metadata,
+        siteIds: manifest.siteIds,
+        sections: manifest.sections,
+        minutes: chunk?.minutes ?? [],
+    };
+}
+function valueConditions(value) {
+    return value
+        ? {
+            lightFlowPerHour: value[1],
+            lightSpeedKmh: value[2],
+            heavyFlowPerHour: value[3],
+            heavySpeedKmh: value[4],
+        }
+        : {
+            lightFlowPerHour: 0,
+            lightSpeedKmh: 0,
+            heavyFlowPerHour: 0,
+            heavySpeedKmh: 0,
+        };
+}
+function interpolate(from, to, progress) {
+    return from + (to - from) * progress;
+}
+export function nationalRoadConditionsAtTime(snapshot, siteIndex, time) {
+    const minutes = snapshot.minutes;
+    if (!minutes.length)
+        return valueConditions();
+    const conditionsAt = (minuteIndex) => valueConditions(minutes[minuteIndex][1].find((value) => value[0] === siteIndex));
+    if (time <= minutes[0][0])
+        return conditionsAt(0);
+    if (time >= minutes.at(-1)[0])
+        return conditionsAt(minutes.length - 1);
+    let high = 1;
+    while (high < minutes.length && minutes[high][0] < time)
+        high += 1;
+    const low = high - 1;
+    const from = conditionsAt(low);
+    const to = conditionsAt(high);
+    const progress = (time - minutes[low][0]) / (minutes[high][0] - minutes[low][0]);
+    return {
+        lightFlowPerHour: interpolate(from.lightFlowPerHour, to.lightFlowPerHour, progress),
+        lightSpeedKmh: interpolate(from.lightSpeedKmh, to.lightSpeedKmh, progress),
+        heavyFlowPerHour: interpolate(from.heavyFlowPerHour, to.heavyFlowPerHour, progress),
+        heavySpeedKmh: interpolate(from.heavySpeedKmh, to.heavySpeedKmh, progress),
+    };
+}
+export function reconstructedNationalVehicleCount(snapshot, time, road) {
+    return Math.round(snapshot.sections.reduce((total, section) => {
+        if (road && section.road !== road)
+            return total;
+        const from = nationalRoadConditionsAtTime(snapshot, section.fromSiteIndex, time);
+        const to = nationalRoadConditionsAtTime(snapshot, section.toSiteIndex, time);
+        const lightFlow = (from.lightFlowPerHour + to.lightFlowPerHour) / 2;
+        const lightSpeed = (from.lightSpeedKmh + to.lightSpeedKmh) / 2;
+        const heavyFlow = (from.heavyFlowPerHour + to.heavyFlowPerHour) / 2;
+        const heavySpeed = (from.heavySpeedKmh + to.heavySpeedKmh) / 2;
+        return (total +
+            (trafficDensity(lightFlow, lightSpeed) +
+                trafficDensity(heavyFlow, heavySpeed)) *
+                section.distanceKm);
+    }, 0));
+}

package/domain/road.d.ts

@@ -0,0 +1,153 @@
+export type RoadTrafficSample = readonly [
+    time: number,
+    lightFlowPerHour: number,
+    lightSpeedKmh: number,
+    heavyFlowPerHour: number,
+    heavySpeedKmh: number
+];
+export interface RoadTrafficDirection {
+    readonly id: string;
+    readonly label: string;
+    readonly reverse: boolean;
+    readonly detectorIds: readonly string[];
+    readonly samples: readonly RoadTrafficSample[];
+}
+export interface RoadTrafficCorridor {
+    readonly id: string;
+    readonly name: string;
+    readonly road: string;
+    readonly distanceKm: number;
+    readonly path: readonly (readonly [longitude: number, latitude: number])[];
+    readonly directions: readonly RoadTrafficDirection[];
+}
+export interface RoadTrafficSnapshot {
+    readonly metadata: {
+        readonly publisher: string;
+        readonly serviceDate: string;
+        readonly windowStart: number;
+        readonly windowEnd: number;
+        readonly sourceUrl: string;
+        readonly measurementSiteUrl: string;
+        readonly measurementSiteTableVersion: number;
+        readonly measurementSitePublishedAt: string;
+        readonly measurementKind: 'representative-calibration' | 'recorded';
+        readonly model: string;
+        readonly note: string;
+        readonly sampleIntervalSeconds: number;
+        readonly visualSampleRate: number;
+        readonly recording?: {
+            readonly firstMeasurementTime: string;
+            readonly lastMeasurementTime: string;
+            readonly completeMinutes: number;
+            readonly minimumDirectionCoverage: number;
+        };
+    };
+    readonly corridors: readonly RoadTrafficCorridor[];
+}
+export interface RoadTopologyPath {
+    readonly id: string;
+    readonly road: string;
+    readonly axisName: string;
+    readonly position: string;
+    readonly mainline: boolean;
+    readonly points: readonly (readonly [longitude: number, latitude: number])[];
+}
+export interface RoadTopologySite {
+    readonly id: string;
+    readonly stationId: string;
+    readonly direction: 'positive' | 'negative';
+    readonly detectorIds: readonly string[];
+    readonly carriageways: readonly string[];
+    readonly coordinate: readonly [longitude: number, latitude: number];
+    readonly match: {
+        readonly confidence: 'high' | 'continuity' | 'authoritative' | 'review' | 'unmatched';
+        readonly method?: 'neighbouring-counters' | 'federal-tmc';
+        readonly tmcLocationCodes?: readonly string[];
+        readonly tmcLocationTableVersions?: readonly string[];
+        readonly distanceMetres?: number;
+        readonly road?: string;
+        readonly axisName?: string;
+        readonly axisPosition?: string;
+        readonly segmentId?: string;
+        readonly mainline?: boolean;
+        readonly projectedCoordinate?: readonly [longitude: number, latitude: number];
+        readonly competingRoad?: string;
+        readonly competingDistanceMetres?: number;
+    };
+}
+export interface RoadTopologyRoad {
+    readonly id: string;
+    readonly label: string;
+    readonly officialLabel: string;
+    readonly description?: string;
+    readonly bounds: {
+        readonly minLongitude: number;
+        readonly maxLongitude: number;
+        readonly minLatitude: number;
+        readonly maxLatitude: number;
+    };
+    readonly focus: readonly [longitude: number, latitude: number];
+    readonly cameraScale: number;
+    readonly pathCount: number;
+    readonly stationCount: number;
+    readonly directionalSiteCount: number;
+    readonly sectionCount: number;
+}
+export interface RoadTopologySection {
+    readonly id: string;
+    readonly road: string;
+    readonly direction: 'positive' | 'negative';
+    readonly fromSiteId: string;
+    readonly toSiteId: string;
+    readonly fromCoordinate: readonly [longitude: number, latitude: number];
+    readonly toCoordinate: readonly [longitude: number, latitude: number];
+    readonly path?: readonly (readonly [longitude: number, latitude: number])[];
+    readonly distanceKm: number;
+}
+export interface RoadTopologySnapshot {
+    readonly metadata: {
+        readonly publisher: string;
+        readonly sourceUrl: string;
+        readonly sourceAsset: string;
+        readonly sourceCrs: string;
+        readonly sourceDate: string;
+        readonly sourceUpdated: string;
+        readonly measurementSiteUrl: string;
+        readonly measurementSiteTableVersion: number;
+        readonly measurementSitePublishedAt: string;
+        readonly tmcLocationUrl?: string;
+        readonly tmcLocationTableVersion?: string;
+        readonly model: string;
+        readonly coverage: {
+            readonly federalStations: number;
+            readonly federalDetectorRecords: number;
+            readonly usableDirectionalGroups: number;
+            readonly matchedDirectionalGroups: number;
+            readonly highConfidenceDirectionalGroups: number;
+            readonly continuityResolvedDirectionalGroups: number;
+            readonly authoritativeResolvedDirectionalGroups: number;
+            readonly reviewDirectionalGroups: number;
+            readonly unmatchedDirectionalGroups: number;
+            readonly matchedStations: number;
+            readonly medianMatchDistanceMetres: number;
+            readonly p95MatchDistanceMetres: number;
+            readonly roads: number;
+            readonly axisSegments: number;
+        };
+    };
+    readonly roads: readonly RoadTopologyRoad[];
+    readonly paths: readonly RoadTopologyPath[];
+    readonly sections: readonly RoadTopologySection[];
+    readonly sites: readonly RoadTopologySite[];
+}
+export interface RoadTrafficConditions {
+    readonly lightFlowPerHour: number;
+    readonly lightSpeedKmh: number;
+    readonly heavyFlowPerHour: number;
+    readonly heavySpeedKmh: number;
+}
+export declare function roadConditionsAtTime(direction: RoadTrafficDirection, time: number): RoadTrafficConditions;
+export declare function trafficDensity(flowPerHour: number, speedKmh: number): number;
+export declare function reconstructedVehicleCount(snapshot: RoadTrafficSnapshot, time: number): number;
+export declare function visualVehicleCount(flowPerHour: number, speedKmh: number, distanceKm: number, sampleRate: number, maximum: number): number;
+export declare function roadDistanceTravelledKm(direction: RoadTrafficDirection, time: number, vehicle: 'light' | 'heavy'): number;