mobility-toolbox-js 3.0.0-beta.1 → 3.0.0-beta.11

package/ol/layers/RealtimeLayer.d.ts

@@ -0,0 +1,285 @@
+import GeoJSON from 'ol/format/GeoJSON';
+import Source from 'ol/source/Source';
+import Feature, { FeatureLike } from 'ol/Feature';
+import { Map, MapEvent } from 'ol';
+import { ObjectEvent } from 'ol/Object';
+import Layer from 'ol/layer/Layer';
+import { RealtimeLayerMixinOptions } from '../../common/mixins/RealtimeLayerMixin';
+import { RealtimeFullTrajectory, RealtimeTrainId, ViewState } from '../../types';
+import { RealtimeTrajectory } from '../../api/typedefs';
+import { WebSocketAPIMessageEventData } from '../../api/WebSocketAPI';
+import RealtimeLayerRenderer from '../renderers/RealtimeLayerRenderer';
+export type RealtimeLayerOptions = RealtimeLayerMixinOptions & {
+    fullTrajectoryStyle?: (feature: FeatureLike, resolution: number, options: any) => void;
+    allowRenderWhenAnimating?: boolean;
+};
+declare const RealtimeLayer_base: {
+    new (options: RealtimeLayerMixinOptions): {
+        [x: string]: any;
+        debug: boolean;
+        trajectories?: {
+            [key: string]: GeoJSONFeature;
+        } | undefined;
+        canvas?: import("../../types").AnyCanvas | undefined;
+        mode: import("../../types").RealtimeMode;
+        api: import("..").RealtimeAPI;
+        tenant: string;
+        bboxParameters?: {
+            [index: string]: string | number | boolean | string[] | number[] | boolean[];
+        } | undefined;
+        time?: Date | undefined;
+        live?: boolean | undefined;
+        speed?: number | undefined;
+        filter?: Function | undefined;
+        sort?: Function | undefined;
+        style?: import("../../types").RealtimeStyleFunction | undefined;
+        styleOptions?: import("../../types").RealtimeStyleOptions | undefined;
+        pixelRatio?: number | undefined;
+        minZoomInterpolation: number;
+        isUpdateBboxOnMoveEnd: boolean;
+        hoverVehicleId?: string | undefined;
+        selectedVehicleId?: string | undefined;
+        renderState?: import("../../types").RealtimeRenderState | undefined;
+        useRequestAnimationFrame?: boolean | undefined;
+        useDebounce?: boolean | undefined;
+        useThrottle?: boolean | undefined;
+        mots?: import("../../types").RealtimeMot[] | undefined;
+        motsByZoom: import("../../types").RealtimeMot[][];
+        generalizationLevel?: import("../../types").RealtimeGeneralizationLevel | undefined;
+        generalizationLevelByZoom: import("../../types").RealtimeGeneralizationLevel[];
+        renderTimeIntervalByZoom: number[];
+        format: GeoJSON<typeof Feature>;
+        requestId?: number | undefined;
+        updateTimeInterval?: number | undefined;
+        updateTimeDelay?: number | undefined;
+        visibilityRef: import("ol/events").EventsKey;
+        selectedVehicle: GeoJSONFeature;
+        getMotsByZoom: (zoom: number) => import("../../types").RealtimeMot[];
+        getGeneralizationLevelByZoom: (zoom: number) => import("../../types").RealtimeGeneralizationLevel;
+        getRenderTimeIntervalByZoom: (zoom: number) => number;
+        throttleRenderTrajectories: (viewState: ViewState, noInterpolate?: boolean | undefined) => void;
+        debounceRenderTrajectories: (viewState: ViewState, noInterpolate?: boolean | undefined) => void;
+        onStart?: ((realtimeLayer: any) => void) | undefined;
+        onStop?: ((realtimeLayer: any) => void) | undefined;
+        defineProperties(options: RealtimeLayerMixinOptions): void;
+        attachToMap(map: any): void;
+        detachFromMap(): void;
+        start(): void;
+        startUpdateTime(): void;
+        stop(): void;
+        stopUpdateTime(): void;
+        renderTrajectoriesInternal(viewState: ViewState, noInterpolate?: boolean): boolean;
+        renderTrajectories(viewState: ViewState | undefined, noInterpolate: boolean | undefined): void;
+        setBbox(extent: [number, number, number, number], zoom: number): void;
+        getRefreshTimeInMs(zoom?: number | undefined): number;
+        getVehicle(filterFc: Function): GeoJSONFeature[];
+        getFeatureInfoAtCoordinate(coordinate: import("ol/coordinate").Coordinate, options: import("../../types").LayerGetFeatureInfoOptions): Promise<import("../../types").LayerGetFeatureInfoResponse>;
+        getTrajectoryInfos(id: string): Promise<{
+            stopSequence: WebSocketAPIMessageEventData<RealtimeFullTrajectory> | WebSocketAPIMessageEventData<GeoJSONFeature[]>;
+            fullTrajectory: WebSocketAPIMessageEventData<RealtimeFullTrajectory> | WebSocketAPIMessageEventData<GeoJSONFeature[]>;
+        }>;
+        purgeOutOfDateTrajectories(): void;
+        purgeTrajectory(trajectory: GeoJSONFeature, extent: [number, number, number, number], zoom: number): boolean;
+        addTrajectory(trajectory: GeoJSONFeature): void;
+        removeTrajectory(trajectoryOrId: any): void;
+        onZoomEnd(): void;
+        onDocumentVisibilityChange(): void;
+        onTrajectoryMessage(data: WebSocketAPIMessageEventData<GeoJSONFeature>): void;
+        onDeleteTrajectoryMessage(data: WebSocketAPIMessageEventData<string>): void;
+        highlightVehicle(id: string): void;
+        selectVehicle(id: string): void;
+    };
+} & {
+    new (...args: any[]): {
+        options?: import("../mixins/PropertiesLayerMixin").PropertiesLayerMixinOptions | undefined;
+        olListenersKeys: import("ol/events").EventsKey[];
+        children: Layer<Source, import("ol/renderer/Layer").default<any>>[];
+        get copyrights(): string;
+        set copyrights(newCopyrights: string | string[]);
+        disabled: boolean;
+        readonly group: string;
+        readonly hitTolerance: boolean;
+        readonly key: string;
+        readonly map: Map;
+        readonly name: string;
+        olLayer: Layer<Source, import("ol/renderer/Layer").default<any>>;
+        parent: Layer<Source, import("ol/renderer/Layer").default<any>>;
+        visible: boolean;
+        setMapInternal: ((map: Map) => void) & ((map: Map | null) => void);
+        onChildrenChange(oldValue: Layer<Source, import("ol/renderer/Layer").default<any>>[]): void;
+        attachToMap(map: Map): void;
+        detachFromMap(): void;
+        flat(): any[];
+        addEventListener: (type: string, listener: import("ol/events").Listener) => void;
+        removeEventListener: (type: string, listener: import("ol/events").Listener) => void;
+        on: import("ol/layer/Layer").LayerOnSignature<import("ol/events").EventsKey>;
+        render: (frameState: import("ol/Map").FrameState | null, target: HTMLElement) => HTMLElement | null;
+        once: import("ol/layer/Layer").LayerOnSignature<import("ol/events").EventsKey>;
+        un: import("ol/layer/Layer").LayerOnSignature<void>;
+        getSource: () => Source | null;
+        getRenderSource: () => Source | null;
+        getFeatures: (pixel: import("ol/pixel").Pixel) => Promise<FeatureLike[]>;
+        getData: (pixel: import("ol/pixel").Pixel) => Float32Array | Uint8ClampedArray | Uint8Array | DataView | null;
+        isVisible: (view?: import("ol").View | import("ol/View").ViewStateLayerStateExtent | undefined) => boolean;
+        getAttributions: (view?: import("ol").View | import("ol/View").ViewStateLayerStateExtent | undefined) => string[];
+        unrender: () => void;
+        getDeclutter: () => string;
+        renderDeclutter: (frameState: import("ol/Map").FrameState, layerState: import("ol/layer/Layer").State) => void;
+        renderDeferred: (frameState: import("ol/Map").FrameState) => void;
+        getMapInternal: () => Map | null;
+        setMap: (map: Map | null) => void;
+        setSource: (source: Source | null) => void;
+        getRenderer: () => import("ol/renderer/Layer").default<any> | null;
+        hasRenderer: () => boolean;
+        getBackground: () => false | import("ol/layer/Base").BackgroundColor;
+        getClassName: () => string;
+        getLayerState: (managed?: boolean | undefined) => import("ol/layer/Layer").State;
+        getLayersArray: (array?: Layer<Source, import("ol/renderer/Layer").default<any>>[] | undefined) => Layer<Source, import("ol/renderer/Layer").default<any>>[];
+        getLayerStatesArray: (states?: import("ol/layer/Layer").State[] | undefined) => import("ol/layer/Layer").State[];
+        getExtent: () => import("ol/extent").Extent | undefined;
+        getMaxResolution: () => number;
+        getMinResolution: () => number;
+        getMinZoom: () => number;
+        getMaxZoom: () => number;
+        getOpacity: () => number;
+        getSourceState: () => import("ol/source/Source").State;
+        getVisible: () => boolean;
+        getZIndex: () => number | undefined;
+        setBackground: (background?: import("ol/layer/Base").BackgroundColor | undefined) => void;
+        setExtent: (extent: import("ol/extent").Extent | undefined) => void;
+        setMaxResolution: (maxResolution: number) => void;
+        setMinResolution: (minResolution: number) => void;
+        setMaxZoom: (maxZoom: number) => void;
+        setMinZoom: (minZoom: number) => void;
+        setOpacity: (opacity: number) => void;
+        setVisible: (visible: boolean) => void;
+        setZIndex: (zindex: number) => void;
+        get: (key: string) => any;
+        getKeys: () => string[];
+        getProperties: () => {
+            [x: string]: any;
+        };
+        getPropertiesInternal: () => {
+            [x: string]: any;
+        } | null;
+        hasProperties: () => boolean;
+        notify: (key: string, oldValue: any) => void;
+        addChangeListener: (key: string, listener: import("ol/events").Listener) => void;
+        removeChangeListener: (key: string, listener: import("ol/events").Listener) => void;
+        set: (key: string, value: any, silent?: boolean | undefined) => void;
+        setProperties: (values: {
+            [x: string]: any;
+        }, silent?: boolean | undefined) => void;
+        unset: (key: string, silent?: boolean | undefined) => void;
+        changed: () => void;
+        getRevision: () => number;
+        dispatchEvent: (event: string | import("ol/events/Event").default) => boolean | undefined;
+        getListeners: (type: string) => import("ol/events").Listener[] | undefined;
+        hasListener: (type?: string | undefined) => boolean;
+        dispose: () => void;
+    };
+} & typeof Layer;
+/**
+ * An OpenLayers layer able to display data from the [geOps Realtime API](https://developer.geops.io/apis/realtime/).
+ *
+ * @example
+ * import { RealtimeLayer } from 'mobility-toolbox-js/ol';
+ *
+ * const layer = new RealtimeLayer({
+ *   apiKey: "yourApiKey"
+ *   // allowRenderWhenAnimating: false,
+ *   // url: "wss://api.geops.io/tracker-ws/v1/",
+ * });
+ *
+ *
+ * @see <a href="/api/class/src/api/RealtimeAPI%20js~RealtimeAPI%20html">RealtimeAPI</a>
+ *
+ * @extends {ol/layer/Layer~Layer}
+ *
+ * @classproperty {boolean} allowRenderWhenAnimating - Allow rendering of the layer when the map is animating.
+ * @public
+ */
+declare class RealtimeLayer extends RealtimeLayer_base {
+    /** @private */
+    allowRenderWhenAnimating?: boolean;
+    /**
+     * Constructor.
+     *
+     * @param {RealtimeLayerOptions} options
+     * @param {boolean} [options.allowRenderWhenAnimating=false] Allow rendering of the layer when the map is animating.
+     * @param {string} options.apiKey Access key for [geOps apis](https://developer.geops.io/).
+     * @param {string} [options.url="wss://api.geops.io/tracker-ws/v1/"] The geOps Realtime API url.
+     *
+     */
+    constructor(options: RealtimeLayerOptions);
+    /**
+     * @private
+     */
+    createRenderer(): RealtimeLayerRenderer;
+    /** @private */
+    attachToMap(map: Map): void;
+    /**
+     * Destroy the container of the tracker.
+     * @private
+     */
+    detachFromMap(): void;
+    /**
+     * Render the trajectories using current map's size, resolution and rotation.
+     * @param {boolean} noInterpolate if true, renders the vehicles without interpolating theirs positions.
+     * @overrides
+     * @private
+     */
+    renderTrajectories(noInterpolate: boolean): void;
+    /**
+     * Launch renderTrajectories. it avoids duplicating code in renderTrajectories methhod.
+     * @private
+     * @override
+     */
+    renderTrajectoriesInternal(viewState: ViewState, noInterpolate: boolean): boolean;
+    /**
+     * Return the delay in ms before the next rendering.
+     * @private
+     */
+    getRefreshTimeInMs(): number;
+    /**
+     * On move end we update the websocket with the new bbox.
+     *
+     * @private
+     * @override
+     */
+    onMoveEnd(evt: MapEvent | ObjectEvent): void;
+    /**
+     * Function called on moveend event only when the zoom has changed.
+     *
+     * @param {ol/MapEvent~MapEvent} evt Moveend event.
+     * @private
+     * @override
+     */
+    onZoomEnd(): void;
+    highlight(feature: Feature): void;
+    select(feature: Feature): void;
+    /**
+     * Remove the trajectory form the list if necessary.
+     *
+     * @private
+     */
+    purgeTrajectory(trajectory: RealtimeTrajectory, extent: [number, number, number, number], zoom: number): boolean;
+    /**
+     * Send the current bbox to the websocket
+     *
+     * @private
+     */
+    setBbox(extent?: [number, number, number, number], zoom?: number): void;
+    /**
+     * Highlight the trajectory of journey.
+     * @private
+     */
+    highlightTrajectory(id: RealtimeTrainId): Promise<Feature[] | undefined>;
+    /**
+     * Create a copy of the RealtimeLayer.
+     * @param {Object} newOptions Options to override
+     * @return {RealtimeLayer} A RealtimeLayer
+     */
+    clone(newOptions: RealtimeLayerOptions): RealtimeLayer;
+}
+export default RealtimeLayer;

