@tomtom-org/maps-sdk 1.0.0-rc.3 → 1.0.0-rc.4

package/core/dist/index.d.ts

@@ -1,23 +1,3 @@
-//#region src/types/generic.d.ts
-/**
- * An object with string keys and unknown values.
- *
- * Use it for objects whose shape is not fixed, such as extensible properties or arbitrary user data.
- *
- * @example
- * ```typescript
- * function processCustomData(data: Anything) {
- *   // Access properties dynamically
- *   console.log(data['customField']);
- * }
- * ```
- *
- * @group Shared
- */
-type Anything = {
-  [x: string]: unknown;
-};
-//#endregion
 //#region ../node_modules/.pnpm/@types+geojson@7946.0.16/node_modules/@types/geojson/index.d.ts
 /**
  * The value values for the "type" property of GeoJSON Objects.
@@ -100,12 +80,12 @@ interface GeoJsonObject {
 /**
  * Union of GeoJSON objects.
  */
-type GeoJSON<G extends Geometry | null = Geometry, P = GeoJsonProperties> = G | Feature<G, P> | FeatureCollection<G, P>;
+type GeoJSON<G extends Geometry$1 | null = Geometry$1, P = GeoJsonProperties> = G | Feature<G, P> | FeatureCollection<G, P>;
 /**
  * Geometry object.
  * https://tools.ietf.org/html/rfc7946#section-3
  */
-type Geometry = Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon | GeometryCollection;
+type Geometry$1 = Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon | GeometryCollection;
 /**
  * Point geometry object.
  * https://tools.ietf.org/html/rfc7946#section-3.1.2
@@ -158,7 +138,7 @@ interface MultiPolygon extends GeoJsonObject {
  * Geometry Collection
  * https://tools.ietf.org/html/rfc7946#section-3.1.8
  */
