@tomtom-org/maps-sdk 0.29.0

package/core/dist/index.d.ts

@@ -0,0 +1,4674 @@
+import { BBox } from 'geojson';
+import { Feature } from 'geojson';
+import { FeatureCollection } from 'geojson';
+import { GeoJsonObject } from 'geojson';
+import { GeoJsonProperties } from 'geojson';
+import { Geometry } from 'geojson';
+import { LineString } from 'geojson';
+import { MultiPolygon } from 'geojson';
+import { Point } from 'geojson';
+import { Polygon } from 'geojson';
+import { Position } from 'geojson';
+
+/**
+ * Structured address components for a place.
+ *
+ * Provides hierarchical address information from building number up to country level.
+ * Not all components are present for every place; availability depends on the location
+ * and data coverage.
+ *
+ * @example
+ * ```typescript
+ * const address: AddressProperties = {
+ *   freeformAddress: '1600 Pennsylvania Avenue NW, Washington, DC 20500, USA',
+ *   streetNumber: '1600',
+ *   streetName: 'Pennsylvania Avenue NW',
+ *   municipality: 'Washington',
+ *   countrySubdivision: 'DC',
+ *   postalCode: '20500',
+ *   countryCode: 'US',
+ *   country: 'United States',
+ *   countryCodeISO3: 'USA'
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type AddressProperties = {
+    /**
+     * Complete formatted address string.
+     *
+     * Follows the formatting conventions of the result's country of origin.
+     * For countries, this is the full country name.
+     */
+    freeformAddress: string;
+    /**
+     * Building or house number on the street.
+     */
+    streetNumber?: string;
+    /**
+     * Street name without the building number.
+     */
+    streetName?: string;
+    /**
+     * Subdivision of a municipality (sub-city or super-city area).
+     */
+    municipalitySubdivision?: string;
+    /**
+     * City or town name.
+     */
+    municipality?: string;
+    /**
+     * County or second-level administrative subdivision.
+     */
+    countrySecondarySubdivision?: string;
+    /**
+     * Named area or third-level administrative subdivision.
+     */
+    countryTertiarySubdivision?: string;
+    /**
+     * State or province (first-level administrative subdivision).
+     */
+    countrySubdivision?: string;
+    /**
+     * Postal code or ZIP code.
+     */
+    postalCode?: string;
+    /**
+     * Extended postal code.
+     *
+     * Availability depends on region. More precise than standard postal code.
+     */
+    extendedPostalCode?: string;
+    /**
+     * Two-letter ISO 3166-1 alpha-2 country code.
+     *
+     * Examples: 'US', 'GB', 'NL', 'DE'
+     */
+    countryCode?: string;
+    /**
+     * Full country name.
+     */
+    country?: string;
+    /**
+     * Three-letter ISO 3166-1 alpha-3 country code.
+     *
+     * Examples: 'USA', 'GBR', 'NLD', 'DEU'
+     *
+     * @see [ISO 3166-1 alpha-3 codes](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-3)
+     */
+    countryCodeISO3?: string;
+    /**
+     * Full name of the first-level administrative subdivision.
+     *
+     * Present when countrySubdivision is abbreviated. Supported for USA, Canada, and Great Britain.
+     * Example: "California" when countrySubdivision is "CA"
+     */
+    countrySubdivisionName?: string;
+    /**
+     * Local area or locality name.
+     *
+     * Represents a named geographic area that groups addressable objects
+     * without being an official administrative unit.
+     */
+    localName?: string;
+};
+
+/**
+ * Address range information for a street segment.
+ *
+ * Used for Address Range type results to indicate ranges of addresses
+ * along a street segment.
+ *
+ * @group Place
+ */
+export declare type AddressRanges = {
+    /**
+     * Address range on the left side of the street.
+     *
+     * Looking from the 'from' point toward the 'to' point.
+     */
+    rangeLeft: string;
+    /**
+     * Address range on the right side of the street.
+     *
+     * Looking from the 'from' point toward the 'to' point.
+     */
+    rangeRight: string;
+    /**
+     * Starting coordinates of the street segment [longitude, latitude].
+     */
+    from: Position;
+    /**
+     * Ending coordinates of the street segment [longitude, latitude].
+     */
+    to: Position;
+};
+
+/**
+ * Generic object type with string keys and unknown values.
+ *
+ * Used as a flexible type constraint for objects where the shape is not predetermined.
+ * Useful for extensible property objects or when accepting arbitrary user data.
+ *
+ * @example
+ * ```typescript
+ * function processCustomData(data: Anything) {
+ *   // Access properties dynamically
+ *   console.log(data['customField']);
+ * }
+ * ```
+ *
+ * @group Shared
+ */
+export declare type Anything = {
+    [x: string]: unknown;
+};
+
+/**
+ * Creates a soft waypoint with a flexible radius for route calculation.
+ *
+ * A soft waypoint allows the routing algorithm to find the optimal path within
+ * a specified radius of the target location, rather than forcing the route to
+ * pass through the exact point. This is useful for:
+ * - Allowing the router to stay on major roads instead of detouring
+ * - Creating more efficient routes when exact location isn't critical
+ * - Simulating "pass near" behavior in route planning
+ *
+ * The resulting waypoint is a GeoJSON Point Feature with a `radiusMeters` property
+ * that the routing service uses to optimize the path.
+ *
+ * @param hasLngLat The location to extract coordinates from. Can be a coordinate array,
+ *                  Point geometry, or Point Feature.
+ * @param radiusMeters The radius in meters within which the route can pass.
+ *                     The routing service will find the optimal point within this radius.
+ * @returns A waypoint Feature with the radiusMeters property set.
+ *
+ * @example
+ * ```typescript
+ * // Create a soft waypoint from coordinates
+ * // Route can pass anywhere within 500m of this point
+ * const softWaypoint = asSoftWaypoint([4.9, 52.3], 500);
+ *
+ * // Use in route calculation
+ * const route = await calculateRoute({
+ *   key: 'your-api-key',
+ *   locations: [
+ *     [4.9, 52.3],              // Hard waypoint (exact location)
+ *     asSoftWaypoint([5.1, 52.5], 1000),  // Soft waypoint (within 1km)
+ *     [5.3, 52.7]               // Hard waypoint (exact location)
+ *   ]
+ * });
+ *
+ * // Create soft waypoint from a Place Feature
+ * const place = await geocode({ key: 'your-api-key', query: 'Amsterdam' });
+ * const softPlace = asSoftWaypoint(place, 2000);
+ * // Route will pass within 2km of Amsterdam center
+ * ```
+ *
+ * @see [Waypoints Guide](https://docs.tomtom.com/maps-sdk-js/guides/services/routing/waypoints-and-custom-routes)
+ *
+ * @group Route
+ */
+export declare const asSoftWaypoint: (hasLngLat: HasLngLat, radiusMeters: number) => Waypoint;
+
+/**
+ * Route features that the routing engine will attempt to avoid when calculating routes.
+ *
+ * Use these options to customize routes based on vehicle capabilities, user preferences,
+ * or regulatory requirements. Note that avoidance is not guaranteed if no alternative route exists.
+ *
+ * @remarks
+ * Available avoidance options:
+ * - `tollRoads`: Avoids roads requiring toll payments
+ * - `motorways`: Avoids high-speed limited-access highways (useful for scenic routes or vehicle restrictions)
+ * - `ferries`: Avoids water crossings requiring ferry transport
+ * - `unpavedRoads`: Avoids unpaved/dirt roads (recommended for standard vehicles)
+ * - `carpools`: Avoids carpool/HOV (High Occupancy Vehicle) lanes
+ * - `alreadyUsedRoads`: Prevents using the same road segment multiple times (useful for delivery routes)
+ * - `borderCrossings`: Avoids crossing international borders (useful for customs/visa considerations)
+ * - `tunnels`: Avoids underground tunnels (useful for vehicles carrying hazardous materials)
+ * - `carTrains`: Avoids car train transport segments
+ * - `lowEmissionZones`: Avoids zones with vehicle emission restrictions
+ *
+ * @example
+ * ```typescript
+ * // Avoid tolls and motorways for a scenic route
+ * const avoid: Avoidable[] = ['tollRoads', 'motorways'];
+ *
+ * // Avoid unpaved roads for a standard car
+ * const avoid: Avoidable[] = ['unpavedRoads'];
+ * ```
+ *
+ * @group Route
+ */
+export declare type Avoidable = (typeof avoidableTypes)[number];
+
+/**
+ * Array of all available route avoidance options.
+ *
+ * This constant defines the complete set of road/route features that can be avoided
+ * during route calculation. Use this to derive the {@link Avoidable} type or to validate
+ * user input against supported avoidance options.
+ *
+ * @remarks
+ * This is a readonly tuple used as the source of truth for valid avoidance types.
+ * The {@link Avoidable} type is derived from this array to ensure type safety.
+ *
+ * @example
+ * ```typescript
+ * // Check if a string is a valid avoidance type
+ * const userInput = 'tollRoads';
+ * if (avoidableTypes.includes(userInput as Avoidable)) {
+ *   // userInput is valid
+ * }
+ *
+ * // Iterate over all available options
+ * avoidableTypes.forEach(type => {
+ *   console.log(`Available option: ${type}`);
+ * });
+ * ```
+ *
+ * @group Route
+ */
+export declare const avoidableTypes: readonly ["tollRoads", "motorways", "ferries", "unpavedRoads", "carpools", "alreadyUsedRoads", "borderCrossings", "tunnels", "carTrains", "lowEmissionZones"];
+
+/**
+ * Calculate the center of bbox
+ * @ignore
+ * @param bbox
+ * */
+export declare const bboxCenter: (bbox: BBox) => Position;
+
+/**
+ * @ignore
+ * @param bboxToContain
+ * @param bboxToExpand
+ */
+export declare const bboxExpandedWithBBox: (bboxToContain: OptionalBBox, bboxToExpand?: BBox) => OptionalBBox;
+
+/**
+ * Expands the given bounding box with the given GeoJSON.
+ * * If the feature has also a bounding box, the latter is considered instead.
+ * * If the given bounding box is undefined, the given point is considered alone.
+ * This results in a zero-sized bounding box or the point bbox if it exists.
+ * @ignore
+ * @param geoJson
+ * @param bboxToExpand
+ */
+export declare const bboxExpandedWithGeoJSON: (geoJson: GeoJsonObject, bboxToExpand?: BBox) => OptionalBBox;
+
+/**
+ * Expands the given bounding box with the given position.
+ * * If the given bounding box is undefined, the given position is considered alone.
+ * This results in a zero-sized bounding box.
+ * @ignore
+ * @param positionToContain
+ * @param bboxToExpand
+ */
+export declare const bboxExpandedWithPosition: (positionToContain: Position, bboxToExpand?: BBox) => OptionalBBox;
+
+/**
+ * Calculates the bounding box which contains all the given bounding boxes.
+ * @ignore
+ * @param bboxes
+ */
+export declare const bboxFromBBoxes: (bboxes: OptionalBBox[]) => OptionalBBox;
+
+/**
+ * Calculates a bounding box from an array of coordinates.
+ * * If the array is beyond a certain size, it doesn't scan it fully,
+ * for performance, but still ensures a decent accuracy.
+ *
+ * @ignore
+ * @param coordinates Should always be passed, but undefined is also supported, resulting in undefined bbox.
+ */
+export declare const bboxFromCoordsArray: (coordinates: Position[] | undefined) => OptionalBBox;
+
+/**
+ * Extracts or calculates a bounding box from GeoJSON objects.
+ *
+ * This utility function handles various GeoJSON types and automatically determines
+ * the best approach to obtain a bounding box:
+ * - Uses existing `bbox` properties when available (fastest)
+ * - Calculates from geometry coordinates when needed
+ * - Aggregates bounding boxes from collections
+ * - Optimizes large geometries by sampling points for performance
+ *
+ * The function prioritizes existing bbox fields over geometry calculations, which is
+ * important for Point features from TomTom services that may have bbox representing
+ * a broader area than just the point location.
+ *
+ * @param hasBBox A GeoJSON object (Feature, FeatureCollection, Geometry, etc.) or array of such objects
+ * @returns The bounding box as `[minLng, minLat, maxLng, maxLat]`, or `undefined` if input is invalid
+ *
+ * @example
+ * ```typescript
+ * // From a Feature with existing bbox
+ * const place = await geocode({ key: 'key', query: 'Amsterdam' });
+ * const bbox = bboxFromGeoJSON(place);
+ * // Returns the bbox that came with the place
+ *
+ * // From a Polygon geometry (calculates bbox)
+ * const polygon = {
+ *   type: 'Polygon',
+ *   coordinates: [[
+ *     [4.88, 52.36],
+ *     [4.90, 52.36],
+ *     [4.90, 52.38],
+ *     [4.88, 52.38],
+ *     [4.88, 52.36]
+ *   ]]
+ * };
+ * const polyBbox = bboxFromGeoJSON(polygon);
+ * // Returns: [4.88, 52.36, 4.90, 52.38]
+ *
+ * // From a FeatureCollection (aggregates all features)
+ * const places = await search({ key: 'key', query: 'coffee' });
+ * const collectionBbox = bboxFromGeoJSON(places);
+ * // Returns bbox encompassing all search results
+ *
+ * // From a LineString (calculates from coordinates)
+ * const route = await calculateRoute({
+ *   key: 'key',
+ *   locations: [[4.9, 52.3], [4.5, 51.9]]
+ * });
+ * const routeBbox = bboxFromGeoJSON(route.routes[0].geometry);
+ * // Returns bbox containing the entire route
+ *
+ * // From an array of GeoJSON objects
+ * const multiBbox = bboxFromGeoJSON([place1, place2, place3]);
+ * // Returns bbox encompassing all three places
+ * ```
+ *
+ * @group Shared
+ */
+export declare const bboxFromGeoJSON: (hasBBox: HasBBox) => OptionalBBox;
+
+/**
+ * Returns the given bbox if it has area, or undefined otherwise.
+ * @ignore
+ * @param bbox The BBox to verify. If undefined, undefined is returned.
+ */
+export declare const bboxOnlyIfWithArea: (bbox: OptionalBBox) => OptionalBBox;
+
+/**
+ * Brand information for a POI.
+ *
+ * Identifies the commercial brand or chain associated with a location.
+ * Useful for finding specific franchise locations or filtering by brand.
+ *
+ * @example
+ * ```typescript
+ * const brand: Brand = {
+ *   name: 'Starbucks'
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type Brand = {
+    /**
+     * Brand name.
+     *
+     * The commercial or franchise name (e.g., 'McDonald\'s', 'Shell', 'Hilton').
+     */
+    name: string;
+};
+
+/**
+ * Traffic incident cause based on TPEG2-TEC standard.
+ *
+ * TPEG (Transport Protocol Experts Group) codes provide standardized
+ * classification of traffic incident causes.
+ *
+ * @see [TPEG2-TEC Standard](https://www.iso.org/standard/59231.html)
+ *
+ * @group Route
+ */
+export declare type CauseTEC = {
+    /**
+     * Main cause code from TPEG2-TEC standard.
+     *
+     * Primary classification of what caused the incident.
+     */
+    mainCauseCode: number;
+    /**
+     * Optional sub-cause code from TPEG2-TEC standard.
+     *
+     * More specific classification under the main cause.
+     */
+    subCauseCode?: number;
+};
+
+/**
+ * Data source reference for EV charging availability.
+ *
+ * @example
+ * ```typescript
+ * // Use this ID with the EV Charging Stations Availability service
+ * const dataSource: ChargingAvailabilityDataSource = {
+ *   id: 'charging-park-123'
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type ChargingAvailabilityDataSource = {
+    /**
+     * Charging availability ID for the EV Charging Stations Availability service.
+     *
+     * Pass this value as the chargingAvailability parameter to fetch
+     * real-time status of charging points and connectors.
+     */
+    id?: string;
+};
+
+/**
+ * Information about a specific charging connection at a charging point.
+ *
+ * Describes the technical specifications of a charging connector including
+ * plug type, voltage, current, and power ratings.
+ *
+ * @group Route
+ */
+export declare type ChargingConnectionInfo = {
+    /**
+     * The plug type for this charging connection.
+     *
+     * Must be compatible with the vehicle's charging port.
+     */
+    plugType: PlugType;
+    /**
+     * The rated voltage in volts (V) of the charging process.
+     *
+     * Common values: 120V, 240V (AC), 400V, 800V (DC)
+     */
+    voltageInV?: number;
+    /**
+     * The rated current in amperes (A) of the charging process.
+     *
+     * Determines the charging speed along with voltage.
+     */
+    currentInA?: number;
+    /**
+     * The current type (AC/DC) for this charging connection.
+     *
+     * - AC: Alternating current (slower charging, 1-phase or 3-phase)
+     * - DC: Direct current (fast charging)
+     */
+    currentType?: CurrentType;
+    /**
+     * The rated maximum power in kilowatts (kW) of the charging connection.
+     *
+     * Indicates the maximum charging speed. Common values:
+     * - 3-7 kW: Level 1/2 AC charging
+     * - 7-22 kW: Level 2 AC charging
+     * - 50-350 kW: DC fast charging
+     */
+    chargingPowerInkW?: number;
+    /**
+     * The charging speed classification of this charging connection.
+     *
+     * @remarks
+     * - `slow`: Typically up to 12 kW (Level 1 AC charging)
+     * - `regular`: Typically between 12 kW and 50 kW (Level 2 AC charging)
+     * - `fast`: Typically between 50 kW and 150 kW (DC fast charging)
+     * - `ultra-fast`: Typically above 150 kW (High-power DC fast charging)
+     */
+    chargingSpeed?: ChargingSpeed;
+};
+
+/**
+ * Information about an EV charging park.
+ *
+ * Describes the charging infrastructure at a location, including available
+ * connector types and counts. This is static information about the facility.
+ *
+ * @example
+ * ```typescript
+ * const chargingPark: ChargingPark = {
+ *   connectors: [
+ *     { id: 'c1', type: 'IEC62196Type2CCS', ratedPowerKW: 150, ... },
+ *     { id: 'c2', type: 'Chademo', ratedPowerKW: 50, ... }
+ *   ],
+ *   connectorCounts: [
+ *     { connector: {...}, count: 4, statusCounts: {} },
+ *     { connector: {...}, count: 2, statusCounts: {} }
+ *   ]
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type ChargingPark = {
+    /**
+     * Array of all unique connector types offered at this charging park.
+     *
+     * Each connector represents a different charging standard available.
+     * Use this to determine compatibility with your vehicle.
+     */
+    connectors: Connector[];
+    /**
+     * Count of connectors grouped by type and power level.
+     *
+     * Provides aggregate counts without real-time availability status.
+     * This is static infrastructure information about how many of each
+     * connector type exist at the location.
+     *
+     * @remarks
+     * For real-time availability, use the availability property instead.
+     * This field shows total counts regardless of current operational status.
+     */
+    connectorCounts: Omit<ConnectorAvailability, 'statusCounts'>[];
+};
+
+/**
+ * Charging park with optional real-time availability data.
+ *
+ * Combines static infrastructure information with dynamic availability status
+ * when available from the EV Charging Station Availability service.
+ *
+ * @example
+ * ```typescript
+ * const parkWithAvailability: ChargingParkWithAvailability = {
+ *   connectors: [...],
+ *   connectorCounts: [...],
+ *   availability: {
+ *     id: 'park-123',
+ *     chargingStations: [...],
+ *     chargingPointAvailability: { count: 10, statusCounts: {...} },
+ *     // ... real-time status data
+ *   }
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type ChargingParkWithAvailability = ChargingPark & {
+    /**
+     * Real-time availability information for this charging park.
+     *
+     * Present only if availability data has been fetched from the
+     * EV Charging Station Availability service. Contains current
+     * operational status for all charging points and connectors.
+     *
+     * @remarks
+     * To get availability data:
+     * 1. Extract the chargingAvailability ID from place.dataSources
+     * 2. Call the EV Charging Stations Availability service
+     * 3. Merge the result into this property
+     */
+    availability?: ChargingStationsAvailability;
+};
+
+/**
+ * Payment option configuration for a charging station.
+ *
+ * Describes a specific payment method and associated payment brands/networks
+ * accepted at a charging location.
+ *
+ * @remarks
+ * The `brands` array may include specific payment network names or provider brands
+ * that are accepted when using the specified payment method.
+ *
+ * @example
+ * ```typescript
+ * // Credit card payment with specific brands
+ * const paymentOption: ChargingPaymentOption = {
+ *   method: 'Direct',
+ *   brands: ['Visa', 'Mastercard', 'American Express']
+ * };
+ *
+ * // Subscription-based payment
+ * const subscriptionOption: ChargingPaymentOption = {
+ *   method: 'Subscription',
+ *   brands: ['ChargePoint', 'EVgo']
+ * };
+ * ```
+ *
+ * @group Route
+ */
+export declare type ChargingPaymentOption = {
+    /**
+     * The payment method type accepted at this charging station.
+     */
+    method: PaymentMethod;
+    /**
+     * Optional list of specific payment brands or networks accepted.
+     *
+     * Examples: credit card brands (Visa, Mastercard), charging networks
+     * (ChargePoint, EVgo), or payment apps (Apple Pay, Google Pay).
+     */
+    brands?: string[];
+};
+
+/**
+ * Individual charging point (EVSE - Electric Vehicle Supply Equipment).
+ *
+ * Represents a single charging unit with one or more connectors.
+ *
+ * @remarks
+ * A charging station typically contains multiple charging points.
+ * Each charging point can have multiple connectors of different types.
+ *
+ * @example
+ * ```typescript
+ * const chargingPoint: ChargingPoint = {
+ *   evseId: 'EVSE-001',
+ *   status: 'Available',
+ *   capabilities: ['CreditCardPayable', 'RemoteStartStopCapable', 'PlugAndCharge'],
+ *   restrictions: ['EvOnly'],
+ *   connectors: [
+ *     { id: 'conn-1', type: 'IEC62196Type2CCS', ratedPowerKW: 150, ... }
+ *   ]
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type ChargingPoint = {
+    /**
+     * Unique identifier for this charging point (EVSE ID).
+     *
+     * Often follows international standards like ISO 15118.
+     */
+    evseId: string;
+    /**
+     * Capabilities and features of this charging point.
+     *
+     * Indicates payment options, remote control, and advanced features.
+     */
+    capabilities: ChargingPointCapability[];
+    /**
+     * Usage or parking restrictions for this charging point.
+     *
+     * Specifies who can use the charger or special parking rules.
+     */
+    restrictions: ChargingPointRestriction[];
+    /**
+     * Real-time operational status of this charging point.
+     *
+     * Indicates if the charger is available, occupied, or out of service.
+     */
+    status: ChargingPointStatus;
+    /**
+     * Physical connectors available at this charging point.
+     *
+     * Each connector represents a different plug type and charging capability.
+     */
+    connectors?: Connector[];
+};
+
+/**
+ * Aggregated availability count for charging points or connectors.
+ *
+ * Provides a summary of how many units are in each operational status.
+ *
+ * @example
+ * ```typescript
+ * const availability: ChargingPointAvailability = {
+ *   count: 10,  // Total of 10 charging points
+ *   statusCounts: {
+ *     Available: 6,
+ *     Occupied: 3,
+ *     OutOfService: 1
+ *   }
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type ChargingPointAvailability = {
+    /**
+     * Total number of charging points or connectors.
+     *
+     * Depends on context:
+     * - For ChargingPointAvailability: total number of charging points
+     * - For ConnectorAvailability: total number of connectors of this type
+     */
+    count: number;
+    /**
+     * Breakdown of units by operational status.
+     *
+     * Maps each status to the number of units in that status.
+     * Only includes statuses that have at least one unit.
+     *
+     * @example
+     * ```typescript
+     * statusCounts: {
+     *   Available: 5,
+     *   Occupied: 2,
+     *   OutOfService: 1
+     * }
+     * ```
+     */
+    statusCounts: Partial<Record<ChargingPointStatus, number>>;
+};
+
+/**
+ * Possible capabilities for a charging point.
+ * @group Place
+ */
+export declare const chargingPointCapabilities: readonly ["ChargingProfileCapable", "ChargingPreferencesCapable", "ChipCardSupport", "ContactlessCardSupport", "CreditCardPayable", "DebitCardPayable", "PedTerminal", "RemoteStartStopCapable", "Reservable", "RfidReader", "StartSessionConnectorRequired", "TokenGroupCapable", "UnlockCapable", "PlugAndCharge", "Unknown"];
+
+/**
+ * Capability of a charging point.
+ *
+ * Describes features and payment options available at the charging point.
+ *
+ * @remarks
+ * - `ChargingProfileCapable`: Supports custom charging profiles
+ * - `ChargingPreferencesCapable`: Supports charging preferences
+ * - `ChipCardSupport`: Payment terminal accepts chip cards
+ * - `ContactlessCardSupport`: Payment terminal accepts contactless cards
+ * - `CreditCardPayable`: Accepts credit card payments
+ * - `DebitCardPayable`: Accepts debit card payments
+ * - `PedTerminal`: Has PIN entry device for payments
+ * - `RemoteStartStopCapable`: Can be started/stopped remotely
+ * - `Reservable`: Supports reservations
+ * - `RfidReader`: Supports RFID token authorization
+ * - `StartSessionConnectorRequired`: Requires connector ID to start session
+ * - `TokenGroupCapable`: Supports token groups for start/stop with different tokens
+ * - `UnlockCapable`: Connector can be remotely unlocked
+ * - `PlugAndCharge`: Supports ISO 15118 Plug & Charge (automatic authentication)
+ * - `Unknown`: Capability not specified
+ *
+ * @example
+ * ```typescript
+ * // Check for specific capabilities
+ * const capabilities: ChargingPointCapability[] = [
+ *   'CreditCardPayable',
+ *   'Reservable',
+ *   'RemoteStartStopCapable'
+ * ];
+ * ```
+ *
+ * @group Place
+ */
+export declare type ChargingPointCapability = (typeof chargingPointCapabilities)[number];
+
+/**
+ * Parking or usage restrictions for a charging point.
+ *
+ * Indicates special requirements or limitations for using the charging location.
+ *
+ * @remarks
+ * - `EvOnly`: Reserved parking spot for electric vehicles only
+ * - `Plugged`: Parking allowed only while actively charging
+ * - `Disabled`: Reserved for disabled persons with valid identification
+ * - `Customers`: For customers/guests only (e.g., hotel, shop)
+ * - `Motorcycles`: Suitable only for electric motorcycles or scooters
+ *
+ * @example
+ * ```typescript
+ * const restrictions: ChargingPointRestriction[] = ['EvOnly', 'Customers'];
+ * ```
+ *
+ * @group Place
+ */
+export declare type ChargingPointRestriction = (typeof chargingPointRestrictions)[number];
+
+/**
+ * @group Place
+ */
+export declare const chargingPointRestrictions: readonly ["EvOnly", "Plugged", "Disabled", "Customers", "Motorcycles"];
+
+/**
+ * Real-time operational status of a charging point.
+ *
+ * @remarks
+ * - `Available`: Ready for use, not currently occupied
+ * - `Reserved`: Reserved by another user
+ * - `Occupied`: Currently in use
+ * - `OutOfService`: Not operational (maintenance or malfunction)
+ * - `Unknown`: Status information unavailable
+ *
+ * @example
+ * ```typescript
+ * const status: ChargingPointStatus = 'Available';
+ * ```
+ *
+ * @group Place
+ */
+export declare type ChargingPointStatus = (typeof chargingPointStatus)[number];
+
+/**
+ * @group Place
+ */
+export declare const chargingPointStatus: readonly ["Available", "Reserved", "Occupied", "OutOfService", "Unknown"];
+
+/**
+ * @group Route
+ */
+export declare type ChargingSpeed = 'slow' | 'regular' | 'fast' | 'ultra-fast';
+
+/**
+ * Electric vehicle charging station.
+ *
+ * Represents a complete charging station facility with one or more charging points.
+ * A station is typically at a single location but may have multiple charging units.
+ *
+ * @example
+ * ```typescript
+ * const station: ChargingStation = {
+ *   id: 'station-123',
+ *   chargingPoints: [
+ *     { evseId: 'EVSE-001', status: 'Available', ... },
+ *     { evseId: 'EVSE-002', status: 'Occupied', ... }
+ *   ]
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type ChargingStation = {
+    /**
+     * Unique identifier for the charging station.
+     */
+    id: string;
+    /**
+     * Array of charging points available at this station.
+     *
+     * Each charging point can serve one vehicle at a time.
+     */
+    chargingPoints: ChargingPoint[];
+};
+
+/**
+ * @group Place
+ */
+export declare const chargingStationAccessTypes: readonly ["Public", "Authorized", "Restricted", "Private", "Unknown"];
+
+/**
+ * Access type for EV charging stations.
+ *
+ * Indicates who can use the charging station.
+ *
+ * @remarks
+ * - `Public`: Open to all electric vehicle drivers
+ * - `Authorized`: Requires membership, subscription, or authorization
+ * - `Restricted`: Limited access (e.g., hotel guests, employees only)
+ * - `Private`: Private use only, not available to public
+ * - `Unknown`: Access type not specified
+ *
+ * @example
+ * ```typescript
+ * const accessType: ChargingStationsAccessType = 'Public';
+ * ```
+ *
+ * @group Place
+ */
+export declare type ChargingStationsAccessType = (typeof chargingStationAccessTypes)[number];
+
+/**
+ * Real-time availability information for EV charging stations.
+ *
+ * Provides comprehensive status information including individual charging points,
+ * aggregated availability by connector type, and access information.
+ *
+ * @remarks
+ * This data is typically retrieved from the EV Charging Stations Availability service
+ * and provides real-time operational status. Use this to:
+ * - Display available charging points on a map
+ * - Filter by connector type and status
+ * - Show aggregated availability statistics
+ * - Check if a station is accessible and open
+ *
+ * @example
+ * ```typescript
+ * const availability: ChargingStationsAvailability = {
+ *   id: 'charging-park-123',
+ *   chargingStations: [...],  // Individual stations with detailed status
+ *   chargingPointAvailability: {
+ *     count: 10,
+ *     statusCounts: { Available: 7, Occupied: 3 }
+ *   },
+ *   connectorAvailabilities: [
+ *     { connector: { type: 'IEC62196Type2CCS', ratedPowerKW: 150, ... }, count: 4, ... },
+ *     { connector: { type: 'Chademo', ratedPowerKW: 50, ... }, count: 2, ... }
+ *   ],
+ *   accessType: 'Public',
+ *   openingHours: { mode: 'nextSevenDays', ... }
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type ChargingStationsAvailability = {
+    /**
+     * Unique identifier for the charging park or facility.
+     *
+     * Matches the ID used to request availability information.
+     */
+    id: string;
+    /**
+     * Array of charging stations with detailed point-level status.
+     *
+     * Each station contains individual charging points with real-time status,
+     * capabilities, and connector information. Use this for detailed views
+     * showing the status of each charging point.
+     */
+    chargingStations: ChargingStation[];
+    /**
+     * Aggregated availability counts across all charging points.
+     *
+     * Provides a quick summary of total charging points and their statuses.
+     * Useful for displaying overall availability without iterating through
+     * individual stations and points.
+     *
+     * @example
+     * ```typescript
+     * // Display: "7 of 10 chargers available"
+     * const total = chargingPointAvailability.count;
+     * const available = chargingPointAvailability.statusCounts.Available || 0;
+     * ```
+     */
+    chargingPointAvailability: ChargingPointAvailability;
+    /**
+     * Availability grouped by connector type and power level.
+     *
+     * Useful for displaying connector-specific availability, allowing users
+     * to quickly see if their required connector type is available.
+     *
+     * @example
+     * ```typescript
+     * // Find availability for CCS Type 2 connectors
+     * const ccsAvailability = connectorAvailabilities.find(
+     *   ca => ca.connector.type === 'IEC62196Type2CCS'
+     * );
+     * ```
+     */
+    connectorAvailabilities: ConnectorAvailability[];
+    /**
+     * Access level for these charging stations.
+     *
+     * Indicates if stations are public, require authorization, or have restrictions.
+     */
+    accessType: ChargingStationsAccessType;
+    /**
+     * Operating hours for the charging facility.
+     *
+     * Indicates when the charging park is accessible. Note that even if chargers
+     * are available 24/7, the facility itself may have restricted access hours.
+     */
+    openingHours?: OpeningHours;
+};
+
+/**
+ * Information about a battery charging stop along an electric vehicle route.
+ *
+ * A GeoJSON Feature representing a charging location where an EV needs to stop
+ * and recharge during a long-distance journey (LDEVR - Long Distance EV Routing).
+ *
+ * @remarks
+ * **Structure:**
+ * - Extends {@link Place} (GeoJSON Feature with Point geometry)
+ * - Includes all {@link CommonPlaceProps} (type, address, poi, chargingPark, etc.)
+ * - Adds charging-specific properties from {@link ChargingStopProps}
+ *
+ * **When Provided:**
+ * - For EV routes where charging is needed to reach the destination
+ * - At the end of route legs where battery charge is insufficient for the next leg
+ * - Contains both required and optional charging stop details
+ *
+ * **Key Properties:**
+ * - `id`: Unique string identifier for this feature, corresponds to charging park ID.
+ * - `type`: Always 'Feature' (GeoJSON)
+ * - `geometry`: Point geometry with charging park coordinates [longitude, latitude]
+ * - `properties`: Combined common place properties and charging-specific details
+ *   - Standard place info: `type`, `address`, `poi`, `chargingPark`
+ *   - Charging details: `chargingParkId`, `chargingParkUuid`, `chargingConnections`
+ *   - Route planning: `chargingTimeInSeconds`, `targetChargeInkWh`, `targetChargeInPCT`
+ *   - Metadata: `chargingParkName`, `chargingParkOperatorName`, `chargingParkPowerInkW`
+ *
+ * @example
+ * ```typescript
+ * const chargingStop: ChargingStop = {
+ *   id: 'charging-stop-1',
+ *   type: 'Feature',
+ *   geometry: {
+ *     type: 'Point',
+ *     coordinates: [4.8945, 52.3667]
+ *   },
+ *   properties: {
+ *     // CommonPlaceProps
+ *     type: 'POI',
+ *     address: {
+ *       freeformAddress: 'Amsterdam Central Station',
+ *       municipality: 'Amsterdam',
+ *       country: 'Netherlands'
+ *     },
+ *     // ChargingStopProps
+ *     chargingParkId: 'park123',
+ *     chargingParkUuid: 'uuid-123-456',
+ *     chargingParkName: 'Amsterdam Central Station - North Side',
+ *     chargingParkOperatorName: 'Ionity',
+ *     chargingConnections: [{
+ *       plugType: 'IEC_62196_Type_2_Connector_Cable_Attached',
+ *       chargingPowerInkW: 150,
+ *       currentType: 'DC'
+ *     }],
+ *     chargingTimeInSeconds: 1200,
+ *     chargingParkPowerInkW: 150,
+ *     chargingStopType: 'Auto_Generated',
+ *     targetChargeInkWh: 75,
+ *     targetChargeInPCT: 75
+ *   }
+ * };
+ * ```
+ *
+ * @group Route
+ */
+export declare type ChargingStop = Place<ChargingStopProps>;
+
+/**
+ * Properties specific to charging stops in electric vehicle routes.
+ *
+ * These properties are combined with {@link CommonPlaceProps} to form
+ * a complete {@link ChargingStop} object.
+ *
+ * @group Route
+ */
+export declare type ChargingStopProps = CommonPlaceProps & {
+    /**
+     * Unique identifier for the charging park.
+     */
+    chargingParkId: string;
+    /**
+     * Array of available charging connections at this park.
+     *
+     * Each connection specifies plug type, power ratings, and current type.
+     */
+    chargingConnections: ChargingConnectionInfo[];
+    /**
+     * Estimated time in seconds required to charge the battery at this stop.
+     *
+     * Calculated based on:
+     * - Current battery charge level
+     * - Target charge level for next leg
+     * - Charging power of the selected connector
+     * - Battery charging curve characteristics
+     */
+    chargingTimeInSeconds: number;
+    /**
+     * The unique UUID identifier of this charging park.
+     *
+     * This universally unique identifier can be used to:
+     * - Check real-time availability of charging stations
+     * - Query detailed charging park information
+     * - Track charging park status and updates
+     * - Cross-reference with TomTom EV Charging Stations API
+     *
+     * @remarks
+     * Use this UUID with the EV Charging Stations Availability API to get
+     * real-time connector availability before arriving at the charging stop.
+     *
+     * @example
+     * ```typescript
+     * // Use UUID to check availability
+     * const availability = await evChargingAvailability.get({
+     *   chargingAvailability: chargingStop.chargingParkUuid
+     * });
+     * ```
+     */
+    chargingParkUuid: string;
+    /**
+     * Detailed information about the recommended charging connection for this stop.
+     *
+     * Specifies which connector type, power level, and charging specifications
+     * should be used at this charging park for optimal charging.
+     *
+     * @remarks
+     * This is typically the best connector available that matches:
+     * - Vehicle's charging capabilities
+     * - Required charging speed for the journey
+     * - Availability at the charging park
+     */
+    chargingConnectionInfo?: ChargingConnectionInfo;
+    /**
+     * The common name of this charging park.
+     *
+     * A human-readable name for the charging location, often including nearby
+     * landmarks, business names, or descriptive identifiers.
+     *
+     * @example
+     * ```typescript
+     * chargingParkName: "Amsterdam Central Station - North Side"
+     * chargingParkName: "Shell Recharge - Highway A2"
+     * ```
+     */
+    chargingParkName?: string;
+    /**
+     * The charging network operator or provider name.
+     *
+     * Identifies the company or organization that operates this charging park.
+     *
+     * @remarks
+     * Common operators include: Shell Recharge, Ionity, ChargePoint, EVgo,
+     * Tesla Supercharger, Fastned, etc.
+     *
+     * @example
+     * ```typescript
+     * chargingParkOperatorName: "Ionity"
+     * chargingParkOperatorName: "Shell Recharge"
+     * ```
+     */
+    chargingParkOperatorName?: string;
+    /**
+     * Maximum available charging power at this charging park in kilowatts (kW).
+     *
+     * Represents the highest power output available across all charging connections
+     * at this location. Actual charging power may be lower depending on:
+     * - Vehicle capabilities
+     * - Selected connector type
+     * - Battery state of charge
+     * - Grid conditions
+     *
+     * @remarks
+     * This is typically the power of the fastest charger at the park.
+     *
+     * @example
+     * ```typescript
+     * // A charging park with multiple chargers
+     * chargingParkPowerInkW: 150 // Has at least one 150kW charger
+     * ```
+     */
+    chargingParkPowerInkW?: number;
+    /**
+     * The best charging speed classification of this charging park amongst its connectors.
+     *
+     * @remarks
+     * - `slow`: Typically up to 12 kW (Level 1 AC charging)
+     * - `regular`: Typically between 12 kW and 50 kW (Level 2 AC charging)
+     * - `fast`: Typically between 50 kW and 150 kW (DC fast charging)
+     * - `ultra-fast`: Typically above 150 kW (High-power DC fast charging)
+     */
+    chargingParkSpeed?: ChargingSpeed;
+    /**
+     * The source of the charging stop at the end of this leg.
+     *
+     * Indicates whether the charging stop was automatically calculated by the
+     * routing engine or explicitly specified by the user.
+     *
+     * @remarks
+     * - `Auto_Generated`: The routing engine selected this charging stop to optimize the route
+     * - `User_Defined`: The user explicitly requested a charging stop at this location
+     */
+    chargingStopType?: 'Auto_Generated' | 'User_Defined';
+    /**
+     * Available payment options at this charging park.
+     *
+     * Lists the payment methods accepted at this charging location.
+     * Multiple options may be available.
+     */
+    chargingParkPaymentOptions?: ChargingPaymentOption[];
+    /**
+     * Target battery charge level in kilowatt-hours (kWh) after charging.
+     *
+     * The routing engine determines the optimal charge level to minimize
+     * total journey time while ensuring the vehicle can reach the next stop.
+     */
+    targetChargeInkWh: number;
+    /**
+     * Target battery charge level as a percentage of maximum capacity.
+     *
+     * Derived from targetChargeInkWh and the vehicle's maximum battery capacity.
+     *
+     * @example
+     * ```typescript
+     * // If maxChargeInkWh is 100 and targetChargeInkWh is 80
+     * targetChargeInPCT // 80
+     * ```
+     */
+    targetChargeInPCT?: number;
+};
+
+/**
+ * POI category classification with localized names.
+ *
+ * Provides both a standardized category code and human-readable names
+ * in multiple languages for displaying POI types.
+ *
+ * @example
+ * ```typescript
+ * const classification: Classification = {
+ *   code: 'RESTAURANT',
+ *   names: [
+ *     { nameLocale: 'en-US', name: 'Restaurant' },
+ *     { nameLocale: 'fr-FR', name: 'Restaurant' },
+ *     { nameLocale: 'de-DE', name: 'Restaurant' }
+ *   ]
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type Classification = {
+    /**
+     * Standardized category code.
+     *
+     * Use this for programmatic filtering and identification of POI types.
+     * See {@link POICategory} for available codes.
+     */
+    code: POICategory;
+    /**
+     * Localized names for this category.
+     *
+     * Array of names in different languages/locales for internationalization support.
+     */
+    names: LocalizedName[];
+};
+
+/**
+ * Summary information for routes using combustion engine vehicles.
+ *
+ * Extends the base summary with fuel consumption estimates.
+ *
+ * @group Route
+ */
+export declare type CombustionSummary = SummaryBase & {
+    /**
+     * Estimated fuel consumption in liters for the route or leg.
+     *
+     * Calculated using the Combustion Consumption Model based on:
+     * - Vehicle speed-to-consumption rates
+     * - Route characteristics (elevation, road types)
+     * - Driving conditions
+     *
+     * @remarks
+     * Included only if:
+     * - Vehicle engine type is set to combustion
+     * - Speed-to-consumption rates are specified in the request
+     *
+     * The value is always positive (no fuel recuperation).
+     *
+     * @example
+     * ```typescript
+     * // A 100km route might consume
+     * fuelConsumptionInLiters: 7.5  // 7.5 liters
+     * ```
+     */
+    fuelConsumptionInLiters?: number;
+};
+
+/**
+ * Common properties shared by all place types.
+ *
+ * Provides the base structure for place information including address,
+ * entry points, POI details, and data source references.
+ *
+ * @group Place
+ */
+export declare type CommonPlaceProps = {
+    /**
+     * Type classification of this place.
+     */
+    type: PlaceType;
+    /**
+     * Structured address components.
+     */
+    address: AddressProperties;
+    /**
+     * Geographic entity type(s).
+     *
+     * Present only when type === 'Geography'.
+     * Array can contain multiple types for areas with multiple administrative roles.
+     */
+    geographyType?: GeographyType[];
+    /**
+     * Mapcode representations of this location.
+     *
+     * Alternative location codes that can be used instead of coordinates.
+     */
+    mapcodes?: Mapcode[];
+    /**
+     * Physical entry points (entrances) to the place.
+     *
+     * Useful for navigation to direct users to the correct entrance.
+     */
+    entryPoints?: EntryPoint[];
+    /**
+     * Address ranges along a street segment.
+     *
+     * Present only when type === 'Address Range'.
+     */
+    addressRanges?: AddressRanges;
+    /**
+     * Point of Interest information.
+     *
+     * Present only when type === 'POI'. Contains business details, categories, hours, etc.
+     */
+    poi?: POI;
+    /**
+     * Related Points of Interest.
+     *
+     * Parent or child POIs (e.g., stores within a mall, a mall containing stores).
+     */
+    relatedPois?: RelatedPOI[];
+    /**
+     * EV charging infrastructure information.
+     *
+     * Present only for Electric Vehicle charging station POIs.
+     */
+    chargingPark?: ChargingPark;
+    /**
+     * References to additional data sources.
+     *
+     * IDs for fetching more detailed information from other services
+     * (geometry, availability, POI details).
+     */
+    dataSources?: PlaceDataSources;
+};
+
+/**
+ * Electric vehicle charging connector with specifications.
+ *
+ * Describes a specific charging connector available at a charging point,
+ * including its technical specifications and capabilities.
+ *
+ * @example
+ * ```typescript
+ * const connector: Connector = {
+ *   id: 'connector-1',
+ *   type: 'IEC62196Type2CCS',
+ *   ratedPowerKW: 150,
+ *   voltageV: 400,
+ *   currentA: 375,
+ *   currentType: 'DC'
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type Connector = {
+    /**
+     * Unique identifier for this connector.
+     */
+    id: string;
+    /**
+     * Physical connector type/standard.
+     *
+     * Must match the vehicle's charging port for compatibility.
+     */
+    type: ConnectorType;
+    /**
+     * Rated charging power in kilowatts (kW).
+     *
+     * Indicates the maximum charging speed. Common values:
+     * - 3-7 kW: Level 1/2 AC charging
+     * - 7-22 kW: Level 2 AC charging
+     * - 50-150 kW: DC fast charging
+     * - 150-350 kW: DC ultra-fast charging
+     */
+    ratedPowerKW: number;
+    /**
+     * Voltage in volts (V).
+     *
+     * Operating voltage for this connector.
+     * Common values: 120V, 240V (AC), 400V, 800V (DC)
+     */
+    voltageV: number;
+    /**
+     * Current in amperes (A).
+     *
+     * Maximum current capacity for this connector.
+     */
+    currentA: number;
+    /**
+     * Type of electrical current (AC or DC).
+     */
+    currentType: CurrentType;
+};
+
+/**
+ * Availability information for a specific connector type.
+ *
+ * Extends ChargingPointAvailability with connector specifications,
+ * useful for displaying available connectors grouped by type and power.
+ *
+ * @example
+ * ```typescript
+ * const connectorAvailability: ConnectorAvailability = {
+ *   connector: {
+ *     type: 'IEC62196Type2CCS',
+ *     ratedPowerKW: 150,
+ *     // ... other connector properties
+ *   },
+ *   count: 4,
+ *   statusCounts: {
+ *     Available: 3,
+ *     Occupied: 1
+ *   }
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type ConnectorAvailability = ChargingPointAvailability & {
+    /**
+     * Connector specifications for this availability group.
+     *
+     * All connectors in this availability group share these specifications
+     * (same type, power rating, voltage, etc.).
+     */
+    connector: Connector;
+};
+
+/**
+ * Electric vehicle charging connector type.
+ *
+ * Defines the physical connector standard used for EV charging.
+ * Different regions and vehicle manufacturers use different connector types.
+ *
+ * @remarks
+ * Common connector types:
+ * - `IEC62196Type1`: SAE J1772 (North America, Japan)
+ * - `IEC62196Type2CableAttached`: Mennekes/Type 2 (Europe)
+ * - `IEC62196Type1CCS`: CCS Type 1 (Combined Charging System)
+ * - `IEC62196Type2CCS`: CCS Type 2 (Combined Charging System)
+ * - `Chademo`: CHAdeMO (Japan, DC fast charging)
+ * - `Tesla`: Tesla proprietary connector
+ * - `GBT20234Part2/3`: Chinese GB/T standard
+ *
+ * @example
+ * ```typescript
+ * const connectorType: ConnectorType = 'IEC62196Type2CCS';
+ * ```
+ *
+ * @group Place
+ */
+export declare type ConnectorType = (typeof connectorTypes)[number];
+
+/**
+ * @group Place
+ */
+export declare const connectorTypes: readonly ["StandardHouseholdCountrySpecific", "IEC62196Type1", "IEC62196Type1CCS", "IEC62196Type2CableAttached", "IEC62196Type2Outlet", "IEC62196Type2CCS", "IEC62196Type3", "Chademo", "GBT20234Part2", "GBT20234Part3", "IEC60309AC3PhaseRed", "IEC60309AC1PhaseBlue", "IEC60309DCWhite", "Tesla"];
+
+/**
+ * Route section representing passage through a country.
+ *
+ * Used to identify which countries the route traverses, useful for:
+ * - Border crossing planning
+ * - International routing costs
+ * - Regulatory requirements
+ *
+ * @example
+ * ```typescript
+ * const countrySection: CountrySectionProps = {
+ *   id: 'country-section-1',
+ *   startPointIndex: 0,
+ *   endPointIndex: 150,
+ *   countryCodeISO3: 'NLD',  // Netherlands
+ *   lengthInMeters: 25000
+ * };
+ * ```
+ *
+ * @group Route
+ */
+export declare type CountrySectionProps = SectionProps & {
+    /**
+     * Three-letter ISO 3166-1 alpha-3 country code.
+     *
+     * Examples: 'USA', 'GBR', 'NLD', 'DEU', 'FRA'
+     *
+     * @see [ISO 3166-1 alpha-3 codes](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-3)
+     */
+    countryCodeISO3: string;
+};
+
+/**
+ * Current type for electric vehicle charging.
+ *
+ * Specifies the type of electrical current used for charging.
+ *
+ * @remarks
+ * - `AC1`: Alternating Current, single-phase (slower charging, typically 3-7 kW)
+ * - `AC3`: Alternating Current, three-phase (faster AC charging, up to 22 kW)
+ * - `DC`: Direct Current (DC fast charging, 50-350+ kW)
+ *
+ * @example
+ * ```typescript
+ * const currentType: CurrentType = 'DC';  // DC fast charging
+ * ```
+ *
+ * @group Place
+ */
+export declare type CurrentType = (typeof currentTypes)[number];
+
+/**
+ * @group Place
+ */
+export declare const currentTypes: readonly ["AC1", "AC3", "DC"];
+
+/**
+ * Default global configuration values.
+ *
+ * Provides sensible defaults for the global configuration.
+ * The API key must be set before using SDK features.
+ *
+ * @group Configuration
+ */
+export declare const defaultConfig: GlobalConfig;
+
+/**
+ * Severity of the traffic delay.
+ *
+ * @remarks
+ * - `unknown`: Delay magnitude cannot be determined
+ * - `minor`: Small delay (few minutes)
+ * - `moderate`: Noticeable delay (several minutes to ~15 minutes)
+ * - `major`: Significant delay (15+ minutes)
+ * - `indefinite`: Unknown or extremely long delay (e.g., road closure)
+ *
+ * @group Route
+ */
+export declare type DelayMagnitude = 'unknown' | 'minor' | 'moderate' | 'major' | 'indefinite';
+
+/**
+ * Display unit configuration for time and distance.
+ *
+ * Used by formatting utilities and map information displays to present
+ * durations and distances with custom labels.
+ *
+ * @group Configuration
+ */
+export declare type DisplayUnits = {
+    /**
+     * Distance unit configuration.
+     *
+     * Controls how distances are displayed throughout the SDK.
+     */
+    distance?: DistanceDisplayUnits;
+    /**
+     * Time unit configuration.
+     *
+     * Controls how durations are displayed throughout the SDK.
+     */
+    time?: TimeDisplayUnits;
+};
+
+/**
+ * Configuration for displaying distance-based units.
+ *
+ * Allows customization of distance unit labels and the unit system
+ * (metric or imperial) used throughout the SDK.
+ *
+ * @group Configuration
+ */
+export declare type DistanceDisplayUnits = {
+    /**
+     * Type of distance unit system.
+     *
+     * Determines whether to use metric (meters, kilometers) or
+     * imperial (feet, miles, yards) units.
+     */
+    type?: DistanceUnitsType;
+    /**
+     * Custom label for kilometer units.
+     *
+     * @default "km"
+     */
+    kilometers?: string;
+    /**
+     * Custom label for meter units.
+     *
+     * @default "m"
+     */
+    meters?: string;
+    /**
+     * Custom label for mile units.
+     *
+     * @default "mi"
+     */
+    miles?: string;
+    /**
+     * Custom label for feet units.
+     *
+     * @default "ft"
+     */
+    feet?: string;
+    /**
+     * Custom label for yard units.
+     *
+     * @default "yd"
+     */
+    yards?: string;
+};
+
+/**
+ * Distance unit system types supported by the SDK formatters.
+ *
+ * Defines which measurement system to use when formatting distances.
+ * Each system uses region-appropriate units and conventions.
+ *
+ * @remarks
+ * **Unit Systems:**
+ *
+ * - `metric`: International System (SI)
+ *   - Units: meters (m), kilometers (km)
+ *   - Used in: Most of the world (Europe, Asia, Africa, South America, Australia)
+ *   - Decimal-based, no fractions
+ *
+ * - `imperial_us`: United States customary units
+ *   - Units: feet (ft), miles (mi)
+ *   - Used in: United States
+ *   - Uses fractions for miles (¼, ½, ¾)
+ *   - Feet for short distances (< 0.125 mi)
+ *
+ * - `imperial_uk`: United Kingdom imperial units
+ *   - Units: yards (yd), miles (mi)
+ *   - Used in: United Kingdom
+ *   - Uses fractions for miles (¼, ½, ¾)
+ *   - Yards for short distances (< 0.125 mi)
+ *
+ * **Differences:**
+ * - US uses feet for short distances
+ * - UK uses yards for short distances
+ * - Both use miles with fractions for medium/long distances
+ *
+ * @example
+ * ```typescript
+ * const system: DistanceUnitsType = 'metric';      // International
+ * const usSystem: DistanceUnitsType = 'imperial_us';  // United States
+ * const ukSystem: DistanceUnitsType = 'imperial_uk';  // United Kingdom
+ * ```
+ *
+ * @group Shared
+ */
+export declare type DistanceUnitsType = 'metric' | 'imperial_us' | 'imperial_uk';
+
+/**
+ * Indicates left-hand vs. right-hand side driving at the point of the maneuver.
+ * @group Route
+ */
+export declare type DrivingSide = 'LEFT' | 'RIGHT';
+
+/**
+ * Summary information for routes using electric vehicles.
+ *
+ * Extends the base summary with battery consumption and charge level estimates.
+ *
+ * @group Route
+ */
+export declare type ElectricSummary = SummaryBase & {
+    /**
+     * Estimated electric energy consumption in kilowatt-hours (kWh).
+     *
+     * Calculated using the Electric Consumption Model based on:
+     * - Vehicle speed-to-consumption rates
+     * - Route characteristics (elevation changes)
+     * - Recuperation (regenerative braking)
+     *
+     * @remarks
+     * Included only if:
+     * - Vehicle engine type is set to electric
+     * - Speed-to-consumption rates are specified in the request
+     *
+     * This value includes recuperated energy and can be negative (indicating net energy gain),
+     * such as when descending a long hill. If maxChargeInkWh is specified, recuperation is
+     * capped to prevent exceeding maximum battery capacity.
+     *
+     * @example
+     * ```typescript
+     * batteryConsumptionInkWh: 15.5    // Consumed 15.5 kWh
+     * batteryConsumptionInkWh: -2.3    // Gained 2.3 kWh (downhill with recuperation)
+     * ```
+     */
+    batteryConsumptionInkWh?: number;
+    /**
+     * Estimated battery consumption as a percentage of maximum capacity.
+     *
+     * Only present if maxChargeInkWh was specified in the request and
+     * batteryConsumptionInkWh is available.
+     *
+     * @example
+     * ```typescript
+     * // If maxChargeInkWh is 100 and batteryConsumptionInkWh is 15.5
+     * batteryConsumptionInPCT: 15.5  // 15.5% of battery capacity
+     * ```
+     */
+    batteryConsumptionInPCT?: number;
+    /**
+     * Estimated battery charge in kWh upon arrival at the destination.
+     *
+     * Available only for Long Distance EV Routing (LDEVR) with charging stops.
+     * Calculated as: currentChargeInkWh - batteryConsumptionInkWh + chargingEnergy
+     */
+    remainingChargeAtArrivalInkWh?: number;
+    /**
+     * Estimated battery charge as percentage of capacity upon arrival.
+     *
+     * Available only for Long Distance EV Routing (LDEVR) with charging stops.
+     * Derived from remainingChargeAtArrivalInkWh and maxChargeInkWh.
+     */
+    remainingChargeAtArrivalInPCT?: number;
+};
+
+/**
+ * Entry point (entrance) for a place.
+ *
+ * Represents a physical access point to a building or facility,
+ * useful for routing to ensure users are directed to the correct entrance.
+ *
+ * @example
+ * ```typescript
+ * const entryPoint: EntryPoint = {
+ *   type: 'main',
+ *   functions: ['FrontDoor'],
+ *   position: [4.9041, 52.3676]
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type EntryPoint = {
+    /**
+     * Type of entry point (main or minor).
+     */
+    type: EntryPointType;
+    /**
+     * Functional description of the entry point.
+     *
+     * Examples: 'FrontDoor', 'ServiceEntrance', 'ParkingGarage'
+     */
+    functions?: string[];
+    /**
+     * Geographic coordinates of the entry point [longitude, latitude].
+     */
+    position: Position;
+};
+
+/**
+ * Type of entry point for a place.
+ *
+ * @remarks
+ * - `main`: Primary entrance (at most one per place)
+ * - `minor`: Secondary or alternative entrance (can have multiple)
+ *
+ * @group Place
+ */
+export declare type EntryPointType = 'main' | 'minor';
+
+/**
+ * Properties for an EV charging station place.
+ *
+ * Extends common place properties with EV-specific charging park information.
+ * Use this type for places that are EV charging locations.
+ *
+ * @example
+ * ```typescript
+ * const evPlace: EVChargingStationPlaceProps = {
+ *   // Common place properties
+ *   id: 'place-123',
+ *   type: 'POI',
+ *   address: {...},
+ *   position: [4.9, 52.3],
+ *   // EV-specific properties
+ *   chargingPark: {
+ *     connectors: [...],
+ *     connectorCounts: [...],
+ *     availability: {...}
+ *   }
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type EVChargingStationPlaceProps = Omit<CommonPlaceProps, 'chargingPark'> & {
+    /**
+     * Charging infrastructure and availability information.
+     *
+     * Contains details about available connectors, counts, and optionally
+     * real-time availability status if fetched from the availability service.
+     */
+    chargingPark?: ChargingParkWithAvailability;
+};
+
+/**
+ * Extended GeoJSON FeatureCollection with additional properties at the collection level.
+ *
+ * This type extends the standard GeoJSON FeatureCollection by adding an optional `properties` field
+ * at the collection level (in addition to properties on individual features).
+ *
+ * @typeParam G - The geometry type for features in the collection (defaults to Geometry)
+ * @typeParam P - The type of properties for individual features (defaults to GeoJsonProperties)
+ * @typeParam FeatureCollectionProps - The type of properties for the collection itself (defaults to unknown)
+ *
+ * @example
+ * ```typescript
+ * // Collection of routes with summary properties at the collection level
+ * const routeCollection: FeatureCollectionWithProperties<LineString, RouteProps, { totalDistance: number }> = {
+ *   type: 'FeatureCollection',
+ *   features: [...],
+ *   properties: { totalDistance: 1000 }
+ * };
+ * ```
+ *
+ * @group Shared
+ */
+export declare interface FeatureCollectionWithProperties<G extends Geometry | null = Geometry, P = GeoJsonProperties, FeatureCollectionProps = unknown> extends FeatureCollection<G, P> {
+    /**
+     * Optional properties for the entire feature collection.
+     * This allows metadata to be attached at the collection level.
+     */
+    properties?: FeatureCollectionProps;
+}
+
+/**
+ * Formatting is based on the number of meters passed and unit type. Less meters more precision.
+ * @example
+ * ```ts
+ * (null, METRIC) -> ""
+ * (0, METRIC) -> "0 m"
+ * (2, METRIC) -> "2 m"
+ * (237, METRIC) -> "240 m"
+ * (730, METRIC) -> "700 m"
+ * (950, METRIC) -> "1 km"
+ * (-999, METRIC) -> "-1 km"
+ * (2850, METRIC) -> "2.9 km"
+ * (283520, METRIC) -> "284 km"
+ * (2, IMPERIAL_US) -> "7 ft"
+ * (100, IMPERIAL_US) -> "330 ft"
+ * (182.88, IMPERIAL_US) -> "600 ft"
+ * (205.95, IMPERIAL_US) -> "¼ mi"
+ * (1205.95, IMPERIAL_US) -> "¾ mi"
+ * (5309.7, IMPERIAL_US) -> "3½ mi"
+ * (-18181.7, IMPERIAL_US) -> "-11 mi"
+ * (2, IMPERIAL_UK) -> "2 yd"
+ * (150.88, IMPERIAL_UK) -> "170 yd"
+ * (4344.3, IMPERIAL_UK) -> "2¾ mi"
+ * (21753.68, IMPERIAL_UK) -> "14 mi"
+ * ```
+ * @param meters
+ * @param options Options for the display units, including their type and custom ways to display them.
+ * @group Shared
+ */
+export declare const formatDistance: (meters: number, options?: DistanceDisplayUnits) => string;
+
+/**
+ * Formats a duration in seconds into a human-readable time string.
+ *
+ * Converts raw seconds into a display-friendly format using hours and minutes,
+ * with intelligent rounding and formatting based on the duration length.
+ *
+ * @param seconds The duration to format, given in seconds. Returns `undefined` for values < 30 seconds.
+ * @param options Optional custom display units for hours and minutes text.
+ *
+ * @returns Formatted time string (e.g., "1 hr 30 min", "45 min"), or `undefined` if duration is too short.
+ *
+ * @remarks
+ * **Rounding Behavior:**
+ * - Durations under 30 seconds return `undefined`
+ * - 30-59 seconds round to "1 min"
+ * - Minutes are rounded to nearest minute
+ * - Hours are displayed when duration ≥ 1 hour
+ *
+ * **Format Patterns:**
+ * - Short duration: "15 min"
+ * - Long duration: "2 hr 30 min"
+ * - Exact hours: "3 hr 00 min"
+ *
+ * **Customization:**
+ * Override default units via `options` or global {@link TomTomConfig}
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * formatDuration(0);       // undefined (too short)
+ * formatDuration(20);      // undefined (too short)
+ * formatDuration(30);      // "1 min"
+ * formatDuration(60);      // "1 min"
+ * formatDuration(100);     // "2 min"
+ * formatDuration(1800);    // "30 min"
+ * formatDuration(3599);    // "1 hr 00 min"
+ * formatDuration(3660);    // "1 hr 01 min"
+ * formatDuration(7200);    // "2 hr 00 min"
+ * formatDuration(36120);   // "10 hr 02 min"
+ *
+ * // Custom units
+ * formatDuration(3660, { hours: 'h', minutes: 'm' });
+ * // Returns: "1 h 01 m"
+ *
+ * // Route travel time
+ * const route = await calculateRoute({ ... });
+ * const travelTime = formatDuration(route.routes[0].summary.travelTimeInSeconds);
+ * console.log(`Estimated time: ${travelTime}`);
+ * // Output: "Estimated time: 2 hr 15 min"
+ * ```
+ *
+ * @group Shared
+ */
+export declare const formatDuration: (seconds: number | undefined, options?: TimeDisplayUnits) => string | undefined;
+
+/**
+ * Fuel types available at gas stations and refueling points.
+ *
+ * Identifies the types of fuel offered at a location. Use this to find
+ * stations with specific fuel types or filter search results.
+ *
+ * @remarks
+ * Common fuel types:
+ * - `Petrol` / `Diesel`: Traditional fossil fuels
+ * - `E85`: 85% ethanol blend
+ * - `LPG`: Liquefied petroleum gas (propane)
+ * - `CNG`: Compressed natural gas
+ * - `LNG`: Liquefied natural gas
+ * - `Hydrogen`: Fuel cell hydrogen
+ * - `Biodiesel`: Renewable diesel
+ * - `AdBlue`: Diesel exhaust fluid (DEF)
+ *
+ * @example
+ * ```typescript
+ * // Station with multiple fuel types
+ * const fuels: Fuel[] = ['Petrol', 'Diesel', 'LPG'];
+ *
+ * // Hydrogen fuel cell station
+ * const fuels: Fuel[] = ['Hydrogen'];
+ * ```
+ *
+ * @group Place
+ */
+export declare type Fuel = 'Petrol' | 'LPG' | 'Diesel' | 'Biodiesel' | 'DieselForCommercialVehicles' | 'E85' | 'LNG' | 'CNG' | 'Hydrogen' | 'AdBlue';
+
+/**
+ * Generate random id for layers
+ * @ignore
+ */
+export declare const generateId: () => string;
+
+/**
+ * Generates an object with TomTom custom header values for the given common parameters.
+ *
+ * @ignore
+ * @param params Global SDK configuration
+ */
+export declare const generateTomTomHeaders: (params: Partial<GlobalConfig>) => TomTomHeaders;
+
+/**
+ * Type of geographic administrative entity.
+ *
+ * Defines the hierarchical level of an administrative area or postal region.
+ *
+ * @remarks
+ * Geographic hierarchy from largest to smallest:
+ * - `Country`: Sovereign nation
+ * - `CountrySubdivision`: State, province, or first-level admin division
+ * - `CountrySecondarySubdivision`: County or second-level admin division
+ * - `CountryTertiarySubdivision`: Third-level admin division
+ * - `Municipality`: City or town
+ * - `MunicipalitySubdivision`: District within a city
+ * - `Neighbourhood`: Named neighborhood or area within a city
+ * - `PostalCodeArea`: Area defined by postal/ZIP code
+ *
+ * @example
+ * ```typescript
+ * const geographyType: GeographyType = 'Municipality';  // City level
+ * ```
+ *
+ * @group Place
+ */
+export declare type GeographyType = (typeof geographyTypes)[number];
+
+/**
+ * @group Place
+ */
+export declare const geographyTypes: readonly ["Country", "CountrySubdivision", "CountrySecondarySubdivision", "CountryTertiarySubdivision", "Municipality", "MunicipalitySubdivision", "Neighbourhood", "PostalCodeArea"];
+
+/**
+ * Data source reference for geometric shape data.
+ *
+ * @example
+ * ```typescript
+ * // Use this ID with the Geometry Data service
+ * const dataSource: GeometryDataSource = {
+ *   id: 'geom-abc123'
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type GeometryDataSource = {
+    /**
+     * Geometry ID for the Geometry Data service.
+     *
+     * Pass this value to fetch the geometric boundary (polygon or multipolygon)
+     * representing the place's shape on the map.
+     */
+    id: string;
+};
+
+/**
+ * Extracts the lng-lat position from various input formats.
+ *
+ * This utility function accepts multiple formats and normalizes them to a standard
+ * GeoJSON Position (lng-lat coordinate array). It handles:
+ * - Raw coordinate arrays `[lng, lat]`
+ * - GeoJSON Point geometries
+ * - GeoJSON Point Features (including Places with entry points)
+ *
+ * @param hasLngLat An object which either is or contains a lng-lat position.
+ * @param options Additional options to control how we extract the position.
+ * @returns The extracted position as `[longitude, latitude]`, or `null` if the input is invalid.
+ *
+ * @example
+ * ```typescript
+ * // From coordinate array
+ * getPosition([4.9, 52.3]); // Returns: [4.9, 52.3]
+ *
+ * // From Point geometry
+ * getPosition({
+ *   type: 'Point',
+ *   coordinates: [4.9, 52.3]
+ * }); // Returns: [4.9, 52.3]
+ *
+ * // From Point Feature
+ * getPosition({
+ *   type: 'Feature',
+ *   geometry: { type: 'Point', coordinates: [4.9, 52.3] },
+ *   properties: {}
+ * }); // Returns: [4.9, 52.3]
+ *
+ * // From Place with entry point
+ * const place = {
+ *   type: 'Feature',
+ *   geometry: { type: 'Point', coordinates: [4.9, 52.3] },
+ *   properties: {
+ *     entryPoints: [
+ *       { type: 'main', position: [4.901, 52.301] }
+ *     ]
+ *   }
+ * };
+ * getPosition(place, { useEntryPoint: 'main-when-available' });
+ * // Returns: [4.901, 52.301] (entry point instead of geometry)
+ *
+ * // Invalid input
+ * getPosition(undefined); // Returns: null
+ * ```
+ *
+ * @group Shared
+ */
+export declare const getPosition: (hasLngLat: HasLngLat | undefined, options?: GetPositionOptions) => Position | null;
+
+/**
+ * Specifies how to handle entry points when extracting a position from a place.
+ *
+ * Entry points represent specific access locations for a place (e.g., building entrances, parking lot entries).
+ *
+ * @remarks
+ * - `main-when-available`: Returns the main entry point position if available, otherwise falls back to the default place position.
+ *   This is useful for routing to ensure vehicles are directed to the correct entrance.
+ * - `ignore`: Always returns the default position of the place (typically the center point).
+ *
+ * @example
+ * ```typescript
+ * // Get position preferring entry point for routing
+ * const position = getPosition(place, { useEntryPoint: 'main-when-available' });
+ *
+ * // Get center position ignoring entry points
+ * const centerPos = getPosition(place, { useEntryPoint: 'ignore' });
+ * ```
+ *
+ * @group Shared
+ */
+export declare type GetPositionEntryPointOption = 'main-when-available' | 'ignore';
+
+/**
+ * Configuration options for extracting position coordinates from a place.
+ *
+ * @group Shared
+ */
+export declare type GetPositionOptions = {
+    /**
+     * Controls whether to use entry point positions when available.
+     *
+     * When set to `'main-when-available'`, the main entry point coordinates will be returned
+     * if they exist, otherwise the default place position is used. This is particularly useful
+     * for routing applications where you want to direct users to the correct entrance.
+     *
+     * @default 'ignore'
+     *
+     * @example
+     * ```typescript
+     * // For routing to a specific entrance
+     * { useEntryPoint: 'main-when-available' }
+     *
+     * // For displaying place center on map
+     * { useEntryPoint: 'ignore' }
+     * ```
+     */
+    useEntryPoint?: GetPositionEntryPointOption;
+};
+
+/**
+ * Extracts the lng-lat position from various input formats (strict version).
+ *
+ * Similar to {@link getPosition}, but throws an error if the input doesn't contain
+ * a valid position. Use this when you expect the input to always be valid and want
+ * to fail fast on invalid data.
+ *
+ * @param hasLngLat An object which either is or contains a lng-lat position.
+ * @param options Additional options to control how we extract the position.
+ * @returns The extracted position as `[longitude, latitude]`.
+ * @throws Error if the input object is undefined or does not contain a lng-lat position.
+ *
+ * @example
+ * ```typescript
+ * // Valid input
+ * getPositionStrict([4.9, 52.3]); // Returns: [4.9, 52.3]
+ *
+ * // Invalid input throws error
+ * try {
+ *   getPositionStrict(undefined);
+ * } catch (error) {
+ *   console.error(error);
+ *   // Error: The received object does not have lng-lat coordinates: undefined
+ * }
+ *
+ * // Invalid object throws error
+ * try {
+ *   getPositionStrict({ invalid: 'object' });
+ * } catch (error) {
+ *   console.error(error);
+ *   // Error: The received object does not have lng-lat coordinates: {"invalid":"object"}
+ * }
+ * ```
+ *
+ * @group Shared
+ */
+export declare const getPositionStrict: (hasLngLat: HasLngLat, options?: GetPositionOptions) => Position;
+
+/**
+ * Determines the type of geographic input (waypoint or path).
+ *
+ * This function inspects the structure of a RoutePlanningLocation to classify it as either:
+ * - **waypoint**: A single point location (coordinate pair, Point geometry, or Point Feature)
+ * - **path**: A line or route (array of coordinates, LineString geometry, or LineString Feature)
+ *
+ * @param routePlanningLocation The geographic input to classify. Can be coordinates, GeoJSON geometry, or GeoJSON Feature.
+ * @returns The type of the input: 'waypoint' for point locations or 'path' for line geometries.
+ *
+ * @example
+ * ```typescript
+ * // Waypoint as coordinate array
+ * getRoutePlanningLocationType([4.9, 52.3]); // Returns: 'waypoint'
+ *
+ * // Path as array of coordinates
+ * getRoutePlanningLocationType([[4.9, 52.3], [4.5, 51.9]]); // Returns: 'path'
+ *
+ * // Waypoint as Point Feature
+ * getRoutePlanningLocationType({
+ *   type: 'Feature',
+ *   geometry: { type: 'Point', coordinates: [4.9, 52.3] },
+ *   properties: {}
+ * }); // Returns: 'waypoint'
+ *
+ * // Path as LineString Feature
+ * getRoutePlanningLocationType({
+ *   type: 'Feature',
+ *   geometry: { type: 'LineString', coordinates: [[4.9, 52.3], [4.5, 51.9]] },
+ *   properties: {}
+ * }); // Returns: 'path'
+ * ```
+ *
+ * @group Route
+ */
+export declare const getRoutePlanningLocationType: (routePlanningLocation: RoutePlanningLocation) => RoutePlanningLocationType;
+
+/**
+ * Global configuration for the TomTom Maps SDK.
+ *
+ * Contains essential parameters like API keys, language settings, and display preferences
+ * that apply across all SDK services and map functionality.
+ *
+ * @remarks
+ * This configuration can be set globally using {@link TomTomConfig} and will be merged
+ * with service-specific configurations, with service configs taking precedence.
+ *
+ * @example
+ * ```typescript
+ * const config: GlobalConfig = {
+ *   apiKey: 'your-api-key',
+ *   apiVersion: 1,
+ *   commonBaseURL: 'https://api.tomtom.com',
+ *   language: 'en-US',
+ *   displayUnits: {
+ *     distance: { type: 'metric' },
+ *     time: { hours: 'hrs', minutes: 'mins' }
+ *   }
+ * };
+ * ```
+ *
+ * @group Configuration
+ */
+export declare type GlobalConfig = {
+    /**
+     * TomTom API key for authentication.
+     *
+     * Required for all SDK features. Obtain an API key from the
+     * [TomTom Developer Portal](https://developer.tomtom.com/).
+     *
+     * @default None (required)
+     */
+    apiKey: string;
+    /**
+     * An experimental alternative to the API Key which enables oauth2 access to APIs.
+     * * If provided, then the API key parameter will be ignored.
+     * @experimental
+     */
+    /**
+     * API version number for service endpoints.
+     *
+     * Each service may have its own default version. Consult the specific
+     * service documentation for available versions.
+     *
+     * @default 1 (but each service can override)
+     */
+    apiVersion: number;
+    /**
+     * Request identifier for tracing and support.
+     *
+     * Must match the pattern: `^[a-zA-Z0-9-]{1,100}$`
+     *
+     * Recommended format is UUID (e.g., `9ac68072-c7a4-11e8-a8d5-f2801f1b9fd1`).
+     * When specified, it's included in the `Tracking-ID` response header.
+     * This is solely for support purposes and does not involve user tracking.
+     *
+     * @see {@link https://docs.tomtom.com/search-api/documentation/search-service/fuzzy-search#trackingid-response | Tracking-ID documentation}
+     */
+    trackingId?: string;
+    /**
+     * Include TomTom-User-Agent header in requests.
+     *
+     * When enabled, adds a header containing the SDK name and version.
+     * Note that enabling this may trigger CORS preflight requests.
+     *
+     * @default false
+     */
+    tomtomUserAgent?: boolean;
+    /**
+     * Language code for SDK services and map content.
+     *
+     * Accepts IETF language codes (case-insensitive). Affects search results,
+     * routing instructions, and map labels.
+     *
+     * @default "NGT" (Neutral Ground Truth - uses local language for each location)
+     *
+     * @see {@link https://docs.tomtom.com/search-api/documentation/product-information/supported-languages | Search supported languages}
+     * @see {@link https://docs.tomtom.com/routing-api/documentation/product-information/supported-languages | Routing supported languages}
+     */
+    language?: Language;
+    /**
+     * Base URL for all TomTom API services.
+     *
+     * Individual services can override this with their own base URLs.
+     * Typically only changed for testing or enterprise deployments.
+     *
+     * @default "https://api.tomtom.com"
+     */
+    commonBaseURL: string;
+    /**
+     * Custom display units for time and distance.
+     *
+     * Applied to {@link formatDistance} and {@link formatDuration} utilities,
+     * which are used throughout the SDK for displaying map information.
+     * If not provided, default unit labels are used.
+     */
+    displayUnits?: DisplayUnits;
+};
+
+/**
+ * Contains guidance related elements. This field is present only when guidance was requested and is available.
+ * @group Route
+ */
+export declare type Guidance = {
+    /**
+     * Main ordered list of instructions to follow.
+     */
+    instructions: Instruction[];
+};
+
+/**
+ * Input type representing a geographic bounding box or an object from which a bounding box can be derived.
+ *
+ * Accepts various formats:
+ * - `BBox`: Direct GeoJSON bounding box array `[west, south, east, north]`
+ * - `GeoJsonObject`: Any GeoJSON object with a `bbox` property or from which bounds can be calculated
+ * - `GeoJsonObject[]`: Array of GeoJSON objects (convenience extension to standard GeoJSON)
+ *
+ * @remarks
+ * Bounding boxes follow the format: `[minLon, minLat, maxLon, maxLat]` or `[west, south, east, north]`
+ *
+ * @example
+ * ```typescript
+ * // Direct BBox array
+ * const bbox1: HasBBox = [4.8, 52.3, 5.0, 52.4];
+ *
+ * // Feature with bbox property
+ * const bbox2: HasBBox = {
+ *   type: 'Feature',
+ *   bbox: [4.8, 52.3, 5.0, 52.4],
+ *   geometry: { type: 'Polygon', coordinates: [...] },
+ *   properties: {}
+ * };
+ *
+ * // Array of features to derive bounds from
+ * const bbox3: HasBBox = [feature1, feature2, feature3];
+ * ```
+ *
+ * @group Shared
+ */
+export declare type HasBBox = BBox | GeoJsonObject | GeoJsonObject[];
+
+/**
+ * Input type representing a geographic point location.
+ *
+ * Accepts various formats for specifying a point location:
+ * - `Position`: Raw coordinate array `[longitude, latitude]`
+ * - `Point`: GeoJSON Point geometry
+ * - `Feature<Point>`: GeoJSON Feature containing a Point geometry
+ *
+ * @remarks
+ * Note: Coordinates follow GeoJSON standard with longitude first, then latitude: `[lng, lat]`
+ *
+ * @example
+ * ```typescript
+ * // As Position array
+ * const pos1: HasLngLat = [4.9041, 52.3676];
+ *
+ * // As Point geometry
+ * const pos2: HasLngLat = { type: 'Point', coordinates: [4.9041, 52.3676] };
+ *
+ * // As Feature
+ * const pos3: HasLngLat = {
+ *   type: 'Feature',
+ *   geometry: { type: 'Point', coordinates: [4.9041, 52.3676] },
+ *   properties: {}
+ * };
+ * ```
+ *
+ * @group Shared
+ */
+export declare type HasLngLat = Position | Point | Feature<Point>;
+
+/**
+ * Sections with important stretches of road information.
+ *
+ * * It provides a set of street names and/or a set of road numbers that allow the driver to identify and distinguish the course of the route (from other potential routes).
+ *
+ * @group Route
+ */
+export declare type ImportantRoadStretchProps = SectionProps & {
+    /**
+     * The integer value of importance. The index starts from 0, and a lower value means higher importance. The index is needed for two reasons:
+     * * To understand which stretch is the most important (for example, if it is necessary to display a smaller number of stretches).
+     * * To group different sections that belong to the same stretch (since there may be gaps in one stretch for various reasons).
+     */
+    index: number;
+    /**
+     * The street name of the important road stretch.
+     */
+    streetName?: string;
+    /**
+     * A set of road numbers that identify the important road stretch.
+     *
+     * @remarks
+     * The road numbers are sorted in descending order of display priority.
+     */
+    roadNumbers?: string[];
+};
+
+/**
+ * @ignore
+ */
+export declare const indexedMagnitudes: DelayMagnitude[];
+
+/**
+ * Route calculation request section types so they can be included in response.
+ * @group Route
+ */
+export declare const inputSectionTypes: SectionType[];
+
+/**
+ * Route calculation request section types, including guidance-related ones, so they can be included in response.
+ * @group Route
+ */
+export declare const inputSectionTypesWithGuidance: SectionType[];
+
+/**
+ * A set of attributes describing a maneuver, e.g., "Turn right", "Keep left", "Take the ferry", "Take the motorway", "Arrive".
+ * @group Route
+ */
+export declare type Instruction = {
+    /**
+     * The index of the point on the route path where the maneuver takes place.
+     * * maneuverPoint is expected to be equal to the path point at this index.
+     */
+    pathPointIndex: number;
+    /**
+     * Location of the maneuver.
+     */
+    maneuverPoint: Position;
+    /**
+     * The distance from the start of the route to the point of the instruction.
+     */
+    routeOffsetInMeters: number;
+    /**
+     * A code identifying the maneuver (e.g., "Turn right").
+     */
+    maneuver: Maneuver;
+    /**
+     * A maneuver can occupy more than one point. For such a maneuver, this field will contain a sequence of all the points it occupies on the map.
+     * For maneuvers that only occupy a single point, this field will contain a single array item, with a point value equal to maneuverPoint.
+     */
+    routePath: RoutePathPoint[];
+    /**
+     * Provides information about the road in the link before the maneuver.
+     */
+    previousRoadInfo: RoadInformation;
+    /**
+     * Provides information about the road we are heading to (past the maneuver).
+     * The source of this information is either the road past the maneuver or the signpost at the maneuver if such exists.
+     */
+    nextRoadInfo: RoadInformation;
+    /**
+     * Included if a signpost is available for this maneuver.
+     * Provides the information displayed in the signpost indicating the direction on route.
+     */
+    signpost?: Signpost;
+    /**
+     * Name of the intersection at which the maneuver must be performed.
+     * Included if intersection name is available for this maneuver.
+     */
+    intersectionName?: TextWithPhonetics;
+    /**
+     * Indicates left-hand vs. right-hand side driving at the point of the maneuver.
+     */
+    drivingSide?: DrivingSide;
+    /**
+     * Included if instruction has a landmark.
+     */
+    landmark?: Landmark;
+    /**
+     * Included if the landmark is AT_TRAFFIC_LIGHT, and a maneuver takes place at the second traffic light (out of two consequent traffic lights).
+     * In such case this attribute represents the distance on the route (in meters) between those traffic lights.
+     */
+    trafficLightOffsetInMeters?: number;
+    /**
+     * List of roads connected to the route but not part of it, right before the maneuver.
+     * These are roads which the driver can accidentally take based on the instruction without considering the dynamic restriction of the route like time or vehicle profile dependent restriction.
+     * Dual-carriageway roads might be represented as a single or several side roads, depending on how the driver might perceive them.
+     * The list will be empty if no road is crossing the route before the maneuver.
+     * This information can be used to allow a richer graphical presentation of the maneuver and visualize connected roads preceding it in proximity.
+     * The list is ordered in ascending order of offset on route.
+     * Included if there are side roads within a reasonable distance before the maneuver.
+     */
+    sideRoads?: SideRoad[];
+    /**
+     * The base URL of the Road Shields service to fetch the road shield atlas and metadata resources.
+     * Currently available resources are:
+     * sprite.png
+     * sprite.json
+     * We recommend to cache the sprite atlas (sprite.png) and metadata (sprite.json) as it changes infrequently and is large compared to a typical road shield description.
+     */
+    roadShieldAtlasReference?: string;
+    /**
+     * List of road shield references to be shown for the instruction.
+     */
+    roadShieldReferences?: RoadShieldReference[];
+    /**
+     * List of road shield references to be shown for the signpost.
+     */
+    signpostRoadShieldReferences?: RoadShieldReference[];
+    /**
+     * Marks this maneuver as obligatory. For example, when a driver reaches a T-junction, where one option is drivable, while the other is not.
+     * Included if the maneuver is a turn maneuver, i.e., maneuver is one of the following:
+     * SLIGHT_RIGHT
+     * TURN_RIGHT
+     * SHARP_RIGHT
+     * SLIGHT_LEFT
+     * TURN_LEFT
+     * SHARP_LEFT
+     * MAKE_UTURN
+     */
+    isManeuverObligatory?: boolean;
+    /**
+     * Gives the total change of angle (in degrees) from the entry until the exit of the maneuver, in the range [-180,180). For example, -90 means "forks off to the left in a perpendicular angle".
+     * At complex junctions, the angle is relative to the entry road.
+     * Included if the maneuver is a turn or roundabout maneuver, i.e., maneuver is one of the following:
+     * STRAIGHT
+     * SLIGHT_RIGHT
+     * TURN_RIGHT
+     * SHARP_RIGHT
+     * SLIGHT_LEFT
+     * TURN_LEFT
+     * SHARP_LEFT
+     * MAKE_UTURN
+     * ROUNDABOUT_STRAIGHT
+     * ROUNDABOUT_SLIGHT_RIGHT
+     * ROUNDABOUT_RIGHT
+     * ROUNDABOUT_SHARP_RIGHT
+     * ROUNDABOUT_SLIGHT_LEFT
+     * ROUNDABOUT_LEFT
+     * ROUNDABOUT_SHARP_LEFT
+     * ROUNDABOUT_BACK
+     */
+    changeOfAngleInDegrees?: number;
+    /**
+     * Included if current maneuver is an exit, and there is another exit before the current maneuver within reasonable distance, which may cause ambiguity.
+     * In such case there might be a need to resolve the ambiguity on client side, and compose an instruction like "Take the 2nd exit".
+     * Represents the offset (on route) of the ambiguous exit from the maneuver point (represented by maneuverPoint), in meters.
+     * The offset is absolute, i.e., it is a positive integer despite the ambiguous exit being located before the maneuver on the route.
+     * Applicable for maneuvers where maneuver is one of the following values:
+     * EXIT_ROUNDABOUT
+     * EXIT_MOTORWAY_LEFT
+     * EXIT_MOTORWAY_RIGHT
+     * SWITCH_MOTORWAY_LEFT
+     * SWITCH_MOTORWAY_RIGHT
+     */
+    offsetOfAmbiguousExitFromManeuverInMeters?: number;
+    /**
+     * The ordinal number of the exit to take at a roundabout, e.g., "take the first/second exit".
+     * Included if the maneuver is a roundabout maneuver, i.e., maneuver is one of the following:
+     * ROUNDABOUT_STRAIGHT
+     * ROUNDABOUT_SLIGHT_RIGHT
+     * ROUNDABOUT_RIGHT
+     * ROUNDABOUT_SHARP_RIGHT
+     * ROUNDABOUT_SLIGHT_LEFT
+     * ROUNDABOUT_LEFT
+     * ROUNDABOUT_SHARP_LEFT
+     * ROUNDABOUT_BACK
+     */
+    roundaboutExitNumber?: number;
+    /**
+     * The name of the tollgate, if available.
+     * Included if the maneuver is a tollgate maneuver, i.e., maneuver is TOLLGATE.
+     */
+    tollgateName?: TextWithPhonetics;
+    /**
+     * Included if the maneuver is a tollgate maneuver, i.e., maneuver is TOLLGATE.
+     * Array containing one or more available toll payment options for this tollgate.
+     */
+    tollPaymentTypes?: TollPaymentType[];
+    /**
+     * The name of the country the border crossing occurs from.
+     * Included if the maneuver is a border crossing maneuver, or leads to a border crossing, i.e., maneuver is one of:
+     * CROSS_BORDER
+     * TAKE_SHIP_FERRY
+     * TAKE_CAR_TRAIN
+     * LEAVE_SHIP_FERRY
+     * LEAVE_CAR_TRAIN
+     */
+    countryCrossingFromName?: TextWithPhonetics;
+    /**
+     * The code (ISO 3166-1 alpha-3) of the country the border crossing occurs from.
+     * Included if the maneuver is a border crossing maneuver, i.e., maneuver is one of:
+     * CROSS_BORDER
+     * TAKE_SHIP_FERRY
+     * TAKE_CAR_TRAIN
+     * LEAVE_SHIP_FERRY
+     * LEAVE_CAR_TRAIN
+     */
+    countryCrossingFromCode?: string;
+    /**
+     * The name of the country the border crossing occurs to.
+     * Included if the maneuver is a border crossing maneuver, or leads to a border crossing, i.e., maneuver is one of:
+     * CROSS_BORDER
+     * TAKE_SHIP_FERRY
+     * TAKE_CAR_TRAIN
+     * LEAVE_SHIP_FERRY
+     * LEAVE_CAR_TRAIN
+     */
+    countryCrossingToName?: TextWithPhonetics;
+    /**
+     * The code (ISO 3166-1 alpha-3) of the country the border crossing occurs to.
+     * Included if the maneuver is a border crossing maneuver, i.e., maneuver is one of:
+     * CROSS_BORDER
+     * TAKE_SHIP_FERRY
+     * TAKE_CAR_TRAIN
+     * LEAVE_SHIP_FERRY
+     * LEAVE_CAR_TRAIN
+     */
+    countryCrossingToCode?: string;
+};
+
+/**
+ * Calculates whether the given bbox has area (width and height).
+ * @ignore
+ * @param bbox The BBox to verify. If undefined, false is returned.
+ */
+export declare const isBBoxWithArea: (bbox: OptionalBBox) => boolean;
+
+/**
+ * Type of landmarks that can be used in instructions.
+ * @group Route
+ */
+export declare type Landmark = 'END_OF_ROAD' | 'AT_TRAFFIC_LIGHT' | 'ON_TO_BRIDGE' | 'ON_BRIDGE' | 'AFTER_BRIDGE' | 'INTO_TUNNEL' | 'INSIDE_TUNNEL' | 'AFTER_TUNNEL';
+
+/**
+ * Lane guidance information.
+ *
+ * Describes possible directions for a lane and which direction to follow.
+ * Used for lane-level navigation guidance.
+ *
+ * @example
+ * ```typescript
+ * // Left lane allows left turn or straight
+ * const laneDirection: LaneDirection = {
+ *   directions: ['LEFT', 'STRAIGHT'],
+ *   follow: 'LEFT'  // Follow the left turn
+ * };
+ * ```
+ *
+ * @group Route
+ */
+export declare type LaneDirection = {
+    /**
+     * All possible directions this lane leads to.
+     *
+     * A lane may allow multiple directions (e.g., straight and turn).
+     */
+    directions: PossibleLaneDirection[];
+    /**
+     * The direction to follow in this lane for the route.
+     *
+     * Present when guidance indicates which direction to take.
+     */
+    follow?: PossibleLaneDirection;
+};
+
+/**
+ * Section representing a lane configuration.
+ * @group Route
+ */
+export declare type LaneSectionProps = SectionProps & {
+    /**
+     * The lane directions for this lane section.
+     */
+    lanes: LaneDirection[];
+    /**
+     * The lane separators for this lane section.
+     */
+    laneSeparators: PossibleLaneSeparator[];
+    /**
+     * Properties of the lane section, as a possible combination of several values. This field is optional.
+     * Possible values:
+     * IS_MANEUVER: whether the lane section contains a maneuver point, that is, there exists a guidance instruction
+     * with a maneuverPoint that falls into this section. The section describes the lane configuration for that
+     * particular instruction.
+     * It is possible that more values will be added to the API in the future.
+     */
+    properties?: string[];
+};
+
+/**
+ * Language code for map display and service responses.
+ *
+ * Determines the language used for:
+ * - Map labels and text on vector tiles
+ * - Place names, addresses, and other textual content in service responses
+ *
+ * Supports various locales with region-specific variants (e.g., `en-US`, `en-GB`).
+ * Special codes like `ngt` (Neutral Ground Truth) and `ngt-Latn` provide language-neutral
+ * or Latin script alternatives.
+ *
+ * @see [Supported languages documentation](https://docs.tomtom.com/map-display-api/documentation/vector/content-v2#list-of-supported-languages)
+ *
+ * @example
+ * ```typescript
+ * // Use US English
+ * const language: Language = 'en-US';
+ *
+ * // Use simplified Chinese
+ * const language: Language = 'zh-Hans';
+ *
+ * // Use neutral ground truth (no translation)
+ * const language: Language = 'ngt';
+ * ```
+ *
+ * @group Shared
+ */
+export declare type Language = (typeof languages)[number];
+
+/**
+ * Array of all supported language codes for map display and service responses.
+ *
+ * This constant array contains all valid language codes that can be used to configure
+ * the language for map labels, place names, addresses, and other textual content.
+ *
+ * The array includes:
+ * - Region-specific language variants (e.g., `en-US`, `en-GB`, `pt-BR`, `pt-PT`)
+ * - Script-specific variants (e.g., `zh-Hans` for Simplified Chinese, `zh-Hant` for Traditional Chinese)
+ * - Special codes like `ngt` (Neutral Ground Truth) for language-neutral content
+ * - Latin script alternatives (e.g., `ngt-Latn`, `ko-Latn-KR`, `ru-Latn-RU`)
+ * - Cyrillic script variants (e.g., `ru-Cyrl-RU`)
+ *
+ * Use this array to:
+ * - Validate user-provided language codes
+ * - Generate language selection UI components
+ * - Iterate over all available language options
+ * - Check if a language code is supported
+ *
+ * @see {@link Language} - The type derived from this array
+ * @see [Supported languages documentation](https://docs.tomtom.com/map-display-api/documentation/vector/content-v2#list-of-supported-languages)
+ *
+ * @example
+ * ```typescript
+ * // Validate a language code
+ * const userLanguage = 'en-US';
+ * if (languages.includes(userLanguage)) {
+ *   console.log('Language is supported');
+ * }
+ *
+ * // Create a language selector
+ * languages.forEach(lang => {
+ *   console.log(`Available language: ${lang}`);
+ * });
+ *
+ * // Check total number of supported languages
+ * console.log(`Total languages: ${languages.length}`);
+ * ```
+ *
+ * @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"];
+
+/**
+ * Route section representing a leg between waypoints.
+ *
+ * A leg is the portion of route between two consecutive non-circle waypoints.
+ * This is a top-level section that encompasses the entire journey segment.
+ *
+ * @remarks
+ * Leg examples:
+ * - A→B route: 1 leg (A to B)
+ * - A→B→C route: 2 legs (A to B, then B to C)
+ * - A→B→(circle)→C route: 2 legs (A to B, then B to C) - circle waypoint doesn't create a leg
+ *
+ * @example
+ * ```typescript
+ * const leg: LegSectionProps = {
+ *   id: 'leg-1',
+ *   summary: {
+ *     departureTime: new Date(),
+ *     arrivalTime: new Date(),
+ *     lengthInMeters: 50000,
+ *     travelTimeInSeconds: 3600,
+ *     // ... other summary fields
+ *   },
+ *   startPointIndex: 0,
+ *   endPointIndex: 250
+ * };
+ * ```
+ *
+ * @group Route
+ */
+export declare type LegSectionProps = Omit<SectionProps, 'startPointIndex' | 'endPointIndex'> & {
+    /**
+     * Index where this leg starts in the route coordinates.
+     *
+     * Only present if the route polyline geometry is available.
+     */
+    startPointIndex?: number;
+    /**
+     * Index where this leg ends in the route coordinates.
+     *
+     * Only present if the route polyline geometry is available.
+     */
+    endPointIndex?: number;
+    /**
+     * Summary statistics for this leg.
+     *
+     * Contains departure/arrival times, distances, durations, and consumption
+     * estimates specifically for this leg of the journey.
+     */
+    summary: LegSummary;
+};
+
+/**
+ * Summary information for a single route leg.
+ *
+ * A leg is the portion of the route between two consecutive waypoints.
+ *
+ * @remarks
+ * - An A→B route has 1 leg
+ * - An A→B→C route has 2 legs (A→B, B→C)
+ * - Circle waypoints don't create new legs
+ *
+ * @group Route
+ */
+export declare type LegSummary = SummaryWithConsumption & {
+    /**
+     * Charging information at the end of this leg.
+     *
+     * Present only if this leg ends at a charging stop, indicating the vehicle
+     * will charge at this waypoint before continuing to the next leg.
+     *
+     * @remarks
+     * Contains details about:
+     * - Charging park location and facilities
+     * - Required charging time
+     * - Target charge level after charging
+     *
+     * @example
+     * ```typescript
+     * chargingInformationAtEndOfLeg: {
+     *   chargingParkId: 'park-123',
+     *   chargingTimeInSeconds: 1200,  // 20 minutes
+     *   targetChargeInkWh: 80,
+     *   targetChargeInPCT: 80
+     * }
+     * ```
+     */
+    chargingInformationAtEndOfLeg?: ChargingStop;
+};
+
+/**
+ * Localized name for a POI category.
+ *
+ * Provides the category name in a specific language/locale.
+ *
+ * @example
+ * ```typescript
+ * const localizedName: LocalizedName = {
+ *   nameLocale: 'en-US',
+ *   name: 'Restaurant'
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type LocalizedName = {
+    /**
+     * Language/locale code for this name.
+     *
+     * Uses IETF language tags (e.g., 'en-US', 'fr-FR', 'de-DE').
+     */
+    nameLocale: string;
+    /**
+     * Category name in the specified locale.
+     *
+     * Human-readable, localized category text.
+     */
+    name: string;
+};
+
+/**
+ * Description of the maneuver, for example: arrive or turn right.
+ * @see https://docs.tomtom.com/routing-api/documentation/routing/calculate-route#maneuver-codes
+ * @group Route
+ */
+export declare type Maneuver = 'DEPART' | 'WAYPOINT_LEFT' | 'WAYPOINT_RIGHT' | 'WAYPOINT_REACHED' | 'WAYPOINT_AHEAD' | 'ARRIVE' | 'ARRIVE_LEFT' | 'ARRIVE_RIGHT' | 'ARRIVE_AHEAD' | 'STRAIGHT' | 'KEEP_LEFT' | 'KEEP_RIGHT' | 'SLIGHT_RIGHT' | 'TURN_RIGHT' | 'SHARP_RIGHT' | 'SLIGHT_LEFT' | 'TURN_LEFT' | 'SHARP_LEFT' | 'MAKE_UTURN' | 'ROUNDABOUT_STRAIGHT' | 'ROUNDABOUT_SHARP_RIGHT' | 'ROUNDABOUT_RIGHT' | 'ROUNDABOUT_SLIGHT_RIGHT' | 'ROUNDABOUT_SLIGHT_LEFT' | 'ROUNDABOUT_LEFT' | 'ROUNDABOUT_SHARP_LEFT' | 'ROUNDABOUT_BACK' | 'EXIT_ROUNDABOUT' | 'EXIT_MOTORWAY_LEFT' | 'EXIT_MOTORWAY_RIGHT' | 'SWITCH_MOTORWAY_LEFT' | 'SWITCH_MOTORWAY_RIGHT' | 'ENTER_CARPOOL_LANE_LEFT' | 'ENTER_CARPOOL_LANE_RIGHT' | 'EXIT_CARPOOL_LANE_LEFT' | 'EXIT_CARPOOL_LANE_RIGHT' | 'MERGE_LEFT_LANE' | 'MERGE_RIGHT_LANE' | 'TAKE_SHIP_FERRY' | 'TAKE_CAR_TRAIN' | 'LEAVE_SHIP_FERRY' | 'LEAVE_CAR_TRAIN' | 'CROSS_BORDER' | 'TOLLGATE';
+
+/**
+ * Mapcode representation of a location.
+ *
+ * A mapcode is a short, memorable code representing a geographic location,
+ * designed as an alternative to coordinates.
+ *
+ * @example
+ * ```typescript
+ * // Local mapcode (requires territory)
+ * const localMapcode: Mapcode = {
+ *   type: 'Local',
+ *   fullMapcode: 'NLD 4J.P2',
+ *   territory: 'NLD',
+ *   code: '4J.P2'
+ * };
+ *
+ * // International mapcode (no territory needed)
+ * const intlMapcode: Mapcode = {
+ *   type: 'International',
+ *   fullMapcode: 'VHXGB.4J9W',
+ *   code: 'VHXGB.4J9W'
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type Mapcode = {
+    /**
+     * The type of mapcode (Local, International, or Alternative).
+     */
+    type: MapcodeType;
+    /**
+     * Complete mapcode including territory if applicable.
+     *
+     * Always unambiguous. Format: "TERRITORY CODE" for local, just "CODE" for international.
+     */
+    fullMapcode: string;
+    /**
+     * Territory code for local mapcodes.
+     *
+     * Present only for Local and Alternative mapcodes. Uses Latin alphabet.
+     * Not present for International mapcodes.
+     */
+    territory?: string;
+    /**
+     * The mapcode without territory.
+     *
+     * Two groups of letters/digits separated by a dot (e.g., "4J.P2").
+     * Uses the response language/alphabet. Not present for International mapcodes.
+     */
+    code?: string;
+};
+
+/**
+ * Type of mapcode.
+ *
+ * Mapcodes are short location codes that can be used as an alternative to coordinates.
+ *
+ * @remarks
+ * - `Local`: Shortest mapcode, requires territory context (e.g., "4J.P2" for Eiffel Tower in FRA)
+ * - `International`: Unambiguous worldwide, no territory needed but longer
+ * - `Alternative`: Alternative local encoding pointing to slightly different coordinates
+ *
+ * @see [Mapcode documentation](https://www.mapcode.com)
+ *
+ * @group Place
+ */
+export declare type MapcodeType = 'Local' | 'International' | 'Alternative';
+
+/**
+ * Merges the global configuration into the given one, with the latter having priority.
+ * @ignore
+ */
+export declare const mergeFromGlobal: <T extends Partial<GlobalConfig>>(givenConfig?: T) => T;
+
+/**
+ * Date and time with convenient derived properties.
+ *
+ * Represents a specific moment in time with pre-calculated components
+ * for easy access without additional date parsing.
+ *
+ * @example
+ * ```typescript
+ * const moment: Moment = {
+ *   date: new Date('2025-10-20T09:30:00Z'),
+ *   dateYYYYMMDD: '2025-10-20',
+ *   year: 2025,
+ *   month: 10,
+ *   day: 20,
+ *   hour: 9,
+ *   minute: 30
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type Moment = {
+    /**
+     * JavaScript Date object representing this moment.
+     */
+    date: Date;
+    /**
+     * Date formatted as YYYY-MM-DD string.
+     *
+     * Useful for display or comparison without time components.
+     */
+    dateYYYYMMDD: string;
+    /**
+     * Four-digit year (e.g., 2025).
+     */
+    year: number;
+    /**
+     * Month number (1-12).
+     *
+     * Note: Unlike JavaScript Date.getMonth(), this is 1-based (January = 1).
+     */
+    month: number;
+    /**
+     * Day of month (1-31).
+     */
+    day: number;
+    /**
+     * Hour in 24-hour format (0-23).
+     */
+    hour: number;
+    /**
+     * Minute (0-59).
+     */
+    minute: number;
+};
+
+/**
+ * Operating hours information for a POI.
+ *
+ * Describes when a location is open for business, including:
+ * - Regular daily schedules
+ * - Split shifts (e.g., lunch break closures)
+ * - Overnight hours
+ * - 24/7 operation
+ *
+ * @remarks
+ * Use this to:
+ * - Display "Open now" / "Closed" status
+ * - Show upcoming hours
+ * - Determine if a location is open at a specific time
+ * - Plan visits during operating hours
+ *
+ * @example
+ * ```typescript
+ * const openingHours: OpeningHours = {
+ *   mode: 'nextSevenDays',
+ *   timeRanges: [
+ *     { start: {...}, end: {...} },  // Monday
+ *     { start: {...}, end: {...} }   // Tuesday
+ *   ],
+ *   alwaysOpenThisPeriod: false
+ * };
+ *
+ * // 24/7 location
+ * const alwaysOpen: OpeningHours = {
+ *   mode: 'nextSevenDays',
+ *   timeRanges: [],
+ *   alwaysOpenThisPeriod: true
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type OpeningHours = {
+    /**
+     * Time period mode for the provided hours.
+     *
+     * Currently always 'nextSevenDays'.
+     */
+    mode: OpeningHoursMode;
+    /**
+     * Array of time ranges when the POI is open.
+     *
+     * Each time range represents one opening period. Multiple ranges per day
+     * indicate split shifts (e.g., closed for lunch).
+     *
+     * Empty array if alwaysOpenThisPeriod is true.
+     */
+    timeRanges: TimeRange[];
+    /**
+     * Indicates if the POI is always open during the requested period.
+     *
+     * When true, the location operates 24/7 and timeRanges will be empty.
+     * When false, refer to timeRanges for specific open hours.
+     */
+    alwaysOpenThisPeriod: boolean;
+};
+
+/**
+ * Operating hours mode specifying the time period covered.
+ *
+ * Currently only 'nextSevenDays' is supported, providing operating hours
+ * for the upcoming week.
+ *
+ * @group Place
+ */
+export declare type OpeningHoursMode = 'nextSevenDays';
+
+/**
+ * Optional bounding box value.
+ *
+ * @group Shared
+ */
+export declare type OptionalBBox = BBox | undefined;
+
+/**
+ * Input representing a path or route to follow.
+ *
+ * Used for route reconstruction or when you want the calculated route to follow
+ * a specific path rather than calculating a new one.
+ *
+ * @remarks
+ * - `Position[]`: Array of coordinate points defining the path
+ * - `Route`: Complete route object (for route reconstruction scenarios)
+ *
+ * @example
+ * ```typescript
+ * // As coordinate array
+ * const path1: PathLike = [
+ *   [4.9, 52.3],
+ *   [4.91, 52.31],
+ *   [4.92, 52.32]
+ * ];
+ *
+ * // As existing route
+ * const path2: PathLike = existingRoute;
+ * ```
+ *
+ * @group Route
+ */
+export declare type PathLike = Position[] | Route;
+
+/**
+ * Payment method type for electric vehicle charging stations.
+ *
+ * Specifies how users can pay for charging services at a particular station.
+ *
+ * @example
+ * ```typescript
+ * const method: PaymentMethod = 'Subscription';
+ * ```
+ *
+ * @group Route
+ */
+export declare type PaymentMethod = (typeof paymentMethods)[number];
+
+/**
+ * Available payment methods for electric vehicle charging stations.
+ *
+ * Defines the types of payment accepted at charging locations.
+ *
+ * @remarks
+ * - `No_Payment`: Free charging, no payment required
+ * - `Subscription`: Requires a subscription or membership plan
+ * - `Direct`: Pay-per-use, direct payment (credit card, app, etc.)
+ *
+ * @group Route
+ */
+export declare const paymentMethods: readonly ["No_Payment", "Subscription", "Direct"];
+
+/**
+ * GeoJSON Feature representing a place.
+ *
+ * A place is a Point feature with comprehensive location information
+ * including address, coordinates, and metadata.
+ *
+ * @typeParam P - Type of the place properties (defaults to CommonPlaceProps)
+ *
+ * @example
+ * ```typescript
+ * const place: Place<SearchPlaceProps> = {
+ *   type: 'Feature',
+ *   id: 'place-123',
+ *   geometry: { type: 'Point', coordinates: [4.9041, 52.3676] },
+ *   properties: {
+ *     type: 'POI',
+ *     address: { freeformAddress: 'Dam, Amsterdam', ... },
+ *     poi: { name: 'Dam Square', ... },
+ *     score: 0.95
+ *   }
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type Place<P extends CommonPlaceProps = CommonPlaceProps> = Omit<Feature<Point, P>, 'id'> & {
+    /**
+     * Unique identifier for this place.
+     *
+     * Required string ID (stricter than GeoJSON Feature's optional id).
+     */
+    id: string;
+};
+
+/**
+ * Data sources for fetching additional place information.
+ *
+ * Provides IDs that can be used with various services to retrieve
+ * detailed or real-time information about a place.
+ *
+ * @remarks
+ * This object acts as a navigation aid, telling you which additional
+ * data is available for a place and providing the IDs needed to fetch it.
+ *
+ * @example
+ * ```typescript
+ * const dataSources: PlaceDataSources = {
+ *   chargingAvailability: { id: 'charging-123' },
+ *   geometry: { id: 'geom-456' },
+ *   poiDetails: { id: 'poi-789', sourceName: 'TomTom' }
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type PlaceDataSources = {
+    /**
+     * Data source for EV charging station availability.
+     *
+     * Present only for places that are EV charging stations (type === POI).
+     * Use the ID to fetch real-time availability from the
+     * EV Charging Stations Availability service.
+     */
+    chargingAvailability?: ChargingAvailabilityDataSource;
+    /**
+     * Data source for geometric shape information.
+     *
+     * Present for places with geometric representations (type === Geography or POI).
+     * Use the ID to fetch boundary polygons from the Geometry Data service.
+     *
+     * @remarks
+     * Useful for:
+     * - Displaying administrative boundaries
+     * - Showing building footprints
+     * - Visualizing area coverage
+     */
+    geometry?: GeometryDataSource;
+    /**
+     * Data source for detailed POI information.
+     *
+     * Present only for POI places (type === POI).
+     * Use the ID to fetch extended details from the Points of Interest Details service.
+     */
+    poiDetails?: PoiDetailsDataSource;
+};
+
+/**
+ * GeoJSON FeatureCollection containing multiple places.
+ *
+ * Collection of place results from search or geocoding operations.
+ *
+ * @typeParam P - Type of individual place properties (defaults to CommonPlaceProps)
+ * @typeParam FeatureCollectionProps - Type of collection-level properties
+ *
+ * @example
+ * ```typescript
+ * const places: Places<SearchPlaceProps> = {
+ *   type: 'FeatureCollection',
+ *   features: [
+ *     { id: '1', type: 'Feature', geometry: {...}, properties: {...} },
+ *     { id: '2', type: 'Feature', geometry: {...}, properties: {...} }
+ *   ]
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type Places<P extends CommonPlaceProps = CommonPlaceProps, FeatureCollectionProps = unknown> = Omit<FeatureCollectionWithProperties<Point, P, FeatureCollectionProps>, 'features'> & {
+    /**
+     * Array of place features.
+     *
+     * Each place has a required string ID.
+     */
+    features: Place<P>[];
+};
+
+/**
+ * Type of place result.
+ *
+ * Categorizes the kind of location returned by search or geocoding services.
+ *
+ * @remarks
+ * - `POI`: Point of Interest (business, landmark, facility)
+ * - `Street`: A named street
+ * - `Geography`: Administrative area (city, state, country, etc.)
+ * - `Point Address`: Specific street address with building number
+ * - `Address Range`: Range of addresses along a street segment
+ * - `Cross Street`: Intersection of two streets
+ *
+ * @example
+ * ```typescript
+ * const placeType: PlaceType = 'POI';
+ * ```
+ *
+ * @group Place
+ */
+export declare type PlaceType = (typeof placeTypes)[number];
+
+/**
+ * @group Place
+ */
+export declare const placeTypes: readonly ["POI", "Street", "Geography", "Point Address", "Address Range", "Cross Street"];
+
+/**
+ * Standard plug/connector type for electric vehicle charging.
+ *
+ * Defines the physical connector type used for charging, which must match
+ * the vehicle's charging port. Different regions and manufacturers use different standards.
+ *
+ * @remarks
+ * Common standards include:
+ * - **IEC 62196 Types**: European and international standards (Type 1, Type 2, Type 3)
+ * - **CHAdeMO**: Japanese DC fast charging standard
+ * - **CCS (Combo)**: Combined charging system (AC + DC)
+ * - **Tesla_Connector**: Tesla proprietary connector
+ * - **SAE_J1772**: North American standard for AC charging
+ * - **China_GB**: Chinese national standard
+ * - **NEMA**: North American standard household outlets
+ *
+ * Different vehicles support different plug types, and charging stations may have multiple
+ * connector types available.
+ *
+ * @example
+ * ```typescript
+ * // Common connector types
+ * const type2: PlugType = 'IEC_62196_Type_2_Connector_Cable_Attached';  // Common in Europe
+ * const chademo: PlugType = 'CHAdeMO';  // Japanese standard
+ * const ccs: PlugType = 'Combo_to_IEC_62196_Type_2_Base';  // CCS Combo 2
+ * const tesla: PlugType = 'Tesla_Connector';  // Tesla vehicles
+ * ```
+ *
+ * @group Route
+ */
+export declare type PlugType = (typeof plugTypes)[number];
+
+/**
+ * Available plug types for EV charging.
+ * @group Route
+ */
+export declare const plugTypes: readonly ["Small_Paddle_Inductive", "Large_Paddle_Inductive", "IEC_60309_1_Phase", "IEC_60309_3_Phase", "IEC_62196_Type_1_Outlet", "IEC_62196_Type_2_Outlet", "IEC_62196_Type_3_Outlet", "IEC_62196_Type_1_Connector_Cable_Attached", "IEC_62196_Type_2_Connector_Cable_Attached", "IEC_62196_Type_3_Connector_Cable_Attached", "Combo_to_IEC_62196_Type_1_Base", "Combo_to_IEC_62196_Type_2_Base", "Type_E_French_Standard_CEE_7_5", "Type_F_Schuko_CEE_7_4", "Type_G_British_Standard_BS_1363", "Type_J_Swiss_Standard_SEV_1011", "China_GB_Part_2", "China_GB_Part_3", "IEC_309_DC_Plug", "AVCON_Connector", "Tesla_Connector", "NEMA_5_20", "CHAdeMO", "SAE_J1772", "TEPCO", "Better_Place_Socket", "Marechal_Socket", "Standard_Household_Country_Specific"];
+
+/**
+ * Point of Interest (POI) information.
+ *
+ * Contains detailed information about a place such as a business, landmark, or facility.
+ * This data enriches basic place information with operational details and categorization.
+ *
+ * @example
+ * ```typescript
+ * const poi: POI = {
+ *   name: 'Central Station Café',
+ *   phone: '+31 20 123 4567',
+ *   brands: ['Starbucks'],
+ *   categoryIds: [7315025],
+ *   categories: ['Café'],
+ *   url: 'https://example.com',
+ *   openingHours: { mode: 'nextSevenDays', timeRanges: [...], alwaysOpenThisPeriod: false }
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type POI = {
+    /**
+     * Name of the point of interest.
+     *
+     * The primary display name, localized according to the request language.
+     */
+    name: string;
+    /**
+     * Contact phone number for the POI.
+     *
+     * Typically includes country code (e.g., '+31 20 123 4567').
+     */
+    phone?: string;
+    /**
+     * Brand names associated with this POI.
+     *
+     * For chain locations, identifies the brand (e.g., 'Starbucks', 'Shell', 'Marriott').
+     */
+    brands?: string[];
+    /**
+     * Website URL for the POI.
+     *
+     * Official website or online presence for the business or location.
+     */
+    url?: string;
+    /**
+     * Category identifiers for the POI.
+     *
+     * Numeric IDs corresponding to the POI category classification system.
+     * Use these for filtering or identifying POI types programmatically.
+     */
+    categoryIds?: number[];
+    /**
+     * Human-readable category names for the POI.
+     *
+     * Localized text descriptions of the POI categories (e.g., 'Restaurant', 'Gas Station', 'Hotel').
+     */
+    categories?: string[];
+    /**
+     * Operating hours information.
+     *
+     * Specifies when the POI is open, including daily schedules and special hours.
+     * Useful for determining if a location is currently open or planning visits.
+     */
+    openingHours?: OpeningHours;
+    /**
+     * Detailed category classifications with localized names.
+     *
+     * Provides category information in multiple languages and includes standardized codes.
+     */
+    classifications?: Classification[];
+    /**
+     * Time zone of the POI location.
+     *
+     * Used for interpreting opening hours and scheduling visits across time zones.
+     */
+    timeZone?: TimeZone;
+};
+
+/**
+ * @group Place
+ */
+export declare type POICategory = 'ACCESS_GATEWAY' | 'ADVENTURE_SPORTS_FACILITY' | 'ADVENTURE_SPORTS_VENUE' | 'ADVENTURE_VEHICLE_TRAIL' | 'ADVERTISING_COMPANY' | 'AFGHAN_RESTAURANT' | 'AFRICAN_RESTAURANT' | 'AGRICULTURE' | 'AGRICULTURAL_BUSINESS' | 'AGRICULTURAL_SUPPLIES' | 'AGRICULTURAL_TECHNOLOGY' | 'AIRFIELD' | 'AIRLINE_ACCESS' | 'AIRLINE_COMPANY' | 'AIRPORT' | 'ALGERIAN_RESTAURANT' | 'AMBULANCE_UNIT' | 'AMERICAN_RESTAURANT' | 'AMPHITHEATER' | 'AMUSEMENT_ARCADE' | 'AMUSEMENT_PARK' | 'AMUSEMENT_PLACE' | 'ANIMAL_SERVICES' | 'ANIMAL_SHELTER' | 'ANTIQUE_ART_SHOP' | 'APARTMENT_RENTAL' | 'AQUATIC_ZOO' | 'ARABIAN_RESTAURANT' | 'ARCH' | 'ARGENTINIAN_RESTAURANT' | 'ARMENIAN_RESTAURANT' | 'ART_SCHOOL' | 'ASHRAM' | 'ASIAN_RESTAURANT' | 'ATHLETICS_TRACK' | 'ATM' | 'ATV_DEALER' | 'AUSTRALIAN_RESTAURANT' | 'AUSTRIAN_RESTAURANT' | 'AUTOMOBILE_COMPANY' | 'AUTOMOBILE_MANUFACTURING' | 'AUTOMOTIVE_DEALER' | 'BAGS_LEATHERWEAR' | 'BAKERY' | 'BANK' | 'BANQUET_ROOMS' | 'BAR' | 'BARBECUE_RESTAURANT' | 'BASEBALL_PARK' | 'BASKETBALL_ARENA' | 'BASQUE_RESTAURANT' | 'BATTLEFIELD' | 'BAY' | 'BEACH' | 'BEACH_CLUB' | 'BEAUTY_SALON' | 'BEAUTY_SUPPLIES' | 'BELGIAN_RESTAURANT' | 'BETTING_STATION' | 'BISTRO' | 'BLOOD_BANK' | 'BOATING_EQUIPMENT_ACCESSORIES' | 'BOAT_DEALER' | 'BOAT_LAUNCHING_RAMP' | 'BODYSHOP' | 'BOLIVIAN_RESTAURANT' | 'BOOK_SHOP' | 'BOSNIAN_RESTAURANT' | 'BOWLING_CENTER' | 'BRAZILIAN_RESTAURANT' | 'BRIDGE' | 'BRIDGE_TUNNEL_OPERATIONS' | 'BRITISH_RESTAURANT' | 'BUFFET_RESTAURANT' | 'BUILDING' | 'BULGARIAN_RESTAURANT' | 'BUNGALOW_RENTAL' | 'BURMESE_RESTAURANT' | 'BUSINESS_PARK' | 'BUSINESS_SERVICES' | 'BUS_CHARTER_COMPANY' | 'BUS_DEALER' | 'BUS_LINES' | 'BUS_STOP' | 'BUTCHER' | 'B_B_GUEST_HOUSE' | 'CABARET_THEATER' | 'CABINS_LODGES' | 'CABLE_TELEPHONE_COMPANY' | 'CAFE' | 'CAFETERIA' | 'CAFE_PUB' | 'CALIFORNIAN_RESTAURANT' | 'CAMBODIAN_RESTAURANT' | 'CAMERAS_PHOTOGRAPHY' | 'CAMPING_GROUND' | 'CANADIAN_RESTAURANT' | 'CAPE' | 'CARAVAN_SITE' | 'CARIBBEAN_RESTAURANT' | 'CARPET_FLOOR_COVERINGS' | 'CAR_ACCESSORIES' | 'CAR_DEALER' | 'CAR_GLASS_REPLACEMENT_SHOP' | 'CAR_REPAIR_AND_SERVICE' | 'CAR_WASH' | 'CASINO' | 'CASH_DISPENSER' | 'CATERING_SERVICES' | 'CAVE' | 'CEMETERY' | 'CHALET_RENTAL' | 'CHECKPOINT' | 'CHEMICAL_COMPANY' | 'CHICKEN_RESTAURANT' | 'CHILDRENS_CLOTHES' | 'CHILD_CARE_FACILITY' | 'CHILEAN_RESTAURANT' | 'CHINESE_RESTAURANT' | 'CHRISTMAS_HOLIDAY_SHOP' | 'CHURCH' | 'CINEMA' | 'CLEANING_SERVICES' | 'CLOTHING_SHOP' | 'CLUB_ASSOCIATION' | 'COACH_STOP' | 'COCKTAIL_BAR' | 'COFFEE_SHOP' | 'COLLEGE_UNIVERSITY' | 'COLOMBIAN_RESTAURANT' | 'COMEDY_CLUB' | 'COMMERCIAL_BUILDING' | 'COMMUNITY_CENTER' | 'COMPANY' | 'COMPUTER_COMPUTER_SUPPLIES' | 'COMPUTER_DATA_SERVICES' | 'CONCERT_HALL' | 'CONDOMINIUM_COMPLEX' | 'CONSTRUCTION_COMPANY' | 'CONSTRUCTION_MATERIAL_EQUIPMENT' | 'CONSUMER_ELECTRONICS' | 'CONVENIENCE_STORE' | 'CORSICAN_RESTAURANT' | 'COTTAGE_RENTAL' | 'COURIER_DROP_BOX' | 'COURTHOUSE' | 'COVE' | 'CREOLE_RESTAURANT' | 'CREPERIE' | 'CRICKET_GROUND' | 'CUBAN_RESTAURANT' | 'CULINARY_SCHOOL' | 'CULTURAL_CENTER' | 'CURTAINS_TEXTILES' | 'CYPRIOT_RESTAURANT' | 'CZECH_RESTAURANT' | 'C_DS_DVD_VIDEOS' | 'DAM' | 'DANCE_STUDIO_SCHOOL' | 'DANISH_RESTAURANT' | 'DELICATESSEN' | 'DELIVERY_SERVICE' | 'DENTIST' | 'DEPARTMENT_STORE' | 'DINNER_THEATER' | 'DISCO_CLUB' | 'DIVERSIFIED_FINANCIALS' | 'DOCTOR' | 'DOMINICAN_RESTAURANT' | 'DONGBEI_RESTAURANT' | 'DOUGHNUT_RESTAURANT' | 'DO_IT_YOURSELF_CENTERS' | 'DRIVE_IN_MOVIES' | 'DRIVE_THROUGH_BOTTLE_SHOP' | 'DRIVING_SCHOOL' | 'DRUG_STORE' | 'DRY_CLEANER' | 'DUNE' | 'DUTCH_RESTAURANT' | 'EGYPTIAN_RESTAURANT' | 'ELECTRICAL_APPLIANCES_SHOP' | 'ELECTRIC_VEHICLE_STATION' | 'ELECTRONICS_COMPANY' | 'EMBASSY' | 'EMERGENCY_MEDICAL_SERVICE' | 'EMERGENCY_ROOM' | 'ENGLISH_RESTAURANT' | 'ENTERTAINMENT' | 'EQUIPMENT_RENTAL' | 'EROTIC_RESTAURANT' | 'ETHIOPIAN_RESTAURANT' | 'EXCHANGE' | 'EXHIBITION_CONVENTION_CENTER' | 'EXOTIC_RESTAURANT' | 'FACTORY_OUTLET' | 'FAIRGROUND' | 'FARM' | 'FARMERS_MARKET' | 'FAST_FOOD' | 'FERRY_TERMINAL' | 'FINNISH_RESTAURANT' | 'FIRE_STATION_BRIGADE' | 'FISHING_HUNTING_AREA' | 'FISHMONGER' | 'FITNESS_CLUB_CENTER' | 'FLATS_APARTMENT_COMPLEX' | 'FLORISTS' | 'FLYING_CLUB' | 'FONDUE_RESTAURANT' | 'FOOD_MARKET' | 'FOOTBALL_STADIUM' | 'FOOTWEAR_SHOE_REPAIRS' | 'FOREST_AREA' | 'FRENCH_RESTAURANT' | 'FRONTIER_CROSSING' | 'FUEL_FACILITIES' | 'FUNERAL_SERVICE_MORTUARIES' | 'FURNITURE_HOME_FURNISHINGS' | 'FUSION_RESTAURANT' | 'GARDEN_CENTERS_SERVICES' | 'GAS_STATION' | 'GENERAL_PRACTITIONER' | 'GEOGRAPHIC_FEATURE' | 'GERMAN_RESTAURANT' | 'GIFTS_CARDS_NOVELTIES_SOUVENIRS' | 'GLASSWARE_CERAMIC_SHOP' | 'GLASS_WINDOWS_STORE' | 'GOLD_EXCHANGE' | 'GOLF_COURSE' | 'GOVERNMENT_OFFICE' | 'GREEK_RESTAURANT' | 'GREENGROCER' | 'GRILL_RESTAURANT' | 'GROCERY_STORE' | 'GUANGDONG_RESTAURANT' | 'GURUDWARA' | 'HAIRDRESSER' | 'HAMBURGER_RESTAURANT' | 'HARBOR' | 'HARDWARE_STORE' | 'HAWAIIAN_RESTAURANT' | 'HEALTH_CARE_SERVICE' | 'HELIPAD_HELICOPTER_LANDING' | 'HIGH_SCHOOL' | 'HIKING_TRAIL' | 'HILL' | 'HISTORICAL_PARK' | 'HISTORIC_SITE' | 'HOBBY_SHOP' | 'HOCKEY_CLUB' | 'HOLIDAY_RENTAL' | 'HOME_APPLIANCE_REPAIR' | 'HORSE_RACING_TRACK' | 'HORSE_RIDING_CENTER' | 'HORSE_RIDING_TRAIL' | 'HORTICULTURE' | 'HOSPITAL' | 'HOSPITAL_FOR_WOMEN_AND_CHILDREN' | 'HOSPITAL_OF_CHINESE_MEDICINE' | 'HOSPITAL_POLYCLINIC' | 'HOSTEL' | 'HOTEL' | 'HOTEL_MOTEL' | 'HOT_POT_RESTAURANT' | 'HOUSE_GARDEN_FURNITURE_FITTINGS' | 'HUNAN_RESTAURANT' | 'HUNGARIAN_RESTAURANT' | 'ICE_CREAM_PARLOR' | 'ICE_HOCKEY_ARENA' | 'ICE_SKATING_RINK' | 'IMPORT_EXPORT_AND_DISTRIBUTION' | 'IMPORTANT_TOURIST_ATTRACTION' | 'INDIAN_RESTAURANT' | 'INDONESIAN_RESTAURANT' | 'INDUSTRIAL_BUILDING' | 'INFORMAL_MARKET' | 'INSURANCE_COMPANY' | 'INTERNATIONAL_RAILROAD_STATION' | 'INTERNATIONAL_RESTAURANT' | 'INTERNET_CAFE' | 'INVESTMENT_ADVISOR' | 'IRANIAN_RESTAURANT' | 'IRISH_RESTAURANT' | 'ISLAND' | 'ISRAELI_RESTAURANT' | 'ITALIAN_RESTAURANT' | 'JAMAICAN_RESTAURANT' | 'JAPANESE_RESTAURANT' | 'JAZZ_CLUB' | 'JEWELRY_CLOCKS_WATCHES' | 'JEWISH_RESTAURANT' | 'JUNIOR_COLLEGE_COMMUNITY_COLLEGE' | 'KARAOKE_CLUB' | 'KITCHENS_BATHROOMS' | 'KOREAN_RESTAURANT' | 'KOSHER_RESTAURANT' | 'LAGOON' | 'LAKESHORE' | 'LANGUAGE_SCHOOL' | 'LATIN_AMERICAN_RESTAURANT' | 'LAUNDRY' | 'LEBANESE_RESTAURANT' | 'LEGAL_SERVICES' | 'LEISURE_CENTER' | 'LIBRARY' | 'LIGHTING_SHOPS' | 'LOCALE' | 'LOCAL_POST_OFFICE' | 'LOCAL_SPECIALITIES_SHOP' | 'LOTTERY_SHOP' | 'LUXEMBOURGIAN_RESTAURANT' | 'MACROBIOTIC_RESTAURANT' | 'MAGHRIB_RESTAURANT' | 'MALTESE_RESTAURANT' | 'MANUFACTURING_COMPANY' | 'MANUFACTURING_FACILITY' | 'MARIJUANA_DISPENSARY' | 'MARINA' | 'MARINE_ELECTRONIC_EQUIPMENT' | 'MARKET' | 'MARSH' | 'MAURITIAN_RESTAURANT' | 'MAUSOLEUM_GRAVE' | 'MECHANICAL_ENGINEERING' | 'MEDIA_FACILITY' | 'MEDICAL_SUPPLIES_EQUIPMENT' | 'MEDICINAL_MARIJUANA_DISPENSARY' | 'MEDITERRANEAN_RESTAURANT' | 'MEMORIAL' | 'MENS_CLOTHING' | 'MEXICAN_RESTAURANT' | 'MICROBREWERY' | 'MIDDLE_EASTERN_RESTAURANT' | 'MIDDLE_SCHOOL' | 'MILITARY_AIRPORT' | 'MILITARY_INSTALLATION' | 'MINERAL_HOT_SPRINGS' | 'MINING_COMPANY' | 'MOBILE_PHONE_SHOP' | 'MONGOLIAN_RESTAURANT' | 'MONUMENT' | 'MOROCCAN_RESTAURANT' | 'MOSQUE' | 'MOTEL' | 'MOTORCYCLE_DEALER' | 'MOTORCYCLE_REPAIR' | 'MOTORING_ORGANIZATION_OFFICE' | 'MOTOR_RACING_STADIUM' | 'MOUNTAIN_BIKE_TRAIL' | 'MOUNTAIN_PASS' | 'MOUNTAIN_PEAK' | 'MOVIE_THEATER' | 'MOVING_STORAGE_COMPANY' | 'MULTI_PURPOSE_STADIUM' | 'MUSEUM' | 'MUSIC_CENTER' | 'MUSIC_INSTRUMENTS_STORE' | 'MUSSELS_RESTAURANT' | 'NAIL_SALON' | 'NATIONAL_RAILROAD_STATION' | 'NATIVE_RESERVATION' | 'NATURAL_RECREATION_ATTRACTION' | 'NATURAL_TOURIST_ATTRACTION' | 'NEPALESE_RESTAURANT' | 'NETBALL_STADIUM' | 'NEWSAGENTS_TOBACCONISTS' | 'NIGHTLIFE' | 'NON_GOVERNMENTAL_ORGANIZATION' | 'NORWEGIAN_RESTAURANT' | 'OASIS' | 'OBSERVATORY' | 'OEM' | 'OFFICE_EQUIPMENT' | 'OIL_NATURAL_GAS' | 'OPEN_CAR_PARKING_AREA' | 'OPEN_PARKING_AREA' | 'OPERA_HOUSE' | 'OPTICIAN' | 'ORGANIC_FOOD_RESTAURANT' | 'ORIENTAL_RESTAURANT' | 'OTHER_FOOD_SHOPS' | 'OTHER_REPAIR_SHOPS' | 'OTHER_WINTER_SPORT' | 'PAGODA' | 'PAINTING_DECORATING' | 'PAKISTANI_RESTAURANT' | 'PAN' | 'PARK' | 'PARKING_GARAGE' | 'PARKWAY' | 'PARK_RECREATION_AREA' | 'PASSENGER_TRANSPORT_TICKET_OFFICE' | 'PAWN_SHOP' | 'PEDESTRIAN_SUBWAY' | 'PERSONAL_CARE_FACILITY' | 'PERSONAL_SERVICE' | 'PERUVIAN_RESTAURANT' | 'PET_SUPPLIES' | 'PETROL_STATION' | 'PHARMACEUTICAL_COMPANY' | 'PHARMACY' | 'PHILIPPINE_RESTAURANT' | 'PHOTOCOPY_SHOP' | 'PHOTO_LAB_DEVELOPMENT' | 'PICNIC_AREA' | 'PIZZERIA' | 'PLACE_OF_WORSHIP' | 'PLAIN_FLAT' | 'PLANETARIUM' | 'PLATEAU' | 'POLICE_STATION' | 'POLISH_RESTAURANT' | 'POLYNESIAN_RESTAURANT' | 'PORTUGUESE_RESTAURANT' | 'PORT_WAREHOUSE_FACILITY' | 'POST_OFFICE' | 'PRESERVE' | 'PRE_SCHOOL' | 'PRIMARY_PRODUCER' | 'PRIMARY_RESOURCE_UTILITY' | 'PRIMARY_SCHOOL' | 'PRISON_CORRECTIONAL_FACILITY' | 'PRIVATE_AIRPORT' | 'PRIVATE_CLUB' | 'PROVENCAL_RESTAURANT' | 'PUB' | 'PUBLIC_AIRPORT' | 'PUBLIC_AMENITY' | 'PUBLIC_CALL_BOX' | 'PUBLIC_HEALTH_TECHNOLOGY_COMPANY' | 'PUBLIC_MARKET' | 'PUBLIC_TOILET' | 'PUBLIC_TRANSPORT_STOP' | 'PUBLISHING_TECHNOLOGIES' | 'PUB_FOOD' | 'QUARRY' | 'RACE_TRACK' | 'RAILROAD_SIDING' | 'RAILWAY_STATION' | 'RAPIDS' | 'REAL_ESTATE_AGENT' | 'REAL_ESTATE_COMPANY' | 'RECREATIONAL_CAMPING_GROUND' | 'RECREATIONAL_MARIJUANA_DISPENSARY' | 'RECREATIONAL_VEHICLE_DEALER' | 'RECREATION_AREA' | 'RECYCLING_SHOP' | 'REEF' | 'RENT_A_CAR_FACILITY' | 'RENT_A_CAR_PARKING' | 'REPAIR_FACILITY' | 'REPAIR_SHOP' | 'RESEARCH_FACILITY' | 'RESERVOIR' | 'RESIDENTIAL_ACCOMMODATION' | 'RESIDENTIAL_ESTATE' | 'RESORT' | 'RESTAURANT' | 'RESTAURANT_AREA' | 'REST_AREA' | 'REST_CAMP' | 'RETAIL_OUTLET' | 'RETIREMENT_COMMUNITY' | 'RIDGE' | 'RIVER_CROSSING' | 'RIVER_SCENIC_AREA' | 'ROADSIDE_RESTAURANT' | 'ROAD_RESCUE' | 'ROAD_TRAFFIC_CONTROL_CENTER' | 'ROCKS' | 'ROCK_CLIMBING_TRAIL' | 'ROMANIAN_RESTAURANT' | 'RUGBY_GROUND' | 'RUSSIAN_RESTAURANT' | 'SALAD_BAR' | 'SANDWICH_RESTAURANT' | 'SAUNA_SOLARIUM_MASSAGE' | 'SAVINGS_INSTITUTION' | 'SAVOY_RESTAURANT' | 'SCANDINAVIAN_RESTAURANT' | 'SCENIC_PANORAMIC_VIEW' | 'SCHOOL' | 'SCOTTISH_RESTAURANT' | 'SEAFOOD' | 'SEASHORE' | 'SECURED_ENTRANCE' | 'SECURITY_PRODUCTS' | 'SENIOR_HIGH_SCHOOL' | 'SERVICE_COMPANY' | 'SHANDONG_RESTAURANT' | 'SHANGHAI_RESTAURANT' | 'SHOP' | 'SHOPPING_CENTER' | 'SHOPPING_SERVICE' | 'SICHUAN_RESTAURANT' | 'SICILIAN_RESTAURANT' | 'SKI_RESORT' | 'SLAVIC_RESTAURANT' | 'SLOVAK_RESTAURANT' | 'SNACKS_RESTAURANT' | 'SNOOKER_POOL_BILLIARD' | 'SOCCER_STADIUM' | 'SOFTWARE_COMPANY' | 'SOUL_FOOD' | 'SOUP_RESTAURANT' | 'SPANISH_RESTAURANT' | 'SPECIALIST' | 'SPECIALTY_CLOTHING_SHOP' | 'SPECIALTY_FOODS' | 'SPECIAL_HOSPITAL' | 'SPECIAL_SCHOOL' | 'SPORTS_CENTER' | 'SPORTS_EQUIPMENT_CLOTHING' | 'SPORT_SCHOOL' | 'STADIUM' | 'STAMP_SHOP' | 'STATION_ACCESS' | 'STATUE' | 'STEAK_HOUSE' | 'STOCK_EXCHANGE' | 'STREETCAR_STOP' | 'SUBWAY_STATION' | 'SUDANESE_RESTAURANT' | 'SUPERMARKETS_HYPERMARKETS' | 'SURINAMESE_RESTAURANT' | 'SUSHI_RESTAURANT' | 'SWEDISH_RESTAURANT' | 'SWIMMING_POOL' | 'SWISS_RESTAURANT' | 'SYNAGOG' | 'SYRIAN_RESTAURANT' | 'TAILOR_SHOP' | 'TAIWANESE_RESTAURANT' | 'TAKEOUT_FOOD' | 'TAPAS_RESTAURANT' | 'TAXI_LIMOUSINE_SHUTTLE_SERVICE' | 'TAXI_STAND' | 'TAX_SERVICES' | 'TEA_HOUSE' | 'TECHNICAL_SCHOOL' | 'TELECOMMUNICATIONS' | 'TEMPLE' | 'TENNIS_COURT' | 'TEPPANYAKI_RESTAURANT' | 'THAI_RESTAURANT' | 'THEATER' | 'THEMATIC_SPORT_CENTER' | 'TIBETAN_RESTAURANT' | 'TIRE_SERVICE' | 'TOLL_GATE' | 'TOURIST_ATTRACTION' | 'TOURIST_INFORMATION_OFFICE' | 'TOWER' | 'TOWNHOUSE_COMPLEX' | 'TOYS_GAMES_SHOP' | 'TRAFFIC_CONTROL_DEPARTMENT' | 'TRAFFIC_SERVICE_CENTER' | 'TRAIL_SYSTEM' | 'TRAILS' | 'TRANSPORT_AUTHORITY_VEHICLE_REGISTRATION' | 'TRANSPORT_COMPANY' | 'TRAVEL_AGENT' | 'TRUCK_DEALER' | 'TRUCK_REPAIR_AND_SERVICE' | 'TRUCK_STOP' | 'TRUCK_WASH' | 'TUNISIAN_RESTAURANT' | 'TUNNEL' | 'TURKISH_RESTAURANT' | 'URBAN_STATION' | 'URUGUAYAN_RESTAURANT' | 'VACATION_RENTAL' | 'VALLEY' | 'VAN_DEALER' | 'VARIETY_STORE' | 'VEGETARIAN_RESTAURANT' | 'VENEZUELAN_RESTAURANT' | 'VETERINARIAN' | 'VIDEO_RENTAL_SHOP' | 'VIETNAMESE_RESTAURANT' | 'VILLA_RENTAL' | 'VOCATIONAL_SCHOOL' | 'WATER_HOLE' | 'WATER_SPORT' | 'WEDDING_SERVICES' | 'WEIGH_SCALES' | 'WEIGH_STATION' | 'WELFARE_ORGANIZATION' | 'WELL' | 'WELSH_RESTAURANT' | 'WESTERN_RESTAURANT' | 'WHOLESALE_CLUB' | 'WILDERNESS_AREA' | 'WILDLIFE_PARK' | 'WINERY' | 'WINE_BAR' | 'WINE_SPIRITS' | 'WOMENS_CLOTHING' | 'YACHT_BASIN' | 'YOGURT_JUICE_BAR' | 'ZOO' | 'ZOOS_ARBORETA_BOTANICAL_GARDEN';
+
+/**
+ * Data source reference for detailed POI information.
+ *
+ * @example
+ * ```typescript
+ * const dataSource: PoiDetailsDataSource = {
+ *   id: 'poi-xyz789',
+ *   sourceName: 'TomTom'
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type PoiDetailsDataSource = {
+    /**
+     * POI details ID for the Points of Interest Details service.
+     *
+     * Pass this value to fetch additional information such as:
+     * - Extended opening hours
+     * - Photos and ratings
+     * - Detailed amenities
+     * - Contact information
+     */
+    id: string;
+    /**
+     * Name of the data provider for this POI.
+     *
+     * Identifies the source of the POI information (e.g., 'TomTom', 'OSM').
+     * Optional identifier for attribution or quality assessment.
+     */
+    sourceName?: string;
+};
+
+/**
+ * GeoJSON Feature containing polygon or multi-polygon geometry.
+ *
+ * Represents an area on the map, such as:
+ * - Administrative boundaries (countries, states, cities)
+ * - Points of interest with building footprints
+ * - Search areas or geofences
+ * - Route reachable ranges
+ *
+ * @typeParam P - Type of the feature's properties object
+ *
+ * @example
+ * ```typescript
+ * const cityBoundary: PolygonFeature<{ name: string, population: number }> = {
+ *   type: 'Feature',
+ *   geometry: {
+ *     type: 'Polygon',
+ *     coordinates: [[
+ *       [4.8, 52.3],
+ *       [5.0, 52.3],
+ *       [5.0, 52.4],
+ *       [4.8, 52.4],
+ *       [4.8, 52.3]
+ *     ]]
+ *   },
+ *   properties: {
+ *     name: 'Amsterdam',
+ *     population: 872680
+ *   }
+ * };
+ * ```
+ *
+ * @group Shared
+ */
+export declare type PolygonFeature<P = GeoJsonProperties> = Feature<Polygon | MultiPolygon, P>;
+
+/**
+ * GeoJSON FeatureCollection containing polygon or multi-polygon features.
+ *
+ * Represents multiple polygonal areas, useful for:
+ * - Collections of administrative boundaries
+ * - Multiple search result areas
+ * - Multiple building footprints
+ *
+ * @typeParam P - Type of each feature's properties object
+ *
+ * @example
+ * ```typescript
+ * const neighborhoods: PolygonFeatures<{ name: string, area: number }> = {
+ *   type: 'FeatureCollection',
+ *   features: [
+ *     {
+ *       type: 'Feature',
+ *       geometry: { type: 'Polygon', coordinates: [...] },
+ *       properties: { name: 'District 1', area: 500000 }
+ *     },
+ *     {
+ *       type: 'Feature',
+ *       geometry: { type: 'Polygon', coordinates: [...] },
+ *       properties: { name: 'District 2', area: 750000 }
+ *     }
+ *   ]
+ * };
+ * ```
+ *
+ * @group Shared
+ */
+export declare type PolygonFeatures<P = GeoJsonProperties> = FeatureCollection<Polygon | MultiPolygon, P>;
+
+/**
+ * Possible directions a lane can lead to.
+ *
+ * Used in lane guidance to indicate which directions are possible from a lane.
+ *
+ * @group Route
+ */
+export declare type PossibleLaneDirection = 'STRAIGHT' | 'SLIGHT_RIGHT' | 'RIGHT' | 'SHARP_RIGHT' | 'RIGHT_U_TURN' | 'SLIGHT_LEFT' | 'LEFT' | 'SHARP_LEFT' | 'LEFT_U_TURN';
+
+/**
+ * All the possible lane separators.
+ * @group Route
+ */
+export declare type PossibleLaneSeparator = 'UNKNOWN' | 'NO_MARKING' | 'LONG_DASHED' | 'DOUBLE_SOLID' | 'SINGLE_SOLID' | 'SOLID_DASHED' | 'DASHED_SOLID' | 'SHORT_DASHED' | 'SHADED_AREA_MARKING' | 'DASHED_BLOCKS' | 'DOUBLE_DASHED' | 'CROSSING_ALERT' | 'PHYSICAL_DIVIDER' | 'PHYSICAL_DIVIDER_LESS_THAN_3M' | 'PHYSICAL_DIVIDER_GUARDRAIL' | 'CURB';
+
+/**
+ * Reference to a related Point of Interest.
+ *
+ * Represents a parent-child relationship between POIs, such as:
+ * - A restaurant inside a shopping mall
+ * - A store within an airport terminal
+ * - A department within a larger facility
+ *
+ * @example
+ * ```typescript
+ * const relatedPOI: RelatedPOI = {
+ *   relationType: 'parent',  // This POI is inside a larger complex
+ *   id: 'abc123def456'       // ID to fetch parent POI details
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type RelatedPOI = {
+    /**
+     * Type of relationship between this POI and the referenced POI.
+     *
+     * - `child`: The referenced POI is contained within this POI (e.g., a store in this mall)
+     * - `parent`: This POI is contained within the referenced POI (e.g., this store is inside a mall)
+     */
+    relationType: 'child' | 'parent';
+    /**
+     * Unique identifier for the related POI.
+     *
+     * Pass this ID to the Place by ID service to fetch detailed information
+     * about the related location.
+     */
+    id: string;
+};
+
+/**
+ * Properties for reverse geocoded places.
+ *
+ * Extends common place properties with reverse geocoding-specific information
+ * like the original query position and address interpolation details.
+ *
+ * @group Place
+ */
+export declare type RevGeoAddressProps = CommonPlaceProps & {
+    /**
+     * Original coordinates used in the reverse geocoding query [longitude, latitude].
+     */
+    originalPosition: Position;
+    /**
+     * Offset position coordinates for address interpolation.
+     *
+     * Present when a street number was specified in the query.
+     * Represents the interpolated position of the specific address number.
+     */
+    offsetPosition?: Position;
+    /**
+     * Which side of the street the address is located on.
+     *
+     * Present only when a street number was specified in the query.
+     */
+    sideOfStreet?: SideOfStreet;
+};
+
+/**
+ * Road information, including properties, street name and road shields.
+ * @group Route
+ */
+export declare type RoadInformation = {
+    /**
+     * The properties of road, as a possible combination of several values.
+     */
+    properties: RoadInformationProperty[];
+    /**
+     * The street name for the road.
+     * Included if street name is available for this road.
+     */
+    streetName?: TextWithPhonetics;
+    /**
+     * Lists the road shields for this road.
+     * The list can be empty if no road shields are available.
+     */
+    roadShields: RoadShield[];
+};
+
+/**
+ * The properties of road.
+ * URBAN -> represents an urban road type.
+ * MOTORWAY -> represents a motorway road type.
+ * CONTROLLED_ACCESS -> represents a controlled access road type with regulated traffic flow and regulated entries and exits.
+ * @group Route
+ */
+export declare type RoadInformationProperty = 'URBAN' | 'MOTORWAY' | 'CONTROLLED_ACCESS';
+
+/**
+ * Road shield object containing extra information.
+ * @group Route
+ */
+export declare type RoadShield = {
+    /**
+     * The road number. Most road numbers have a 'letter' prefix, which is also returned.
+     */
+    roadNumber: TextWithPhonetics;
+    /**
+     * Information allowing the client to build an image of the road shield using the TomTom RoadShield API.
+     * Included if instructionRoadShieldReferences was requested.
+     */
+    roadShieldReference: RoadShieldReference;
+    /**
+     * The state code of the state the shield is in (second part of an ISO 3166-2 identifier).
+     * Included if state codes are available for the country the road shield is located in.
+     */
+    stateCode?: string;
+    /**
+     * The country code (ISO 3166-1 alpha-3) of the country the shield is in.
+     */
+    countryCode: string;
+};
+
+/**
+ * Object describes a single road shield reference.
+ * @group Route
+ */
+export declare type RoadShieldReference = {
+    /**
+     * A unique identifier for the road shield.
+     */
+    reference: string;
+    /**
+     * An optional string to be shown on the road shield.
+     */
+    shieldContent?: string;
+    /**
+     * An optional list of possible affixes that can be shown in addition to the shieldContent.
+     */
+    affixes: string[];
+};
+
+/**
+ * Section representing a road shield.
+ * @group Route
+ */
+export declare type RoadShieldSectionProps = SectionProps & {
+    /**
+     * The road shield code for this section.
+     */
+    roadShieldReferences: RoadShieldReference[];
+};
+
+/**
+ * GeoJSON Feature representing a calculated route.
+ *
+ * The geometry is a LineString containing the route path coordinates.
+ * The properties contain all route information (summary, sections, guidance).
+ *
+ * @typeParam P - Type of the route properties (defaults to RouteProps)
+ *
+ * @example
+ * ```typescript
+ * const route: Route = {
+ *   type: 'Feature',
+ *   geometry: {
+ *     type: 'LineString',
+ *     coordinates: [[4.9, 52.3], [4.91, 52.31], ...]
+ *   },
+ *   properties: {
+ *     id: 'route-123',
+ *     summary: { lengthInMeters: 5000, travelTimeInSeconds: 300, ... },
+ *     sections: { ... },
+ *     index: 0
+ *   }
+ * };
+ * ```
+ *
+ * @group Route
+ */
+export declare type Route<P extends RouteProps = RouteProps> = Feature<LineString, P>;
+
+/**
+ * Route path point and its metadata.
+ * @group Route
+ */
+export declare type RoutePathPoint = {
+    point: Position;
+    /**
+     * Distance (in meters) from the start of the route to this point.
+     */
+    distanceInMeters: number;
+    /**
+     * The time (in seconds) from the start of the route to this point.
+     */
+    travelTimeInSeconds: number;
+};
+
+/**
+ * Generic geographic input for route planning.
+ *
+ * Can be either a waypoint (point location) or a path (line to follow).
+ * This flexible type allows mixing different input types in route calculations.
+ *
+ * @remarks
+ * - Use waypoints for origin, destination, and intermediate stops
+ * - Use paths for route reconstruction or to force the route along specific roads
+ *
+ * @example
+ * ```typescript
+ * const locations: RoutePlanningLocation[] = [
+ *   [4.9, 52.3],                    // Start waypoint
+ *   { radiusMeters: 1000, ... },    // Circle waypoint
+ *   existingPathCoordinates,        // Path to follow
+ *   [5.0, 52.4]                     // End waypoint
+ * ];
+ * ```
+ *
+ * @group Route
+ */
+export declare type RoutePlanningLocation = WaypointLike | PathLike;
+
+/**
+ * Classification of a RoutePlanningLocation by its type.
+ *
+ * Used internally to distinguish between waypoint and path inputs.
+ *
+ * @remarks
+ * - `waypoint`: Represents a single point location (WaypointLike)
+ * - `path`: Represents a path or route to follow (PathLike)
+ *
+ * @group Route
+ */
+export declare type RoutePlanningLocationType = 'waypoint' | 'path';
+
+/**
+ * Array of progress points along the route path.
+ *
+ * Provides distance and time information at key points along the route.
+ * This field is included when `extendedRouteRepresentations` is requested.
+ *
+ * @remarks
+ * - Always contains entries for the first and last points in the route
+ * - Progress for intermediate points can be linearly interpolated between explicitly defined points
+ * - Use the Haversine formula for distance calculations between points
+ *
+ * @example
+ * ```typescript
+ * const progress: RouteProgress = [
+ *   { pointIndex: 0, travelTimeInSeconds: 0, distanceInMeters: 0 },
+ *   { pointIndex: 50, travelTimeInSeconds: 120, distanceInMeters: 2500 },
+ *   { pointIndex: 100, travelTimeInSeconds: 300, distanceInMeters: 5000 }
+ * ];
+ * ```
+ *
+ * @group Route
+ */
+export declare type RouteProgress = RouteProgressPoint[];
+
+/**
+ * Progress information for a specific point along the route.
+ *
+ * Contains cumulative distance and time measurements from the route start to this point.
+ *
+ * @group Route
+ */
+export declare type RouteProgressPoint = {
+    /**
+     * Zero-based index of this point in the route's coordinate array.
+     */
+    pointIndex: number;
+    /**
+     * Cumulative travel time in seconds from the route start to this point.
+     */
+    travelTimeInSeconds?: number;
+    /**
+     * Cumulative distance in meters from the route start to this point.
+     */
+    distanceInMeters?: number;
+};
+
+/**
+ * Properties object for a calculated route.
+ *
+ * Contains all route information including summary statistics, sections,
+ * guidance instructions, and progress data.
+ *
+ * @group Route
+ */
+export declare type RouteProps = {
+    /**
+     * Unique identifier for this route.
+     *
+     * Randomly generated to distinguish between multiple route alternatives.
+     */
+    id: string;
+    /**
+     * Summary statistics for the entire route.
+     *
+     * Contains departure/arrival times, total length, duration, and consumption estimates.
+     */
+    summary: RouteSummary;
+    /**
+     * Route sections with specific characteristics.
+     *
+     * Sections represent portions of the route with distinct properties such as:
+     * - Countries traversed
+     * - Traffic incidents
+     * - Route legs (segments between waypoints)
+     * - Special road types (tunnels, ferries, toll roads)
+     */
+    sections: SectionsProps;
+    /**
+     * Turn-by-turn navigation instructions.
+     *
+     * Only present when guidance was requested and is available.
+     * Includes maneuvers, road names, and instruction text.
+     */
+    guidance?: Guidance;
+    /**
+     * Distance and time progress at key points along the route.
+     *
+     * Only present when extended route representations are requested.
+     * Useful for displaying progress information or calculating intermediate times.
+     */
+    progress?: RouteProgress;
+    /**
+     * Index of this route in the collection of alternatives.
+     *
+     * The first route (index 0) is typically the recommended/best route.
+     * Subsequent indices represent alternative routes.
+     */
+    index: number;
+};
+
+/**
+ * GeoJSON FeatureCollection containing one or more calculated routes.
+ *
+ * Typically contains the main route (index 0) and optional alternative routes.
+ * Collection properties can include metadata about the routing request.
+ *
+ * @typeParam P - Type of individual route properties (defaults to RouteProps)
+ * @typeParam FeatureCollectionProps - Type of collection-level properties
+ *
+ * @example
+ * ```typescript
+ * const routes: Routes = {
+ *   type: 'FeatureCollection',
+ *   features: [
+ *     { type: 'Feature', geometry: {...}, properties: { index: 0, ... } }, // Main route
+ *     { type: 'Feature', geometry: {...}, properties: { index: 1, ... } }  // Alternative
+ *   ],
+ *   properties: {
+ *     requestId: 'req-456',
+ *     calculatedAt: new Date()
+ *   }
+ * };
+ * ```
+ *
+ * @group Route
+ */
+export declare type Routes<P extends RouteProps = RouteProps, FeatureCollectionProps = unknown> = FeatureCollectionWithProperties<LineString, P, FeatureCollectionProps>;
+
+/**
+ * Complete summary information for an entire route.
+ *
+ * Includes all journey statistics from origin to destination, including
+ * any intermediate charging stops for electric vehicles.
+ *
+ * @group Route
+ */
+export declare type RouteSummary = SummaryWithConsumption & {
+    /**
+     * Total time in seconds spent at all charging stops during the route.
+     *
+     * @remarks
+     * - Only present for electric vehicle routes with charging stops (LDEVR)
+     * - The route's travelTimeInSeconds includes this charging time
+     * - To get driving time only: travelTimeInSeconds - totalChargingTimeInSeconds
+     *
+     * @example
+     * ```typescript
+     * // Route with 2 charging stops of 20 and 25 minutes
+     * totalChargingTimeInSeconds: 2700  // 45 minutes total
+     * ```
+     */
+    totalChargingTimeInSeconds?: number;
+};
+
+/**
+ * Properties for search result places.
+ *
+ * Extends common place properties with search-specific information
+ * like relevance scores and distances.
+ *
+ * @group Place
+ */
+export declare type SearchPlaceProps = CommonPlaceProps & {
+    /**
+     * Information about the original data source.
+     *
+     * Attribution or source identification for the result.
+     */
+    info?: string;
+    /**
+     * Relevance score for this search result.
+     *
+     * Higher scores indicate better match to the query criteria.
+     * Used for ranking search results.
+     */
+    score?: number;
+    /**
+     * Distance in meters to this result from the bias position.
+     *
+     * Present only when geoBias (position bias) was provided in the search.
+     */
+    distance?: number;
+};
+
+/**
+ * Base properties for all route sections.
+ *
+ * Sections divide a route into portions with specific characteristics or attributes.
+ * All section types extend this base with additional specialized properties.
+ *
+ * @group Route
+ */
+export declare type SectionProps = {
+    /**
+     * Unique identifier for this section.
+     *
+     * Randomly generated to distinguish between sections.
+     */
+    id: string;
+    /**
+     * Index of the route coordinate where this section begins.
+     *
+     * Zero-based index into the route's LineString coordinates array.
+     */
+    startPointIndex: number;
+    /**
+     * Index of the route coordinate where this section ends (inclusive).
+     *
+     * Zero-based index into the route's LineString coordinates array.
+     */
+    endPointIndex: number;
+    /**
+     * Elapsed time in seconds from route start to the beginning of this section.
+     */
+    startTravelTimeInSeconds?: number;
+    /**
+     * Elapsed time in seconds from route start to the end of this section.
+     */
+    endTravelTimeInSeconds?: number;
+    /**
+     * Duration in seconds to traverse this section.
+     *
+     * Calculated as: endTravelTimeInSeconds - startTravelTimeInSeconds
+     */
+    durationInSeconds?: number;
+    /**
+     * Cumulative distance in meters from route start to the beginning of this section.
+     */
+    startLengthInMeters?: number;
+    /**
+     * Cumulative distance in meters from route start to the end of this section.
+     */
+    endLengthInMeters?: number;
+    /**
+     * Length in meters of this section.
+     *
+     * Calculated as: endLengthInMeters - startLengthInMeters
+     */
+    lengthInMeters?: number;
+};
+
+/**
+ * Route sections are parts of the planned route that have specific characteristics,
+ * such as ones on a ferry or motorway, or sections with traffic incidents in them.
+ * Using sections, you can show users where these things lie on a planned route.
+ * @group Route
+ */
+export declare type SectionsProps = {
+    leg: LegSectionProps[];
+    carTrain?: SectionProps[];
+    ferry?: SectionProps[];
+    motorway?: SectionProps[];
+    pedestrian?: SectionProps[];
+    toll?: SectionProps[];
+    tollVignette?: CountrySectionProps[];
+    country?: CountrySectionProps[];
+    traffic?: TrafficSectionProps[];
+    vehicleRestricted?: SectionProps[];
+    tunnel?: SectionProps[];
+    unpaved?: SectionProps[];
+    urban?: SectionProps[];
+    carpool?: SectionProps[];
+    lowEmissionZone?: SectionProps[];
+    lanes?: LaneSectionProps[];
+    roadShields?: RoadShieldSectionProps[];
+    speedLimit?: SpeedLimitSectionProps[];
+    importantRoadStretch?: ImportantRoadStretchProps[];
+};
+
+/**
+ * @group Route
+ */
+export declare type SectionType = keyof SectionsProps;
+
+/**
+ * @group Route
+ */
+export declare const sectionTypes: SectionType[];
+
+/**
+ * Side of the street indicator.
+ *
+ * @remarks
+ * - `L`: Left side
+ * - `R`: Right side
+ *
+ * @group Place
+ */
+export declare type SideOfStreet = 'L' | 'R';
+
+/**
+ * Side road information.
+ * @group Route
+ */
+export declare type SideRoad = {
+    /**
+     * Side from where the road connects to the route.
+     */
+    side: SideRoadSide;
+    /**
+     * Offset (on route) of the side road from the maneuver point (represented by maneuverPoint), in meters.
+     * The offset is absolute, i.e., it is a positive integer despite that the side road is located before the maneuver on the route.
+     */
+    offsetFromManeuverInMeters: number;
+};
+
+/**
+ * Side from where the road connects to the route.
+ * @group Route
+ */
+export declare type SideRoadSide = 'LEFT' | 'RIGHT' | 'LEFT_AND_RIGHT';
+
+/**
+ * Signpost information.
+ * @group Route
+ */
+export declare type Signpost = {
+    /**
+     * Exit name of the controlled access road.
+     * Included if an exit name is available for this signpost.
+     */
+    exitName?: TextWithPhonetics;
+    /**
+     * Exit number of the controlled access road. Included if an exit number is available for this signpost.
+     * Multiple exit numbers can be encoded in the string, e.g. "E10/E12". If exit number is not available, the field will be absent.
+     */
+    exitNumber?: TextWithPhonetics;
+    /**
+     * The toward name from the signpost.
+     */
+    towardName: TextWithPhonetics;
+};
+
+/**
+ * Section representing a speed limit.
+ * @group Route
+ */
+export declare type SpeedLimitSectionProps = SectionProps & {
+    /**
+     * The speed limit in km/h for this section.
+     */
+    maxSpeedLimitInKmh: number;
+};
+
+/**
+ * Common summary type for a route or route leg.
+ * Contains departure/arrival times, lengths and durations.
+ * @group Route
+ */
+export declare type SummaryBase = {
+    /**
+     * Estimated arrival time at the end of the route or leg.
+     *
+     * Calculated from departure time plus travel time, accounting for traffic conditions.
+     */
+    arrivalTime: Date;
+    /**
+     * Departure time from the beginning of the route or leg.
+     *
+     * Based on the departure time specified in the routing request.
+     */
+    departureTime: Date;
+    /**
+     * Total length of the route or leg in meters.
+     */
+    lengthInMeters: number;
+    /**
+     * Estimated travel time in seconds for the route or leg.
+     *
+     * @remarks
+     * This value includes delays due to real-time traffic, even when considerTraffic=false.
+     * Use noTrafficTravelTimeInSeconds for free-flow travel time without traffic delays.
+     */
+    travelTimeInSeconds: number;
+    /**
+     * Additional delay in seconds caused by current traffic conditions.
+     *
+     * Represents the extra time compared to free-flow conditions.
+     * A value of 0 means no traffic delays.
+     */
+    trafficDelayInSeconds: number;
+    /**
+     * Length in meters of the route affected by traffic events causing delays.
+     *
+     * Indicates the portion of the route experiencing congestion or incidents.
+     */
+    trafficLengthInMeters: number;
+    /**
+     * Estimated travel time in seconds assuming free-flow conditions.
+     *
+     * Calculated as if there were no traffic delays (no congestion).
+     * Only included if requested using the computeTravelTimeFor parameter.
+     */
+    noTrafficTravelTimeInSeconds?: number;
+    /**
+     * Estimated travel time in seconds using time-dependent historic traffic data.
+     *
+     * Represents the expected travel time based on typical traffic patterns
+     * for the requested departure time (e.g., rush hour vs off-peak).
+     * Only included if requested using the computeTravelTimeFor parameter.
+     */
+    historicTrafficTravelTimeInSeconds?: number;
+    /**
+     * Estimated travel time in seconds using real-time traffic speed data.
+     *
+     * Based on current live traffic conditions and incidents.
+     * Only included if requested using the computeTravelTimeFor parameter.
+     */
+    liveTrafficIncidentsTravelTimeInSeconds?: number;
+};
+
+/**
+ * Combined summary supporting both combustion and electric vehicle metrics.
+ *
+ * @group Route
+ */
+export declare type SummaryWithConsumption = CombustionSummary & ElectricSummary;
+
+/**
+ * Text with phonetic transcription.
+ * @group Route
+ */
+export declare type TextWithPhonetics = {
+    /**
+     * The name as a text string.
+     */
+    text: string;
+    /**
+     * The phonetic transcription of the name.
+     * Included if phonetic transcription is available for the specific name, and phonetic transcriptions have been requested by the client.
+     * Note: The phonetic transcription can contain double quote characters ("). In this case those characters are escaped with a backslash (\).
+     */
+    phonetic: string;
+    /**
+     * Encodes the language using an IETF language tag, e.g., en-GB, en-US.
+     */
+    phoneticLanguageCode: string;
+};
+
+/**
+ * Configuration for displaying time-based units.
+ *
+ * Allows customization of time unit labels used for durations
+ * throughout the SDK.
+ *
+ * @group Configuration
+ */
+export declare type TimeDisplayUnits = {
+    /**
+     * Custom label for hour units.
+     *
+     * @default "h"
+     */
+    hours?: string;
+    /**
+     * Custom label for minute units.
+     *
+     * @default "min"
+     */
+    minutes?: string;
+};
+
+/**
+ * Time range with start and end moments.
+ *
+ * Represents a period when a POI is open. Can span multiple days
+ * (e.g., opening late one day and closing early the next).
+ *
+ * @remarks
+ * - For same-day hours: start and end are on the same date
+ * - For overnight hours: end date is after start date (e.g., open until 2 AM)
+ *
+ * @example
+ * ```typescript
+ * // Monday 9:00 AM to 5:00 PM
+ * const timeRange: TimeRange = {
+ *   start: { date: new Date('2025-10-20T09:00:00'), hour: 9, minute: 0, ... },
+ *   end: { date: new Date('2025-10-20T17:00:00'), hour: 17, minute: 0, ... }
+ * };
+ *
+ * // Friday 10 PM to Saturday 2 AM (overnight)
+ * const overnight: TimeRange = {
+ *   start: { date: new Date('2025-10-24T22:00:00'), hour: 22, ... },
+ *   end: { date: new Date('2025-10-25T02:00:00'), hour: 2, ... }
+ * };
+ * ```
+ *
+ * @group Place
+ */
+export declare type TimeRange = {
+    /**
+     * Opening time for this period.
+     */
+    start: Moment;
+    /**
+     * Closing time for this period.
+     */
+    end: Moment;
+};
+
+/**
+ * Time zone information using IANA Time Zone Database identifiers.
+ *
+ * @remarks
+ * IANA identifiers follow the format `Area/Location` (e.g., `America/New_York`, `Europe/London`).
+ * These are standardized time zone identifiers maintained by the Internet Assigned Numbers Authority.
+ *
+ * @see [IANA Time Zone Database](https://www.iana.org/time-zones)
+ *
+ * @example
+ * ```typescript
+ * const timezone: TimeZone = {
+ *   ianaId: 'Europe/Amsterdam'
+ * };
+ * ```
+ *
+ * @group Shared
+ */
+export declare type TimeZone = {
+    /**
+     * IANA Time Zone Database identifier.
+     *
+     * Examples: `America/New_York`, `Europe/London`, `Asia/Tokyo`
+     */
+    ianaId: string;
+};
+
+/**
+ * Available toll payment options.
+ * @group Route
+ */
+export declare type TollPaymentType = 'CASH_COINS_AND_BILLS' | 'CASH_BILLS_ONLY' | 'CASH_COINS_ONLY' | 'CASH_EXACT_CHANGE' | 'CREDIT_CARD' | 'DEBIT_CARD' | 'TRAVEL_CARD' | 'ETC' | 'ETC_TRANSPONDER' | 'ETC_VIDEO_CAMERA' | 'SUBSCRIPTION';
+
+/**
+ * SDK name used TomTom custom header TomTom-User-Agent
+ * @ignore
+ */
+export declare const TOMTOM_USER_AGENT_SDK_NAME = "TomTomSDKsMapsJS";
+
+/**
+ * Global configuration singleton for the TomTom Maps SDK.
+ *
+ * Manages SDK-wide configuration settings that apply to all services and maps.
+ * Uses the singleton pattern to ensure consistent configuration across the application.
+ *
+ * @remarks
+ * Configuration set via this class is merged with service-specific parameters,
+ * with service parameters taking precedence over global settings.
+ *
+ * @example
+ * ```typescript
+ * // Set global configuration
+ * TomTomConfig.instance.put({
+ *   apiKey: 'your-api-key',
+ *   language: 'en-US'
+ * });
+ *
+ * // Get current configuration
+ * const config = TomTomConfig.instance.get();
+ *
+ * // Reset to defaults
+ * TomTomConfig.instance.reset();
+ * ```
+ *
+ * @group Configuration
+ */
+export declare class TomTomConfig {
+    /**
+     * Singleton instance of the configuration.
+     */
+    static readonly instance: TomTomConfig;
+    private config;
+    private constructor();
+    /**
+     * Merge configuration values into the global configuration.
+     *
+     * New values override existing ones. This performs a shallow merge,
+     * so nested objects are replaced entirely rather than merged.
+     *
+     * @param config - Partial configuration to merge
+     *
+     * @example
+     * ```typescript
+     * TomTomConfig.instance.put({
+     *   apiKey: 'your-api-key',
+     *   language: 'de-DE'
+     * });
+     * ```
+     */
+    put(config: Partial<GlobalConfig>): void;
+    /**
+     * Reset configuration to default values.
+     *
+     * Clears all custom configuration and restores the initial defaults.
+     * Note that the default API key is an empty string.
+     *
+     * @example
+     * ```typescript
+     * TomTomConfig.instance.reset();
+     * ```
+     */
+    reset(): void;
+    /**
+     * Get the current global configuration.
+     *
+     * @returns Current configuration object
+     *
+     * @example
+     * ```typescript
+     * const config = TomTomConfig.instance.get();
+     * console.log(config.apiKey);
+     * ```
+     */
+    get(): GlobalConfig;
+}
+
+/**
+ * Interface for TomTom custom headers
+ * Those headers are added in every request to TomTom services
+ * * TomTom-User-Agent - Name and version of this SDK
+ * * Authorization - Bearer token for experimental OAuth2 support.
+ * Based on the apiAccessToken parameter.
+ * Tracking-ID - @see https://docs.tomtom.com/search-api/documentation/search-service/fuzzy-search#trackingid-request
+ * @ignore
+ */
+export declare type TomTomHeaders = {
+    'TomTom-User-Agent'?: string;
+    Authorization?: string;
+    'Tracking-ID'?: string;
+};
+
+/**
+ * @ignore
+ * @param lngLat
+ */
+export declare const toPointFeature: (lngLat: Position) => Feature<Point>;
+
+/**
+ * Simple category classification for traffic incidents.
+ *
+ * @remarks
+ * - `jam`: Traffic congestion or slow-moving traffic
+ * - `road_work`: Construction or maintenance work
+ * - `road_closure`: Road is closed or blocked
+ * - `other`: Other types of incidents
+ *
+ * @group Route
+ */
+export declare type TrafficCategory = 'jam' | 'road_work' | 'road_closure' | 'other';
+
+/**
+ * Traffic incident information based on TPEG2-TEC standard.
+ *
+ * Provides standardized classification of traffic flow effects and causes.
+ *
+ * @group Route
+ */
+export declare type TrafficIncidentTEC = {
+    /**
+     * Effect code describing impact on traffic flow.
+     *
+     * TPEG2-TEC standard code indicating how traffic is affected.
+     */
+    effectCode: number;
+    /**
+     * List of causes for this traffic incident.
+     *
+     * Array of cause elements with at least one entry. Multiple causes
+     * may contribute to a single traffic incident.
+     */
+    causes?: [CauseTEC, ...CauseTEC[]];
+};
+
+/**
+ * Route section affected by a traffic incident.
+ *
+ * Represents a portion of the route experiencing traffic delays due to
+ * congestion, accidents, construction, or other incidents.
+ *
+ * @example
+ * ```typescript
+ * const trafficSection: TrafficSectionProps = {
+ *   id: 'traffic-1',
+ *   startPointIndex: 50,
+ *   endPointIndex: 75,
+ *   simpleCategory: 'jam',
+ *   magnitudeOfDelay: 'moderate',
+ *   delayInSeconds: 420,  // 7 minutes
+ *   effectiveSpeedInKmh: 25,
+ *   tec: { effectCode: 1, causes: [{ mainCauseCode: 101 }] }
+ * };
+ * ```
+ *
+ * @group Route
+ */
+export declare type TrafficSectionProps = SectionProps & {
+    /**
+     * Simple category classification of the incident.
+     */
+    simpleCategory: TrafficCategory;
+    /**
+     * Severity level of the delay caused by this incident.
+     */
+    magnitudeOfDelay: DelayMagnitude;
+    /**
+     * TPEG2-TEC standardized incident information.
+     *
+     * Provides internationally standardized codes for traffic incident classification.
+     */
+    tec: TrafficIncidentTEC;
+    /**
+     * Actual average speed through this incident in km/h.
+     *
+     * Present when speed information is available. Lower speeds indicate worse congestion.
+     */
+    effectiveSpeedInKmh?: number;
+    /**
+     * Additional delay in seconds caused by this incident.
+     *
+     * Extra time compared to free-flow conditions. Present when delay can be calculated.
+     */
+    delayInSeconds?: number;
+};
+
+/**
+ * Primary mode of transportation for route calculation.
+ *
+ * Currently only `'car'` is supported. This determines road type preferences,
+ * speed calculations, and routing rules applied to the calculated route.
+ *
+ * @remarks
+ * Future versions may support additional modes like truck, taxi, bus, bicycle, and pedestrian.
+ *
+ * @example
+ * ```typescript
+ * const travelMode: TravelMode = 'car';
+ * ```
+ *
+ * @group Route
+ */
+export declare type TravelMode = 'car';
+
+/**
+ * Geopolitical view context for map display and data.
+ *
+ * Controls how disputed territories and borders are displayed on the map and in service responses.
+ * Different countries may have different perspectives on territorial boundaries and place names.
+ *
+ * @remarks
+ * - `Unified`: Default view with a neutral representation
+ * - Country-specific codes (e.g., `AR`, `IN`, `PK`, etc.): Displays boundaries and names according to that country's perspective
+ *
+ * @example
+ * ```typescript
+ * // Use unified/neutral view
+ * const view: View = 'Unified';
+ *
+ * // Use India's geopolitical perspective
+ * const view: View = 'IN';
+ *
+ * // Use Argentina's perspective
+ * const view: View = 'AR';
+ * ```
+ *
+ * @group Shared
+ */
+export declare type View = (typeof views)[number];
+
+/**
+ * List of available views for geopolitical context.
+ * @group Shared
+ */
+export declare const views: readonly ["Unified", "AR", "IN", "PK", "IL", "MA", "RU", "TR", "CN"];
+
+/**
+ * GeoJSON Feature representing a route waypoint.
+ *
+ * Waypoints are points that define the route path. The route will pass through each waypoint
+ * in the order they are specified.
+ *
+ * @typeParam T - Additional custom properties beyond the standard waypoint properties
+ *
+ * @remarks
+ * - Regular waypoints (without radius) create route legs and generate arrival instructions
+ * - Circle waypoints (with radiusMeters) shape the route without creating legs
+ *
+ * @example
+ * ```typescript
+ * // Regular waypoint
+ * const waypoint: Waypoint = {
+ *   type: 'Feature',
+ *   geometry: { type: 'Point', coordinates: [4.9041, 52.3676] },
+ *   properties: {}
+ * };
+ *
+ * // Circle waypoint with custom properties
+ * const circleWaypoint: Waypoint<{ name: string }> = {
+ *   type: 'Feature',
+ *   geometry: { type: 'Point', coordinates: [4.9041, 52.3676] },
+ *   properties: { radiusMeters: 1000, name: 'Via Amsterdam' }
+ * };
+ * ```
+ *
+ * @group Route
+ */
+export declare type Waypoint<T extends Anything = Anything> = Feature<Point, WaypointProps & T>;
+
+/**
+ * Flexible input type for specifying a waypoint location.
+ *
+ * Accepts various formats for convenience:
+ * - Full `Waypoint` Feature (for circle waypoints or waypoints with custom properties)
+ * - Any object with coordinates (Position array, Point geometry, or Feature)
+ *
+ * @remarks
+ * Waypoints are single points by default. To create a circle (soft) waypoint,
+ * use the full Waypoint Feature format with a radiusMeters property.
+ *
+ * @example
+ * ```typescript
+ * // As coordinate array
+ * const wp1: WaypointLike = [4.9041, 52.3676];
+ *
+ * // As Point geometry
+ * const wp2: WaypointLike = { type: 'Point', coordinates: [4.9041, 52.3676] };
+ *
+ * // As full Waypoint Feature with radius
+ * const wp3: WaypointLike = {
+ *   type: 'Feature',
+ *   geometry: { type: 'Point', coordinates: [4.9041, 52.3676] },
+ *   properties: { radiusMeters: 500 }
+ * };
+ * ```
+ *
+ * @group Route
+ */
+export declare type WaypointLike = Waypoint | HasLngLat;
+
+/**
+ * Properties specific to route waypoints.
+ *
+ * @group Route
+ */
+export declare type WaypointProps = {
+    /**
+     * Radius in meters defining a circle (soft) waypoint.
+     *
+     * When specified, the waypoint becomes a circle waypoint that shapes the route without
+     * generating explicit navigation instructions or creating an additional route leg.
+     *
+     * @remarks
+     * - Circle waypoints influence the route path while providing flexibility to the routing engine
+     * - Larger radius values give more freedom for route optimization
+     * - Smaller radius values force the route to pass closer to the specified point
+     * - Unlike regular waypoints, circle waypoints don't create legs or generate "arrive at waypoint" instructions
+     * - Useful for shaping routes through general areas rather than specific points
+     *
+     * Must be a positive integer with a maximum value of 135000.
+     *
+     * @example
+     * ```typescript
+     * // Circle waypoint with 1km radius - route will pass somewhere within this area
+     * { radiusMeters: 1000 }
+     *
+     * // Small radius - route will pass very close to this point
+     * { radiusMeters: 50 }
+     * ```
+     */
+    radiusMeters?: number;
+};
+
+/**
+ * GeoJSON FeatureCollection of waypoints.
+ *
+ * Contains multiple waypoints that together define a multi-stop route.
+ *
+ * @typeParam T - Additional custom properties for individual waypoints
+ *
+ * @example
+ * ```typescript
+ * const waypoints: Waypoints = {
+ *   type: 'FeatureCollection',
+ *   features: [
+ *     { type: 'Feature', geometry: { type: 'Point', coordinates: [4.9, 52.3] }, properties: {} },
+ *     { type: 'Feature', geometry: { type: 'Point', coordinates: [4.95, 52.35] }, properties: {} }
+ *   ]
+ * };
+ * ```
+ *
+ * @group Route
+ */
+export declare type Waypoints<T extends Anything = Anything> = FeatureCollection<Point, WaypointProps & T>;
+
+export { }