mobility-toolbox-js 2.0.0-beta.3 → 2.0.0-beta.33

package/ol/controls/CopyrightControl.d.ts

@@ -0,0 +1,31 @@
+export default CopyrightControl;
+/**
+ * Display layer's copyrights.
+ *
+ * @example
+ * import { Map } from 'ol';
+ * import { CopyrightControl } from 'mobility-toolbox-js/ol';
+ *
+ * const map = new Map({
+ *   target: 'map',
+ * });
+ * const control = new CopyrightControl();
+ * control.attachToMap(map)
+ *
+ *
+ * @see <a href="/example/ol-copyright">Openlayers copyright example</a>
+ *
+ * @extends {Control}
+ * @implements {CopyrightInterface}
+ */
+declare class CopyrightControl extends Control implements CopyrightInterface {
+    constructor(options: any);
+    onPostRender(evt: any): void;
+    getCopyrights(): any[];
+    /**
+     * @ignore
+     */
+    frameState: any;
+}
+import Control from "../../common/controls/Control";
+//# sourceMappingURL=CopyrightControl.d.ts.map

package/ol/controls/CopyrightControl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CopyrightControl.d.ts","sourceRoot":"","sources":["../../../src/ol/controls/CopyrightControl.js"],"names":[],"mappings":";AAKA;;;;;;;;;;;;;;;;;;GAkBG;AACH,0DAFgB,kBAAkB;IAGhC,0BAGC;IAwCD,6BAQC;IA9CD,uBAsBC;IAkBG;;OAEG;IACH,gBAAgC;CAIrC"}

package/ol/controls/RoutingControl.d.ts

