@mapmap/maps 0.5.2 → 0.7.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import maplibregl, { CustomLayerInterface, Map, StyleSpecification, MapOptions, ExpressionSpecification } from 'maplibre-gl';
-export { DirectionIconName, DirectionIconStep, directionIconSvg, directionIcons, iconNameForManeuver, iconNameForStep } from './direction-icons.js';
+export { DirectionIconName, DirectionIconStep, directionIconSvg, directionIcons, iconNameForManeuver, iconNameForStep, iconNamesForSteps } from './direction-icons.js';
 
 /**
  * Shared public types for @mapmap/maps.
@@ -518,6 +518,26 @@ interface NavRouteDesign {
     opacity: number;
     /** Casing (outline) colour drawn under the line. */
     casingColor: string;
+    /**
+     * Casing width in px. Defaults to `width + 4`.
+     *
+     * Optional because the casing was previously always `width + 4`, which
+     * cannot express a design whose casing is not exactly four wider than
+     * its line (the playground's is 9 over a 4.5 line).
+     */
+    casingWidth?: number;
+    /**
+     * Casing opacity, 0-1. Defaults to {@link NavRouteDesign.opacity}.
+     *
+     * Optional because casing and line previously shared one opacity, which
+     * cannot express a translucent casing under a solid line.
+     */
+    casingOpacity?: number;
+    /**
+     * Line dash pattern, in line-widths, as MapLibre's `line-dasharray`.
+     * Omitted or `null` draws a solid line.
+     */
+    dash?: number[] | null;
 }
 /** Current-position puck tokens. */
 interface NavPuckDesign {
@@ -902,7 +922,8 @@ declare function navDesignFromThemeUrl(url: string, fetchImpl?: typeof fetch): P
  * and expression building. The class->category mapping mirrors
  * `website/lib/poi-icons.ts` (`POI_CLASS_CATEGORIES`). Keep them in sync so
  * a theme previews in Studio exactly as the SDK applies it. Not imported
- * from the website because the packages do not depend on each other.
+ * from the website because nothing here may depend on the website: the
+ * dependency runs the other way (the website installs `@mapmap/maps`).
  *
  * PUBLISH NOTE: the block travels with the THEME DOCUMENT, never with the
  * compiled `style.json`. The canonical `sn_style` crate stores `extra`
@@ -1089,7 +1110,24 @@ declare class MapMapMap {
     private effectGeometry;
     private effectExplicit;
     private effectLayer;
+    /** True while an effect re-apply is already queued behind the style. */
+    private effectWaiting;
+    private destroyed;
+    private readonly pendingWaits;
     constructor(options: MapMapOptions);
+    /**
+     * Run `action` as soon as the style can take layer edits, or now if it
+     * already can.
+     *
+     * Never wait on `load` alone: MapLibre fires it exactly once per map, so
+     * anything deferred after the first load is dropped for good - and
+     * `isStyleLoaded()` reports false for the whole of every `style.load`
+     * (the new style's sources are still loading) and whenever a source is
+     * loading afterwards. Waiting for whichever of `style.load` / `idle` /
+     * `load` arrives first covers the first load and every later style swap,
+     * and the listeners detach as soon as one fires (or on `destroy()`).
+     */
+    private whenStyleReady;
     private readonly handleStyleLoadForEffects;
     /** The current style's `metadata`, if it can be read yet. */
     private styleMetadata;
@@ -1147,24 +1185,450 @@ declare class MapMapMap {
      * (maplibre-native#4107 — fill-extrusion memory at street zooms).
      */
     setBuildings3d(enabled: boolean): void;
-    /** Resolves once the style and first tiles are loaded. */
+    /**
+     * Resolves once the style and first tiles are loaded.
+     *
+     * Safe to call at any point in the map's life, not just before its
+     * first load: `map.loaded()` goes false again whenever a source is
+     * loading (a theme swap, a pan into new tiles) while `load` only ever
+     * fires once, so this waits on `idle` too rather than hanging.
+     */
     whenReady(): Promise<void>;
-    /** Remove the map and release its WebGL context. */
+    /**
+     * Remove the map and release its WebGL context. Anything still queued
+     * behind a style load is dropped first, so nothing touches the map
+     * after this returns.
+     */
     destroy(): void;
 }
 /** Functional alias for {@link MapMapMap}, mirroring the Mapbox `new Map` feel. */
 declare function createMap(options: MapMapOptions): MapMapMap;
 
+/**
+ * GENERATED FILE — do not edit by hand.
+ *
+ * LOCKSTEP: identical copies of this module are emitted to
+ *   web-sdk/src/marker-icons.ts
+ *   website/lib/marker-icons.ts
+ * Source of truth: map-assets/icons/markers/*.svg
+ * Regenerate with:  node map-assets/icons/markers/generate.mjs
+ *
+ * Every glyph is 24x24 viewBox path data, drawn as a solid shape (nonzero
+ * fill rule; holes are reverse-wound subpaths) that reads clearly in white
+ * at 24 px. The pin body is the teardrop the coloured marker is drawn
+ * with: head centre (12, 9.4), radius 9, tip exactly at (12, 24) so an
+ * `icon-anchor: "bottom"` symbol anchors at the tip.
+ *
+ * The glyph-id list is the LOCKED `theme.extra.markers` v1 contract shared
+ * with MapMap Studio and the gateway's Rust validator — order and spelling
+ * must never drift.
+ */
+/** The 21 marker glyph ids of the `extra.markers` v1 contract, in order. */
+declare const MARKER_GLYPH_IDS: readonly ["pin", "dot", "star", "heart", "flag", "home", "work", "food", "cafe", "bar", "shop", "hotel", "parking", "fuel", "charging", "transit", "bike", "camera", "music", "warning", "info"];
+/** One marker glyph id (`"pin"`, `"star"`, `"fuel"`, ...). */
+type MarkerGlyphId = (typeof MARKER_GLYPH_IDS)[number];
+/** Whether `value` is one of the 21 marker glyph ids. */
+declare function isMarkerGlyphId(value: unknown): value is MarkerGlyphId;
+/** 24x24 viewBox SVG path data for every marker glyph, keyed by id. */
+declare const markerGlyphPaths: Record<MarkerGlyphId, string>;
+/**
+ * The coloured pin-body teardrop, 24x24 viewBox: head centre (12, 9.4),
+ * radius 9, tip at (12, 24). Every glyph except `dot` is drawn in white
+ * on top of this body, centred on the head.
+ */
+declare const MARKER_PIN_BODY_PATH = "M12 24C7 17.2 3 13.2 3 9.4a9 9 0 0 1 18 0C21 13.2 17 17.2 12 24Z";
+/** The glyph and pin-body coordinate space (a 24x24 viewBox). */
+declare const MARKER_GLYPH_VIEWBOX = 24;
+
+/**
+ * MarkersLayer - custom markers & labels from a Studio theme's
+ * `extra.markers` block (schema v1).
+ *
+ * A theme can carry up to 200 designed markers - coloured glyph pins, a
+ * plain dot, or a small custom image - each with an optional text label.
+ * This module renders that block on a MapLibre map: glyph markers are
+ * rasterised on an offscreen canvas at 2x (the `poi-icons` pattern) and
+ * registered via `map.addImage`; custom images are `data:` URIs capped at
+ * 64 KB (the `puck.ts` precedent). Everything draws from ONE GeoJSON
+ * source and ONE symbol layer, both id `mm-user-markers`, with per-feature
+ * `icon-image`, `icon-size`, `icon-anchor`, label and text sizing.
+ *
+ * LOCKSTEP: the schema, glyph set, image caps and cache-key format are a
+ * locked contract shared with MapMap Studio's markers panel and the
+ * gateway's Rust validator. Do not change ids, defaults or key formats
+ * here without coordinating all three.
+ *
+ * Like PlacesLayer, the layer survives `setStyle` (theme swaps) — but NOT
+ * because a diffed `setStyle` leaves it alone. `Style.serialize()` includes
+ * runtime-added sources and layers, so MapLibre's diff sees
+ * `mm-user-markers` in the old style and not in the new one and emits
+ * removeLayer/removeSource for it: EVERY theme swap tears this layer down.
+ * It comes back because `Style.setState` fires `style.load` after a
+ * successful diff as well as after a full reload, and this layer
+ * re-installs on that event. Do not "optimise" the re-install away.
+ * (Runtime IMAGES do survive a successful diff — only a full reload rebuilds
+ * the image registry — so `registerImages` is written to be idempotent.)
+ */
+
+/** One marker size preset. */
+type MarkerSize = "s" | "m" | "l";
+/** The marker size presets, smallest first. */
+declare const MARKER_SIZES: readonly ["s", "m", "l"];
+/** CSS pixel size of each marker preset (the rasterised square canvas). */
+declare const MARKER_SIZES_PX: Record<MarkerSize, number>;
+/** Label text size in px for each marker size preset. */
+declare const MARKER_LABEL_TEXT_SIZES: Record<MarkerSize, number>;
+/** Default marker colour (MapMap marker blue). */
+declare const MARKER_DEFAULT_COLOUR = "#1a6bff";
+/** Maximum accepted `data:` marker-image payload (matches the puck's cap). */
+declare const MAX_MARKER_IMAGE_BYTES: number;
+/** Maximum markers per theme (`extra.markers` v1 contract). */
+declare const MAX_MARKER_ITEMS = 200;
+/** Maximum marker `id` length (contract). */
+declare const MAX_MARKER_ID_LENGTH = 64;
+/** Maximum marker `label` length (contract). */
+declare const MAX_MARKER_LABEL_LENGTH = 120;
+/**
+ * Maximum characters drawn INSIDE a pin head by the short-text mode of
+ * {@link renderMarkerImage} (numbered waypoints `1`, `2`, `3`; lettered
+ * stops `A`, `B`). Anything longer belongs in a `label` below the pin.
+ */
+declare const MAX_MARKER_TEXT_LENGTH = 3;
+/** The shared GeoJSON source id AND symbol layer id (contract). */
+declare const MARKERS_ID = "mm-user-markers";
+/** One parsed marker of an `extra.markers` v1 block. */
+interface MarkerItem {
+    /** Stable unique id, non-empty, at most 64 characters. */
+    id: string;
+    /** Longitude, degrees, [-180, 180]. */
+    lng: number;
+    /** Latitude, degrees, [-90, 90]. */
+    lat: number;
+    /** Glyph drawn on the pin (or the standalone `dot`). Default `"pin"`. */
+    icon: MarkerGlyphId;
+    /**
+     * Optional custom image (`data:` URI, png/jpeg/webp/svg+xml, at most
+     * 64 KB decoded). Overrides `icon`; an unusable image falls back to the
+     * default pin, never to nothing.
+     */
+    image?: string;
+    /** Pin colour, `#rrggbb` (normalised lowercase). Default `#1a6bff`. */
+    colour: string;
+    /** Size preset. Default `"m"` (32 CSS px). */
+    size: MarkerSize;
+    /** Optional label drawn below the marker, at most 120 characters. */
+    label?: string;
+}
+/** A parsed `extra.markers` block. */
+interface MarkersBlock {
+    /** Block schema version; currently always 1. */
+    version: 1;
+    /** The valid markers, in input order, capped at 200. */
+    items: MarkerItem[];
+}
+/**
+ * Cut a string to `max` UNICODE SCALARS (not UTF-16 code units). The Rust
+ * validator counts `chars()`, so a plain `slice` both rejected valid emoji
+ * strings and could cut a surrogate pair in half — and a lone surrogate
+ * fails `serde_json` with a JSON parse error instead of the friendly
+ * marker message. LOCKSTEP: the same helper exists in Studio's mirror.
+ */
+declare function truncateChars(text: string, max: number): string;
+/**
+ * A usable custom marker image, or `undefined`: a `data:` URI of an
+ * accepted image type (png/jpeg/webp/svg+xml) whose decoded payload is at
+ * most 64 KB. Oversized or foreign URIs are rejected - the marker falls
+ * back to its glyph pin (the `puck.ts` cap precedent).
+ */
+declare function markerImage(v: unknown): string | undefined;
+/**
+ * Lenient parse of an `extra.markers` value into a v1 block. A block whose
+ * `version` is not 1 (including a missing one) parses to NOTHING: the Rust
+ * validator requires exactly 1, so a version-less block that rendered here
+ * could never be published, and a future v2 block must not be silently
+ * drawn as v1 by an already-deployed SDK.
+ *
+ * Within a v1 block, invalid ITEMS are skipped (bad/missing id, duplicate
+ * id, out-of-range coordinates); invalid FIELDS on a valid item fall back
+ * to their defaults (unknown glyph -> `pin`, bad colour -> the default
+ * blue, bad size -> `m`, over-long labels truncated, unusable images
+ * dropped). Never throws on bad data - a hand-edited theme cannot break
+ * the map. At most 200 items survive.
+ */
+declare function parseMarkers(value: unknown): MarkersBlock;
+/**
+ * Reads and parses the `extra.markers` block from a Studio theme document.
+ * Returns `undefined` when the theme carries no markers block at all (so
+ * callers can tell "no markers" apart from "an empty designed set"); a
+ * present but malformed block parses leniently via {@link parseMarkers}.
+ */
+declare function markersFromTheme(theme: Theme | undefined | null): MarkersBlock | undefined;
+/**
+ * Fetches a hosted theme document and reads its `extra.markers` block -
+ * the same endpoint contract as `navDesignFromThemeUrl`:
+ *
+ * ```ts
+ * const markers = await markersFromThemeUrl(
+ *   "https://api.mapmap.ai/styles/midnight-fleet-a1b2c3/theme",
+ * );
+ * if (markers) new MarkersLayer(map, markers);
+ * ```
+ *
+ * Returns `undefined` when the theme carries no markers block; throws on
+ * network failure, a non-2xx response or a non-JSON body. Bad DATA never
+ * throws - invalid items are skipped by the lenient parser.
+ *
+ * @param fetchImpl Optional `fetch` replacement (tests, Node polyfills).
+ */
+declare function markersFromThemeUrl(url: string, fetchImpl?: typeof fetch): Promise<MarkersBlock | undefined>;
+/**
+ * `map.addImage` cache key for a rasterised glyph marker:
+ * `mm-marker-<icon>-<colour>-<size>` (contract format; the colour is the
+ * normalised lowercase `#rrggbb`). Identical markers share one image.
+ */
+declare function markerImageKey(icon: MarkerGlyphId, colour: string, size: MarkerSize): string;
+/**
+ * Normalise a short pin text: trimmed and cut to
+ * {@link MAX_MARKER_TEXT_LENGTH} characters, or `undefined` when nothing
+ * printable remains. Callers use `undefined` to mean "draw the glyph".
+ */
+declare function markerText(value: unknown): string | undefined;
+/**
+ * `map.addImage` cache key for a rasterised SHORT-TEXT marker:
+ * `mm-marker-text-<text>-<colour>-<size>`. Deliberately distinct from
+ * {@link markerImageKey} so glyph pins keep their existing keys unchanged.
+ */
+declare function markerTextImageKey(text: string, colour: string, size: MarkerSize): string;
+/**
+ * `map.addImage` cache key for a custom-image marker: the data URI is
+ * hashed (FNV-1a), so identical images share one registered copy no
+ * matter how many markers use them.
+ */
+declare function markerImageDataKey(dataUri: string): string;
+/** What {@link renderMarkerImage} returns, ready for `map.addImage`. */
+interface RenderedMarkerImage {
+    /** The rasterised marker, drawn at 2x. */
+    image: ImageData;
+    /** Pass to `addImage` so the marker displays at its CSS pixel size. */
+    pixelRatio: 2;
+}
+/** Options for {@link renderMarkerImage}. */
+interface RenderMarkerImageOptions {
+    /** Glyph to draw. Default `"pin"`. */
+    icon?: MarkerGlyphId;
+    /** Pin (or dot) colour. Default the marker blue. */
+    colour?: string;
+    /** Size preset. Default `"m"` (32 CSS px). */
+    size?: MarkerSize;
+    /**
+     * Short text (1-3 characters) drawn in white in the pin head INSTEAD of
+     * the glyph - numbered waypoints (`"1"`, `"2"`) and lettered stops
+     * (`"A"`, `"B"`). Longer strings are cut to
+     * {@link MAX_MARKER_TEXT_LENGTH}; blank strings fall back to the glyph.
+     * Text always draws the pin body, so `icon: "dot"` is ignored when text
+     * is given (a dot has no head to write in).
+     */
+    text?: string;
+}
+/**
+ * Rasterise one marker to `ImageData` for `map.addImage`, per the
+ * rendering contract: every glyph except `dot` is the coloured pin-body
+ * teardrop with the glyph drawn in white centred on the head (anchor the
+ * symbol `bottom` - the tip sits exactly on the canvas's bottom edge);
+ * `dot` is a coloured circle with a white outline (anchor `center`). The
+ * canvas is a square of twice the preset's CSS pixel size, returned with
+ * `pixelRatio: 2`.
+ *
+ * Passing `text` switches on the short-text mode: the same coloured pin
+ * body, with 1-3 white bold characters centred in the head (auto-shrunk to
+ * fit) in place of the glyph. That is what numbered waypoints and lettered
+ * stops are drawn with.
+ *
+ * Returns `null` where canvas 2D or `Path2D` is unavailable (never
+ * expected in a browser; keeps non-DOM environments safe, the
+ * `poi-icons.ts` pattern).
+ */
+declare function renderMarkerImage(options?: RenderMarkerImageOptions): RenderedMarkerImage | null;
+/** The generated MapLibre ids (see {@link MarkersLayer.ids}). */
+interface MarkersLayerIds {
+    /** The GeoJSON source id (`mm-user-markers`). */
+    source: string;
+    /** The symbol layer id (`mm-user-markers`). */
+    layer: string;
+}
+/** Options for {@link MarkersLayer}. */
+interface MarkersLayerOptions {
+    /**
+     * Called when a marker's custom image passes the schema (right media
+     * type, within the 64 KB cap) but MapLibre cannot rasterise it — most
+     * often an SVG with no intrinsic `width`/`height`, which `<img>` renders
+     * happily and `createImageBitmap` rejects. The marker keeps its glyph
+     * pin either way; this is the only way to TELL the user that the logo
+     * they can see in their editor will not be on the map.
+     */
+    onImageError?: (image: string, error: unknown) => void;
+}
+/**
+ * Draws a theme's custom markers & labels on a MapLibre map.
+ *
+ * ```ts
+ * const markers = await markersFromThemeUrl(themeUrl);
+ * if (markers) new MarkersLayer(map, markers);
+ * ```
+ *
+ * Registers every needed marker image (rasterised glyph pins are cached by
+ * `mm-marker-<icon>-<colour>-<size>`; custom images by data-URI hash),
+ * builds one GeoJSON feature per marker carrying its image key, label,
+ * precomputed `icon-size` ratio and anchor, and installs the single
+ * `mm-user-markers` source + symbol layer. Survives `setStyle` like
+ * PlacesLayer (re-installed on every `style.load`).
+ */
+declare class MarkersLayer {
+    private readonly map;
+    private readonly options;
+    private items;
+    private data;
+    private destroyed;
+    /**
+     * Bumped by {@link clear} (and {@link destroy}). An image load started
+     * before the bump resolves into a cleared layer, so its handler compares
+     * the generation it was started in and drops out — without this a
+     * pending `loadImage` would rebuild and RE-INSTALL the layer on a map the
+     * caller had already cleaned up.
+     */
+    private generation;
+    /** Custom images by cache key, once loaded (kept across style swaps). */
+    private readonly loadedImages;
+    /** Custom-image cache keys that failed to load (pin fallback, once). */
+    private readonly failedImages;
+    /** Custom-image cache keys with a load in flight. */
+    private readonly pendingImages;
+    /**
+     * Every `map.addImage` key this layer currently owns, so a rebuild can
+     * drop the ones nothing references any more and teardown removes exactly
+     * what it added (the RouteLayer endpoints pattern). Without it every
+     * icon/colour/size change leaked a 2x RGBA image — 25 KB per click at
+     * the 40px preset — and re-invalidated the sprite atlas.
+     */
+    private readonly registeredImageKeys;
+    constructor(map: MapMapMap | Map, markers?: MarkersBlock, options?: MarkersLayerOptions);
+    private readonly handleStyleLoad;
+    /**
+     * Replace the layer's markers with a parsed block (`undefined` or an
+     * empty block clears the map of markers but keeps the layer alive).
+     * Custom images load asynchronously: their markers render as default
+     * pins until the image arrives, then swap in place; a failed or
+     * oversized image keeps the pin fallback.
+     */
+    setMarkers(markers: MarkersBlock | undefined): void;
+    /** The layer's current markers. */
+    get current(): MarkerItem[];
+    /**
+     * The MapLibre source/layer ids - public API for escape-hatch styling.
+     * Both are the contract id `mm-user-markers`.
+     */
+    get ids(): MarkersLayerIds;
+    /**
+     * Rebuild the source data from the items and (re)install. Mirrors
+     * PlacesLayer's never-drop-an-update rule: once the source exists the
+     * data is applied immediately (even while `isStyleLoaded()` is
+     * transiently false mid-render); before first installation the latest
+     * data is stashed for the next `style.load`.
+     */
+    private rebuild;
+    /** Build one feature, kicking off the custom-image load if needed. */
+    private featureFor;
+    /** Load a custom `data:` image once; rebuild the features when done. */
+    private loadCustomImage;
+    /**
+     * Register every image the current features reference and drop the ones
+     * they no longer do (idempotent). Runtime images survive a diffed
+     * `setStyle` and are rebuilt after a full reload, so this runs on every
+     * install as well as every data rebuild.
+     */
+    private registerImages;
+    /** Add-or-update the images, source and layer on the current style. */
+    private install;
+    /**
+     * Remove the markers' layer, source and registered images from the map.
+     * Images are removed by the keys this layer REGISTERED, not by whatever
+     * `items` happens to hold now — deriving them from the items meant
+     * `setMarkers(undefined)` followed by `clear()`/`destroy()` removed
+     * nothing at all.
+     */
+    clear(): void;
+    /**
+     * Remove the markers and detach the style.load listener. Call when
+     * disposing of the layer (the map is left untouched). Any image load
+     * still in flight resolves into a no-op.
+     */
+    destroy(): void;
+}
+
 /**
  * RouteLayer - fetch an OSRM route from the MapMap gateway and draw it.
  *
  * The route request/parse logic lives in the pure `osrm` module; this class
  * owns the network call and the MapLibre source/layers (a signal-blue line
- * with a darker casing, matching the brand).
+ * with a darker casing, matching the brand), plus the optional overlays
+ * that hang off a drawn route: alternatives, ferry dashes, the manoeuvre
+ * arrow, average-speed corridors, and — with the `endpoints` option — the
+ * branded start/destination/waypoint markers, drawn as a symbol layer over
+ * their own source so they land in canvas exports and match the native
+ * SDKs.
  */
 
 /** MapMap brand signal blue (see website `--signal`). */
 declare const SIGNAL_BLUE = "#3a86ff";
+/**
+ * Runtime overrides for the drawn line, applied over the design or the
+ * built-in look. Every field is optional; omitted ones are left alone.
+ */
+interface RouteLineStyle {
+    /** Line colour. */
+    color?: string;
+    /** Dash pattern in line-widths, or `null` for solid. */
+    dash?: number[] | null;
+    /** Casing opacity, 0-1. Set 0 to hide the casing entirely. */
+    casingOpacity?: number;
+}
+/**
+ * One designed endpoint marker: a coloured pin (or dot) drawn from the
+ * shared marker rasteriser, optionally with a text label underneath.
+ */
+interface EndpointMarker {
+    /** Glyph drawn on the pin, or `"dot"` for a plain circle. */
+    icon?: MarkerGlyphId;
+    /**
+     * Short text (1-3 characters) drawn in the pin head INSTEAD of the
+     * glyph - `"A"`, `"B"`, `"1"`. Overrides `icon`.
+     */
+    text?: string;
+    /** Marker colour, any CSS colour the canvas accepts. */
+    colour?: string;
+    /** Size preset: `"s"` 24 px, `"m"` 32 px, `"l"` 40 px. */
+    size?: MarkerSize;
+    /** Optional caption drawn below the marker, with a white halo. */
+    label?: string;
+}
+/**
+ * How a route's start, end and intermediate waypoints are drawn. Every
+ * field is optional; `false` switches an endpoint off entirely.
+ */
+interface EndpointsDesign {
+    /** The first route coordinate. Default a green `dot`, size `m`. */
+    start?: EndpointMarker | false;
+    /** The last route coordinate. Default a signal-blue `pin`, size `m`. */
+    end?: EndpointMarker | false;
+    /** Every intermediate stop. Default a signal-blue `pin`, size `s`. */
+    waypoint?: EndpointMarker | false;
+    /**
+     * Draw each waypoint's 1-based index in its pin head (`1`, `2`, `3`)
+     * instead of the glyph. Default `true`. An explicit `waypoint.text`
+     * wins over the number.
+     */
+    numberWaypoints?: boolean;
+}
 interface RouteLayerOptions {
     /** Gateway base URL. Defaults to the map's `baseUrl` when given a map. */
     baseUrl?: string;
@@ -1191,6 +1655,51 @@ interface RouteLayerOptions {
      * route line"). Defaults to a dimmed grey.
      */
     progressColor?: string;
+    /** Casing colour for unselected alternative routes. */
+    alternativeCasingColor?: string;
+    /** Line colour for unselected alternative routes. */
+    alternativeColor?: string;
+    /** Colour of the ferry dashes drawn over the selected route. */
+    ferryColor?: string;
+    /**
+     * Branded start/end/waypoint markers on the drawn route. Off by default:
+     * a layer built without this option behaves exactly as it always has.
+     *
+     * `true` uses the brand defaults (green `dot` at the start, blue `pin`
+     * at the end, smaller numbered blue pins at each intermediate stop); an
+     * {@link EndpointsDesign} overrides any of them, and `false` on one
+     * endpoint drops just that one.
+     *
+     * The coordinates come from the route itself: first coordinate = start,
+     * last = end. Intermediate stops are remembered from
+     * {@link RouteLayer.routePath}'s via points, or set explicitly with
+     * {@link RouteLayer.setWaypoints} when drawing a route parsed elsewhere.
+     *
+     * These are symbol-layer markers, not DOM `maplibregl.Marker`s, so they
+     * appear in canvas exports and match the native SDKs.
+     */
+    endpoints?: boolean | EndpointsDesign;
+}
+/** The MapLibre ids a {@link RouteLayer} owns (see {@link RouteLayer.ids}). */
+interface RouteLayerIds {
+    /** GeoJSON source holding the route line. */
+    source: string;
+    /** Line layer drawn under the route (the darker casing). */
+    casing: string;
+    /** Line layer for the route itself. */
+    line: string;
+    /** GeoJSON source for the manoeuvre arrow. */
+    maneuverSource: string;
+    /** Symbol layer for the manoeuvre arrow. */
+    maneuver: string;
+    /** GeoJSON source for the average-speed corridors. */
+    corridorSource: string;
+    /** Line layer tinting the average-speed corridors. */
+    corridor: string;
+    /** GeoJSON source for the start/end/waypoint markers. */
+    endpointsSource: string;
+    /** Symbol layer drawing the start/end/waypoint markers. */
+    endpoints: string;
 }
 /** Draws MapMap routes on a MapLibre map. */
 declare class RouteLayer {
@@ -1208,22 +1717,69 @@ declare class RouteLayer {
     private readonly arrowImageId;
     private readonly corridorSourceId;
     private readonly corridorLayerId;
+    private readonly endpointsSourceId;
+    private readonly endpointsLayerId;
+    /** The resolved endpoint design, or `undefined` when switched off. */
+    private readonly endpoints;
+    /** Intermediate stops for the endpoint markers, `[lng, lat]` each. */
+    private waypoints;
+    /** Marker images this layer registered, so teardown can remove them. */
+    private readonly endpointImageKeys;
     private readonly design;
     private alertsDesign;
     private readonly progressColor;
+    private readonly altSourceId;
+    private readonly altCasingLayerId;
+    private readonly altLineLayerId;
+    private readonly ferrySourceId;
+    private readonly ferryLayerId;
+    private readonly altCasingColor;
+    private readonly altColor;
+    private readonly ferryColor;
     private lastRoute;
+    /** Unselected alternatives, drawn beneath the selected route. */
+    private alternatives;
+    /** Ferry legs of the selected route, drawn as dashes over its line. */
+    private ferrySegments;
+    private selectHandler;
+    /** Runtime paint override, re-applied after every style reload. */
+    private lineStyle;
     private progress;
     private maneuver;
     private corridors;
+    /**
+     * Monotonic id of the newest route request. A response only draws when it
+     * still owns this value - see {@link RouteLayer.routePath}.
+     */
+    private requestSeq;
+    /** Whether the alternative-line click listener is currently attached. */
+    private altClickBound;
     constructor(map: MapMapMap | Map, options?: RouteLayerOptions);
     private readonly handleStyleLoad;
+    /**
+     * The MapLibre source and layer ids this layer owns - public API for
+     * escape-hatch styling and layer ordering (`map.moveLayer`). All are
+     * derived from the `id` option (default `mapmap-route`).
+     */
+    get ids(): RouteLayerIds;
     /**
      * Route from `from` to `to` (with optional intermediate `via` points passed
      * through `options` is not supported here - pass a coordinate list to
      * {@link routePath} for that), draw the line, and return the parsed route.
      */
     route(from: LngLatLike, to: LngLatLike, options?: RouteOptions): Promise<ParsedRoute>;
-    /** Route through an ordered list of coordinates and draw the result. */
+    /**
+     * Route through an ordered list of coordinates and draw the result.
+     *
+     * Concurrent calls are ordered by ISSUE, not by arrival: only the newest
+     * request draws. A destination retyped while the first request is still in
+     * flight used to leave the map showing whichever response happened to land
+     * last, so a driver could be looking at the line to the address they had
+     * already replaced. Each caller still receives its own parsed route, so a
+     * caller that wants the data of a superseded request keeps getting it -
+     * only the drawing is suppressed. {@link RouteLayer.clear} likewise
+     * supersedes anything in flight.
+     */
     routePath(points: LngLatLike[], options?: RouteOptions): Promise<ParsedRoute>;
     /** The most recently drawn route, if any. */
     get current(): ParsedRoute | undefined;
@@ -1235,6 +1791,98 @@ declare class RouteLayer {
     draw(route: ParsedRoute): void;
     /** Add-or-update the source and layers for a route on the current style. */
     private install;
+    /**
+     * Set the intermediate stops drawn by the endpoint markers, in order.
+     * {@link routePath} fills these in from its own via points, so this is
+     * only needed when drawing a route parsed elsewhere (e.g. a route fetched
+     * by the app and handed to {@link draw}). An empty array clears them.
+     */
+    setWaypoints(waypoints: readonly LngLatLike[]): void;
+    /** The intermediate stops currently drawn, `[lng, lat]` each. */
+    get currentWaypoints(): [number, number][];
+    /**
+     * Build one Point feature per endpoint marker: start (first route
+     * coordinate), each waypoint in order, then end (last coordinate). The
+     * end is added last so it wins MapLibre's symbol-collision ordering when
+     * markers overlap on a short route.
+     */
+    private endpointFeatures;
+    /**
+     * Register every endpoint marker image the current features need
+     * (idempotent; `setStyle` wipes runtime images, so this runs on each
+     * install). Keys are remembered so teardown removes exactly what this
+     * layer added.
+     */
+    private registerEndpointImages;
+    /** Add-or-update the endpoint markers' source and symbol layer. */
+    private installEndpoints;
+    /** Remove the endpoint markers, their source and their images. */
+    private clearEndpoints;
+    /**
+     * Draw a bare line from coordinates, without a parsed OSRM route.
+     *
+     * {@link RouteLayer.draw} expects a {@link ParsedRoute} because it is
+     * normally fed by {@link RouteLayer.route}. Callers that already have
+     * geometry and nothing else — an agent tool result, a stored polyline,
+     * a hand-built preview — had to invent a `ParsedRoute` with zeroed
+     * distance and duration that `draw` never reads. This is that path,
+     * named honestly.
+     */
+    drawGeometry(coordinates: [number, number][]): void;
+    /**
+     * Draw a set of routes: one selected, the rest as dimmer alternatives
+     * beneath it. Offering alternatives is table stakes for a navigation UI,
+     * and the selected route keeps every feature of {@link RouteLayer.draw}
+     * (progress, manoeuvre arrow, corridors, route effects).
+     *
+     * Pass the index of the route to select; out-of-range values clamp to the
+     * first route. Calling with a single route is equivalent to `draw`, and
+     * calling with an empty array clears everything.
+     */
+    drawAlternatives(routes: ParsedRoute[], selectedIndex?: number): void;
+    /** Which alternatives are currently drawn, in the order given. */
+    get alternativeRoutes(): readonly ParsedRoute[];
+    /**
+     * Register a click handler for the alternative lines. The index is the
+     * position within the array last passed to
+     * {@link RouteLayer.drawAlternatives}, so a caller can re-issue that call
+     * with the new selection. Passing `undefined` removes the handler.
+     */
+    onSelectAlternative(handler: ((index: number) => void) | undefined): void;
+    /**
+     * Draw ferry legs of the selected route as dashes over its line, so water
+     * crossings do not read as driving.
+     *
+     * Supplied as explicit geometries rather than derived from the route,
+     * because `line-dasharray` cannot be data-driven: a ferry leg needs its
+     * own layer, and only the caller knows which parts of their route are
+     * ferries.
+     */
+    setFerrySegments(segments: [number, number][][]): void;
+    /** Remove the ferry dashes. */
+    clearFerrySegments(): void;
+    /** Add-or-update the alternative-route source and its two layers. */
+    private installAlternatives;
+    private readonly handleAlternativeClick;
+    /** Original array position of each drawn alternative, by its own index. */
+    private altOriginalIndices;
+    private removeAlternativeLayers;
+    /** Add-or-update the ferry-dash overlay above the selected route. */
+    private installFerry;
+    /**
+     * Override the drawn line's paint at runtime, over whatever the design or
+     * the built-in look set.
+     *
+     * Route styling is not always static: a route can be provisional, or a
+     * straight-line approximation that must not be mistaken for a surveyed
+     * one. That is a paint change on a route already drawn, so it belongs
+     * here rather than in the constructor's design.
+     *
+     * Overrides survive style reloads. Pass `{}` to clear them.
+     */
+    setLineStyle(style: RouteLineStyle): void;
+    /** Apply any runtime override; a no-op when the layers are absent. */
+    private applyLineStyle;
     /**
      * Sets how much of the route has been travelled, as a fraction in `[0, 1]`
      * of the line's length. The travelled part dims to `progressColor` (the
@@ -1275,7 +1923,11 @@ declare class RouteLayer {
     clearAlertCorridors(): void;
     /** Add-or-update the corridor source/layer for the current style. */
     private installCorridors;
-    /** Remove the route's layers and source from the map. */
+    /**
+     * Remove the route's layers and source from the map. Any route request
+     * still in flight is superseded, so a late response cannot redraw a route
+     * the caller has already cleared.
+     */
     clear(): void;
     /**
      * Remove the route and detach the layer's `style.load` listener. Call
@@ -1567,7 +2219,11 @@ interface UploadProbeOptions {
     backoffMs?: (attempt: number) => number;
     /** Injectable delay, for deterministic tests (default `setTimeout`). */
     sleep?: (ms: number) => Promise<void>;
-    /** Abort signal forwarded to fetch. */
+    /**
+     * Abort signal forwarded to fetch. Once it has aborted the retry loop
+     * stops immediately (an abort is a caller decision, not a transient
+     * failure) and the upload resolves `"gaveUp"`.
+     */
     signal?: AbortSignal;
 }
 /** The `/v1/probe` endpoint for a gateway origin (trailing slashes trimmed). */
@@ -1575,8 +2231,9 @@ declare function buildProbeUrl(baseUrl: string): string;
 /**
  * POST one probe body to `{baseUrl}/v1/probe` with a bearer key. Transient
  * failures (network or `5xx`) are retried with bounded backoff; permanent ones
- * (`400`/`403`/`501`) are not. Resolves with the terminal outcome and never
- * rejects, so a fire-and-forget `void uploadProbeBatch(...)` is safe.
+ * (`400`/`403`/`501`) are not, and neither is an aborted `signal`. Resolves
+ * with the terminal outcome and never rejects, so a fire-and-forget
+ * `void uploadProbeBatch(...)` is safe.
  *
  * @param body the string returned by `GuidanceSession.finishProbeJson()`.
  */
@@ -1645,6 +2302,33 @@ interface PlacesIcon {
     /** MapLibre `icon-size` scale factor. Defaults to `1`. */
     size?: number;
 }
+/**
+ * Options for the per-place name labels (see `PlacesLayerOptions.label`).
+ *
+ * The colour keys accept BOTH spellings: `colour`/`haloColour` (British,
+ * as first shipped) and `color`/`haloColor` (matching the sibling
+ * `color`/`clusterColor` options on {@link PlacesLayerOptions}). A
+ * dynamically built options object should not lose its labels' colours to
+ * a spelling mismatch. British wins if somehow both are given.
+ */
+interface PlacesLabelOptions {
+    /**
+     * Feature property holding the label text (see {@link Place.properties}
+     * for what is addressable). Defaults to `"name"` - every place carries
+     * its `name` there.
+     */
+    property?: string;
+    /** Text size in px. Defaults to `12`. */
+    size?: number;
+    /** Text colour. Defaults to a dark ink (`#333333`). Alias: `color`. */
+    colour?: string;
+    /** Text colour, American spelling of {@link PlacesLabelOptions.colour}. */
+    color?: string;
+    /** Halo colour behind the text. Defaults to white. Alias: `haloColor`. */
+    haloColour?: string;
+    /** Halo colour, American spelling of {@link PlacesLabelOptions.haloColour}. */
+    haloColor?: string;
+}
 /** Options for {@link PlacesLayer.nearestByDriveTime}. */
 interface NearestByDriveTimeOptions {
     /** How many places to return. Defaults to `1`. */
@@ -1688,8 +2372,29 @@ interface PlacesLayerOptions {
     /**
      * Custom pin image for unclustered places (a symbol layer instead of the
      * default circle). If the image fails to load, the circle look is used.
+     *
+     * Also accepts a record of images keyed by a feature-property value for
+     * per-place icons - e.g. `{ cafe: { url: … }, fuel: { url: … } }` picks
+     * an image per place from the property named by `iconProperty` (default
+     * `"kind"`). Places whose property value has no entry - or whose entry's
+     * image fails to load - keep the default circle look.
      */
-    icon?: PlacesIcon;
+    icon?: PlacesIcon | Record<string, PlacesIcon>;
+    /**
+     * Feature property that selects a per-place icon when `icon` is a
+     * record (ignored for a single icon). Defaults to `"kind"`. Set place
+     * `properties` values to the record's keys.
+     */
+    iconProperty?: string;
+    /**
+     * Per-place name labels beside the points. `true` labels every place
+     * with its `name`; an options object customises the property, size and
+     * colours (see {@link PlacesLabelOptions}). Labels are drawn in the map
+     * font with a halo, hide before they collide (`text-optional`), and
+     * only ever appear on unclustered points. Omit for no labels (today's
+     * behaviour).
+     */
+    label?: boolean | PlacesLabelOptions;
     /**
      * Fit the map to the places the first time they are set. Defaults to
      * `false` (the map view is left alone).
@@ -1723,6 +2428,13 @@ interface PlacesLayerIds {
     clusters: string;
     /** The cluster count badge layer id (only installed with `cluster: true`). */
     clusterCounts: string;
+    /** The labels symbol layer id (only installed with a `label` option). */
+    labels: string;
+    /**
+     * The circle layer drawn under places without a loaded per-place icon
+     * (only installed when `icon` is a record of images).
+     */
+    pointsFallback: string;
 }
 /** Options for {@link PlacesLayer.select}. */
 interface PlacesSelectOptions {
@@ -1756,13 +2468,20 @@ declare class PlacesLayer {
     private readonly clustersLayerId;
     private readonly clusterCountLayerId;
     private readonly pointsLayerId;
+    private readonly pointsFallbackLayerId;
+    private readonly labelsLayerId;
     private readonly iconImageId;
     private readonly cluster;
     private readonly clusterRadius;
     private readonly clusterMaxZoom;
     private readonly color;
     private readonly clusterColor;
-    private readonly icon;
+    private readonly singleIcon;
+    private readonly iconRecord;
+    private readonly iconProperty;
+    private readonly label;
+    /** Per-place icon keys whose image failed to load (circle fallback). */
+    private readonly failedIconKeys;
     private readonly wantFitBounds;
     private readonly onPlaceClick;
     private readonly popupFn;
@@ -1826,6 +2545,11 @@ declare class PlacesLayer {
      * attached; unreachable places (`null` duration) are dropped. Needs the
      * gateway `baseUrl`/`apiKey` - picked up from a `MapMapMap` automatically,
      * or pass them as layer options.
+     *
+     * Answers always describe the places that were asked about: the list is
+     * snapshotted at call time, so a `setPlaces` landing mid-flight (a
+     * search-as-you-type filter, say) cannot mis-pair the matrix rows with a
+     * different set of places.
      */
     nearestByDriveTime(origin: {
         lat: number;
@@ -1833,6 +2557,13 @@ declare class PlacesLayer {
     }, options?: NearestByDriveTimeOptions): Promise<PlaceWithDriveTime[]>;
     /** Add-or-update the source and layers on the current style. */
     private install;
+    /**
+     * The per-place name labels layer (only with a `label` option): the map
+     * font with a halo, anchored just below each unclustered point, hidden
+     * before colliding (`text-optional`). Re-installed with the rest of the
+     * layers on every `style.load`.
+     */
+    private installLabelsLayer;
     /** Cluster circles (sized by count) and the count badge on top. */
     private installClusterLayers;
     /**
@@ -1841,6 +2572,17 @@ declare class PlacesLayer {
      * circle look if it fails, like PositionPuck's image fallback).
      */
     private installPointsLayer;
+    /** The `map.addImage` id for one key of the per-place icon record. */
+    private iconImageIdFor;
+    /**
+     * Per-place icon mode: load every record image (each key independently -
+     * one bad URL never sinks the rest), then install a symbol layer whose
+     * `icon-image` is a match expression on `iconProperty`, plus a circle
+     * fallback layer for places whose property value has no loaded icon.
+     */
+    private installPerPlaceIconLayers;
+    /** Install the per-place icon symbol layer + circle fallback layer. */
+    private addPerPlaceLayers;
     private addCirclePointsLayer;
     private addIconPointsLayer;
     /** Open the built-in popup for a place, replacing any previous one. */
@@ -2177,7 +2919,15 @@ declare class IsochroneLayer {
     showReachability(options: ShowReachabilityOptions): Promise<IsochroneFeatureCollection>;
     /** The most recently drawn rings, if any. */
     get current(): IsochroneFeatureCollection | undefined;
-    /** Draw (or update) a ring collection. Safe before the style has loaded. */
+    /**
+     * Draw (or update) a ring collection. Safe before the style has loaded.
+     * Never silently drops an update: once the source exists the data is
+     * applied immediately, even while `isStyleLoaded()` is transiently
+     * `false` mid-render (PlacesLayer has the same rule) - otherwise the map
+     * would keep showing the previous rings until the next style swap.
+     * Calls made before the source has first been installed are stashed in
+     * `lastData` - the latest wins - and installed on the next `style.load`.
+     */
     private draw;
     /** Add-or-update the source and ring layers on the current style. */
     private install;
@@ -2342,13 +3092,31 @@ interface LaneIndication {
     valid?: boolean;
     /** Whether guidance recommends this lane. */
     active?: boolean;
+    /**
+     * Which one of {@link directions} guidance actually takes from this lane,
+     * when the server resolves it (the gateway's `active_direction`, set only
+     * on active lanes whose mask decodes to a single indication).
+     *
+     * A lane may permit several movements — "straight or right" is the common
+     * one — and only this field says which of them the route uses. Draw the
+     * lane arrow from it, falling back to the first permitted direction: see
+     * {@link laneArrowDirection}.
+     */
+    activeDirection?: string;
 }
-/** A typed fragment of banner content. */
+/**
+ * A typed fragment of banner content.
+ *
+ * Field names are the wire names, because these objects come straight off
+ * `route.raw` without a mapping pass (see {@link extractGuidance}).
+ */
 interface BannerComponent {
     type: string;
     text: string;
     directions?: string[];
     active?: boolean;
+    /** Which of `directions` guidance recommends (gateway `active_direction`). */
+    active_direction?: string;
 }
 /** One banner line. */
 interface BannerContent {
@@ -2421,6 +3189,18 @@ declare function ssmlToText(ssml: string): string;
  * `valid` set.
  */
 declare function bannerLanes(banner: BannerInstruction): LaneIndication[];
+/**
+ * The single direction a lane's arrow should show.
+ *
+ * A lane that permits several movements ("straight or right") carries them
+ * all in `directions`, in the gateway's bitmask order, which is NOT the
+ * order the route cares about. Drawing `directions[0]` therefore shows a
+ * straight-ahead arrow on the lane the driver is being told to turn right
+ * from. `activeDirection` is the one the route actually takes, so it wins;
+ * the first permitted direction is only the fallback for lanes where the
+ * server could not resolve one.
+ */
+declare function laneArrowDirection(lane: LaneIndication): string;
 /**
  * Unicode arrow for a lane/maneuver direction (OSRM indication strings).
  * A text-only fallback; sprite-based lane icons ship with the map assets.
@@ -2558,9 +3338,10 @@ declare function cameraKindsShownOnMap(design: NavAlertsDesign, mode?: MapDispla
  * floor and per-mode visibility.
  *
  * The features must carry a `kind` property holding one of
- * {@link NAV_CAMERA_KINDS} (or the gateway's `redlight` spelling); an
- * unrecognised value falls back to the `unknown` icon, never to a guess at
- * a specific camera type.
+ * {@link NAV_CAMERA_KINDS} or any wire spelling {@link navCameraKind}
+ * accepts (the gateway's `redlight`, OSM's `traffic_signals`, …); an
+ * unrecognised or absent value falls back to the `unknown` icon, never to a
+ * guess at a specific camera type.
  *
  * @param source GeoJSON source id holding the camera features.
  * @param variant Sprite variant to draw: `"light"` icons read on a dark
@@ -2783,4 +3564,4 @@ declare class VoiceGuidance {
     private playEarcon;
 }
 
-export { ALERT_CONTRAST_MIN, AdrCheck, type AdrCheckOptions, type AdrCheckRequest, type AdrCheckResult, type AdrDimensions, type AdrTunnelCategory, type AlertChipContent, type AlertContrastIssue, type AlertPresentation, type BannerComponent, type BannerContent, type BannerInstruction, type BuildStyleOptions, type CameraAlert, CameraAlertChip, type CameraFix, DEFAULT_GLYPHS_URL, DEFAULT_TERRITORY_TILES_URL, type DiagnosticIssue, EFFECTS_METADATA_KEY, FLOW_DEFAULTS, FULL_ATTRIBUTION, FlowRouteEffectLayer, type FlythroughController, type FlythroughOptions, type FlythroughPose, GuidanceBanner, type GuidanceSeverity, type GuidanceSpokenPrompt, type IsochroneFeatureCollection, IsochroneLayer, type IsochroneLayerOptions, LOGO_SVG, type LaneIndication, type LayerOverride, type LngLatLike, LogoControl, type LogoOptions, type LogoPosition, MAX_PUCK_IMAGE_BYTES, type MapDiagnosticsInput, type MapDisplayMode, MapMapMap, type MapMapOptions, type MapMapTheme, NAV_ALERT_AUDIO_MODES, NAV_ALERT_CHIP_POSITIONS, NAV_ALERT_ICON_SETS, NAV_ALERT_LEAD_DISTANCES, NAV_ALERT_LEAD_DISTANCE_M, NAV_ALERT_MODES, NAV_ALERT_SOUNDS, NAV_ALERT_SOUND_BASE_URL, NAV_ALERT_SOUND_FILES, NAV_CAMERA_DEFAULTS, NAV_CAMERA_KINDS, type NavAlertAudioMode, type NavAlertChipPosition, type NavAlertIconSet, type NavAlertKindDesign, type NavAlertLeadDistance, type NavAlertMode, type NavAlertSound, type NavAlertsDesign, type NavBannerDesign, type NavCameraDesign, type NavCameraKind, type NavDesign, type NavPuckDesign, type NavRouteDesign, NavigationCamera, type NavigationCameraMode, type NavigationCameraOptions, type NearestByDriveTimeOptions, OPENMAPTILES_ATTRIBUTION, OSM_ATTRIBUTION, PALETTE_SLOTS, POI_CATEGORY_COLORS, POI_CATEGORY_IDS, POI_CLASS_CATEGORIES, type ParsedRoute, type Place, type PlacePointFeature, type PlaceWithDistance, type PlaceWithDriveTime, type PlacesFeatureCollection, type PlacesIcon, type PlacesInput, PlacesLayer, type PlacesLayerIds, type PlacesLayerOptions, type PlacesSelectOptions, type PoiCategoryDesign, type PoiDesign, PositionPuck, type PositionPuckOptions, type ProbeUploadOutcome, RIBBON_FLOATS_PER_VERTEX, ROUTE_EFFECTS, type ReachabilityMode, type RibbonMesh, type RouteEffectLayer, type RouteEffectName, type RouteFlowOptions, type RouteGeometry, RouteLayer, type RouteLayerOptions, type RouteOptions, type RouteProfile, SIGNAL_BLUE, SOURCE_LAYERS, type SetRouteEffectOptions, type SeverityProsody, type ShowReachabilityOptions, type SpeakOptions, type StepGuidance, type SunTimes, type Theme, type ThemeEffects, ThemeScheduler, type ThemeSchedulerOptions, type TruckParams, type UploadProbeOptions, VoiceGuidance, type VoiceGuidanceOptions, type VoiceGuidanceUpdate, type VoiceInstruction, alertChipContent, alertContrastIssues, alertIconSvg, alertIconUrl, alertPresentation, alertSoundUrl, alertSpeedReadoutColor, applyPoiDesign, bannerLanes, bearingBetween, bindFlythroughToScroll, buildAdrCheckBody, buildProbeUrl, buildRouteQuery, buildRouteUrl, buildStyle, builtInPoiColor, cameraKindLabel, cameraKindsShownOnMap, cameraShownOnMap, cameraSpriteName, cameraSymbolLayer, contrastRatio, createMap, createRouteEffect, defaultNavAlertsDesign, defaultNavDesign, defaultPoiDesign, directionArrow, effectsFromStyleMetadata, extractGuidance, flythrough, flythroughPose, formatCoord, formatCoords, haversineDistanceM, isNameTextField, languageTextField, lngLatToMercator, navAlertLeadDistanceM, navAlertSoundUrl, navCameraKind, navDesignFromTheme, navDesignFromThemeUrl, parseCssColour, parseHexColor, parseNavAlertsDesign, parseNavDesign, parseOsrmRoute, parsePoiDesign, placesFromGeoJSON, poiDesignFromTheme, poiDesignFromThemeUrl, poiDesignIsDefault, poiTextColorExpression, prefersReducedMotion, registerPmtilesProtocol, relativeLuminance, resetDiagnostics, resolveTheme, runMapDiagnostics, setMapLanguage, severityProsody, shortestArcDeg, shortestArcDelta, speak, ssmlToText, sunTimes, tessellateRouteRibbon, toLngLat, toPmtilesUrl, uploadProbeBatch };
+export { ALERT_CONTRAST_MIN, AdrCheck, type AdrCheckOptions, type AdrCheckRequest, type AdrCheckResult, type AdrDimensions, type AdrTunnelCategory, type AlertChipContent, type AlertContrastIssue, type AlertPresentation, type BannerComponent, type BannerContent, type BannerInstruction, type BuildStyleOptions, type CameraAlert, CameraAlertChip, type CameraFix, DEFAULT_GLYPHS_URL, DEFAULT_TERRITORY_TILES_URL, type DiagnosticIssue, EFFECTS_METADATA_KEY, type EndpointMarker, type EndpointsDesign, FLOW_DEFAULTS, FULL_ATTRIBUTION, FlowRouteEffectLayer, type FlythroughController, type FlythroughOptions, type FlythroughPose, GuidanceBanner, type GuidanceSeverity, type GuidanceSpokenPrompt, type IsochroneFeatureCollection, IsochroneLayer, type IsochroneLayerOptions, LOGO_SVG, type LaneIndication, type LayerOverride, type LngLatLike, LogoControl, type LogoOptions, type LogoPosition, MARKERS_ID, MARKER_DEFAULT_COLOUR, MARKER_GLYPH_IDS, MARKER_GLYPH_VIEWBOX, MARKER_LABEL_TEXT_SIZES, MARKER_PIN_BODY_PATH, MARKER_SIZES, MARKER_SIZES_PX, MAX_MARKER_ID_LENGTH, MAX_MARKER_IMAGE_BYTES, MAX_MARKER_ITEMS, MAX_MARKER_LABEL_LENGTH, MAX_MARKER_TEXT_LENGTH, MAX_PUCK_IMAGE_BYTES, type MapDiagnosticsInput, type MapDisplayMode, MapMapMap, type MapMapOptions, type MapMapTheme, type MarkerGlyphId, type MarkerItem, type MarkerSize, type MarkersBlock, MarkersLayer, type MarkersLayerIds, type MarkersLayerOptions, NAV_ALERT_AUDIO_MODES, NAV_ALERT_CHIP_POSITIONS, NAV_ALERT_ICON_SETS, NAV_ALERT_LEAD_DISTANCES, NAV_ALERT_LEAD_DISTANCE_M, NAV_ALERT_MODES, NAV_ALERT_SOUNDS, NAV_ALERT_SOUND_BASE_URL, NAV_ALERT_SOUND_FILES, NAV_CAMERA_DEFAULTS, NAV_CAMERA_KINDS, type NavAlertAudioMode, type NavAlertChipPosition, type NavAlertIconSet, type NavAlertKindDesign, type NavAlertLeadDistance, type NavAlertMode, type NavAlertSound, type NavAlertsDesign, type NavBannerDesign, type NavCameraDesign, type NavCameraKind, type NavDesign, type NavPuckDesign, type NavRouteDesign, NavigationCamera, type NavigationCameraMode, type NavigationCameraOptions, type NearestByDriveTimeOptions, OPENMAPTILES_ATTRIBUTION, OSM_ATTRIBUTION, PALETTE_SLOTS, POI_CATEGORY_COLORS, POI_CATEGORY_IDS, POI_CLASS_CATEGORIES, type ParsedRoute, type Place, type PlacePointFeature, type PlaceWithDistance, type PlaceWithDriveTime, type PlacesFeatureCollection, type PlacesIcon, type PlacesInput, type PlacesLabelOptions, PlacesLayer, type PlacesLayerIds, type PlacesLayerOptions, type PlacesSelectOptions, type PoiCategoryDesign, type PoiDesign, PositionPuck, type PositionPuckOptions, type ProbeUploadOutcome, RIBBON_FLOATS_PER_VERTEX, ROUTE_EFFECTS, type ReachabilityMode, type RenderMarkerImageOptions, type RenderedMarkerImage, type RibbonMesh, type RouteEffectLayer, type RouteEffectName, type RouteFlowOptions, type RouteGeometry, RouteLayer, type RouteLayerIds, type RouteLayerOptions, type RouteLineStyle, type RouteOptions, type RouteProfile, SIGNAL_BLUE, SOURCE_LAYERS, type SetRouteEffectOptions, type SeverityProsody, type ShowReachabilityOptions, type SpeakOptions, type StepGuidance, type SunTimes, type Theme, type ThemeEffects, ThemeScheduler, type ThemeSchedulerOptions, type TruckParams, type UploadProbeOptions, VoiceGuidance, type VoiceGuidanceOptions, type VoiceGuidanceUpdate, type VoiceInstruction, alertChipContent, alertContrastIssues, alertIconSvg, alertIconUrl, alertPresentation, alertSoundUrl, alertSpeedReadoutColor, applyPoiDesign, bannerLanes, bearingBetween, bindFlythroughToScroll, buildAdrCheckBody, buildProbeUrl, buildRouteQuery, buildRouteUrl, buildStyle, builtInPoiColor, cameraKindLabel, cameraKindsShownOnMap, cameraShownOnMap, cameraSpriteName, cameraSymbolLayer, contrastRatio, createMap, createRouteEffect, defaultNavAlertsDesign, defaultNavDesign, defaultPoiDesign, directionArrow, effectsFromStyleMetadata, extractGuidance, flythrough, flythroughPose, formatCoord, formatCoords, haversineDistanceM, isMarkerGlyphId, isNameTextField, laneArrowDirection, languageTextField, lngLatToMercator, markerGlyphPaths, markerImage, markerImageDataKey, markerImageKey, markerText, markerTextImageKey, markersFromTheme, markersFromThemeUrl, navAlertLeadDistanceM, navAlertSoundUrl, navCameraKind, navDesignFromTheme, navDesignFromThemeUrl, parseCssColour, parseHexColor, parseMarkers, parseNavAlertsDesign, parseNavDesign, parseOsrmRoute, parsePoiDesign, placesFromGeoJSON, poiDesignFromTheme, poiDesignFromThemeUrl, poiDesignIsDefault, poiTextColorExpression, prefersReducedMotion, registerPmtilesProtocol, relativeLuminance, renderMarkerImage, resetDiagnostics, resolveTheme, runMapDiagnostics, setMapLanguage, severityProsody, shortestArcDeg, shortestArcDelta, speak, ssmlToText, sunTimes, tessellateRouteRibbon, toLngLat, toPmtilesUrl, truncateChars, uploadProbeBatch };