ol-elevation-profile 2.0.1 → 2.1.0

package/dist/ol-elevation-profile.d.ts

@@ -0,0 +1,947 @@
+/**
+ * Synchronized elevation profile control for OpenLayers, rendered with d3.
+ *
+ * Reads elevation (Z) directly from 3D line geometries (`[lon, lat, z]`). A track without
+ * Z is completed from a terrain model - keyless AWS Terrain Tiles by default, which means
+ * the control fetches tiles on its own; set `dem: null` to keep it entirely offline.
+ * Clicking (or hovering) a track shows its profile; a marker stays synchronized on both
+ * the map and the chart.
+ *
+ * Peer dependencies (provided by the host application, not bundled):
+ *  - OpenLayers >= 6  (https://openlayers.org/)
+ *  - d3 >= 7          (https://d3js.org/)
+ *
+ * @module ol-elevation-profile
+ * @license MIT
+ */
+import Control from 'ol/control/Control.js';
+import Overlay from 'ol/Overlay.js';
+declare const THEMES: {
+    steelblue: {
+        area: string;
+        line: string;
+        axis: string;
+        text: string;
+        focus: string;
+    };
+    lime: {
+        area: string;
+        line: string;
+        axis: string;
+        text: string;
+        focus: string;
+    };
+    purple: {
+        area: string;
+        line: string;
+        axis: string;
+        text: string;
+        focus: string;
+    };
+    slate: {
+        area: string;
+        line: string;
+        axis: string;
+        text: string;
+        focus: string;
+    };
+    graphite: {
+        area: string;
+        line: string;
+        axis: string;
+        text: string;
+        focus: string;
+    };
+    amber: {
+        area: string;
+        line: string;
+        axis: string;
+        text: string;
+        focus: string;
+    };
+};
+declare const POSITIONS: string[];
+/**
+ * Known terrain-tile sources.
+ *
+ * A PNG tile carries elevation in its R/G/B channels; it is read on a canvas rather
+ * than queried point by point from an API. That is what makes a 10 000-point track a
+ * handful of requests, with no key, no quota and no rate limit, where the free
+ * elevation APIs cap out at 100 or 200 points per call.
+ *
+ * Attribution is not automatic: the library does not own the map. It is up to the
+ * application to carry `attributions` in its own basemap source - and since the DEM is
+ * on by default, that obligation arrives without having been asked for. `dem: null`
+ * turns the whole thing off.
+ */
+declare const DEM_PRESETS: {
+    terrarium: {
+        url: string;
+        encoding: string;
+        maxZoom: number;
+        attributions: string;
+    };
+    /**
+     * IGN Géoplateforme, serving the RGE ALTI over France and its overseas territories.
+     *
+     * A point API rather than tiles, hence its own sampler: it answers 200 points per
+     * request and announces one request per second, so a 10 000 point track takes about
+     * fifty calls spread over as many seconds. In exchange it is metre-accurate where the
+     * world models are at ninety.
+     *
+     * **No key is required** on the public endpoint - verified against the live service.
+     * `apiKey` exists for a deployment that does demand one; it is appended as a query
+     * parameter, named by `apiKeyParam`.
+     *
+     * Outside its coverage the service does not error: it answers OUT_OF_COVERAGE for the
+     * point. No border is coded here - one asks, and it says itself where it does not know.
+     */
+    ign: {
+        api: string;
+        url: string;
+        resource: string;
+        batch: number;
+        minInterval: number;
+        attributions: string;
+    };
+};
+/**
+ * Reads elevations from a set of terrain tiles.
+ *
+ * Positions are held in **world pixels** rather than tile by tile: the four neighbours
+ * of a point can fall in two different tiles whenever it runs along an edge, which is
+ * the common case on a track. Converting to world pixels first, then resolving the
+ * tile, makes the edge case disappear instead of handling it.
+ */
+declare class DemSampler {
+    cfg: any;
+    decode: any;
+    tileUrl: (z: any, x: any, y: any) => any;
+    tiles: Map<any, any>;
+    /** @param {Object} cfg `url`, `encoding`, `tileSize`, `concurrency`. */
+    constructor(cfg: any);
+    /**
+     * North-west neighbour of the point plus the interpolation fractions, in world pixels.
+     *
+     * The half-pixel subtracted is not a fudge: pixel centres fall on half-integers, and
+     * without that shift `floor()` would return the cell containing the point rather than
+     * its western neighbour, offsetting the whole profile by half a pixel.
+     */
+    _neighbours(lon: any, lat: any, z: any): {
+        i0: number;
+        j0: number;
+        tx: number;
+        ty: number;
+    };
+    /** Tile key of a world pixel; x wraps around the globe, y clamps at the poles. */
+    _key(i: any, j: any, z: any): {
+        key: string;
+        ii: number;
+        jj: number;
+    };
+    /** Elevation of one pixel, or null if its tile is missing. */
+    _at(i: any, j: any, z: any): any;
+    /**
+     * Elevation **bilinearly interpolated** between the four surrounding pixels; null as
+     * soon as a single one is missing.
+     *
+     * Bilinear rather than "the pixel containing the point": on a 30 or 90 m model, taking
+     * the pixel value makes the profile advance in stairs, and every stair counts as a
+     * climb then a descent in the ascent total. The interpolation invents no relief: it
+     * renders the same surface, without the steps of the sampling grid.
+     */
+    sample(lon: any, lat: any, z: any): any;
+    /** Keys of the tiles needed by the four neighbours of each of the points. */
+    tilesFor(lonlats: any, z: any): Set<any>;
+    /** Pixels of one tile, or null if it could not be read. */
+    _fetch(key: any): Promise<any>;
+    /**
+     * Loads the missing tiles, `concurrency` in flight. Resolves false if one is missing.
+     *
+     * Lost tiles are remembered as such: without that, a second pass over the same track
+     * would fire the same requests, doomed to fail again.
+     */
+    load(keys: any): Promise<boolean>;
+}
+export type ElevationProfileOptions = {
+    /**
+     * Panel placement strategy (floating is partial).
+     */
+    immersion?: 'docked' | 'floating';
+    /**
+     * Anchor on the map.
+     */
+    position?: 'top' | 'bottom' | 'left' | 'right' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    /**
+     * Width in px (capped to the map width), or full map width.
+     */
+    width?: number | 'auto' | '100%' | 'full';
+    /**
+     * Height in px.
+     */
+    height?: number;
+    /**
+     * Inner chart margins.
+     */
+    margins?: {
+        unit: ('px' | 'em' | 'rem');
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    /**
+     * Distance/elevation units.
+     */
+    units?: 'meters' | 'imperial';
+    /**
+     * Built-in theme name or a colors object.
+     */
+    theme?: string;
+    /**
+     * `null` = theme, `'auto'` = track color (area = color, darker line), or a CSS color.
+     */
+    color?: string | null;
+    /**
+     * Layer used to read the track color when `color:'auto'`.
+     */
+    trackLayer?: import('ol/layer/Vector').default | null;
+    /**
+     * `false`, `true` (= transparencyLevel), or alpha 0..1 (0 = fully transparent).
+     */
+    transparency?: boolean | number;
+    /**
+     * Background alpha when `transparency===true`.
+     */
+    transparencyLevel?: number;
+    /**
+     * Horizontal grid lines.
+     */
+    grid?: boolean;
+    /**
+     * Split the profile into slope-class colored portions.
+     */
+    slope?: boolean;
+    /**
+     * Slope class width, in percent.
+     */
+    slopeClassSize?: number;
+    /**
+     * Maximum number of slope classes (colors + legend).
+     */
+    maxClasses?: number;
+    /**
+     * `null` = blue-to-red ramp; otherwise an interpolated color array.
+     */
+    slopeColors?: string[] | null;
+    /**
+     * Vertical separator at each slope-class change.
+     */
+    slopeSeparators?: boolean;
+    /**
+     * Color legend under the title.
+     */
+    slopeLegend?: boolean;
+    /**
+     * Elevation smoothing window, in METERS (0 = none).
+     */
+    smoothing?: number;
+    /**
+     * X axis ticks (null = auto from width).
+     */
+    xTicks?: number | null;
+    /**
+     * Y axis ticks (null = auto from height).
+     */
+    yTicks?: number | null;
+    /**
+     * `'auto'`: the
+     * profile fills the height, which is legible but changes scale from one track to the
+     * next, so a 2 % ramp looks like a wall and two profiles cannot be compared. A number
+     * fixes the metres covered per physical centimetre, which makes RANGES comparable.
+     * `{exaggeration}` fixes the ratio between the two axes instead, which makes SLOPES
+     * comparable: the gradient read off the chart is the real one, multiplied by the same
+     * factor on every track, and the control recomputes it per track and per A/B crop.
+     * Either form is a **floor**, not a cage: a track whose range exceeds what the height
+     * can show would spill out of the frame, which is worse than losing comparability, so
+     * the scale then widens silently, nothing being drawn on the chart to say so.
+     */
+    verticalScale?: ('auto' | number | {
+        exaggeration: number;
+    });
+    /**
+     * How a track is selected on the map.
+     */
+    show?: 'click' | 'mouseover';
+    /**
+     * What to do with a track that ends up
+     * with no elevation at all: none in its geometry, and none the terrain model could
+     * supply either (`dem: null`, or a fill that failed). `true` shows the panel with the
+     * track's title and the `noElevation` message where the chart would be; `false` hides
+     * the panel outright. Either way no chart is drawn: a flat line at zero under a D+ of
+     * 0 m is not a missing figure, it is a wrong one.
+     */
+    showWithoutElevation?: boolean;
+    /**
+     * Click on empty map hides the profile.
+     */
+    hideOnMapClick?: boolean;
+    /**
+     * Show the collapse/expand button.
+     */
+    collapsable?: boolean;
+    /**
+     * Initial collapsed state.
+     */
+    collapsed?: boolean;
+    /**
+     * Hovering the map moves the chart indicator.
+     */
+    followMap?: boolean;
+    /**
+     * Show the position marker on the map.
+     */
+    marker?: boolean;
+    /**
+     * Adapt width/placement; mobile included.
+     */
+    responsive?: boolean;
+    /**
+     * Below this width: mobile mode (100% width, top/bottom only).
+     */
+    mobileBreakpoint?: number;
+    /**
+     * A/B buttons to crop map + profile to a sub-range.
+     */
+    zoom?: boolean;
+    /**
+     * Nested crops allowed: a crop can itself be cropped,
+     * down to this depth. `1` restores the former single level. A "back" button appears
+     * from the second level; "show all" empties the stack whatever the depth.
+     */
+    zoomLevels?: number;
+    /**
+     * Toolbar button exporting the whole panel as a PNG.
+     */
+    exportPng?: boolean;
+    /**
+     * When computing time, ignore stopped segments (moving time).
+     */
+    ignoreStops?: boolean;
+    /**
+     * Speed threshold (m/s) below which a segment counts as a stop.
+     */
+    stopSpeed?: number;
+    /**
+     * Tooltip content (`'time'` = elapsed time at the cursor, if the track has time data).
+     */
+    tooltipItems?: Array<'distance' | 'elevation' | 'slope' | 'time'>;
+    /**
+     * Header content (string tokens: distance, ascent, descent, min, max, minmax, `'duration'` = total elapsed time).
+     */
+    headerItems?: Array<string | {
+        property: string;
+        label?: string;
+        asLink?: boolean;
+        linkText?: string;
+    }>;
+    /**
+     * Language of the shipped labels. An unknown
+     * code falls back to English rather than leaving keys empty.
+     */
+    lang?: ('en' | 'fr' | 'es');
+    /**
+     * Per-key overrides applied on top of `lang`. They survive
+     * a later language change, so a corrected key stays corrected.
+     */
+    labels?: any;
+    /**
+     * Feature property used as the title,
+     * or a list of them tried in order - the first one holding a value wins. A feature with
+     * none falls back on the `untitled` label.
+     */
+    titleProperty?: (string | string[]);
+    /**
+     * Feature property holding a URL, which
+     * makes the title a link, or a list tried in order - the first one holding an actual
+     * URL wins, so a property carrying something else is stepped over rather than rendered
+     * as a broken link. `null`, the default, never links the title: a dataset is not asked
+     * to explain that its `url` column is not the one meant for the reader.
+     */
+    titleLink?: (string | string[]) | null;
+    /**
+     * Decimation for render/interaction (stats use full data).
+     */
+    maxPoints?: number;
+    /**
+     * Projection of the feature coordinates.
+     */
+    dataProjection?: (import('ol/proj/Projection').default | null) | string;
+    /**
+     * Fill missing elevations
+     * from a terrain model. Sources: `'terrarium'` (default) or `true` = AWS Terrain Tiles;
+     * `'ign'` = IGN Géoplateforme RGE ALTI (France, keyless, `apiKey` optional);
+     * `{url}` = XYZ template; `{wms:{url,layers,params}}` = WMS tiles;
+     * `{olSource}` = any `ol/source/TileImage` (XYZ, TileWMS, and so on);
+     * `{featureInfo:{url,layers,property}}` = WMS GetFeatureInfo, one request per point,
+     * for a greyscale coverage that cannot be decoded from its pixels (slow);
+     * `{track:{url,coords,parse,fetchOptions}}` = a profile the application computed
+     * beforehand and serves per track, `url` being a `{property}` template read off the
+     * feature (or a function). Unlike every other source it answers with the whole track:
+     * `[[lon,lat,z],…]` replaces the geometry, so a decimated profile is accepted, while a
+     * plain `[z,…]` still lines up with the geometry's own points;
+     * a function or `{sample}` `(lonlats, ctx) => number[]|Promise<number[]>` to source them
+     * yourself; `null` disables the whole thing.
+     * Decoding: `encoding` is `'terrarium'`, `'mapbox'`, or a function `(r,g,b,a) => metres`.
+     */
+    dem?: (boolean | string | Function | any) | null;
+};
+/**
+ * @typedef {Object} ElevationProfileOptions
+ * @property {'docked'|'floating'} [immersion='docked'] Panel placement strategy (floating is partial).
+ * @property {'top'|'bottom'|'left'|'right'|'top-left'|'top-right'|'bottom-left'|'bottom-right'} [position='bottom'] Anchor on the map.
+ * @property {number|'auto'|'100%'|'full'} [width=520] Width in px (capped to the map width), or full map width.
+ * @property {number} [height=180] Height in px.
+ * @property {{unit:('px'|'em'|'rem'),top:number,right:number,bottom:number,left:number}} [margins] Inner chart margins.
+ * @property {'meters'|'imperial'} [units='meters'] Distance/elevation units.
+ * @property {string} [theme='steelblue'] Built-in theme name or a colors object.
+ * @property {?string} [color=null] `null` = theme, `'auto'` = track color (area = color, darker line), or a CSS color.
+ * @property {?import('ol/layer/Vector').default} [trackLayer=null] Layer used to read the track color when `color:'auto'`.
+ * @property {boolean|number} [transparency=false] `false`, `true` (= transparencyLevel), or alpha 0..1 (0 = fully transparent).
+ * @property {number} [transparencyLevel=0.45] Background alpha when `transparency===true`.
+ * @property {boolean} [grid=true] Horizontal grid lines.
+ * @property {boolean} [slope=false] Split the profile into slope-class colored portions.
+ * @property {number} [slopeClassSize=2.5] Slope class width, in percent.
+ * @property {number} [maxClasses=8] Maximum number of slope classes (colors + legend).
+ * @property {?string[]} [slopeColors=null] `null` = blue-to-red ramp; otherwise an interpolated color array.
+ * @property {boolean} [slopeSeparators=true] Vertical separator at each slope-class change.
+ * @property {boolean} [slopeLegend=true] Color legend under the title.
+ * @property {number} [smoothing=0] Elevation smoothing window, in METERS (0 = none).
+ * @property {?number} [xTicks=null] X axis ticks (null = auto from width).
+ * @property {?number} [yTicks=null] Y axis ticks (null = auto from height).
+ * @property {('auto'|number|{exaggeration:number})} [verticalScale='auto'] `'auto'`: the
+ *   profile fills the height, which is legible but changes scale from one track to the
+ *   next, so a 2 % ramp looks like a wall and two profiles cannot be compared. A number
+ *   fixes the metres covered per physical centimetre, which makes RANGES comparable.
+ *   `{exaggeration}` fixes the ratio between the two axes instead, which makes SLOPES
+ *   comparable: the gradient read off the chart is the real one, multiplied by the same
+ *   factor on every track, and the control recomputes it per track and per A/B crop.
+ *   Either form is a **floor**, not a cage: a track whose range exceeds what the height
+ *   can show would spill out of the frame, which is worse than losing comparability, so
+ *   the scale then widens silently, nothing being drawn on the chart to say so.
+ * @property {'click'|'mouseover'} [show='click'] How a track is selected on the map.
+ * @property {boolean} [showWithoutElevation=true] What to do with a track that ends up
+ *   with no elevation at all: none in its geometry, and none the terrain model could
+ *   supply either (`dem: null`, or a fill that failed). `true` shows the panel with the
+ *   track's title and the `noElevation` message where the chart would be; `false` hides
+ *   the panel outright. Either way no chart is drawn: a flat line at zero under a D+ of
+ *   0 m is not a missing figure, it is a wrong one.
+ * @property {boolean} [hideOnMapClick=true] Click on empty map hides the profile.
+ * @property {boolean} [collapsable=true] Show the collapse/expand button.
+ * @property {boolean} [collapsed=false] Initial collapsed state.
+ * @property {boolean} [followMap=true] Hovering the map moves the chart indicator.
+ * @property {boolean} [marker=true] Show the position marker on the map.
+ * @property {boolean} [responsive=true] Adapt width/placement; mobile included.
+ * @property {number} [mobileBreakpoint=640] Below this width: mobile mode (100% width, top/bottom only).
+ * @property {boolean} [zoom=false] A/B buttons to crop map + profile to a sub-range.
+ * @property {number} [zoomLevels=3] Nested crops allowed: a crop can itself be cropped,
+ *   down to this depth. `1` restores the former single level. A "back" button appears
+ *   from the second level; "show all" empties the stack whatever the depth.
+ * @property {boolean} [exportPng=false] Toolbar button exporting the whole panel as a PNG.
+ * @property {boolean} [ignoreStops=true] When computing time, ignore stopped segments (moving time).
+ * @property {number} [stopSpeed=0.5] Speed threshold (m/s) below which a segment counts as a stop.
+ * @property {Array<'distance'|'elevation'|'slope'|'time'>} [tooltipItems=['distance','elevation']] Tooltip content (`'time'` = elapsed time at the cursor, if the track has time data).
+ * @property {Array<string|{property:string,label?:string,asLink?:boolean,linkText?:string}>} [headerItems] Header content (string tokens: distance, ascent, descent, min, max, minmax, `'duration'` = total elapsed time).
+ * @property {('en'|'fr'|'es')} [lang='en'] Language of the shipped labels. An unknown
+ *   code falls back to English rather than leaving keys empty.
+ * @property {Object} [labels={}] Per-key overrides applied on top of `lang`. They survive
+ *   a later language change, so a corrected key stays corrected.
+ * @property {(string|string[])} [titleProperty='name'] Feature property used as the title,
+ *   or a list of them tried in order - the first one holding a value wins. A feature with
+ *   none falls back on the `untitled` label.
+ * @property {?(string|string[])} [titleLink=null] Feature property holding a URL, which
+ *   makes the title a link, or a list tried in order - the first one holding an actual
+ *   URL wins, so a property carrying something else is stepped over rather than rendered
+ *   as a broken link. `null`, the default, never links the title: a dataset is not asked
+ *   to explain that its `url` column is not the one meant for the reader.
+ * @property {number} [maxPoints=2000] Decimation for render/interaction (stats use full data).
+ * @property {?import('ol/proj/Projection').default|string} [dataProjection=null] Projection of the feature coordinates.
+ * @property {?(boolean|string|Function|Object)} [dem='terrarium'] Fill missing elevations
+ *   from a terrain model. Sources: `'terrarium'` (default) or `true` = AWS Terrain Tiles;
+ *   `'ign'` = IGN Géoplateforme RGE ALTI (France, keyless, `apiKey` optional);
+ *   `{url}` = XYZ template; `{wms:{url,layers,params}}` = WMS tiles;
+ *   `{olSource}` = any `ol/source/TileImage` (XYZ, TileWMS, and so on);
+ *   `{featureInfo:{url,layers,property}}` = WMS GetFeatureInfo, one request per point,
+ *   for a greyscale coverage that cannot be decoded from its pixels (slow);
+ *   `{track:{url,coords,parse,fetchOptions}}` = a profile the application computed
+ *   beforehand and serves per track, `url` being a `{property}` template read off the
+ *   feature (or a function). Unlike every other source it answers with the whole track:
+ *   `[[lon,lat,z],…]` replaces the geometry, so a decimated profile is accepted, while a
+ *   plain `[z,…]` still lines up with the geometry's own points;
+ *   a function or `{sample}` `(lonlats, ctx) => number[]|Promise<number[]>` to source them
+ *   yourself; `null` disables the whole thing.
+ *   Decoding: `encoding` is `'terrarium'`, `'mapbox'`, or a function `(r,g,b,a) => metres`.
+ */
+/**
+ * Elevation profile control.
+ * @extends {import('ol/control/Control').default}
+ *
+ * @example
+ * const profile = new OlElevationProfile({ theme: 'steelblue', color: 'auto', trackLayer });
+ * map.addControl(profile);
+ * profile.setFeature(feature); // feature with a 3D LineString geometry
+ */
+declare class ElevationProfile extends Control {
+    options: {};
+    _userLabels: any;
+    slopeColors: any;
+    _feature: import("ol/Feature").default<import("ol/geom").Geometry, {
+        [x: string]: any;
+    }>;
+    _fullSamples: any;
+    _fullStats: {
+        distance: number;
+        duration: number;
+        ascent: number;
+        descent: number;
+        min: number;
+        max: number;
+        maxAbsSlope: number;
+        points: any;
+    };
+    _samples: any;
+    _stats: {
+        distance: number;
+        duration: number;
+        ascent: number;
+        descent: number;
+        min: number;
+        max: number;
+        maxAbsSlope: number;
+        points: any;
+    };
+    _marker: Overlay;
+    _collapsed: boolean;
+    _crops: any[];
+    _off: number;
+    _zoomA: any;
+    _zoomB: any;
+    _armed: any;
+    _demZ: any[];
+    _demFor: any;
+    _demSeq: number;
+    _demLoading: boolean;
+    _trackLines: any[][];
+    _linesFor: any;
+    _onResize: () => void;
+    _titleEl: HTMLSpanElement;
+    _statsEl: HTMLSpanElement;
+    _toolbar: HTMLSpanElement;
+    _btnA: HTMLButtonElement;
+    _btnB: HTMLButtonElement;
+    _btnBack: HTMLButtonElement;
+    _btnAll: HTMLButtonElement;
+    _btnPng: HTMLButtonElement;
+    _toggleBtn: HTMLButtonElement;
+    _legendEl: HTMLDivElement;
+    _body: HTMLDivElement;
+    themeColors: any;
+    _mapKeys: any[];
+    _hasTime: boolean;
+    _vScale: number;
+    _vExaggeration: number;
+    _x: any;
+    _y: any;
+    _dims: {
+        innerW: number;
+        innerH: number;
+    };
+    _focus: any;
+    /** @param {ElevationProfileOptions} [opts] */
+    constructor(opts?: ElevationProfileOptions);
+    /** Recadré dès qu'un niveau est empilé. Lu partout où le booléen l'était. */
+    get _cropMode(): boolean;
+    /** Profondeur courante ; 0 quand on voit la trace entière. */
+    get _cropDepth(): number;
+    /** Niveaux imbriqués autorisés, au moins un. */
+    get _cropMax(): number;
+    /**
+     * Whether a feature has any Z (elevation) coordinate.
+     * @param {import('ol/Feature').default} feature
+     * @returns {boolean}
+     */
+    static featureHasZ(feature: import('ol/Feature').default): boolean;
+    /**
+     * Whether a feature carries per-point time data (coordTimes / XYZM).
+     * @param {import('ol/Feature').default} feature
+     * @returns {boolean}
+     */
+    static featureHasTime(feature: import('ol/Feature').default): boolean;
+    _buildDom(root: any): void;
+    /**
+     * Reporte les libellés courants sur ce que le rendu ne réécrit pas.
+     *
+     * Les boutons et le bouton de repli sont construits une fois pour toutes ; sans cela,
+     * changer de langue ne toucherait que le graphe et laisserait les infobulles dans
+     * l'ancienne. Le titre n'est repris que faute de tracé : sinon il porte le nom du tracé,
+     * qui n'est pas un libellé de la librairie.
+     */
+    _applyLabels(): void;
+    /**
+     * Le bouton de repli dit ce qu'il va faire, non ce qu'il montre.
+     *
+     * Un seul libellé pour les deux états ("réduire ou agrandir") laisse deviner lequel
+     * des deux le clic déclenche ; l'icône, elle, a déjà basculé. Le titre suit donc l'état,
+     * et l'infobulle visible dit la même chose que le nom accessible.
+     */
+    _applyToggleLabel(): void;
+    _resolveColor(): any;
+    _featureColor(): string;
+    _applyTheme(): void;
+    _applyTransparency(): void;
+    _applyCollapsable(): void;
+    /** @param {boolean} [force] Force collapsed (true) or expanded (false). */
+    toggleCollapsed(force?: boolean): void;
+    _availWidth(): number;
+    _isMobile(): boolean;
+    _applyPlacement(): boolean;
+    _adjustAttribution(): void;
+    setMap(map: any): void;
+    /**
+     * Show the profile for the given feature (LineString, MultiLineString, or a Polygon /
+     * MultiPolygon profiled along its outer ring), ideally 3D.
+     * Passing a falsy value hides the control.
+     * @param {?import('ol/Feature').default} feature
+     * @returns {this}
+     */
+    setFeature(feature: import('ol/Feature').default | null): this;
+    /** Hide the profile and clear the current feature. @returns {this} */
+    clear(): this;
+    /**
+     * @returns {?{distance:number,duration:?number,ascent:number,descent:number,min:number,max:number,maxAbsSlope:number,points:number}}
+     * `duration` is `null` when the track carries no time data.
+     */
+    getStats(): {
+        distance: number;
+        duration: number | null;
+        ascent: number;
+        descent: number;
+        min: number;
+        max: number;
+        maxAbsSlope: number;
+        points: number;
+    } | null;
+    /** @param {string|Object} t Theme name or colors object. @returns {this} */
+    setTheme(t: string | any): this;
+    /** @param {?string} c CSS color, `'auto'`, or `null` (theme). @returns {this} */
+    setColor(c: string | null): this;
+    /**
+     * Update one or more options at runtime and re-render.
+     * @param {Partial<ElevationProfileOptions>} patch
+     * @returns {this}
+     */
+    setOptions(patch: Partial<ElevationProfileOptions>): this;
+    /**
+     * Fills the missing elevations from a terrain model, then redraws.
+     *
+     * **A track is filled entirely or not at all.** A profile missing a few points is not
+     * an incomplete profile: points without Z count as zero, the line dives to sea level
+     * and the ascent total becomes absurd. Better the flat profile we would have had
+     * without the DEM.
+     *
+     * Nothing is reported to the user on failure: the fill is a supplement, it has no
+     * business breaking a display that succeeded without it. The `demload` event lets the
+     * application know if it wants to.
+     *
+     * @param {import('ol/Feature').default} feature
+     * @fires demload
+     * @private
+     */
+    private _fillFromDem;
+    /** @private */
+    private _startFill;
+    /**
+     * Va chercher un profil déjà calculé, que l'application tient prêt pour cette trace.
+     *
+     * Les dix autres sources échantillonnent un modèle de terrain aux points de la trace.
+     * Celle-ci ne fait rien de tel : elle demande à l'application le profil qu'elle a déjà,
+     * calculé une fois à l'ingestion sur le modèle qu'elle voulait, décimé comme elle
+     * l'entendait. C'est le cas d'une application qui a fait son altimétrie en amont et ne
+     * veut ni la refaire dans le navigateur ni dépendre d'un service au clic.
+     *
+     * La réponse peut prendre deux formes, et elles ne veulent pas dire la même chose :
+     * un tableau de nombres est une altitude par point de la géométrie, qui rejoint le
+     * chemin ordinaire ; un tableau de triplets `[lon, lat, z]` porte SA propre géométrie
+     * et remplace celle de la trace, ce qui est le seul moyen d'accepter un profil décimé.
+     *
+     * @private
+     */
+    private _startTrackFill;
+    /**
+     * Adopte un profil précalculé, sous l'une ou l'autre de ses deux formes.
+     *
+     * Un triplet incomplet fait tout refuser, par la même règle que `_demDone` : un profil
+     * auquel il manque des points n'est pas un profil incomplet, c'est un profil faux.
+     *
+     * @fires demload
+     * @private
+     */
+    private _trackDone;
+    /**
+     * Outcome of a fill, whatever produced it: adopt the elevations, drop the spinner,
+     * redraw, announce.
+     *
+     * A result of the wrong length is refused outright rather than padded. Elevations one
+     * can no longer map to their points are worse than absent ones: they would land on the
+     * wrong places, and nothing downstream would notice.
+     *
+     * @fires demload
+     * @private
+     */
+    private _demDone;
+    _compute(): void;
+    /**
+     * Pixels CSS d'un centimètre physique, mesurés plutôt que déduits.
+     *
+     * Le rapport nominal est de 96 px par pouce, soit 37,8 px par centimètre, mais le zoom
+     * du navigateur le déplace : mesurer un élément d'un centimètre suit ce zoom là où une
+     * constante mentirait. Non mémorisé - la mesure force un calcul de disposition, mais un
+     * rendu est rare et un cache se périmerait au premier Ctrl+molette.
+     */
+    _pxPerCm(): number;
+    /**
+     * Échelle verticale du graphe.
+     *
+     * En `'auto'`, le profil remplit la hauteur : c'est lisible, mais l'échelle change d'une
+     * trace à l'autre, si bien qu'une pente de 2 % y prend l'allure d'un mur et que deux
+     * profils ne se comparent pas. Un nombre fixe au contraire les mètres couverts par
+     * centimètre physique.
+     *
+     * La valeur demandée est un **plancher**, non un carcan : une trace dont l'amplitude
+     * dépasse ce que la hauteur peut montrer déborderait du cadre, ce qui est pire que de
+     * perdre la comparabilité. Le graphe n'en dit rien : l'échelle n'est pas une donnée de
+     * la trace et n'a pas à encombrer le dessin ; l'échelle réellement appliquée est
+     * seulement publiée dans `_vScale`, à qui veut la connaître.
+     *
+     * `nice()` n'est pas appliqué en échelle absolue : il arrondit le domaine vers
+     * l'extérieur, donc il fausserait le rapport qu'on vient de fixer.
+     */
+    _yScale(s: any, zpad: any, innerH: any, innerW: any): any;
+    /**
+     * Les mètres par centimètre demandés, sous l'une ou l'autre forme de `verticalScale`.
+     *
+     * Une échelle absolue rend les AMPLITUDES comparables, pas les pentes : l'axe
+     * horizontal s'étire toujours sur toute la trace, si bien qu'une même pente de 5 %
+     * paraît trois fois plus raide sur une boucle de 3 km que sur une traversée de 30. Une
+     * exagération fixe le RAPPORT entre les deux axes : la pente lue sur le dessin est
+     * alors la pente réelle, multipliée par un facteur constant d'une trace à l'autre.
+     *
+     * Elle se calcule ici et pas chez l'appelant parce qu'elle demande deux choses que lui
+     * n'a pas : la largeur du graphe une fois les marges retirées, et la distance
+     * réellement affichée - celle du recadrage A/B en cours, non celle de la trace.
+     *
+     * @private
+     */
+    private _verticalScaleFor;
+    _statsOf(samples: any, fromTotal: any): {
+        distance: number;
+        duration: number;
+        ascent: number;
+        descent: number;
+        min: number;
+        max: number;
+        maxAbsSlope: number;
+        points: any;
+    };
+    _smooth(pts: any, meters: any): void;
+    _decimate(pts: any, maxPoints: any): any;
+    _addSlope(samples: any): void;
+    _slopeScale(): {
+        classSize: any;
+        maxIdx: number;
+        capped: boolean;
+        colorByIndex: any;
+    };
+    _classIndex(slope: any, sc: any): number;
+    _fmtDuration(sec: any): string;
+    /**
+     * Track title, and its optional link.
+     *
+     * Its own method because it is the only part of the header that stays visible once
+     * collapsed: the CSS hides the body, the stats, the legend and the toolbar. `_render`
+     * is skipped while collapsed, so without a separate entry point the title would keep
+     * naming the previous track after a change of feature.
+     */
+    /**
+     * Cette trace a-t-elle une altitude, d'où qu'elle vienne ?
+     *
+     * Trois sources possibles, et une seule suffit : le Z de la géométrie, les altitudes
+     * rapportées par un modèle de terrain, ou le profil précalculé d'une source `track`.
+     * Aucune des trois, et il n'y a rien à dessiner - ce qui ne veut pas dire zéro.
+     *
+     * @private
+     */
+    private _hasElevation;
+    /**
+     * Ce qui prend la place du graphe quand la trace n'a aucune altitude.
+     *
+     * Même forme que le spinner, et pour la même raison : la hauteur du graphe est tenue,
+     * si bien que le panneau ne saute pas si un profil finit par arriver. Le titre reste,
+     * lui : c'est la trace cliquée, et l'utilisateur a besoin de savoir laquelle.
+     *
+     * @private
+     */
+    private _renderNoElevation;
+    /**
+     * La première propriété qui répond, parmi celles proposées.
+     *
+     * Un nom de propriété unique reste un nom de propriété unique ; une liste est essayée
+     * dans l'ordre. `garde` filtre ce qu'on accepte : n'importe quelle valeur non vide pour
+     * un titre, une URL véritable pour un lien - sans quoi une propriété `url` contenant
+     * autre chose ferait un lien mort plutôt que pas de lien du tout.
+     *
+     * @private
+     */
+    private _pickProperty;
+    _renderTitle(): void;
+    _renderHeader(sansAltimetrie: any): void;
+    /**
+     * Spinner shown in place of the chart while the terrain model loads.
+     *
+     * It keeps the chart's height so the panel does not jump when the profile replaces it,
+     * and it carries no colour of its own: the CSS takes `--oep-area`, which `_applyTheme`
+     * has just set - the theme colour, or the track colour under `color: 'auto'`.
+     */
+    _renderSpinner(): void;
+    _render(): void;
+    /**
+     * Properties frozen onto the exported clone.
+     *
+     * A serialized SVG carries no stylesheet: rules that live in the CSS file, and every
+     * `var(--oep-*)` they resolve, vanish the moment the markup leaves the document. The
+     * export would come out as black shapes on nothing. So the computed value of each
+     * painting property is written inline, node by node.
+     */
+    static get _EXPORT_PROPS(): string[];
+    /** Copies the computed painting styles of `src` onto `dst`, recursively. */
+    _freezeStyles(src: any, dst: any): void;
+    /**
+     * The whole panel as an SVG string: background, title, stats, legend, chart.
+     *
+     * Rebuilt rather than screenshotted. The header is HTML and the chart is SVG, and the
+     * only way to put HTML in an SVG is a `foreignObject`, which browsers refuse to
+     * rasterise consistently. Redrawing the two text lines as `<text>` is a handful of
+     * lines and works everywhere.
+     *
+     * The current-position indicator is dropped: it marks where the pointer happens to be,
+     * which means nothing once the image is saved.
+     */
+    _exportSvg(): {
+        width: number;
+        height: number;
+        svg: string;
+    };
+    /**
+     * Export the whole panel - title, stats, legend and chart - as a PNG.
+     *
+     * Resolves with the Blob. Unless `download` is false, it also saves the file, which is
+     * what the toolbar button does.
+     *
+     * @param {{scale?:number, filename?:string, download?:boolean}} [opts]
+     *   `scale` defaults to the device pixel ratio, so the image is not soft on a retina
+     *   screen. `filename` defaults to the track title.
+     * @returns {Promise<Blob>}
+     */
+    exportPNG(opts?: {
+        scale?: number;
+        filename?: string;
+        download?: boolean;
+    }): Promise<Blob>;
+    /** @private */
+    private _save;
+    _arm(which: any): void;
+    /**
+     * Pose la borne armée à l'abscisse [x0], puis arme l'autre tant qu'elle manque.
+     *
+     * Poser A n'a d'intérêt que pour poser B ensuite : enchaîner d'un clic sur l'autre
+     * évite l'aller-retour par la barre d'outils entre les deux. Les deux bornes réunies,
+     * le recadrage part et rien ne reste armé.
+     */
+    _placeBound(x0: any): void;
+    _updateZoomButtons(): void;
+    /**
+     * Recadre sur le sommet de la pile : échantillons, statistiques, origine des abscisses.
+     *
+     * Les bornes empilées sont gardées en abscisse de la trace **entière**, jamais dans le
+     * repère du niveau courant : sinon chaque cran se lirait dans celui du précédent et
+     * l'erreur de rebasage se composerait de niveau en niveau. Rend les coordonnées
+     * cartographiques du niveau, dont le cadrage a besoin.
+     */
+    _applyCrops(): any;
+    /** Cadre la carte sur un niveau, ou sur la trace entière si [coords] est nul. */
+    _fitMap(coords: any): any;
+    /** Empile un niveau. [a0] et [b0] sont lus dans le repère du niveau courant. */
+    _pushCrop(a0: any, b0: any): void;
+    /**
+     * Recadre sur A..B déjà posés. Conservé : c'était le point d'entrée du niveau unique,
+     * et le supprimer casserait ce qui l'appelle sans rien apporter.
+     */
+    _applyZoom(): void;
+    /** Remonte d'un niveau. */
+    _popCrop(): void;
+    /** Vide la pile d'un coup, quel que soit le nombre de niveaux. */
+    _exitZoom(): void;
+    /**
+     * Point of the profiled outline closest to a map coordinate.
+     *
+     * A polygon's own `getClosestPoint` answers for its **surface**: with the cursor inside
+     * the ring it returns the cursor itself, so the marker would follow the pointer across
+     * the whole shape instead of sliding along the outline. Lines keep the geometry's own
+     * answer, which is exact rather than limited to the decimated samples.
+     */
+    _closestOnProfile(coordinate: any): any;
+    /**
+     * Projeté d'une coordonnée sur la ligne brisée [data] : le point, et son abscisse
+     * curviligne dans le repère de [data].
+     *
+     * Retenir l'échantillon le plus proche ferait sauter le marqueur de sommet en sommet,
+     * l'écart entre deux points de trace étant souvent bien plus grand que le pas du
+     * pointeur. La projection sur les segments donne le point réellement visé.
+     */
+    _projectOn(data: any, coord: any): any;
+    _tooltipText(d: any): string;
+    _setFocus(d: any): void;
+    /**
+     * Point du profil à une abscisse quelconque, interpolé entre les deux échantillons qui
+     * l'encadrent.
+     *
+     * Se caler sur l'échantillon le plus proche ferait avancer le curseur de sommet en
+     * sommet : sur un tracé peu dense, ou décimé par `maxPoints`, le saut est franc et le
+     * survol perd sa continuité. Les échantillons sont les points *mesurés*, non les seules
+     * positions que le curseur ait le droit d'occuper.
+     *
+     * La pente n'est pas interpolée : `_addSlope` la pose sur le segment qui précède chaque
+     * échantillon, elle est donc constante sur ce segment et vaut celle de son extrémité.
+     * Le temps l'est, mais seulement si les deux bornes en portent un.
+     */
+    _sampleAt(x0: any): any;
+    /** Suit une coordonnée de la carte, projetée sur le tracé courant. */
+    _focusByCoord(coord: any): void;
+    _clearFocus(): void;
+    _clear(): void;
+}
+declare namespace ElevationProfile {
+    var addTheme: (name: string, colors: {
+        area: string;
+        line: string;
+        axis: string;
+        text: string;
+        focus: string;
+    }) => void;
+    export { THEMES };
+    export { DEM_PRESETS };
+    export { DemSampler };
+    export { POSITIONS };
+    export var version: string;
+}
+export default ElevationProfile;