@tomtom-org/maps-sdk 0.54.0 → 0.56.0

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, CountrySectionProps, 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.
@@ -342,9 +342,35 @@ export type StandardStyle = {
   version?: string;
 };
 /**
- * Configuration for a custom map style.
+ * Where a custom style comes from: a URL to fetch it from, or the specification itself. Exactly one.
+ *
+ * @example
+ * ```typescript
+ * const fromUrl: CustomStyleSource = { url: 'https://example.com/my-custom-style.json' };
+ *
+ * const fromJson: CustomStyleSource = {
+ *   json: { version: 8, sources: { ... }, layers: [ ... ] },
+ * };
+ * ```
  *
- * Allows using your own map style either via URL or direct JSON specification.
+ * @group Map Style
+ */
+export type CustomStyleSource = {
+  /**
+   * URL to a MapLibre/Mapbox style JSON, without an API key — the SDK adds the configured one.
+   */
+  url: string;
+  json?: never;
+} | {
+  /**
+   * The complete style, as a
+   * [MapLibre Style Specification](https://maplibre.org/maplibre-style-spec/) object.
+   */
+  json: StyleSpecification;
+  url?: never;
+};
+/**
+ * Configuration for a custom map style.
  *
  * @remarks
  * Use custom styles for:
@@ -371,41 +397,7 @@ export type StandardStyle = {
  *
  * @group Map Style
  */
