mobility-toolbox-js 3.0.0-beta.8 → 3.0.0

package/common/utils/getMapGlCopyrights.js

@@ -8,7 +8,6 @@ const getMapGlCopyrights = (map) => {
     if (!map) {
         return [];
     }
-    // @ts-ignore
     const { style } = map;
     if (!style) {
         return [];
@@ -16,10 +15,11 @@ const getMapGlCopyrights = (map) => {
     const { sourceCaches } = style;
     let copyrights = [];
     Object.values(sourceCaches).forEach((value) => {
+        var _a;
         if (value.used) {
             const source = value.getSource();
-            const attribution = // @ts-ignore
-             source.attribution || (source.options && source.options.attribution);
+            // @ts-expect-error improve types
+            const attribution = source.attribution || ((_a = source.options) === null || _a === void 0 ? void 0 : _a.attribution);
             if (attribution) {
                 copyrights = copyrights.concat(attribution.replace(/&copy;/g, '©').split(/(<a.*?<\/a>)/));
             }

package/common/utils/getRealtimeModeSuffix.d.ts

@@ -0,0 +1,10 @@
+import type { RealtimeMode } from '../../types';
+import type { RealtimeModesType } from '../../api/RealtimeAPI';
+/**
+ * Get the websocket channel suffix, depending on the current mode.
+ * @param {String} mode Mode 'topographic' ou 'schematic'.
+ * @param {String[]} modes List of modes
+ * @private
+ */
+declare const getModeSuffix: (mode: RealtimeMode, modes: RealtimeModesType) => string;
+export default getModeSuffix;

package/common/utils/getRealtimeModeSuffix.js

@@ -1,6 +1,7 @@
 /**
  * Get the websocket channel suffix, depending on the current mode.
  * @param {String} mode Mode 'topographic' ou 'schematic'.
+ * @param {String[]} modes List of modes
  * @private
  */
 const getModeSuffix = (mode, modes) => mode === modes.SCHEMATIC ? '_schematic' : '';

package/common/utils/getUrlWithParams.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Return the styleUrl with apiKey parameters set.
+ * @param {string} url a url.
+ * @param {Object<String,String>} params a list of key/value pair to add to the url.
+ * @private
+ */
+declare const getUrlWithParams: (url: string, params: Object) => URL;
+export default getUrlWithParams;

package/common/utils/getVehiclePosition.d.ts

@@ -0,0 +1,17 @@
+import { Coordinate } from 'ol/coordinate';
+import { RealtimeTrajectory } from '../../types';
+export interface VehiclePosition {
+    coord: Coordinate;
+    rotation?: number;
+}
+/**
+ * Interpolate or not the vehicle position from a trajectory at a specific date.
+ *
+ * @param {number} now Current date to interpolate a position with. In ms.
+ * @param {RealtimeTrajectory} trajectory The trajectory to interpolate.
+ * @param {boolean} noInterpolate If true, the vehicle position is not interpolated on each render but only once.
+ * @returns {VehiclePosition}
+ * @private
+ */
+declare const getVehiclePosition: (now: number, trajectory: RealtimeTrajectory, noInterpolate: boolean) => VehiclePosition;
+export default getVehiclePosition;

package/common/utils/getVehiclePosition.js

@@ -9,14 +9,17 @@ import { LineString } from 'ol/geom';
  * @private
  */
 const getVehiclePosition = (now, trajectory, noInterpolate) => {
-    const { time_intervals: timeIntervals, olGeometry, coordinate, } = trajectory.properties;
-    const { coordinates } = trajectory.geometry;
-    let { type } = trajectory.geometry;
+    const { coordinate, 
+    // @ts-expect-error  olGeometry is added by the RealtimeLayer
+    olGeometry, time_intervals: timeIntervals, } = trajectory.properties;
+    let { coordinates, type } = trajectory.geometry;
     let geometry = olGeometry;
     let coord;
     let rotation;
+    // If an olGeometry exists we use it. It avoids to create one each time.
     if (olGeometry) {
         type = geometry.getType();
+        coordinates = geometry.getCoordinates();
     }
     if (noInterpolate && coordinate) {
         coord = coordinate;

package/common/utils/index.d.ts

@@ -0,0 +1,16 @@
+export { default as getUrlWithParams } from "./getUrlWithParams";
+export { default as getMapGlCopyrights } from "./getMapGlCopyrights";
+export { default as removeDuplicate } from "./removeDuplicate";
+export { default as createRealtimeFilters } from "./createRealtimeFilters";
+export { default as getLayersAsFlatArray } from "./getLayersAsFlatArray";
+export * from "./timeUtils";
+export * from "./constants";
+export { default as sortByDelay } from "./sortByDelay";
+export { default as renderTrajectories } from "./renderTrajectories";
+export { default as debounceDeparturesMessages } from "./debounceDeparturesMessages";
+export { default as debounceWebsocketMessages } from "./debounceWebsocketMessages";
+export { default as sortAndFilterDepartures } from "./sortAndFilterDepartures";
+export { default as compareDepartures } from "./compareDepartures";
+export { default as createCanvas } from "./createCanvas";
+export { default as getVehiclePosition } from "./getVehiclePosition";
+export * as realtimeConfig from "./realtimeConfig";

package/common/utils/realtimeConfig.d.ts

@@ -0,0 +1,64 @@
+import { AnyCanvasContext, RealtimeMot } from '../../types';
+/**
+ * @private
+ */
+export declare const MOTS_ONLY_RAIL: RealtimeMot[];
+/**
+ * @private
+ */
+export declare const MOTS_WITH_CABLE: RealtimeMot[];
+/**
+ * @private
+ */
+export declare const MOTS_WITHOUT_CABLE: RealtimeMot[];
+/**
+ * @private
+ */
+export declare const MOTS_ALL: RealtimeMot[];
+/**
+ * Trajserv value: 'Tram',  'Subway / Metro / S-Bahn',  'Train', 'Bus', 'Ferry', 'Cable Car', 'Gondola', 'Funicular', 'Long distance bus', 'Rail',
+ * New endpoint use Rail instead of Train.
+ * New tracker values:  null, "tram", "subway", "rail", "bus", "ferry", "cablecar", "gondola", "funicular", "coach".
+ *
+ * @private
+ */
+export declare const types: RegExp[];
+/**
+ * @private
+ */
+export declare const bgColors: string[];
+/**
+ * @private
+ */
+export declare const textColors: string[];
+/**
+ * @private
+ */
+export declare const getTypeIndex: (type: RealtimeMot) => number;
+/**
+ * @private
+ */
+export declare const getRadius: (type: RealtimeMot, zoom: number) => number;
+/**
+ * @private
+ */
+export declare const getBgColor: (type: RealtimeMot) => string;
+/**
+ * @private
+ */
+export declare const getTextColor: (type: RealtimeMot) => string;
+/**
+ * @private
+ */
+export declare const getTextSize: (ctx: AnyCanvasContext, markerSize: number, text: string, fontSize: number, getTextFont: (fontSize: number, text?: string) => string) => number;
+/**
+ * @private
+ * @param {number} delayInMs Delay in milliseconds.
+ * @param {boolean} cancelled true if the journey is cancelled.
+ * @param {boolean} isDelayText true if the color is used for delay text of the symbol.
+ */
+export declare const getDelayColor: (delayInMs: null | number, cancelled?: boolean, isDelayText?: boolean) => string;
+/**
+ * @private
+ */
+export declare const getDelayText: (delayInMs: number, cancelled: boolean) => string;

package/common/utils/realtimeConfig.js

@@ -1,4 +1,3 @@
-/** @private */
 const radiusMapping = [
     [0, 0, 0, 0, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],
     [0, 0, 0, 0, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7],

package/common/utils/removeDuplicate.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This function remove duplicates lower case string value of an array.
+ * It removes also null, undefined or non string values.
+ *
+ * @param {array} array Array of values.
+ * @private
+ */
+declare const removeDuplicate: (array: any[]) => any[];
+export default removeDuplicate;

package/common/utils/renderTrajectories.d.ts

@@ -0,0 +1,17 @@
+import { AnyCanvas, RealtimeRenderState, RealtimeStyleFunction, RealtimeStyleOptions, RealtimeTrajectories, ViewState } from '../../types';
+/**
+ * Draw all the trajectories available in a canvas.
+ * @param {HTMLCanvas|HTMLOffscreenCanvas} canvas The canvas where to draw the trajectories.
+ * @param {ViewState} trajectories An array of trajectories.
+ * @param {Function} style A function that returns a canvas representing a vehicle of a specific trajectory.
+ * @param {ViewState} viewState The view state of the map.
+ * @param {Object} options The options.
+ * @param {boolean} options.hoverVehicleId The id of the vehicle to highlight.
+ * @param {boolean} options.selectedVehicleId The id of the vehicle to select.
+ * @param {boolean} options.noInterpolate If true trajectories are not interpolated but
+ *   drawn at the last known coordinate. Use this for performance optimization
+ *   during map navigation.
+ * @private
+ */
+declare const renderTrajectories: (canvas: AnyCanvas, trajectories: RealtimeTrajectories, style: RealtimeStyleFunction, viewState: ViewState, options: RealtimeStyleOptions) => RealtimeRenderState;
+export default renderTrajectories;

package/common/utils/renderTrajectories.js

@@ -1,11 +1,12 @@
-import { compose, apply, create } from 'ol/transform';
+import { apply, compose, create } from 'ol/transform';
 import getVehiclePosition from './getVehiclePosition';
 /**
  * Draw all the trajectories available in a canvas.
- * @param {HTMLCanvas|HTMLOffscreenCanvas} The canvas where to draw the trajectories.
+ * @param {HTMLCanvas|HTMLOffscreenCanvas} canvas The canvas where to draw the trajectories.
  * @param {ViewState} trajectories An array of trajectories.
  * @param {Function} style A function that returns a canvas representing a vehicle of a specific trajectory.
  * @param {ViewState} viewState The view state of the map.
+ * @param {Object} options The options.
  * @param {boolean} options.hoverVehicleId The id of the vehicle to highlight.
  * @param {boolean} options.selectedVehicleId The id of the vehicle to select.
  * @param {boolean} options.noInterpolate If true trajectories are not interpolated but
@@ -17,13 +18,13 @@ const renderTrajectories = (canvas, trajectories, style, viewState, options) =>
     if (!canvas) {
         return { renderedTrajectories: [] };
     }
-    const { time = Date.now(), size = [], center, resolution, rotation = 0, pixelRatio = 1, } = viewState;
+    const { center, pixelRatio = 1, resolution, rotation = 0, size = [], time = Date.now(), } = viewState;
     if (!resolution || !center) {
         return { renderedTrajectories: [] };
     }
-    const { noInterpolate = false, hoverVehicleId, selectedVehicleId, filter, getScreenPixel = (pixel, viewStat) => (viewStat.zoom || 0) < 12
+    const { filter, getScreenPixel = (pixel, viewStat) => (viewStat.zoom || 0) < 12
         ? pixel.map((coord) => Math.floor(coord))
-        : pixel, } = options;
+        : pixel, hoverVehicleId, noInterpolate = false, selectedVehicleId, } = options;
     const context = canvas.getContext('2d');
     context === null || context === void 0 ? void 0 : context.clearRect(0, 0, canvas.width, canvas.height);
     const [width, height] = size;
@@ -49,7 +50,7 @@ const renderTrajectories = (canvas, trajectories, style, viewState, options) =>
             continue;
         }
         // We simplify the trajectory object
-        const { train_id: id, timeOffset } = trajectory.properties;
+        const { timeOffset, train_id: id } = trajectory.properties;
         // We set the rotation and the timeFraction of the trajectory (used by tralis).
         // if rotation === null that seems there is no rotation available.
         const { coord, rotation: rotationIcon } = getVehiclePosition(time - (timeOffset || 0), trajectory, noInterpolate);

package/common/utils/sortAndFilterDepartures.d.ts

@@ -0,0 +1,16 @@
+import { RealtimeAPIDeparturesById } from '../../api/RealtimeAPI';
+import type { RealtimeDepartureExtended } from '../../types';
+/**
+ * This function sort Departures by arrival time and filter out unwanted departures:
+ *  - when dparture time is in the past
+ *  - when departure are duplicated
+ *  - when departure is not in the next 30 min
+ *
+ * @param {Object} depObject The object containing departures by id.
+ * @param {boolean} [sortByMinArrivalTime=false] If true sort departures by arrival time.
+ * @param {number} [maxDepartureAge=30] The maximum departure age in minutes.
+ * @return {RealtimeDeparture[]} Return departures array.
+ * @private
+ */
+declare const sortAndfilterDepartures: (depObject: RealtimeAPIDeparturesById, sortByMinArrivalTime?: boolean, maxDepartureAge?: number) => RealtimeDepartureExtended[];
+export default sortAndfilterDepartures;

package/common/utils/sortAndFilterDepartures.js

@@ -7,7 +7,8 @@ import compareDepartures from './compareDepartures';
  *
  * @param {Object} depObject The object containing departures by id.
  * @param {boolean} [sortByMinArrivalTime=false] If true sort departures by arrival time.
- * @return {Array<Departure>} Return departures array.
+ * @param {number} [maxDepartureAge=30] The maximum departure age in minutes.
+ * @return {RealtimeDeparture[]} Return departures array.
  * @private
  */
 const sortAndfilterDepartures = (depObject, sortByMinArrivalTime = false, maxDepartureAge = 30) => {

package/common/utils/sortByDelay.d.ts

@@ -0,0 +1,3 @@
+import { RealtimeTrajectory } from '../../types';
+declare const sortByDelay: (traj1: RealtimeTrajectory, traj2: RealtimeTrajectory) => number;
+export default sortByDelay;

package/common/utils/sortByDelay.js

@@ -1,4 +1,3 @@
-/** @private */
 const sortByDelay = (traj1, traj2) => {
     const props1 = traj1.properties;
     const props2 = traj2.properties;
@@ -10,12 +9,17 @@ const sortByDelay = (traj1, traj2) => {
     }
     // We put cancelled train inbetween green and yellow trains
     // >=180000ms corresponds to yellow train
+    // @ts-expect-error
     if (props1.cancelled && !props2.cancelled) {
+        // @ts-expect-error
         return props2.delay < 180000 ? -1 : 1;
     }
+    // @ts-expect-error
     if (props2.cancelled && !props1.cancelled) {
+        // @ts-expect-error
         return props1.delay < 180000 ? 1 : -1;
     }
+    // @ts-expect-error
     return props2.delay - props1.delay;
 };
 export default sortByDelay;

package/common/utils/timeUtils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Get a Date object as UTC date string .
+ * ex: 2019 09 01
+ * @private
+ */
+export declare const getUTCDateString: (now?: Date) => string;
+/**
+ * Get the UTC time string of Date object.
+ * ex: 09:05:01.123
+ * @private
+ */
+export declare const getUTCTimeString: (date: Date) => string;
+/**
+ * Returns a string representation of a number, with a zero if the number is lower than 10.
+ * @private
+ */
+export declare const pad: (integer: number) => string;
+/**
+ * Returns a 'hh:mm' string from a time in ms.
+ * @param {Number} timeInMs Time in milliseconds.
+ * @private
+ */
+export declare const getHoursAndMinutes: (timeInMs: number) => string;

package/common/utils/toMercatorExtent.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @private
+ */
+declare const toMercatorExtent: (bounds: maplibregl.LngLatBounds) => import("ol/extent").Extent;
+export default toMercatorExtent;

package/iife.d.ts

@@ -0,0 +1,2 @@
+export default mbt;
+import mbt from './index';

package/index.d.ts

@@ -0,0 +1,9 @@
+export * as ol from "./ol";
+export * as maplibre from "./maplibre";
+declare namespace _default {
+    export { ol };
+    export { maplibre };
+}
+export default _default;
+import * as ol from './ol';
+import * as maplibre from './maplibre';

package/maplibre/controls/CopyrightControl.d.ts

@@ -0,0 +1,38 @@
+import { ControlPosition, IControl } from 'maplibre-gl';
+/**
+ * Display layer's attributions trying to remove duplicated ones.
+ *
+ * @example
+ * import { Map } from 'maplibre-gl';
+ * import { CopyrightControl } from 'mobility-toolbox-js/maplibre';
+ *
+ * const map = new Map({
+ *   container: 'map',
+ *   style: `https://maps.geops.io/styles/travic_v2/style.json?key=${window.apiKey}`,
+ * });
+ *
+ * const control = new CopyrightControl();
+ * map.addControl(control);
+ *
+ *
+ * @see <a href="/example/mb-realtime>MapLibre Realtime layer example</a>
+ *
+ * @implements {maplibregl.IControl}
+ *
+ * @public
+ */
+declare class CopyrightControl implements IControl {
+    container?: HTMLElement;
+    content?: string;
+    map?: maplibregl.Map;
+    options?: {
+        customAttribution?: string | string[];
+        separator?: string;
+    };
+    constructor(options?: {});
+    getDefaultPosition(): ControlPosition;
+    onAdd(map: maplibregl.Map): HTMLElement;
+    onRemove(): HTMLElement | undefined;
+    render(): void;
+}
+export default CopyrightControl;

package/maplibre/controls/CopyrightControl.js

@@ -4,11 +4,11 @@ import { getMapGlCopyrights } from '../../common/utils';
  */
 const DEFAULT_SEPARATOR = ' | ';
 /**
- * Display layer's copyrights.
+ * Display layer's attributions trying to remove duplicated ones.
  *
  * @example
- * import { Map } from 'Maplibre-gl';
- * import { CopyrightControl } from 'mobility-toolbox-js/Maplibre';
+ * import { Map } from 'maplibre-gl';
+ * import { CopyrightControl } from 'mobility-toolbox-js/maplibre';
  *
  * const map = new Map({
  *   container: 'map',
@@ -19,13 +19,20 @@ const DEFAULT_SEPARATOR = ' | ';
  * map.addControl(control);
  *
  *
- * @see <a href="/example/mb-copyright">Maplibre copyright example</a>
+ * @see <a href="/example/mb-realtime>MapLibre Realtime layer example</a>
  *
+ * @implements {maplibregl.IControl}
+ *
+ * @public
  */
 class CopyrightControl {
     constructor(options = {}) {
         this.options = options;
     }
+    // eslint-disable-next-line class-methods-use-this
+    getDefaultPosition() {
+        return 'bottom-right';
+    }
     onAdd(map) {
         this.map = map;
         if (!this.container) {
@@ -51,10 +58,6 @@ class CopyrightControl {
         this.map = undefined;
         return this.container;
     }
-    // eslint-disable-next-line class-methods-use-this
-    getDefaultPosition() {
-        return 'bottom-right';
-    }
     render() {
         var _a, _b;
         if (this.map && this.container) {

package/maplibre/controls/index.d.ts

@@ -0,0 +1 @@
+export { default as CopyrightControl } from "./CopyrightControl";

package/maplibre/index.d.ts

@@ -0,0 +1,5 @@
+export * from "../api";
+export * from "../common";
+export * from "./controls";
+export * from "./layers";
+export * from "./utils";

package/maplibre/layers/Layer.d.ts

@@ -0,0 +1,29 @@
+import { CustomLayerInterface, Evented } from 'maplibre-gl';
+import type { AnyMapGlMap } from '../../types';
+export interface LayerOptions {
+    id?: string;
+}
+export type CUSTOM = 'custom';
+/**
+ * A class representing a layer to display on an Maplibre map.
+ *
+ * @example
+ * import { Layer } from 'mobility-toolbox-js/Maplibre';
+ *
+ * const layer = new Layer({ id:'MyLayer' });
+ *
+ * @implements {maplibregl.CustomLayerInterface}
+ * @extends {maplibregl.Evented}
+ * @private
+ */
+declare class Layer extends Evented implements CustomLayerInterface {
+    id: string;
+    map: AnyMapGlMap | undefined;
+    options: LayerOptions;
+    type: CUSTOM;
+    constructor(options?: LayerOptions);
+    onAdd(map: AnyMapGlMap, gl: WebGL2RenderingContext | WebGLRenderingContext): void;
+    onRemove(map: AnyMapGlMap, gl: WebGL2RenderingContext | WebGLRenderingContext): void;
+    render(gl: WebGL2RenderingContext | WebGLRenderingContext): void;
+}
+export default Layer;

package/maplibre/layers/Layer.js

@@ -1,5 +1,5 @@
-import { v4 as uuid } from 'uuid';
 import { Evented } from 'maplibre-gl';
+import { v4 as uuid } from 'uuid';
 /**
  * A class representing a layer to display on an Maplibre map.
  *
@@ -8,7 +8,7 @@ import { Evented } from 'maplibre-gl';
  *
  * const layer = new Layer({ id:'MyLayer' });
  *
- * @implements {maplibregl.CustomLayer}
+ * @implements {maplibregl.CustomLayerInterface}
  * @extends {maplibregl.Evented}
  * @private
  */
@@ -19,7 +19,6 @@ class Layer extends Evented {
         this.type = 'custom';
         this.options = options;
         this.id = options.id || uuid();
-        this.type = 'custom';
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     onAdd(map, gl) {

package/maplibre/layers/RealtimeLayer.d.ts

@@ -0,0 +1,124 @@
+import { CanvasSourceSpecification, LayerSpecification } from 'maplibre-gl';
+import RealtimeEngine, { RealtimeEngineOptions } from '../../common/utils/RealtimeEngine';
+import Layer, { LayerOptions } from './Layer';
+import type { AnyCanvas, AnyMapGlMap } from '../../types';
+export type RealtimeLayerOptions = LayerOptions & RealtimeEngineOptions;
+/**
+ * A Maplibre layer able to display data from the [geOps Realtime API](https://developer.geops.io/apis/realtime/).
+ *
+ * @example
+ * import { Map } from 'maplibre-gl';
+ * import { RealtimeLayer } from 'mobility-toolbox-js/maplibre';
+ *
+ * // Define the map
+ * const map = new Map({ ... });
+ *
+ * // Define your layer map
+ * const layer = new RealtimeLayer({
+ *   apiKey: "yourApiKey"
+ *   // url: "wss://api.geops.io/tracker-ws/v1/",
+ * });
+ *
+ * // Add the layer to your map *
+ * map.on('load', () => {
+ *   map.addLayer(layer);
+ * });
+ *
+ *
+ * @see <a href="/api/class/src/api/RealtimeAPI%20js~RealtimeAPI%20html">RealtimeAPI</a>
+ * @see <a href="/example/mb-realtime>MapLibre Realtime layer example</a>
+ *
+ * @implements {maplibregl.CustomLayerInterface}
+ * @extends {maplibregl.Evented}
+ * @classproperty {function} filter - Filter out a train. This function must be fast, it is executed for every trajectory on every render frame.
+ * @classproperty {RealtimeMode} mode - The realtime mode to use.
+ * @classproperty {RealtimeMot[]} mots - Filter trains by its mode of transportation. It filters trains on backend side.
+ * @classproperty {RealtimeTenant} tenant - Filter trains by its tenant. It filters trains on backend side.
+ * @classproperty {function} sort - Sort trains. This function must be fast, it is executed on every render frame.
+ * @classproperty {function} style - Function to style the vehicles.
+ s
+ * @public
+ */
+declare class RealtimeLayer extends Layer {
+    #private;
+    engine: RealtimeEngine;
+    layer: LayerSpecification;
+    source: CanvasSourceSpecification;
+    sourceId: string;
+    /**
+     * Constructor.
+     *
+     * @param {RealtimeLayerOptions} options
+     * @param {string} options.apiKey Access key for [geOps apis](https://developer.geops.io/).
+     * @param {FilterFunction} options.filter Filter out a train. This function must be fast, it is executed for every trajectory on every render frame.
+     * @param {getMotsByZoomFunction} options.getMotsByZoom Returns for each zoom level the list of MOTs to display. It filters trains on backend side.
+     * @param {number} [options.minZoomInterpolation=8] Minimal zoom level where to start to interpolate train positions.
+     * @param {RealtimeMode} [options.mode='topographic'] The realtime mode to use.
+     * @param {SortFunction} options.sort Sort trains. This function must be fast, it is executed on every render frame.
+     * @param {RealtimeStyleFunction} options.style Function to style the vehicles.
+     * @param {RealtimeTenant} options.tenant Filter trains by its tenant. It filters trains on backend side.
+     * @param {string} [options.url="wss://api.geops.io/tracker-ws/v1/"] The geOps Realtime API url.
+     */
+    constructor(options?: RealtimeLayerOptions);
+    /**
+     * Return the current view state. Used by the RealtimeEngine.
+     * @private
+     */
+    getViewState(): {
+        center?: undefined;
+        extent?: undefined;
+        pixelRatio?: undefined;
+        resolution?: undefined;
+        rotation?: undefined;
+        size?: undefined;
+        visible?: undefined;
+        zoom?: undefined;
+    } | {
+        center: import("ol/coordinate").Coordinate;
+        extent: number[];
+        pixelRatio: number;
+        resolution: number;
+        rotation: number;
+        size: number[];
+        visible: boolean;
+        zoom: number;
+    };
+    /**
+     * Add sources, layers and listeners to the map.
+     */
+    onAdd(map: AnyMapGlMap, gl: WebGL2RenderingContext | WebGLRenderingContext): void;
+    onLoad(): void;
+    /**
+     * Callback on 'move' event.
+     */
+    onMove(): void;
+    /**
+     * Callback on 'moveend' event.
+     */
+    onMoveEnd(): void;
+    /**
+     * Callback when the RealtimeEngine has rendered successfully.
+     */
+    onRealtimeEngineRender(): void;
+    /**
+     * Remove source, layers and listeners from the map.
+     */
+    onRemove(map: AnyMapGlMap, gl: WebGL2RenderingContext | WebGLRenderingContext): void;
+    onZoomEnd(): void;
+    /**
+     * Start updating vehicles position.
+     *
+     * @public
+     */
+    start(): void;
+    /**
+     * Stop updating vehicles position.
+     *
+     * @public
+     */
+    stop(): void;
+    get canvas(): AnyCanvas | undefined;
+    get pixelRatio(): number | undefined;
+    set pixelRatio(pixelRatio: number | undefined);
+}
+export default RealtimeLayer;