package/ol/layers/RealtimeLayer.js

@@ -11,7 +11,7 @@ import RealtimeLayerRenderer from '../renderers/RealtimeLayerRenderer';
 /** @private */
 const format = new GeoJSON();
 /**
- * Responsible for loading and display data from the geOps Realtime API.
+ * An OpenLayers layer able to display data from the [geOps Realtime API](https://developer.geops.io/apis/realtime/).
  *
  * @example
  * import { RealtimeLayer } from 'mobility-toolbox-js/ol';
@@ -86,9 +86,12 @@ class RealtimeLayer extends RealtimeLayerMixin(MobilityLayerMixin(Layer)) {
             if (this.visible) {
                 this.start();
             }
+            // @ts-expect-error - bad ts check RealtimeLayer is a BaseLayer
             const index = this.map.getLayers().getArray().indexOf(this);
             this.map.getLayers().insertAt(index, this.vectorLayer);
-            this.olListenersKeys.push(...this.map.on(['moveend', 'change:target'], (evt) => {
+            this.olListenersKeys.push(...this.map.on(['moveend', 'change:target'], 
+            // @ts-expect-error - bad ol definitions
+            (evt) => {
                 const view = (evt.map || evt.target).getView();
                 if (view.getAnimating() || view.getInteracting()) {
                     return;
@@ -174,8 +177,10 @@ class RealtimeLayer extends RealtimeLayerMixin(MobilityLayerMixin(Layer)) {
         if (isRendered) {
             /** @private */
             this.renderedViewState = Object.assign({}, viewState);