@@ -0,0 +1,180 @@
+export default RoutingControl;
+/**
+ * Display a route of a specified mean of transport.
+ *
+ * @example
+ * import { Map } from 'ol';
+ * import { RoutingControl } from 'mobility-toolbox-js/ol';
+ *
+ * const map = new Map({
+ *   target: 'map'
+ * });
+ *
+ * const control = new RoutingControl();
+ *
+ * control.attachToMap(map)
+ *
+ * @classproperty {string} apiKey - Key used for RoutingApi requests.
+ * @classproperty {string} stopsApiKey - Key used for Stop lookup requests (defaults to apiKey).
+ * @classproperty {string} stopsApiUrl - Url used for Stop lookup requests (defaults to https://api.geops.io/stops/v1/lookup/).
+ * @classproperty {Array.<Array<graph="osm", minZoom=0, maxZoom=99>>} graphs - Array of routing graphs and min/max zoom levels. If you use the control in combination with the [geOps Maps API](https://developer.geops.io/apis/maps/), you may want to use the optimal level of generalizations: "[['gen4', 0, 8], ['gen3', 8, 9], ['gen2', 9, 11], ['gen1', 11, 13], ['osm', 13, 99]]"
+ * @classproperty {string} mot - Mean of transport to be used for routing.
+ * @classproperty {object} routingApiParams - object of additional parameters to pass to the routing api request.
+ * @classproperty {object} snapToClosestStation - If true, the routing will snap the coordinate to the closest station. Default to false.
+ * @classproperty {boolean} useRawViaPoints - Experimental property. Wen true, it allows the user to add via points using different kind of string. See "via" parameter defined by the [geOps Routing API](https://developer.geops.io/apis/routing/). Default to false, only array of coordinates and station's id are supported as via points.
+ * @classproperty {RoutingLayer|Layer} routingLayer - Layer for adding route features.
+ * @classproperty {function} onRouteError - Callback on error.
+ * @classproperty {boolean} loading - True if the control is requesting the backend.
+ * @see <a href="/example/ol-routing">Openlayers routing example</a>
+ *
+ * @extends {Control}
+ * @implements {RoutingInterface}
+ */
+declare class RoutingControl extends Control implements RoutingInterface {
+    /**
+     * Calculate at which resolutions corresponds each generalizations.
+     *
+     * @private
+     */
+    private static getGraphsResolutions;
+    constructor(options?: {});
+    /** True if the control is requesting the backend. */
+    loading: boolean;
+    /** @ignore */
+    graphs: any;
+    /** @ignore */
+    mot: any;
+    /** @ignore */
+    modify: boolean;
+    /** @ignore */
+    routingApiParams: any;
+    /** @ignore */
+    useRawViaPoints: any;
+    /** @ignore */
+    snapToClosestStation: any;
+    /** @ignore */
+    cacheStationData: {};
+    /** @ignore */
+    abortControllers: any[];
+    /** @ignore */
+    apiKey: any;
+    /** @ignore */
+    stopsApiKey: any;
+    /** @ignore */
+    segments: any[];
+    /** @ignore */
+    stopsApiUrl: any;
+    /** @ignore */
+    api: RoutingAPI;
+    /** @ignore */
+    routingLayer: any;
+    /** @ignore */
+    onRouteError: any;
+    /** @ignore */
+    viaPoints: any[];
+    /**
+     * Used on click on map while control is active:
+     *   By default adds a viaPoint to the end of array.
+     *   If an existing viaPoint is clicked removes the clicked viaPoint.
+     * @private
+     */
+    private onMapClick;
+    /**
+     * Used on end of the modify interaction. Resolves feature modification:
+     *   Line drag creates new viaPoint at the final coordinate of drag.
+     *   Point drag replaces old viaPoint.
+     * @private
+     */
+    private onModifyEnd;
+    /**
+     * Used on start of the modify interaction. Stores relevant data
+     * in this.initialRouteDrag object
+     * @private
+     */
+    private onModifyStart;
+    /** @ignore */
+    apiChangeListener: () => Promise<any>;
+    /**
+     * Adds/Replaces a viaPoint to the viaPoints array and redraws route:
+     *   Adds a viaPoint at end of array by default.
+     *   If an index is passed a viaPoint is added at the specified index.
+     *   If an index is passed and overwrite x is > 0, x viaPoints at the specified
+     *     index are replaced with a single new viaPoint.
+     * @param {number[]|string} coordinates Array of coordinates
+     * @param {number} [index=-1] Integer representing the index of the added viaPoint. If not specified, the viaPoint is added at the end of the array.
+     * @param {number} [overwrite=0] Marks the number of viaPoints that are removed at the specified index on add.
+     */
+    addViaPoint(coordinatesOrString: any, index?: number, overwrite?: number): void;
+    /**
+     * Removes a viaPoint at the passed array index and redraws route
+     * By default the last viaPoint is removed.
+     * @param {number} index Integer representing the index of the viaPoint to delete.
+     */
+    removeViaPoint(index?: number): void;
+    /**
+     * Replaces the current viaPoints with a new coordinate array.
+     * @param {Array<Array<number>>} coordinateArray Array of nested coordinates
+     */
+    setViaPoints(coordinateArray: Array<Array<number>>): void;
+    /**
+     * Removes all viaPoints, clears the source and triggers a change event
+     */
+    reset(): void;
+    /**
+     * Aborts viapoint and route requests
+     * @private
+     */
+    private abortRequests;
+    /**
+     * Draws route on map using an array of coordinates:
+     *   If a single coordinate is passed a single point feature is added to map.
+     *   If two or more coordinates are passed a request to the RoutingAPI fetches
+     *       the route using the passed coordinates and the current mot.
+     * @private
+     */
+    private drawRoute;
+    /**
+     * Draw a via point. This function can parse all the possibilitiies
+     *
+     * @private
+     */
+    private drawViaPoint;
+    /** @ignore */
+    initialRouteDrag: {
+        viaPoint: any;
+        oldRoute: any;
+        segmentIndex: number;
+    };
+    /** @ignore */
+    element: HTMLButtonElement;
+    /**
+     * Create the interaction used to modify vertexes of features.
+     * @private
+     */
+    private createModifyInteraction;
+    /**
+     * @type {ol.interaction.Modify}
+     * @private
+     */
+    private modifyInteraction;
+    /**
+     * Add click listener to map.
+     * @private
+     */
+    private addListeners;
+    /** @ignore */
+    onMapClickKey: any;
+    /**
+     * Remove click listener from map.
+     * @private
+     */
+    private removeListeners;
+    /** @ignore */
+    format: GeoJSON;
+    /** @ignore */
+    graphsResolutions: any;
+}
+import Control from "../../common/controls/Control";
+import { RoutingAPI } from "../../api";
+import { GeoJSON } from "ol/format";
+//# sourceMappingURL=RoutingControl.d.ts.map

