import GeoJSON from 'ol/format/GeoJSON';
import { RealtimeAPI } from '../../api';
import type { FeatureCollection } from 'geojson';
import type { Coordinate } from 'ol/coordinate';
import type { WebSocketAPIMessageEventData } from '../../api/WebSocketAPI';
import type { AnyCanvas, LayerGetFeatureInfoOptions, RealtimeMode, RealtimeMot, RealtimeRenderState, RealtimeStyleFunction, RealtimeStyleOptions, RealtimeTenant, RealtimeTrainId, RealtimeTrajectory, ViewState } from '../../types';
import type { FilterFunction, SortFunction } from '../typedefs';
export interface RealtimeEngineOptions {
    api?: RealtimeAPI;
    apiKey?: string;
    bbox?: (number | string)[];
    bboxParameters?: Record<string, boolean | boolean[] | number | number[] | string | string[]>;
    buffer?: number[];
    canvas?: HTMLCanvasElement;
    debug?: boolean;
    filter?: FilterFunction;
    generalizationLevelByZoom?: string[];
    getGeneralizationLevelByZoom?: (zoom: number, generalizationLevelByZoom: string[]) => string;
    getGraphByZoom?: (zoom: number, graphByZoom: string[]) => string | undefined;
    getMotsByZoom?: (zoom: number, motsByZoom: RealtimeMot[][]) => RealtimeMot[];
    getRefreshTimeInMs?: () => number;
    getRenderTimeIntervalByZoom?: (zoom: number, renderTimeIntervalByZoom: number[]) => number;
    getViewState?: () => ViewState;
    graphByZoom?: string[];
    hoverVehicleId?: RealtimeTrainId;
    isUpdateBboxOnMoveEnd?: boolean;
    live?: boolean;
    minZoomInterpolation?: number;
    mode?: RealtimeMode;
    motsByZoom?: RealtimeMot[][];
    onIdle?: (realtimeEngine: RealtimeEngine) => void;
    onRender?: (renderState: RealtimeRenderState, viewState: ViewState) => void;
    onStart?: (realtimeEngine: RealtimeEngine) => void;
    onStop?: (realtimeEngine: RealtimeEngine) => void;
    pingIntervalMs?: number;
    pixelRatio?: number;
    prefix?: string;
    renderTimeIntervalByZoom?: number[];
    selectedVehicleId?: RealtimeTrainId;
    shouldRender?: () => boolean;
    sort?: SortFunction;
    speed?: number;
    style?: RealtimeStyleFunction;
    styleOptions?: Partial<RealtimeStyleOptions>;
    tenant?: RealtimeTenant;
    time?: Date;
    url?: string;
    useDebounce?: boolean;
    useRequestAnimationFrame?: boolean;
    useThrottle?: boolean;
}
/**
 * Basic style options used by default in the RealtimeEngine.
 */
export declare const defaultStyleOptions: RealtimeStyleOptions;
/**
 * This class is responsible for drawing trajectories from a realtime API in a canvas,
 * depending on the map's view state and at a specific time.
 *
 * This class is totally agnostic from Maplibre or OpenLayers and must stay taht way.
 */