-interface GeometryCollection<G extends Geometry = Geometry> extends GeoJsonObject {
+interface GeometryCollection<G extends Geometry$1 = Geometry$1> extends GeoJsonObject {
   type: "GeometryCollection";
   geometries: G[];
 }
@@ -169,7 +149,7 @@ type GeoJsonProperties = {
  * A feature object which contains a geometry and associated properties.
  * https://tools.ietf.org/html/rfc7946#section-3.2
  */
-interface Feature<G extends Geometry | null = Geometry, P = GeoJsonProperties> extends GeoJsonObject {
+interface Feature<G extends Geometry$1 | null = Geometry$1, P = GeoJsonProperties> extends GeoJsonObject {
   type: "Feature";
   /**
    * The feature's geometry
@@ -189,11 +169,142 @@ interface Feature<G extends Geometry | null = Geometry, P = GeoJsonProperties> e
  * A collection of feature objects.
  *  https://tools.ietf.org/html/rfc7946#section-3.3
  */
-interface FeatureCollection<G extends Geometry | null = Geometry, P = GeoJsonProperties> extends GeoJsonObject {
+interface FeatureCollection<G extends Geometry$1 | null = Geometry$1, P = GeoJsonProperties> extends GeoJsonObject {
   type: "FeatureCollection";
   features: Array<Feature<G, P>>;
 }
 //#endregion
+//#region src/types/cells.d.ts
+/**
+ * A statistic {@link aggregateIntoCells} computes over the values of the points in each cell.
+ * - `count` - How many points the cell holds.
+ * - `sum`, `mean`, `median`, `min`, `max` - Of their values.
+ *
+ * @group Utils
+ */
+type CellStatistic = 'count' | 'sum' | 'mean' | 'median' | 'min' | 'max';
+/**
+ * The shape of the cells of a grid {@link aggregateIntoCells} lays out:
+ * - `'hex'` - Hexagons, flat side up.
+ * - `'square'` - Squares.
+ *
+ * @group Utils
+ */
+type CellGridShape = 'hex' | 'square';
+/**
+ * The cells {@link aggregateIntoCells} groups points into: a grid of {@link CellGridShape}, or a collection
+ * of your own polygons, such as districts.
+ *
+ * @group Utils
+ */
+type CellGrid = CellGridShape | FeatureCollection<Polygon | MultiPolygon>;
+/**
+ * The keys of `P` whose values are numbers.
+ *
+ * @group Utils
+ */
+type NumericPropertyKey<P> = { [K in keyof NonNullable<P>]-?: NonNullable<P>[K] extends number | null | undefined ? K : never; }[keyof NonNullable<P>] & string;
+/**
+ * Where a point's value comes from: the name of a numeric property, or a function that reads it.
+ *
+ * A point whose value is missing or not a finite number is left out of every statistic, `count` included.
+ *
+ * @group Utils
+ */
+type CellValue<P extends GeoJsonProperties> = NumericPropertyKey<P> | ((point: Feature<Point, P>) => number | null | undefined);
+/**
+ * The options of a grid of hexagons or squares.
+ *
+ * @group Utils
+ */
+type LatticeGridOptions<G extends CellGridShape> = {
+  grid: G;
+  /** A cell's side in kilometres: a square's, or a hexagon's, which is also its centre-to-corner distance. */
+  cellSizeKM: number;
+  /**
+   * The centre of one cell, which lays out the grid. Its latitude sets the cell size in degrees.
+   * Defaults to the centre of the points' bounding box.
+   *
+   * Pass the same position each time, such as your city's centre, to keep the cells in place while
+   * your points change.
+   */
+  gridOrigin?: Position;
+};
+/**
+ * The grid half of {@link AggregateIntoCellsOptions}: a grid of hexagons or squares, or your own polygons.
+ * A `grid` that may be either needs narrowing first, as only a grid of hexagons or squares takes a `cellSizeKM`.
+ *
+ * @group Utils
+ */
+type CellGridOptions<G extends CellGrid> = [G] extends [CellGridShape] ? LatticeGridOptions<G> : [G] extends [FeatureCollection<Polygon | MultiPolygon>] ? {
+  grid: G;
+} : LatticeGridOptions<Extract<G, CellGridShape>> | {
+  grid: Exclude<G, CellGridShape>;
+};
+/**
+ * The value half of {@link AggregateIntoCellsOptions}: the statistics to compute, and the value they read.
+ * Without a `value`, the cells only count their points.
+ *
+ * @group Utils
+ */
+type CellValueOptions<P extends GeoJsonProperties, S extends CellStatistic> = {
+  value?: undefined;
+  stats?: readonly (S & 'count')[];
+} | {
+  value: CellValue<P>;
+  /** The statistics each cell gets, as properties of the same names. */
+  stats: readonly S[];
+};
+/**
+ * Options of {@link aggregateIntoCells}.
+ *
+ * @typeParam P - The properties of the points.
+ * @typeParam S - The statistics each cell gets.
+ * @typeParam G - The grid.
+ *
+ * @group Utils
+ */
+type AggregateIntoCellsOptions<P extends GeoJsonProperties, S extends CellStatistic, G extends CellGrid> = CellGridOptions<G> & CellValueOptions<P, S> & {
+  /**
+   * Leaves out the cells holding fewer points than this. Defaults to 1. A value below 1 counts as 1,
+   * so one of your polygons without points never shows.
+   */
+  minCount?: number;
+};
+/**
+ * The statistics of one cell, each a property named after it.
+ *
+ * @group Utils
+ */
+type CellStatistics<S extends CellStatistic> = { [K in S]: number; };
+/**
+ * What {@link aggregateIntoCells} returns: one polygon per cell holding points, with the statistics as its
+ * properties. Your own polygons keep their geometry, `id` and properties, the statistics added to them.
+ *
+ * @group Utils
+ */
+type AggregatedCells<S extends CellStatistic, G extends CellGrid> = [G] extends [FeatureCollection<infer Geometry, infer Properties>] ? FeatureCollection<Geometry, NonNullable<Properties> & CellStatistics<S>> : FeatureCollection<Polygon, CellStatistics<S>>;
+//#endregion
+//#region src/types/generic.d.ts
+/**
+ * An object with string keys and unknown values.
+ *
+ * Use it for objects whose shape is not fixed, such as extensible properties or arbitrary user data.
+ *
+ * @example
+ * ```typescript
+ * function processCustomData(data: Anything) {
+ *   // Access properties dynamically
+ *   console.log(data['customField']);
+ * }
+ * ```
+ *
+ * @group Shared
+ */
+type Anything = {
+  [x: string]: unknown;
+};
+//#endregion
 //#region src/types/geojson.d.ts
 /**
  * A geographic point, in one of these forms:
@@ -224,9 +335,15 @@ interface FeatureCollection<G extends Geometry | null = Geometry, P = GeoJsonPro
  */
 type HasLngLat = [number, number] | Position | Point | Feature<Point>;
 /**
- * A geographic bounding box as an array of four numbers.
+ * A geographic bounding box as an array of four numbers: `[west, south, east, north]`.
+ *
+ * @remarks
+ * A box whose west edge lies east of its east edge, `west > east`, crosses the antimeridian, as in
+ * {@link https://datatracker.ietf.org/doc/html/rfc7946#section-5.2 | RFC 7946 §5.2}: `[176.8, -21, -178.2, -12.5]`
+ * covers Fiji. The services return that form, and every bbox utility reads and returns it.
  *
- * The format is `[minLon, minLat, maxLon, maxLat]`, or `[west, south, east, north]`.
+ * MapLibre's `fitBounds` and the map's `bounds` option read it as is. Elsewhere in MapLibre, add 360 to
+ * `east`, as `LngLatBounds.adjustAntiMeridian()` does.
  *
  * @group Shared
  */
@@ -240,7 +357,7 @@ type BBox = [number, number, number, number];
  * - `GeoJSON[]` - An array of GeoJSON objects, a convenience extension to standard GeoJSON.
  *
  * @remarks
- * The format is `[minLon, minLat, maxLon, maxLat]`, or `[west, south, east, north]`.
+ * The format is `[west, south, east, north]`, crossing the antimeridian when `west > east`, as {@link BBox} describes.
  *
  * @example
  * ```typescript
@@ -371,7 +488,7 @@ type PolygonFeatures<P = GeoJsonProperties> = Omit<FeatureCollection<Polygon | M
  *
  * @group Shared
  */
-interface FeatureCollectionWithProperties<G extends Geometry | null = Geometry, P = GeoJsonProperties, FeatureCollectionProps = unknown> extends Omit<FeatureCollection<G, P>, 'bbox'> {
+interface FeatureCollectionWithProperties<G extends Geometry$1 | null = Geometry$1, P = GeoJsonProperties, FeatureCollectionProps = unknown> extends Omit<FeatureCollection<G, P>, 'bbox'> {
   /**
    * The bounding box of all features in the collection, including any bounding boxes they have.
    * It is present only if the collection has features.
@@ -411,6 +528,8 @@ export declare const geopoliticalViews: readonly ["Unified", "AE", "AR", "BN", "
  * | Search, place details, reverse geocoding | `KR`, `US` |
  * | Geocoding | `AE`, `BN`, `CL`, `DZ`, `KR`, `MY`, `PH`, `US`, `VN` |
  *
+ * {@link servesGeopoliticalView} answers the same question in code.
+ *
  * @example
  * ```typescript
  * // The map and every service, from India's perspective
@@ -421,6 +540,20 @@ export declare const geopoliticalViews: readonly ["Unified", "AE", "AR", "BN", "
  * @group Shared
  */
 export type GeopoliticalView = (typeof geopoliticalViews)[number];
+/**
+ * A TomTom API the SDK sends a {@link GeopoliticalView} to.
+ *
+ * @remarks
+ * - `mapTiles`: The Orbis vector tiles the map draws.
+ * - `search`: `fuzzySearch`, `geometrySearch`, `alongRouteSearch`, `discoverPlaces` and
+ *   `getSearchSuggestions`.
+ * - `placeDetails`: `getPlaceDetails`.
+ * - `reverseGeocoding`: `reverseGeocode`.
+ * - `geocoding`: `geocode` and `geocodeOne`.
+ *
+ * @group Shared
+ */
+export type GeopoliticalViewAPI = 'mapTiles' | 'search' | 'placeDetails' | 'reverseGeocoding' | 'geocoding';
 //#endregion
 //#region src/types/getPosition.d.ts
 /**
@@ -429,8 +562,9 @@ export type GeopoliticalView = (typeof geopoliticalViews)[number];
  * Entry points are specific access locations of a place, such as building entrances or parking lot entries.
  *
  * @remarks
- * - `main-when-available` - Returns the main entry point position if available, otherwise the default place position.
- *   Use it for routing, to direct vehicles to the correct entrance.
+ * - `main-when-available` - Returns the position of the entry point typed `'main'`. A place with none uses its
+ *   first untyped entry point, as reverse geocoding returns them. A place whose entry points are all `'minor'`, or
+ *   that has none, returns its own position. Use it for routing, to direct vehicles to the correct entrance.
  * - `ignore` - Always returns the default position of the place, typically the center point.
  *
  * @example
@@ -454,8 +588,8 @@ type GetPositionOptions = {
   /**
    * Whether to use entry point positions when available.
    *
-   * With `'main-when-available'`, you get the main entry point coordinates if they exist,
-   * otherwise the default place position. Use it for routing, to direct users to the correct entrance.
+   * With `'main-when-available'`, you get an entry point's coordinates, as {@link GetPositionEntryPointOption}
+   * describes. Use it for routing, to direct users to the correct entrance.
    *
    * @default 'ignore'
    *
@@ -523,7 +657,7 @@ type TomTomAPIHeaders = {
  *
  * @group Shared
  */
-export declare const languages: readonly ["ngt", "ngt-Latn", "ar", "bg-BG", "zh-Hant", "zh-Hans", "cs-CZ", "da-DK", "nl-NL", "en-AU", "en-CA", "en-GB", "en-NZ", "en-US", "fi-FI", "fr-FR", "de-DE", "el-GR", "hu-HU", "id-ID", "it-IT", "ko-KR", "ko-Latn-KR", "lt-LT", "ms-MY", "nb-NO", "pl-PL", "pt-BR", "pt-PT", "ru-RU", "ru-Latn-RU", "ru-Cyrl-RU", "sk-SK", "sl-SI", "es-ES", "es-MX", "sv-SE", "th-TH", "tr-TR"];
+export declare const languages: readonly ["ngt", "ngt-Latn", "ar", "eu-ES", "bg-BG", "ca-ES", "zh-Hant", "zh-Hans", "hr-HR", "cs-CZ", "da-DK", "nl-NL", "en-AU", "en-CA", "en-GB", "en-NZ", "en-US", "et-EE", "fi-FI", "fr-FR", "gl-ES", "de-DE", "el-GR", "he-IL", "hi-IN", "hu-HU", "id-ID", "it-IT", "ja-JP", "kk-KZ", "ko-KR", "ko-Latn-KR", "lv-LV", "lt-LT", "ms-MY", "nb-NO", "pl-PL", "pt-BR", "pt-PT", "ro-RO", "ru-RU", "ru-Latn-RU", "ru-Cyrl-RU", "sr-RS", "sk-SK", "sl-SI", "es-ES", "es-MX", "sv-SE", "th-TH", "tr-TR", "uk-UA"];
 /**
  * A language code for map display and service responses.
  *
@@ -531,6 +665,11 @@ export declare const languages: readonly ["ngt", "ngt-Latn", "ar", "bg-BG", "zh-
  * - Map labels and text on vector tiles.
  * - Place names, addresses and other textual content in service responses.
  *
+ * `Language` lists every language the map labels carry. A service that lacks one answers in local names,
+ * as the places services do for `hi-IN` and `ja-JP`. Text a service writes itself, such as route
+ * instructions, POI category names and traffic incident descriptions, comes in the nearest language it has,
+ * or in English.
+ *
  * It covers locales with region-specific variants, such as `en-US` and `en-GB`. Special codes
  * such as `ngt` (Neutral Ground Truth) and `ngt-Latn` give language-neutral or Latin script alternatives.
  *
@@ -884,8 +1023,7 @@ type ChargingPark = {
  * @example
  * ```typescript
  * const dataSources: PlaceDataSources = {
- *   geometry: { id: 'geom-456' },
- *   poiDetails: { id: 'poi-789', sourceName: 'TomTom' }
+ *   geometry: { id: 'geom-456' }
  * };
  * ```
  *
@@ -907,9 +1045,10 @@ type PlaceDataSources = {
    */
   geometry?: GeometryDataSource;
   /**
-   * The data source for detailed POI information, present only for POI places (type === POI).
+   * The data source for detailed POI information, which the Orbis places API doesn't return.
    *
-   * Use its ID to fetch extended details from the Points of Interest Details service.
+   * @remarks
+   * To fetch a place's details, pass the place's own `id` to `getPlaceDetails`.
    */
   poiDetails?: PoiDetailsDataSource;
 };
@@ -936,27 +1075,16 @@ type GeometryDataSource = {
   id: string;
 };
 /**
- * Data source reference for detailed POI information.
+ * Data source reference for detailed POI information, which the Orbis places API doesn't return.
  *
- * @example
- * ```typescript
- * const dataSource: PoiDetailsDataSource = {
- *   id: 'poi-xyz789',
- *   sourceName: 'TomTom'
- * };
- * ```
+ * @remarks
+ * To fetch a place's details, pass the place's own `id` to `getPlaceDetails`.
  *
  * @group Place
  */
 type PoiDetailsDataSource = {
   /**
-   * The POI details ID for the Points of Interest Details service.
-   *
-   * Pass it to fetch additional information such as:
-   * - Extended opening hours
-   * - Photos and ratings
-   * - Detailed amenities
-   * - Contact information
+   * The POI details ID.
    */
   id: string;
   /**
@@ -1205,10 +1333,12 @@ type POI = {
    */
   categories: POICategory[];
   /**
-   * The localized, human-readable category names of the POI, as the API returns them.
+   * The human-readable category names of the POI, as the API returns them, such as `'italian'`,
+   * `'restaurant'`, `'petrol station'` or `'hotel'`.
    *
-   * They are language-sensitive descriptions, such as `'italian'`, `'restaurant'`, `'gas station'`
-   * or `'hotel'`, to display in the UI.
+   * They are in English, the same whatever the request `language`. For names in that language, look
+   * up each of {@link categories} by `code` in what `getPOICategories` returns for it. A few of those
+   * names are identifiers, such as `'GeneralHospitalAndPolyclinic'`: keep these English names there.
    */
   localizedCategories: string[];
   /**
@@ -1380,7 +1510,7 @@ export type AddressRanges = {
  * - `minor`: One of possibly several secondary or alternative entrances.
  *
  * The type is absent when the service does not classify its entry points, as with
- * reverse geocoding.
+ * reverse geocoding. {@link GetPositionEntryPointOption} `main-when-available` then uses the first untyped one.
  *
  * @group Place
  */
@@ -2515,16 +2645,23 @@ type SummaryBase = {
    */
   travelTimeInSeconds: number;
   /**
-   * The extra time in seconds that current traffic conditions cause, compared to free-flow conditions.
+   * The delay in seconds of the traffic events along `trafficLengthInMeters`.
    *
-   * A value of 0 means no traffic delays.
+   * @remarks
+   * It is present only when the routing service sends it, and it is not the gap to free-flow
+   * conditions. For the gap to free-flow, request the travel times with `computeTravelTimeFor: 'all'`
+   * and use `Math.max(0, liveTrafficIncidentsTravelTimeInSeconds - noTrafficTravelTimeInSeconds)`.
+   * The live travel time can fall below the free-flow one, so keep the floor at 0.
    */
-  trafficDelayInSeconds: number;
+  trafficDelayInSeconds?: number;
   /**
    * The length in meters of the route that traffic events delay, which is the portion with
    * congestion or incidents.
+   *
+   * @remarks
+   * It is present only when the routing service sends it.
    */
-  trafficLengthInMeters: number;
+  trafficLengthInMeters?: number;
   /**
    * The estimated travel time in seconds in free-flow conditions, as if there were no traffic
    * delays (no congestion).
@@ -2790,10 +2927,12 @@ export type TrafficSectionProps = SectionProps & {
    */
   delayInSeconds?: number;
   /**
-   * The identifier of the traffic incident behind this section.
+   * The routing service's identifier of the traffic incident behind this section.
    *
-   * It is the join key back to the full incident. To get the whole record, pass it to the traffic
-   * incident details service rather than re-deriving it from the section's geometry.
+   * @remarks
+   * It is the tail of the incident's `id` in `trafficIncidentDetails`, not that id, so passing it as
+   * `ids` finds nothing. To get the whole record, query `trafficIncidentDetails` with the section's
+   * {@link getSectionBBox} and keep the incident whose `id.endsWith(eventId)`.
    */
   eventId?: string;
 };
@@ -2812,6 +2951,103 @@ export type DistinctSectionProps = SectionProps & {
   /** The length of the section, along the route. */
   lengthInMeters: number;
 };
+/**
+ * A curve of a route: a stretch where the road keeps turning the same way.
+ *
+ * @remarks
+ * The SDK finds curves in the route's geometry, with {@link getCurveSections}. A small radius with a
+ * large heading change makes a hard curve: a hairpin turns some 180° on a radius of 10 to 20 metres.
+ *
+ * @example
+ * ```typescript
+ * const hairpin: CurveSectionProps = {
+ *   id: 'curve-1',
+ *   startPointIndex: 120,
+ *   endPointIndex: 131,
+ *   headingChangeInDegrees: -172, // a left hairpin
+ *   radiusInMeters: 14,
+ *   lengthInMeters: 70,
+ *   curvinessScore: 84, // each of the 42 metres of its arc counts twice
+ *   severity: 0.94,
+ * };
+ * ```
+ *
+ * @group Route
+ */
+export type CurveSectionProps = SectionProps & {
+  /**
+   * How far the heading turns along the curve: positive to the right, negative to the left. It can
+   * pass 180° on a hairpin or a roundabout.
+   */
+  headingChangeInDegrees: number;
+  /**
+   * The radius of the circle the curve follows where it turns tightest, over the shortest part of
+   * it that turns four fifths of its heading change: a curve can ease in on a wide bend first.
+   */
+  radiusInMeters: number;
+  /** The length of the curve, along the route, from where it starts turning to where it straightens. */
+  lengthInMeters: number;
+  /**
+   * How much the curve has to offer a rider, as roadcurvature.com scores roads: the length of its
+   * arc, `radiusInMeters` times the heading change in radians, with each metre counted:
+   * - 2 times below a radius of 30 m, 1.6 times below 60 m, 1.3 times below 100 m and 1 time below 175 m.
+   * - Not at all on a curve wider than 175 m, which scores 0.
+   */
+  curvinessScore: number;
+  /**
+   * How hard the curve is to drive, from 0 to 1: how much a driver slows down for it, from the
+   * speed limit on the road leading into it.
+   *
+   * @remarks
+   * - It grows as the radius shrinks. A shallow curve counts as wider than its radius, since a
+   *   driver can straighten it out across the lane, but a hairpin can't be straightened.
+   * - A turn at a junction, with a turn, U-turn or roundabout `maneuver`, scores as one the driver
+   *   slows right down for, however wide its corner is drawn.
+   * - It reads the route's `speedLimit` sections, so ask for them along with the curves. Where the
+   *   route has no limit for the road, it takes a typical limit outside towns.
+   * - A curve a driver takes at the limit scores 0. The tighter the curve is for the road, the
+   *   nearer 1 it scores.
+   */
+  severity: number;
+  /**
+   * The maneuver of the guidance instruction on the curve, such as `TURN_LEFT` or
+   * `ROUNDABOUT_RIGHT`. It tells a turn at a junction from a bend of the road, so it is absent:
+   * - On a curve no instruction falls on, or whose only instructions mark no junction: a departure,
+   *   an arrival, a waypoint, a border or a tollgate.
+   * - Where the instruction keeps to the road, as "Turn left to stay on the SS38" where a side road
+   *   leaves a hairpin, or has no other way to take, as "Follow the road to the left". A roundabout
+   *   and a U-turn always name theirs.
+   * - On every curve of a route calculated without `guidance`.
+   */
+  maneuver?: Maneuver;
+};
+/**
+ * A curvy stretch of a route: curves that follow one another closely, such as a mountain pass.
+ *
+ * @remarks
+ * The SDK groups the route's curves into stretches, with {@link getCurvyStretchSections}. To list
+ * the curves of a stretch, pass it as `within` to {@link getSectionsWithin}.
+ *
+ * A curve at a maneuver ends a stretch, since a run of turns at junctions makes no winding road.
+ * That takes a route with guidance: without it, turns at junctions between short roads can make one.
+ *
+ * @group Route
+ */
+export type CurvyStretchSectionProps = SectionProps & {
+  /** How many curves the stretch holds. Over `lengthInMeters`, it says how winding the stretch is. */
+  curveCount: number;
+  /** How many of its curves are hairpins, as {@link isHairpin} tells them. */
+  hairpinCount: number;
+  /** The length of the stretch, along the route. */
+  lengthInMeters: number;
+  /** The radius of the stretch's tightest curve. */
+  minRadiusInMeters: number;
+  /**
+   * The `curvinessScore` of its curves, added up: the higher, the more a rider gets out of it.
+   * Roadcurvature.com, which scores roads the same way, calls those over 1000 very twisty.
+   */
+  curvinessScore: number;
+};
 /**
  * A route section for a leg, the portion of route between two consecutive waypoints.
  *
@@ -2969,6 +3205,23 @@ export type SectionsProps = {
   carTrain?: SectionProps[];
   /** One section per country the route passes through, each naming that country. */
   country?: CountrySectionProps[];
+  /**
+   * The curves of the route, in order along it.
+   *
+   * @remarks
+   * The SDK finds them in the route's geometry, with {@link getCurveSections} and the thresholds of
+   * the `curveDetection` of `calculateRoute`, when its `sectionTypes` names `curve`.
+   * {@link withCurveSections} finds them again with others.
+   */
+  curve?: CurveSectionProps[];
+  /**
+   * The stretches where curves follow one another closely, in order along the route.
+   *
+   * @remarks
+   * The SDK groups the route's curves into them, with {@link getCurvyStretchSections} and the
+   * thresholds of the `curveDetection` of `calculateRoute`, when its `sectionTypes` names `curvyStretch`.
+   */
+  curvyStretch?: CurvyStretchSectionProps[];
   /**
    * The stretches no other route of the same response drives, in order along the route.
    *
@@ -3046,21 +3299,37 @@ export type SectionsProps = {
  * @group Route
  */
 export type SectionType = keyof SectionsProps;
+/**
+ * The section types a route calculation returns when its request names none: every type the
+ * routing API returns, and `lanes` with guidance.
+ *
+ * @remarks
+ * A `sectionTypes` list replaces the default rather than adding to it. Spread this one to add to
+ * it, such as the curves, which the SDK finds only when a list names them.
+ *
+ * @example
+ * ```typescript
+ * const routes = await calculateRoute({ locations, sectionTypes: [...defaultSectionTypes, 'curve', 'curvyStretch'] });
+ * ```
+ *
+ * @group Route
+ */
+export declare const defaultSectionTypes: readonly ["carpool", "carTrain", "country", "ferry", "importantRoadStretch", "lowEmissionZone", "motorway", "pedestrian", "roadShields", "speedLimit", "toll", "tollRoad", "tollVignette", "traffic", "tunnel", "unpaved", "urban", "vehicleRestricted", "lanes"];
 /**
  * The section types a route calculation request can ask to include in the response.
  * @group Route
  */
-export declare const inputSectionTypes: readonly ["carpool", "carTrain", "country", "ferry", "importantRoadStretch", "lowEmissionZone", "motorway", "pedestrian", "roadShields", "speedLimit", "toll", "tollRoad", "tollVignette", "traffic", "tunnel", "unpaved", "urban", "vehicleRestricted"];
+export declare const inputSectionTypes: readonly ["carpool", "carTrain", "country", "ferry", "importantRoadStretch", "lowEmissionZone", "motorway", "pedestrian", "roadShields", "speedLimit", "toll", "tollRoad", "tollVignette", "traffic", "tunnel", "unpaved", "urban", "vehicleRestricted", "curve", "curvyStretch"];
 /**
  * The section types, including guidance-related ones, a route calculation request can ask to include in the response.
  * @group Route
  */
-export declare const inputSectionTypesWithGuidance: readonly ["carpool", "carTrain", "country", "ferry", "importantRoadStretch", "lowEmissionZone", "motorway", "pedestrian", "roadShields", "speedLimit", "toll", "tollRoad", "tollVignette", "traffic", "tunnel", "unpaved", "urban", "vehicleRestricted", "lanes"];
+export declare const inputSectionTypesWithGuidance: readonly ["carpool", "carTrain", "country", "ferry", "importantRoadStretch", "lowEmissionZone", "motorway", "pedestrian", "roadShields", "speedLimit", "toll", "tollRoad", "tollVignette", "traffic", "tunnel", "unpaved", "urban", "vehicleRestricted", "curve", "curvyStretch", "lanes"];
 /**
  * Every section type a route can carry: the requestable ones, plus `leg` and `distinct`, which no request names.
  * @group Route
  */
-export declare const sectionTypes: readonly ["carpool", "carTrain", "country", "ferry", "importantRoadStretch", "lowEmissionZone", "motorway", "pedestrian", "roadShields", "speedLimit", "toll", "tollRoad", "tollVignette", "traffic", "tunnel", "unpaved", "urban", "vehicleRestricted", "lanes", "leg", "distinct"];
+export declare const sectionTypes: readonly ["carpool", "carTrain", "country", "ferry", "importantRoadStretch", "lowEmissionZone", "motorway", "pedestrian", "roadShields", "speedLimit", "toll", "tollRoad", "tollVignette", "traffic", "tunnel", "unpaved", "urban", "vehicleRestricted", "curve", "curvyStretch", "lanes", "leg", "distinct"];
 //#endregion
 //#region src/types/route/analysis.d.ts
 /**
@@ -3072,6 +3341,82 @@ type DistinctSectionsOptions = {
   /** Leaves out the sections shorter than this. */
   minLengthInMeters?: number;
 };
+/**
+ * The thresholds a stretch of road has to reach to count as a curve.
+ *
+ * @remarks
+ * The defaults keep the bends a passenger feels: from a country road's 40° bend on a radius of 250
+ * metres to a hairpin. Lower `maxRadiusInMeters` to keep only hard curves, such as to warn someone
+ * prone to motion sickness, or raise it to count sweeping bends too.
+ *
+ * @group Utils
+ */
+type CurveSectionsOptions = {
+  /**
+   * Leaves out the curves turning less than this, either way.
+   * @default 40
+   */
+  minHeadingChangeInDegrees?: number;
+  /**
+   * Leaves out the curves wider than this.
+   * @default 250
+   */
+  maxRadiusInMeters?: number;
+  /**
+   * How far the road may run straight within a curve. A longer straight ends it, so two bends
+   * apart are two curves.
+   *
+   * It defaults to 40, or to 15% of a `maxRadiusInMeters` over 267, since a wide curve turns little
+   * over 40 metres.
+   */
+  maxStraightInMeters?: number;
+};
+/**
+ * How close curves have to follow one another to make a curvy stretch.
+ *
+ * @group Utils
+ */
+type CurvyStretchSectionsOptions = {
+  /**
+   * The curves to group, in order along the route. Defaults to the route's `sections.curve`, or to
+   * {@link getCurveSections} with its defaults when the route has none.
+   */
+  curves?: readonly CurveSectionProps[];
+  /**
+   * The longest gap between two curves of one stretch.
+   * @default 500
+   */
+  maxGapInMeters?: number;
+  /**
+   * Leaves out the stretches with fewer curves than this.
+   * @default 3
+   */
+  minCurveCount?: number;
+};
+/**
+ * The thresholds a route's curves and curvy stretches are found with.
+ *
+ * @remarks
+ * `calculateRoute` takes it as `curveDetection`, and {@link withCurveSections} to find them again
+ * on a route you already have.
+ *
+ * @example
+ * ```typescript
+ * // Only the hard curves, and the stretches of five or more of them
+ * const curveDetection: CurveDetectionOptions = {
+ *     curve: { maxRadiusInMeters: 100 },
+ *     curvyStretch: { minCurveCount: 5 },
+ * };
+ * ```
+ *
+ * @group Utils
+ */
+type CurveDetectionOptions = {
+  /** The thresholds a stretch of road has to reach to count as a curve. */
+  curve?: CurveSectionsOptions;
+  /** How close the curves found have to follow one another to make a curvy stretch. */
+  curvyStretch?: Omit<CurvyStretchSectionsOptions, 'curves'>;
+};
 /**
  * A route's sections of one type within the spans asked about.
  *
@@ -3127,8 +3472,8 @@ type RouteComparison = {
  */
 type CompareRoutesOptions = {
   /**
-   * The section types to weigh. Defaults to every type the routing service returns, leaving out
-   * `leg` and `distinct`.
+   * The section types to weigh. Defaults to every type `calculateRoute` can return, `curve` and
+   * `curvyStretch` included when the routes carry them, leaving out `leg` and `distinct`.
    */
   types?: readonly SectionType[];
 };
@@ -3626,11 +3971,11 @@ export declare const sdkErrorCodes: readonly ["INVALID_REQUEST", "INSECURE_BASE_
  *
  * | Code | When |
  * | --- | --- |
- * | `INVALID_REQUEST` | The SDK's request validation failed, or the API answered `400` or another `4xx` not below |
+ * | `INVALID_REQUEST` | The SDK's request validation failed, a service could not build a request sent with `validateRequest: false`, or the API answered `400` or another `4xx` not below |
  * | `INSECURE_BASE_URL` | `commonBaseURL` is neither `https:` nor `http:` on a loopback address, checked even with `validateRequest: false` |
  * | `INVALID_CREDENTIALS` | The API answered `401`: the key is missing, invalid or expired |
  * | `INSUFFICIENT_PERMISSIONS` | The API answered `403`: the key is valid but not allowed this request, because that API is not enabled for it (a Private Preview API needs its access granted) or its domain restriction refused the page |
- * | `NOT_FOUND` | The API answered `404` |
+ * | `NOT_FOUND` | The API answered `404`, or `geocodeOne` or `discoverOnePlace` found no place |
  * | `RATE_LIMITED` | The API still answered `429` after the retries `retry` allows |
  * | `LIVE_SERVICE_NOT_AVAILABLE` | The API answered a `5xx` |
  * | `NETWORK_NOT_AVAILABLE` | No response arrived: offline, DNS, TLS or CORS failure |
@@ -4091,11 +4436,15 @@ export type DisplayUnits = {
  * When a service request receives a 429 status code, the SDK retries it with exponential
  * backoff. It respects a `Retry-After` header given in seconds.
  *
+ * @remarks
+ * Without a `Retry-After` header, each wait is drawn at random between half the backoff and the
+ * whole of it, so that clients rate-limited at the same moment don't all retry together.
+ *
  * @example
  * ```typescript
  * TomTomConfig.instance.put({
  *   retry: {
- *     initialWaitMs: 0.447,
+ *     initialWaitMs: 447,
  *     backoffFactor: 1.618,
  *     timeoutMs: 40000,
  *   }
@@ -4106,18 +4455,18 @@ export type DisplayUnits = {
  */
 export type RetryConfig = {
   /**
-   * The wait in milliseconds before the first retry.
+   * The backoff in milliseconds before the first retry: the longest the first wait can be.
    *
-   * It is the base delay when no `Retry-After` header is present.
+   * It applies when no `Retry-After` header is present.
    *
-   * @default 0.447
+   * @default 447
    */
   initialWaitMs?: number;
   /**
-   * The multiplier applied to the wait after each retry.
+   * The multiplier applied to the backoff after each retry.
    *
-   * For example, with `initialWaitMs: 0.447` and `backoffFactor: 1.618`,
-   * the waits are 0.447ms, 0.723ms, 1.170ms and so on.
+   * For example, with `initialWaitMs: 447` and `backoffFactor: 1.618`,
+   * the backoff is 447ms, 723ms, 1170ms and so on.
    *
    * @default 1.618
    */
@@ -4175,7 +4524,7 @@ export type GlobalConfig = {
   /**
    * The language of SDK services and map content.
    *
-   * It accepts IETF language codes, case-insensitive, and affects search results,
+   * It accepts the IETF language codes {@link Language} lists, and affects search results,
    * routing instructions, map labels and traffic incident descriptions.
    *
    * @default "ngt" (Neutral Ground Truth - uses local language for each location)
@@ -4232,7 +4581,7 @@ export type GlobalConfig = {
    * By default, the SDK retries requests that receive a 429 status code with exponential backoff.
    * A field you leave out takes its default. To turn retrying off, set it to `undefined`.
    *
-   * @default { initialWaitMs: 0.447, backoffFactor: 1.618, timeoutMs: 40000 }
+   * @default { initialWaitMs: 447, backoffFactor: 1.618, timeoutMs: 40000 }
    * @see {@link RetryConfig}
    */
   retry?: RetryConfig;
@@ -4289,8 +4638,8 @@ export declare class TomTomConfig {
    * Merges configuration values into the global configuration.
    *
    * New values override existing ones. The merge is shallow, so a nested object replaces the
-   * existing one entirely. The exception is a `retry` object, which takes its missing fields from
-   * the default retry config.
+   * existing one entirely. A `retry` object then takes its missing fields from the default retry
+   * config, not from an earlier `put`.
    *
    * @example
    * ```typescript
@@ -4315,6 +4664,10 @@ export declare class TomTomConfig {
   /**
    * Returns the current global configuration.
    *
+   * It holds `apiKey`, `commonBaseURL`, `retry` (unless you set it to `undefined`) and the keys you
+   * set. A key you never set reads `undefined` and behaves as its {@link GlobalConfig} property
+   * describes.
+   *
    * @example
    * ```typescript
    * const config = TomTomConfig.instance.get();
@@ -4350,7 +4703,9 @@ export declare const isProxyCredentialsMode: (config?: Partial<Pick<GlobalConfig
  */
 export declare const isBBoxWithArea: (bbox: OptionalBBox) => boolean;
 /**
- * The bounding box that contains all the given ones, skipping `undefined` entries.
+ * The narrowest bounding box that contains all the given ones, skipping `undefined` entries.
+ *
+ * It crosses the antimeridian, with `west > east`, when that is the narrower way to contain them.
  *
  * @group Utils
  */
@@ -4358,7 +4713,11 @@ export declare const bboxFromBBoxes: (bboxes: OptionalBBox[]) => OptionalBBox;
 /**
  * The bounding box of an array of `[longitude, latitude]` positions, or `undefined` if empty.
  *
- * A very long array is sampled rather than scanned in full, which keeps the box close to exact.
+ * - It reads the positions as loose points, with no edges between them. For a line or a ring, pass it
+ *   as GeoJSON to {@link bboxFromGeoJSON}, which follows its edges.
+ * - It crosses the antimeridian, with `west > east`, when that box is narrower than the one from the
+ *   lowest to the highest longitude. A tie, or positions spanning -180 to 180, keeps the latter.
+ * - A very long array is sampled rather than scanned in full, which keeps the box close to exact.
  *
  * @group Utils
  */
@@ -4375,8 +4734,16 @@ export declare const bboxFromCoordsArray: (coordinates: Position[] | undefined)
  * An existing bbox wins over the geometry. This matters for Point features from TomTom
  * services, whose bbox may cover a broader area than the point itself.
  *
+ * A calculated box crosses the antimeridian, with `west > east`, when that is the narrower way to
+ * enclose the input:
+ * - Points and multi-points take the narrower box, as {@link bboxFromCoordsArray} does.
+ * - A line or a ring follows its edges, which never wrap across the antimeridian (RFC 7946 §3.1.9):
+ *   `[[179, 0], [-179, 0]]` spans 358°, and `[[179, 0], [181, 0]]` gives `[179, 0, -179, 0]`.
+ * - The parts of a multi-geometry and the members of a collection merge as {@link bboxFromBBoxes} does,
+ *   so a polygon cut at 180, as RFC 7946 asks, gets the box across the antimeridian.
+ *
  * @param hasBBox A GeoJSON object, such as a Feature, FeatureCollection or Geometry, or an array of them.
- * @returns The bounding box as `[minLng, minLat, maxLng, maxLat]`, or `undefined` for invalid input.
+ * @returns The bounding box as `[west, south, east, north]`, or `undefined` for invalid input.
  *
  * @example
  * ```typescript
@@ -4425,15 +4792,162 @@ export declare const bboxFromGeoJSON: (hasBBox: HasBBox) => OptionalBBox;
  *
  * @group Utils
  */
-export declare const bboxCenter: ([west, south, east, north]: BBox) => Position;
+export declare const bboxCenter: (bbox: BBox) => Position;
 /**
  * Creates a GeoJSON Polygon Feature representing the area of the given bounding box.
+ *
+ * For a box crossing the antimeridian, with `west > east`, the ring's east edge is `east + 360`, which
+ * keeps it around the box rather than around the rest of the world.
+ *
  * @param bbox The bounding box as `[west, south, east, north]`.
  *
  * @group Utils
  */
 export declare const polygonFromBBox: (bbox: BBox) => Feature<Polygon>;
 //#endregion
+//#region src/util/cells.d.ts
+/**
+ * Groups points into cells, a grid of hexagons or squares or your own polygons, and gives each cell
+ * statistics over a value of its points, such as the median price per square metre.
+ *
+ * @param points - The points to aggregate.
+ * @param options - The cells, the value and the statistics.
+ * @returns A polygon per cell holding at least `minCount` points, with the statistics as its properties,
+ * for any map module to draw, such as `CustomGeoJSONModule`.
+ *
+ * @remarks
+ * - A grid cell is found from the point's coordinates alone, so the cost grows with the points, not the
+ *   cells. Every point with a value and finite coordinates lands in a cell, and the cells around the
+ *   antimeridian stay side by side, their longitudes past ±180 where needed. A grid cell's `id` names
+ *   its grid, column and row: `'hex:3:-2'`.
+ * - Your own polygons are tested point by point, after a bounding-box check. A point inside several of
+ *   them counts in each.
+ * - The cell size is fixed. To follow the zoom, aggregate again on the map's `zoomend` with a size for
+ *   the new zoom.
+ *
+ * @example
+ * ```typescript
+ * const cells = aggregateIntoCells(listings, {
+ *     grid: 'hex',
+ *     cellSizeKM: 1,
+ *     value: 'pricePerSquareMeter',
+ *     stats: ['median', 'mean', 'count'],
+ *     minCount: 5,
+ * });
+ * // Each cell's properties: { median, mean, count }
+ * ```
+ *
+ * @group Utils
+ */
+export declare const aggregateIntoCells: <P extends GeoJsonProperties, const S extends CellStatistic = "count", const G extends CellGrid = CellGrid>(points: FeatureCollection<Point, P>, options: AggregateIntoCellsOptions<P, S, G>) => AggregatedCells<S, G>;
+//#endregion
+//#region src/util/curves.d.ts
+/**
+ * Finds the curves of a route: the stretches where the road keeps turning the same way.
+ *
+ * @param route The route, with its geometry, and its guidance instructions when it has them.
+ * @param options The thresholds a stretch has to reach to count as a curve.
+ * @returns The curves, in order along the route.
+ *
+ * @remarks
+ * - `calculateRoute` fills `sections.curve` when its `sectionTypes` names `curve`, with these
+ *   thresholds from its `curveDetection.curve`. Call this, or {@link withCurveSections}, to find
+ *   them again with others.
+ * - A curve ends at a straight longer than `maxStraightInMeters`, or where the road turns the
+ *   other way, so an S-bend is two curves.
+ * - A sharp corner between two straights, as at most junctions, is no curve: the road doesn't bend
+ *   there. A roundabout is, and on a route with guidance a curve at a junction names its
+ *   `maneuver`, as {@link CurveSectionProps} sets out.
+ * - Where a route turns back at a waypoint, as at the end of a dead-end road, it makes no curve.
+ * - Each curve's `severity` reads the route's `speedLimit` sections, when it has them.
+ *
+ * @example
+ * ```typescript
+ * // Only the hard curves, to warn a passenger prone to motion sickness
+ * const hard = getCurveSections(route, { maxRadiusInMeters: 50, minHeadingChangeInDegrees: 60 });
+ * ```
+ *
+ * @group Utils
+ */
+export declare const getCurveSections: (route: Route, { minHeadingChangeInDegrees, maxRadiusInMeters, maxStraightInMeters }?: CurveSectionsOptions) => CurveSectionProps[];
+/**
+ * Whether a curve is a hairpin: a bend of the road turning 140° or more on a radius of 40 m or less,
+ * as the numbered bends of a mountain pass do.
+ *
+ * @remarks
+ * - A wider bend that turns as far, as where a valley road swings round a spur, is a horseshoe a
+ *   driver takes at speed, and no hairpin.
+ * - A curve at a maneuver, as a roundabout or a turn at a junction, is no hairpin however far it
+ *   turns.
+ * - A curvy stretch's `hairpinCount` counts its curves this says yes to.
+ *
+ * @example
+ * ```typescript
+ * const hairpins = route.properties.sections.curve?.filter(isHairpin) ?? [];
+ * ```
+ *
+ * @group Utils
+ */
+export declare const isHairpin: (curve: Pick<CurveSectionProps, "headingChangeInDegrees" | "radiusInMeters" | "maneuver">) => boolean;
+/**
+ * Finds the curvy stretches of a route: where curves follow one another closely, such as a
+ * mountain pass or a winding country road.
+ *
+ * @param route The route, with its geometry.
+ * @param options The curves to group, and how close they have to follow one another.
+ * @returns The curvy stretches, in order along the route.
+ *
+ * @remarks
+ * - `calculateRoute` fills `sections.curvyStretch` when its `sectionTypes` names `curvyStretch`,
+ *   with these thresholds from its `curveDetection.curvyStretch`. Call this for others, or over
+ *   curves you found with your own {@link getCurveSections} thresholds.
+ * - A curve at a maneuver ends a stretch, as {@link CurvyStretchSectionProps} sets out.
+ * - A stretch's `curveCount` over its `lengthInMeters` says how winding it is: the hairpins of a
+ *   mountain pass come one every 200 m or so. Rank the stretches by it to seek out the best roads, or
+ *   to tell which route stays clear of them. Its `hairpinCount` says how many of them are hairpins,
+ *   as {@link isHairpin} tells them.
+ * - Its `curvinessScore` adds up its curves' scores, so a longer stretch scores more. Roadcurvature.com,
+ *   which scores roads the same way, lists them from 300 and calls those over 1000 very twisty.
+ *
+ * @example
+ * ```typescript
+ * const routes = await calculateRoute({ locations, costModel: { routeType: 'thrilling' }, guidance: { type: 'coded' } });
+ * const passes = getCurvyStretchSections(routes.features[0], { minCurveCount: 5 });
+ * passes.forEach((pass) => console.log(`${pass.curveCount} curves in ${formatDistance(pass.lengthInMeters)}`));
+ *
+ * // The most rewarding stretch to ride
+ * const best = passes.toSorted((first, second) => second.curvinessScore - first.curvinessScore)[0];
+ * ```
+ *
+ * @group Utils
+ */
+export declare const getCurvyStretchSections: (route: Route, { curves, maxGapInMeters, minCurveCount }?: CurvyStretchSectionsOptions) => CurvyStretchSectionProps[];
+/**
+ * A copy of a route with its curves and curvy stretches found again, with thresholds of your own.
+ *
+ * @param route The route, with its geometry, and its guidance instructions when it has them.
+ * @param options The thresholds, `calculateRoute`'s `curveDetection` among them.
+ * @returns The route with new `sections.curve` and `sections.curvyStretch`, each left out when it
+ * finds none. Its other sections stay as they are.
+ *
+ * @remarks
+ * - Tune the thresholds on routes you already have, with no new request. Calling
+ *   {@link getCurveSections} and {@link getCurvyStretchSections} yourself does the same, as long as
+ *   you pass the new curves to the second.
+ * - The curves read the route as it came back: a `maneuver` needs its guidance, and a `severity`
+ *   its `speedLimit` sections. Ask for both when you calculate it.
+ *
+ * @example
+ * ```typescript
+ * // Count the sweeping bends of up to 500 m too
+ * const wider = routes.features.map((route) => withCurveSections(route, { curve: { maxRadiusInMeters: 500 } }));
+ * await routingModule.showRoutes({ ...routes, features: wider });
+ * ```
+ *
+ * @group Utils
+ */
+export declare const withCurveSections: (route: Route, { curve, curvyStretch }?: CurveDetectionOptions) => Route;
+//#endregion
 //#region src/util/distinctSections.d.ts
 /**
  * Finds the stretches of each route that none of the other routes drives.
@@ -4467,6 +4981,26 @@ export declare const getDistinctSections: (routes: Routes | Route[], { minLength
  */
 export declare const generateId: () => string;
 //#endregion
+//#region src/util/geopoliticalView.d.ts
+/**
+ * Tells whether the SDK sends `view` to that API, so you can label a result with the view its request carried.
+ *
+ * @remarks
+ * The map and the services decide what to send from this same predicate. A request without its
+ * view gets the API's default, as {@link GeopoliticalView} describes.
+ *
+ * @example
+ * ```typescript
+ * const place = await reverseGeocode({ position, geopoliticalView: 'US' });
+ * // false: the address is in the default view for the caller's country
+ * const label = servesGeopoliticalView('US', 'reverseGeocoding') ? 'US' : 'Default view';
+ * ```
+ *
+ * @see [Supported views](https://docs.tomtom.com/maps-sdk-js/guides/core/geopolitical-views#supported-views)
+ * @group Shared
+ */
+export declare const servesGeopoliticalView: (view: GeopoliticalView, api: GeopoliticalViewAPI) => boolean;
+//#endregion
 //#region src/util/headers.d.ts
 /**
  * SDK name used TomTom custom header tomtom-user-agent
@@ -4545,6 +5079,9 @@ export declare const getInstructionLanes: (route: Route, instruction: Pick<Instr
  * - GeoJSON Point geometries
  * - GeoJSON Point Features, including Places with entry points
  *
+ * With `main-when-available`, a place with no entry point typed `'main'` uses its first untyped one, as
+ * reverse geocoding returns them. {@link GetPositionEntryPointOption} has the full rule.
+ *
  * @param hasLngLat An object that is or contains a lng-lat position.
  * @param options How to extract the position.
  * @returns The extracted position as `[longitude, latitude]`, or `null` if the input is invalid.
@@ -4837,7 +5374,7 @@ export declare const getRouteProgressForSection: (route: Route, section: RouteSp
  *
  * @param route The route containing the section.
  * @param section The section, or any {@link RouteSpan}, to calculate the bbox for.
- * @returns The bounding box as `[minLng, minLat, maxLng, maxLat]`, or `undefined` if the section or route is invalid.
+ * @returns The bounding box as `[west, south, east, north]`, or `undefined` if the section or route is invalid.
  *
  * @remarks
  * - Three points are fast, but a winding section can stray outside their box. For a tighter box,
@@ -4850,7 +5387,7 @@ export declare const getRouteProgressForSection: (route: Route, section: RouteSp
  * // section = { id: 'section-1', startPointIndex: 0, endPointIndex: 3, countryCodeISO3: 'NLD' }
  *
  * const bbox = getSectionBBox(route, section);
- * // Returns: [minLng, minLat, maxLng, maxLat] spanning the section, or undefined
+ * // Returns: [west, south, east, north] spanning the section, or undefined
  * ```
  *
  * @group Utils
@@ -5088,4 +5625,4 @@ export declare const formatDuration: (seconds: number | undefined, options?: Tim
  */
 export declare const formatDistance: (meters: number | undefined, options?: DistanceDisplayUnits) => string;
 //#endregion
-export type { Anything, BBox, ChargingPark, CompareRoutesOptions, DistanceUnitsType, DistinctSectionsOptions, DrivingSide, FeatureCollectionWithProperties, Fuel, GeometryDataSource, GetPositionEntryPointOption, GetPositionOptions, Guidance, HasBBox, HasLngLat, ImportantRoad, ImportantRoadsOptions, Instruction, InstructionText, Landmark, LegSummary, Maneuver, ManeuverAngle, ManeuverView, Moment, OpeningHours, OpeningHoursMode, OptionalBBox, POI, PathLike, PlaceDataSources, PoiDetailsDataSource, PolygonFeature, PolygonFeatures, RelatedPOI, RoadInformation, RoadInformationProperty, RoadShield, RoadShieldReference, RoundaboutType, RouteComparison, RoutePathPoint, RoutePlanningLocation, RoutePlanningLocationType, RouteSummary, SectionsWithin, SectionsWithinOfType, SectionsWithinOptions, SideRoad, SideRoadSide, Signpost, SummaryBase, TimeRange, TimeZone, TollPaymentType, TomTomAPIHeaders, Waypoint, WaypointLike, WaypointProps, Waypoints };
+export type { AggregateIntoCellsOptions, AggregatedCells, Anything, BBox, CellGrid, CellGridOptions, CellGridShape, CellStatistic, CellStatistics, CellValue, CellValueOptions, ChargingPark, CompareRoutesOptions, CurveDetectionOptions, CurveSectionsOptions, CurvyStretchSectionsOptions, DistanceUnitsType, DistinctSectionsOptions, DrivingSide, FeatureCollectionWithProperties, Fuel, GeometryDataSource, GetPositionEntryPointOption, GetPositionOptions, Guidance, HasBBox, HasLngLat, ImportantRoad, ImportantRoadsOptions, Instruction, InstructionText, Landmark, LatticeGridOptions, LegSummary, Maneuver, ManeuverAngle, ManeuverView, Moment, NumericPropertyKey, OpeningHours, OpeningHoursMode, OptionalBBox, POI, PathLike, PlaceDataSources, PoiDetailsDataSource, PolygonFeature, PolygonFeatures, RelatedPOI, RoadInformation, RoadInformationProperty, RoadShield, RoadShieldReference, RoundaboutType, RouteComparison, RoutePathPoint, RoutePlanningLocation, RoutePlanningLocationType, RouteSummary, SectionsWithin, SectionsWithinOfType, SectionsWithinOptions, SideRoad, SideRoadSide, Signpost, SummaryBase, TimeRange, TimeZone, TollPaymentType, TomTomAPIHeaders, Waypoint, WaypointLike, WaypointProps, Waypoints };