package/ol/controls/RoutingControl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RoutingControl.d.ts","sourceRoot":"","sources":["../../../src/ol/controls/RoutingControl.js"],"names":[],"mappings":";AAiDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wDAFgB,gBAAgB;IAoH9B;;;;OAIG;IACH,oCAMC;IA5HD,0BA+GC;IAlFC,qDAAqD;IACrD,iBAAoB;IAEpB,cAAc;IACd,YAAgD;IAEhD,cAAc;IACd,SAA+B;IAE/B,cAAc;IACd,gBAAsC;IAEtC,cAAc;IACd,sBAAsD;IAEtD,cAAc;IACd,qBAAuD;IAEvD,cAAc;IACd,0BAAiE;IAEjE,cAAc;IACd,qBAA0B;IAE1B,cAAc;IACd,wBAA0B;IAE1B,cAAc;IACd,YAA4B;IAE5B,cAAc;IACd,iBAAqD;IAErD,cAAc;IACd,gBAAkB;IAElB,cAAc;IACd,iBAA0E;IAE1E,cAAc;IACd,gBAEE;IAEF,cAAc;IACd,kBAKI;IAEJ,cAAc;IACd,kBAUI;IAEJ,cAAc;IACd,iBAAmB;IAoXrB;;;;;OAKG;IACH,mBAeC;IA4CD;;;;;OAKG;IACH,oBAqBC;IArED;;;;OAIG;IACH,sBAmCC;IAxaC,cAAc;IACd,sCAA+C;IAmBjD;;;;;;;;;OASG;IACH,8CAHW,MAAM,cACN,MAAM,QAchB;IAED;;;;OAIG;IACH,uBAFW,MAAM,QAYhB;IAED;;;OAGG;IACH,8BAFW,MAAM,MAAM,MAAM,CAAC,CAAC,QAS9B;IAED;;OAEG;IACH,cASC;IAED;;;OAGG;IACH,sBAeC;IAED;;;;;;OAMG;IACH,kBA0HC;IAED;;;;OAIG;IACH,qBAkHC;IA2DC,cAAc;IACd;;;;MAIC;IAsCD,cAAc;IACd,2BAA+C;IAYjD;;;OAGG;IACH,gCA8BC;IA7BC;;;OAGG;IAEH,0BAoBE;IAMJ;;;OAGG;IACH,qBAOC;IAFC,cAAc;IACd,mBAAgE;IAGlE;;;OAGG;IACH,wBAEC;IAKG,cAAc;IACd,gBAEE;IAEF,cAAc;IACd,uBAGC;CA2BN"}

package/ol/controls/StopFinderControl.d.ts

@@ -0,0 +1,32 @@
+export default StopFinderControl;
+/**
+ * Search stations.
+ *
+ * @example
+ * import { Map } from 'ol';
+ * import { StopFinderControl } from 'mobility-toolbox-js/ol';
+ *
+ * const map = new Map({
+ *   target: 'map',
+ * });
+ *
+ * const control = new StopFinderControl({
+ *   apiKey: [yourApiKey]
+ * });
+ *
+ * control.attachToMap(map);
+ *
+ *
+ * @see <a href="/example/ol-search">Openlayers search example</a>
+ *
+ * @extends {Control}
+ * @implements {StopFinderInterface}
+ */
+declare class StopFinderControl extends Control implements StopFinderInterface {
+    /**
+     * @private
+     */
+    private onSuggestionClick;
+}
+import Control from "../../common/controls/Control";
+//# sourceMappingURL=StopFinderControl.d.ts.map

package/ol/controls/StopFinderControl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StopFinderControl.d.ts","sourceRoot":"","sources":["../../../src/ol/controls/StopFinderControl.js"],"names":[],"mappings":";AAIA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,2DAFgB,mBAAmB;IAGjC;;OAEG;IACH,0BAGC;CACF"}

package/ol/controls/index.d.ts

@@ -0,0 +1,4 @@
+export { default as CopyrightControl } from "./CopyrightControl";
+export { default as RoutingControl } from "./RoutingControl";
+export { default as StopFinderControl } from "./StopFinderControl";
+//# sourceMappingURL=index.d.ts.map

package/ol/controls/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ol/controls/index.js"],"names":[],"mappings":""}

package/ol/index.d.ts

