@tomtom-org/maps-sdk 0.54.0 → 0.55.1

package/map/dist/index.d.ts

@@ -1,5 +1,14 @@
-import { BackgroundLayerSpecification, CircleLayerSpecification, DataDrivenPropertyValueSpecification, ExpressionSpecification, GeoJSONSource, GeoJSONSourceSpecification, LayerSpecification, LineLayerSpecification, LngLat, Map, MapGeoJSONFeature, MapOptions, Source, SourceSpecification, StyleImageInterface, StyleImageMetadata, StyleSpecification, SymbolLayerSpecification } from "maplibre-gl";
-import { Anything, AreaAnalyticsMetricKey, AreaAnalyticsMetrics, BBox, ChargingSpeed, ChargingStop, CommonPlaceProps, DelayMagnitude, DisplayUnits, GetPositionEntryPointOption, GlobalConfig, Instruction, Language, POICategory, Place, Places, PolygonFeature, PolygonFeatures, Route, RouteProps, Routes, SectionProps, TrafficAreaAnalytics, TrafficIncident, TrafficIncidentBaseProperties, TrafficIncidentCategory, TrafficIncidentDetails, TrafficIncidentTimeValidity, TrafficSectionProps, Waypoint, WaypointLike, Waypoints } from "@tomtom-org/maps-sdk/core";
+import { BackgroundLayerSpecification, CircleLayerSpecification, DataDrivenPropertyValueSpecification, ExpressionFilterSpecification, ExpressionSpecification, GeoJSONSource, GeoJSONSourceSpecification, LayerSpecification, LineLayerSpecification, LngLat, Map, MapGeoJSONFeature, MapOptions, Source, SourceSpecification, StyleImageInterface, StyleImageMetadata, StyleSpecification, SymbolLayerSpecification } from "maplibre-gl";
+import { Anything, AreaAnalyticsMetricKey, AreaAnalyticsMetrics, BBox, ChargingSpeed, ChargingStop, ChargingStopProps, CommonPlaceProps, DelayMagnitude, DisplayUnits, GetPositionEntryPointOption, GlobalConfig, Instruction, Language, POICategory, Place, Places, PolygonFeature, PolygonFeatures, Route, RouteProps, Routes, SectionProps, SectionType, TrafficAreaAnalytics, TrafficIncident, TrafficIncidentBaseProperties, TrafficIncidentCategory, TrafficIncidentDetails, TrafficIncidentTimeValidity, TrafficSectionProps, Waypoint, WaypointLike, Waypoints } from "@tomtom-org/maps-sdk/core";
+//#region src/shared/types/style.d.ts
+/**
+ * Indicator of a light or dark theme.
+ * * Can be used to classify a map style as light or dark, or to apply light or dark configurations to map modules if they support it.
+ *
+ * @group Map Style
+ */
+type LightDark = 'light' | 'dark';
+//#endregion
 //#region src/init/types/mapEventsConfig.d.ts
 /**
  * Configuration options for map user event handling.
@@ -192,15 +201,6 @@ type MapEventsConfig = EventHandlerCursorConfig & {
   longHoverDelayOnStillMapMS?: number;
 };
 //#endregion
-//#region src/shared/types/style.d.ts
-/**
- * Indicator of a light or dark theme.
- * * Can be used to classify a map style as light or dark, or to apply light or dark configurations to map modules if they support it.
- *
- * @group Map Style
- */
-type LightDark = 'light' | 'dark';
-//#endregion
 //#region src/init/types/mapInit.d.ts
 /**
  * Array of all available standard style identifiers.
@@ -601,6 +601,20 @@ export type TomTomMapParams = Partial<GlobalConfig> & {
  */
 export type InternalTomTomMapParams = GlobalConfig & TomTomMapParams;
 //#endregion
+//#region src/init/styleInputBuilder.d.ts
+/**
+ * The version of the TomTom Orbis map styles the SDK loads when {@link StandardStyle.version} is not
+ * given. Everything in the SDK that relies on the structure of a standard style — the base-map
+ * layer groups, the styling knobs — is curated and verified against this version, so a bump here is
+ * a bump of those tables too.
+ *
+ * Exported so the tooling that curates against it — the style-fixture refresh script — reads the
+ * same value, rather than restating it.
+ *
+ * @ignore
+ */
+export declare const DEFAULT_STYLE_VERSION = "0.6.0-0";
+//#endregion
 //#region src/TomTomMap.d.ts
 /**
  * Handler interface for responding to map style changes.
@@ -668,6 +682,15 @@ export type StyleChangeHandler = {
    * @returns void or a Promise that resolves when reinitialization is complete
    */
   onStyleChanged?: (context: StyleChangeContext) => void | Promise<void>;
+  /**
+   * Where this handler runs relative to the others: lower values run first, equal values run in
+   * registration order. Defaults to `0`, which is also what the SDK's data and visibility modules
+   * use; the SDK's {@link StylingModule} runs at `100` so semantic styling always lands on top of
+   * whatever the modules restored.
+   *
+   * @default 0
+   */
+  priority?: number;
 };
 /**
  * What a {@link StyleChangeHandler} is told about the style switch it is reacting to.
@@ -3612,6 +3635,61 @@ export declare class CombinedEvents<T, CFG, TShown = never, WHERE_SCOPE = never>
   off(type: EventType | 'config-change' | 'shown-features'): void;
 }
 //#endregion
+//#region src/shared/layers/layerFilterComposer.d.ts
+/**
+ * A rewrite of the filter a style gave one of its layers: the whole filter in, the whole filter out.
+ * @ignore
+ */
+export type LayerFilterTransform = (filter: unknown) => unknown;
+/**
+ * The single owner of a style layer's `filter`.
+ *
+ * Several modules narrow the same layer: {@link POIsModule.filterCategories} adds a category clause
+ * to the POI layer, and the styling knob `pois.zoomShift` rewrites the density term inside that same
+ * layer's filter. Each rebuilding the filter from its own snapshot of the style means whichever
+ * writes last drops the other's work, with nothing to show that it happened.
+ *
+ * So no module writes a style layer's filter itself. Each registers what it wants under a key of its
+ * own, and the composer writes the one filter that carries all of it: the filter the style shipped,
+ * run through every **transform**, then narrowed by every **clause**.
+ *
+ * The snapshot and the contributions belong to the style they were taken from, so both are dropped
+ * when a new style arrives; every module re-registers what it still wants as it restores itself.
+ *
+ * @ignore
+ */
+export declare class LayerFilterComposer {
+  private readonly mapLibreMap;
+  private readonly byLayer;
+  private constructor();
+  /**
+   * The composer of this map, created on first use. One per map: it is the shared state the
+   * contributors write through.
+   */
+  static for(tomtomMap: TomTomMap): LayerFilterComposer;
+  /**
+   * Registers a rewrite of the filter the style gave this layer, replacing the one this
+   * contributor registered before. Pass `undefined` to withdraw it and leave the filter to
+   * the other contributors.
+   *
+   * @param layerId - The style layer whose filter is rewritten.
+   * @param contributor - A key unique to the contributor, e.g. `'styling.zoomShift'`.
+   * @param transform - Receives the style's own filter, returns the filter to use instead.
+   */
+  setTransform(layerId: string, contributor: string, transform: LayerFilterTransform | undefined): void;
+  /**
+   * Registers a clause that narrows this layer further, `and`-ed with the style's own filter and
+   * with every other contributor's clause. Pass `undefined` to withdraw it.
+   *
+   * @param layerId - The style layer to narrow.
+   * @param contributor - A key unique to the contributor, e.g. `'pois.categories'`.
+   * @param clause - The clause to add, in expression syntax.
+   */
+  setClause(layerId: string, contributor: string, clause: ExpressionFilterSpecification | undefined): void;
+  private contribute;
+  private apply;
+}
+//#endregion
 //#region src/shared/AbstractMapModule.d.ts
 /**
  * How a module builds user events over some of its sources.
@@ -3707,6 +3785,17 @@ export declare abstract class AbstractMapModule<SOURCES_WITH_LAYERS extends Sour
    * @ignore
    */
   protected readonly instanceIndex: number;
+  /**
+   * The map's single owner of a **style** layer's `filter`. Several modules narrow the same style
+   * layer, so none of them calls `setFilter` on one directly: the composer is what keeps one from
+   * dropping another's work, and what holds the filter the style itself shipped. A module may
+   * still set the filter of a layer it added and owns alone.
+   *
+   * Assigned in this constructor, which already runs `_initSourcesWithLayers` and `applyConfig`,
+   * so a subclass field would be assigned too late for either to use it.
+   * @ignore
+   */
+  protected readonly filterComposer: LayerFilterComposer;
   /**
    * Per-concrete-class instance counter. WeakMap-keyed so unloaded classes can be GC'd.
    * @ignore
@@ -3725,6 +3814,14 @@ export declare abstract class AbstractMapModule<SOURCES_WITH_LAYERS extends Sour
    * @param config Optional configuration to initialize directly as soon as the map is ready.
    */
   protected constructor(tomtomMap: TomTomMap, config?: CFG);
+  /**
+   * Where this module restores itself in the style-change sequence (see
+   * {@link StyleChangeHandler.priority}). Data and visibility modules keep the default; a module
+   * whose work must land on top of theirs returns a higher value.
+   * @protected
+   * @ignore
+   */
+  protected styleChangePriority(): number;
   /**
    * Initializes the sources with layers of this module.
    * @param config The optional configuration for the module.
@@ -3996,6 +4093,106 @@ export declare abstract class AbstractDataOwnedMapModule<SOURCES_WITH_LAYERS ext
  */
 export declare abstract class AbstractStyleOwnedMapModule<SOURCES_WITH_LAYERS extends StyleSourcesWithLayers, CFG extends MapModuleCommonConfig | undefined = undefined> extends AbstractMapModule<SOURCES_WITH_LAYERS, CFG> {}
 //#endregion
