@tomtom-org/maps-sdk 0.45.6 → 0.45.8

package/map/dist/index.d.ts

@@ -35,7 +35,9 @@ import { Places } from '@tomtom-org/maps-sdk/core';
 import { Places as Places_2 } from '@tomtom-org/maps-sdk/core';
 import { POICategory } from '@tomtom-org/maps-sdk/core';
 import { Point } from 'geojson';
+import { PolygonFeature } from '@tomtom-org/maps-sdk/core';
 import { PolygonFeatures } from '@tomtom-org/maps-sdk/core';
+import { PolygonFeatures as PolygonFeatures_2 } from '@tomtom-org/maps-sdk/core';
 import { Position } from 'geojson';
 import { Route } from '@tomtom-org/maps-sdk/core';
 import { RouteProps } from '@tomtom-org/maps-sdk/core';
@@ -46,6 +48,7 @@ import { Source } from 'maplibre-gl';
 import { SourceSpecification } from 'maplibre-gl';
 import { StyleSpecification } from 'maplibre-gl';
 import { SymbolLayerSpecification } from 'maplibre-gl';
+import { TrafficIncidentCategory } from '@tomtom-org/maps-sdk/core';
 import { TrafficSectionProps } from '@tomtom-org/maps-sdk/core';
 import { Waypoint } from '@tomtom-org/maps-sdk/core';
 import { WaypointLike } from '@tomtom-org/maps-sdk/core';