@@ -0,0 +1,6 @@
+export * from "../api";
+export * from "../common";
+export * from "./controls";
+export * from "./layers";
+export * from "./styles";
+//# sourceMappingURL=index.d.ts.map

package/ol/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ol/index.js"],"names":[],"mappings":""}

package/ol/layers/Layer.d.ts

@@ -0,0 +1,49 @@
+export default Layer;
+/**
+ * A class representing a layer to display on an OpenLayers map.
+ *
+ * @example
+ * import { Layer } from 'mobility-toolbox-js/ol';
+ *
+ * const layer = new Layer({
+ *   olLayer: ...,
+ * });
+ *
+ * @see <a href="/example/ol-map">Map example</a>
+ *
+ * @classproperty {ol/Map~Map} map - The map where the layer is displayed.
+ * @extends {Layer}
+ */
+declare class Layer {
+    /**
+     * Define layer's properties.
+     *
+     * @ignore
+     */
+    defineProperties(options: any): void;
+    /**
+     * Initialize the layer and listen to feature clicks.
+     * @param {ol/Map~Map} map
+     */
+    attachToMap(map: any): void;
+    /**
+     * Terminate what was initialized in init function. Remove layer, events...
+     */
+    detachFromMap(): void;
+    activateUserInteractions(): void;
+    singleClickListenerKey: any;
+    pointerMoveListenerKey: any;
+    deactivateUserInteractions(): void;
+    /**
+     * Toggle listeners needed when a layer is avisible or not.
+     * @private
+     */
+    private toggleVisibleListeners;
+    /**
+     * Create a copy of the Layer.
+     * @param {Object} newOptions Options to override
+     * @return {Layer} A Layer
+     */
+    clone(newOptions: any): Layer;
+}
+//# sourceMappingURL=Layer.d.ts.map

package/ol/layers/Layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Layer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/Layer.js"],"names":[],"mappings":";AAIA;;;;;;;;;;;;;;GAcG;AACH;IAqBE;;;;OAIG;IACH,qCAQC;IAED;;;OAGG;IACH,4BAiDC;IAED;;OAEG;IACH,sBAYC;IAED,iCAyBC;IAjBG,4BAGC;IASD,4BAGC;IAIL,mCAEC;IAED;;;OAGG;IACH,+BAMC;IAED;;;;OAIG;IACH,wBAFY,KAAK,CAIhB;CACF"}

package/ol/layers/MapboxLayer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A class representing Mapboxlayer to display on BasicMap
+ *
+ * @example
+ * import { MapboxLayer } from 'mobility-toolbox-js/ol';
+ *
+ * const layer = new MapboxLayer({
+ *   url: 'https://maps.geops.io/styles/travic_v2/style.json',
+ *   apikey: 'yourApiKey',
+ * });
+ *
+ * @classproperty {ol/Map~Map} map - The map where the layer is displayed.
+ * @extends {Layer}
+ */
+export default class MapboxLayer extends Layer {
+    /**
+     * Create the mapbox map.
+     * @private
+     */
+    private loadMbMap;
+    /** @ignore */
+    renderState: {
+        center: any[];
+        zoom: any;
+        rotation: any;
+        visible: any;
+        opacity: any;
+        size: number[];
+    };
+    /** @ignore */
+    copyrights: any[];
+    getOlLayerRender(): (frameState: any) => any;
+    getMapboxMapClass(): any;
+    /**
+     * Create a copy of the MapboxLayer.
+     * @param {Object} newOptions Options to override
+     * @return {MapboxLayer} A MapboxLayer
+     */
+    clone(newOptions: any): MapboxLayer;
+}
+import Layer from "./Layer";
+//# sourceMappingURL=MapboxLayer.d.ts.map

package/ol/layers/MapboxLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapboxLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/MapboxLayer.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH;IA2BE;;;OAGG;IACH,kBA0CC;IA/BC,cAAc;IACd;;;;;;;MAOC;IAOC,cAAc;IACd,kBAA0D;IAiB9D,6CAEC;IAGD,yBAEC;IAED;;;;OAIG;IACH,wBAFY,WAAW,CAItB;CACF"}

package/ol/layers/MapboxStyleLayer.d.ts