+//#region src/shared/knobs.d.ts
+/**
+ * The kind of value a display knob takes.
+ *
+ * @remarks
+ * One vocabulary for every knob catalogue in the SDK — map styling and any module that describes
+ * its display as knobs draw from the same set, so an agent that learned one catalogue can read the
+ * other.
+ *
+ * - `toggle`: `true`/`false`, e.g. whether an overlay is drawn.
+ * - `factor`: a multiplier over what the style already does (`1` = unchanged).
+ * - `number`: an absolute number with a range.
+ * - `color`: a CSS colour string.
+ * - `enum`: one of the knob's `options`.
+ * @group Shared
+ */
+export type KnobKind = 'toggle' | 'factor' | 'number' | 'color' | 'enum';
+/**
+ * Inclusive bounds for a `factor` or `number` knob. `step` is what a slider would use; some ranges
+ * (e.g. opacity 0–1) have no natural step and omit it.
+ *
+ * @group Shared
+ */
+export type KnobRange = {
+  min: number;
+  max: number;
+  step?: number;
+};
+/**
+ * A single, machine-readable description of one display knob.
+ *
+ * @remarks
+ * The point of describing knobs as data is that a caller — increasingly a coding agent rather than
+ * a person reading docs — can ask what a module actually exposes instead of guessing layer ids from
+ * training data. Three things follow from having it:
+ *
+ * - **ground before generating** — write against what the module exposes, not what you remember;
+ * - **validate** — ranges and allowed values arrive as data, so a bad value is caught before it
+ *   is rendered;
+ * - **report and diff** — the paired settings object is plain and serializable, so a display change
+ *   is reviewable in a pull request.
+ *
+ * A visual editor cannot do any of those: it cannot be read, diffed, or put in a pull request.
+ *
+ * Modules narrow this shape with their own descriptor type — e.g. `StylingKnobDescriptor` requires
+ * `available` and `appliesTo`, while a module whose knobs are always applicable omits them.
+ *
+ * @group Shared
+ */
+export type KnobDescriptor<T = unknown> = {
+  /**
+   * Stable, dotted identifier, e.g. `labels.sizeFactor`. Treat these as public API: they are what
+   * a caller stores, diffs and passes back.
+   */
+  id: string;
+  /** What kind of value the knob takes. */
+  kind: KnobKind;
+  /** One-line description of what turning this knob does. */
+  description: string;
+  /** The value in force when nothing has been configured. */
+  default: T;
+  /** The value in force now. */
+  current: T;
+  /** Whether {@link KnobDescriptor.current} came from configuration rather than the default. */
+  overridden: boolean;
+  /** Inclusive bounds, for `factor` and `number` knobs. */
+  range?: KnobRange;
+  /** The allowed values, for `enum` knobs. */
+  options?: readonly string[];
+  /**
+   * Whether the knob has anything to work on in the loaded style. Omitted by modules whose knobs
+   * are always applicable; set to `false` by modules where a knob can be present in the catalogue
+   * but do nothing on the current style.
+   */
+  available?: boolean;
+  /**
+   * Which styles or contexts the knob works in. A string rather than a fixed union so each
+   * module can choose its own vocabulary — styling uses `'any-style' | 'tomtom-styles'`.
+   */
+  appliesTo?: string;
+};
+/**
+ * Builds one knob descriptor, working out `overridden` from whether a configured value was given.
+ * Pass `available` / `appliesTo` / `range` / `options` through `extra` when the module uses them.
+ * @ignore
+ */
+export declare const knob: <T, ID extends string, KIND extends KnobKind, Extra extends object = Record<string, never>>(id: ID, kind: KIND, description: string, defaultValue: T, configured: T | undefined, extra?: Extra) => KnobDescriptor<T> & {
+  id: ID;
+  kind: KIND;
+} & Extra;
+/**
+ * Reduces a knob catalogue to a plain, serializable object of the values in force.
+ *
+ * @remarks
+ * Only knobs whose value was configured are included, so the result is a diff against the defaults
+ * rather than a dump of everything — which is what makes it reviewable.
+ * @ignore
+ */
+export declare const knobSettings: (knobs: KnobDescriptor[]) => Record<string, unknown>;
+//#endregion
 //#region src/shared/layers/commonLayerProps.d.ts
 /**
  * Bold font face used in the TomTom map style.
@@ -6533,7 +6730,7 @@ export type MapStylePOICategory = keyof typeof mapDisplayPoiCategoryMappings;
 /**
  * @ignore
  */