-            if (this.getRenderer().container) {
-                this.getRenderer().container.style.transform = '';
+            // @ts-expect-error - we are in the same class
+            const { container } = this.getRenderer();
+            if (container) {
+                container.style.transform = '';
             }
         }
         return isRendered;
@@ -266,7 +271,7 @@ class RealtimeLayer extends RealtimeLayerMixin(MobilityLayerMixin(Layer)) {
             // it will trigger a js error on calculateExtent function.
             return false;
         }
-        return super.purgeTrajectory(trajectory, extent || this.map.getView().calculateExtent(), zoom || this.map.getView().getZoom());
+        return super.purgeTrajectory(trajectory, extent || this.map.getView().calculateExtent(), zoom || this.map.getView().getZoom() || 0);
     }
     /**
      * Send the current bbox to the websocket
@@ -274,7 +279,8 @@ class RealtimeLayer extends RealtimeLayerMixin(MobilityLayerMixin(Layer)) {
      * @private
      */
     setBbox(extent, zoom) {
-        super.setBbox(extent || this.map.getView().calculateExtent(), zoom || this.map.getView().getZoom());
+        super.setBbox(extent ||
+            this.map.getView().calculateExtent(), zoom || this.map.getView().getZoom() || 0);
     }
     /**
      * Highlight the trajectory of journey.

package/ol/layers/index.d.ts

@@ -0,0 +1,3 @@
+export { default as MaplibreLayer } from "./MaplibreLayer";
+export { default as MaplibreStyleLayer } from "./MaplibreStyleLayer";
+export { default as RealtimeLayer } from "./RealtimeLayer";

package/ol/mixins/MobilityLayerMixin.d.ts

@@ -0,0 +1,98 @@
+import { Layer } from 'ol/layer';
+import { PropertiesLayerMixinOptions } from './PropertiesLayerMixin';
+export type MobilityLayerOptions = PropertiesLayerMixinOptions & {
+    [x: string]: any;
+};
+type GConstructor<T = {}> = new (...args: any[]) => T;
+export type Layerable = GConstructor<Omit<Layer, keyof string>>;
+declare function MobilityLayerMixin<TBase extends Layerable>(Base: TBase): {
+    new (...args: any[]): {
+        options?: PropertiesLayerMixinOptions | undefined;
+        olListenersKeys: import("ol/events").EventsKey[];
+        children: Layer<import("ol/source").Source, import("ol/renderer/Layer").default<any>>[];
+        get copyrights(): string;
+        set copyrights(newCopyrights: string | string[]);
+        disabled: boolean;
+        readonly group: string;
+        readonly hitTolerance: boolean;
+        readonly key: string;
+        readonly map: import("ol").Map;
+        readonly name: string;
+        olLayer: Layer<import("ol/source").Source, import("ol/renderer/Layer").default<any>>;
+        parent: Layer<import("ol/source").Source, import("ol/renderer/Layer").default<any>>;
+        visible: boolean;
+        setMapInternal: ((map: import("ol").Map) => void) & ((map: import("ol").Map | null) => void);
+        onChildrenChange(oldValue: Layer<import("ol/source").Source, import("ol/renderer/Layer").default<any>>[]): void;
+        attachToMap(map: import("ol").Map): void;
+        detachFromMap(): void;
+        flat(): any[];
+        addEventListener: (type: string, listener: import("ol/events").Listener) => void;
+        removeEventListener: (type: string, listener: import("ol/events").Listener) => void;
+        on: import("ol/layer/Layer").LayerOnSignature<import("ol/events").EventsKey>;
+        render: (frameState: import("ol/Map").FrameState | null, target: HTMLElement) => HTMLElement | null;
+        once: import("ol/layer/Layer").LayerOnSignature<import("ol/events").EventsKey>;
+        un: import("ol/layer/Layer").LayerOnSignature<void>;
+        getSource: () => import("ol/source").Source | null;
+        getRenderSource: () => import("ol/source").Source | null;
+        getFeatures: (pixel: import("ol/pixel").Pixel) => Promise<import("ol/Feature").FeatureLike[]>;
+        getData: (pixel: import("ol/pixel").Pixel) => Float32Array | Uint8ClampedArray | Uint8Array | DataView | null;
+        isVisible: (view?: import("ol").View | import("ol/View").ViewStateLayerStateExtent | undefined) => boolean;
+        getAttributions: (view?: import("ol").View | import("ol/View").ViewStateLayerStateExtent | undefined) => string[];
+        unrender: () => void;
+        getDeclutter: () => string;
+        renderDeclutter: (frameState: import("ol/Map").FrameState, layerState: import("ol/layer/Layer").State) => void;
+        renderDeferred: (frameState: import("ol/Map").FrameState) => void;
+        getMapInternal: () => import("ol").Map | null;
+        setMap: (map: import("ol").Map | null) => void;
+        setSource: (source: import("ol/source").Source | null) => void;
+        getRenderer: () => import("ol/renderer/Layer").default<any> | null;
+        hasRenderer: () => boolean;
+        getBackground: () => false | import("ol/layer/Base").BackgroundColor;
+        getClassName: () => string;
+        getLayerState: (managed?: boolean | undefined) => import("ol/layer/Layer").State;
+        getLayersArray: (array?: Layer<import("ol/source").Source, import("ol/renderer/Layer").default<any>>[] | undefined) => Layer<import("ol/source").Source, import("ol/renderer/Layer").default<any>>[];
+        getLayerStatesArray: (states?: import("ol/layer/Layer").State[] | undefined) => import("ol/layer/Layer").State[];
+        getExtent: () => import("ol/extent").Extent | undefined;
+        getMaxResolution: () => number;
+        getMinResolution: () => number;
+        getMinZoom: () => number;
+        getMaxZoom: () => number;
+        getOpacity: () => number;
+        getSourceState: () => import("ol/source/Source").State;
+        getVisible: () => boolean;
+        getZIndex: () => number | undefined;
+        setBackground: (background?: import("ol/layer/Base").BackgroundColor | undefined) => void;
+        setExtent: (extent: import("ol/extent").Extent | undefined) => void;
+        setMaxResolution: (maxResolution: number) => void;
+        setMinResolution: (minResolution: number) => void;
+        setMaxZoom: (maxZoom: number) => void;
+        setMinZoom: (minZoom: number) => void;
+        setOpacity: (opacity: number) => void;
+        setVisible: (visible: boolean) => void;
+        setZIndex: (zindex: number) => void;
+        get: (key: string) => any;
+        getKeys: () => string[];
+        getProperties: () => {
+            [x: string]: any;
+        };
+        getPropertiesInternal: () => {
+            [x: string]: any;
+        } | null;
+        hasProperties: () => boolean;
+        notify: (key: string, oldValue: any) => void;
+        addChangeListener: (key: string, listener: import("ol/events").Listener) => void;
+        removeChangeListener: (key: string, listener: import("ol/events").Listener) => void;
+        set: (key: string, value: any, silent?: boolean | undefined) => void;
+        setProperties: (values: {
+            [x: string]: any;
+        }, silent?: boolean | undefined) => void;
+        unset: (key: string, silent?: boolean | undefined) => void;
+        changed: () => void;
+        getRevision: () => number;
+        dispatchEvent: (event: string | import("ol/events/Event").default) => boolean | undefined;
+        getListeners: (type: string) => import("ol/events").Listener[] | undefined;
+        hasListener: (type?: string | undefined) => boolean;
+        dispose: () => void;
+    };
+} & TBase;
+export default MobilityLayerMixin;

package/ol/mixins/MobilityLayerMixin.js

@@ -1,9 +1,6 @@
 import PropertiesLayerMixin from './PropertiesLayerMixin';
 function MobilityLayerMixin(Base) {
-    return class extends PropertiesLayerMixin(Base) {
-        constructor(options = {}) {
-            super(options);
-        }
+    return class MobilityLayer extends PropertiesLayerMixin(Base) {
     };
 }
 export default MobilityLayerMixin;

package/ol/mixins/PropertiesLayerMixin.d.ts

@@ -0,0 +1,127 @@
+import { Layer } from 'ol/layer';
+import { EventsKey } from 'ol/events';
+import { Map } from 'ol';
+import type { Options } from 'ol/layer/Layer';
+import type { Layerable } from './MobilityLayerMixin';
+export type PropertiesLayerMixinOptions = Options & {
+    key?: string;
+    name?: string;
+    group?: string;
+    copyrights?: string[];
+    children?: any[];
+    visible?: boolean;
+    disabled?: boolean;
+    hitTolerance?: number;
+    properties?: {
+        [x: string]: any;
+    };
+    map?: Map;
+} & {
+    [x: string]: any;
+};
+/**
+ * This mixin adds some properties to access ol custom properties easily.
+ */
+declare function PropertiesLayerMixin<TBase extends Layerable>(Base: TBase): {
+    new (...args: any[]): {
+        options?: PropertiesLayerMixinOptions | undefined;
+        olListenersKeys: EventsKey[];
+        children: Layer<import("ol/source").Source, import("ol/renderer/Layer").default<any>>[];
+        get copyrights(): string;
+        set copyrights(newCopyrights: string | string[]);
+        disabled: boolean;
+        readonly group: string;
+        readonly hitTolerance: boolean;
+        readonly key: string;
+        readonly map: Map;
+        readonly name: string;
+        olLayer: Layer<import("ol/source").Source, import("ol/renderer/Layer").default<any>>;
+        parent: Layer<import("ol/source").Source, import("ol/renderer/Layer").default<any>>;
+        visible: boolean;
+        setMapInternal(map: Map): void;
+        /** @private */
+        onChildrenChange(oldValue: Layer[]): void;
+        /**
+         * Initialize the layer with the map passed in parameters.
+         *
+         * @param {ol/Map~Map} map A map.
+         */
+        attachToMap(map: Map): void;
+        /**
+         * Terminate what was initialized in init function. Remove layer, events...
+         */
+        detachFromMap(): void;
+        /**
+         * Return the an array containing all the descendants of the layer in a flat array. Including the current layer.
+         */
+        flat(): any[];
+        addEventListener: (type: string, listener: import("ol/events").Listener) => void;
+        removeEventListener: (type: string, listener: import("ol/events").Listener) => void;
+        on: import("ol/layer/Layer").LayerOnSignature<EventsKey>;
+        render: (frameState: import("ol/Map").FrameState | null, target: HTMLElement) => HTMLElement | null;
+        once: import("ol/layer/Layer").LayerOnSignature<EventsKey>;
+        un: import("ol/layer/Layer").LayerOnSignature<void>;
+        getSource: () => import("ol/source").Source | null;
+        getRenderSource: () => import("ol/source").Source | null;
+        getFeatures: (pixel: import("ol/pixel").Pixel) => Promise<import("ol/Feature").FeatureLike[]>;
+        getData: (pixel: import("ol/pixel").Pixel) => Float32Array | Uint8ClampedArray | Uint8Array | DataView | null;
+        isVisible: (view?: import("ol").View | import("ol/View").ViewStateLayerStateExtent | undefined) => boolean;
+        getAttributions: (view?: import("ol").View | import("ol/View").ViewStateLayerStateExtent | undefined) => string[];
+        unrender: () => void;
+        getDeclutter: () => string;
+        renderDeclutter: (frameState: import("ol/Map").FrameState, layerState: import("ol/layer/Layer").State) => void;
+        renderDeferred: (frameState: import("ol/Map").FrameState) => void;
+        getMapInternal: () => Map | null;
+        setMap: (map: Map | null) => void;
+        setSource: (source: import("ol/source").Source | null) => void;
+        getRenderer: () => import("ol/renderer/Layer").default<any> | null;
+        hasRenderer: () => boolean;
+        getBackground: () => false | import("ol/layer/Base").BackgroundColor;
+        getClassName: () => string;
+        getLayerState: (managed?: boolean | undefined) => import("ol/layer/Layer").State;
+        getLayersArray: (array?: Layer<import("ol/source").Source, import("ol/renderer/Layer").default<any>>[] | undefined) => Layer<import("ol/source").Source, import("ol/renderer/Layer").default<any>>[];
+        getLayerStatesArray: (states?: import("ol/layer/Layer").State[] | undefined) => import("ol/layer/Layer").State[];
+        getExtent: () => import("ol/extent").Extent | undefined;
+        getMaxResolution: () => number;
+        getMinResolution: () => number;
+        getMinZoom: () => number;
+        getMaxZoom: () => number;
+        getOpacity: () => number;
+        getSourceState: () => import("ol/source/Source").State;
+        getVisible: () => boolean;
+        getZIndex: () => number | undefined;
+        setBackground: (background?: import("ol/layer/Base").BackgroundColor | undefined) => void;
+        setExtent: (extent: import("ol/extent").Extent | undefined) => void;
+        setMaxResolution: (maxResolution: number) => void;
+        setMinResolution: (minResolution: number) => void;
+        setMaxZoom: (maxZoom: number) => void;
+        setMinZoom: (minZoom: number) => void;
+        setOpacity: (opacity: number) => void;
+        setVisible: (visible: boolean) => void;
+        setZIndex: (zindex: number) => void;
+        get: (key: string) => any;
+        getKeys: () => string[];
+        getProperties: () => {
+            [x: string]: any;
+        };
+        getPropertiesInternal: () => {
+            [x: string]: any;
+        } | null;
+        hasProperties: () => boolean;
+        notify: (key: string, oldValue: any) => void;
+        addChangeListener: (key: string, listener: import("ol/events").Listener) => void;
+        removeChangeListener: (key: string, listener: import("ol/events").Listener) => void;
+        set: (key: string, value: any, silent?: boolean | undefined) => void;
+        setProperties: (values: {
+            [x: string]: any;
+        }, silent?: boolean | undefined) => void;
+        unset: (key: string, silent?: boolean | undefined) => void;
+        changed: () => void;
+        getRevision: () => number;
+        dispatchEvent: (event: string | import("ol/events/Event").default) => boolean | undefined;
+        getListeners: (type: string) => import("ol/events").Listener[] | undefined;
+        hasListener: (type?: string | undefined) => boolean;
+        dispose: () => void;
+    };
+} & TBase;
+export default PropertiesLayerMixin;