declare class RealtimeEngine {
    _generalizationLevelByZoom: string[];
    _graphByZoom: string[];
    _idleTimeout?: number;
    _mode: RealtimeMode;
    _speed: number;
    _style: RealtimeStyleFunction;
    _time: Date;
    api: RealtimeAPI;
    bboxParameters?: Record<string, boolean | boolean[] | number | number[] | string | string[]>;
    canvas?: AnyCanvas;
    debounceRenderTrajectories: (viewState: ViewState, noInterpolate?: boolean) => void;
    debug: boolean;
    filter?: FilterFunction;
    format: GeoJSON;
    generalizationLevel?: string;
    getGeneralizationLevelByZoom: (zoom: number) => string;
    getGraphByZoom: (zoom: number) => string | undefined;
    getMotsByZoom: (zoom: number) => RealtimeMot[];
    getRenderTimeIntervalByZoom: (zoom: number) => number;
    hoverVehicleId?: RealtimeTrainId;
    isIdle: boolean;
    isUpdateBboxOnMoveEnd: boolean;
    live?: boolean;
    minZoomInterpolation: number;
    mots?: RealtimeMot[];
    motsByZoom: RealtimeMot[][];
    onIdle?: (realtimeLayer: RealtimeEngine) => void;
    onRender?: (renderState: RealtimeRenderState, viewState: ViewState) => void;
    onStart?: (realtimeLayer: RealtimeEngine) => void;
    onStop?: (realtimeLayer: RealtimeEngine) => void;
    pixelRatio?: number;
    renderState?: RealtimeRenderState;
    renderTimeIntervalByZoom: number[];
    requestId?: number;
    selectedVehicle: RealtimeTrajectory;
    selectedVehicleId?: RealtimeTrainId;
    sort?: SortFunction;
    styleOptions: RealtimeStyleOptions;
    tenant: RealtimeTenant;
    throttleRenderTrajectories: (viewState: ViewState, noInterpolate?: boolean) => void;
    trajectories?: Record<RealtimeTrainId, RealtimeTrajectory>;
    updateTimeDelay?: number;
    updateTimeInterval?: number;
    useDebounce?: boolean;
    useRequestAnimationFrame?: boolean;
    useThrottle?: boolean;
    get generalizationLevelByZoom(): string[];
    set generalizationLevelByZoom(generalizationLevelByZoom: string[]);
    get graphByZoom(): string[];
    set graphByZoom(graphByZoom: string[]);
    get mode(): RealtimeMode;
    set mode(newMode: RealtimeMode);
    get speed(): number;
    set speed(newSpeed: number);
    get style(): RealtimeStyleFunction;
    set style(newStyle: RealtimeStyleFunction);
    get time(): Date;
    set time(newTime: Date | number);
    constructor(options: RealtimeEngineOptions);
    /**
     * Add a trajectory.
     * @param {RealtimeTrajectory} trajectory The trajectory to add.
     * @private
     */
    addTrajectory(trajectory: RealtimeTrajectory): void;
    attachToMap(): void;
    detachFromMap(): void;
    /**
     * Get the duration before the next update depending on zoom level.
     *
     * @private
     */
    getRefreshTimeInMs(): number;
    /**
     * Get vehicle.
     * @param {function} filterFc A function use to filter results.
     * @return {Array<Object>} Array of vehicle.
     */
    getVehicles(filterFc: FilterFunction): RealtimeTrajectory[];
    /**
     * Request feature information for a given coordinate.
     *
     * @param {ol/coordinate~Coordinate} coordinate Coordinate.
     * @param {Object} options Options See child classes to see which options are supported.
     * @param {number} [options.resolution=1] The resolution of the map.
     * @param {number} [options.nb=Infinity] The max number of vehicles to return.
     * @return {Promise<FeatureInfo>} Promise with features, layer and coordinate.
     */
    getVehiclesAtCoordinate(coordinate: Coordinate, options?: LayerGetFeatureInfoOptions): FeatureCollection;
    getViewState: () => ViewState;
    /**
     * Callback on websocket's deleted_vehicles channel events.
     * It removes the trajectory from the list.
     *
     * @private
     * @override
     */
    onDeleteTrajectoryMessage(data: WebSocketAPIMessageEventData<RealtimeTrainId>): void;
    onDocumentVisibilityChange(): void;
    /**
     * Callback on websocket's trajectory channel events.
     * It adds a trajectory to the list.
     *
     * @private
     */
    onTrajectoryMessage(data: WebSocketAPIMessageEventData<RealtimeTrajectory>): void;
    /**
     * On zoomend we adjust the time interval of the update of vehicles positions.
     *
     * @private
     */
    onZoomEnd(): void;
    /**
     * Remove all trajectories that are in the past.
     */
    purgeOutOfDateTrajectories(): void;
    /**
     * Determine if the trajectory is useless and should be removed from the list or not.
     * By default, this function exclude vehicles:
     *  - that have their trajectory outside the current extent and
     *  - that aren't in the MOT list.
     *
     * @param {RealtimeTrajectory} trajectory
     * @return {boolean} if the trajectory must be displayed or not.
     * @private
     */
    purgeTrajectory(trajectory: RealtimeTrajectory): boolean;
    removeTrajectory(trajectoryOrId: RealtimeTrainId | RealtimeTrajectory): void;
    /**
     * Render the trajectories requesting an animation frame and cancelling the previous one.
     * This function must be overrided by children to provide the correct parameters.
     *
     * @param {boolean} noInterpolate If true trajectories are not interpolated but
     *   drawn at the last known coordinate. Use this for performance optimization
     *   during map navigation.
     * @private
     */
    renderTrajectories(noInterpolate?: boolean): void;
    /**
     * Launch renderTrajectories. it avoids duplicating code in renderTrajectories method.
     *
     * @param {object} viewState The view state of the map.
     * @param {number[2]} viewState.center Center coordinate of the map in mercator coordinate.
     * @param {number[4]} viewState.extent Extent of the map in mercator coordinates.
     * @param {number[2]} viewState.size Size ([width, height]) of the canvas to render.
     * @param {number} [viewState.rotation = 0] Rotation of the map to render.
     * @param {number} viewState.resolution Resolution of the map to render.
     * @param {boolean} noInterpolate If true trajectories are not interpolated but
     *   drawn at the last known coordinate. Use this for performance optimization
     *   during map navigation.
     * @private
     */
    renderTrajectoriesInternal(viewState: ViewState, noInterpolate?: boolean): boolean;
    setBbox(): void;
    shouldRender: () => boolean;
    start(): void;
    /**
     * Start the clock.
     * @private
     */
    startUpdateTime(): void;
    stop(): void;
    /**
     * Stop the clock.
     * @private
     */
    stopUpdateTime(): void;
    updateIdleState(): void;
}
export default RealtimeEngine;