-export declare const toBaseMapPOICategory: (category: POICategory) => string;
+export declare const toBaseMapPOICategory: (category: POICategory) => string | undefined;
 /**
  * The deduplicated set of base-map POI categories — the right-hand side of
  * {@link completeMapDisplayPoiCategoryMappings}. Each value names the
@@ -8312,7 +8509,6 @@ type PoIsSourcesAndLayers = {
  */
 export declare class POIsModule extends AbstractStyleOwnedMapModule<PoIsSourcesAndLayers, POIsModuleConfig> {
   private categoriesFilter?;
-  private originalFilter?;
   /**
    * Retrieves a POIsModule instance for the given map.
    *
@@ -8504,7 +8700,282 @@ export declare class POIsModule extends AbstractStyleOwnedMapModule<PoIsSourcesA
   get events(): CombinedEvents<POIsModuleFeature, POIsModuleConfig, never>;
 }
 //#endregion
+//#region src/routing/layers/sectionRegistry.d.ts
+type UndrawnSectionType = 'country' | 'lanes' | 'leg' | 'roadShields' | 'toll';
+/**
+ * A section type the module draws, and therefore one the caller can configure.
+ *
+ * @remarks
+ * Every section type the API can return, less the ones nothing draws. Derived from the core
+ * {@link SectionType} vocabulary, and {@link SECTION_REGISTRY} is keyed by it, so a section type
+ * added to core has to be registered there or named undrawn above before this package compiles.
+ *
+ * @group Routing
+ */
+type DrawnSectionType = Exclude<SectionType, UndrawnSectionType>;
+/**
+ * The section types whose layers are generated from {@link SECTION_REGISTRY}.
+ *
+ * @remarks
+ * Plain line overlays over the route, one registration each. The remaining drawn types
+ * ({@link bespokeSectionTypes}) carry type-specific icons or data-driven colours, so they keep
+ * hand-written layers — but they take the same {@link SectionDisplayConfig} knobs.
+ *
+ * @group Routing
+ */
+export declare const generatedSectionTypes: readonly ["carpool", "carTrain", "importantRoadStretch", "lowEmissionZone", "motorway", "pedestrian", "speedLimit", "tollVignette", "unpaved", "urban"];
+/**
+ * The drawn section types whose layers are hand-written rather than generated.
+ *
+ * @group Routing
+ */
+export declare const bespokeSectionTypes: readonly ["ferry", "tollRoad", "traffic", "tunnel", "vehicleRestricted"];
+/**
+ * A section type whose layers are generated from the registry.
+ * @group Routing
+ */
+type GeneratedSectionType = (typeof generatedSectionTypes)[number];
+/**
+ * A drawn section type with hand-written layers.
+ * @group Routing
+ */
+type BespokeSectionType = (typeof bespokeSectionTypes)[number];
+/**
+ * Every drawn section type, generated ones first.
+ * @group Routing
+ */
+export declare const drawnSectionTypes: readonly ["carpool", "carTrain", "importantRoadStretch", "lowEmissionZone", "motorway", "pedestrian", "speedLimit", "tollVignette", "unpaved", "urban", "ferry", "tollRoad", "traffic", "tunnel", "vehicleRestricted"];
+/**
+ * How a section's line relates to the route line it marks — both where it sits in the layer order
+ * and how wide it is drawn, since neither reads as intended without the other.
+ *
+ * @remarks
+ * - `halo`: beneath the route's own lines and wider than its outline, so the section shows as a
+ *   band hugging the route on both sides. The route keeps its own colour.
+ * - `inline`: above the route line at the route's own width, so the route itself appears in the
+ *   section's colour along that stretch. This is how `tunnel` and `ferry` draw.
+ *
+ * Every section defaults to whichever of the two it has always been drawn as.
+ *
+ * @group Routing
+ */
+type SectionDrawStyle = 'halo' | 'inline';
+/**
+ * The line pattern of a section.
+ * @group Routing
+ */
+type SectionLinePattern = 'solid' | 'dashed' | 'dotted';
+/**
+ * One of the uniform knobs {@link SectionDisplayConfig} offers.
+ * @group Routing
+ */
+type SectionKnobName = 'visible' | 'color' | 'opacity' | 'width' | 'style' | 'pattern' | 'icon' | 'sign';
+/**
+ * The key one section type's source, events scope and `getShown()` entry are filed under.
+ *
+ * @remarks
+ * `routing.events[sectionSourceKey('lowEmissionZone')]` and
+ * `routing.getShown()[sectionSourceKey('tunnel')]` both reach the section named by the type.
+ *
+ * @group Routing
+ */
+type SectionSourceKey<T extends DrawnSectionType = DrawnSectionType> = (typeof SECTION_REGISTRY)[T]['sourceKey'];
+/**
+ * What every drawn section type is, and which knobs it answers to.
+ *
+ * @remarks
+ * The single table the section tier is built from: the layer specs, the per-type sources, the
+ * visibility rules and the knob catalogue all read it, so none of them can drift from the others.
+ * @ignore
+ */
+declare const SECTION_REGISTRY: {
+  readonly carpool: {
+    readonly sourceKey: "carpoolSections";
+    readonly visible: false;
+    readonly style: "halo";
+    readonly pattern: "solid";
+    readonly knobs: readonly ["visible", "color", "opacity", "width", "style", "pattern", "icon"];
+  };
+  readonly carTrain: {
+    readonly sourceKey: "carTrainSections";
+    readonly visible: true;
+    readonly style: "halo";
+    readonly pattern: "dashed";
+    readonly knobs: readonly ["visible", "color", "opacity", "width", "style", "pattern", "icon"];
+  };
+  readonly importantRoadStretch: {
+    readonly sourceKey: "importantRoadStretchSections";
+    readonly visible: false;
+    readonly style: "halo";
+    readonly pattern: "solid";
+    readonly knobs: readonly ["visible", "color", "opacity", "width", "style", "pattern", "icon"];
+  };
+  readonly lowEmissionZone: {
+    readonly sourceKey: "lowEmissionZoneSections";
+    readonly visible: true;
+    readonly style: "halo";
+    readonly pattern: "solid";
+    readonly knobs: readonly ["visible", "color", "opacity", "width", "style", "pattern", "icon"];
+  };
+  readonly motorway: {
+    readonly sourceKey: "motorwaySections";
+    readonly visible: false;
+    readonly style: "halo";
+    readonly pattern: "solid";
+    readonly knobs: readonly ["visible", "color", "opacity", "width", "style", "pattern", "icon"];
+  };
+  readonly pedestrian: {
+    readonly sourceKey: "pedestrianSections";
+    readonly visible: false;
+    readonly style: "halo";
+    readonly pattern: "dashed";
+    readonly knobs: readonly ["visible", "color", "opacity", "width", "style", "pattern", "icon"];
+  };
+  readonly speedLimit: {
+    readonly sourceKey: "speedLimitSections";
+    readonly visible: true;
+    readonly knobs: readonly ["visible", "sign"];
+  };
+  readonly tollVignette: {
+    readonly sourceKey: "tollVignetteSections";
+    readonly visible: true;
+    readonly style: "halo";
+    readonly pattern: "dashed";
+    readonly knobs: readonly ["visible", "color", "opacity", "width", "style", "pattern", "icon"];
+  };
+  readonly unpaved: {
+    readonly sourceKey: "unpavedSections";
+    readonly visible: false;
+    readonly style: "halo";
+    readonly pattern: "dashed";
+    readonly knobs: readonly ["visible", "color", "opacity", "width", "style", "pattern", "icon"];
+  };
+  readonly urban: {
+    readonly sourceKey: "urbanSections";
+    readonly visible: false;
+    readonly style: "halo";
+    readonly pattern: "solid";
+    readonly knobs: readonly ["visible", "color", "opacity", "width", "style", "pattern", "icon"];
+  };
+  readonly ferry: {
+    readonly sourceKey: "ferries";
+    readonly visible: true;
+    readonly style: "inline";
+    readonly pattern: "solid";
+    readonly knobs: readonly ["visible", "color", "opacity", "width", "style", "pattern", "icon"];
+  };
+  readonly tollRoad: {
+    readonly sourceKey: "tollRoads";
+    readonly visible: true;
+    readonly style: "halo";
+    readonly pattern: "solid";
+    readonly knobs: readonly ["visible", "color", "opacity", "width", "style", "pattern", "icon"];
+  };
+  readonly traffic: {
+    readonly sourceKey: "incidents";
+    readonly visible: true;
+    readonly style: "inline";
+    readonly pattern: "solid";
+    readonly knobs: readonly ["visible", "opacity", "width", "style"];
+  };
+  readonly tunnel: {
+    readonly sourceKey: "tunnels";
+    readonly visible: true;
+    readonly style: "inline";
+    readonly pattern: "solid";
+    readonly knobs: readonly ["visible", "color", "opacity", "width", "style", "pattern", "icon"];
+  };
+  readonly vehicleRestricted: {
+    readonly sourceKey: "vehicleRestricted";
+    readonly visible: true;
+    readonly style: "inline";
+    readonly pattern: "dotted";
+    readonly knobs: readonly ["visible", "color", "opacity", "width", "style", "pattern", "icon"];
+  };
+};
+/**
+ * The knobs one section type answers to.
+ *
+ * @remarks
+ * Read off {@link SECTION_REGISTRY}, so `sections.traffic.color` is a compile error rather than a
+ * setting that draws nothing: `traffic` colours its line by `magnitudeOfDelay`.
+ *
+ * @group Routing
+ */
+type SectionKnobOf<T extends DrawnSectionType = DrawnSectionType> = (typeof SECTION_REGISTRY)[T]['knobs'][number];
+/**
+ * Whether the given type answers to the given knob.
+ *
+ * @remarks
+ * What a panel of section controls asks to decide which controls to render — the type system says
+ * the same thing through {@link SectionKnobOf}, but only a value can be looped over.
+ *
+ * @example
+ * ```typescript
+ * for (const knobName of ['color', 'opacity', 'pattern'] as const) {
+ *     if (sectionSupportsKnob(type, knobName)) renderControl(type, knobName);
+ * }
+ * ```
+ *
+ * @group Routing
+ */
+export declare const sectionSupportsKnob: (type: DrawnSectionType, knobName: SectionKnobName) => boolean;
+/**
+ * Whether the given type draws itself when `sections` says nothing about it.
+ *
+ * @remarks
+ * The answer a panel of section controls needs to show which switches start on. Asking the map
+ * instead cannot answer it: a type draws no layer for a route carrying none of its sections, so an
+ * absent layer reads the same as a type switched off.
+ *
+ * @example
+ * ```typescript
+ * const [drawn, optIn] = partition(drawnSectionTypes, sectionDrawsByDefault);
+ * ```
+ *
+ * @group Routing
+ */
+export declare const sectionDrawsByDefault: (type: DrawnSectionType) => boolean;
+/**
+ * The key the given section type's source, events scope and `getShown()` entry are filed under.
+ *
+ * @example
+ * ```typescript
+ * routing.events[sectionSourceKey('lowEmissionZone')].on('click', (section) => { … });
+ * const tunnels = routing.getShown()[sectionSourceKey('tunnel')];
+ * ```
+ *
+ * @group Routing
+ */
+export declare const sectionSourceKey: <T extends DrawnSectionType>(type: T) => SectionSourceKey<T>;
+//#endregion
 //#region src/routing/types/routeModuleConfig.d.ts
+/**
+ * The MapLibre layer id of a generated section's line layer.
+ *
+ * @remarks
+ * Derived from the section type, so `motorway` is drawn by `routeSectionMotorwayLine`.
+ * @group Routing
+ */
+type SectionLineLayerName<T extends GeneratedSectionType = GeneratedSectionType> = `routeSection${Capitalize<T>}Line`;
+/**
+ * The MapLibre layer id of a section's icon layer.
+ *
+ * @remarks
+ * Added to a generated section as soon as `sections.<type>.icon` asks for one, so `motorway` draws
+ * its icon through `routeSectionMotorwaySymbol`.
+ * @group Routing
+ */
+type SectionSymbolLayerName<T extends GeneratedSectionType = GeneratedSectionType> = `routeSection${Capitalize<T>}Symbol`;
+/**
+ * The MapLibre layer id drawing the signs of one generated section type.
+ *
+ * @remarks
+ * Present for the types that post their own value on a sign, so `speedLimit` draws its signs
+ * through `routeSectionSpeedLimitSign`.
+ * @group Routing
+ */
+type SectionSignLayerName<T extends GeneratedSectionType = GeneratedSectionType> = `routeSection${Capitalize<T>}Sign`;
 /**
  * Detailed configuration for the visual appearance of route layers on the map with the MapLibre specification.
  *
@@ -8603,15 +9074,18 @@ type RouteLayersConfig = {
     routeChargingStopSymbol?: Partial<ToBeAddedLayerSpecTemplate<SymbolLayerSpecification>>;
   } & HasAdditionalLayersConfig;
   /**
-   * Layer specifications for specialized route sections.
+   * Layer specifications for route sections, keyed by section type.
    *
    * @remarks
-   * Each section is a subset of the route path.
+   * Each section is a subset of the route path, and every type the module draws has an entry
+   * here — the same vocabulary as the semantic `sections` config, one tier down. This is the
+   * escape hatch: use it when the knobs on `sections` are not enough and you need full MapLibre
+   * control over the layers a section is drawn with.
    *
-   * Different types of road sections along the route can be styled individually
-   * to highlight specific characteristics or conditions.
+   * The generated types carry a line layer, and an icon layer once `sections.<type>.icon` asks
+   * for one. The remaining five draw themselves with the hand-written layers documented below.
    */
-  sections?: {
+  sections?: { [T in GeneratedSectionType]?: { [K in SectionLineLayerName<T>]?: Partial<ToBeAddedLayerSpecTemplate<LineLayerSpecification>>; } & { [K in SectionSymbolLayerName<T>]?: Partial<ToBeAddedLayerSpecTemplate<SymbolLayerSpecification>>; } & { [K in SectionSignLayerName<T>]?: Partial<ToBeAddedLayerSpecTemplate<SymbolLayerSpecification>>; } & HasAdditionalLayersConfig; } & {
     /**
      * Ferry crossing section layers.
      *
@@ -8640,7 +9114,7 @@ type RouteLayersConfig = {
      * @remarks
      * Highlights route segments affected by traffic incidents or disruptions.
      */
-    incident?: {
+    traffic?: {
       /**
        * Symbol layer used to mark the start of a jam on the route.
        *
@@ -9017,73 +9491,283 @@ type RouteTheme = {
   waypointSize?: RouteWaypointSize;
 };
 /**
- * Configuration options for the routing module.
+ * The icon drawn on a route section.
  *
  * @remarks
- * Provides customization options for route visualization and behavior,
- * including display units, waypoint handling, and layer styling.
+ * Backed by a symbol layer over the section's own source: the generated section types get one
+ * added, and the types that already draw an icon (`ferry`, `tollRoad`) have theirs replaced.
  *
  * @group Routing
  */
-type RoutingModuleConfig = MapModuleCommonConfig & {
+type SectionIconConfig = {
   /**
-   * Units for displaying distances in route summaries and instructions.
+   * The id of an image in the loaded style's sprite, e.g. `poi-toll_plaza`. An id the sprite does
+   * not carry draws nothing.
+   */
+  image: string;
+  /**
+   * Where the icon sits on the section.
    *
    * @remarks
-   * Overrides the global configuration setting for display units.
-   * Affects distance values shown in route summaries and turn-by-turn instructions.
+   * - `center`: one icon at the middle of each section.
+   * - `along`: icons repeated along the section.
    *
-   * Available options:
-   * - `metric` - Kilometers and meters
-   * - `imperial` - Miles and feet
+   * A section is a stretch of line, so there is no placement at its start: MapLibre places
+   * symbols on a line either once at its centre or repeatedly along it.
    *
-   * @defaultValue `"metric"`
+   * @defaultValue `"center"`
    */
-  displayUnits?: DisplayUnits;
+  placement?: 'center' | 'along';
   /**
-   * Main styling configuration for the route visualization.
+   * Icon scale, where `1` is the sprite image's own size.
    *
-   * @remarks
-   * * Provides high-level styling options that affect the overall appearance of the route,
-   * such as the primary color used for route lines and waypoints.
-   * * Can be overwritten by more specific layer styling configurations.
+   * @defaultValue 1
    */
-  theme?: RouteTheme;
+  size?: number;
+};
+type SectionKnobs = {
   /**
-   * Configuration for the waypoints source and layers to display them on the map.
+   * Whether the section is drawn at all.
    *
    * @remarks
-   * Controls how waypoint source data and/or layer configs are processed to rendering them the map.
+   * The default is per type, on one rule: a type draws itself when its stretches are sparse
+   * along a route and consequential for the driver. `carTrain`, `ferry`, `lowEmissionZone`,
+   * `tollRoad`, `tollVignette`, `traffic`, `tunnel` and `vehicleRestricted` do, until switched
+   * off here, and so does `speedLimit`, which posts a sign per section rather than banding the
+   * route. The rest wait to be asked — `motorway`, `urban` and `country` each run nearly a
+   * route's whole length, so a band drawn for them buries the route line.
    */
-  waypoints?: WaypointsConfig;
+  visible?: boolean;
   /**
-   * Configuration for the charging stops source and layers to display them on the map.
-   *
-   * @remarks
-   * Controls how charging stops source data and/or layer configs are processed to rendering them the map.
+   * Line colour, as any CSS colour string. Each section type has its own default; on a type
+   * drawn with more than one line, this sets the principal one and the rest are derived from it.
    */
-  chargingStops?: ChargingStopsConfig;
+  color?: string;
   /**
-   * Configuration for the route summary bubbles displayed on the map.
-   *
-   * @remarks
-   * Summary bubbles show key route information (distance, duration, traffic delay)
-   * as visual overlays positioned along the route.
+   * Line opacity, 0 to 1. Sections default to partial opacity so the route line stays readable
+   * underneath.
    */
-  summaryBubbles?: {
-    /**
-     * Controls the visibility of route summary bubbles on the map.
-     *
-     * @defaultValue true
-     */
-    visible?: boolean;
-  };
+  opacity?: number;
   /**
-   * Custom layer styling configuration.
-   *
-   * @remarks
-   * * Overrides the default layer styling with custom specifications.
-   * * You must provide complete layer specifications for any layers you wish to customize.
+   * Line width preset. Defaults to the route's own width.
+   */
+  width?: RouteWidth;
+  /**
+   * Whether the section bands the route (`halo`) or stands in for the route line along its own
+   * stretch (`inline`). This decides both where the section's line sits in the layer order and
+   * how wide it is drawn. Each type defaults to the one it has always been drawn as.
+   */
+  style?: SectionDrawStyle;
+  /**
+   * Line pattern. Each type has its own default — the ones that mark a legal rather than a
+   * physical property of the road are dashed, and `vehicleRestricted` is dotted.
+   */
+  pattern?: SectionLinePattern;
+  /**
+   * An icon drawn on the section. None of the generated types draws one by default.
+   */
+  icon?: SectionIconConfig;
+  /**
+   * The sign a section posts its own value on, for the one type whose information is a number
+   * rather than a stretch: `speedLimit`.
+   */
+  sign?: SectionSignConfig;
+};
+/**
+ * The unit a speed limit sign reads in.
+ *
+ * @group Routing
+ */
+type SectionSignUnit = 'km/h' | 'mph';
+/**
+ * What a section's signs give way to when two symbols want the same spot.
+ *
+ * @remarks
+ * MapLibre resolves symbol collisions from the topmost layer down, so the layer underneath is the
+ * one that gives way.
+ *
+ * - `belowMapLabels` — the signs give way to everything, the base map's own labels included, so a
+ *   sign never lands on a street or place name. Sparse maps, and the price of a tidy one: in a city
+ *   the labels take most of the room. Affordable because a sign repeats along its stretch, so one
+ *   dropped where a label sits reappears further along.
+ * - `belowRouteIcons` — the signs give way to the route's own icons, each of which says something
+ *   the road cannot, but take precedence over the base map's labels.
+ * - `aboveRouteIcons` — the signs give way to nothing, for a map whose subject is the limits.
+ *
+ * @group Routing
+ */
+type SectionSignPriority = 'belowMapLabels' | 'belowRouteIcons' | 'aboveRouteIcons';
+/**
+ * The sign a section type posts its own value on.
+ *
+ * @remarks
+ * `speedLimit` is the one type that takes this, and a sign is the whole of what it draws — there
+ * is no line along the stretch, because a line would mark every stretch that carries a limit
+ * without ever saying what the limit is. {@link SectionDisplayConfig.visible} switches the signs
+ * themselves.
+ *
+ * The sign follows the road rather than the reader. Where the route also carries `country`
+ * sections, each sign takes the face, the unit and the numeral colour of the country its stretch
+ * runs through: the white disc most of Europe posts on, the yellow one Sweden, Finland and Iceland
+ * use, the `SPEED LIMIT` plaque of the United States, and Japan's blue numerals. A country with no
+ * entry posts the white disc in km/h.
+ *
+ * Where mph is posted the number is converted and rounded to the step signs come in. Without
+ * `country` sections the display units decide the face and the unit, and an explicit {@link unit}
+ * overrides both.
+ *
+ * Signs scale with the zoom, as the ferry and toll-road icons do; {@link minzoom} decides how early
+ * they appear at all.
+ *
+ * @group Routing
+ */
+type SectionSignConfig = {
+  /**
+   * The lowest zoom the signs are drawn at.
+   *
+   * @defaultValue 9, the zoom at which a sign is about a stretch of road a reader can see. Over
+   * a whole country the stretches fall in the same few pixels, so the few signs that survive the
+   * collision are an arbitrary sample rather than the limits of the drive.
+   */
+  minzoom?: number;
+  /**
+   * Whether a sign gives way to the other icons the route draws, or takes precedence over them.
+   *
+   * @defaultValue `'belowRouteIcons'`
+   */
+  priority?: SectionSignPriority;
+  /**
+   * The unit every sign reads in, whatever the road posts.
+   *
+   * @remarks
+   * Left out, each sign follows its own country, or the display units where the route carries no
+   * `country` sections.
+   */
+  unit?: SectionSignUnit;
+};
+/**
+ * Appearance of one route section type.
+ *
+ * @remarks
+ * The semantic tier for sections: enough to draw, recolour, resize or mute any section type the
+ * module draws, without writing a MapLibre layer spec — see {@link DrawnSectionType} for the
+ * types, and `layers.sections` for anything these knobs cannot express.
+ *
+ * Which knobs a type takes is part of its type. `traffic` colours its line by `magnitudeOfDelay`
+ * and takes its icons from the incident data, so `sections.traffic.color` does not compile rather
+ * than compiling and drawing nothing. {@link sectionSupportsKnob} answers the same question at
+ * runtime, for a UI that builds its controls from the type.
+ *
+ * @example
+ * ```typescript
+ * const config: RoutingModuleConfig = {
+ *   sections: {
+ *     // Opt in to two of the sections nothing draws by default:
+ *     urban: { visible: true },
+ *     lowEmissionZone: { visible: true, color: '#1B7A43', opacity: 0.8 },
+ *     // Restyle two that are drawn already:
+ *     tunnel: { color: '#402060', style: 'halo' },
+ *     tollRoad: { icon: { image: 'poi-toll_plaza', placement: 'along' } },
+ *     // And drop one:
+ *     traffic: { visible: false },
+ *   },
+ * };
+ * ```
+ *
+ * @group Routing
+ */
+type SectionDisplayConfig<T extends DrawnSectionType = DrawnSectionType> = Pick<SectionKnobs, SectionKnobOf<T>>;
+/**
+ * Appearance of every route section type, keyed by type.
+ *
+ * @group Routing
+ */
+type SectionsDisplayConfig = { [T in DrawnSectionType]?: SectionDisplayConfig<T>; };
+/**
+ * Configuration options for the routing module.
+ *
+ * @remarks
+ * Provides customization options for route visualization and behavior,
+ * including display units, waypoint handling, and layer styling.
+ *
+ * @group Routing
+ */
+type RoutingModuleConfig = MapModuleCommonConfig & {
+  /**
+   * Units for displaying distances in route summaries and instructions.
+   *
+   * @remarks
+   * Overrides the global configuration setting for display units.
+   * Affects distance values shown in route summaries and turn-by-turn instructions.
+   *
+   * Available options:
+   * - `metric` - Kilometers and meters
+   * - `imperial` - Miles and feet
+   *
+   * @defaultValue `"metric"`
+   */
+  displayUnits?: DisplayUnits;
+  /**
+   * Main styling configuration for the route visualization.
+   *
+   * @remarks
+   * * Provides high-level styling options that affect the overall appearance of the route,
+   * such as the primary color used for route lines and waypoints.
+   * * Can be overwritten by more specific layer styling configurations.
+   */
+  theme?: RouteTheme;
+  /**
+   * Configuration for the waypoints source and layers to display them on the map.
+   *
+   * @remarks
+   * Controls how waypoint source data and/or layer configs are processed to rendering them the map.
+   */
+  waypoints?: WaypointsConfig;
+  /**
+   * Configuration for the charging stops source and layers to display them on the map.
+   *
+   * @remarks
+   * Controls how charging stops source data and/or layer configs are processed to rendering them the map.
+   */
+  chargingStops?: ChargingStopsConfig;
+  /**
+   * Configuration for the route summary bubbles displayed on the map.
+   *
+   * @remarks
+   * Summary bubbles show key route information (distance, duration, traffic delay)
+   * as visual overlays positioned along the route.
+   */
+  summaryBubbles?: {
+    /**
+     * Controls the visibility of route summary bubbles on the map.
+     *
+     * @defaultValue true
+     */
+    visible?: boolean;
+  };
+  /**
+   * Appearance of the route sections, keyed by section type.
+   *
+   * @remarks
+   * Covers every section type the module draws, on the same knobs: draw it or not, its colour,
+   * opacity, width, whether it bands the route or stands in for its line, its line pattern and
+   * its icon.
+   *
+   * The types whose stretches are sparse and consequential draw themselves — `carTrain`,
+   * `ferry`, `lowEmissionZone`, `tollRoad`, `tollVignette`, `traffic`, `tunnel` and
+   * `vehicleRestricted` — and switch off with `{ visible: false }`. The rest switch on with
+   * `{ visible: true }`: a type covering most of a route buries the route line.
+   *
+   * `layers.sections` takes full MapLibre layer specs for the same types, for anything these
+   * knobs cannot express.
+   */
+  sections?: SectionsDisplayConfig;
+  /**
+   * Custom layer styling configuration.
+   *
+   * @remarks
+   * * Overrides the default layer styling with custom specifications.
+   * * You must provide complete layer specifications for any layers you wish to customize.
    * * You can still reuse the default configurations if you want incremental changes. See: defaultRoutingLayers.
    * * Any layer not specified will continue to use its default styling.
    * * Use this only if you need fine MapLibre control on how some parts of the route are displayed.
@@ -9196,10 +9880,14 @@ export declare const getLineOutlineWidth: (size?: RouteWidth) => ExpressionSpeci
  */
 export declare const getWaypointIconSize: (size?: RouteWaypointSize) => ExpressionSpecification;
 /**
- * Returns the toll road outline width expression for the given size preset.
+ * Returns the width expression of a section halo for the given size preset.
+ *
+ * @remarks
+ * Wider than {@link getLineOutlineWidth} at every zoom, which is what makes a section drawn
+ * beneath the route show as a band around it rather than disappear under the route's own outline.
  * @ignore
  */
-export declare const getTollRoadOutlineWidth: (size?: RouteWidth) => ExpressionSpecification;
+export declare const getSectionHaloWidth: (size?: RouteWidth) => ExpressionSpecification;
 /**
  * Returns the instruction line width expression for the given size preset.
  * @ignore
@@ -9514,6 +10202,75 @@ type DisplayRouteSummary = Feature<Point, DisplayRouteSummaryProps>;
  */
 type DisplayRouteSummaries = FeatureCollection<Point, DisplayRouteSummaryProps>;
 //#endregion
+//#region src/routing/types/guidance.d.ts
+/**
+ * @ignore
+ */
+type DisplayInstructionArrowProps = {
+  lastPointBearingDegrees: number;
+};
+/**
+ * @ignore
+ */
+type DisplayInstructionArrows = FeatureCollection<Point, Instruction & DisplayInstructionArrowProps & DisplayRouteRelatedProps>;
+/**
+ * @ignore
+ */
+type DisplayInstruction = Feature<LineString, Instruction & DisplayRouteRelatedProps>;
+/**
+ * @ignore
+ */
+type DisplayInstructions = FeatureCollection<LineString, Instruction & DisplayRouteRelatedProps>;
+//#endregion
+//#region src/routing/util/displayChargingStops.d.ts
+type DisplayChargingStopProps = PlaceDisplayProps & ChargingStopProps & DisplayRouteRelatedProps & {
+  chargingDuration: string;
+  chargingPower: string;
+  stopDuration?: string;
+};
+/**
+ * The charging stops as displayed on the map, carrying the route state and index so a selection
+ * change can restyle them in place.
+ * @ignore
+ */
+type DisplayChargingStops = FeatureCollection<Point, DisplayChargingStopProps>;
+//#endregion
+//#region src/routing/types/planningWaypoint.d.ts
+/**
+ * Waypoint or placeholder for route planning.
+ *
+ * Represents a point along a route, which can be a full waypoint with position
+ * and properties, or `null` for placeholder positions (e.g., unset waypoints in
+ * a multi-stop route planner UI).
+ *
+ * @remarks
+ * **Use Cases:**
+ * - Route planning interfaces with add/remove waypoint functionality
+ * - Multi-stop delivery route optimization
+ * - Placeholder slots in waypoint arrays
+ * - Optional intermediate stops
+ *
+ * **Waypoint Types:**
+ * - `WaypointLike`: Full waypoint with coordinates and optional properties
+ * - `null`: Placeholder for unset or removed waypoints
+ *
+ * @example
+ * ```typescript
+ * // Array of waypoints with some unset
+ * const waypoints: PlanningWaypoint[] = [
+ *   { type: 'Feature', geometry: { type: 'Point', coordinates: [4.9, 52.3] } },
+ *   null,  // Empty slot for user to add waypoint
+ *   { type: 'Feature', geometry: { type: 'Point', coordinates: [4.5, 51.9] } }
+ * ];
+ *
+ * // Filter out null waypoints before routing
+ * const validWaypoints = waypoints.filter(w => w !== null);
+ * ```
+ *
+ * @group Routing
+ */
+type PlanningWaypoint = WaypointLike | null;
+//#endregion
 //#region src/routing/types/routeSections.d.ts
 /**
  * Display-ready section properties combining base section data with route context.
@@ -9677,62 +10434,6 @@ type DisplayTrafficSectionProps = DisplaySectionProps & TrafficSectionProps & {
   title?: string;
 };
 //#endregion
-//#region src/routing/types/guidance.d.ts
-/**
- * @ignore
- */
-type DisplayInstructionArrowProps = {
-  lastPointBearingDegrees: number;
-};
-/**
- * @ignore
- */
-type DisplayInstructionArrows = FeatureCollection<Point, Instruction & DisplayInstructionArrowProps & DisplayRouteRelatedProps>;
-/**
- * @ignore
- */
-type DisplayInstruction = Feature<LineString, Instruction & DisplayRouteRelatedProps>;
-/**
- * @ignore
- */
-type DisplayInstructions = FeatureCollection<LineString, Instruction & DisplayRouteRelatedProps>;
-//#endregion
-//#region src/routing/types/planningWaypoint.d.ts
-/**
- * Waypoint or placeholder for route planning.
- *
- * Represents a point along a route, which can be a full waypoint with position
- * and properties, or `null` for placeholder positions (e.g., unset waypoints in
- * a multi-stop route planner UI).
- *
- * @remarks
- * **Use Cases:**
- * - Route planning interfaces with add/remove waypoint functionality
- * - Multi-stop delivery route optimization
- * - Placeholder slots in waypoint arrays
- * - Optional intermediate stops
- *
- * **Waypoint Types:**
- * - `WaypointLike`: Full waypoint with coordinates and optional properties
- * - `null`: Placeholder for unset or removed waypoints
- *
- * @example
- * ```typescript
- * // Array of waypoints with some unset
- * const waypoints: PlanningWaypoint[] = [
- *   { type: 'Feature', geometry: { type: 'Point', coordinates: [4.9, 52.3] } },
- *   null,  // Empty slot for user to add waypoint
- *   { type: 'Feature', geometry: { type: 'Point', coordinates: [4.5, 51.9] } }
- * ];
- *
- * // Filter out null waypoints before routing
- * const validWaypoints = waypoints.filter(w => w !== null);
- * ```
- *
- * @group Routing
- */
-type PlanningWaypoint = WaypointLike | null;
-//#endregion
 //#region src/routing/types/waypointDisplayProps.d.ts
 /**
  * @group Routing
@@ -9870,13 +10571,13 @@ export declare const STOP_DISPLAY_INDEX = "stopDisplayIndex";
 /**
  * @ignore
  */
-type RoutingSourcesWithLayers = {
+type RoutingSourcesWithLayers = { [K in SectionSourceKey<GeneratedSectionType>]: GeoJSONSourceWithLayers<RouteSections>; } & {
   mainLines: GeoJSONSourceWithLayers<Routes<DisplayRouteProps>>;
   waypoints: GeoJSONSourceWithLayers<Waypoints<WaypointDisplayProps>>;
   vehicleRestricted: GeoJSONSourceWithLayers<RouteSections>;
   incidents: GeoJSONSourceWithLayers<RouteSections<DisplayTrafficSectionProps>>;
   ferries: GeoJSONSourceWithLayers<RouteSections>;
-  chargingStops: GeoJSONSourceWithLayers<Waypoints>;
+  chargingStops: GeoJSONSourceWithLayers<DisplayChargingStops>;
   tollRoads: GeoJSONSourceWithLayers<RouteSections>;
   tunnels: GeoJSONSourceWithLayers<RouteSections>;
   instructionLines: GeoJSONSourceWithLayers<DisplayInstructions>;
@@ -9953,7 +10654,7 @@ export type RoutingShownFeatures = {
  *
  * @group Routing
  */
-export type RoutingEvents = CombinedEvents<MapGeoJSONFeature, RoutingModuleConfig, RoutingShownFeatures> & {
+export type RoutingEvents = CombinedEvents<MapGeoJSONFeature, RoutingModuleConfig, RoutingShownFeatures> & { [K in SectionSourceKey<GeneratedSectionType>]: UserEvents<RouteSection>; } & {
   /** The route lines themselves. */
   mainLines: UserEvents<Route<DisplayRouteProps>>;
   /** Origin, destination and intermediate stops. */
@@ -10080,6 +10781,59 @@ export declare class RoutingModule extends AbstractDataOwnedMapModule<RoutingSou
    * @ignore
    */
   protected _applyConfig(config?: RoutingModuleConfig): RoutingModuleConfig;
+  /**
+   * Shows the speed limit sections, each carrying the sign that posts it.
+   *
+   * @remarks
+   * `speedLimit` is the one type drawn from its own number rather than its extent, so the number,
+   * the face and the numeral colour are derived here and ride on the feature. That makes the unit
+   * in force an input to the data rather than to the paint, which is why a change to it re-runs
+   * this instead of restyling the layer in place.
+   */
+  private showSpeedLimitSections;
+  /**
+   * Re-derives the posted signs when the unit they read in changed.
+   *
+   * @remarks
+   * No paint property can restate a number, so `sign.unit` and `displayUnits` are the two knobs
+   * that have to reach the features rather than the layers — the summary bubbles are re-shown for
+   * the same reason. Runs before the visibility pass, so the re-shown source goes through it.
+   */
+  private reshowSpeedLimitSigns;
+  /**
+   * Applies the `sections.<type>.visible` knob to every section type.
+   *
+   * @remarks
+   * Every other source here follows one rule — its layers are visible whenever it holds features
+   * — and for sections that rule is not enough. Almost every route has urban stretches, a tunnel
+   * or a country crossing somewhere along it, so "has features" would draw all sixteen types the
+   * moment a route is shown, whatever the caller asked for. This runs right after anything that
+   * shows features and after any config change, in the same tick, so nothing renders in between.
+   */
+  private applySectionVisibility;
+  /** The id of the layer posting this type's signs, for a type that posts them. */
+  private signLayerID;
+  /**
+   * Settles which icons a section's signs give way to.
+   *
+   * @remarks
+   * MapLibre resolves symbol collisions from the topmost layer down, so this is a matter of where
+   * the sign layer sits — and it cannot be a `beforeID`, because the layers a sign yields to are
+   * added when the features that need them are shown: a route with no waypoints shown has no
+   * waypoint layer to anchor to, and an anchor that is not on the map costs the sign layer
+   * itself. So the stacking is settled here instead, after each show and each config change.
+   */
+  private applySignPriority;
+  /**
+   * The layer a section's signs are moved under, for what they are configured to give way to.
+   *
+   * @remarks
+   * `aboveRouteIcons` anchors to nothing, which puts the layer on top. The other two differ only
+   * in where the search starts: under the base map's labels for `belowMapLabels`, and at them for
+   * `belowRouteIcons`, since a section's own icon layer is pinned below the labels and a sign
+   * sent under that would give way to every place name on the way.
+   */
+  private signAnchorLayerID;
   /** @ignore */
   protected discardShownData(): void;
   /**
@@ -10244,17 +10998,27 @@ export declare class RoutingModule extends AbstractDataOwnedMapModule<RoutingSou
    * ```
    */
   getShown(): {
-    mainLines: Routes<DisplayRouteProps>;
-    waypoints: Waypoints<WaypointDisplayProps>;
-    incidents: RouteSections<DisplayTrafficSectionProps>;
-    ferries: RouteSections;
-    chargingStops: Waypoints;
-    tollRoads: RouteSections;
     tunnels: RouteSections;
     vehicleRestricted: RouteSections;
     instructionLines: DisplayInstructions;
     instructionArrows: DisplayInstructionArrows;
     summaryBubbles: DisplayRouteSummaries;
+    carpoolSections: RouteSections | undefined;
+    carTrainSections: RouteSections | undefined;
+    importantRoadStretchSections: RouteSections | undefined;
+    lowEmissionZoneSections: RouteSections | undefined;
+    motorwaySections: RouteSections | undefined;
+    pedestrianSections: RouteSections | undefined;
+    speedLimitSections: RouteSections | undefined;
+    tollVignetteSections: RouteSections | undefined;
+    unpavedSections: RouteSections | undefined;
+    urbanSections: RouteSections | undefined;
+    mainLines: Routes<DisplayRouteProps>;
+    waypoints: Waypoints<WaypointDisplayProps>;
+    incidents: RouteSections<DisplayTrafficSectionProps>;
+    ferries: RouteSections;
+    chargingStops: DisplayChargingStops;
+    tollRoads: RouteSections;
   };
   /**
    * Unified events interface for the routing module.
@@ -10288,6 +11052,460 @@ export declare class RoutingModule extends AbstractDataOwnedMapModule<RoutingSou
   getLayerToRenderLinesUnder(): string;
 }
 //#endregion
+//#region src/shared/layers/layerSelector.d.ts
+/**
+ * Picks style layers by the taxonomy TomTom ships with the style rather than by their (unstable)
+ * ids: `metadata.group` first, then optional narrowing by layer type, source layer and
+ * case-insensitive id fragments. Every constraint given must hold.
+ *
+ * This is the one matching rule behind the base-map layer groups and the styling knobs, so a
+ * curated map is a small data table rather than code, and a style-version bump is checked by
+ * running the same tables against the new style.
+ *
+ * @ignore
+ */
+type LayerSelector = {
+  /** Values of `metadata.group` the layer may carry. Omit to accept any group. */
+  metadataGroups?: string[];
+  /** Layer types the layer may have. */
+  layerTypes?: LayerSpecification['type'][];
+  /** Sources the layer must draw from. */
+  sources?: string[];
+  /**
+   * Source types (`vector`, `raster`, `geojson`…) the layer's source may have. Needs the style's
+   * sources to be passed along when matching; without them this constraint cannot hold.
+   */
+  sourceTypes?: string[];
+  /** Source layers (vector tile layers) the layer must draw from. */
+  sourceLayers?: string[];
+  /** The layer id must contain at least one of these fragments (case-insensitive). */
+  idIncludes?: string[];
+  /** The layer id must contain none of these fragments (case-insensitive). */
+  idExcludes?: string[];
+};
+//#endregion
+//#region src/styling/types/stylingTypes.d.ts
+/**
+ * What kind of value a styling knob takes — a subset of the shared {@link KnobKind} vocabulary.
+ *
+ * - `factor`: a multiplier over what the style already does (`1` = unchanged), e.g. label size.
+ * - `number`: an absolute number with a range, e.g. a minimum zoom.
+ * - `toggle`: `true`/`false`, e.g. whether exit numbers are shown.
+ * - `color`: a CSS colour string (`#rrggbb`, `hsl(…)`, `rgb(…)`, a named colour).
+ *
+ * @group Map Styling
+ */
+export declare const stylingKnobKinds: readonly ["factor", "number", "toggle", "color"];
+/**
+ * @group Map Styling
+ */
+type StylingKnobKind = (typeof stylingKnobKinds)[number];
+/**
+ * Which styles a knob works on.
+ *
+ * - `any-style`: every style, including a custom one of your own.
+ * - `tomtom-styles`: the TomTom styles this SDK version is verified against. On any other style the
+ *   knob reports itself unavailable instead of doing nothing silently.
+ *
+ * @group Map Styling
+ */
+export declare const stylingKnobAppliesTo: readonly ["any-style", "tomtom-styles"];
+/**
+ * @group Map Styling
+ */
+type StylingKnobAppliesTo = (typeof stylingKnobAppliesTo)[number];
+/**
+ * A value a styling knob can hold; which one depends on the knob's {@link StylingKnobKind}.
+ *
+ * @group Map Styling
+ */
+type StylingKnobValue = number | boolean | string;
+/**
+ * The valid range of a numeric knob, in the units of the knob (`factor` knobs are unitless).
+ * Styling always ships a slider `step`; the shared {@link KnobRange} leaves it optional.
+ *
+ * @group Map Styling
+ */
+type StylingKnobRange = KnobRange & {
+  step: number;
+};
+/**
+ * One entry of the styling catalogue returned by {@link StylingModule.describe}: everything a UI or
+ * an agent needs to offer the knob, validate a value for it and show its state.
+ *
+ * @remarks
+ * Narrows the shared {@link KnobDescriptor}: styling ids and value types are known, `range.step` is
+ * always given, and `available` / `appliesTo` are required — every styling knob answers both.
+ *
+ * @group Map Styling
+ */
+type StylingKnobDescriptor = KnobDescriptor & {
+  /** The knob's id, as accepted by {@link StylingModule.set}. */
+  id: StylingKnobId;
+  kind: StylingKnobKind;
+  /**
+   * The value the loaded style ships with. `undefined` when the style defines it as a data-driven
+   * expression that no single value stands for; `reset` still restores it exactly.
+   */
+  default: StylingKnobValue | undefined;
+  /** The value in effect right now: the override if there is one, otherwise the default. */
+  current: StylingKnobValue | undefined;
+  /** The range of valid values, for `factor` and `number` knobs. */
+  range?: StylingKnobRange;
+  /**
+   * Whether the knob has anything to work on in the loaded style. `false` means setting it would
+   * do nothing — the SDK also warns once in the console when that happens. Check this before
+   * offering the knob in a UI or to an agent.
+   */
+  available: boolean;
+  /** Which styles the knob works on; see {@link stylingKnobAppliesTo}. */
+  appliesTo: StylingKnobAppliesTo;
+};
+/**
+ * The machine-readable styling catalogue: what can be styled on the loaded style, with defaults,
+ * ranges and current values. Additive across SDK minor versions; knob ids are public API.
+ *
+ * @group Map Styling
+ */
+type StylingCatalogue = {
+  knobs: StylingKnobDescriptor[];
+};
+/**
+ * A serializable set of styling knob values — what {@link StylingModule.getConfig} returns and
+ * {@link StylingModule.applyConfig} accepts. Persist it, put it in a pull request, or ship it as a
+ * preset: re-applying it on a later SDK version keeps working for as long as the knob ids do.
+ *
+ * @example
+ * ```typescript
+ * const settings: StylingSettings = {
+ *   'labels.sizeFactor': 1.2,
+ *   'roads.exitNumbers': false,
+ *   'traffic.flow.slowColor': '#f59e0b',
+ * };
+ * styling.applyConfig(settings);
+ * ```
+ *
+ * @group Map Styling
+ */
+type StylingSettings = MapModuleCommonConfig & { [K in StylingKnobId]?: StylingKnobValueOf<K>; };
+//#endregion
+//#region src/styling/knobCatalogue.d.ts
+/** @ignore */
+type ScalableProperty = 'text-size' | 'icon-size' | 'line-width';
+/** @ignore */
+type ColorProperty = 'line-color' | 'text-color' | 'text-halo-color';
+/**
+ * How a knob reaches the style. A knob may use several (e.g. text and icon size together).
+ * @ignore
+ */
+type KnobMechanism =
+/** M1 — multiplies the property's own value on every matched layer (works on any style). */
+{
+  type: 'scale';
+  property: ScalableProperty;
+  layers: LayerSelector[];
+} |
+/** M2 — shows/hides the matched layers. */
+{
+  type: 'visibility';
+  layers: LayerSelector[];
+} |
+/**
+ * M2 — sets a colour literal on the matched layers; `shades` are layers whose colour the style
+ * derived from it (an outline, a tunnel variant) and that are re-derived by the same HSL offset.
+ */
+{
+  type: 'color';
+  property: ColorProperty;
+  layers: LayerSelector[];
+  shades?: LayerSelector[];
+} |
+/** Sets the minimum zoom of the matched layers. */
+{
+  type: 'minZoom';
+  layers: LayerSelector[];
+} |
+/** Shifts the `["-", ["zoom"], offset]` density term inside the matched layers' filters. */
+{
+  type: 'zoomOffset';
+  layers: LayerSelector[];
+};
+/** @ignore */
+type KnobDefinition = {
+  kind: StylingKnobKind;
+  description: string;
+  range?: StylingKnobRange;
+  appliesTo: StylingKnobAppliesTo;
+  mechanisms: KnobMechanism[];
+};
+/**
+ * The styling knob catalogue: what the SDK can restyle on a TomTom standard style, and how.
+ *
+ * Ids are public API — additive only. Ranges follow TomTom Map Maker's validated grammar (factors
+ * 0.5–1.5 in 0.1 steps) so a value that looks right in the designer's tool looks right here.
+ * @ignore
+ */
+declare const knobDefinitions: {
+  readonly 'labels.sizeFactor': KnobDefinition;
+  readonly 'symbols.sizeFactor': KnobDefinition;
+  readonly 'roads.widthFactor': KnobDefinition;
+  readonly 'pois.sizeFactor': KnobDefinition;
+  readonly 'pois.minZoom': {
+    readonly kind: "number";
+    readonly description: "Zoom level from which base-map POIs appear (the style default is 6).";
+    readonly range: {
+      readonly min: 3;
+      readonly max: 18;
+      readonly step: 1;
+    };
+    readonly appliesTo: "tomtom-styles";
+    readonly mechanisms: [{
+      readonly type: "minZoom";
+      readonly layers: [{
+        readonly idExcludes: ["micro"];
+        readonly metadataGroups?: string[];
+        readonly layerTypes?: import("maplibre-gl").LayerSpecification["type"][];
+        readonly sources?: string[];
+        readonly sourceTypes?: string[];
+        readonly sourceLayers?: string[];
+        readonly idIncludes?: string[];
+      }];
+    }];
+  };
+  readonly 'pois.zoomShift': {
+    readonly kind: "number";
+    readonly description: "Shifts the zoom at which each POI appears: positive = later and sparser, negative = earlier and denser.";
+    readonly range: {
+      readonly min: -3;
+      readonly max: 3;
+      readonly step: 1;
+    };
+    readonly appliesTo: "tomtom-styles";
+    readonly mechanisms: [{
+      readonly type: "zoomOffset";
+      readonly layers: [LayerSelector];
+    }];
+  };
+  readonly 'pois.labelColor': KnobDefinition;
+  readonly 'pois.labelOutlineColor': KnobDefinition;
+  readonly 'pois.microMarkers': KnobDefinition;
+  readonly 'roads.exitNumbers': KnobDefinition;
+  readonly 'roads.shields': KnobDefinition;
+  readonly 'roads.arrows': KnobDefinition;
+  readonly 'roads.restricted': KnobDefinition;
+  readonly 'roads.underConstruction': KnobDefinition;
+  readonly 'buildings.footprints': KnobDefinition;
+  readonly 'buildings.3d': KnobDefinition;
+  readonly 'traffic.flow.freeColor': KnobDefinition;
+  readonly 'traffic.flow.slowColor': KnobDefinition;
+  readonly 'traffic.flow.queueingColor': KnobDefinition;
+  readonly 'traffic.flow.stationaryColor': KnobDefinition;
+  readonly 'traffic.flow.closedColor': KnobDefinition;
+  readonly 'traffic.flow.widthFactor': KnobDefinition;
+  readonly 'traffic.incidents.minorColor': KnobDefinition;
+  readonly 'traffic.incidents.moderateColor': KnobDefinition;
+  readonly 'traffic.incidents.majorColor': KnobDefinition;
+  readonly 'traffic.incidents.closedColor': KnobDefinition;
+  readonly 'traffic.incidents.widthFactor': KnobDefinition;
+};
+/**
+ * The id of a styling knob — see {@link StylingModule.describe} for what each one does.
+ *
+ * @group Map Styling
+ */
+type StylingKnobId = keyof typeof knobDefinitions;
+/**
+ * Every styling knob id, in catalogue order.
+ *
+ * @group Map Styling
+ */
+export declare const stylingKnobIds: StylingKnobId[];
+type ValueOfKind<KIND extends StylingKnobKind> = KIND extends 'toggle' ? boolean : KIND extends 'color' ? string : number;
+/**
+ * The value type a given styling knob takes.
+ *
+ * @group Map Styling
+ */
+type StylingKnobValueOf<ID extends StylingKnobId> = ValueOfKind<(typeof knobDefinitions)[ID]['kind']>;
+//#endregion
+//#region src/styling/StylingModule.d.ts
+/**
+ * Event surface of {@link StylingModule}: it owns no map features, so only the lifecycle half is
+ * live — `config-change` fires with the full {@link StylingSettings} after every knob change.
+ *
+ * @group Map Styling
+ */
+export type StylingEvents = CombinedEvents<MapGeoJSONFeature, StylingSettings, never>;
+/**
+ * Semantic styling of the base map, traffic and POIs — the tier between hiding a layer group and
+ * hand-editing MapLibre layers.
+ *
+ * Every adjustable thing is a **knob** with a stable id, a kind, a range and a default read from the
+ * loaded style. {@link describe} returns that catalogue as data, so a UI or an AI agent can build
+ * controls, validate values and diff state without knowing anything about the style's layers.
+ *
+ * @remarks
+ * **Which styles a knob works on** is `appliesTo` in the catalogue. `any-style` knobs (sizes,
+ * widths) wrap whatever the style already does — `text-size: E` becomes `["*", 1.3, E]` — so they
+ * work on a custom style too. `tomtom-styles` knobs (toggles, colours) reach their layers through
+ * the TomTom styles this SDK version is verified against; on any other style they report
+ * `available: false`, warn once and do nothing rather than failing silently.
+ *
+ * **Style changes.** Settings are re-applied after every `setStyle` that carries state over, on top of
+ * whatever the other modules restored, and dropped on a clean switch (`resetState: true`).
+ *
+ * **Interplay with other modules.** Toggles set layer visibility, as {@link BaseMapModule} and
+ * {@link POIsModule} do for whole groups; the later call wins. `pois.zoomShift` rewrites the POI
+ * layer filters, which {@link POIsModule.filterCategories} also narrows: the two compose, so either
+ * can be set at any time and neither drops the other.
+ *
+ * @example
+ * ```typescript
+ * import { StylingModule } from '@tomtom-org/maps-sdk/map';
+ *
+ * const styling = await StylingModule.get(map);
+ * styling.set('labels.sizeFactor', 1.2);
+ * styling.set('roads.exitNumbers', false);
+ * styling.set('traffic.flow.slowColor', '#f59e0b');
+ *
+ * // Everything a control panel or an agent needs, as data:
+ * for (const knob of styling.describe().knobs) {
+ *   console.log(knob.id, knob.kind, knob.range, knob.current);
+ * }
+ *
+ * // Serializable, diffable, re-applicable:
+ * const saved = styling.getConfig();
+ * styling.resetConfig();
+ * styling.applyConfig(saved);
+ * ```
+ *
+ * @see [Map Styling Guide](https://docs.tomtom.com/maps-sdk-js/guides/map/styling)
+ *
+ * @group Map Styling
+ */
+export declare class StylingModule extends AbstractStyleOwnedMapModule<Record<string, never>, StylingSettings> {
+  private originalValues;
+  private styleSources;
+  private resolved;
+  private scaleKnobsByTarget;
+  private warned;
+  /**
+   * Retrieves the styling module of the given map, creating it on first use.
+   *
+   * @param map - The TomTomMap instance to style.
+   * @param settings - Optional knob values to apply right away, e.g. restored from storage.
+   * @returns A promise that resolves once the map style is loaded and the settings are applied.
+   *
+   * @remarks
+   * **Instances:** the module styles the sources and layers the map style already provides, so
+   * every map has exactly one — a second `get()` returns the same instance, with the given
+   * settings applied on top of what it already holds.
+   *
+   * @example
+   * ```typescript
+   * const styling = await StylingModule.get(map, { 'labels.sizeFactor': 1.2 });
+   * ```
+   */
+  static get(map: TomTomMap, settings?: StylingSettings): Promise<StylingModule>;
+  private constructor();
+  /**
+   * @ignore
+   */
+  protected styleChangePriority(): number;
+  /**
+   * @ignore
+   */
+  protected _initSourcesWithLayers(): Record<string, never>;
+  /**
+   * @ignore
+   */
+  protected _applyConfig(settings: StylingSettings | undefined): StylingSettings | undefined;
+  /**
+   * The styling catalogue for the loaded style: every knob with its kind, range, default, current
+   * value and how many layers it reaches.
+   *
+   * @remarks
+   * Meant to be consumed as data — build a control panel from it, hand it to an agent, or diff two
+   * calls. Knob ids and the shape of the entries are public API and change additively only.
+   *
+   * @example
+   * ```typescript
+   * const { knobs } = styling.describe();
+   * const sliders = knobs.filter((knob) => knob.kind === 'factor' && knob.available);
+   * ```
+   */
+  describe(): StylingCatalogue;
+  /**
+   * The value a knob currently has: the override if one is set, otherwise the style's own default.
+   *
+   * @param id - The knob to read.
+   * @returns The current value, or `undefined` when the style defines it as a data-driven
+   * expression that no single value stands for.
+   *
+   * @example
+   * ```typescript
+   * styling.get('labels.sizeFactor'); // 1 until set
+   * ```
+   */
+  get<ID extends StylingKnobId>(id: ID): StylingKnobValueOf<ID> | undefined;
+  /**
+   * Sets one knob. The value is validated against the knob's kind and range before anything is
+   * touched, and applied to every layer the knob reaches.
+   *
+   * @param id - The knob to set; see {@link describe} for the catalogue.
+   * @param value - A number for `factor`/`number` knobs (within `range`), a boolean for `toggle`
+   * knobs, a CSS colour string for `color` knobs.
+   * @throws `RangeError` when the value is not valid for the knob; `Error` for an unknown id.
+   *
+   * @example
+   * ```typescript
+   * styling.set('roads.widthFactor', 1.3);
+   * styling.set('buildings.3d', true);
+   * styling.set('traffic.flow.stationaryColor', 'hsl(0, 100%, 40%)');
+   * ```
+   */
+  set<ID extends StylingKnobId>(id: ID, value: StylingKnobValueOf<ID>): void;
+  /**
+   * Restores the style's own values for one knob, or for all of them.
+   *
+   * @param id - The knob to reset; omit to reset every knob (same as {@link resetConfig}).
+   *
+   * @example
+   * ```typescript
+   * styling.reset('labels.sizeFactor');
+   * styling.reset(); // back to the style as shipped
+   * ```
+   */
+  reset(id?: StylingKnobId): void;
+  /**
+   * Lifecycle events of this module. The module owns no map features, so there are no user
+   * interaction events; `config-change` fires with the full settings after every knob change.
+   *
+   * @example
+   * ```typescript
+   * styling.events.on('config-change', (settings) => localStorage.setItem('styling', JSON.stringify(settings)));
+   * ```
+   */
+  get events(): StylingEvents;
+  private indexStyle;
+  private resolveMechanism;
+  private capture;
+  private originalValueOf;
+  private refreshKnob;
+  private refreshMechanism;
+  private refreshVisibility;
+  private refreshMinZoom;
+  private refreshZoomOffset;
+  private refreshScaledProperty;
+  private refreshColor;
+  private setProperty;
+  private describeKnob;
+  private defaultOf;
+  private assertKnob;
+  private validate;
+  private warnOnce;
+}
+//#endregion
 //#region src/traffic/types/trafficAreaAnalyticsConfig.d.ts
 /**
  * A single stop in an analytics color ramp.
@@ -11370,7 +12588,6 @@ type TrafficFlowSourcesWithLayers = {
  * @group Traffic Flow
  */
 export declare class TrafficFlowModule extends AbstractStyleOwnedMapModule<TrafficFlowSourcesWithLayers, FlowConfig> {
-  private originalFilters;
   /**
    * Retrieves a TrafficFlowModule instance for the given map.
    *
@@ -12124,7 +13341,6 @@ type TrafficIncidentsSourcesWithLayers = {
  * @group Traffic Incidents
  */
 export declare class TrafficIncidentsModule extends AbstractStyleOwnedMapModule<TrafficIncidentsSourcesWithLayers, IncidentsConfig> {
-  private originalFilters;
   /**
    * Retrieves a TrafficIncidentsModule instance for the given map.
    *
@@ -12448,4 +13664,4 @@ export declare const calculatePaddedCenter: (options: CalculateMapCenterOptions)
  */
 export declare const calculateFittingBBox: (options: CalculateFittingBBoxOptions) => BBox | null;
 //#endregion
-export type { AREA_ANALYTICS_DEFAULTS, AreaAnalyticsBeforeLayerConfig, AreaAnalyticsColorStop, AreaAnalyticsColorStopsConfig, AreaAnalyticsColorTheme, AreaAnalyticsDisplayMode, AreaAnalyticsHeightConfig, AreaAnalyticsMetricConfig, AreaAnalyticsMetricFilter, AreaAnalyticsRegionPolygonConfig, AreaAnalyticsValueType, AvailabilityLevel, BeforeLayerConfig, ByIdOrIndex, CSSCursor, ChargingSpeedIconMapping, ChargingStopIconConfig, ChargingStopIconMapping, ChargingStopTextConfig, ChargingStopsConfig, CleanEventStateOptions, CleanEventStatesOptions, ClickEventType, CustomImage, DefaultPlaceIconConfig, DisplayRouteProps, DisplayRouteRelatedProps, DisplayRouteSummaries, DisplayRouteSummary, DisplayRouteSummaryProps, EVAvailabilityConfig, EventHandlerConfig, EventHandlerCursorConfig, EventType, FilterShowMode, FilterablePOICategory, GeoJSONSourcesWithLayers, HasAdditionalLayersConfig, HasBeforeID, HillshadeModuleConfig, HoverEventType, IncidentFocusStyle, LayerSpecFilter, LayerSpecTemplate, LayerSpecWithSource, LightDark, MapEventsConfig, MapFont, MapModuleCommonConfig, MapStyleLayerID, POIsModuleConfig, POIsModuleFeature, PlaceConnectionDisplay, PlaceConnectionLayerName, PlaceConnectionsConfig, PlaceConnectionsLayersConfig, PlaceIconConfig, PlaceLayerName, PlaceLayersConfig, PlaceTextConfig, PlacesModuleConfig, PlacesTheme, PlanningWaypoint, PutEventStateOptions, RouteLayersConfig, RouteStateProps, RouteTheme, RouteWaypointSize, RouteWidth, RoutingModuleConfig, SVGIconStyleOptions, SourceWithLayerIDs, SourceWithLayers, SourcesWithLayers, StyleSourcesWithLayers, SupportsEvents, SymbolLayerSpecWithoutSource, ToBeAddedLayerSpec, ToBeAddedLayerSpecTemplate, ToBeAddedLayerSpecWithoutSource, TrafficAreaAnalyticsConfig, TrafficIncidentOverlayConfig, UserEventHandler, ValuesFilter, WaypointsConfig };
+export type { AREA_ANALYTICS_DEFAULTS, AreaAnalyticsBeforeLayerConfig, AreaAnalyticsColorStop, AreaAnalyticsColorStopsConfig, AreaAnalyticsColorTheme, AreaAnalyticsDisplayMode, AreaAnalyticsHeightConfig, AreaAnalyticsMetricConfig, AreaAnalyticsMetricFilter, AreaAnalyticsRegionPolygonConfig, AreaAnalyticsValueType, AvailabilityLevel, BeforeLayerConfig, BespokeSectionType, ByIdOrIndex, CSSCursor, ChargingSpeedIconMapping, ChargingStopIconConfig, ChargingStopIconMapping, ChargingStopTextConfig, ChargingStopsConfig, CleanEventStateOptions, CleanEventStatesOptions, ClickEventType, CustomImage, DefaultPlaceIconConfig, DisplayRouteProps, DisplayRouteRelatedProps, DisplayRouteSummaries, DisplayRouteSummary, DisplayRouteSummaryProps, DrawnSectionType, EVAvailabilityConfig, EventHandlerConfig, EventHandlerCursorConfig, EventType, FilterShowMode, FilterablePOICategory, GeneratedSectionType, GeoJSONSourcesWithLayers, HasAdditionalLayersConfig, HasBeforeID, HillshadeModuleConfig, HoverEventType, IncidentFocusStyle, LayerSpecFilter, LayerSpecTemplate, LayerSpecWithSource, LightDark, MapEventsConfig, MapFont, MapModuleCommonConfig, MapStyleLayerID, POIsModuleConfig, POIsModuleFeature, PlaceConnectionDisplay, PlaceConnectionLayerName, PlaceConnectionsConfig, PlaceConnectionsLayersConfig, PlaceIconConfig, PlaceLayerName, PlaceLayersConfig, PlaceTextConfig, PlacesModuleConfig, PlacesTheme, PlanningWaypoint, PutEventStateOptions, RouteLayersConfig, RouteStateProps, RouteTheme, RouteWaypointSize, RouteWidth, RoutingModuleConfig, SVGIconStyleOptions, SectionDisplayConfig, SectionDrawStyle, SectionIconConfig, SectionKnobName, SectionKnobOf, SectionLineLayerName, SectionLinePattern, SectionSignConfig, SectionSignLayerName, SectionSignPriority, SectionSignUnit, SectionSourceKey, SectionSymbolLayerName, SectionsDisplayConfig, SourceWithLayerIDs, SourceWithLayers, SourcesWithLayers, StyleSourcesWithLayers, StylingCatalogue, StylingKnobAppliesTo, StylingKnobDescriptor, StylingKnobId, StylingKnobKind, StylingKnobRange, StylingKnobValue, StylingKnobValueOf, StylingSettings, SupportsEvents, SymbolLayerSpecWithoutSource, ToBeAddedLayerSpec, ToBeAddedLayerSpecTemplate, ToBeAddedLayerSpecWithoutSource, TrafficAreaAnalyticsConfig, TrafficIncidentOverlayConfig, UserEventHandler, ValuesFilter, WaypointsConfig };