@@ -0,0 +1,146 @@
+export default MapboxStyleLayer;
+/**
+ * Layer for visualizing a specific set of layer from a MapboxLayer.
+ *
+ * @example
+ * import { MapboxLayer, MapboxStyleLayer } from 'mobility-toolbox-js/ol';
+ *
+ * const mapboxLayer = new MapboxLayer({
+ *   url: 'https://maps.geops.io/styles/travic_v2/style.json?key=[yourApiKey]',
+ * });
+ *
+ * const layer = new MapboxStyleLayer({
+ *   mapboxLayer: mapboxLayer,
+ *   styleLayersFilter: () => {},
+ * });
+ *
+ * @classproperty {ol/Map~Map} map - The map where the layer is displayed.
+ * @extends {Layer}
+ */
+declare class MapboxStyleLayer extends Layer {
+    /**
+     * Constructor.
+     *
+     * @param {Object} options
+     * @param {MapboxLayer} [options.mapboxLayer] The MapboxLayer to use.
+     * @param {Function} [options.styleLayersFilter] Filter function to decide which style layer to display.
+     */
+    constructor(options?: {
+        mapboxLayer?: MapboxLayer;
+        styleLayersFilter?: Function;
+    });
+    /**
+     * MapboxLayer provided for the style Layer.
+     * @type {MapboxLayer}
+     * @private
+     */
+    private mapboxLayer;
+    /**
+     * Define if the layer has data to display in the current mapbox layer.
+     */
+    disabled: boolean;
+    /**
+     * Function to filter features to be displayed.
+     * @type {function}
+     * @private
+     */
+    private styleLayersFilter;
+    /**
+     * Mapbox style layer id where to add the style layers.
+     * See [mapbox.map.addLayer](https://docs.mapbox.com/mapbox-gl-js/api/map/#map#addlayer) documentation.
+     * @type {String}
+     * @private
+     */
+    private beforeId;
+    /**
+     * Function to filter features for getFeatureInfoAtCoordinate method.
+     * @type {function}
+     * @private
+     */
+    private featureInfoFilter;
+    /**
+     * Function to query the rendered features.
+     * @type {function}
+     * @private
+     */
+    private queryRenderedLayersFilter;
+    /**
+     * Array of features to highlight.
+     * @type {Array<ol/Feature~Feature>}
+     * @private
+     */
+    private highlightedFeatures;
+    /**
+     * Array of selected features.
+     * @type {Array<ol/Feature~Feature>}
+     * @private
+     */
+    private selectedFeatures;
+    /**
+     * Array of mapbox style layers to add.
+     * @type {Array<mapboxgl.styleLayer>}
+     * @private
+     */
+    private styleLayers;
+    /** @ignore */
+    addStyleLayers(): void;
+    /**
+     * On Mapbox map load callback function. Add style layers and dynaimc filters.
+     * @ignore
+     */
+    onLoad(): void;
+    /** @private */
+    private addDynamicFilters;
+    /**
+     * Terminate the layer.
+     * @param {mapboxgl.Map} map the mapbox map.
+     * @override
+     */
+    override detachFromMap(map: mapboxgl.Map): void;
+    /** @ignore */
+    removeStyleLayers(): void;
+    /**
+     * Request feature information for a given coordinate.
+     * @param {ol/coordinate~Coordinate} coordinate Coordinate to request the information at.
+     * @return {Promise<FeatureInfo>} Promise with features, layer and coordinate.
+     */
+    getFeatureInfoAtCoordinate(coordinate: any): Promise<FeatureInfo>;
+    /**
+     * Set filter that determines which features should be rendered in a style layer.
+     * @param {mapboxgl.filter} filter Determines which features should be rendered in a style layer.
+     */
+    setFilter(filter: mapboxgl.filter): void;
+    /**
+     * Set if features are hovered or not.
+     * @param {Array<ol/Feature~Feature>} features
+     * @param {boolean} state Is the feature hovered
+     * @private
+     */
+    private setHoverState;
+    /**
+     * Select a list of features.
+     * @param {Array<ol/Feature~Feature>} [features=[]] Features to select.
+     * @private
+     */
+    private select;
+    /**
+     * Highlight a list of features.
+     * @param {Array<ol/Feature~Feature>} [features=[]] Features to highlight.
+     * @private
+     */
+    private highlight;
+    /**
+     * Apply visibility to style layers that fits the styleLayersFilter function.
+     * @param {Event} evt Layer's event that has called the function.
+     * @private
+     */
+    private applyLayoutVisibility;
+    /**
+     * Create a copy of the MapboxStyleLayer.
+     * @param {Object} newOptions Options to override.
+     * @return {MapboxStyleLayer} A MapboxStyleLayer.
+     */
+    clone(newOptions: any): MapboxStyleLayer;
+}
+import Layer from "./Layer";
+//# sourceMappingURL=MapboxStyleLayer.d.ts.map