@@ -965,6 +968,31 @@ declare type BaseSourceAndLayers = {
  */
 export declare const buildPlaceTitle: (place: Place) => string;
 
+/**
+ * Attaches labels and applies theme-specific geometry to reachable range polygon features.
+ *
+ * Features must be ordered **largest budget first** (e.g. 30 min, 20 min, 10 min).
+ * For the `inverted` theme, polygons are converted to donuts and one extra innermost feature is appended.
+ *
+ * @param features Polygon features from `calculateReachableRange`, ordered largest budget first.
+ * @param labels   Label per feature in matching order (e.g. `['30 min', '20 min', '10 min']`).
+ * @param theme    Visual theme. Defaults to `'filled'`.
+ *
+ * @example
+ * ```typescript
+ * const features = [range30min, range20min, range10min];
+ * const labels   = ['30 min', '20 min', '10 min'];
+ *
+ * module.show({
+ *     type: 'FeatureCollection',
+ *     features: buildReachableRangeFeatures(features, labels, 'inverted'),
+ * });
+ * ```
+ *
+ * @group Geometries
+ */
+export declare const buildReachableRangeFeatures: (features: PolygonFeature[], labels: string[], theme?: GeometryTheme) => PolygonFeature[];
+
 /**
  * Generates the routing layers configuration for route visualization on the map.
  * @param config - Optional routing module configuration to customize layer properties.
@@ -1301,9 +1329,11 @@ export declare type CleanEventStatesOptions = {
  */
 export declare type ClickEventType = 'click' | 'contextmenu';
 
-declare type ColorPaletteOptions = keyof typeof colorPalettes;
+export declare const colorPaletteIDs: ColorPaletteOptions[];
 
-declare const colorPalettes: {
+export declare type ColorPaletteOptions = keyof typeof colorPalettes;
+
+export declare const colorPalettes: {
     warm: string[];
     browns: string[];
     cold: string[];
@@ -1585,7 +1615,7 @@ export declare const defaultRoutingLayers: Required<RouteLayersConfig>;
  * Allows filtering incidents based on whether they cause delays and the severity of those delays.
  * Useful for focusing on incidents with the most significant traffic impact.
  *
- * @group Traffic
+ * @group Traffic Incidents
  */
 export declare type DelayFilter = {
     /**
@@ -2265,7 +2295,27 @@ export declare class EventsModule<T = MapGeoJSONFeature> {
     private readonly eventProxy;
     private readonly sourceWithLayers;
     private readonly config;
-    constructor(eventProxy: EventsProxy, sourceWithLayers: SourceWithLayers, config: EventHandlerConfig | undefined);
+    /**
+     * Optional function that transforms a raw {@link MapGeoJSONFeature} into the
+     * feature type `T` exposed by the module. When provided, every feature passed (fired)
+     * to event handlers is first run through this function, so callers receive the
+     * module's own feature shape instead of the underlying MapLibre feature.
+     *
+     * When omitted, `T` defaults to `MapGeoJSONFeature` and features are forwarded
+     * as-is.
+     */
+    private readonly mapping?;
+    constructor(eventProxy: EventsProxy, sourceWithLayers: SourceWithLayers, config: EventHandlerConfig | undefined, 
+    /**
+     * Optional function that transforms a raw {@link MapGeoJSONFeature} into the
+     * feature type `T` exposed by the module. When provided, every feature passed (fired)
+     * to event handlers is first run through this function, so callers receive the
+     * module's own feature shape instead of the underlying MapLibre feature.
+     *
+     * When omitted, `T` defaults to `MapGeoJSONFeature` and features are forwarded
+     * as-is.
+     */
+    mapping?: ((feature: MapGeoJSONFeature) => T) | undefined);
     /**
      * Register an event handler for user interactions with map features.
      *
@@ -2764,11 +2814,14 @@ export declare class GeometriesModule extends AbstractMapModule<GeometrySourcesW
     private titleLayerSpecs;
     private geometryFillLayerSpecs;
     private geometryOutlineLayerSpecs;
+    private lineLabelLayerSpecs;
     private sourceID;
     private fillLayerID;
     private outlineLayerID;
+    private lineLabelLayerID;
     private titleSourceID;
     private titleLayerID;
+    private lastRawInput;
     /**
      * 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.
@@ -3142,18 +3195,61 @@ export declare type GeometriesModuleConfig = MapModuleCommonConfig & {
      * ```
      */
     beforeLayerConfig?: GeometryBeforeLayerConfig;
+    /**
+     * Line label configuration.
+     *
+     * When set, labels are placed along the polygon border lines.
+     */
+    lineLabelConfig?: GeometryLineLabelConfig;
+    /**
+     * Visual theme applied to all features shown by this module.
+     *
+     * - `'filled'` — Colored fill with thin border (default)
+     * - `'outline'` — Transparent fill with thick colored border
+     * - `'inverted'` — Colors the area **outside** the polygon (donut geometry)
+     *
+     * Individual features can override this by setting `theme` in their properties.
+     *
+     * @example
+     * ```typescript
+     * // Show the "rest of the world" outside a country
+     * const module = await GeometriesModule.get(map, {
+     *     theme: 'inverted',
+     *     colorConfig: { fillColor: 'black', fillOpacity: 0.5 }
+     * });
+     * module.show(countryGeometry);
+     * ```
+     */
+    theme?: GeometryTheme;
+    /**
+     * Transform applied to features before rendering.
+     *
+     * Receives the value passed to {@link GeometriesModule.show} and returns
+     * features ready for display. Useful for deriving labels or other display
+     * properties from domain data.
+     *
+     * @remarks
+     * Used internally by {@link reachableRangeGeometryConfig} to generate budget
+     * labels (e.g. `'30 min'`) from feature properties. For most use cases,
+     * the standard config fields (`colorConfig`, `textConfig`, `theme`) suffice.
+     *
+     * @example
+     * ```typescript
+     * // Derive title from a custom property
+     * const config: GeometriesModuleConfig = {
+     *     transformFeaturesForDisplay: (fc) => ({
+     *         ...fc,
+     *         features: fc.features.map((f) => ({
+     *             ...f,
+     *             properties: { ...f.properties, title: f.properties?.customLabel },
+     *         })),
+     *     }),
+     * };
+     * ```
+     */
+    transformFeaturesForDisplay?: (input: PolygonFeatures_2) => PolygonFeatures_2;
 };
 
-/**
- * @ignore
- */
-export declare const GEOMETRY_COLOR_PROP = "color";
-
-/**
- * @ignore
- */
-export declare const GEOMETRY_TITLE_PROP = "title";
-
 /**
  * Layer positioning configuration for geometries.
  *
@@ -3214,7 +3310,7 @@ export declare type GeometryColorConfig = {
      * - Color palette name (e.g., `'red'`, `'blue'`)
      * - MapLibre expression for data-driven styling
      *
-     * @default '#0080FF'
+     * @default '#0A3653'
      *
      * @example
      * ```typescript
@@ -3238,7 +3334,7 @@ export declare type GeometryColorConfig = {
      * @remarks
      * Value between 0 (fully transparent) and 1 (fully opaque).
      *
-     * @default 0.3
+     * @default 0.15
      *
      * @example
      * ```typescript
@@ -3279,7 +3375,7 @@ export declare type GeometryLineConfig = {
     /**
      * Color of the geometry border/outline.
      *
-     * @default '#0080FF'
+     * @default '#0A3653'
      *
      * @example
      * ```typescript
@@ -3318,6 +3414,97 @@ export declare type GeometryLineConfig = {
     lineWidth?: DataDrivenPropertyValueSpecification<number>;
 };
 
+/**
+ * Line label configuration for geometries.
+ *
+ * When set, a symbol layer is added to the geometry source,
+ * placing labels along the polygon border lines
+ *
+ * @example
+ * ```typescript
+ * // Defaults
+ * const lineLabelConfig: GeometryLineLabelConfig = {};
+ *
+ * // Custom appearance for dark fills
+ * const lineLabelConfig: GeometryLineLabelConfig = {
+ *   minZoom: 10,
+ *   textColor: '#FFFFFF',
+ *   textHaloColor: '#000000',
+ *   textSize: 13
+ * };
+ * ```
+ *
+ * @group Geometries
+ */
+export declare type GeometryLineLabelConfig = {
+    /**
+     * Minimum zoom level at which border labels are visible.
+     *
+     * @default 3
+     */
+    minZoom?: number;
+    /**
+     * Font size of the border labels in pixels.
+     *
+     * @default 15
+     *
+     * @example
+     * ```typescript
+     * textSize: 13
+     * // Data-driven
+     * textSize: ['interpolate', ['linear'], ['zoom'], 8, 12, 14, 16]
+     * ```
+     */
+    textSize?: DataDrivenPropertyValueSpecification<number>;
+    /**
+     * Color of the border label text.
+     *
+     * @default '#333333'
+     *
+     * @example
+     * ```typescript
+     * textColor: '#FFFFFF'
+     * textColor: ['get', 'labelColor']
+     * ```
+     */
+    textColor?: DataDrivenPropertyValueSpecification<string>;
+    /**
+     * Color of the halo drawn around the border label text.
+     *
+     * The halo improves legibility against complex or dark backgrounds.
+     *
+     * @default '#FFFFFF'
+     *
+     * @example
+     * ```typescript
+     * textHaloColor: '#000000'
+     * ```
+     */
+    textHaloColor?: DataDrivenPropertyValueSpecification<string>;
+    /**
+     * Width of the halo drawn around the border label text, in pixels.
+     *
+     * @default 2
+     *
+     * @example
+     * ```typescript
+     * textHaloWidth: 3
+     * ```
+     */
+    textHaloWidth?: DataDrivenPropertyValueSpecification<number>;
+    /**
+     * Distance between repeated labels along the border line, in pixels.
+     *
+     * @default 200
+     *
+     * @example
+     * ```typescript
+     * symbolSpacing: 350
+     * ```
+     */
+    symbolSpacing?: number;
+};
+
 /**
  * IDs of sources and layers from a geometry module.
  */
@@ -3369,6 +3556,27 @@ export declare type GeometryTextConfig = {
     textField: DataDrivenPropertyValueSpecification<string>;
 };
 
+/**
+ * Visual theme for polygon display with {@link GeometriesModule}.
+ *
+ * - `'filled'`   — Colored fill with thin border (default)
+ * - `'outline'`  — Transparent fill with thick colored border
+ * - `'inverted'` — Colors the area **outside** the polygon (donut geometry)
+ *
+ * Set via {@link GeometriesModuleConfig.theme} at config level, or per-feature in
+ * `properties.theme`.
+ *
+ * @group Geometries
+ */
+export declare type GeometryTheme = 'filled' | 'outline' | 'inverted';
+
+/**
+ * All valid {@link GeometryTheme} values.
+ *
+ * @group Geometries
+ */
+export declare const geometryThemes: readonly ["filled", "outline", "inverted"];
+
 /**
  * Gets the map style sprite image ID to display on the map for the give place.
  * @ignore
@@ -3650,47 +3858,6 @@ declare type HillshadeSourcesWithLayers = {
  */
 export declare type HoverEventType = 'hover' | 'hover-move' | 'long-hover';
 
-/**
- * Available traffic incident category identifiers.
- *
- * @remarks
- * These categories classify different types of traffic incidents that can be displayed on the map.
- *
- * @group Traffic Incidents
- */
-export declare const incidentCategories: readonly ["unknown", "accident", "fog", "dangerous_conditions", "rain", "ice", "jam", "lane_closed", "road_closed", "road_works", "wind", "flooding", "broken_down_vehicle"];
-
-/**
- * @ignore
- */
-export declare const incidentCategoriesMapping: Record<IncidentCategory, number>;
-
-/**
- * Traffic incident category type.
- *
- * @remarks
- * Represents the type of traffic incident affecting road conditions.
- * Used for filtering and categorizing incidents displayed on the map.
- *
- * Available categories:
- * - `unknown` - Unclassified incident
- * - `accident` - Vehicle collision or crash
- * - `fog` - Low visibility due to fog
- * - `dangerous_conditions` - Hazardous road conditions
- * - `rain` - Heavy rain affecting traffic
- * - `ice` - Icy road conditions
- * - `jam` - Traffic congestion or standstill
- * - `lane_closed` - One or more lanes unavailable
- * - `road_closed` - Complete road closure
- * - `road_works` - Construction or maintenance
- * - `wind` - Strong winds affecting traffic
- * - `flooding` - Water on roadway
- * - `broken_down_vehicle` - Disabled vehicle blocking traffic
- *
- * @group Traffic Incidents
- */
-export declare type IncidentCategory = (typeof incidentCategories)[number];
-
 /**
  * Common configuration for traffic incident visualization components.
  *
@@ -5699,7 +5866,7 @@ export declare type POIsModuleConfig = MapModuleCommonConfig & {
  */
 export declare type POIsModuleFeature = Omit<MapGeoJSONFeature, 'properties'> & {
     /**
-     * POI-specific properties from the vector tile.
+     * POI-specific properties from the vector tile data.
      */
     properties: {
         /**
@@ -5772,6 +5939,39 @@ declare type PoIsSourcesAndLayers = {
  */
 export declare const preparePlacesForDisplay: (placesInput: Place | Place[] | Places_2, instanceIndex: number, config?: PlacesModuleConfig) => Places_2<DisplayPlaceProps>;
 
+/**
+ * Prepares the output of `calculateReachableRanges` for display with {@link GeometriesModule}.
+ *
+ * Derives labels from each feature's `budget` property by default, applies theme-specific
+ * geometry, and preserves the bounding box. Pass the returned value directly to `module.show()`.
+ *
+ * Note: when using {@link reachableRangeGeometryConfig} this is called automatically — you only
+ * need this function for explicit control over labels or theme.
+ *
+ * Features must be ordered **largest budget first** (e.g. 30 min, 20 min, 10 min).
+ *
+ * @param result Raw output of `calculateReachableRanges`.
+ * @param theme Visual theme. Defaults to `'filled'`.
+ * @param label Custom label generator; when omitted, labels derived from `budget` property.
+ *
+ * @example
+ * ```typescript
+ * // explicit control:
+ * module.show(prepareReachableRangesForDisplay(result, 'inverted'));
+ * module.show(prepareReachableRangesForDisplay(result, 'filled', (f) => myLabel(f)));
+ * ```
+ *
+ * @group Geometries
+ */
+export declare const prepareReachableRangesForDisplay: (result: PolygonFeatures, theme?: GeometryTheme, label?: ReachableRangeLabelFn) => PolygonFeatures;
+
+/**
+ * Likelihood of a traffic incident occurring.
+ *
+ * @group Traffic
+ */
+export declare type ProbabilityOfOccurrence = 'certain' | 'probable' | 'risk_of' | 'improbable';
+
 /**
  * Parameters to update the event state of a feature programmatically.
  *
@@ -5850,6 +6050,31 @@ export declare type PutEventStateOptions = ByIdOrIndex & {
     show?: boolean;
 };
 
+/**
+ * Returns a {@link GeometriesModuleConfig} for reachable ranges.
+ *
+ * Builds on {@link themedGeometryConfig} and overrides `transformFeaturesForDisplay` so the
+ * raw output of `calculateReachableRanges` can be passed directly to {@link GeometriesModule.show}
+ * — labels are derived from each feature's `budget` property.
+ *
+ * @param palette Color palette. Defaults to `'fadedRainbow'`.
+ * @param theme Visual theme. Defaults to `'filled'`.
+ * @param label Custom label generator; when omitted, labels are derived from `budget` property.
+ *
+ * @example
+ * ```typescript
+ * const module = await GeometriesModule.get(map, reachableRangeGeometryConfig());
+ * const result = await calculateReachableRanges([...]);
+ * module.show(result); // labels and theme applied automatically
+ * ```
+ *
+ * @group Geometries
+ */
+export declare const reachableRangeGeometryConfig: (palette?: ColorPaletteOptions, theme?: GeometryTheme, label?: ReachableRangeLabelFn) => GeometriesModuleConfig;
+
+/** Custom label generator for reachable range features. */
+export declare type ReachableRangeLabelFn = (feature: PolygonFeature, index: number) => string;
+
 /**
  * Available road hierarchy category identifiers.
  *
@@ -5859,7 +6084,7 @@ export declare type PutEventStateOptions = ByIdOrIndex & {
  *
  * @group Traffic
  */
-export declare const roadCategories: readonly ["motorway", "trunk", "primary", "secondary", "tertiary", "street"];
+export declare const roadCategories: readonly ["motorway", "motorway_link", "trunk", "trunk_link", "primary", "primary_link", "secondary", "secondary_link", "tertiary", "tertiary_link", "street", "service", "track"];
 
 /**
  * Road hierarchy category type.
@@ -5869,17 +6094,29 @@ export declare const roadCategories: readonly ["motorway", "trunk", "primary", "
  * Used for filtering traffic data display based on road significance.
  *
  * Road hierarchy (from highest to lowest):
- * - `motorway` - High-capacity highways with restricted access
- * - `trunk` - Major inter-city roads
- * - `primary` - Primary through routes
- * - `secondary` - Secondary through routes
- * - `tertiary` - Connecting roads (see {@link TertiaryRoadCategory})
- * - `street` - Local streets (see {@link StreetRoadCategory})
+ * - `motorway` / `motorway_link` - High-capacity highways with restricted access
+ * - `trunk` / `trunk_link` - Major inter-city roads
+ * - `primary` / `primary_link` - Primary through routes
+ * - `secondary` / `secondary_link` - Secondary through routes
+ * - `tertiary` / `tertiary_link` - Connecting roads
+ * - `street` - Local streets (see {@link StreetRoadSubCategory})
+ * - `service` - Service roads (see {@link ServiceRoadSubCategory})
+ * - `track` - Unpaved or agricultural tracks
  *
  * @group Traffic
  */
 export declare type RoadCategory = (typeof roadCategories)[number];
 
+/**
+ * Road sub-category type.
+ *
+ * @remarks
+ * Combines street and service sub-categories. Only `street` and `service` road categories have sub-categories.
+ *
+ * @group Traffic
+ */
+export declare type RoadSubCategory = StreetRoadSubCategory | ServiceRoadSubCategory;
+
 /**
  * Main route line foreground color.
  * @ignore
@@ -6727,6 +6964,31 @@ declare type RoutingSourcesWithLayers = {
  */
 export declare const SELECTED_ROUTE_FILTER: ExpressionSpecification;
 
+/**
+ * Available service road sub-category identifiers.
+ *
+ * @remarks
+ * Provides finer granularity for classifying service roads.
+ *
+ * @group Traffic
+ */
+export declare const serviceRoadSubCategories: readonly ["parking", "driveway", "alley"];
+
+/**
+ * Service road sub-category type.
+ *
+ * @remarks
+ * Further classifies `service` roads into specific sub-types.
+ *
+ * Sub-categories:
+ * - `parking` - Roads within parking areas
+ * - `driveway` - Private access roads
+ * - `alley` - Narrow back-access lanes
+ *
+ * @group Traffic
+ */
+export declare type ServiceRoadSubCategory = (typeof serviceRoadSubCategories)[number];
+
 /**
  * Optional parameters when showing routes on the map.
  *
@@ -7021,21 +7283,22 @@ export declare const STOP_DISPLAY_INDEX = "stopDisplayIndex";
  *
  * @group Traffic
  */
-export declare const streetRoadCategories: readonly ["local", "minor_local"];
+export declare const streetRoadSubCategories: readonly ["unclassified", "residential", "living_street"];
 
 /**
  * Street road sub-category type.
  *
  * @remarks
- * Further classifies local streets into specific sub-types for more granular filtering.
+ * Further classifies `street` roads into specific sub-types.
  *
  * Sub-categories:
- * - `local` - Standard local streets
- * - `minor_local` - Minor residential streets
+ * - `unclassified` - Unclassified local roads
+ * - `residential` - Roads in residential areas
+ * - `living_street` - Pedestrian-priority shared streets
  *
  * @group Traffic
  */
-export declare type StreetRoadCategory = (typeof streetRoadCategories)[number];
+export declare type StreetRoadSubCategory = (typeof streetRoadSubCategories)[number];
 
 /**
  * Handler interface for responding to map style changes.
@@ -7248,28 +7511,26 @@ export declare type SVGIconStyleOptions = {
 export declare type SymbolLayerSpecWithoutSource = Omit<SymbolLayerSpecification, 'source'>;
 
 /**
- * Available tertiary road sub-category identifiers.
+ * Config for themed polygon display with palette-based coloring.
  *
- * @remarks
- * Provides finer granularity for classifying tertiary roads.
+ * Includes data-driven expressions so each feature's `theme` property controls its
+ * styling, line labels config, and positions layers below map labels.
  *
- * @group Traffic
+ * For reachable ranges, use {@link reachableRangeGeometryConfig} which extends this
+ * with auto-generated labels.
+ *
+ * @param palette Color palette for polygon fills. Defaults to `'fadedRainbow'`.
+ *
+ * @group Geometries
  */
-export declare const tertiaryRoadCategories: readonly ["connecting", "major_local"];
+export declare const themedGeometryConfig: (palette?: ColorPaletteOptions) => GeometriesModuleConfig;
 
 /**
- * Tertiary road sub-category type.
- *
- * @remarks
- * Further classifies tertiary roads into specific sub-types for more granular filtering.
- *
- * Sub-categories:
- * - `connecting` - Roads connecting different areas
- * - `major_local` - Major roads within local areas
+ * Whether the incident is currently active or expected in the future.
  *
  * @group Traffic
  */
-export declare type TertiaryRoadCategory = (typeof tertiaryRoadCategories)[number];
+export declare type TimeValidity = 'present' | 'future';
 
 /**
  * @ignore
@@ -7999,16 +8260,16 @@ export declare type TrafficCommonFilter = {
      * Filters traffic data by road sub-categories.
      *
      * @remarks
-     * Provides finer-grained control for tertiary roads and streets.
-     * Applies to sub-categories of {@link TertiaryRoadCategory} and {@link StreetRoadCategory}.
+     * Provides finer-grained control for street and service roads.
+     * Applies to sub-categories of {@link StreetRoadSubCategory} and {@link ServiceRoadSubCategory}.
      *
      * @example
      * ```ts
      * // Hide minor local streets
-     * roadSubCategories: { show: 'all_except', values: ['minor_local'] }
+     * roadSubCategories: { show: 'all_except', values: ['living_street'] }
      * ```
      */
-    roadSubCategories?: ValuesFilter<TertiaryRoadCategory | StreetRoadCategory>;
+    roadSubCategories?: ValuesFilter<RoadSubCategory>;
 };
 
 /**
@@ -8324,15 +8585,62 @@ export declare class TrafficFlowModule extends AbstractMapModule<TrafficFlowSour
      * ```
      */
     getShown(): {
-        trafficFlow: MapGeoJSONFeature[];
+        trafficFlow: TrafficFlowModuleFeature[];
     };
     /**
      * Create the events on/off for this module
      * @returns An instance of EventsModule
      */
-    get events(): EventsModule<MapGeoJSONFeature>;
+    get events(): EventsModule<TrafficFlowModuleFeature>;
 }
 
+/**
+ * Defines the structure of a traffic flow feature, which extends the basic GeoJSON feature
+ * with properties extracted from the traffic flow vector tiles.
+ *
+ * @group Traffic Flow
+ */
+export declare type TrafficFlowModuleFeature = Omit<MapGeoJSONFeature, 'properties'> & {
+    properties: {
+        /**
+         * Road hierarchy category type.
+         */
+        roadCategory: RoadCategory;
+        /**
+         * Road hierarchy subcategory type. Only present for `street` and `service` road categories.
+         */
+        roadSubcategory?: RoadSubCategory;
+        /**
+         * Speed relative to free-flow traffic, ranging from 0.00 (standstill) to 1.00 (free flow).
+         */
+        relativeSpeed: number;
+        /**
+         * Indicates whether the road segment is in a left-hand traffic region.
+         */
+        leftHandTraffic: boolean;
+        /**
+         * Indicates whether the road segment is closed to traffic.
+         */
+        roadClosure: boolean;
+        /**
+         * Absolute speed in kilometers per hour.
+         */
+        absoluteSpeed?: number;
+        /**
+         * Indicates whether the flow covers different directional geometries (i.e. both directions of a two-way road).
+         */
+        partOfTwoWayRoad?: boolean;
+        /**
+         * OpenLR code describing the location of the flow section.
+         */
+        openlr?: string;
+        /**
+         * Positive integer ranking the importance of the road segment.
+         */
+        displayClass?: number;
+    };
+};
+
 /**
  * IDs of sources and layers for traffic flow module.
  */
@@ -8359,10 +8667,10 @@ export declare type TrafficIncidentsFilter = TrafficCommonFilter & {
      * @example
      * ```ts
      * // Show only accidents and road closures
-     * incidentCategories: { show: 'only', values: ['accident', 'road_closed'] }
+     * incidentCategories: { show: 'only', values: ['accident', 'road-closed'] }
      * ```
      */
-    incidentCategories?: ValuesFilter<IncidentCategory>;
+    incidentCategories?: ValuesFilter<TrafficIncidentCategory>;
     /**
      * Filters incidents by delay severity magnitude.
      *
@@ -8414,7 +8722,7 @@ export declare type TrafficIncidentsFilter = TrafficCommonFilter & {
  * filters: {
  *   any: [
  *     { magnitudes: { show: 'only', values: ['major'] } },
- *     { incidentCategories: { show: 'only', values: ['road_closed'] } }
+ *     { incidentCategories: { show: 'only', values: ['road-closed'] } }
  *   ]
  * }
  * ```
@@ -8481,7 +8789,7 @@ export declare type TrafficIncidentsFilters = {
  *   any: [{
  *     incidentCategories: {
  *       show: 'only',
- *       values: ['accident', 'road_closed']
+ *       values: ['accident', 'road-closed']
  *     }
  *   }]
  * });
@@ -8491,7 +8799,7 @@ export declare type TrafficIncidentsFilters = {
  *   any: [{
  *     incidentCategories: {
  *       show: 'all_except',
- *       values: ['road_works']
+ *       values: ['roadworks']
  *     }
  *   }]
  * });
@@ -8578,7 +8886,7 @@ export declare class TrafficIncidentsModule extends AbstractMapModule<TrafficInc
      *     any: [{
      *       incidentCategories: {
      *         show: 'only',
-     *         values: ['accident', 'road_closed', 'jam']
+     *         values: ['accident', 'road-closed', 'jam']
      *       }
      *     }]
      *   }
@@ -8612,13 +8920,13 @@ export declare class TrafficIncidentsModule extends AbstractMapModule<TrafficInc
      * - `roadSubCategories`: Filter by specific road types
      *
      * **Available Incident Categories:**
-     * - `accident`, `road_closed`, `lane_closed`
-     * - `road_works` (construction)
+     * - `accident`, `road-closed`, `lane-closed`
+     * - `roadworks` (construction)
      * - `jam` (traffic jam)
-     * - `fog`, `rain`, `ice`, `wind`, `flooding`
-     * - `dangerous_conditions`
-     * - `broken_down_vehicle`
-     * - `unknown`
+     * - `fog`, `rain`, `frost`, `wind`, `flooding`
+     * - `danger`, `animals-on-road`, `narrow-lanes`
+     * - `broken-down-vehicle`
+     * - `other`
      *
      * **Delay Magnitudes:**
      * - `minor`: Small delays
@@ -8633,7 +8941,7 @@ export declare class TrafficIncidentsModule extends AbstractMapModule<TrafficInc
      *   any: [{
      *     incidentCategories: {
      *       show: 'only',
-     *       values: ['accident', 'road_closed']
+     *       values: ['accident', 'road-closed']
      *     }
      *   }]
      * });
@@ -8775,15 +9083,101 @@ export declare class TrafficIncidentsModule extends AbstractMapModule<TrafficInc
      * ```
      */
     getShown(): {
-        trafficIncidents: MapGeoJSONFeature[];
+        trafficIncidents: TrafficIncidentsModuleFeature[];
     };
     /**
      * Create the events on/off for this module
      * @returns An instance of EventsModule
      */
-    get events(): EventsModule<MapGeoJSONFeature>;
+    get events(): EventsModule<TrafficIncidentsModuleFeature>;
 }
 
+/**
+ * Defines the structure of a traffic incident feature, which extends the basic GeoJSON feature with specific properties related to traffic incidents. This type is used to represent individual traffic incidents on the map, providing details such as the description of the incident, its severity, and the road category where it is occurring.
+ */
+export declare type TrafficIncidentsModuleFeature = Omit<MapGeoJSONFeature, 'properties'> & {
+    /**
+     * Properties specific to traffic incidents, extracted from the vector tile data.
+     *
+     * @remarks
+     * These properties include a unique identifier for the incident, a description of the incident, its category, the magnitude of any resulting delay, and information about the road where the incident is occurring (including road category and subcategory). Additionally, it indicates whether the incident is in a left-hand traffic region.
+     */
+    properties: {
+        /**
+         * Unique identifier for the traffic incident, common across Traffic API services.
+         */
+        id: string;
+        /**
+         * Description of the traffic incident, providing details about the nature of the incident.
+         */
+        description: string;
+        /**
+         * Category of the traffic incident, classifying the type of incident (e.g., accident, roadworks, congestion) based on predefined categories.
+         */
+        category: TrafficIncidentCategory;
+        /**
+         * Severity of the delay.
+         */
+        magnitudeOfDelay: DelayMagnitude;
+        /**
+         * The delay caused by the incident in seconds (except in road closures). It is calculated against free-flow travel time (the travel time when the traffic is minimal, e.g., night traffic).
+         */
+        delayInSeconds?: number;
+        /**
+         * Road hierarchy category type.
+         */
+        roadCategory: RoadCategory;
+        /**
+         * Road hierarchy subcategory type, providing more specific classification of the road where the incident is occurring.
+         */
+        roadSubcategory: RoadSubCategory;
+        /**
+         * Indicates whether the traffic incident is occurring in a left-hand traffic region.
+         */
+        leftHandTraffic: boolean;
+        /**
+         * Indicates whether the incident covers different directional geometries (i.e. both directions of a two-way road).
+         */
+        partOfTwoWayRoad?: boolean;
+        /**
+         * The date and time when the incident started.
+         */
+        startTime?: Date;
+        /**
+         * The estimated date and time when the incident will end.
+         */
+        endTime?: Date;
+        /**
+         * Likelihood assessment of the incident occurring.
+         */
+        probabilityOfOccurrence?: ProbabilityOfOccurrence;
+        /**
+         * Number of user reports for the incident.
+         */
+        numberOfReports?: number;
+        /**
+         * The date and time of the most recent user report for the incident.
+         */
+        lastReportTime?: Date;
+        /**
+         * Average speed within the incident area, in km/h.
+         */
+        averageSpeedKmph?: number;
+        /**
+         * OpenLR code describing the location of the incident.
+         */
+        openlr?: string;
+        /**
+         * Whether the incident is currently active or expected in the future.
+         */
+        timeValidity?: TimeValidity;
+        /**
+         * Positive integer ranking the importance of the road where the incident occurs.
+         */
+        displayClass?: number;
+    };
+};
+
 /**
  * IDs of sources and layers for traffic incidents module.
  */