-export type CustomStyle = {
-  /**
-   * URL to a MapLibre/Mapbox style JSON.
-   *
-   * The URL should not include the API key - it will be automatically added.
-   * Mutually exclusive with the `json` property.
-   *
-   * @example
-   * ```typescript
-   * url: 'https://api.tomtom.com/style/1/style/my-custom-style'
-   * ```
-   */
-  url?: string;
-  /**
-   * Direct style specification as JSON.
-   *
-   * Provide the complete MapLibre Style Specification object.
-   * Mutually exclusive with the `url` property.
-   *
-   * @see [MapLibre Style Specification](https://maplibre.org/maplibre-style-spec/)
-   *
-   * @example
-   * ```typescript
-   * json: {
-   *   version: 8,
-   *   sources: {
-   *     'my-source': { type: 'vector', url: '...' }
-   *   },
-   *   layers: [
-   *     { id: 'background', type: 'background', paint: { 'background-color': '#f0f0f0' } }
-   *   ]
-   * }
-   * ```
-   */
-  json?: StyleSpecification;
+export type CustomStyle = CustomStyleSource & {
   /**
    * Whether the style draws a light or a dark map.
    *
@@ -601,6 +593,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 +674,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 +3627,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 +3777,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 +3806,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 +4085,108 @@ 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`.
+ * - `colors`: a list of colours, each a CSS colour string or one of the knob's `options` — names
+ *   the module resolves to colours, such as styling knob ids. An empty list is the knob's default.
+ * @group Shared
+ */
+export type KnobKind = 'toggle' | 'factor' | 'number' | 'color' | 'enum' | 'colors';
+/**
+ * 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; the names accepted besides CSS colours, for `colors` 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 +6724,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
@@ -7300,7 +7491,7 @@ type PlaceConnectionsConfig = {
  *
  * @group Places
  */
-type PlacesModuleConfig = MapModuleCommonConfig & {
+type PlacesModuleConfig<P extends CommonPlaceProps = CommonPlaceProps> = MapModuleCommonConfig & {
   /**
    * Base style for all places.
    *
@@ -7383,10 +7574,26 @@ type PlacesModuleConfig = MapModuleCommonConfig & {
    * }
    * ```
    */
-  extraFeatureProps?: {
-    [key: string]: ((place: Place) => any) | any;
-  };
+  extraFeatureProps?: Record<string, ExtraFeatureProp<P>>;
+};
+/**
+ * A value a GeoJSON feature property can hold.
+ *
+ * @group Places
+ */
+type FeaturePropValue = string | number | boolean | null | undefined | FeaturePropValue[] | {
+  [key: string]: FeaturePropValue;
 };
+/**
+ * An entry of {@link PlacesModuleConfig.extraFeatureProps}: a fixed value written onto every place
+ * feature, or a function computing one per place.
+ *
+ * @typeParam P - The place properties the callbacks receive. Name it on the config
+ * (`PlacesModuleConfig<MyPlaceProps>`) to have callbacks typed for the places you show.
+ *
+ * @group Places
+ */
+type ExtraFeatureProp<P extends CommonPlaceProps = CommonPlaceProps> = FeaturePropValue | ((place: Place<P>) => FeaturePropValue);
 //#endregion
 //#region src/places/utils/prepareConnectionsForDisplay.d.ts
 /**
@@ -7455,89 +7662,6 @@ export type PlacesEvents = CombinedEvents<MapGeoJSONFeature, PlacesModuleConfig,
   /** The lines and labels connecting places to their parent, when connections are shown. */
   connections: UserEvents<MapGeoJSONFeature>;
 };
-/**
- * Map module for displaying and managing place markers.
- *
- * The PlacesModule provides functionality to display location markers (pins) on the map
- * for points of interest, search results, or custom locations. It supports various marker
- * styles, custom icons, text labels, and interactive events.
- *
- * @remarks
- * **Features:**
- * - Multiple marker styles (pin, circle-icon, base-map POI-like)
- * - Custom icons per POI category
- * - Text labels with styling options
- * - Data-driven styling via MapLibre expressions
- * - Interactive events (click, hover, etc.)
- * - Support for custom feature properties
- * - EV charging station availability display (opt-in)
- *
- * **Marker Styles:**
- * - `pin`: Traditional teardrop-shaped map pins
- * - `circle-icon`: Simple circular markers (previously named `circle`)
- * - `base-map`: Mimics the map's built-in POI layer styling (combines `main`, `selected`, and `micro` layers). For micro-only rendering, hide the `main` layer via `layers.main.layout.visibility = 'none'`.
- *
- * **EV Charging Station Availability:**
- * When displaying EV charging stations with availability data from
- * {@link getPlacesWithEVAvailability}, the module can:
- * - Show available/total charging points (e.g., "3/10")
- * - Color-code availability (green = good, orange = limited, red = none/low)
- * - Display as formatted text within the station's label
- *
- * This feature is disabled by default. To enable it, set `evAvailability.enabled` to `true`
- * in the configuration.
- *
- * **Common Use Cases:**
- * - Search result visualization
- * - Custom location markers
- * - Store locators
- * - EV charging station maps with real-time availability
- * - Delivery/pickup points
- * - Saved locations display
- *
- * @example
- * ```typescript
- * // Create places module with pin markers
- * const placesModule = await PlacesModule.create(map, {
- *   icon: {
- *     categoryIcons: []
- *   },
- *   text: {
- *     field: (place) => place.properties.poi?.name || 'Unknown'
- *   },
- *   theme: 'pin'
- * });
- *
- * // Display places from search
- * await placesModule.show(searchResults);
- *
- * // EV Charging Stations - Opt-in to availability display
- * const evStations = await PlacesModule.create(map, {
- *   evAvailability: { enabled: true }
- * });
- * const results = await search({ poiCategories: ['ELECTRIC_VEHICLE_STATION'] });
- * evStations.show(await getPlacesWithEVAvailability(results)); // Shows availability
- *
- * // Granular control: Enable for searched stations only, background stations without
- * const bgStations = await PlacesModule.create(map); // EV availability disabled
- * const searched = await PlacesModule.create(map, {
- *   evAvailability: { enabled: true }
- * });
- *
- * // Handle clicks
- * placesModule.events.on('click', (feature) => {
- *   console.log('Clicked:', feature.properties);
- * });
- *
- * placesModule.events.on('hover', (feature) => {
- *   showTooltip(feature.properties.poi?.name);
- * });
- * ```
- *
- * @see [Places Guide](https://docs.tomtom.com/maps-sdk-js/guides/map/places)
- *
- * @group Places
- */
 export declare class PlacesModule extends AbstractDataOwnedMapModule<PlacesSourcesAndLayers, PlacesModuleConfig> {
   private layerSpecs;
   private connectionLayerSpecs;
@@ -7560,7 +7684,7 @@ export declare class PlacesModule extends AbstractDataOwnedMapModule<PlacesSourc
    * @param config  The module optional configuration
    * @returns {Promise} Returns a promise with a new instance of this module
    */
-  static create(tomtomMap: TomTomMap, config?: PlacesModuleConfig): Promise<PlacesModule>;
+  static create<P extends CommonPlaceProps = CommonPlaceProps>(tomtomMap: TomTomMap, config?: PlacesModuleConfig<P>): Promise<PlacesModule>;
   private constructor();
   /**
    * @ignore
@@ -7671,9 +7795,7 @@ export declare class PlacesModule extends AbstractDataOwnedMapModule<PlacesSourc
    * });
    * ```
    */
-  applyExtraFeatureProps(extraFeatureProps: {
-    [key: string]: any;
-  }): void;
+  applyExtraFeatureProps<P extends CommonPlaceProps = CommonPlaceProps>(extraFeatureProps: NonNullable<PlacesModuleConfig<P>['extraFeatureProps']>): void;
   private updateLayersAndData;
   private rebuildSourcesAndLayers;
   private updateConnectionLayersAndData;
@@ -8312,7 +8434,6 @@ type PoIsSourcesAndLayers = {
  */
 export declare class POIsModule extends AbstractStyleOwnedMapModule<PoIsSourcesAndLayers, POIsModuleConfig> {
   private categoriesFilter?;
-  private originalFilter?;
   /**
    * Retrieves a POIsModule instance for the given map.
    *
@@ -8504,93 +8625,368 @@ export declare class POIsModule extends AbstractStyleOwnedMapModule<PoIsSourcesA
   get events(): CombinedEvents<POIsModuleFeature, POIsModuleConfig, never>;
 }
 //#endregion
-//#region src/routing/types/routeModuleConfig.d.ts
+//#region src/routing/layers/sectionRegistry.d.ts
+type UndrawnSectionType = 'country' | 'lanes' | 'leg' | 'roadShields' | 'toll';
 /**
- * Detailed configuration for the visual appearance of route layers on the map with the MapLibre specification.
+ * A section type the module draws, and therefore one the caller can configure.
  *
  * @remarks
- * Provides fine-grained control over all route visualization layers, including
- * main route lines, waypoints, route sections (ferry, tunnel, toll roads, etc.),
- * turn-by-turn guidance instructions, and route summaries.
+ * 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.
  *
- * All fields are optional. When a field is not provided, the default styling will be used.
+ * @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
  */
-type RouteLayersConfig = {
-  /**
-   * Main route line layer specifications.
-   *
-   * @remarks
-   * Defines the visual styling for the primary route path displayed on the map.
-   * Can include both line and symbol layers for enhanced visualization.
-   */
-  mainLines?: {
-    /**
-     * Styling for the primary, selected route line.
-     *
-     * @remarks
-     * Controls the visual appearance of the active route's line (color, width, dash pattern, etc.).
-     */
-    routeLine?: Partial<ToBeAddedLayerSpecTemplate<LineLayerSpecification>>;
-    /**
-     * Styling for the outline (stroke) around the primary route line.
-     *
-     * @remarks
-     * Typically used to create contrast between the route and map background.
-     */
-    routeOutline?: Partial<ToBeAddedLayerSpecTemplate<LineLayerSpecification>>;
-    /**
-     * Styling for the deselected (inactive) route line.
-     *
-     * @remarks
-     * Used when multiple routes are shown and some are visually de-emphasized.
-     */
-    routeDeselectedLine?: Partial<ToBeAddedLayerSpecTemplate<LineLayerSpecification>>;
-    /**
-     * Styling for the outline around the deselected route line.
-     *
-     * @remarks
-     * Matches `routeDeselectedLine` but provides an outer stroke for visibility.
-     */
-    routeDeselectedOutline?: Partial<ToBeAddedLayerSpecTemplate<LineLayerSpecification>>;
-    /**
-     * Symbol layer that renders directional arrows along the main route.
-     *
-     * @remarks
-     * Arrows can help indicate travel direction along routes with complex geometry.
-     */
-    routeLineArrows?: Partial<ToBeAddedLayerSpecTemplate<SymbolLayerSpecification>>;
-  } & HasAdditionalLayersConfig;
-  /**
-   * Waypoint layer specifications.
-   *
-   * @remarks
-   * Controls the appearance of waypoint icons (origin, destination, and intermediate stops)
-   * and their labels along the route.
-   */
-  waypoints?: {
-    /**
-     * Symbol layer for waypoint icons (origin, destination, stops).
-     *
-     * @remarks
-     * Customize icons, sizes, and placement for waypoints using this layer.
-     */
-    routeWaypointSymbol?: Partial<ToBeAddedLayerSpecTemplate<SymbolLayerSpecification>>;
-    /**
-     * Symbol layer for waypoint labels displayed next to waypoint icons.
-     *
-     * @remarks
-     * Controls label text, font, and offset for waypoint annotations.
-     */
-    routeWaypointLabel?: Partial<ToBeAddedLayerSpecTemplate<SymbolLayerSpecification>>;
-  } & HasAdditionalLayersConfig;
-  /**
-   * Electric vehicle charging station section layers.
-   *
-   * @remarks
-   * Marks charging stop locations along routes calculated for electric vehicles.
-   *
+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.
+ *
+ * @remarks
+ * Provides fine-grained control over all route visualization layers, including
+ * main route lines, waypoints, route sections (ferry, tunnel, toll roads, etc.),
+ * turn-by-turn guidance instructions, and route summaries.
+ *
+ * All fields are optional. When a field is not provided, the default styling will be used.
+ *
+ * @group Routing
+ */
+type RouteLayersConfig = {
+  /**
+   * Main route line layer specifications.
+   *
+   * @remarks
+   * Defines the visual styling for the primary route path displayed on the map.
+   * Can include both line and symbol layers for enhanced visualization.
+   */
+  mainLines?: {
+    /**
+     * Styling for the primary, selected route line.
+     *
+     * @remarks
+     * Controls the visual appearance of the active route's line (color, width, dash pattern, etc.).
+     */
+    routeLine?: Partial<ToBeAddedLayerSpecTemplate<LineLayerSpecification>>;
+    /**
+     * Styling for the outline (stroke) around the primary route line.
+     *
+     * @remarks
+     * Typically used to create contrast between the route and map background.
+     */
+    routeOutline?: Partial<ToBeAddedLayerSpecTemplate<LineLayerSpecification>>;
+    /**
+     * Styling for the deselected (inactive) route line.
+     *
+     * @remarks
+     * Used when multiple routes are shown and some are visually de-emphasized.
+     */
+    routeDeselectedLine?: Partial<ToBeAddedLayerSpecTemplate<LineLayerSpecification>>;
+    /**
+     * Styling for the outline around the deselected route line.
+     *
+     * @remarks
+     * Matches `routeDeselectedLine` but provides an outer stroke for visibility.
+     */
+    routeDeselectedOutline?: Partial<ToBeAddedLayerSpecTemplate<LineLayerSpecification>>;
+    /**
+     * Symbol layer that renders directional arrows along the main route.
+     *
+     * @remarks
+     * Arrows can help indicate travel direction along routes with complex geometry.
+     */
+    routeLineArrows?: Partial<ToBeAddedLayerSpecTemplate<SymbolLayerSpecification>>;
+  } & HasAdditionalLayersConfig;
+  /**
+   * Waypoint layer specifications.
+   *
+   * @remarks
+   * Controls the appearance of waypoint icons (origin, destination, and intermediate stops)
+   * and their labels along the route.
+   */
+  waypoints?: {
+    /**
+     * Symbol layer for waypoint icons (origin, destination, stops).
+     *
+     * @remarks
+     * Customize icons, sizes, and placement for waypoints using this layer.
+     */
+    routeWaypointSymbol?: Partial<ToBeAddedLayerSpecTemplate<SymbolLayerSpecification>>;
+    /**
+     * Symbol layer for waypoint labels displayed next to waypoint icons.
+     *
+     * @remarks
+     * Controls label text, font, and offset for waypoint annotations.
+     */
+    routeWaypointLabel?: Partial<ToBeAddedLayerSpecTemplate<SymbolLayerSpecification>>;
+  } & HasAdditionalLayersConfig;
+  /**
+   * Electric vehicle charging station section layers.
+   *
+   * @remarks
+   * Marks charging stop locations along routes calculated for electric vehicles.
+   *
    * Charging stops are individual points which are originally extracted from leg sections.
    */
   chargingStops?: {
@@ -8603,15 +8999,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 +9039,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.
        *
@@ -8784,6 +9183,18 @@ type RouteLayersConfig = {
      */
     routeSummaryBubbleSymbol?: Partial<ToBeAddedLayerSpecTemplate<SymbolLayerSpecification>>;
   } & HasAdditionalLayersConfig;
+  /**
+   * Border crossing layers.
+   *
+   * @remarks
+   * Anything {@link CountryCrossingConfig} cannot express about the plaque or its label.
+   */
+  countryCrossings?: {
+    /**
+     * Symbol layer writing each crossing's label on its plaque.
+     */
+    routeCountryCrossing?: Partial<ToBeAddedLayerSpecTemplate<SymbolLayerSpecification>>;
+  } & HasAdditionalLayersConfig;
 };
 /**
  * Mapping of charging stop speeds to sprite image IDs.
@@ -9017,89 +9428,391 @@ 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.
-   *
-   * Available options:
-   * - `metric` - Kilometers and meters
-   * - `imperial` - Miles and feet
+   * - `center`: one icon at the middle of each section.
+   * - `along`: icons repeated along the section.
    *
-   * @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.
-   * * 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.
+   * Line width preset. Defaults to the route's own width.
    */
-  layers?: RouteLayersConfig;
-};
-//#endregion
-//#region src/routing/layers/routingLayers.d.ts
+  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';
+/**
+ * Where a section's signs are posted along the stretch they belong to.
+ *
+ * @remarks
+ * - `atChange`, the default — one sign where the value changes, and none after it, which is where
+ *   the road posts its own. Sections of a sign-posting type tile the route end to end and no two
+ *   consecutive ones carry the same value, so every section boundary is a change.
+ * - `along` — the sign repeated down the stretch at a fixed screen spacing, so a reader zoomed into
+ *   the middle of a long one still sees the value in force. A stretch too short on screen to fit a
+ *   sign draws none.
+ *
+ * A stretch can run 50 km, so under `atChange` a reader zoomed in past its start sees no sign until
+ * the next change — as on the road itself.
+ *
+ * @group Routing
+ */
+type SectionSignPlacement = 'atChange' | 'along';
+/**
+ * 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, at the cost of showing fewer in a city. Cheap under
+ *   `along` placement, where the dropped sign is posted again further down the stretch.
+ * - `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.
+ *
+ * A sign stands where the limit changes; {@link placement} repeats it down the stretch instead.
+ * 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 = {
+  /**
+   * Where the signs are posted along the stretch.
+   *
+   * @defaultValue `'atChange'`, which is where the road posts its own.
+   */
+  placement?: SectionSignPlacement;
+  /**
+   * The lowest zoom the signs are drawn at.
+   *
+   * @defaultValue 10, where a sign is about a stretch of road a reader can see. Further out the
+   * stretches fall in the same few pixels and the surviving signs are an arbitrary sample.
+   */
+  minzoom?: number;
+  /**
+   * What a sign gives way to when another symbol wants the same spot.
+   *
+   * @defaultValue follows {@link placement}: `'belowRouteIcons'` under `atChange`, where the sign
+   * is the only one posting that change; `'belowMapLabels'` under `along`, where the next repeat
+   * posts it again.
+   */
+  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;
+};
+/**
+ * How a border crossing's plaque is turned on the map.
+ *
+ * - `viewport` — level with the screen, however the map is rotated.
+ * - `route` — turned to the route's bearing where it crosses, so the plaque runs along the road. It
+ *   is kept upright, so the label never reads upside down.
+ *
+ * @group Routing
+ */
+type CountryCrossingAlignment = 'viewport' | 'route';
+/**
+ * Appearance of the border crossings along a route.
+ *
+ * @remarks
+ * A crossing is the seam between two consecutive `country` sections, so it is a point rather than a
+ * stretch, and takes knobs of its own instead of a place in the section catalogue. Each is a plaque
+ * naming both countries by their ISO 3166-1 alpha-2 codes in the direction of travel, `'ES → FR'`.
+ *
+ * The plaque follows the map's light/dark theme unless {@link color} or {@link textColor} says
+ * otherwise, so it stays legible across a style change without being reconfigured.
+ *
+ * @example
+ * ```typescript
+ * const routes = await calculateRoute({ locations, sectionTypes: ['country'] });
+ * await routing.showRoutes(routes);
+ * ```
+ *
+ * @group Routing
+ */
+type CountryCrossingConfig = {
+  /**
+   * Whether the crossings are drawn.
+   *
+   * @defaultValue `true`
+   */
+  visible?: boolean;
+  /**
+   * The lowest zoom a crossing is drawn at.
+   *
+   * @defaultValue 4, low enough for a continental route to show its borders while framed whole.
+   */
+  minzoom?: number;
+  /**
+   * The plaque colour behind the label.
+   *
+   * @defaultValue the SDK's near-black `'#1A2024'` on a light map, and the near-white `'#F1F3F5'`
+   * on a dark one.
+   */
+  color?: string;
+  /**
+   * The label colour.
+   *
+   * @defaultValue whichever of the SDK's near-black and near-white reads on the plaque, so
+   * setting {@link color} alone stays legible.
+   */
+  textColor?: string;
+  /**
+   * How the plaque is turned on the map.
+   *
+   * @defaultValue `'viewport'`
+   */
+  alignment?: CountryCrossingAlignment;
+};
+/**
+ * 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 border crossings along the route.
+   *
+   * @remarks
+   * Read off the route's `country` sections, so a route carrying none draws none.
+   */
+  countryCrossings?: CountryCrossingConfig;
+  /**
+   * 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.
+   */
+  layers?: RouteLayersConfig;
+};
+//#endregion
+//#region src/routing/layers/routingLayers.d.ts
 /**
  * Generates the routing layers configuration for route visualization on the map.
  * @param config - Optional routing module configuration to customize layer properties.
  * @param layerIDPrefix - Optional prefix to add to layer IDs for supporting multiple instances.
  * @param instanceIndex - Optional instance index for image ID suffixes.
+ * @param lightDark - The map style's light/dark theme, which the country crossing plaque colours follow.
  * @ignore
  */
-export declare const buildRoutingLayers: (config?: RoutingModuleConfig, layerIDPrefix?: string, instanceIndex?: number) => Required<RouteLayersConfig>;
+export declare const buildRoutingLayers: (config?: RoutingModuleConfig, layerIDPrefix?: string, instanceIndex?: number, lightDark?: LightDark) => Required<RouteLayersConfig>;
 /**
  * Default routing layers configuration. Calls routingLayers with no parameters.
  *
@@ -9196,10 +9909,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
@@ -9513,68 +10230,194 @@ type DisplayRouteSummary = Feature<Point, DisplayRouteSummaryProps>;
  * @group Routing
  */
 type DisplayRouteSummaries = FeatureCollection<Point, DisplayRouteSummaryProps>;
-//#endregion
-//#region src/routing/types/routeSections.d.ts
 /**
- * Display-ready section properties combining base section data with route context.
- *
- * Extends section information with routing module display properties, allowing
- * sections to be rendered with proper styling and route association.
- *
- * @remarks
- * Used for rendering special route segments like ferry crossings, tolls, tunnels, etc.
- *
- * @example
- * ```typescript
- * const sectionProps: DisplaySectionProps = {
- *   ...sectionData,
- *   routeIndex: 0,
- *   routeState: 'selected'
- * };
- * ```
+ * Display-ready props of one border crossing.
  *
  * @group Routing
  */
-type DisplaySectionProps = SectionProps & DisplayRouteRelatedProps;
+type DisplayCountryCrossingProps = DisplayRouteRelatedProps & {
+  /** ISO 3166-1 alpha-2 code of the country the route leaves. */
+  fromCountryCode: string;
+  /** ISO 3166-1 alpha-2 code of the country the route enters. */
+  toCountryCode: string;
+  /** The label the plaque is stretched around — `'ES → FR'`. */
+  label: string;
+  /**
+   * Bearing of the route where it crosses, in degrees clockwise from north.
+   *
+   * @remarks
+   * What `alignment: 'route'` turns the plaque by. Present whatever the alignment, so switching
+   * it is a restyle rather than a re-derive.
+   */
+  bearing: number;
+  /**
+   * `startPointIndex` of the `country` section the route leaves, which identifies that section
+   * on {@link RouteProps.sections} even when the route enters the same country twice.
+   */
+  fromSectionStartPointIndex: number;
+  /** `startPointIndex` of the `country` section the route enters. */
+  toSectionStartPointIndex: number;
+};
 /**
- * GeoJSON feature representing a route section of a certain type.
- *
- * Represents a specific segment of a route with special characteristics
- * (e.g., ferry, toll road, tunnel, traffic incident, EV charging stop).
+ * GeoJSON feature of one border crossing, placed where the route enters the second country.
  *
- * @typeParam S - The section properties type, defaults to DisplaySectionProps
+ * @group Routing
+ */
+type DisplayCountryCrossing = Feature<Point, DisplayCountryCrossingProps>;
+/**
+ * A border crossing as an event hands it over: the drawn feature, plus the two `country` sections
+ * it joins.
  *
  * @remarks
- * **Common Section Types:**
- * - Ferry crossings
- * - Toll roads
- * - Tunnels
- * - Traffic incidents
- * - Vehicle restrictions
- * - EV charging stops
- *
- * Each section has a start and end point along the route, represented as
- * a LineString geometry.
+ * The sections are looked up on the route the crossing belongs to, so they are the same objects
+ * `route.properties.sections.country` holds rather than copies. They are absent only when the route
+ * that carried them is no longer shown.
  *
- * @example
- * ```typescript
- * // Ferry section
- * const ferrySection: RouteSection = {
- *   type: 'Feature',
- *   geometry: {
- *     type: 'LineString',
- *     coordinates: [[4.9, 52.3], [4.95, 52.35]]
- *   },
- *   properties: {
- *     sectionType: 'ferry',
- *     routeIndex: 0,
- *     routeState: 'selected'
- *   }
- * };
+ * @group Routing
+ */
+type CountryCrossingFeature = Feature<Point, DisplayCountryCrossingProps & {
+  /** The `country` section the route leaves. */
+  fromSection?: CountrySectionProps;
+  /** The `country` section the route enters. */
+  toSection?: CountrySectionProps;
+}>;
+/**
+ * GeoJSON feature collection of the border crossings along the shown routes.
  *
- * // Toll road section
- * const tollSection: RouteSection = {
- *   type: 'Feature',
+ * @group Routing
+ */
+type DisplayCountryCrossings = FeatureCollection<Point, DisplayCountryCrossingProps>;
+//#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.
+ *
+ * Extends section information with routing module display properties, allowing
+ * sections to be rendered with proper styling and route association.
+ *
+ * @remarks
+ * Used for rendering special route segments like ferry crossings, tolls, tunnels, etc.
+ *
+ * @example
+ * ```typescript
+ * const sectionProps: DisplaySectionProps = {
+ *   ...sectionData,
+ *   routeIndex: 0,
+ *   routeState: 'selected'
+ * };
+ * ```
+ *
+ * @group Routing
+ */
+type DisplaySectionProps = SectionProps & DisplayRouteRelatedProps;
+/**
+ * GeoJSON feature representing a route section of a certain type.
+ *
+ * Represents a specific segment of a route with special characteristics
+ * (e.g., ferry, toll road, tunnel, traffic incident, EV charging stop).
+ *
+ * @typeParam S - The section properties type, defaults to DisplaySectionProps
+ *
+ * @remarks
+ * **Common Section Types:**
+ * - Ferry crossings
+ * - Toll roads
+ * - Tunnels
+ * - Traffic incidents
+ * - Vehicle restrictions
+ * - EV charging stops
+ *
+ * Each section has a start and end point along the route, represented as
+ * a LineString geometry.
+ *
+ * @example
+ * ```typescript
+ * // Ferry section
+ * const ferrySection: RouteSection = {
+ *   type: 'Feature',
+ *   geometry: {
+ *     type: 'LineString',
+ *     coordinates: [[4.9, 52.3], [4.95, 52.35]]
+ *   },
+ *   properties: {
+ *     sectionType: 'ferry',
+ *     routeIndex: 0,
+ *     routeState: 'selected'
+ *   }
+ * };
+ *
+ * // Toll road section
+ * const tollSection: RouteSection = {
+ *   type: 'Feature',
  *   geometry: {
  *     type: 'LineString',
  *     coordinates: [[5.1, 52.4], [5.2, 52.5]]
@@ -9677,62 +10520,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,18 +10657,19 @@ 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>;
   instructionArrows: GeoJSONSourceWithLayers<DisplayInstructionArrows>;
   summaryBubbles: GeoJSONSourceWithLayers<DisplayRouteSummaries>;
+  countryCrossings: GeoJSONSourceWithLayers<DisplayCountryCrossings>;
 };
 //#endregion
 //#region src/routing/types/showOptions.d.ts
@@ -9953,7 +10741,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. */
@@ -9962,6 +10750,8 @@ export type RoutingEvents = CombinedEvents<MapGeoJSONFeature, RoutingModuleConfi
   chargingStops: UserEvents<RouteSection>;
   /** The summary bubbles shown against each alternative. */
   summaryBubbles: UserEvents<DisplayRouteSummary>;
+  /** The border crossings along the route, each carrying the two `country` sections it joins. */
+  countryCrossings: UserEvents<CountryCrossingFeature>;
   /** Traffic incidents on the route. */
   incidents: UserEvents<RouteSection<DisplayTrafficSectionProps>>;
   /** Sections the vehicle is restricted from. */
@@ -9992,300 +10782,1179 @@ export type RoutingEvents = CombinedEvents<MapGeoJSONFeature, RoutingModuleConfi
  * - Distance and duration information
  * - Support for multiple routes simultaneously
  *
- * **Common Use Cases:**
- * - Turn-by-turn navigation displays
- * - Route planning and comparison
- * - Multi-stop route optimization
- * - Interactive route editing
- * - Fleet management route visualization
+ * **Common Use Cases:**
+ * - Turn-by-turn navigation displays
+ * - Route planning and comparison
+ * - Multi-stop route optimization
+ * - Interactive route editing
+ * - Fleet management route visualization
+ *
+ * @example
+ * ```typescript
+ * // Create the module
+ * const routingModule = await RoutingModule.create(map, {
+ *   displayUnits: {
+ *     distance: { type: 'metric' }
+ *   }
+ * });
+ *
+ * // Calculate and display a route
+ * const result = await calculateRoute({
+ *   key: 'your-api-key',
+ *   locations: [
+ *     [4.9041, 52.3676],  // Amsterdam
+ *     [4.4777, 51.9244]   // Rotterdam
+ *   ],
+ *   routeOptions: {
+ *     travelMode: 'car',
+ *     routeType: 'fastest'
+ *   }
+ * });
+ *
+ * await routingModule.showRoutes(result);
+ * ```
+ *
+ * @see [Routing Guide](https://docs.tomtom.com/maps-sdk-js/guides/map/routing)
+ *
+ * @group Routing
+ */
+export declare class RoutingModule extends AbstractDataOwnedMapModule<RoutingSourcesWithLayers, RoutingModuleConfig> {
+  private layersSpecs;
+  private layerIDPrefix;
+  private readonly shownFeaturesHandlers;
+  /**
+   * Make sure the map is ready before create an instance of the module and any other interaction with the map
+   * @param tomtomMap The TomTomMap instance.
+   * @param config  The module optional configuration
+   * @returns {Promise} Returns a promise with a new instance of this module
+   *
+   * @remarks
+   * **Instances:**
+   * `RoutingModule` owns the sources, layers and images it adds, all suffixed per instance. Every
+   * call therefore returns a **new, independent** instance, and stacking several of them on one
+   * map is a supported thing to do.
+   *
+   * **Configuration Options:**
+   * - `displayUnits`: Distance units (metric/imperial)
+   * - `waypointsSource`: Waypoint entry point options
+   * - `layers`: Complete layer styling configuration
+   *
+   * **Default Styling:**
+   * If no custom layers are provided, uses {@link defaultRoutingLayers}.
+   *
+   * @example
+   * Default initialization:
+   * ```typescript
+   * const routingModule = await RoutingModule.create(map);
+   * ```
+   *
+   * @example
+   * With custom configuration:
+   * ```typescript
+   * const routingModule = await RoutingModule.create(map, {
+   *   displayUnits: 'imperial',
+   *   waypointsSource: {
+   *     entryPoints: 'main-when-available'
+   *   }
+   * });
+   * ```
+   */
+  static create(tomtomMap: TomTomMap, config?: RoutingModuleConfig): Promise<RoutingModule>;
+  private constructor();
+  private createSourcesWithLayers;
+  /**
+   * @ignore
+   */
+  protected _initSourcesWithLayers(config?: RoutingModuleConfig, restore?: boolean): RoutingSourcesWithLayers;
+  /**
+   * @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;
+  /** The colours the crossings draw with, which follow the map's theme unless configured. */
+  private crossingColors;
+  /**
+   * What {@link applyCountryCrossingConfig} last painted the crossings with.
+   *
+   * @remarks
+   * Tracked here rather than re-derived from `this.config`, because the theme is an input the
+   * config cannot see: a style change moves the resolved colours while the config says the same
+   * thing. Cleared when the sources are rebuilt, so a restored style repaints from scratch.
+   */
+  private appliedCrossingColors;
+  /**
+   * Brings the border crossings in line with a changed configuration.
+   *
+   * @remarks
+   * The source is gated on `visible`, as the summary bubbles' is, so switching them back on
+   * re-derives the features: a layer spec cannot put back data the source does not hold.
+   *
+   * Both colours are applied here rather than left to the layer spec: the plaque is an image, so
+   * a new colour has to replace it, and the label's colour follows the map theme, which the spec
+   * that built the layer cannot know about after a style change.
+   */
+  private applyCountryCrossingConfig;
+  /**
+   * 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;
+  /**
+   * @ignore
+   */
+  protected restoreDataAndConfigImpl(): void;
+  private addImageIfNotExisting;
+  /**
+   * Displays the given routes on the map.
+   *
+   * @param routes - Route data from Routing API or custom routes.
+   * @param options - Optional configuration for route selection and display.
+   * @param options.selectedIndex - Index of the route to display as selected (default: 0).
+   *
+   * @remarks
+   * **Waypoints are NOT shown by this method.**
+   * Route lines are drawn but start/stop/destination markers are not. To display waypoint
+   * markers, call {@link showWaypoints} separately. Alternatively, use
+   * {@link PlacesModule} to display waypoints as fully customizable place markers.
+   *
+   * **Behavior:**
+   * - Replaces any previously shown routes
+   * - Shows all route-related features: lines, sections, summaries, guidance
+   * - First route is selected by default (appears more prominent)
+   *
+   * **Route Features:**
+   * - Main route lines (selected and deselected styles)
+   * - Traffic sections with delays
+   * - Ferry, tunnel, and charged-road (`tollRoad`) sections
+   * - EV charging stations (for EV routes)
+   * - Turn-by-turn instruction lines and arrows
+   * - Summary bubbles with distance/time/traffic info
+   *
+   * @example
+   * Show a route (no waypoint markers):
+   * ```typescript
+   * await routing.showRoutes(response.routes);
+   * // Waypoint markers are NOT shown — call showWaypoints() to add them
+   * ```
+   *
+   * @example
+   * Show routes and waypoint markers:
+   * ```typescript
+   * const locations = [[4.9, 52.4], [4.5, 51.9]];
+   * const response = await calculateRoute({ locations });
+   * await routing.showRoutes(response.routes);
+   * await routing.showWaypoints(locations); // Show start/destination markers separately
+   * ```
+   *
+   * @example
+   * Show multiple routes with specific selection:
+   * ```typescript
+   * await routing.showRoutes(response.routes, { selectedIndex: 1 });
+   * ```
+   */
+  showRoutes(routes: Route | Routes, options?: ShowRoutesOptions): Promise<void>;
+  /**
+   * Clears any previously shown routes from the map.
+   *
+   * @remarks
+   * - Clears all route-related layers (lines, sections, guidance, summaries)
+   * - Does NOT clear waypoints (use {@link clearWaypoints})
+   * - Module remains initialized and ready for new routes
+   *
+   * @example
+   * ```typescript
+   * await routing.clearRoutes();
+   * ```
+   */
+  clearRoutes(): Promise<void>;
+  /**
+   * Changes which route appears as selected.
+   *
+   * @param index - Zero-based index of the route to select.
+   *
+   * @remarks
+   * **Visual Changes:**
+   * - Selected route appears more prominent (thicker, brighter)
+   * - Previously selected route becomes deselected style
+   * - Updates all route-related features (sections, guidance)
+   *
+   * **Requirements:**
+   * - Route must already be displayed via {@link showRoutes}
+   * - Index must be within range of displayed routes
+   *
+   * @example
+   * ```typescript
+   * // Show multiple routes
+   * await routingModule.showRoutes(routes);
+   *
+   * // User clicks alternative route
+   * await routingModule.selectRoute(1);
+   *
+   * // Switch back to first route
+   * await routingModule.selectRoute(0);
+   * ```
+   */
+  selectRoute(index: number): Promise<void>;
+  /**
+   * Displays waypoint markers (start, stop, and destination pins) on the map.
+   *
+   * @param waypoints - An array of planning waypoints or a `Waypoints` FeatureCollection.
+   *
+   * @remarks
+   * Waypoint markers are **not** shown by {@link showRoutes} — this method must be called
+   * separately to display them. For more control over marker appearance and behavior,
+   * consider using {@link PlacesModule} to render waypoints as place markers instead.
+   *
+   * @example
+   * Show routes and then waypoints:
+   * ```typescript
+   * const locations = [[4.9041, 52.3676], [4.4777, 51.9244]];
+   * const response = await calculateRoute({ locations });
+   * await routingModule.showRoutes(response.routes);
+   * await routingModule.showWaypoints(locations); // Must be called separately
+   * ```
+   */
+  showWaypoints(waypoints: PlanningWaypoint[] | Waypoints): Promise<void>;
+  /**
+   * Clears any previously shown waypoints from the map.
+   * If nothing was shown before, nothing happens.
+   */
+  clearWaypoints(): Promise<void>;
+  /**
+   * Returns the currently shown routes and waypoints.
+   *
+   * @returns An object containing all currently displayed routing data.
+   *
+   * @remarks
+   * Returns the exact data that was passed to the `showRoutes()` and `showWaypoints()` methods.
+   *
+   * **Returned Data:**
+   * - `mainLines`: Main route lines (selected and alternative)
+   * - `waypoints`: Route waypoints (start, stops, finish)
+   * - `incidents`: Traffic incidents on routes
+   * - `ferries`: Ferry sections
+   * - `chargingStops`: EV charging stations
+   * - `tollRoads`: Sections that cost money to drive — the `tollRoad` section type
+   * - `tunnels`: Tunnel sections
+   * - `vehicleRestricted`: Vehicle-restricted sections
+   * - `instructionLines`: Turn-by-turn instruction lines
+   * - `instructionArrows`: Instruction arrow markers
+   * - `summaryBubbles`: Route summary popups
+   * - `countryCrossings`: Border crossings along the route
+   *
+   * @example
+   * ```typescript
+   * const shown = routingModule.getShown();
+   * console.log(`Showing ${shown.mainLines.features.length} routes`);
+   * console.log(`Showing ${shown.waypoints.features.length} waypoints`);
+   * console.log(`Showing ${shown.chargingStops.features.length} charging stops`);
+   * ```
+   *
+   * @example
+   * Check if any routes are displayed:
+   * ```typescript
+   * const shown = routingModule.getShown();
+   * if (shown.mainLines.features.length > 0) {
+   *   console.log('Routes are displayed');
+   * } else {
+   *   console.log('No routes displayed');
+   * }
+   * ```
+   */
+  getShown(): {
+    tunnels: RouteSections;
+    vehicleRestricted: RouteSections;
+    instructionLines: DisplayInstructions;
+    instructionArrows: DisplayInstructionArrows;
+    summaryBubbles: DisplayRouteSummaries;
+    countryCrossings: DisplayCountryCrossings;
+    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.
+   *
+   * `events` itself covers every route feature and the module's lifecycle events; the named
+   * scopes below cover one part of a route each, and every one of them can be narrowed further
+   * with `where()`.
+   *
+   * ```typescript
+   * routing.events.mainLines.on('click', (route) => { ... });
+   * routing.events.waypoints.on('hover', (waypoint) => { ... });
+   *
+   * // Only the long tunnels, with their own hover cursor:
+   * routing.events.tunnels
+   *     .where((section) => section.properties.lengthInMeters > 500, { cursorOnHover: 'help' })
+   *     .on('click', showTunnel);
+   *
+   * const unsub = routing.events.on('config-change', (config) => { ... });
+   * routing.events.on('shown-features', (features) => {
+   *   if ('routes' in features) { ... }
+   * });
+   * unsub();
+   * ```
+   */
+  get events(): RoutingEvents;
+  /**
+   * Returns the map style layer under which route lines are rendered.
+   * * Useful if you want to render extra layers just above the route ones but not on top of everything else.
+   * * It might differ depending on the loaded style/version.
+   */
+  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/mapColorCatalogue.d.ts
+/**
+ * The ten semantic map colours — TomTom Map Maker's *Foundations* palette, under its own names and
+ * in its own order. One name drives every layer and shade the style derives from it.
+ *
+ * | Name | Map Maker | Reaches |
+ * |---|---|---|
+ * | `land` | Land (base) | Map background and other bare-land features, influences admin borders/labels. Also used to derive all map colours if undefined. |
+ * | `water` | Water | Waterbodies, waterways and other water features. Also influences glaciers, water labels and ferry lines. |
+ * | `vegetation` | Vegetation | Forests and other land cover such as grass and shrubland. Also influences earth cover vegetation at smaller scales. |
+ * | `park` | Park & Recreation | City parks and sport/recreation grounds. Also influences National Parks and other protected areas at smaller scales. |
+ * | `artificial` | Artificial | Built-up-areas and man-made features such as landuse grounds and buildings. Also influences railways. |
+ * | `roadMajor` | Major Road | Most important road classes, from motorways & trunks to primary roads. Also influences outline and tunnel colours. |
+ * | `road` | Road | Less important road classes, from secondary/tertiary to streets and service roads. Also influences tunnel colours. |
+ * | `roadOutline` | Road Outline | Road outlines for secondary/tertiary roads and minor classes. Also influences road labels and all other outline colours. |
+ * | `label` | Label | Labels for capitals and other populated places/admin areas. Also influences border styling and all other label colours. |
+ * | `labelOutline` | Label Outline | Outlines for populated places and admin area labels. Also influences border outlines and all other label halos. |
+ *
+ * @group Map Styling
+ */
+type MapColorName = 'land' | 'water' | 'vegetation' | 'park' | 'artificial' | 'roadMajor' | 'road' | 'roadOutline' | 'label' | 'labelOutline';
+/**
+ * A partial set of map colours for {@link StylingModule.setMapColors}: any subset of the ten,
+ * each a CSS colour string.
+ *
+ * @example
+ * ```typescript
+ * styling.setMapColors({ land: '#f3f5f7', water: '#accbe2', roadMajor: '#a1b8ce', label: '#364659' });
+ * ```
+ *
+ * @group Map Styling
+ */
+type MapColors = Partial<Record<MapColorName, string>>;
+/**
+ * Every paint property the styling knobs write a colour to. Listed once as values, since
+ * `StylingModule` needs the set at runtime to pick MapLibre's paint setter over its layout one.
+ * @ignore
+ */
+declare const paintColorProperties: readonly ["fill-color", "fill-outline-color", "line-color", "text-color", "text-halo-color", "fill-extrusion-color", "background-color"];
+/** @ignore */
+type PaintColorProperty = (typeof paintColorProperties)[number];
+/**
+ * The ten map colour names, in Map Maker's Foundations order.
+ *
+ * @group Map Styling
+ */
+export declare const mapColorNames: MapColorName[];
+//#endregion
+//#region src/styling/presets.d.ts
+/**
+ * The styling presets the SDK ships: named bundles of knob settings for common intents. Each is data
+ * over the knob catalogue, so a preset is exactly as durable as the knobs it sets, and an app can
+ * start from one and adjust.
+ * @ignore
+ */
+declare const stylingPresets: {
+  readonly 'data-viz': {
+    readonly name: "Data visualisation";
+    readonly description: "A quiet base for your own data on top: fewer labels and markers, thinner roads, no badges competing with the overlay.";
+    readonly settings: {
+      readonly 'labels.sizeFactor': 0.9;
+      readonly 'symbols.sizeFactor': 0.9;
+      readonly 'roads.widthFactor': 0.8;
+      readonly 'roads.exitNumbers': false;
+      readonly 'roads.shields': false;
+      readonly 'roads.arrows': false;
+      readonly 'pois.microMarkers': false;
+      readonly 'pois.minZoom': 14;
+      readonly 'buildings.3d': false;
+    };
+  };
+  readonly 'night-driving': {
+    readonly name: "Night driving";
+    readonly description: "Bigger labels and shields, wider roads and traffic tubes, POIs out of the way until close up.";
+    readonly settings: {
+      readonly 'labels.sizeFactor': 1.2;
+      readonly 'symbols.sizeFactor': 1.2;
+      readonly 'roads.widthFactor': 1.2;
+      readonly 'roads.exitNumbers': true;
+      readonly 'roads.shields': true;
+      readonly 'roads.arrows': true;
+      readonly 'pois.minZoom': 13;
+      readonly 'pois.microMarkers': false;
+      readonly 'traffic.flow.widthFactor': 1.3;
+      readonly 'buildings.3d': false;
+    };
+  };
+  readonly minimal: {
+    readonly name: "Minimal";
+    readonly description: "The bare map: land, water, roads and the main place names. Everything decorative off.";
+    readonly settings: {
+      readonly 'labels.sizeFactor': 0.9;
+      readonly 'roads.exitNumbers': false;
+      readonly 'roads.shields': false;
+      readonly 'roads.arrows': false;
+      readonly 'roads.restricted': false;
+      readonly 'roads.underConstruction': false;
+      readonly 'buildings.footprints': false;
+      readonly 'buildings.3d': false;
+      readonly 'pois.microMarkers': false;
+      readonly 'pois.minZoom': 16;
+    };
+  };
+  readonly globe: {
+    readonly name: "Globe";
+    readonly description: "A globe with an atmosphere for the zoomed-out view; flattens to Mercator as you zoom in.";
+    readonly settings: {
+      readonly 'view.projection': "globe";
+      readonly 'view.sky': true;
+    };
+  };
+  readonly terrain: {
+    readonly name: "Terrain";
+    readonly description: "3D terrain with a sky for tilted views. Needs the hillshade style part and a pitched camera.";
+    readonly settings: {
+      readonly 'view.terrain': true;
+      readonly 'view.terrainExaggeration': 1.2;
+      readonly 'view.sky': true;
+    };
+  };
+};
+/**
+ * The id of a styling preset, as accepted by {@link StylingModule.applyPreset}.
+ *
+ * @group Map Styling
+ */
+type StylingPresetId = keyof typeof stylingPresets;
+/**
+ * Every styling preset id, in catalogue order.
+ *
+ * @group Map Styling
+ */
+export declare const stylingPresetIds: StylingPresetId[];
+//#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).
+ * - `enum`: one of the knob's `options`, e.g. the projection.
+ *
+ * @group Map Styling
+ */
+export declare const stylingKnobKinds: readonly ["factor", "number", "toggle", "color", "enum"];
+/**
+ * @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;
+  /** The valid values, for `enum` knobs. */
+  options?: readonly string[];
+  /**
+   * Whether the knob has anything to work on in the loaded style. `false` means setting it would
+   * do nothing, and the SDK also warns once in the console when that happens. Check this before
+   * offering the knob in a UI or to an agent. Map-level knobs are always available bar
+   * `view.terrain`, which needs the style to carry an elevation source.
+   */
+  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[];
+  /** The presets {@link StylingModule.applyPreset} accepts, with the settings each one applies. */
+  presets: StylingPresetDescriptor[];
+};
+/**
+ * A named bundle of knob settings — TomTom's cartographic opinions, in code. Apply one with
+ * {@link StylingModule.applyPreset}.
+ *
+ * @group Map Styling
+ */
+type StylingPresetDescriptor = {
+  id: StylingPresetId;
+  name: string;
+  /** One line on the use case the preset serves. */
+  description: string;
+  /** The knob values the preset applies; the same shape {@link StylingModule.applyConfig} takes. */
+  settings: StylingSettings;
+};
+/**
+ * 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 = Extract<PaintColorProperty, '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[];
+} |
+/** Map-level: the projection the whole map is drawn in. */
+{
+  type: 'projection';
+} |
+/** Map-level: the sky/atmosphere (its colours come from the sibling colour knobs). */
+{
+  type: 'sky';
+} |
+/** Map-level: 3D terrain from the style's raster-dem source (exaggeration from the sibling knob). */
+{
+  type: 'terrain';
+} |
+/** Map-level: the colour behind the map canvas, which a globe leaves visible around the planet. */
+{
+  type: 'space';
+} |
+/**
+ * One of the ten semantic map colours: re-derives every literal it governs from the new colour,
+ * keeping each one's HSL offset from the style's own base (the anchor).
+ */
+{
+  type: 'mapColor';
+  color: MapColorName;
+};
+/** @ignore */
+type KnobDefinition = {
+  kind: StylingKnobKind;
+  description: string;
+  range?: StylingKnobRange;
+  /** The valid values of an `enum` knob. */
+  options?: readonly string[];
+  appliesTo: StylingKnobAppliesTo;
+  mechanisms: KnobMechanism[];
+};
+type KnobDefinitionOf<KIND extends StylingKnobKind> = KnobDefinition & {
+  kind: KIND;
+};
+/**
+ * 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': KnobDefinitionOf<"factor">;
+  readonly 'symbols.sizeFactor': KnobDefinitionOf<"factor">;
+  readonly 'roads.widthFactor': KnobDefinitionOf<"factor">;
+  readonly 'pois.sizeFactor': KnobDefinitionOf<"factor">;
+  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': KnobDefinitionOf<"color">;
+  readonly 'pois.labelOutlineColor': KnobDefinitionOf<"color">;
+  readonly 'pois.microMarkers': KnobDefinitionOf<"toggle">;
+  readonly 'roads.exitNumbers': KnobDefinitionOf<"toggle">;
+  readonly 'roads.shields': KnobDefinitionOf<"toggle">;
+  readonly 'roads.arrows': KnobDefinitionOf<"toggle">;
+  readonly 'roads.restricted': KnobDefinitionOf<"toggle">;
+  readonly 'roads.underConstruction': KnobDefinitionOf<"toggle">;
+  readonly 'buildings.footprints': KnobDefinitionOf<"toggle">;
+  readonly 'buildings.3d': KnobDefinitionOf<"toggle">;
+  readonly 'traffic.flow.freeColor': KnobDefinitionOf<"color">;
+  readonly 'traffic.flow.slowColor': KnobDefinitionOf<"color">;
+  readonly 'traffic.flow.queueingColor': KnobDefinitionOf<"color">;
+  readonly 'traffic.flow.stationaryColor': KnobDefinitionOf<"color">;
+  readonly 'traffic.flow.closedColor': KnobDefinitionOf<"color">;
+  readonly 'traffic.flow.widthFactor': KnobDefinitionOf<"factor">;
+  readonly 'traffic.incidents.minorColor': KnobDefinitionOf<"color">;
+  readonly 'traffic.incidents.moderateColor': KnobDefinitionOf<"color">;
+  readonly 'traffic.incidents.majorColor': KnobDefinitionOf<"color">;
+  readonly 'traffic.incidents.closedColor': KnobDefinitionOf<"color">;
+  readonly 'traffic.incidents.widthFactor': KnobDefinitionOf<"factor">;
+  readonly 'colors.land': KnobDefinitionOf<"color">;
+  readonly 'colors.water': KnobDefinitionOf<"color">;
+  readonly 'colors.vegetation': KnobDefinitionOf<"color">;
+  readonly 'colors.park': KnobDefinitionOf<"color">;
+  readonly 'colors.artificial': KnobDefinitionOf<"color">;
+  readonly 'colors.roadMajor': KnobDefinitionOf<"color">;
+  readonly 'colors.road': KnobDefinitionOf<"color">;
+  readonly 'colors.roadOutline': KnobDefinitionOf<"color">;
+  readonly 'colors.label': KnobDefinitionOf<"color">;
+  readonly 'colors.labelOutline': KnobDefinitionOf<"color">;
+  readonly 'view.projection': {
+    readonly kind: "enum";
+    readonly description: "How the map is drawn: flat Mercator or a globe. The globe flattens to Mercator between zoom 11 and 12 by design.";
+    readonly options: readonly ["mercator", "globe"];
+    readonly appliesTo: "any-style";
+    readonly mechanisms: [{
+      readonly type: "projection";
+    }];
+  };
+  readonly 'view.sky': {
+    readonly kind: "toggle";
+    readonly description: "A sky with atmosphere behind the globe and above a tilted flat map. Without it MapLibre draws a fully transparent sky, so a globe arrives with no atmosphere.";
+    readonly appliesTo: "any-style";
+    readonly mechanisms: [{
+      readonly type: "sky";
+    }];
+  };
+  readonly 'view.skyColor': {
+    readonly kind: "color";
+    readonly description: "Colour of the sky (and of the atmosphere halo around the globe). Defaults to a daylit blue on a light style and a night blue on a dark one.";
+    readonly appliesTo: "any-style";
+    readonly mechanisms: [{
+      readonly type: "sky";
+    }];
+  };
+  readonly 'view.horizonColor': {
+    readonly kind: "color";
+    readonly description: "Colour of the sky at the horizon. Defaults with the style theme, so a dark map gets a dim horizon rather than a white one.";
+    readonly appliesTo: "any-style";
+    readonly mechanisms: [{
+      readonly type: "sky";
+    }];
+  };
+  readonly 'view.spaceColor': {
+    readonly kind: "color";
+    readonly description: "Colour behind the map, which a globe leaves visible around the planet. The map canvas is transparent, so without this the page background shows through. Defaults with the style theme: white on a light style, near-black on a dark one.";
+    readonly appliesTo: "any-style";
+    readonly mechanisms: [{
+      readonly type: "space";
+    }];
+  };
+  readonly 'view.terrain': {
+    readonly kind: "toggle";
+    readonly description: "3D terrain from the style's elevation source (the hillshade style part). Needs a tilted camera to show; MapLibre's terrain fog starts at pitch 60, which is also its default maxPitch.";
+    readonly appliesTo: "any-style";
+    readonly mechanisms: [{
+      readonly type: "terrain";
+    }];
+  };
+  readonly 'view.terrainExaggeration': {
+    readonly kind: "number";
+    readonly description: "Vertical exaggeration of the 3D terrain (1 = true elevation).";
+    readonly range: {
+      readonly min: 0.5;
+      readonly max: 3;
+      readonly step: 0.1;
+    };
+    readonly appliesTo: "any-style";
+    readonly mechanisms: [{
+      readonly type: "terrain";
+    }];
+  };
+};
+/**
+ * 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[];
+/**
+ * The id of a styling knob that holds a colour — every colour the styling module can name, and so
+ * resolve against whichever style is loaded.
+ *
+ * @group Map Styling
+ */
+type StylingColorKnobId = { [ID in StylingKnobId]: (typeof knobDefinitions)[ID]['kind'] extends 'color' ? ID : never; }[StylingKnobId];
+/**
+ * Every colour knob id, in catalogue order.
+ *
+ * @group Map Styling
+ */
+export declare const stylingColorKnobIds: StylingColorKnobId[];
+type ValueOfKind<KIND extends StylingKnobKind> = KIND extends 'toggle' ? boolean : KIND extends 'color' | 'enum' ? 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
- * // Create the module
- * const routingModule = await RoutingModule.create(map, {
- *   displayUnits: {
- *     distance: { type: 'metric' }
- *   }
- * });
+ * import { StylingModule } from '@tomtom-org/maps-sdk/map';
  *
- * // Calculate and display a route
- * const result = await calculateRoute({
- *   key: 'your-api-key',
- *   locations: [
- *     [4.9041, 52.3676],  // Amsterdam
- *     [4.4777, 51.9244]   // Rotterdam
- *   ],
- *   routeOptions: {
- *     travelMode: 'car',
- *     routeType: 'fastest'
- *   }
- * });
+ * const styling = await StylingModule.get(map);
+ * styling.set('labels.sizeFactor', 1.2);
+ * styling.set('roads.exitNumbers', false);
+ * styling.set('traffic.flow.slowColor', '#f59e0b');
  *
- * await routingModule.showRoutes(result);
+ * // 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 [Routing Guide](https://docs.tomtom.com/maps-sdk-js/guides/map/routing)
+ * @see [Map Styling Guide](https://docs.tomtom.com/maps-sdk-js/guides/map/styling)
  *
- * @group Routing
+ * @group Map Styling
  */
-export declare class RoutingModule extends AbstractDataOwnedMapModule<RoutingSourcesWithLayers, RoutingModuleConfig> {
-  private layersSpecs;
-  private layerIDPrefix;
-  private readonly shownFeaturesHandlers;
+export declare class StylingModule extends AbstractStyleOwnedMapModule<Record<string, never>, StylingSettings> {
+  private originalValues;
+  private mapLevelState;
+  private styleSources;
+  private resolved;
+  private scaleKnobsByTarget;
+  private mapColorTargetsByKey;
+  private mapColorTargetsByKnob;
+  private mapColorAnchors;
+  private warned;
+  private reindexed;
+  private originalSpaceColor;
   /**
-   * Make sure the map is ready before create an instance of the module and any other interaction with the map
-   * @param tomtomMap The TomTomMap instance.
-   * @param config  The module optional configuration
-   * @returns {Promise} Returns a promise with a new instance of this module
-   *
-   * @remarks
-   * **Instances:**
-   * `RoutingModule` owns the sources, layers and images it adds, all suffixed per instance. Every
-   * call therefore returns a **new, independent** instance, and stacking several of them on one
-   * map is a supported thing to do.
-   *
-   * **Configuration Options:**
-   * - `displayUnits`: Distance units (metric/imperial)
-   * - `waypointsSource`: Waypoint entry point options
-   * - `layers`: Complete layer styling configuration
+   * Retrieves the styling module of the given map, creating it on first use.
    *
-   * **Default Styling:**
-   * If no custom layers are provided, uses {@link defaultRoutingLayers}.
+   * @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.
    *
-   * @example
-   * Default initialization:
-   * ```typescript
-   * const routingModule = await RoutingModule.create(map);
-   * ```
+   * @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
-   * With custom configuration:
    * ```typescript
-   * const routingModule = await RoutingModule.create(map, {
-   *   displayUnits: 'imperial',
-   *   waypointsSource: {
-   *     entryPoints: 'main-when-available'
-   *   }
-   * });
+   * const styling = await StylingModule.get(map, { 'labels.sizeFactor': 1.2 });
    * ```
    */
-  static create(tomtomMap: TomTomMap, config?: RoutingModuleConfig): Promise<RoutingModule>;
+  static get(map: TomTomMap, settings?: StylingSettings): Promise<StylingModule>;
   private constructor();
-  private createSourcesWithLayers;
   /**
    * @ignore
    */
-  protected _initSourcesWithLayers(config?: RoutingModuleConfig, restore?: boolean): RoutingSourcesWithLayers;
+  protected styleChangePriority(): number;
   /**
    * @ignore
    */
-  protected _applyConfig(config?: RoutingModuleConfig): RoutingModuleConfig;
-  /** @ignore */
-  protected discardShownData(): void;
+  protected _initSourcesWithLayers(): Record<string, never>;
   /**
    * @ignore
    */
-  protected restoreDataAndConfigImpl(): void;
-  private addImageIfNotExisting;
+  protected _applyConfig(settings: StylingSettings | undefined): StylingSettings | undefined;
   /**
-   * Displays the given routes on the map.
-   *
-   * @param routes - Route data from Routing API or custom routes.
-   * @param options - Optional configuration for route selection and display.
-   * @param options.selectedIndex - Index of the route to display as selected (default: 0).
+   * The styling catalogue for the loaded style: every knob with its kind, range, default, current
+   * value and how many layers it reaches.
    *
    * @remarks
-   * **Waypoints are NOT shown by this method.**
-   * Route lines are drawn but start/stop/destination markers are not. To display waypoint
-   * markers, call {@link showWaypoints} separately. Alternatively, use
-   * {@link PlacesModule} to display waypoints as fully customizable place markers.
-   *
-   * **Behavior:**
-   * - Replaces any previously shown routes
-   * - Shows all route-related features: lines, sections, summaries, guidance
-   * - First route is selected by default (appears more prominent)
-   *
-   * **Route Features:**
-   * - Main route lines (selected and deselected styles)
-   * - Traffic sections with delays
-   * - Ferry, tunnel, and charged-road (`tollRoad`) sections
-   * - EV charging stations (for EV routes)
-   * - Turn-by-turn instruction lines and arrows
-   * - Summary bubbles with distance/time/traffic info
+   * 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
-   * Show a route (no waypoint markers):
    * ```typescript
-   * await routing.showRoutes(response.routes);
-   * // Waypoint markers are NOT shown — call showWaypoints() to add them
+   * const { knobs } = styling.describe();
+   * const sliders = knobs.filter((knob) => knob.kind === 'factor' && knob.available);
    * ```
+   */
+  describe(): StylingCatalogue;
+  /**
+   * Applies a preset: a named bundle of knob settings the SDK ships for a common intent
+   * (`data-viz`, `night-driving`, `minimal`, `globe`, `terrain`). See `describe().presets` for
+   * what each one sets.
    *
-   * @example
-   * Show routes and waypoint markers:
-   * ```typescript
-   * const locations = [[4.9, 52.4], [4.5, 51.9]];
-   * const response = await calculateRoute({ locations });
-   * await routing.showRoutes(response.routes);
-   * await routing.showWaypoints(locations); // Show start/destination markers separately
-   * ```
+   * @param id - The preset to apply.
+   * @param options - `merge: true` lays the preset over the current settings instead of replacing
+   * them (the default), so knobs the preset does not mention keep their values.
+   * @throws `Error` for an unknown preset id.
    *
    * @example
-   * Show multiple routes with specific selection:
    * ```typescript
-   * await routing.showRoutes(response.routes, { selectedIndex: 1 });
+   * styling.applyPreset('data-viz');
+   * styling.set('labels.sizeFactor', 1.1); // then adjust
+   *
+   * styling.applyPreset('globe', { merge: true }); // keep the rest, switch to a globe with a sky
    * ```
    */
-  showRoutes(routes: Route | Routes, options?: ShowRoutesOptions): Promise<void>;
+  applyPreset(id: StylingPresetId, options?: {
+    merge?: boolean;
+  }): void;
   /**
-   * Clears any previously shown routes from the map.
+   * The value a knob currently has: the override if one is set, otherwise the style's own default.
    *
-   * @remarks
-   * - Clears all route-related layers (lines, sections, guidance, summaries)
-   * - Does NOT clear waypoints (use {@link clearWaypoints})
-   * - Module remains initialized and ready for new routes
+   * @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
-   * await routing.clearRoutes();
+   * styling.get('labels.sizeFactor'); // 1 until set
    * ```
    */
-  clearRoutes(): Promise<void>;
+  get<ID extends StylingKnobId>(id: ID): StylingKnobValueOf<ID> | undefined;
   /**
-   * Changes which route appears as selected.
-   *
-   * @param index - Zero-based index of the route to select.
+   * 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.
    *
-   * @remarks
-   * **Visual Changes:**
-   * - Selected route appears more prominent (thicker, brighter)
-   * - Previously selected route becomes deselected style
-   * - Updates all route-related features (sections, guidance)
-   *
-   * **Requirements:**
-   * - Route must already be displayed via {@link showRoutes}
-   * - Index must be within range of displayed routes
+   * @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
-   * // Show multiple routes
-   * await routingModule.showRoutes(routes);
-   *
-   * // User clicks alternative route
-   * await routingModule.selectRoute(1);
-   *
-   * // Switch back to first route
-   * await routingModule.selectRoute(0);
+   * styling.set('roads.widthFactor', 1.3);
+   * styling.set('buildings.3d', true);
+   * styling.set('traffic.flow.stationaryColor', 'hsl(0, 100%, 40%)');
    * ```
    */
-  selectRoute(index: number): Promise<void>;
+  set<ID extends StylingKnobId>(id: ID, value: StylingKnobValueOf<ID>): void;
   /**
-   * Displays waypoint markers (start, stop, and destination pins) on the map.
-   *
-   * @param waypoints - An array of planning waypoints or a `Waypoints` FeatureCollection.
+   * Restores the style's own values for one knob, or for all of them.
    *
-   * @remarks
-   * Waypoint markers are **not** shown by {@link showRoutes} — this method must be called
-   * separately to display them. For more control over marker appearance and behavior,
-   * consider using {@link PlacesModule} to render waypoints as place markers instead.
+   * @param id - The knob to reset; omit to reset every knob (same as {@link resetConfig}).
    *
    * @example
-   * Show routes and then waypoints:
    * ```typescript
-   * const locations = [[4.9041, 52.3676], [4.4777, 51.9244]];
-   * const response = await calculateRoute({ locations });
-   * await routingModule.showRoutes(response.routes);
-   * await routingModule.showWaypoints(locations); // Must be called separately
+   * styling.reset('labels.sizeFactor');
+   * styling.reset(); // back to the style as shipped
    * ```
    */
-  showWaypoints(waypoints: PlanningWaypoint[] | Waypoints): Promise<void>;
-  /**
-   * Clears any previously shown waypoints from the map.
-   * If nothing was shown before, nothing happens.
-   */
-  clearWaypoints(): Promise<void>;
+  reset(id?: StylingKnobId): void;
   /**
-   * Returns the currently shown routes and waypoints.
-   *
-   * @returns An object containing all currently displayed routing data.
+   * Recolours the whole base map with up to ten semantic colours in one call — Map Maker's
+   * Foundations palette, each listed with what it reaches under {@link MapColorName}. Partial
+   * objects are fine; colours not given stay as they are.
    *
    * @remarks
-   * Returns the exact data that was passed to the `showRoutes()` and `showWaypoints()` methods.
+   * Each colour re-derives every shade the style built from it — a trunk variant, an outline, a
+   * tunnel — at the style's own HSL offset, so those relationships survive the recolour. The ten
+   * are also the `colors.*` knobs, so `describe()`, `reset` and settings persistence apply.
    *
-   * **Returned Data:**
-   * - `mainLines`: Main route lines (selected and alternative)
-   * - `waypoints`: Route waypoints (start, stops, finish)
-   * - `incidents`: Traffic incidents on routes
-   * - `ferries`: Ferry sections
-   * - `chargingStops`: EV charging stations
-   * - `tollRoads`: Sections that cost money to drive — the `tollRoad` section type
-   * - `tunnels`: Tunnel sections
-   * - `vehicleRestricted`: Vehicle-restricted sections
-   * - `instructionLines`: Turn-by-turn instruction lines
-   * - `instructionArrows`: Instruction arrow markers
-   * - `summaryBubbles`: Route summary popups
+   * Those offsets come off the loaded style, which makes a palette a recolour and not an
+   * inversion: dark land over `standardLight` pushes the derived shades to the ends of their
+   * range, so switch to `standardDark` first.
    *
-   * @example
-   * ```typescript
-   * const shown = routingModule.getShown();
-   * console.log(`Showing ${shown.mainLines.features.length} routes`);
-   * console.log(`Showing ${shown.waypoints.features.length} waypoints`);
-   * console.log(`Showing ${shown.chargingStops.features.length} charging stops`);
-   * ```
+   * @param colors - The colours to set, as CSS colour strings.
+   * @throws `RangeError` for a value that is not a colour; `Error` for an unknown colour name.
    *
    * @example
-   * Check if any routes are displayed:
    * ```typescript
-   * const shown = routingModule.getShown();
-   * if (shown.mainLines.features.length > 0) {
-   *   console.log('Routes are displayed');
-   * } else {
-   *   console.log('No routes displayed');
-   * }
+   * styling.setMapColors({ land: '#f3f5f7', water: '#accbe2', roadMajor: '#a1b8ce', label: '#364659' });
+   * styling.reset('colors.roadMajor'); // one colour back to the style
    * ```
    */
-  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;
-  };
+  setMapColors(colors: MapColors): void;
   /**
-   * Unified events interface for the routing module.
+   * The style as currently rendered — the loaded style with every knob applied — as a MapLibre
+   * style specification, to save, diff, serve yourself, or load back as a custom style.
    *
-   * `events` itself covers every route feature and the module's lifecycle events; the named
-   * scopes below cover one part of a route each, and every one of them can be narrowed further
-   * with `where()`.
+   * @remarks
+   * It includes whatever the SDK's data modules (places, routes) have on the map, and its tile
+   * URLs carry the API key the map was created with: strip or rotate it before publishing.
+   */
+  exportStyle(): StyleSpecification;
+  /**
+   * 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
-   * routing.events.mainLines.on('click', (route) => { ... });
-   * routing.events.waypoints.on('hover', (waypoint) => { ... });
-   *
-   * // Only the long tunnels, with their own hover cursor:
-   * routing.events.tunnels
-   *     .where((section) => section.properties.lengthInMeters > 500, { cursorOnHover: 'help' })
-   *     .on('click', showTunnel);
-   *
-   * const unsub = routing.events.on('config-change', (config) => { ... });
-   * routing.events.on('shown-features', (features) => {
-   *   if ('routes' in features) { ... }
-   * });
-   * unsub();
+   * styling.events.on('config-change', (settings) => localStorage.setItem('styling', JSON.stringify(settings)));
    * ```
    */
-  get events(): RoutingEvents;
-  /**
-   * Returns the map style layer under which route lines are rendered.
-   * * Useful if you want to render extra layers just above the route ones but not on top of everything else.
-   * * It might differ depending on the loaded style/version.
-   */
-  getLayerToRenderLinesUnder(): string;
+  get events(): StylingEvents;
+  private indexStyle;
+  private resolveMechanism;
+  private capture;
+  private originalValueOf;
+  private resolveMapColor;
+  private demSourceId;
+  private refreshKnob;
+  private refreshMechanism;
+  private refreshSpace;
+  private defaultSpaceColor;
+  private refreshMapColorProperty;
+  private refreshProjection;
+  private refreshSky;
+  private refreshTerrain;
+  private refreshVisibility;
+  private refreshMinZoom;
+  private refreshZoomOffset;
+  private refreshScaledProperty;
+  private refreshColor;
+  private setProperty;
+  private describeKnob;
+  private defaultOf;
+  private mapLevelDefaultOf;
+  private assertKnob;
+  private validate;
+  private warnOnce;
 }
 //#endregion
 //#region src/traffic/types/trafficAreaAnalyticsConfig.d.ts
@@ -10565,6 +12234,17 @@ type AreaAnalyticsRegionPolygonConfig = {
    */
   inverted?: boolean;
 };
+/**
+ * The green / amber / red every metric's default colour stops and the `trafficLight` colour theme
+ * are drawn from.
+ *
+ * @ignore
+ */
+declare const TRAFFIC_LIGHT_COLORS: {
+  readonly good: "#2dc653";
+  readonly moderate: "#f5a623";
+  readonly bad: "#e03030";
+};
 /**
  * Default values for all {@link TrafficAreaAnalyticsConfig} options.
  *
@@ -10585,10 +12265,16 @@ declare const AREA_ANALYTICS_DEFAULTS: {
     congestionLevel: {
       color: {
         valueType: "raw";
-        stops: {
+        stops: ({
+          value: number;
+          color: "#2dc653";
+        } | {
           value: number;
-          color: string;
-        }[];
+          color: "#f5a623";
+        } | {
+          value: number;
+          color: "#e03030";
+        })[];
       };
       height: {
         maxHeightMeters: number;
@@ -10599,10 +12285,16 @@ declare const AREA_ANALYTICS_DEFAULTS: {
     speed: {
       color: {
         valueType: "relativeToPredefinedRangePCT";
-        stops: {
+        stops: ({
+          value: number;
+          color: "#e03030";
+        } | {
           value: number;
-          color: string;
-        }[];
+          color: "#f5a623";
+        } | {
+          value: number;
+          color: "#2dc653";
+        })[];
       };
       height: {
         maxHeightMeters: number;
@@ -10613,10 +12305,16 @@ declare const AREA_ANALYTICS_DEFAULTS: {
     travelTime: {
       color: {
         valueType: "relativeToPredefinedRangePCT";
-        stops: {
+        stops: ({
+          value: number;
+          color: "#2dc653";
+        } | {
           value: number;
-          color: string;
-        }[];
+          color: "#f5a623";
+        } | {
+          value: number;
+          color: "#e03030";
+        })[];
       };
       height: {
         maxHeightMeters: number;
@@ -10627,10 +12325,16 @@ declare const AREA_ANALYTICS_DEFAULTS: {
     freeFlowSpeed: {
       color: {
         valueType: "relativeToPredefinedRangePCT";
-        stops: {
+        stops: ({
+          value: number;
+          color: "#e03030";
+        } | {
           value: number;
-          color: string;
-        }[];
+          color: "#f5a623";
+        } | {
+          value: number;
+          color: "#2dc653";
+        })[];
       };
       height: {
         maxHeightMeters: number;
@@ -10641,10 +12345,16 @@ declare const AREA_ANALYTICS_DEFAULTS: {
     networkLength: {
       color: {
         valueType: "relativeToActualRangePCT";
-        stops: {
+        stops: ({
+          value: number;
+          color: "#2dc653";
+        } | {
           value: number;
-          color: string;
-        }[];
+          color: "#f5a623";
+        } | {
+          value: number;
+          color: "#e03030";
+        })[];
       };
       height: {
         maxHeightMeters: number;
@@ -11370,7 +13080,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 +13833,6 @@ type TrafficIncidentsSourcesWithLayers = {
  * @group Traffic Incidents
  */
 export declare class TrafficIncidentsModule extends AbstractStyleOwnedMapModule<TrafficIncidentsSourcesWithLayers, IncidentsConfig> {
-  private originalFilters;
   /**
    * Retrieves a TrafficIncidentsModule instance for the given map.
    *
@@ -12368,6 +14076,20 @@ export declare class TrafficIncidentsModule extends AbstractStyleOwnedMapModule<
   get events(): CombinedEvents<TrafficIncidentsModuleFeature, IncidentsConfig, never>;
 }
 //#endregion
+//#region src/utils/colorUtils.d.ts
+/**
+ * Red, green, blue and alpha of a colour, each 0–1.
+ * @ignore
+ */
+type RGBAColor = [number, number, number, number];
+/**
+ * Parses any CSS colour a map style writes — `#rgb`, `#rrggbb(aa)`, `rgb()`/`rgba()` in numbers or
+ * percentages, `hsl()`/`hsla()`, `transparent` and the named colours — or `undefined` for a string
+ * that is not one.
+ * @ignore
+ */
+export declare const parseCssColor: (cssColor: string) => RGBAColor | undefined;
+//#endregion
 //#region src/utils/types/paddedBounds.d.ts
 /**
  * Options for calculating map center.
@@ -12448,4 +14170,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, CountryCrossingAlignment, CountryCrossingConfig, CountryCrossingFeature, CustomImage, DefaultPlaceIconConfig, DisplayCountryCrossing, DisplayCountryCrossingProps, DisplayCountryCrossings, DisplayRouteProps, DisplayRouteRelatedProps, DisplayRouteSummaries, DisplayRouteSummary, DisplayRouteSummaryProps, DrawnSectionType, EVAvailabilityConfig, EventHandlerConfig, EventHandlerCursorConfig, EventType, ExtraFeatureProp, FeaturePropValue, FilterShowMode, FilterablePOICategory, GeneratedSectionType, GeoJSONSourcesWithLayers, HasAdditionalLayersConfig, HasBeforeID, HillshadeModuleConfig, HoverEventType, IncidentFocusStyle, LayerSpecFilter, LayerSpecTemplate, LayerSpecWithSource, LightDark, MapColorName, MapColors, MapEventsConfig, MapFont, MapModuleCommonConfig, MapStyleLayerID, POIsModuleConfig, POIsModuleFeature, PlaceConnectionDisplay, PlaceConnectionLayerName, PlaceConnectionsConfig, PlaceConnectionsLayersConfig, PlaceIconConfig, PlaceLayerName, PlaceLayersConfig, PlaceTextConfig, PlacesModuleConfig, PlacesTheme, PlanningWaypoint, PutEventStateOptions, RGBAColor, RouteLayersConfig, RouteStateProps, RouteTheme, RouteWaypointSize, RouteWidth, RoutingModuleConfig, SVGIconStyleOptions, SectionDisplayConfig, SectionDrawStyle, SectionIconConfig, SectionKnobName, SectionKnobOf, SectionLineLayerName, SectionLinePattern, SectionSignConfig, SectionSignLayerName, SectionSignPlacement, SectionSignPriority, SectionSignUnit, SectionSourceKey, SectionSymbolLayerName, SectionsDisplayConfig, SourceWithLayerIDs, SourceWithLayers, SourcesWithLayers, StyleSourcesWithLayers, StylingCatalogue, StylingColorKnobId, StylingKnobAppliesTo, StylingKnobDescriptor, StylingKnobId, StylingKnobKind, StylingKnobRange, StylingKnobValue, StylingKnobValueOf, StylingPresetDescriptor, StylingPresetId, StylingSettings, SupportsEvents, SymbolLayerSpecWithoutSource, TRAFFIC_LIGHT_COLORS, ToBeAddedLayerSpec, ToBeAddedLayerSpecTemplate, ToBeAddedLayerSpecWithoutSource, TrafficAreaAnalyticsConfig, TrafficIncidentOverlayConfig, UserEventHandler, ValuesFilter, WaypointsConfig };