package/ol/layers/MapboxStyleLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapboxStyleLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/MapboxStyleLayer.js"],"names":[],"mappings":";AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;;;;OAMG;IACH;QAHiC,WAAW;QACd,iBAAiB;OA4F9C;IAvFC;;;;OAIG;IACH,oBAAsC;IAEtC;;OAEG;IACH,kBAAqB;IAErB;;;;OAIG;IACH,0BAAkD;IAElD;;;;;OAKG;IACH,iBAAgC;IAEhC;;;;OAIG;IACH,0BAAoE;IAEpE;;;;OAIG;IACH,kCAAkE;IAElE;;;;OAIG;IACH,4BAA6B;IAE7B;;;;OAIG;IACH,yBAA0B;IAE1B;;;;OAIG;IACH,oBACyE;IAiG3E,cAAc;IACd,uBAcC;IAiBD;;;OAGG;IACH,eAaC;IAtIG,eAAe;IACf,0BAMC;IAgEL;;;;OAIG;IACH,gDAOC;IAmBD,cAAc;IACd,0BAYC;IAqBD;;;;OAIG;IACH,6CAFY,QAAQ,WAAW,CAAC,CAiC/B;IAED;;;OAGG;IACH,yCAYC;IAED;;;;;OAKG;IACH,sBA8BC;IAED;;;;OAIG;IACH,eAIC;IAED;;;;OAIG;IACH,kBAeC;IAED;;;;OAIG;IAEH,8BA8BC;IAED;;;;OAIG;IACH,wBAFY,gBAAgB,CAI3B;CACF"}

package/ol/layers/MaplibreLayer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A class representing MaplibreLayer to display on BasicMap
+ *
+ * @example
+ * import { MaplibreLayer } from 'mobility-toolbox-js/ol';
+ *
+ * const layer = new MaplibreLayer({
+ *   url: 'https://maps.geops.io/styles/travic_v2/style.json',
+ *   apikey: 'yourApiKey',
+ * });
+ *
+ * @classproperty {ol/Map~Map} map - The map where the layer is displayed.
+ * @extends {Layer}
+ */
+export default class MaplibreLayer extends Layer {
+    getOlLayerRender(): (frameState: any) => any;
+    getMapboxMapClass(): typeof Map;
+    /**
+     * Create a copy of the MapboxLayer.
+     * @param {Object} newOptions Options to override
+     * @return {MapboxLayer} A MapboxLayer
+     */
+    clone(newOptions: any): MapboxLayer;
+}
+import Layer from "./Layer";
+import { Map } from "maplibre-gl";
+//# sourceMappingURL=MaplibreLayer.d.ts.map

package/ol/layers/MaplibreLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MaplibreLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/MaplibreLayer.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH;IACE,6CAEC;IAGD,gCAEC;IAED;;;;OAIG;IACH,oCAEC;CACF"}

package/ol/layers/RealtimeLayer.d.ts

@@ -0,0 +1,119 @@
+export default RealtimeLayer;
+/**
+ * Responsible for loading and display data from a Realtime service.
+ *
+ * @example
+ * import { RealtimeLayer } from 'mobility-toolbox-js/ol';
+ *
+ * const layer = new RealtimeLayer({
+ *   url: [yourUrl],
+ *   apiKey: [yourApiKey],
+ * });
+ *
+ *
+ * @see <a href="/api/class/src/api/RealtimeAPI%20js~RealtimeAPI%20html">RealtimeAPI</a>
+ *
+ * @extends {Layer}
+ * @implements {UserInteractionsLayerInterface}
+ * @implements {RealtimeLayerInterface}
+ */
+declare class RealtimeLayer extends Layer implements UserInteractionsLayerInterface, RealtimeLayerInterface {
+    /**
+     * Constructor.
+     *
+     * @param {Object} options
+     * @private
+     */
+    private constructor();
+    /** @ignore */
+    olLayer: any;
+    container: HTMLDivElement;
+    transformContainer: HTMLDivElement;
+    vectorLayer: any;
+    /** @ignore */
+    renderState: {
+        center: number[];
+        zoom: any;
+        rotation: number;
+    };
+    attachToMap(map: any): void;
+    currentZoom: any;
+    /**
+     * Detect in the canvas if there is data to query at a specific coordinate.
+     * @param {ol/coordinate~Coordinate}  coordinate The coordinate to test
+     * @returns
+     */
+    hasFeatureInfoAtCoordinate(coordinate: any): boolean;
+    /**
+     * Render the trajectories using current map's size, resolution and rotation.
+     * @param {boolean} noInterpolate if true, renders the vehicles without interpolating theirs positions.
+     * @overrides
+     */
+    renderTrajectories(noInterpolate: boolean): void;
+    /**
+     * Launch renderTrajectories. it avoids duplicating code in renderTrajectories methhod.
+     * @private
+     * @override
+     */
+    private override renderTrajectoriesInternal;
+    renderedViewState: any;
+    /**
+     * Return the delay in ms before the next rendering.
+     */
+    getRefreshTimeInMs(): any;
+    getFeatureInfoAtCoordinate(coordinate: any, options?: {}): any;
+    /**
+     * On move end we update the websocket with the new bbox.
+     *
+     * @private
+     * @override
+     */
+    private override onMoveEnd;
+    /**
+     * Function called on moveend event only when the zoom has changed.
+     *
+     * @param {ol/MapEvent~MapEvent} evt Moveend event.
+     * @private
+     * @override
+     */
+    private override onZoomEnd;
+    /**
+     * Update the cursor style when hovering a vehicle.
+     *
+     * @private
+     * @override
+     */
+    private override onFeatureHover;
+    /**
+     * Display the complete trajectory of the vehicle.
+     *
+     * @private
+     * @override
+     */
+    private override onFeatureClick;
+    /**
+     * Remove the trajectory form the list if necessary.
+     *
+     * @private
+     */
+    private purgeTrajectory;
+    /**
+     * Send the current bbox to the websocket
+     *
+     * @private
+     */
+    private setBbox;
+    /**
+     * Highlight the trajectory of journey.
+     * @private
+     */
+    private highlightTrajectory;
+    /**
+     * Create a copy of the RealtimeLayer.
+     * @param {Object} newOptions Options to override
+     * @return {RealtimeLayer} A RealtimeLayer
+     */
+    clone(newOptions: any): RealtimeLayer;
+}
+import Layer from "./Layer";
+//# sourceMappingURL=RealtimeLayer.d.ts.map

package/ol/layers/RealtimeLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RealtimeLayer.d.ts","sourceRoot":"","sources":["../../../src/ol/layers/RealtimeLayer.js"],"names":[],"mappings":";AAYA;;;;;;;;;;;;;;;;;GAiBG;AACH,qDAHgB,8BAA8B,EAC9B,sBAAsB;IAGpC;;;;;OAKG;IACH,sBA2FC;IApFC,cAAc;IACd,aAsEI;IApDQ,0BAA8C;IAI9C,mCAAuD;IAmDnE,iBAAmD;IAInD,cAAc;IACd;;;;MAIC;IAGH,4BAqBC;IANO,iBAAuB;IAgB/B;;;;OAIG;IACH,qDAYC;IAED;;;;OAIG;IACH,kCAHW,OAAO,QAiBjB;IAED;;;;OAIG;IACH,4CAuBC;IAPG,uBAAyC;IAS7C;;OAEG;IACH,0BAEC;IAED,+DAMC;IAED;;;;;OAKG;IACH,2BAaC;IAED;;;;;;OAMG;IAEH,2BAEC;IAED;;;;;OAKG;IACH,gCAKC;IAED;;;;;OAKG;IACH,gCAQC;IAED;;;;OAIG;IACH,wBAMC;IAED;;;;OAIG;IACH,gBAQC;IAED;;;OAGG;IACH,4BAiBC;IAED;;;;OAIG;IACH,wBAFY,aAAa,CAIxB;CACF"}