@tomtom-org/maps-sdk-plugin-agent-toolkit 0.2.2

package/dist/index.d.ts

@@ -0,0 +1,4428 @@
+import { $strip } from 'zod/v4/core';
+import { BaseMapModule } from '../../map/dist';
+import { BBox } from '../../../../core/dist';
+import { ColorArraySpecification } from 'maplibre-gl';
+import { ColorSpecification } from 'maplibre-gl';
+import { DataDrivenPropertyValueSpecification } from 'maplibre-gl';
+import { ExpressionSpecification } from 'maplibre-gl';
+import { FormattedSpecification } from 'maplibre-gl';
+import { GeometriesModule } from '../../map/dist';
+import { GeometryTheme } from '../../map/dist';
+import { HillshadeModule } from '../../map/dist';
+import { LanguageModel } from 'ai';
+import { Map as Map_2 } from 'maplibre-gl';
+import { ModelMessage } from 'ai';
+import { NumberArraySpecification } from 'maplibre-gl';
+import { PaddingSpecification } from 'maplibre-gl';
+import { Place } from '../../core/dist';
+import { Places } from '../../core/dist';
+import { PlacesModule } from '../../map/dist';
+import { PlanningWaypoint } from '../../map/dist';
+import { POIsModule } from '../../map/dist';
+import { PolygonFeatures } from '../../core/dist';
+import { Position } from 'geojson';
+import { PrepareStepFunction } from 'ai';
+import { PropertyValueSpecification } from 'maplibre-gl';
+import { ReachableRangeBudget } from '../../services/dist';
+import { ResolvedImageSpecification } from 'maplibre-gl';
+import { Routes } from '../../core/dist';
+import { RoutingModule } from '../../map/dist';
+import { TomTomMap } from '../../map/dist';
+import { ToolLoopAgent } from 'ai';
+import { TrafficAreaAnalytics } from '../../core/dist';
+import { TrafficAreaAnalyticsConfig } from '../../map/dist';
+import { TrafficAreaAnalyticsModule } from '../../map/dist';
+import { TrafficFlowModule } from '../../map/dist';
+import { TrafficIncidentsModule } from '../../map/dist';
+import { TransitionSpecification } from 'maplibre-gl';
+import { VariableAnchorOffsetCollectionSpecification } from 'maplibre-gl';
+import { VisibilitySpecification } from 'maplibre-gl';
+import { WaypointLike } from '../../core/dist';
+import { z } from 'zod';
+import { ZodAny } from 'zod';
+import { ZodArray } from 'zod';
+import { ZodBoolean } from 'zod';
+import { ZodDate } from 'zod';
+import { ZodEnum } from 'zod';
+import { ZodLiteral } from 'zod';
+import { ZodNumber } from 'zod';
+import { ZodObject } from 'zod';
+import { ZodOptional } from 'zod';
+import { ZodReadonly } from 'zod';
+import { ZodRecord } from 'zod';
+import { ZodString } from 'zod';
+import { ZodTuple } from 'zod';
+import { ZodUnion } from 'zod';
+import { ZodUnknown } from 'zod';
+
+/** Output schema for the add-stop-to-route tool. */
+declare const addStopToRouteOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    count: z.ZodNumber;
+    routes: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        summary: z.ZodObject<{
+            travelTimeInSeconds: z.ZodNumber;
+            lengthInMeters: z.ZodNumber;
+            trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
+            trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
+            departureTime: z.ZodOptional<z.ZodString>;
+            arrivalTime: z.ZodOptional<z.ZodString>;
+            noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        legSummaries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            travelTimeInSeconds: z.ZodNumber;
+            lengthInMeters: z.ZodNumber;
+            trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
+            trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
+            departureTime: z.ZodOptional<z.ZodString>;
+            arrivalTime: z.ZodOptional<z.ZodString>;
+            noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/**
+ * Tool schema for adding a stop to existing route.
+ */
+declare const addStopToRouteSchema: z.ZodObject<{
+    location: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        query: z.ZodString;
+        locationType: z.ZodEnum<{
+            default: "default";
+            poi: "poi";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        position: z.ZodObject<{
+            lng: z.ZodNumber;
+            lat: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>>;
+    showOnMap: z.ZodBoolean;
+}, z.core.$strip>;
+
+/**
+ * The base system prompt that teaches the LLM how to use the agent toolkit tools.
+ *
+ * @remarks
+ * Export this constant so consumers can reference or extend it when providing
+ * a custom system prompt via `MapAgentOptions.systemPrompt`.
+ *
+ * @example
+ * ```typescript
+ * import { createMapAgent, BASE_SYSTEM_PROMPT } from '@tomtom-org/maps-sdk-plugin-agent-toolkit';
+ *
+ * const agent = createMapAgent(map, {
+ *   model: openai('gpt-4o'),
+ *   systemPrompt: BASE_SYSTEM_PROMPT + '\n\nAlways respond in Spanish.'
+ * });
+ * ```
+ *
+ * @group System Prompt
+ */
+export declare const BASE_SYSTEM_PROMPT = "You are a helpful map assistant with access to a TomTom interactive map and location services.\n\nCOORDINATE ORDER:\n- All coordinates are [longitude, latitude] (GeoJSON standard)\n- All bounding boxes are [minLng, minLat, maxLng, maxLat]\n\nTOOL EXECUTION:\n- Call context-independent tools in the same step (parallel execution).\n- Many service tools have a show or showOnMap parameter \u2014 use it to display results on the map in one step instead of calling a separate show tool afterward.\n- Use standalone showPlaces / showRoute / showWaypoints only when displaying results already in context from a previous step.\n\nLOCATION REFERENCE:\n- \"near me\" / \"my location\" / \"where I am\" \u2192 getCurrentLocation (user's physical GPS position, may prompt permission)\n- \"in this area\" / \"here on the map\" / \"near the map center\" \u2192 getViewport (map's current view)\n- If getCurrentLocation fails due to permission denial, fall back to getViewport as the reference point\n\nRESPONSE FORMATTING:\n- Use markdown in all responses\n- Show key information in bold\n- Use bullet lists when presenting multiple items or results\n- Keep responses concise \u2014 lead with the most relevant information\n\n";
+
+/**
+ * State for base map display: style, language, viewport, layers, and hillshade.
+ *
+ * Provides direct access to the TomTomMap and MapLibre instances alongside
+ * lazy-initialized BaseMapModule and HillshadeModule.
+ */
+declare class BaseMapState implements StateSlice {
+    readonly ttMap: TomTomMap;
+    private _baseMapModule?;
+    private _hillshadeModule?;
+    constructor(ttMap: TomTomMap);
+    get mapLibreMap(): Map_2;
+    getBaseMapModule(): Promise<BaseMapModule>;
+    getHillshadeModule(): Promise<HillshadeModule>;
+    reset(): void;
+}
+
+/* Excluded from this release type: buildSystemPrompt */
+
+/**
+ * Tool schema for calculating a bounding box from GeoJSON.
+ */
+declare const calculateBBoxSchema: z.ZodObject<{
+    geoJson: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+}, z.core.$strip>;
+
+/** Result returned by {@link classifyUserIntent}. */
+export declare type ClassificationResult = {
+    /** Tool names selected by the classifier. */
+    activeToolNames: string[];
+    /** Wall-clock time in ms for the classification step only (not the agent response). */
+    timeMs: number;
+    /** Token usage for the classification LLM call. */
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+};
+
+/**
+ * A classifier function that selects which tools to activate for a user message.
+ * Return `null` to activate all tools (fail-open).
+ *
+ * @group Classifier
+ */
+export declare type Classifier = (context: ClassifierContext) => Promise<ClassificationResult | null>;
+
+/**
+ * Context passed to a classifier function.
+ *
+ * @group Classifier
+ */
+export declare type ClassifierContext = {
+    /** Full message history for the current conversation. */
+    messages: ReadonlyArray<ModelMessage>;
+    /** Metadata for all registered tools. */
+    toolsMetadata: Record<string, ToolMetadata>;
+};
+
+/** Options passed to {@link classifyUserIntent}. */
+declare type ClassifierOptions = {
+    /**
+     * Language model to use for structured generation.
+     * Ideally should be a fast, low-cost model (e.g. gpt-4o-mini).
+     */
+    chatModel: LanguageModel;
+    /** Per-tool metadata used to build the classifier prompt. */
+    toolsMetadata: Record<string, ToolMetadata>;
+};
+
+/**
+ * Classify a user conversation to determine which tools to activate.
+ *
+ * The `conversation` should contain the last user message plus a compaction
+ * of the previous chat history (each truncated to save tokens).
+ *
+ * @example
+ * ```typescript
+ * const result = await classifyUserIntent(conversation, {
+ *   chatModel: openai('gpt-4o-mini'),
+ *   toolsMetadata,
+ * });
+ * // result.activeToolNames contains the selected tools
+ * ```
+ */
+export declare function classifyUserIntent(conversation: ConversationMessage[], options: ClassifierOptions): Promise<ClassificationResult>;
+
+/**
+ * Tool schema for clearing map features.
+ */
+declare const clearMapSchema: z.ZodObject<{
+    layers: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        routes: "routes";
+        places: "places";
+        geometries: "geometries";
+        analytics: "analytics";
+    }>>>;
+}, z.core.$strip>;
+
+/** A single turn in the conversation passed to {@link classifyUserIntent}. */
+declare type ConversationMessage = {
+    role: 'user' | 'assistant';
+    content: string;
+};
+
+/**
+ * Creates the default LLM-based classifier. Uses structured generation to select
+ * the minimal tool set for each user message.
+ *
+ * @param options.model - Language model for classification (ideally fast/cheap like gpt-4o-mini)
+ * @param options.maxHistoryMessages - Max prior turns for context. Default: 8
+ * @param options.maxHistoryMessageLength - Max chars per history message. Default: 300
+ */
+export declare function createDefaultClassifier(options: {
+    model: LanguageModel;
+    maxHistoryMessages?: number;
+    maxHistoryMessageLength?: number;
+}): Classifier;
+
+/**
+ * Creates a conversational agent toolkit that gives an LLM control over a TomTom map.
+ *
+ * Returns a ToolLoopAgent instance (compatible with DirectChatTransport) with
+ * `state` and `destroy` attached. Classification runs transparently inside
+ * `prepareStep` — no wrapper type needed.
+ *
+ * @param map - The TomTomMap instance to control
+ * @param options - Agent configuration options
+ * @returns A ToolLoopAgent with state access and cleanup
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { createMapAgent } from '@tomtom-org/maps-sdk-plugin-agent-toolkit';
+ * import { openai } from '@ai-sdk/openai';
+ * import { DirectChatTransport } from 'ai/react';
+ *
+ * const agent = createMapAgent(map, { model: openai('gpt-4o') });
+ *
+ * // Works directly with DirectChatTransport — no .agent property needed
+ * const { messages, sendMessage } = useChat({
+ *   transport: new DirectChatTransport({ agent }),
+ * });
+ * ```
+ *
+ * @example Custom tools + removal
+ * ```typescript
+ * const agent = createMapAgent(map, {
+ *   model: openai('gpt-4o'),
+ *   tools: {
+ *     getCustomLocation: myLocationTool,  // add custom
+ *     setLanguage: false,                 // remove default
+ *   },
+ * });
+ * ```
+ */
+export declare function createMapAgent<CS extends ToolState = ToolState>(map: TomTomMap, options: MapAgentOptions<CS>): MapAgentInstance<CS>;
+
+/**
+ * Factory that creates a fully initialized ToolState from a TomTomMap instance.
+ * Optionally merges custom state slices alongside built-in state.
+ *
+ * @param map - TomTomMap instance for module initialization
+ * @param customSlices - Additional state slices accessible by custom tools
+ */
+export declare function createToolState<T extends Record<string, unknown> = Record<string, never>>(map: TomTomMap, customSlices?: T): ToolState & T;
+
+/**
+ * Default tool set for the agent toolkit.
+ * Included automatically by createMapAgent unless includeDefaultTools is false.
+ * Use resolveTools() for manual composition outside createMapAgent.
+ */
+export declare const DEFAULT_TOOLS: {
+    locatePlace: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        query: ZodString;
+        waypointIndex: ZodOptional<ZodNumber>;
+        locationType: ZodEnum<    {
+        default: "default";
+        poi: "poi";
+        }>;
+        where: ZodUnion<readonly [ZodObject<    {
+        position: ZodArray<ZodNumber>;
+        }, $strip>, ZodObject<    {
+        boundingBox: ZodUnion<readonly [ZodUnion<readonly [ZodArray<ZodNumber>]>, ZodObject<    {
+        bbox: ZodUnion<readonly [ZodArray<ZodNumber>]>;
+        }, $strip>]>;
+        }, $strip>, ZodLiteral<"within-map-bounds">, ZodLiteral<"nearby-map-center">, ZodLiteral<"global">, ZodString]>;
+        show: ZodOptional<ZodObject<    {
+        markerType: ZodEnum<    {
+        pin: "pin";
+        none: "none";
+        }>;
+        zoomMode: ZodEnum<    {
+        none: "none";
+        auto: "auto";
+        }>;
+        }, $strip>>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        name: ZodOptional<ZodString>;
+        address: ZodOptional<ZodString>;
+        position: ZodArray<ZodNumber>;
+        waypointIndex: ZodOptional<ZodNumber>;
+        shown: ZodOptional<ZodObject<    {
+        markerType: ZodBoolean;
+        zoomMode: ZodBoolean;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeLocatePlace;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    reverseGeocode: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        position: ZodArray<ZodNumber>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        name: ZodOptional<ZodString>;
+        address: ZodOptional<ZodString>;
+        position: ZodArray<ZodNumber>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeReverseGeocode;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    discoverPlaces: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        query: ZodOptional<ZodString>;
+        where: ZodOptional<ZodUnion<readonly [ZodObject<    {
+        position: ZodArray<ZodNumber>;
+        }, $strip>, ZodObject<    {
+        boundingBox: ZodUnion<readonly [ZodUnion<readonly [ZodArray<ZodNumber>]>, ZodObject<    {
+        bbox: ZodUnion<readonly [ZodArray<ZodNumber>]>;
+        }, $strip>]>;
+        }, $strip>, ZodLiteral<"within-map-bounds">, ZodLiteral<"nearby-map-center">, ZodLiteral<"global">, ZodString]>>;
+        radiusMeters: ZodOptional<ZodNumber>;
+        limit: ZodOptional<ZodNumber>;
+        poiCategories: ZodOptional<ZodArray<ZodString>>;
+        show: ZodOptional<ZodObject<    {
+        markerType: ZodEnum<    {
+        pin: "pin";
+        none: "none";
+        }>;
+        zoomMode: ZodEnum<    {
+        none: "none";
+        auto: "auto";
+        }>;
+        }, $strip>>;
+        withinRange: ZodOptional<ZodString>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        count: ZodNumber;
+        features: ZodArray<ZodObject<    {
+        name: ZodOptional<ZodString>;
+        address: ZodOptional<ZodString>;
+        position: ZodArray<ZodNumber>;
+        }, $strip>>;
+        shown: ZodOptional<ZodObject<    {
+        markerType: ZodBoolean;
+        zoomMode: ZodBoolean;
+        }, $strip>>;
+        placeResultIndex: ZodOptional<ZodString>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeDiscoverPlaces;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    setRouteLocations: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        locations: ZodArray<ZodUnion<readonly [ZodObject<    {
+        query: ZodString;
+        locationType: ZodEnum<    {
+        default: "default";
+        poi: "poi";
+        }>;
+        }, $strip>, ZodObject<    {
+        position: ZodObject<    {
+        lng: ZodNumber;
+        lat: ZodNumber;
+        }, $strip>;
+        }, $strip>]>>;
+        showOnMap: ZodBoolean;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        count: ZodNumber;
+        routes: ZodArray<ZodObject<    {
+        index: ZodNumber;
+        summary: ZodObject<    {
+        travelTimeInSeconds: ZodNumber;
+        lengthInMeters: ZodNumber;
+        trafficDelayInSeconds: ZodOptional<ZodNumber>;
+        trafficLengthInMeters: ZodOptional<ZodNumber>;
+        departureTime: ZodOptional<ZodString>;
+        arrivalTime: ZodOptional<ZodString>;
+        noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        }, $strip>;
+        legSummaries: ZodOptional<ZodArray<ZodObject<    {
+        travelTimeInSeconds: ZodNumber;
+        lengthInMeters: ZodNumber;
+        trafficDelayInSeconds: ZodOptional<ZodNumber>;
+        trafficLengthInMeters: ZodOptional<ZodNumber>;
+        departureTime: ZodOptional<ZodString>;
+        arrivalTime: ZodOptional<ZodString>;
+        noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        }, $strip>>>;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeSetRouteLocations;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    setRouteParameters: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        maxAlternatives: ZodOptional<ZodNumber>;
+        costModel: ZodOptional<ZodObject<    {
+        routeType: ZodOptional<ZodEnum<    {
+        fast: "fast";
+        short: "short";
+        efficient: "efficient";
+        thrilling: "thrilling";
+        }>>;
+        traffic: ZodOptional<ZodEnum<    {
+        live: "live";
+        historical: "historical";
+        }>>;
+        avoid: ZodOptional<ZodArray<ZodEnum<    {
+        tollRoads: "tollRoads";
+        motorways: "motorways";
+        ferries: "ferries";
+        unpavedRoads: "unpavedRoads";
+        carpools: "carpools";
+        alreadyUsedRoads: "alreadyUsedRoads";
+        borderCrossings: "borderCrossings";
+        tunnels: "tunnels";
+        carTrains: "carTrains";
+        lowEmissionZones: "lowEmissionZones";
+        }>>>;
+        avoidAreas: ZodOptional<ZodArray<ZodArray<ZodNumber>>>;
+        }, $strip>>;
+        when: ZodOptional<ZodObject<    {
+        option: ZodEnum<    {
+        departAt: "departAt";
+        arriveBy: "arriveBy";
+        }>;
+        date: ZodString;
+        }, $strip>>;
+        showOnMap: ZodBoolean;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        count: ZodNumber;
+        routes: ZodArray<ZodObject<    {
+        index: ZodNumber;
+        summary: ZodObject<    {
+        travelTimeInSeconds: ZodNumber;
+        lengthInMeters: ZodNumber;
+        trafficDelayInSeconds: ZodOptional<ZodNumber>;
+        trafficLengthInMeters: ZodOptional<ZodNumber>;
+        departureTime: ZodOptional<ZodString>;
+        arrivalTime: ZodOptional<ZodString>;
+        noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        }, $strip>;
+        legSummaries: ZodOptional<ZodArray<ZodObject<    {
+        travelTimeInSeconds: ZodNumber;
+        lengthInMeters: ZodNumber;
+        trafficDelayInSeconds: ZodOptional<ZodNumber>;
+        trafficLengthInMeters: ZodOptional<ZodNumber>;
+        departureTime: ZodOptional<ZodString>;
+        arrivalTime: ZodOptional<ZodString>;
+        noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        }, $strip>>>;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        success: ZodLiteral<true>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeSetRouteParameters;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    addStopToRoute: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        location: ZodOptional<ZodUnion<readonly [ZodObject<    {
+        query: ZodString;
+        locationType: ZodEnum<    {
+        default: "default";
+        poi: "poi";
+        }>;
+        }, $strip>, ZodObject<    {
+        position: ZodObject<    {
+        lng: ZodNumber;
+        lat: ZodNumber;
+        }, $strip>;
+        }, $strip>]>>;
+        showOnMap: ZodBoolean;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        count: ZodNumber;
+        routes: ZodArray<ZodObject<    {
+        index: ZodNumber;
+        summary: ZodObject<    {
+        travelTimeInSeconds: ZodNumber;
+        lengthInMeters: ZodNumber;
+        trafficDelayInSeconds: ZodOptional<ZodNumber>;
+        trafficLengthInMeters: ZodOptional<ZodNumber>;
+        departureTime: ZodOptional<ZodString>;
+        arrivalTime: ZodOptional<ZodString>;
+        noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        }, $strip>;
+        legSummaries: ZodOptional<ZodArray<ZodObject<    {
+        travelTimeInSeconds: ZodNumber;
+        lengthInMeters: ZodNumber;
+        trafficDelayInSeconds: ZodOptional<ZodNumber>;
+        trafficLengthInMeters: ZodOptional<ZodNumber>;
+        departureTime: ZodOptional<ZodString>;
+        arrivalTime: ZodOptional<ZodString>;
+        noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        }, $strip>>>;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeAddStopToRoute;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    removeStopFromRoute: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        stopIndex: ZodNumber;
+        showOnMap: ZodBoolean;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        count: ZodNumber;
+        routes: ZodArray<ZodObject<    {
+        index: ZodNumber;
+        summary: ZodObject<    {
+        travelTimeInSeconds: ZodNumber;
+        lengthInMeters: ZodNumber;
+        trafficDelayInSeconds: ZodOptional<ZodNumber>;
+        trafficLengthInMeters: ZodOptional<ZodNumber>;
+        departureTime: ZodOptional<ZodString>;
+        arrivalTime: ZodOptional<ZodString>;
+        noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        }, $strip>;
+        legSummaries: ZodOptional<ZodArray<ZodObject<    {
+        travelTimeInSeconds: ZodNumber;
+        lengthInMeters: ZodNumber;
+        trafficDelayInSeconds: ZodOptional<ZodNumber>;
+        trafficLengthInMeters: ZodOptional<ZodNumber>;
+        departureTime: ZodOptional<ZodString>;
+        arrivalTime: ZodOptional<ZodString>;
+        noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        }, $strip>>>;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeRemoveStopFromRoute;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    getPOICategoryCodes: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        filters: ZodOptional<ZodArray<ZodString>>;
+        language: ZodString;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        count: ZodNumber;
+        codes: ZodArray<ZodString>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeGetPoiCategoryCodes;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    getTrafficIncidents: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        bbox: ZodOptional<ZodArray<ZodNumber>>;
+        ids: ZodOptional<ZodArray<ZodString>>;
+        categoryFilter: ZodOptional<ZodArray<ZodEnum<    {
+        accident: "accident";
+        "animals-on-road": "animals-on-road";
+        "broken-down-vehicle": "broken-down-vehicle";
+        danger: "danger";
+        flooding: "flooding";
+        fog: "fog";
+        frost: "frost";
+        jam: "jam";
+        "lane-closed": "lane-closed";
+        "narrow-lanes": "narrow-lanes";
+        other: "other";
+        rain: "rain";
+        "road-closed": "road-closed";
+        roadworks: "roadworks";
+        wind: "wind";
+        }>>>;
+        timeValidityFilter: ZodOptional<ZodArray<ZodEnum<    {
+        present: "present";
+        future: "future";
+        }>>>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        count: ZodNumber;
+        incidents: ZodArray<ZodObject<    {
+        id: ZodString;
+        category: ZodString;
+        magnitudeOfDelay: ZodString;
+        timeValidity: ZodString;
+        events: ZodArray<ZodObject<    {
+        description: ZodString;
+        category: ZodString;
+        }, $strip>>;
+        from: ZodOptional<ZodString>;
+        to: ZodOptional<ZodString>;
+        roadNumbers: ZodOptional<ZodArray<ZodString>>;
+        lengthInMeters: ZodOptional<ZodNumber>;
+        delayInSeconds: ZodOptional<ZodNumber>;
+        startTime: ZodOptional<ZodDate>;
+        endTime: ZodOptional<ZodDate>;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeGetTrafficIncidents;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    getTrafficAreaAnalytics: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        location: ZodOptional<ZodUnion<readonly [ZodObject<    {
+        query: ZodString;
+        locationType: ZodEnum<    {
+        default: "default";
+        poi: "poi";
+        }>;
+        }, $strip>, ZodObject<    {
+        position: ZodObject<    {
+        lng: ZodNumber;
+        lat: ZodNumber;
+        }, $strip>;
+        }, $strip>]>>;
+        bbox: ZodOptional<ZodArray<ZodNumber>>;
+        showOnMap: ZodOptional<ZodBoolean>;
+        startDate: ZodOptional<ZodString>;
+        endDate: ZodOptional<ZodString>;
+        days: ZodOptional<ZodArray<ZodString>>;
+        metrics: ZodUnion<readonly [ZodLiteral<"all">, ZodArray<ZodEnum<    {
+        speed: "speed";
+        congestionLevel: "congestionLevel";
+        freeFlowSpeed: "freeFlowSpeed";
+        travelTime: "travelTime";
+        networkLength: "networkLength";
+        }>>]>;
+        functionalRoadClasses: ZodOptional<ZodUnion<readonly [ZodLiteral<"all">, ZodArray<ZodEnum<    {
+        MOTORWAY: "MOTORWAY";
+        MAJOR_ROAD: "MAJOR_ROAD";
+        OTHER_MAJOR_ROAD: "OTHER_MAJOR_ROAD";
+        SECONDARY_ROAD: "SECONDARY_ROAD";
+        LOCAL_CONNECTING_ROAD: "LOCAL_CONNECTING_ROAD";
+        LOCAL_ROAD_HIGH_IMPORTANCE: "LOCAL_ROAD_HIGH_IMPORTANCE";
+        LOCAL_ROAD: "LOCAL_ROAD";
+        LOCAL_ROAD_MINOR_IMPORTANCE: "LOCAL_ROAD_MINOR_IMPORTANCE";
+        OTHER_ROAD: "OTHER_ROAD";
+        }>>]>>;
+        hours: ZodOptional<ZodUnion<readonly [ZodLiteral<"all">, ZodArray<ZodNumber>]>>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        name: ZodOptional<ZodString>;
+        timezone: ZodOptional<ZodString>;
+        dateRange: ZodObject<    {
+        start: ZodString;
+        end: ZodString;
+        }, $strip>;
+        baseData: ZodObject<    {
+        speed: ZodOptional<ZodNumber>;
+        freeFlowSpeed: ZodOptional<ZodNumber>;
+        congestionLevel: ZodOptional<ZodNumber>;
+        travelTime: ZodOptional<ZodNumber>;
+        networkLength: ZodOptional<ZodNumber>;
+        }, $strip>;
+        metrics: ZodArray<ZodString>;
+        tileCount: ZodNumber;
+        availableGranularities: ZodArray<ZodString>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeGetTrafficAreaAnalytics;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    queryTrafficAnalytics: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        granularity: ZodOptional<ZodEnum<    {
+        yearly: "yearly";
+        monthly: "monthly";
+        weekly: "weekly";
+        daily: "daily";
+        hourly: "hourly";
+        average: "average";
+        }>>;
+        metric: ZodOptional<ZodEnum<    {
+        speed: "speed";
+        congestionLevel: "congestionLevel";
+        freeFlowSpeed: "freeFlowSpeed";
+        travelTime: "travelTime";
+        networkLength: "networkLength";
+        }>>;
+        startDate: ZodOptional<ZodString>;
+        endDate: ZodOptional<ZodString>;
+        hourStart: ZodOptional<ZodNumber>;
+        hourEnd: ZodOptional<ZodNumber>;
+        dayOfWeek: ZodOptional<ZodArray<ZodNumber>>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        granularity: ZodString;
+        count: ZodNumber;
+        entries: ZodArray<ZodObject<    {
+        speed: ZodOptional<ZodNumber>;
+        freeFlowSpeed: ZodOptional<ZodNumber>;
+        congestionLevel: ZodOptional<ZodNumber>;
+        travelTime: ZodOptional<ZodNumber>;
+        networkLength: ZodOptional<ZodNumber>;
+        date: ZodOptional<ZodString>;
+        hour: ZodOptional<ZodNumber>;
+        year: ZodOptional<ZodNumber>;
+        month: ZodOptional<ZodNumber>;
+        week: ZodOptional<ZodNumber>;
+        day: ZodOptional<ZodNumber>;
+        }, $strip>>;
+        currentVisualization: ZodOptional<ZodObject<    {
+        activeMetric: ZodOptional<ZodString>;
+        displayMode: ZodOptional<ZodString>;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeQueryTrafficAnalytics;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    showPlaces: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        id: ZodOptional<ZodString>;
+        fitBounds: ZodOptional<ZodBoolean>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        success: ZodLiteral<true>;
+        count: ZodNumber;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeShowPlaces;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    showRoute: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        id: ZodOptional<ZodString>;
+        selectedIndex: ZodOptional<ZodNumber>;
+        fitBounds: ZodOptional<ZodBoolean>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        success: ZodLiteral<true>;
+        displayedRoute: ZodNumber;
+        routeCount: ZodNumber;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeShowRoutes;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    showTrafficAreaAnalytics: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        mode: ZodOptional<ZodEnum<    {
+        heatmap: "heatmap";
+        "hexgrid-3d": "hexgrid-3d";
+        "hexgrid-2d": "hexgrid-2d";
+        "square-3d": "square-3d";
+        "square-2d": "square-2d";
+        }>>;
+        metric: ZodOptional<ZodEnum<    {
+        speed: "speed";
+        congestionLevel: "congestionLevel";
+        travelTime: "travelTime";
+        }>>;
+        colorTheme: ZodOptional<ZodEnum<    {
+        trafficLight: "trafficLight";
+        heat: "heat";
+        monochrome: "monochrome";
+        viridis: "viridis";
+        plasma: "plasma";
+        }>>;
+        heightScale: ZodOptional<ZodNumber>;
+        scaleMode: ZodOptional<ZodEnum<    {
+        raw: "raw";
+        predefinedRange: "predefinedRange";
+        currentRange: "currentRange";
+        }>>;
+        filter: ZodOptional<ZodObject<    {
+        min: ZodOptional<ZodNumber>;
+        max: ZodOptional<ZodNumber>;
+        }, $strip>>;
+        visible: ZodOptional<ZodBoolean>;
+        fitBounds: ZodOptional<ZodBoolean>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        success: ZodLiteral<true>;
+        mode: ZodString;
+        metric: ZodString;
+        colorTheme: ZodString;
+        visible: ZodBoolean;
+        filtered: ZodBoolean;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeShowTrafficAreaAnalytics;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    showWaypoints: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {}, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        success: ZodLiteral<true>;
+        count: ZodNumber;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeShowWaypoints;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    getShownPlaces: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {}, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        count: ZodNumber;
+        features: ZodArray<ZodObject<    {
+        name: ZodOptional<ZodString>;
+        address: ZodOptional<ZodString>;
+        position: ZodArray<ZodNumber>;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeGetShownPlaces;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    getShownRoutes: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {}, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        count: ZodNumber;
+        routes: ZodArray<ZodObject<    {
+        index: ZodNumber;
+        summary: ZodObject<    {
+        travelTimeInSeconds: ZodNumber;
+        lengthInMeters: ZodNumber;
+        trafficDelayInSeconds: ZodOptional<ZodNumber>;
+        trafficLengthInMeters: ZodOptional<ZodNumber>;
+        departureTime: ZodOptional<ZodString>;
+        arrivalTime: ZodOptional<ZodString>;
+        noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        }, $strip>;
+        legSummaries: ZodOptional<ZodArray<ZodObject<    {
+        travelTimeInSeconds: ZodNumber;
+        lengthInMeters: ZodNumber;
+        trafficDelayInSeconds: ZodOptional<ZodNumber>;
+        trafficLengthInMeters: ZodOptional<ZodNumber>;
+        departureTime: ZodOptional<ZodString>;
+        arrivalTime: ZodOptional<ZodString>;
+        noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        }, $strip>>>;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeGetShownRoutes;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    getShownWaypoints: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {}, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        count: ZodNumber;
+        waypoints: ZodArray<ZodObject<    {
+        name: ZodOptional<ZodUnknown>;
+        position: ZodArray<ZodNumber>;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeGetShownWaypoints;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    getShownRouteTrafficIncidents: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {}, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        count: ZodNumber;
+        trafficIncidents: ZodArray<ZodObject<    {
+        id: ZodString;
+        magnitudeOfDelay: ZodString;
+        title: ZodOptional<ZodString>;
+        delayInSeconds: ZodOptional<ZodNumber>;
+        effectiveSpeedInKmh: ZodOptional<ZodNumber>;
+        categories: ZodOptional<ZodArray<ZodString>>;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeGetShownRouteTrafficIncidents;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    getShownRouteSections: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        sectionType: ZodEnum<    {
+        leg: "leg";
+        traffic: "traffic";
+        carpool: "carpool";
+        carTrain: "carTrain";
+        country: "country";
+        ferry: "ferry";
+        importantRoadStretch: "importantRoadStretch";
+        lanes: "lanes";
+        lowEmissionZone: "lowEmissionZone";
+        motorway: "motorway";
+        pedestrian: "pedestrian";
+        roadShields: "roadShields";
+        speedLimit: "speedLimit";
+        toll: "toll";
+        tollVignette: "tollVignette";
+        tunnel: "tunnel";
+        unpaved: "unpaved";
+        urban: "urban";
+        vehicleRestricted: "vehicleRestricted";
+        }>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        sectionType: ZodString;
+        routes: ZodArray<ZodObject<    {
+        routeIndex: ZodNumber;
+        sections: ZodArray<ZodUnknown>;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeGetShownRouteSections;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    getShownIncidents: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {}, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        count: ZodNumber;
+        trafficIncidents: ZodArray<ZodObject<    {
+        id: ZodString;
+        category: ZodString;
+        magnitudeOfDelay: ZodString;
+        description: ZodOptional<ZodString>;
+        delayInSeconds: ZodOptional<ZodNumber>;
+        roadCategory: ZodOptional<ZodString>;
+        averageSpeedKmph: ZodOptional<ZodNumber>;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeGetShownIncidents;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    clearMap: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        layers: ZodOptional<ZodArray<ZodEnum<    {
+        routes: "routes";
+        places: "places";
+        geometries: "geometries";
+        analytics: "analytics";
+        }>>>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        success: ZodLiteral<true>;
+        cleared: ZodArray<ZodString>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeClearMap;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    flyTo: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        where: ZodUnion<readonly [ZodObject<    {
+        boundingBox: ZodUnion<readonly [ZodUnion<readonly [ZodArray<ZodNumber>]>, ZodObject<    {
+        bbox: ZodUnion<readonly [ZodArray<ZodNumber>]>;
+        }, $strip>]>;
+        padding: ZodOptional<ZodNumber>;
+        }, $strip>, ZodObject<    {
+        position: ZodArray<ZodNumber>;
+        zoom: ZodOptional<ZodNumber>;
+        }, $strip>]>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        success: ZodLiteral<true>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeFlyTo;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    fitRouteSection: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        sectionType: ZodEnum<    {
+        leg: "leg";
+        traffic: "traffic";
+        carpool: "carpool";
+        carTrain: "carTrain";
+        country: "country";
+        ferry: "ferry";
+        importantRoadStretch: "importantRoadStretch";
+        lanes: "lanes";
+        lowEmissionZone: "lowEmissionZone";
+        motorway: "motorway";
+        pedestrian: "pedestrian";
+        roadShields: "roadShields";
+        speedLimit: "speedLimit";
+        toll: "toll";
+        tollVignette: "tollVignette";
+        tunnel: "tunnel";
+        unpaved: "unpaved";
+        urban: "urban";
+        vehicleRestricted: "vehicleRestricted";
+        }>;
+        id: ZodString;
+        padding: ZodOptional<ZodNumber>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        success: ZodLiteral<true>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeFitRouteSection;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    getViewport: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {}, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        center: ZodArray<ZodNumber>;
+        zoom: ZodNumber;
+        bbox: ZodArray<ZodNumber>;
+        pitch: ZodNumber;
+        bearing: ZodNumber;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeGetViewport;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    recallPlaces: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        id: ZodOptional<ZodString>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        entries: ZodArray<ZodObject<    {
+        id: ZodString;
+        label: ZodString;
+        timestamp: ZodNumber;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        id: ZodString;
+        label: ZodString;
+        timestamp: ZodNumber;
+        places: ZodObject<    {
+        count: ZodNumber;
+        features: ZodArray<ZodObject<    {
+        name: ZodOptional<ZodString>;
+        address: ZodOptional<ZodString>;
+        position: ZodArray<ZodNumber>;
+        }, $strip>>;
+        }, $strip>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeRecallPlaces;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    recallRoutes: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        id: ZodOptional<ZodString>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        entries: ZodArray<ZodObject<    {
+        id: ZodString;
+        label: ZodString;
+        timestamp: ZodNumber;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        id: ZodString;
+        label: ZodString;
+        timestamp: ZodNumber;
+        routes: ZodObject<    {
+        count: ZodNumber;
+        routes: ZodArray<ZodObject<    {
+        index: ZodNumber;
+        summary: ZodObject<    {
+        travelTimeInSeconds: ZodNumber;
+        lengthInMeters: ZodNumber;
+        trafficDelayInSeconds: ZodOptional<ZodNumber>;
+        trafficLengthInMeters: ZodOptional<ZodNumber>;
+        departureTime: ZodOptional<ZodString>;
+        arrivalTime: ZodOptional<ZodString>;
+        noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        }, $strip>;
+        legSummaries: ZodOptional<ZodArray<ZodObject<    {
+        travelTimeInSeconds: ZodNumber;
+        lengthInMeters: ZodNumber;
+        trafficDelayInSeconds: ZodOptional<ZodNumber>;
+        trafficLengthInMeters: ZodOptional<ZodNumber>;
+        departureTime: ZodOptional<ZodString>;
+        arrivalTime: ZodOptional<ZodString>;
+        noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
+        }, $strip>>>;
+        }, $strip>>;
+        }, $strip>;
+        waypoints: ZodArray<ZodObject<    {
+        position: ZodArray<ZodNumber>;
+        }, $strip>>;
+        params: ZodObject<    {
+        maxAlternatives: ZodOptional<ZodNumber>;
+        costModel: ZodOptional<ZodObject<    {
+        routeType: ZodOptional<ZodEnum<    {
+        fast: "fast";
+        short: "short";
+        efficient: "efficient";
+        thrilling: "thrilling";
+        }>>;
+        traffic: ZodOptional<ZodEnum<    {
+        live: "live";
+        historical: "historical";
+        }>>;
+        avoid: ZodOptional<ZodArray<ZodEnum<    {
+        tollRoads: "tollRoads";
+        motorways: "motorways";
+        ferries: "ferries";
+        unpavedRoads: "unpavedRoads";
+        carpools: "carpools";
+        alreadyUsedRoads: "alreadyUsedRoads";
+        borderCrossings: "borderCrossings";
+        tunnels: "tunnels";
+        carTrains: "carTrains";
+        lowEmissionZones: "lowEmissionZones";
+        }>>>;
+        avoidAreas: ZodOptional<ZodArray<ZodArray<ZodNumber>>>;
+        }, $strip>>;
+        when: ZodOptional<ZodObject<    {
+        option: ZodEnum<    {
+        departAt: "departAt";
+        arriveBy: "arriveBy";
+        }>;
+        date: ZodString;
+        }, $strip>>;
+        }, $strip>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeRecallRoutes;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    getCurrentWaypoints: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        slotIndex: ZodOptional<ZodNumber>;
+        includeEmptySlots: ZodOptional<ZodBoolean>;
+        offset: ZodOptional<ZodNumber>;
+        limit: ZodOptional<ZodNumber>;
+        }, $strip>;
+        outputSchema: ZodObject<    {
+        totalSlots: ZodNumber;
+        filledSlots: ZodNumber;
+        matchedCount: ZodNumber;
+        returnedCount: ZodNumber;
+        offset: ZodNumber;
+        hasMore: ZodBoolean;
+        nextOffset: ZodOptional<ZodNumber>;
+        waypoints: ZodArray<ZodObject<    {
+        slotIndex: ZodNumber;
+        isFilled: ZodBoolean;
+        address: ZodOptional<ZodString>;
+        position: ZodOptional<ZodArray<ZodNumber>>;
+        }, $strip>>;
+        }, $strip>;
+        execute: typeof executeGetCurrentWaypoints;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    getStandardMapStyles: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {}, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        styles: ZodReadonly<ZodArray<ZodString>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeGetStandardMapStyles;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    setMapStandardStyle: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        style: ZodEnum<    {
+        standardLight: "standardLight";
+        standardDark: "standardDark";
+        drivingLight: "drivingLight";
+        drivingDark: "drivingDark";
+        monoLight: "monoLight";
+        monoDark: "monoDark";
+        satellite: "satellite";
+        }>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        success: ZodLiteral<true>;
+        style: ZodString;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeSetMapStandardStyle;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    setRouteTheme: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        mainColor: ZodOptional<ZodString>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        success: ZodLiteral<true>;
+        theme: ZodObject<    {
+        mainColor: ZodOptional<ZodString>;
+        }, $strip>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeSetRouteTheme;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    setLanguage: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        language: ZodString;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        success: ZodLiteral<true>;
+        language: ZodString;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeSetLanguage;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    toggleBaseMapLayerGroups: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        visible: ZodBoolean;
+        layerGroups: ZodArray<ZodEnum<    {
+        roadShields: "roadShields";
+        land: "land";
+        water: "water";
+        borders: "borders";
+        buildings2D: "buildings2D";
+        buildings3D: "buildings3D";
+        houseNumbers: "houseNumbers";
+        roadLines: "roadLines";
+        roadLabels: "roadLabels";
+        placeLabels: "placeLabels";
+        smallerTownLabels: "smallerTownLabels";
+        cityLabels: "cityLabels";
+        capitalLabels: "capitalLabels";
+        stateLabels: "stateLabels";
+        countryLabels: "countryLabels";
+        }>>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        success: ZodLiteral<true>;
+        visible: ZodBoolean;
+        layerGroups: ZodArray<ZodString>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeToggleBaseMapLayerGroups;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    togglePOIs: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        reset: ZodOptional<ZodBoolean>;
+        allMapPOIsVisible: ZodOptional<ZodBoolean>;
+        filterCategories: ZodOptional<ZodObject<    {
+        show: ZodEnum<    {
+        only: "only";
+        all_except: "all_except";
+        }>;
+        values: ZodArray<ZodString>;
+        }, $strip>>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        success: ZodLiteral<true>;
+        allMapPOIsVisible: ZodOptional<ZodBoolean>;
+        filterCategories: ZodOptional<ZodObject<    {
+        show: ZodEnum<    {
+        only: "only";
+        all_except: "all_except";
+        }>;
+        values: ZodArray<ZodString>;
+        }, $strip>>;
+        reset: ZodOptional<ZodBoolean>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeTogglePOIs;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    toggleTrafficFlow: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        visible: ZodBoolean;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        success: ZodLiteral<true>;
+        trafficFlowVisible: ZodBoolean;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeToggleTrafficFlow;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    toggleTrafficIncidents: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        visible: ZodBoolean;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        success: ZodLiteral<true>;
+        trafficIncidentsVisible: ZodBoolean;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeToggleTrafficIncidents;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    getMapStyleLayers: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        layerIdQuery: ZodOptional<ZodString>;
+        include: ZodArray<ZodEnum<    {
+        layout: "layout";
+        paint: "paint";
+        }>>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        layers: ZodArray<ZodObject<    {
+        id: ZodString;
+        layout: ZodOptional<ZodUnknown>;
+        paint: ZodOptional<ZodUnknown>;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeGetMapStyleLayers;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    setLayoutProperties: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        changes: ZodArray<ZodObject<    {
+        layerId: ZodString;
+        propertyName: ZodString;
+        value: ZodAny;
+        }, $strip>>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        results: ZodArray<ZodUnion<readonly [ZodObject<    {
+        layerId: ZodString;
+        propertyName: ZodString;
+        value: ZodUnknown;
+        success: ZodLiteral<true>;
+        }, $strip>, ZodObject<    {
+        layerId: ZodString;
+        propertyName: ZodString;
+        error: ZodString;
+        }, $strip>]>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeSetLayoutProperties;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    setPaintProperties: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        changes: ZodArray<ZodObject<    {
+        layerId: ZodString;
+        propertyName: ZodString;
+        value: ZodAny;
+        }, $strip>>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        results: ZodArray<ZodUnion<readonly [ZodObject<    {
+        layerId: ZodString;
+        propertyName: ZodString;
+        value: ZodUnknown;
+        success: ZodLiteral<true>;
+        }, $strip>, ZodObject<    {
+        layerId: ZodString;
+        propertyName: ZodString;
+        error: ZodString;
+        }, $strip>]>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeSetPaintProperties;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    setPitchBearing: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        pitch: ZodOptional<ZodNumber>;
+        bearing: ZodOptional<ZodNumber>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        success: ZodLiteral<true>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeSetPitchBearing;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    zoomInOrOut: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        delta: ZodNumber;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        zoom: ZodNumber;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeZoomInOrOut;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    executeMaplibreCode: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        code: ZodString;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        success: ZodLiteral<true>;
+        result: ZodOptional<ZodUnknown>;
+        sources: ZodObject<    {
+        added: ZodArray<ZodString>;
+        removed: ZodArray<ZodString>;
+        updated: ZodArray<ZodString>;
+        }, $strip>;
+        layers: ZodObject<    {
+        added: ZodArray<ZodString>;
+        removed: ZodArray<ZodString>;
+        updated: ZodArray<ZodString>;
+        }, $strip>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeExecuteMaplibreCode;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    calculateBBox: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        geoJson: ZodUnion<readonly [ZodRecord<ZodString, ZodUnknown>, ZodArray<ZodRecord<ZodString, ZodUnknown>>]>;
+        }, $strip>;
+        execute: typeof executeCalculateBBox;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    formatDistance: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        meters: ZodNumber;
+        unitType: ZodOptional<ZodEnum<    {
+        metric: "metric";
+        imperial_us: "imperial_us";
+        imperial_uk: "imperial_uk";
+        }>>;
+        }, $strip>;
+        execute: typeof executeFormatDistance;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    formatDuration: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        seconds: ZodNumber;
+        }, $strip>;
+        execute: typeof executeFormatDuration;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    getSectionProgress: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        sectionType: ZodEnum<    {
+        leg: "leg";
+        traffic: "traffic";
+        carpool: "carpool";
+        carTrain: "carTrain";
+        country: "country";
+        ferry: "ferry";
+        importantRoadStretch: "importantRoadStretch";
+        lanes: "lanes";
+        lowEmissionZone: "lowEmissionZone";
+        motorway: "motorway";
+        pedestrian: "pedestrian";
+        roadShields: "roadShields";
+        speedLimit: "speedLimit";
+        toll: "toll";
+        tollVignette: "tollVignette";
+        tunnel: "tunnel";
+        unpaved: "unpaved";
+        urban: "urban";
+        vehicleRestricted: "vehicleRestricted";
+        }>;
+        ids: ZodOptional<ZodArray<ZodString>>;
+        }, $strip>;
+        execute: typeof executeGetSectionProgress;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    getSectionBBox: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        sectionType: ZodEnum<    {
+        leg: "leg";
+        traffic: "traffic";
+        carpool: "carpool";
+        carTrain: "carTrain";
+        country: "country";
+        ferry: "ferry";
+        importantRoadStretch: "importantRoadStretch";
+        lanes: "lanes";
+        lowEmissionZone: "lowEmissionZone";
+        motorway: "motorway";
+        pedestrian: "pedestrian";
+        roadShields: "roadShields";
+        speedLimit: "speedLimit";
+        toll: "toll";
+        tollVignette: "tollVignette";
+        tunnel: "tunnel";
+        unpaved: "unpaved";
+        urban: "urban";
+        vehicleRestricted: "vehicleRestricted";
+        }>;
+        id: ZodString;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        bbox: ZodArray<ZodNumber>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeGetSectionBBox;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    getRouteProgress: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        routeIndex: ZodOptional<ZodNumber>;
+        traveledTimeInSeconds: ZodOptional<ZodNumber>;
+        traveledDistanceInMeters: ZodOptional<ZodNumber>;
+        clockTime: ZodOptional<ZodString>;
+        }, $strip>;
+        execute: typeof executeGetRouteProgress;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    getCurrentLocation: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {}, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        position: ZodArray<ZodNumber>;
+        accuracy: ZodNumber;
+        timestamp: ZodNumber;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeGetCurrentLocation;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    help: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        mode: ZodEnum<    {
+        summary: "summary";
+        detail: "detail";
+        }>;
+        query: ZodOptional<ZodString>;
+        tag: ZodOptional<ZodEnum<    {
+        place: "place";
+        leg: "leg";
+        location: "location";
+        route: "route";
+        traffic: "traffic";
+        carpool: "carpool";
+        carTrain: "carTrain";
+        country: "country";
+        ferry: "ferry";
+        importantRoadStretch: "importantRoadStretch";
+        lanes: "lanes";
+        lowEmissionZone: "lowEmissionZone";
+        motorway: "motorway";
+        pedestrian: "pedestrian";
+        roadShields: "roadShields";
+        speedLimit: "speedLimit";
+        toll: "toll";
+        tollVignette: "tollVignette";
+        tunnel: "tunnel";
+        unpaved: "unpaved";
+        urban: "urban";
+        vehicleRestricted: "vehicleRestricted";
+        waypoint: "waypoint";
+        locate: "locate";
+        discover: "discover";
+        "map style": "map style";
+        utilities: "utilities";
+        search: "search";
+        detour: "detour";
+        "along-route": "along-route";
+        "reachable-range": "reachable-range";
+        isochrone: "isochrone";
+        range: "range";
+        EV: "EV";
+        coverage: "coverage";
+        recall: "recall";
+        state: "state";
+        }>>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        mode: ZodLiteral<"summary">;
+        examplePrompts: ZodArray<ZodString>;
+        }, $strip>, ZodObject<    {
+        mode: ZodLiteral<"detail">;
+        query: ZodOptional<ZodString>;
+        tag: ZodOptional<ZodEnum<    {
+        place: "place";
+        leg: "leg";
+        location: "location";
+        route: "route";
+        traffic: "traffic";
+        carpool: "carpool";
+        carTrain: "carTrain";
+        country: "country";
+        ferry: "ferry";
+        importantRoadStretch: "importantRoadStretch";
+        lanes: "lanes";
+        lowEmissionZone: "lowEmissionZone";
+        motorway: "motorway";
+        pedestrian: "pedestrian";
+        roadShields: "roadShields";
+        speedLimit: "speedLimit";
+        toll: "toll";
+        tollVignette: "tollVignette";
+        tunnel: "tunnel";
+        unpaved: "unpaved";
+        urban: "urban";
+        vehicleRestricted: "vehicleRestricted";
+        waypoint: "waypoint";
+        locate: "locate";
+        discover: "discover";
+        "map style": "map style";
+        utilities: "utilities";
+        search: "search";
+        detour: "detour";
+        "along-route": "along-route";
+        "reachable-range": "reachable-range";
+        isochrone: "isochrone";
+        range: "range";
+        EV: "EV";
+        coverage: "coverage";
+        recall: "recall";
+        state: "state";
+        }>>;
+        matchedTools: ZodArray<ZodObject<    {
+        name: ZodString;
+        description: ZodString;
+        examplePrompts: ZodArray<ZodString>;
+        relatedTools: ZodOptional<ZodArray<ZodString>>;
+        }, $strip>>;
+        totalMatched: ZodNumber;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: () => Promise<never>;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+    };
+    searchAlongRoute: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        query: ZodOptional<ZodString>;
+        poiCategories: ZodOptional<ZodArray<ZodString>>;
+        routeId: ZodOptional<ZodString>;
+        maxDetourTimeSeconds: ZodNumber;
+        sortBy: ZodOptional<ZodEnum<    {
+        detourTime: "detourTime";
+        detourOffset: "detourOffset";
+        }>>;
+        limit: ZodOptional<ZodNumber>;
+        show: ZodOptional<ZodObject<    {
+        markerType: ZodEnum<    {
+        pin: "pin";
+        none: "none";
+        }>;
+        zoomMode: ZodEnum<    {
+        none: "none";
+        auto: "auto";
+        }>;
+        }, $strip>>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        count: ZodNumber;
+        features: ZodArray<ZodObject<    {
+        name: ZodOptional<ZodString>;
+        address: ZodOptional<ZodString>;
+        position: ZodArray<ZodNumber>;
+        }, $strip>>;
+        placeResultIndex: ZodString;
+        shown: ZodOptional<ZodObject<    {
+        markerType: ZodBoolean;
+        zoomMode: ZodBoolean;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        status: ZodLiteral<"no_route">;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeSearchAlongRoute;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+        dependsOn: string[];
+    };
+    findReachableArea: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        origin: ZodUnion<readonly [ZodObject<    {
+        query: ZodString;
+        locationType: ZodEnum<    {
+        default: "default";
+        poi: "poi";
+        }>;
+        }, $strip>, ZodObject<    {
+        position: ZodObject<    {
+        lng: ZodNumber;
+        lat: ZodNumber;
+        }, $strip>;
+        }, $strip>]>;
+        budgets: ZodArray<ZodObject<    {
+        type: ZodEnum<    {
+        timeMinutes: "timeMinutes";
+        distanceKM: "distanceKM";
+        }>;
+        value: ZodNumber;
+        }, $strip>>;
+        theme: ZodOptional<ZodEnum<    {
+        filled: "filled";
+        outline: "outline";
+        inverted: "inverted";
+        }>>;
+        showOnMap: ZodBoolean;
+        showOriginPin: ZodOptional<ZodBoolean>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        rangeId: ZodString;
+        originName: ZodString;
+        budgets: ZodArray<ZodObject<    {
+        type: ZodEnum<    {
+        timeMinutes: "timeMinutes";
+        distanceKM: "distanceKM";
+        }>;
+        value: ZodNumber;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        status: ZodEnum<    {
+        not_found: "not_found";
+        no_results: "no_results";
+        }>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeFindReachableArea;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+    recallRanges: {
+        description: string;
+        classificationPrompt: string;
+        inputSchema: ZodObject<    {
+        id: ZodOptional<ZodString>;
+        }, $strip>;
+        outputSchema: ZodUnion<readonly [ZodObject<    {
+        entries: ZodArray<ZodObject<    {
+        id: ZodString;
+        label: ZodString;
+        timestamp: ZodNumber;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        id: ZodString;
+        label: ZodString;
+        timestamp: ZodNumber;
+        origin: ZodObject<    {
+        query: ZodOptional<ZodString>;
+        position: ZodTuple<[ZodNumber, ZodNumber], null>;
+        }, $strip>;
+        budgets: ZodArray<ZodObject<    {
+        type: ZodString;
+        value: ZodNumber;
+        }, $strip>>;
+        }, $strip>, ZodObject<    {
+        error: ZodString;
+        }, $strip>]>;
+        execute: typeof executeRecallRanges;
+        tags: string[];
+        examples: string[];
+        examplePrompts: string[];
+        relatedTools: string[];
+    };
+};
+
+/** Output schema for the discover-places tool. */
+declare const discoverPlacesOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    count: z.ZodNumber;
+    features: z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        address: z.ZodOptional<z.ZodString>;
+        position: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+    shown: z.ZodOptional<z.ZodObject<{
+        markerType: z.ZodBoolean;
+        zoomMode: z.ZodBoolean;
+    }, z.core.$strip>>;
+    placeResultIndex: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/**
+ * Tool schema for discovering places.
+ */
+declare const discoverPlacesSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    where: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        position: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        boundingBox: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodNumber>]>, z.ZodObject<{
+            bbox: z.ZodUnion<readonly [z.ZodArray<z.ZodNumber>]>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>, z.ZodLiteral<"within-map-bounds">, z.ZodLiteral<"nearby-map-center">, z.ZodLiteral<"global">, z.ZodString]>>;
+    radiusMeters: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    poiCategories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    show: z.ZodOptional<z.ZodObject<{
+        markerType: z.ZodEnum<{
+            pin: "pin";
+            none: "none";
+        }>;
+        zoomMode: z.ZodEnum<{
+            none: "none";
+            auto: "auto";
+        }>;
+    }, z.core.$strip>>;
+    withinRange: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
+/**
+ * Create the add stop to route tool.
+ */
+/** Standalone execute for ToolEntry format. */
+declare function executeAddStopToRoute(params: z.infer<typeof addStopToRouteSchema>, state: ToolState): Promise<z.infer<typeof addStopToRouteOutputSchema>>;
+
+/** Execute function for calculateBBox — usable with ToolEntry format. */
+declare function executeCalculateBBox(params: z.infer<typeof calculateBBoxSchema>, _state: ToolState): Promise<{
+    error: string;
+    bbox?: undefined;
+    minLng?: undefined;
+    minLat?: undefined;
+    maxLng?: undefined;
+    maxLat?: undefined;
+} | {
+    bbox: BBox;
+    minLng: number;
+    minLat: number;
+    maxLng: number;
+    maxLat: number;
+    error?: undefined;
+}>;
+
+/**
+ * Execute clear map.
+ */
+declare function executeClearMap(params: z.infer<typeof clearMapSchema>, state: ToolState): Promise<{
+    success: boolean;
+    cleared: ("routes" | "places" | "geometries" | "analytics")[];
+    error?: undefined;
+} | {
+    error: string;
+    success?: undefined;
+    cleared?: undefined;
+}>;
+
+/**
+ * Create the discover places tool.
+ */
+/** Standalone execute for ToolEntry format. */
+declare function executeDiscoverPlaces(params: z.infer<typeof discoverPlacesSchema>, state: ToolState): Promise<z.infer<typeof discoverPlacesOutputSchema>>;
+
+/** Execute function for executeMaplibreCode — usable with ToolEntry format. */
+declare function executeExecuteMaplibreCode(params: z.infer<typeof executeMaplibreCodeSchema>, state: ToolState): Promise<{
+    success: boolean;
+    result: {} | undefined;
+    sources: {
+        added: string[];
+        removed: string[];
+        updated: string[];
+    };
+    layers: {
+        added: string[];
+        removed: string[];
+        updated: string[];
+    };
+    error?: undefined;
+} | {
+    error: string;
+    success?: undefined;
+    result?: undefined;
+    sources?: undefined;
+    layers?: undefined;
+}>;
+
+/** Standalone execute for ToolEntry format. */
+declare function executeFindReachableArea(params: z.infer<typeof findReachableAreaSchema>, state: ToolState): Promise<z.infer<typeof findReachableAreaOutputSchema>>;
+
+/**
+ * Execute fit route section.
+ */
+declare function executeFitRouteSection(params: z.infer<typeof fitRouteSectionSchema>, state: ToolState): Promise<{
+    error: string;
+    success?: undefined;
+} | {
+    success: boolean;
+    error?: undefined;
+}>;
+
+/** Execute function for flyTo — usable with ToolEntry format. */
+declare function executeFlyTo(params: z.infer<typeof flyToSchema>, state: ToolState): Promise<{
+    error: string;
+    success?: undefined;
+} | {
+    success: boolean;
+    error?: undefined;
+}>;
+
+/** Execute function for formatDistance — usable with ToolEntry format. */
+declare function executeFormatDistance(params: z.infer<typeof formatDistanceSchema>, _state: ToolState): Promise<{
+    formatted: string;
+    input: {
+        meters: number;
+        unitType: "metric" | "imperial_us" | "imperial_uk";
+    };
+    error?: undefined;
+} | {
+    error: string;
+    formatted?: undefined;
+    input?: undefined;
+}>;
+
+/** Execute function for formatDuration — usable with ToolEntry format. */
+declare function executeFormatDuration(params: z.infer<typeof formatDurationSchema>, _state: ToolState): Promise<{
+    formatted: undefined;
+    message: string;
+    input: {
+        seconds: number;
+    };
+    error?: undefined;
+} | {
+    formatted: string;
+    input: {
+        seconds: number;
+    };
+    message?: undefined;
+    error?: undefined;
+} | {
+    error: string;
+    formatted?: undefined;
+    message?: undefined;
+    input?: undefined;
+}>;
+
+/** Execute function for getCurrentLocation — usable with ToolEntry format. */
+declare function executeGetCurrentLocation(_params: z.infer<typeof getCurrentLocationSchema>, _state: ToolState): Promise<z.infer<typeof getCurrentLocationOutputSchema>>;
+
+declare function executeGetCurrentWaypoints(params: z.infer<typeof getCurrentWaypointsSchema>, state: ToolState): Promise<z.infer<typeof getCurrentWaypointsOutputSchema>>;
+
+/** Execute function for getMapStyleLayers — usable with ToolEntry format. */
+declare function executeGetMapStyleLayers(params: z.infer<typeof getMapStyleLayersSchema>, state: ToolState): Promise<{
+    error: string;
+    layers?: undefined;
+} | {
+    layers: {
+        layout?: {
+            "fill-sort-key"?: DataDrivenPropertyValueSpecification<number>;
+            visibility?: VisibilitySpecification;
+        } | {
+            "line-cap"?: DataDrivenPropertyValueSpecification<"butt" | "round" | "square">;
+            "line-join"?: DataDrivenPropertyValueSpecification<"bevel" | "round" | "miter">;
+            "line-miter-limit"?: DataDrivenPropertyValueSpecification<number>;
+            "line-round-limit"?: DataDrivenPropertyValueSpecification<number>;
+            "line-sort-key"?: DataDrivenPropertyValueSpecification<number>;
+            visibility?: VisibilitySpecification;
+        } | {
+            "symbol-placement"?: PropertyValueSpecification<"point" | "line" | "line-center">;
+            "symbol-spacing"?: PropertyValueSpecification<number>;
+            "symbol-avoid-edges"?: PropertyValueSpecification<boolean>;
+            "symbol-sort-key"?: DataDrivenPropertyValueSpecification<number>;
+            "symbol-z-order"?: PropertyValueSpecification<"auto" | "viewport-y" | "source">;
+            "icon-allow-overlap"?: PropertyValueSpecification<boolean>;
+            "icon-overlap"?: PropertyValueSpecification<"never" | "always" | "cooperative">;
+            "icon-ignore-placement"?: PropertyValueSpecification<boolean>;
+            "icon-optional"?: PropertyValueSpecification<boolean>;
+            "icon-rotation-alignment"?: PropertyValueSpecification<"map" | "viewport" | "auto">;
+            "icon-size"?: DataDrivenPropertyValueSpecification<number>;
+            "icon-text-fit"?: PropertyValueSpecification<"none" | "width" | "height" | "both">;
+            "icon-text-fit-padding"?: PropertyValueSpecification<[number, number, number, number]>;
+            "icon-image"?: DataDrivenPropertyValueSpecification<ResolvedImageSpecification>;
+            "icon-rotate"?: DataDrivenPropertyValueSpecification<number>;
+            "icon-padding"?: DataDrivenPropertyValueSpecification<PaddingSpecification>;
+            "icon-keep-upright"?: PropertyValueSpecification<boolean>;
+            "icon-offset"?: DataDrivenPropertyValueSpecification<[number, number]>;
+            "icon-anchor"?: DataDrivenPropertyValueSpecification<"center" | "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right">;
+            "icon-pitch-alignment"?: PropertyValueSpecification<"map" | "viewport" | "auto">;
+            "text-pitch-alignment"?: PropertyValueSpecification<"map" | "viewport" | "auto">;
+            "text-rotation-alignment"?: PropertyValueSpecification<"map" | "viewport" | "viewport-glyph" | "auto">;
+            "text-field"?: DataDrivenPropertyValueSpecification<FormattedSpecification>;
+            "text-font"?: DataDrivenPropertyValueSpecification<Array<string>>;
+            "text-size"?: DataDrivenPropertyValueSpecification<number>;
+            "text-max-width"?: DataDrivenPropertyValueSpecification<number>;
+            "text-line-height"?: PropertyValueSpecification<number>;
+            "text-letter-spacing"?: DataDrivenPropertyValueSpecification<number>;
+            "text-justify"?: DataDrivenPropertyValueSpecification<"auto" | "left" | "center" | "right">;
+            "text-radial-offset"?: DataDrivenPropertyValueSpecification<number>;
+            "text-variable-anchor"?: PropertyValueSpecification<Array<"center" | "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right">>;
+            "text-variable-anchor-offset"?: DataDrivenPropertyValueSpecification<VariableAnchorOffsetCollectionSpecification>;
+            "text-anchor"?: DataDrivenPropertyValueSpecification<"center" | "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right">;
+            "text-max-angle"?: PropertyValueSpecification<number>;
+            "text-writing-mode"?: PropertyValueSpecification<Array<"horizontal" | "vertical">>;
+            "text-rotate"?: DataDrivenPropertyValueSpecification<number>;
+            "text-padding"?: PropertyValueSpecification<number>;
+            "text-keep-upright"?: PropertyValueSpecification<boolean>;
+            "text-transform"?: DataDrivenPropertyValueSpecification<"none" | "uppercase" | "lowercase">;
+            "text-offset"?: DataDrivenPropertyValueSpecification<[number, number]>;
+            "text-allow-overlap"?: PropertyValueSpecification<boolean>;
+            "text-overlap"?: PropertyValueSpecification<"never" | "always" | "cooperative">;
+            "text-ignore-placement"?: PropertyValueSpecification<boolean>;
+            "text-optional"?: PropertyValueSpecification<boolean>;
+            visibility?: VisibilitySpecification;
+        } | {
+            "circle-sort-key"?: DataDrivenPropertyValueSpecification<number>;
+            visibility?: VisibilitySpecification;
+        } | {
+            visibility?: VisibilitySpecification;
+        } | {
+            visibility?: VisibilitySpecification;
+        } | {
+            visibility?: VisibilitySpecification;
+        } | {
+            visibility?: VisibilitySpecification;
+        } | {
+            visibility?: VisibilitySpecification;
+        } | {
+            visibility?: VisibilitySpecification;
+        } | undefined;
+        paint?: {
+            "fill-antialias"?: PropertyValueSpecification<boolean>;
+            "fill-opacity"?: DataDrivenPropertyValueSpecification<number>;
+            "fill-opacity-transition"?: TransitionSpecification;
+            "fill-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
+            "fill-color-transition"?: TransitionSpecification;
+            "fill-outline-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
+            "fill-outline-color-transition"?: TransitionSpecification;
+            "fill-translate"?: PropertyValueSpecification<[number, number]>;
+            "fill-translate-transition"?: TransitionSpecification;
+            "fill-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
+            "fill-pattern"?: DataDrivenPropertyValueSpecification<ResolvedImageSpecification>;
+            "fill-pattern-transition"?: TransitionSpecification;
+        } | {
+            "line-opacity"?: DataDrivenPropertyValueSpecification<number>;
+            "line-opacity-transition"?: TransitionSpecification;
+            "line-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
+            "line-color-transition"?: TransitionSpecification;
+            "line-translate"?: PropertyValueSpecification<[number, number]>;
+            "line-translate-transition"?: TransitionSpecification;
+            "line-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
+            "line-width"?: DataDrivenPropertyValueSpecification<number>;
+            "line-width-transition"?: TransitionSpecification;
+            "line-gap-width"?: DataDrivenPropertyValueSpecification<number>;
+            "line-gap-width-transition"?: TransitionSpecification;
+            "line-offset"?: DataDrivenPropertyValueSpecification<number>;
+            "line-offset-transition"?: TransitionSpecification;
+            "line-blur"?: DataDrivenPropertyValueSpecification<number>;
+            "line-blur-transition"?: TransitionSpecification;
+            "line-dasharray"?: DataDrivenPropertyValueSpecification<Array<number>>;
+            "line-dasharray-transition"?: TransitionSpecification;
+            "line-pattern"?: DataDrivenPropertyValueSpecification<ResolvedImageSpecification>;
+            "line-pattern-transition"?: TransitionSpecification;
+            "line-gradient"?: ExpressionSpecification;
+        } | {
+            "icon-opacity"?: DataDrivenPropertyValueSpecification<number>;
+            "icon-opacity-transition"?: TransitionSpecification;
+            "icon-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
+            "icon-color-transition"?: TransitionSpecification;
+            "icon-halo-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
+            "icon-halo-color-transition"?: TransitionSpecification;
+            "icon-halo-width"?: DataDrivenPropertyValueSpecification<number>;
+            "icon-halo-width-transition"?: TransitionSpecification;
+            "icon-halo-blur"?: DataDrivenPropertyValueSpecification<number>;
+            "icon-halo-blur-transition"?: TransitionSpecification;
+            "icon-translate"?: PropertyValueSpecification<[number, number]>;
+            "icon-translate-transition"?: TransitionSpecification;
+            "icon-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
+            "text-opacity"?: DataDrivenPropertyValueSpecification<number>;
+            "text-opacity-transition"?: TransitionSpecification;
+            "text-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
+            "text-color-transition"?: TransitionSpecification;
+            "text-halo-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
+            "text-halo-color-transition"?: TransitionSpecification;
+            "text-halo-width"?: DataDrivenPropertyValueSpecification<number>;
+            "text-halo-width-transition"?: TransitionSpecification;
+            "text-halo-blur"?: DataDrivenPropertyValueSpecification<number>;
+            "text-halo-blur-transition"?: TransitionSpecification;
+            "text-translate"?: PropertyValueSpecification<[number, number]>;
+            "text-translate-transition"?: TransitionSpecification;
+            "text-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
+        } | {
+            "circle-radius"?: DataDrivenPropertyValueSpecification<number>;
+            "circle-radius-transition"?: TransitionSpecification;
+            "circle-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
+            "circle-color-transition"?: TransitionSpecification;
+            "circle-blur"?: DataDrivenPropertyValueSpecification<number>;
+            "circle-blur-transition"?: TransitionSpecification;
+            "circle-opacity"?: DataDrivenPropertyValueSpecification<number>;
+            "circle-opacity-transition"?: TransitionSpecification;
+            "circle-translate"?: PropertyValueSpecification<[number, number]>;
+            "circle-translate-transition"?: TransitionSpecification;
+            "circle-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
+            "circle-pitch-scale"?: PropertyValueSpecification<"map" | "viewport">;
+            "circle-pitch-alignment"?: PropertyValueSpecification<"map" | "viewport">;
+            "circle-stroke-width"?: DataDrivenPropertyValueSpecification<number>;
+            "circle-stroke-width-transition"?: TransitionSpecification;
+            "circle-stroke-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
+            "circle-stroke-color-transition"?: TransitionSpecification;
+            "circle-stroke-opacity"?: DataDrivenPropertyValueSpecification<number>;
+            "circle-stroke-opacity-transition"?: TransitionSpecification;
+        } | {
+            "heatmap-radius"?: DataDrivenPropertyValueSpecification<number>;
+            "heatmap-radius-transition"?: TransitionSpecification;
+            "heatmap-weight"?: DataDrivenPropertyValueSpecification<number>;
+            "heatmap-intensity"?: PropertyValueSpecification<number>;
+            "heatmap-intensity-transition"?: TransitionSpecification;
+            "heatmap-color"?: ExpressionSpecification;
+            "heatmap-opacity"?: PropertyValueSpecification<number>;
+            "heatmap-opacity-transition"?: TransitionSpecification;
+        } | {
+            "fill-extrusion-opacity"?: PropertyValueSpecification<number>;
+            "fill-extrusion-opacity-transition"?: TransitionSpecification;
+            "fill-extrusion-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
+            "fill-extrusion-color-transition"?: TransitionSpecification;
+            "fill-extrusion-translate"?: PropertyValueSpecification<[number, number]>;
+            "fill-extrusion-translate-transition"?: TransitionSpecification;
+            "fill-extrusion-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
+            "fill-extrusion-pattern"?: DataDrivenPropertyValueSpecification<ResolvedImageSpecification>;
+            "fill-extrusion-pattern-transition"?: TransitionSpecification;
+            "fill-extrusion-height"?: DataDrivenPropertyValueSpecification<number>;
+            "fill-extrusion-height-transition"?: TransitionSpecification;
+            "fill-extrusion-base"?: DataDrivenPropertyValueSpecification<number>;
+            "fill-extrusion-base-transition"?: TransitionSpecification;
+            "fill-extrusion-vertical-gradient"?: PropertyValueSpecification<boolean>;
+        } | {
+            "raster-opacity"?: PropertyValueSpecification<number>;
+            "raster-opacity-transition"?: TransitionSpecification;
+            "raster-hue-rotate"?: PropertyValueSpecification<number>;
+            "raster-hue-rotate-transition"?: TransitionSpecification;
+            "raster-brightness-min"?: PropertyValueSpecification<number>;
+            "raster-brightness-min-transition"?: TransitionSpecification;
+            "raster-brightness-max"?: PropertyValueSpecification<number>;
+            "raster-brightness-max-transition"?: TransitionSpecification;
+            "raster-saturation"?: PropertyValueSpecification<number>;
+            "raster-saturation-transition"?: TransitionSpecification;
+            "raster-contrast"?: PropertyValueSpecification<number>;
+            "raster-contrast-transition"?: TransitionSpecification;
+            resampling?: PropertyValueSpecification<"linear" | "nearest">;
+            "raster-resampling"?: PropertyValueSpecification<"linear" | "nearest">;
+            "raster-fade-duration"?: PropertyValueSpecification<number>;
+        } | {
+            "hillshade-illumination-direction"?: PropertyValueSpecification<NumberArraySpecification>;
+            "hillshade-illumination-altitude"?: PropertyValueSpecification<NumberArraySpecification>;
+            "hillshade-illumination-anchor"?: PropertyValueSpecification<"map" | "viewport">;
+            "hillshade-exaggeration"?: PropertyValueSpecification<number>;
+            "hillshade-exaggeration-transition"?: TransitionSpecification;
+            "hillshade-shadow-color"?: PropertyValueSpecification<ColorArraySpecification>;
+            "hillshade-shadow-color-transition"?: TransitionSpecification;
+            "hillshade-highlight-color"?: PropertyValueSpecification<ColorArraySpecification>;
+            "hillshade-highlight-color-transition"?: TransitionSpecification;
+            "hillshade-accent-color"?: PropertyValueSpecification<ColorSpecification>;
+            "hillshade-accent-color-transition"?: TransitionSpecification;
+            "hillshade-method"?: PropertyValueSpecification<"standard" | "basic" | "combined" | "igor" | "multidirectional">;
+            resampling?: PropertyValueSpecification<"linear" | "nearest">;
+        } | {
+            "color-relief-opacity"?: PropertyValueSpecification<number>;
+            "color-relief-opacity-transition"?: TransitionSpecification;
+            "color-relief-color"?: ExpressionSpecification;
+            resampling?: PropertyValueSpecification<"linear" | "nearest">;
+        } | {
+            "background-color"?: PropertyValueSpecification<ColorSpecification>;
+            "background-color-transition"?: TransitionSpecification;
+            "background-pattern"?: PropertyValueSpecification<ResolvedImageSpecification>;
+            "background-pattern-transition"?: TransitionSpecification;
+            "background-opacity"?: PropertyValueSpecification<number>;
+            "background-opacity-transition"?: TransitionSpecification;
+        } | undefined;
+        id: string;
+    }[];
+    error?: undefined;
+}>;
+
+/**
+ * Create the get-poi-category-codes tool.
+ */
+/** Standalone execute for ToolEntry format. */
+declare function executeGetPoiCategoryCodes(params: z.infer<typeof getPoiCategoryCodesSchema>, _state: ToolState): Promise<z.infer<typeof getPoiCategoryCodesOutputSchema>>;
+
+/** Execute function for getRouteProgress — usable with ToolEntry format. */
+declare function executeGetRouteProgress(params: z.infer<typeof getRouteProgressSchema>, state: ToolState): Promise<{
+    error: string;
+} | {
+    longitude: number;
+    latitude: number;
+    travelTimeInSeconds: number;
+    distanceInMeters: number;
+}>;
+
+/** Execute function for getSectionBBox — usable with ToolEntry format. */
+declare function executeGetSectionBBox(params: z.infer<typeof getSectionBBoxSchema>, state: ToolState): Promise<z.infer<typeof getSectionBBoxOutputSchema>>;
+
+/** Execute function for getSectionProgress — usable with ToolEntry format. */
+declare function executeGetSectionProgress(params: z.infer<typeof getSectionProgressSchema>, state: ToolState): Promise<{
+    error: string;
+    sectionType?: undefined;
+    sections?: undefined;
+} | {
+    sectionType: "leg" | "traffic" | "carpool" | "carTrain" | "country" | "ferry" | "importantRoadStretch" | "lanes" | "lowEmissionZone" | "motorway" | "pedestrian" | "roadShields" | "speedLimit" | "toll" | "tollVignette" | "tunnel" | "unpaved" | "urban" | "vehicleRestricted";
+    sections: object[];
+    error?: undefined;
+}>;
+
+/**
+ * Execute get shown incidents.
+ */
+declare function executeGetShownIncidents(_params: z.infer<typeof getShownIncidentsSchema>, state: ToolState): Promise<z.infer<typeof getShownIncidentsOutputSchema>>;
+
+/**
+ * Execute get shown places.
+ */
+declare function executeGetShownPlaces(_params: z.infer<typeof getShownPlacesSchema>, state: ToolState): Promise<{
+    count: number;
+    features: {
+        name: string | undefined;
+        address: string;
+        position: Position;
+    }[];
+    error?: undefined;
+} | {
+    error: string;
+    count?: undefined;
+    features?: undefined;
+}>;
+
+/**
+ * Execute get shown routes.
+ */
+declare function executeGetShownRoutes(_params: z.infer<typeof getShownRoutesSchema>, state: ToolState): Promise<z.infer<typeof getShownRoutesOutputSchema>>;
+
+/**
+ * Execute get shown route sections.
+ */
+declare function executeGetShownRouteSections(params: z.infer<typeof getShownRouteSectionsSchema>, state: ToolState): Promise<z.infer<typeof getShownRouteSectionsOutputSchema>>;
+
+/**
+ * Execute get shown route traffic incidents.
+ */
+declare function executeGetShownRouteTrafficIncidents(_params: z.infer<typeof getShownRouteTrafficIncidentsSchema>, state: ToolState): Promise<z.infer<typeof getShownRouteTrafficIncidentsOutputSchema>>;
+
+/**
+ * Execute get shown waypoints.
+ */
+declare function executeGetShownWaypoints(_params: z.infer<typeof getShownWaypointsSchema>, state: ToolState): Promise<z.infer<typeof getShownWaypointsOutputSchema>>;
+
+/**
+ * Execute get standard map styles.
+ */
+declare function executeGetStandardMapStyles(_params: z.infer<typeof getStandardMapStylesSchema>, _state: ToolState): Promise<z.infer<typeof getStandardMapStylesOutputSchema>>;
+
+/**
+ * Create the get traffic area analytics tool.
+ */
+/** Standalone execute for ToolEntry format. */
+declare function executeGetTrafficAreaAnalytics(params: z.infer<typeof getTrafficAreaAnalyticsSchema>, state: ToolState): Promise<z.infer<typeof getTrafficAreaAnalyticsOutputSchema>>;
+
+/**
+ * Create the get traffic incidents tool.
+ */
+/** Standalone execute for ToolEntry format. */
+declare function executeGetTrafficIncidents(params: z.infer<typeof getTrafficIncidentsSchema>, _state: ToolState): Promise<z.infer<typeof getTrafficIncidentsOutputSchema>>;
+
+/** Execute function for getViewport — usable with ToolEntry format. */
+declare function executeGetViewport(_params: z.infer<typeof getViewportSchema>, state: ToolState): Promise<{
+    center: [number, number];
+    zoom: number;
+    bbox: BBox;
+    pitch: number;
+    bearing: number;
+    error?: undefined;
+} | {
+    error: string;
+    center?: undefined;
+    zoom?: undefined;
+    bbox?: undefined;
+    pitch?: undefined;
+    bearing?: undefined;
+}>;
+
+/** Standalone execute for ToolEntry format. */
+declare function executeLocatePlace(params: z.infer<typeof locatePlaceSchema>, state: ToolState): Promise<z.infer<typeof locatePlaceOutputSchema>>;
+
+/** Input schema for the executeMaplibreCode tool. */
+declare const executeMaplibreCodeSchema: z.ZodObject<{
+    code: z.ZodString;
+}, z.core.$strip>;
+
+/**
+ * Create the query traffic analytics tool.
+ */
+/** Standalone execute for ToolEntry format. */
+declare function executeQueryTrafficAnalytics(params: z.infer<typeof queryTrafficAnalyticsSchema>, state: ToolState): Promise<z.infer<typeof queryTrafficAnalyticsOutputSchema>>;
+
+declare function executeRecallPlaces(params: z.infer<typeof recallPlacesSchema>, state: ToolState): Promise<z.infer<typeof recallPlacesOutputSchema>>;
+
+declare function executeRecallRanges(params: z.infer<typeof recallRangesSchema>, state: ToolState): Promise<z.infer<typeof recallRangesOutputSchema>>;
+
+declare function executeRecallRoutes(params: z.infer<typeof recallRoutesSchema>, state: ToolState): Promise<z.infer<typeof recallRoutesOutputSchema>>;
+
+/**
+ * Create the remove stop from route tool.
+ */
+/** Standalone execute for ToolEntry format. */
+declare function executeRemoveStopFromRoute(params: z.infer<typeof removeStopFromRouteSchema>, state: ToolState): Promise<z.infer<typeof removeStopFromRouteOutputSchema>>;
+
+/**
+ * Create the reverse geocode tool.
+ */
+/** Standalone execute for ToolEntry format. */
+declare function executeReverseGeocode(params: z.infer<typeof reverseGeocodeSchema>, state: ToolState): Promise<z.infer<typeof reverseGeocodeOutputSchema>>;
+
+/** Standalone execute for ToolEntry format. */
+declare function executeSearchAlongRoute(params: z.infer<typeof searchAlongRouteSchema>, state: ToolState): Promise<z.infer<typeof searchAlongRouteOutputSchema>>;
+
+/**
+ * Execute set language.
+ */
+declare function executeSetLanguage(params: z.infer<typeof setLanguageSchema>, state: ToolState): Promise<{
+    success: boolean;
+    language: string;
+    error?: undefined;
+} | {
+    error: string;
+    success?: undefined;
+    language?: undefined;
+}>;
+
+/** Execute function for setLayoutProperties — usable with ToolEntry format. */
+declare function executeSetLayoutProperties(params: z.infer<typeof setLayoutPropertiesSchema>, state: ToolState): Promise<{
+    results: ({
+        layerId: string;
+        propertyName: string;
+        value: any;
+        success: true;
+        error?: undefined;
+    } | {
+        layerId: string;
+        propertyName: string;
+        error: string;
+        value?: undefined;
+        success?: undefined;
+    })[];
+    error?: undefined;
+} | {
+    error: string;
+    results?: undefined;
+}>;
+
+/**
+ * Execute set map standard style.
+ */
+declare function executeSetMapStandardStyle(params: z.infer<typeof setMapStandardStyleSchema>, state: ToolState): Promise<{
+    success: boolean;
+    style: "standardLight" | "standardDark" | "drivingLight" | "drivingDark" | "monoLight" | "monoDark" | "satellite";
+    error?: undefined;
+} | {
+    error: string;
+    success?: undefined;
+    style?: undefined;
+}>;
+
+/** Execute function for setPaintProperties — usable with ToolEntry format. */
+declare function executeSetPaintProperties(params: z.infer<typeof setPaintPropertiesSchema>, state: ToolState): Promise<{
+    results: ({
+        layerId: string;
+        propertyName: string;
+        value: any;
+        success: true;
+        error?: undefined;
+    } | {
+        layerId: string;
+        propertyName: string;
+        error: string;
+        value?: undefined;
+        success?: undefined;
+    })[];
+    error?: undefined;
+} | {
+    error: string;
+    results?: undefined;
+}>;
+
+/** Execute function for setPitchBearing — usable with ToolEntry format. */
+declare function executeSetPitchBearing(params: z.infer<typeof setPitchBearingSchema>, state: ToolState): Promise<{
+    error: string;
+    success?: undefined;
+} | {
+    success: boolean;
+    error?: undefined;
+}>;
+
+/**
+ * Create the set-route-locations tool.
+ */
+/** Standalone execute for ToolEntry format. */
+declare function executeSetRouteLocations(params: z.infer<typeof setRouteLocationsSchema>, state: ToolState): Promise<z.infer<typeof setRouteLocationsOutputSchema>>;
+
+/**
+ * Create the set-route-parameters tool.
+ */
+/** Standalone execute for ToolEntry format. */
+declare function executeSetRouteParameters(params: z.infer<typeof setRouteParametersSchema>, state: ToolState): Promise<z.infer<typeof setRouteParametersOutputSchema>>;
+
+/**
+ * Execute set route theme.
+ */
+declare function executeSetRouteTheme(params: z.infer<typeof setRouteThemeSchema>, state: ToolState): Promise<{
+    success: true;
+    theme: {
+        mainColor?: string;
+    };
+    error?: undefined;
+} | {
+    error: string;
+    success?: undefined;
+    theme?: undefined;
+}>;
+
+/**
+ * Execute show places.
+ */
+declare function executeShowPlaces(params: z.infer<typeof showPlacesSchema>, state: ToolState): Promise<{
+    error: string;
+    success?: undefined;
+    count?: undefined;
+} | {
+    success: boolean;
+    count: number;
+    error?: undefined;
+}>;
+
+/**
+ * Execute show routes.
+ */
+declare function executeShowRoutes(params: z.infer<typeof showRouteSchema>, state: ToolState): Promise<{
+    error: string;
+    success?: undefined;
+    displayedRoute?: undefined;
+    routeCount?: undefined;
+} | {
+    success: boolean;
+    displayedRoute: number;
+    routeCount: number;
+    error?: undefined;
+}>;
+
+/**
+ * Execute show traffic area analytics.
+ */
+declare function executeShowTrafficAreaAnalytics(params: z.infer<typeof showTrafficAreaAnalyticsSchema>, state: ToolState): Promise<z.infer<typeof showTrafficAreaAnalyticsOutputSchema>>;
+
+/**
+ * Execute show waypoints.
+ */
+declare function executeShowWaypoints(_params: z.infer<typeof showWaypointsSchema>, state: ToolState): Promise<z.infer<typeof showWaypointsOutputSchema>>;
+
+/**
+ * Execute toggle base map layer groups.
+ */
+declare function executeToggleBaseMapLayerGroups(params: z.infer<typeof toggleBaseMapLayerGroupsSchema>, state: ToolState): Promise<{
+    success: boolean;
+    visible: boolean;
+    layerGroups: ("roadShields" | "land" | "water" | "borders" | "buildings2D" | "buildings3D" | "houseNumbers" | "roadLines" | "roadLabels" | "placeLabels" | "smallerTownLabels" | "cityLabels" | "capitalLabels" | "stateLabels" | "countryLabels")[];
+    error?: undefined;
+} | {
+    error: string;
+    success?: undefined;
+    visible?: undefined;
+    layerGroups?: undefined;
+}>;
+
+/**
+ * Execute toggle POIs.
+ */
+declare function executeTogglePOIs(params: z.infer<typeof togglePOIsSchema>, state: ToolState): Promise<z.infer<typeof togglePOIsOutputSchema>>;
+
+/**
+ * Execute toggle traffic flow.
+ */
+declare function executeToggleTrafficFlow(params: z.infer<typeof toggleTrafficFlowSchema>, state: ToolState): Promise<{
+    success: boolean;
+    trafficFlowVisible: boolean;
+    error?: undefined;
+} | {
+    error: string;
+    success?: undefined;
+    trafficFlowVisible?: undefined;
+}>;
+
+/**
+ * Execute toggle traffic incidents.
+ */
+declare function executeToggleTrafficIncidents(params: z.infer<typeof toggleTrafficIncidentsSchema>, state: ToolState): Promise<{
+    success: boolean;
+    trafficIncidentsVisible: boolean;
+    error?: undefined;
+} | {
+    error: string;
+    success?: undefined;
+    trafficIncidentsVisible?: undefined;
+}>;
+
+/** Execute function for zoomInOrOut — usable with ToolEntry format. */
+declare function executeZoomInOrOut(params: z.infer<typeof zoomInOrOutSchema>, state: ToolState): Promise<{
+    zoom: number;
+    error?: undefined;
+} | {
+    error: string;
+    zoom?: undefined;
+}>;
+
+/**
+ * Extracts the text content of the last user message in a message array.
+ * Returns null if no user message is found or if content has no text.
+ */
+export declare function extractLastUserText(messages: ReadonlyArray<ModelMessage>): string | null;
+
+declare const findReachableAreaOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    rangeId: z.ZodString;
+    originName: z.ZodString;
+    budgets: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            timeMinutes: "timeMinutes";
+            distanceKM: "distanceKM";
+        }>;
+        value: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodEnum<{
+        not_found: "not_found";
+        no_results: "no_results";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+declare const findReachableAreaSchema: z.ZodObject<{
+    origin: z.ZodUnion<readonly [z.ZodObject<{
+        query: z.ZodString;
+        locationType: z.ZodEnum<{
+            default: "default";
+            poi: "poi";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        position: z.ZodObject<{
+            lng: z.ZodNumber;
+            lat: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>;
+    budgets: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            timeMinutes: "timeMinutes";
+            distanceKM: "distanceKM";
+        }>;
+        value: z.ZodNumber;
+    }, z.core.$strip>>;
+    theme: z.ZodOptional<z.ZodEnum<{
+        filled: "filled";
+        outline: "outline";
+        inverted: "inverted";
+    }>>;
+    showOnMap: z.ZodBoolean;
+    showOriginPin: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+
+/**
+ * Tool schema for fitting route section bounds.
+ */
+declare const fitRouteSectionSchema: z.ZodObject<{
+    sectionType: z.ZodEnum<{
+        leg: "leg";
+        traffic: "traffic";
+        carpool: "carpool";
+        carTrain: "carTrain";
+        country: "country";
+        ferry: "ferry";
+        importantRoadStretch: "importantRoadStretch";
+        lanes: "lanes";
+        lowEmissionZone: "lowEmissionZone";
+        motorway: "motorway";
+        pedestrian: "pedestrian";
+        roadShields: "roadShields";
+        speedLimit: "speedLimit";
+        toll: "toll";
+        tollVignette: "tollVignette";
+        tunnel: "tunnel";
+        unpaved: "unpaved";
+        urban: "urban";
+        vehicleRestricted: "vehicleRestricted";
+    }>;
+    id: z.ZodString;
+    padding: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+
+/** Input schema for fly-to. */
+declare const flyToSchema: z.ZodObject<{
+    where: z.ZodUnion<readonly [z.ZodObject<{
+        boundingBox: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodNumber>]>, z.ZodObject<{
+            bbox: z.ZodUnion<readonly [z.ZodArray<z.ZodNumber>]>;
+        }, z.core.$strip>]>;
+        padding: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        position: z.ZodArray<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
+
+/**
+ * Tool schema for formatting distance.
+ */
+declare const formatDistanceSchema: z.ZodObject<{
+    meters: z.ZodNumber;
+    unitType: z.ZodOptional<z.ZodEnum<{
+        metric: "metric";
+        imperial_us: "imperial_us";
+        imperial_uk: "imperial_uk";
+    }>>;
+}, z.core.$strip>;
+
+/**
+ * Tool schema for formatting duration.
+ */
+declare const formatDurationSchema: z.ZodObject<{
+    seconds: z.ZodNumber;
+}, z.core.$strip>;
+
+/**
+ * Output schema for current location tool.
+ */
+declare const getCurrentLocationOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    position: z.ZodArray<z.ZodNumber>;
+    accuracy: z.ZodNumber;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/**
+ * Tool schema for retrieving browser current location.
+ */
+declare const getCurrentLocationSchema: z.ZodObject<{}, z.core.$strip>;
+
+declare const getCurrentWaypointsOutputSchema: z.ZodObject<{
+    totalSlots: z.ZodNumber;
+    filledSlots: z.ZodNumber;
+    matchedCount: z.ZodNumber;
+    returnedCount: z.ZodNumber;
+    offset: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+    nextOffset: z.ZodOptional<z.ZodNumber>;
+    waypoints: z.ZodArray<z.ZodObject<{
+        slotIndex: z.ZodNumber;
+        isFilled: z.ZodBoolean;
+        address: z.ZodOptional<z.ZodString>;
+        position: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+declare const getCurrentWaypointsSchema: z.ZodObject<{
+    slotIndex: z.ZodOptional<z.ZodNumber>;
+    includeEmptySlots: z.ZodOptional<z.ZodBoolean>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+
+/**
+ * Tool schema for getting map style layers.
+ */
+declare const getMapStyleLayersSchema: z.ZodObject<{
+    layerIdQuery: z.ZodOptional<z.ZodString>;
+    include: z.ZodArray<z.ZodEnum<{
+        layout: "layout";
+        paint: "paint";
+    }>>;
+}, z.core.$strip>;
+
+/** Output schema for the get-poi-category-codes tool. */
+declare const getPoiCategoryCodesOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    count: z.ZodNumber;
+    codes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/**
+ * Tool input schema for fetching POI category codes.
+ */
+declare const getPoiCategoryCodesSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    language: z.ZodString;
+}, z.core.$strip>;
+
+/**
+ * Tool schema for getting a coordinate position along a route.
+ * The three progress inputs are mutually exclusive — provide exactly one.
+ */
+declare const getRouteProgressSchema: z.ZodObject<{
+    routeIndex: z.ZodOptional<z.ZodNumber>;
+    traveledTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+    traveledDistanceInMeters: z.ZodOptional<z.ZodNumber>;
+    clockTime: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
+/** Output schema for the get-section-bbox tool. */
+declare const getSectionBBoxOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    bbox: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/** Input schema for the get-section-bbox tool. */
+declare const getSectionBBoxSchema: z.ZodObject<{
+    sectionType: z.ZodEnum<{
+        leg: "leg";
+        traffic: "traffic";
+        carpool: "carpool";
+        carTrain: "carTrain";
+        country: "country";
+        ferry: "ferry";
+        importantRoadStretch: "importantRoadStretch";
+        lanes: "lanes";
+        lowEmissionZone: "lowEmissionZone";
+        motorway: "motorway";
+        pedestrian: "pedestrian";
+        roadShields: "roadShields";
+        speedLimit: "speedLimit";
+        toll: "toll";
+        tollVignette: "tollVignette";
+        tunnel: "tunnel";
+        unpaved: "unpaved";
+        urban: "urban";
+        vehicleRestricted: "vehicleRestricted";
+    }>;
+    id: z.ZodString;
+}, z.core.$strip>;
+
+/**
+ * Tool schema for getting section progress.
+ */
+declare const getSectionProgressSchema: z.ZodObject<{
+    sectionType: z.ZodEnum<{
+        leg: "leg";
+        traffic: "traffic";
+        carpool: "carpool";
+        carTrain: "carTrain";
+        country: "country";
+        ferry: "ferry";
+        importantRoadStretch: "importantRoadStretch";
+        lanes: "lanes";
+        lowEmissionZone: "lowEmissionZone";
+        motorway: "motorway";
+        pedestrian: "pedestrian";
+        roadShields: "roadShields";
+        speedLimit: "speedLimit";
+        toll: "toll";
+        tollVignette: "tollVignette";
+        tunnel: "tunnel";
+        unpaved: "unpaved";
+        urban: "urban";
+        vehicleRestricted: "vehicleRestricted";
+    }>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+
+/** Output schema for the get-shown-incidents tool. */
+declare const getShownIncidentsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    count: z.ZodNumber;
+    trafficIncidents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        category: z.ZodString;
+        magnitudeOfDelay: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        delayInSeconds: z.ZodOptional<z.ZodNumber>;
+        roadCategory: z.ZodOptional<z.ZodString>;
+        averageSpeedKmph: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/**
+ * Tool schema for getting shown traffic incidents on map.
+ */
+declare const getShownIncidentsSchema: z.ZodObject<{}, z.core.$strip>;
+
+/**
+ * Tool schema for getting shown places on map.
+ */
+declare const getShownPlacesSchema: z.ZodObject<{}, z.core.$strip>;
+
+/** Output schema for the get-shown-route-sections tool. */
+declare const getShownRouteSectionsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    sectionType: z.ZodString;
+    routes: z.ZodArray<z.ZodObject<{
+        routeIndex: z.ZodNumber;
+        sections: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/** Input schema for the get-shown-route-sections tool. */
+declare const getShownRouteSectionsSchema: z.ZodObject<{
+    sectionType: z.ZodEnum<{
+        leg: "leg";
+        traffic: "traffic";
+        carpool: "carpool";
+        carTrain: "carTrain";
+        country: "country";
+        ferry: "ferry";
+        importantRoadStretch: "importantRoadStretch";
+        lanes: "lanes";
+        lowEmissionZone: "lowEmissionZone";
+        motorway: "motorway";
+        pedestrian: "pedestrian";
+        roadShields: "roadShields";
+        speedLimit: "speedLimit";
+        toll: "toll";
+        tollVignette: "tollVignette";
+        tunnel: "tunnel";
+        unpaved: "unpaved";
+        urban: "urban";
+        vehicleRestricted: "vehicleRestricted";
+    }>;
+}, z.core.$strip>;
+
+/** Output schema for the get-shown-routes tool. */
+declare const getShownRoutesOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    count: z.ZodNumber;
+    routes: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        summary: z.ZodObject<{
+            travelTimeInSeconds: z.ZodNumber;
+            lengthInMeters: z.ZodNumber;
+            trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
+            trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
+            departureTime: z.ZodOptional<z.ZodString>;
+            arrivalTime: z.ZodOptional<z.ZodString>;
+            noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        legSummaries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            travelTimeInSeconds: z.ZodNumber;
+            lengthInMeters: z.ZodNumber;
+            trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
+            trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
+            departureTime: z.ZodOptional<z.ZodString>;
+            arrivalTime: z.ZodOptional<z.ZodString>;
+            noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/**
+ * Tool schema for getting shown routes on map.
+ */
+declare const getShownRoutesSchema: z.ZodObject<{}, z.core.$strip>;
+
+/** Output schema for the get-shown-route-traffic-incidents tool. */
+declare const getShownRouteTrafficIncidentsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    count: z.ZodNumber;
+    trafficIncidents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        magnitudeOfDelay: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        delayInSeconds: z.ZodOptional<z.ZodNumber>;
+        effectiveSpeedInKmh: z.ZodOptional<z.ZodNumber>;
+        categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/**
+ * Tool schema for getting shown route traffic incidents on map.
+ */
+declare const getShownRouteTrafficIncidentsSchema: z.ZodObject<{}, z.core.$strip>;
+
+/** Output schema for the get-shown-waypoints tool. */
+declare const getShownWaypointsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    count: z.ZodNumber;
+    waypoints: z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodUnknown>;
+        position: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/**
+ * Tool schema for getting shown waypoints on map.
+ */
+declare const getShownWaypointsSchema: z.ZodObject<{}, z.core.$strip>;
+
+/** Output schema for the get-standard-map-styles tool. */
+declare const getStandardMapStylesOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    styles: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/**
+ * Tool schema for getting standard map styles.
+ */
+declare const getStandardMapStylesSchema: z.ZodObject<{}, z.core.$strip>;
+
+/** Output schema for the get-traffic-area-analytics tool. */
+declare const getTrafficAreaAnalyticsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodOptional<z.ZodString>;
+    dateRange: z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+    }, z.core.$strip>;
+    baseData: z.ZodObject<{
+        speed: z.ZodOptional<z.ZodNumber>;
+        freeFlowSpeed: z.ZodOptional<z.ZodNumber>;
+        congestionLevel: z.ZodOptional<z.ZodNumber>;
+        travelTime: z.ZodOptional<z.ZodNumber>;
+        networkLength: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    metrics: z.ZodArray<z.ZodString>;
+    tileCount: z.ZodNumber;
+    availableGranularities: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/**
+ * Tool schema for fetching traffic area analytics.
+ */
+declare const getTrafficAreaAnalyticsSchema: z.ZodObject<{
+    location: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        query: z.ZodString;
+        locationType: z.ZodEnum<{
+            default: "default";
+            poi: "poi";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        position: z.ZodObject<{
+            lng: z.ZodNumber;
+            lat: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>>;
+    bbox: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    showOnMap: z.ZodOptional<z.ZodBoolean>;
+    startDate: z.ZodOptional<z.ZodString>;
+    endDate: z.ZodOptional<z.ZodString>;
+    days: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metrics: z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodEnum<{
+        speed: "speed";
+        congestionLevel: "congestionLevel";
+        freeFlowSpeed: "freeFlowSpeed";
+        travelTime: "travelTime";
+        networkLength: "networkLength";
+    }>>]>;
+    functionalRoadClasses: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodEnum<{
+        MOTORWAY: "MOTORWAY";
+        MAJOR_ROAD: "MAJOR_ROAD";
+        OTHER_MAJOR_ROAD: "OTHER_MAJOR_ROAD";
+        SECONDARY_ROAD: "SECONDARY_ROAD";
+        LOCAL_CONNECTING_ROAD: "LOCAL_CONNECTING_ROAD";
+        LOCAL_ROAD_HIGH_IMPORTANCE: "LOCAL_ROAD_HIGH_IMPORTANCE";
+        LOCAL_ROAD: "LOCAL_ROAD";
+        LOCAL_ROAD_MINOR_IMPORTANCE: "LOCAL_ROAD_MINOR_IMPORTANCE";
+        OTHER_ROAD: "OTHER_ROAD";
+    }>>]>>;
+    hours: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodNumber>]>>;
+}, z.core.$strip>;
+
+/** Output schema for the get-traffic-incidents tool. */
+declare const getTrafficIncidentsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    count: z.ZodNumber;
+    incidents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        category: z.ZodString;
+        magnitudeOfDelay: z.ZodString;
+        timeValidity: z.ZodString;
+        events: z.ZodArray<z.ZodObject<{
+            description: z.ZodString;
+            category: z.ZodString;
+        }, z.core.$strip>>;
+        from: z.ZodOptional<z.ZodString>;
+        to: z.ZodOptional<z.ZodString>;
+        roadNumbers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        lengthInMeters: z.ZodOptional<z.ZodNumber>;
+        delayInSeconds: z.ZodOptional<z.ZodNumber>;
+        startTime: z.ZodOptional<z.ZodDate>;
+        endTime: z.ZodOptional<z.ZodDate>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/**
+ * Tool schema for fetching traffic incident details.
+ */
+declare const getTrafficIncidentsSchema: z.ZodObject<{
+    bbox: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    categoryFilter: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        accident: "accident";
+        "animals-on-road": "animals-on-road";
+        "broken-down-vehicle": "broken-down-vehicle";
+        danger: "danger";
+        flooding: "flooding";
+        fog: "fog";
+        frost: "frost";
+        jam: "jam";
+        "lane-closed": "lane-closed";
+        "narrow-lanes": "narrow-lanes";
+        other: "other";
+        rain: "rain";
+        "road-closed": "road-closed";
+        roadworks: "roadworks";
+        wind: "wind";
+    }>>>;
+    timeValidityFilter: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        present: "present";
+        future: "future";
+    }>>>;
+}, z.core.$strip>;
+
+/**
+ * Tool schema for getting viewport.
+ */
+declare const getViewportSchema: z.ZodObject<{}, z.core.$strip>;
+
+declare const locatePlaceOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodString>;
+    position: z.ZodArray<z.ZodNumber>;
+    waypointIndex: z.ZodOptional<z.ZodNumber>;
+    shown: z.ZodOptional<z.ZodObject<{
+        markerType: z.ZodBoolean;
+        zoomMode: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+declare const locatePlaceSchema: z.ZodObject<{
+    query: z.ZodString;
+    waypointIndex: z.ZodOptional<z.ZodNumber>;
+    locationType: z.ZodEnum<{
+        default: "default";
+        poi: "poi";
+    }>;
+    where: z.ZodUnion<readonly [z.ZodObject<{
+        position: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        boundingBox: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodNumber>]>, z.ZodObject<{
+            bbox: z.ZodUnion<readonly [z.ZodArray<z.ZodNumber>]>;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>, z.ZodLiteral<"within-map-bounds">, z.ZodLiteral<"nearby-map-center">, z.ZodLiteral<"global">, z.ZodString]>;
+    show: z.ZodOptional<z.ZodObject<{
+        markerType: z.ZodEnum<{
+            pin: "pin";
+            none: "none";
+        }>;
+        zoomMode: z.ZodEnum<{
+            none: "none";
+            auto: "auto";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+/**
+ * The return type of createMapAgent().
+ * A real ToolLoopAgent instance with state access and cleanup.
+ */
+export declare type MapAgentInstance<CS extends ToolState = ToolState> = ToolLoopAgent & {
+    /** Live agent state (built-in + custom slices). */
+    readonly state: CS;
+    /** Tear down: resets all state slices that have a reset() method. */
+    destroy(): void;
+};
+
+/**
+ * Options for creating an agent toolkit.
+ *
+ * @typeParam CS - Full state type. Must extend `ToolState`. Defaults to base `ToolState` (no custom slices).
+ *
+ * @example Custom state
+ * ```typescript
+ * interface MyState extends ToolState {
+ *     fleet: FleetState;
+ * }
+ *
+ * createMapAgent<MyState>(map, {
+ *     model,
+ *     state: { fleet: new FleetState() },
+ * });
+ * ```
+ */
+export declare type MapAgentOptions<CS extends ToolState = ToolState> = {
+    /** AI SDK language model instance. REQUIRED — no default provider. */
+    model: LanguageModel;
+    /**
+     * Complete system prompt that replaces the default.
+     * If provided, `systemPromptSuffix` is ignored.
+     */
+    systemPrompt?: string;
+    /**
+     * Additional text appended to the built-in prompt.
+     * Ignored if `systemPrompt` is provided.
+     */
+    systemPromptSuffix?: string;
+    /**
+     * Whether to include all built-in default tools.
+     * Defaults to `true`. Set to `false` to start with no defaults
+     * and provide only custom tools via `tools`.
+     */
+    includeDefaultTools?: boolean;
+    /**
+     * Tool overrides merged with default tools.
+     * - `ToolEntry` values add a new tool or replace a default.
+     * - `false` values exclude a default tool.
+     *
+     * When omitted, all default tools are used as-is.
+     *
+     * @example
+     * ```typescript
+     * // Add a custom tool (defaults included automatically)
+     * createMapAgent(map, {
+     *     model,
+     *     tools: { getCustomLocation: myTool },
+     * });
+     *
+     * // Remove a default tool
+     * createMapAgent(map, {
+     *     model,
+     *     tools: { setLanguage: false },
+     * });
+     * ```
+     */
+    tools?: {
+        [K in ToolNameHint]?: ToolEntry<CS> | false | undefined;
+    };
+    /**
+     * Custom state slices merged alongside built-in state.
+     * Only custom slices need to be provided — built-in slices are created automatically.
+     * Accessible in custom tool `execute` via the state parameter.
+     */
+    state?: Omit<CS, keyof ToolState>;
+    /**
+     * Pluggable classifier for automatic tool selection.
+     * - Omit to use the default LLM-based classifier (uses main model)
+     * - Pass a `Classifier` function for custom logic
+     * - Pass `false` to disable classification entirely
+     */
+    classifier?: Classifier | false;
+    /**
+     * Called after each classification. Use to observe selected tools or log.
+     */
+    onClassify?: (result: ClassificationResult | null) => void;
+    /**
+     * Custom prepareStep hook, composed with internal classification step.
+     * Your `activeTools` are intersected with the classifier's selection.
+     */
+    prepareStep?: PrepareStepFunction;
+    /**
+     * Whether to include output schemas on tools.
+     * Defaults to `true`. Set to `false` for providers that don't support structured tool outputs.
+     */
+    outputSchemas?: boolean;
+    /** Max multi-step tool loop iterations. Default: 10. */
+    maxSteps?: number;
+};
+
+/**
+ * State for the map POI layer (points of interest overlay).
+ *
+ * Holds the lazy-initialized POIsModule for showing, hiding, and filtering
+ * the built-in POI categories rendered on the base map.
+ */
+declare class MapPOIsState implements StateSlice {
+    private readonly _ttMap;
+    private _poisModule?;
+    constructor(_ttMap: TomTomMap);
+    getPOIsModule(): Promise<POIsModule>;
+    get poisModule(): POIsModule | undefined;
+    reset(): void;
+}
+
+declare interface PlacesEntry {
+    id: string;
+    timestamp: number;
+    label: string;
+    data: Place[];
+}
+
+/**
+ * State for place search, geocoding, and geometries.
+ *
+ * Holds lazy-initialized PlacesModule and GeometriesModule alongside an
+ * append-only history of place and search results produced during the session.
+ */
+declare class PlacesState implements StateSlice {
+    private readonly _ttMap;
+    private _placesModule?;
+    private _entries;
+    constructor(_ttMap: TomTomMap);
+    getPlacesModule(): Promise<PlacesModule>;
+    get placesModule(): PlacesModule | undefined;
+    get entries(): readonly PlacesEntry[];
+    /**
+     * This is used purely to pass data between tools in a context-dependent way,
+     * so we assume the most recent entry is the relevant one to show on the map.
+     */
+    get latestPlace(): Place[] | undefined;
+    addPlaceResult(place: Place | Places, label: string): string;
+    reset(): void;
+}
+
+/** Output schema for the query-traffic-analytics tool. */
+declare const queryTrafficAnalyticsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    granularity: z.ZodString;
+    count: z.ZodNumber;
+    entries: z.ZodArray<z.ZodObject<{
+        speed: z.ZodOptional<z.ZodNumber>;
+        freeFlowSpeed: z.ZodOptional<z.ZodNumber>;
+        congestionLevel: z.ZodOptional<z.ZodNumber>;
+        travelTime: z.ZodOptional<z.ZodNumber>;
+        networkLength: z.ZodOptional<z.ZodNumber>;
+        date: z.ZodOptional<z.ZodString>;
+        hour: z.ZodOptional<z.ZodNumber>;
+        year: z.ZodOptional<z.ZodNumber>;
+        month: z.ZodOptional<z.ZodNumber>;
+        week: z.ZodOptional<z.ZodNumber>;
+        day: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    currentVisualization: z.ZodOptional<z.ZodObject<{
+        activeMetric: z.ZodOptional<z.ZodString>;
+        displayMode: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+declare const queryTrafficAnalyticsSchema: z.ZodObject<{
+    granularity: z.ZodOptional<z.ZodEnum<{
+        yearly: "yearly";
+        monthly: "monthly";
+        weekly: "weekly";
+        daily: "daily";
+        hourly: "hourly";
+        average: "average";
+    }>>;
+    metric: z.ZodOptional<z.ZodEnum<{
+        speed: "speed";
+        congestionLevel: "congestionLevel";
+        freeFlowSpeed: "freeFlowSpeed";
+        travelTime: "travelTime";
+        networkLength: "networkLength";
+    }>>;
+    startDate: z.ZodOptional<z.ZodString>;
+    endDate: z.ZodOptional<z.ZodString>;
+    hourStart: z.ZodOptional<z.ZodNumber>;
+    hourEnd: z.ZodOptional<z.ZodNumber>;
+    dayOfWeek: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+
+declare interface RangeEntry {
+    id: string;
+    timestamp: number;
+    label: string;
+    origin: {
+        query?: string;
+        position: Position;
+    };
+    budgets: ReachableRangeBudget[];
+    /** Raw polygon result for use in subsequent geometry searches. Not exposed to the agent. */
+    polygon?: PolygonFeatures;
+}
+
+/**
+ * State for reachable range results.
+ *
+ * Stores semantic summaries of calculated ranges (origin, budgets).
+ * Also retains raw polygon geometry internally for use in geometry searches
+ * (e.g. discoverPlaces withinRange). Displayed on the map via GeometriesModule.
+ */
+declare class RangeState implements StateSlice {
+    private readonly _ttMap;
+    private _entries;
+    private _placesModule?;
+    private _geometriesModule?;
+    private _currentTheme?;
+    constructor(_ttMap: TomTomMap);
+    getPlacesModule(): Promise<PlacesModule>;
+    getGeometriesModule(theme: GeometryTheme): Promise<GeometriesModule>;
+    get geometriesModule(): GeometriesModule | undefined;
+    get entries(): readonly RangeEntry[];
+    get latestEntry(): RangeEntry | undefined;
+    addEntry(entry: Omit<RangeEntry, 'id' | 'timestamp'>): string;
+    reset(): void;
+}
+
+declare const recallPlacesOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    timestamp: z.ZodNumber;
+    places: z.ZodObject<{
+        count: z.ZodNumber;
+        features: z.ZodArray<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            address: z.ZodOptional<z.ZodString>;
+            position: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+declare const recallPlacesSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
+declare const recallRangesOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    timestamp: z.ZodNumber;
+    origin: z.ZodObject<{
+        query: z.ZodOptional<z.ZodString>;
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    }, z.core.$strip>;
+    budgets: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        value: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+declare const recallRangesSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
+declare const recallRoutesOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    timestamp: z.ZodNumber;
+    routes: z.ZodObject<{
+        count: z.ZodNumber;
+        routes: z.ZodArray<z.ZodObject<{
+            index: z.ZodNumber;
+            summary: z.ZodObject<{
+                travelTimeInSeconds: z.ZodNumber;
+                lengthInMeters: z.ZodNumber;
+                trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
+                trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
+                departureTime: z.ZodOptional<z.ZodString>;
+                arrivalTime: z.ZodOptional<z.ZodString>;
+                noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+                historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+                liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+            legSummaries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                travelTimeInSeconds: z.ZodNumber;
+                lengthInMeters: z.ZodNumber;
+                trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
+                trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
+                departureTime: z.ZodOptional<z.ZodString>;
+                arrivalTime: z.ZodOptional<z.ZodString>;
+                noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+                historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+                liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    waypoints: z.ZodArray<z.ZodObject<{
+        position: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+    params: z.ZodObject<{
+        maxAlternatives: z.ZodOptional<z.ZodNumber>;
+        costModel: z.ZodOptional<z.ZodObject<{
+            routeType: z.ZodOptional<z.ZodEnum<{
+                fast: "fast";
+                short: "short";
+                efficient: "efficient";
+                thrilling: "thrilling";
+            }>>;
+            traffic: z.ZodOptional<z.ZodEnum<{
+                live: "live";
+                historical: "historical";
+            }>>;
+            avoid: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                tollRoads: "tollRoads";
+                motorways: "motorways";
+                ferries: "ferries";
+                unpavedRoads: "unpavedRoads";
+                carpools: "carpools";
+                alreadyUsedRoads: "alreadyUsedRoads";
+                borderCrossings: "borderCrossings";
+                tunnels: "tunnels";
+                carTrains: "carTrains";
+                lowEmissionZones: "lowEmissionZones";
+            }>>>;
+            avoidAreas: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNumber>>>;
+        }, z.core.$strip>>;
+        when: z.ZodOptional<z.ZodObject<{
+            option: z.ZodEnum<{
+                departAt: "departAt";
+                arriveBy: "arriveBy";
+            }>;
+            date: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+declare const recallRoutesSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
+/** Output schema for the remove-stop-from-route tool. */
+declare const removeStopFromRouteOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    count: z.ZodNumber;
+    routes: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        summary: z.ZodObject<{
+            travelTimeInSeconds: z.ZodNumber;
+            lengthInMeters: z.ZodNumber;
+            trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
+            trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
+            departureTime: z.ZodOptional<z.ZodString>;
+            arrivalTime: z.ZodOptional<z.ZodString>;
+            noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        legSummaries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            travelTimeInSeconds: z.ZodNumber;
+            lengthInMeters: z.ZodNumber;
+            trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
+            trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
+            departureTime: z.ZodOptional<z.ZodString>;
+            arrivalTime: z.ZodOptional<z.ZodString>;
+            noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/**
+ * Tool schema for removing a stop from an existing route.
+ */
+declare const removeStopFromRouteSchema: z.ZodObject<{
+    stopIndex: z.ZodNumber;
+    showOnMap: z.ZodBoolean;
+}, z.core.$strip>;
+
+/**
+ * Merges default tools with user overrides.
+ *
+ * - `ToolEntry` values add or replace tools in `defaults`.
+ * - `false` values remove tools from `defaults`.
+ * - Returns a new object — `defaults` is never mutated.
+ *
+ * @param defaults - Base tool record (typically DEFAULT_TOOLS or empty).
+ * @param overrides - User-provided additions, replacements, and exclusions.
+ * @returns Resolved tool record ready for setupTools.
+ */
+export declare function resolveTools<S extends ToolState>(defaults: Record<string, ToolEntry<S>>, overrides?: {
+    [K in ToolNameHint]?: ToolEntry<S> | false | undefined;
+}): Record<string, ToolEntry<S>>;
+
+/** Output schema for the reverse-geocode tool. */
+declare const reverseGeocodeOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodString>;
+    position: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/**
+ * Tool schema for reverse geocoding (coordinates to address).
+ */
+declare const reverseGeocodeSchema: z.ZodObject<{
+    position: z.ZodArray<z.ZodNumber>;
+}, z.core.$strip>;
+
+/**
+ * Route planning parameters stored in routing state.
+ * Consumed by setRouteLocations, addStopToRoute, and removeStopFromRoute.
+ */
+declare interface RouteParams {
+    maxAlternatives?: number;
+    costModel?: {
+        routeType?: string;
+        traffic?: 'live' | 'historical';
+        avoid?: string[];
+        avoidAreas?: Array<number[]>;
+    };
+    when?: {
+        option: 'departAt' | 'arriveBy';
+        date: string;
+    };
+}
+
+declare interface RoutesEntry {
+    id: string;
+    timestamp: number;
+    label: string;
+    data: Routes;
+    waypoints: WaypointLike[];
+    params: RouteParams;
+}
+
+/**
+ * State for route calculation, waypoint management, and route planning parameters.
+ *
+ * Holds the lazy-initialized RoutingModule alongside an append-only history of
+ * calculated routes, sparse planning slots (being assembled before a calculation),
+ * and current route parameters.
+ */
+declare class RoutingState implements StateSlice {
+    private readonly _ttMap;
+    private _routingModule?;
+    private _entries;
+    private _planningSlots;
+    private _params;
+    constructor(_ttMap: TomTomMap);
+    getRoutingModule(): Promise<RoutingModule>;
+    get routingModule(): RoutingModule | undefined;
+    get entries(): readonly RoutesEntry[];
+    get currentRoutes(): Routes | undefined;
+    get currentWaypoints(): WaypointLike[] | undefined;
+    /** Sparse nullable slots being assembled before triggering a route calculation. */
+    get planningSlots(): PlanningWaypoint[];
+    get params(): RouteParams;
+    addRoutes(routes: Routes, waypoints: WaypointLike[], label: string): void;
+    setWaypointAt(index: number, waypoint: WaypointLike): void;
+    setParams(params: Partial<RouteParams>): void;
+    reset(): void;
+}
+
+declare const searchAlongRouteOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    count: z.ZodNumber;
+    features: z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        address: z.ZodOptional<z.ZodString>;
+        position: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+    placeResultIndex: z.ZodString;
+    shown: z.ZodOptional<z.ZodObject<{
+        markerType: z.ZodBoolean;
+        zoomMode: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"no_route">;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+declare const searchAlongRouteSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    poiCategories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    routeId: z.ZodOptional<z.ZodString>;
+    maxDetourTimeSeconds: z.ZodNumber;
+    sortBy: z.ZodOptional<z.ZodEnum<{
+        detourTime: "detourTime";
+        detourOffset: "detourOffset";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    show: z.ZodOptional<z.ZodObject<{
+        markerType: z.ZodEnum<{
+            pin: "pin";
+            none: "none";
+        }>;
+        zoomMode: z.ZodEnum<{
+            none: "none";
+            auto: "auto";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+/**
+ * Tool schema for setting language.
+ */
+declare const setLanguageSchema: z.ZodObject<{
+    language: z.ZodString;
+}, z.core.$strip>;
+
+/** Input schema for the setLayoutProperties tool. */
+declare const setLayoutPropertiesSchema: z.ZodObject<{
+    changes: z.ZodArray<z.ZodObject<{
+        layerId: z.ZodString;
+        propertyName: z.ZodString;
+        value: z.ZodAny;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+/**
+ * Tool schema for setting a standard map style.
+ */
+declare const setMapStandardStyleSchema: z.ZodObject<{
+    style: z.ZodEnum<{
+        standardLight: "standardLight";
+        standardDark: "standardDark";
+        drivingLight: "drivingLight";
+        drivingDark: "drivingDark";
+        monoLight: "monoLight";
+        monoDark: "monoDark";
+        satellite: "satellite";
+    }>;
+}, z.core.$strip>;
+
+/** Input schema for the setPaintProperties tool. */
+declare const setPaintPropertiesSchema: z.ZodObject<{
+    changes: z.ZodArray<z.ZodObject<{
+        layerId: z.ZodString;
+        propertyName: z.ZodString;
+        value: z.ZodAny;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+/**
+ * Tool schema for setting pitch and bearing.
+ */
+declare const setPitchBearingSchema: z.ZodObject<{
+    pitch: z.ZodOptional<z.ZodNumber>;
+    bearing: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+
+/** Output schema for the set-route-locations tool. */
+declare const setRouteLocationsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    count: z.ZodNumber;
+    routes: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        summary: z.ZodObject<{
+            travelTimeInSeconds: z.ZodNumber;
+            lengthInMeters: z.ZodNumber;
+            trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
+            trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
+            departureTime: z.ZodOptional<z.ZodString>;
+            arrivalTime: z.ZodOptional<z.ZodString>;
+            noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        legSummaries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            travelTimeInSeconds: z.ZodNumber;
+            lengthInMeters: z.ZodNumber;
+            trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
+            trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
+            departureTime: z.ZodOptional<z.ZodString>;
+            arrivalTime: z.ZodOptional<z.ZodString>;
+            noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/** Input schema for set-route-locations. */
+declare const setRouteLocationsSchema: z.ZodObject<{
+    locations: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        query: z.ZodString;
+        locationType: z.ZodEnum<{
+            default: "default";
+            poi: "poi";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        position: z.ZodObject<{
+            lng: z.ZodNumber;
+            lat: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>>;
+    showOnMap: z.ZodBoolean;
+}, z.core.$strip>;
+
+/** Output schema for set-route-parameters. */
+declare const setRouteParametersOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    count: z.ZodNumber;
+    routes: z.ZodArray<z.ZodObject<{
+        index: z.ZodNumber;
+        summary: z.ZodObject<{
+            travelTimeInSeconds: z.ZodNumber;
+            lengthInMeters: z.ZodNumber;
+            trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
+            trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
+            departureTime: z.ZodOptional<z.ZodString>;
+            arrivalTime: z.ZodOptional<z.ZodString>;
+            noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        legSummaries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            travelTimeInSeconds: z.ZodNumber;
+            lengthInMeters: z.ZodNumber;
+            trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
+            trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
+            departureTime: z.ZodOptional<z.ZodString>;
+            arrivalTime: z.ZodOptional<z.ZodString>;
+            noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+            liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    success: z.ZodLiteral<true>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/** Input schema for set-route-parameters. */
+declare const setRouteParametersSchema: z.ZodObject<{
+    maxAlternatives: z.ZodOptional<z.ZodNumber>;
+    costModel: z.ZodOptional<z.ZodObject<{
+        routeType: z.ZodOptional<z.ZodEnum<{
+            fast: "fast";
+            short: "short";
+            efficient: "efficient";
+            thrilling: "thrilling";
+        }>>;
+        traffic: z.ZodOptional<z.ZodEnum<{
+            live: "live";
+            historical: "historical";
+        }>>;
+        avoid: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            tollRoads: "tollRoads";
+            motorways: "motorways";
+            ferries: "ferries";
+            unpavedRoads: "unpavedRoads";
+            carpools: "carpools";
+            alreadyUsedRoads: "alreadyUsedRoads";
+            borderCrossings: "borderCrossings";
+            tunnels: "tunnels";
+            carTrains: "carTrains";
+            lowEmissionZones: "lowEmissionZones";
+        }>>>;
+        avoidAreas: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNumber>>>;
+    }, z.core.$strip>>;
+    when: z.ZodOptional<z.ZodObject<{
+        option: z.ZodEnum<{
+            departAt: "departAt";
+            arriveBy: "arriveBy";
+        }>;
+        date: z.ZodString;
+    }, z.core.$strip>>;
+    showOnMap: z.ZodBoolean;
+}, z.core.$strip>;
+
+/**
+ * Tool schema for setting route theme.
+ */
+declare const setRouteThemeSchema: z.ZodObject<{
+    mainColor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+
+/**
+ * Tool schema for showing places on the map.
+ */
+declare const showPlacesSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    fitBounds: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+
+/**
+ * Tool schema for showing routes on the map.
+ */
+declare const showRouteSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    selectedIndex: z.ZodOptional<z.ZodNumber>;
+    fitBounds: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+
+/** Output schema for the show-traffic-area-analytics tool. */
+declare const showTrafficAreaAnalyticsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    mode: z.ZodString;
+    metric: z.ZodString;
+    colorTheme: z.ZodString;
+    visible: z.ZodBoolean;
+    filtered: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/**
+ * Tool schema for showing traffic area analytics on the map.
+ */
+declare const showTrafficAreaAnalyticsSchema: z.ZodObject<{
+    mode: z.ZodOptional<z.ZodEnum<{
+        heatmap: "heatmap";
+        "hexgrid-3d": "hexgrid-3d";
+        "hexgrid-2d": "hexgrid-2d";
+        "square-3d": "square-3d";
+        "square-2d": "square-2d";
+    }>>;
+    metric: z.ZodOptional<z.ZodEnum<{
+        speed: "speed";
+        congestionLevel: "congestionLevel";
+        travelTime: "travelTime";
+    }>>;
+    colorTheme: z.ZodOptional<z.ZodEnum<{
+        trafficLight: "trafficLight";
+        heat: "heat";
+        monochrome: "monochrome";
+        viridis: "viridis";
+        plasma: "plasma";
+    }>>;
+    heightScale: z.ZodOptional<z.ZodNumber>;
+    scaleMode: z.ZodOptional<z.ZodEnum<{
+        raw: "raw";
+        predefinedRange: "predefinedRange";
+        currentRange: "currentRange";
+    }>>;
+    filter: z.ZodOptional<z.ZodObject<{
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    visible: z.ZodOptional<z.ZodBoolean>;
+    fitBounds: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+
+/** Output schema for the show-waypoints tool. */
+declare const showWaypointsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    count: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/**
+ * Tool schema for showing waypoints on the map.
+ */
+declare const showWaypointsSchema: z.ZodObject<{}, z.core.$strip>;
+
+/**
+ * Common interface for state slices. Implement `reset()` to participate
+ * in cleanup when `destroy()` is called on the agent.
+ *
+ * All built-in state classes implement this. Custom slices can optionally
+ * implement it to get automatic cleanup.
+ */
+export declare interface StateSlice {
+    reset(): void;
+}
+
+/**
+ * Tool schema for toggling base map layer groups.
+ */
+declare const toggleBaseMapLayerGroupsSchema: z.ZodObject<{
+    visible: z.ZodBoolean;
+    layerGroups: z.ZodArray<z.ZodEnum<{
+        roadShields: "roadShields";
+        land: "land";
+        water: "water";
+        borders: "borders";
+        buildings2D: "buildings2D";
+        buildings3D: "buildings3D";
+        houseNumbers: "houseNumbers";
+        roadLines: "roadLines";
+        roadLabels: "roadLabels";
+        placeLabels: "placeLabels";
+        smallerTownLabels: "smallerTownLabels";
+        cityLabels: "cityLabels";
+        capitalLabels: "capitalLabels";
+        stateLabels: "stateLabels";
+        countryLabels: "countryLabels";
+    }>>;
+}, z.core.$strip>;
+
+/** Output schema for the toggle-pois tool. */
+declare const togglePOIsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    allMapPOIsVisible: z.ZodOptional<z.ZodBoolean>;
+    filterCategories: z.ZodOptional<z.ZodObject<{
+        show: z.ZodEnum<{
+            only: "only";
+            all_except: "all_except";
+        }>;
+        values: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    reset: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+    error: z.ZodString;
+}, z.core.$strip>]>;
+
+/**
+ * Tool schema for toggling POIs.
+ */
+declare const togglePOIsSchema: z.ZodObject<{
+    reset: z.ZodOptional<z.ZodBoolean>;
+    allMapPOIsVisible: z.ZodOptional<z.ZodBoolean>;
+    filterCategories: z.ZodOptional<z.ZodObject<{
+        show: z.ZodEnum<{
+            only: "only";
+            all_except: "all_except";
+        }>;
+        values: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+
+/**
+ * Tool schema for toggling traffic flow.
+ */
+declare const toggleTrafficFlowSchema: z.ZodObject<{
+    visible: z.ZodBoolean;
+}, z.core.$strip>;
+
+/**
+ * Tool schema for toggling traffic incidents.
+ */
+declare const toggleTrafficIncidentsSchema: z.ZodObject<{
+    visible: z.ZodBoolean;
+}, z.core.$strip>;
+
+/** All valid default tool names, derived from {@link DEFAULT_TOOLS}. */
+export declare const TOOL_NAMES: ToolName[];
+
+/**
+ * A tool definition — the universal format for both built-in and third-party tools.
+ * Combines execution (inputSchema + execute) with classifier metadata.
+ *
+ * @typeParam S - The ToolState shape this tool requires. Default: base `ToolState`.
+ *
+ * @group Tools
+ */
+export declare type ToolEntry<S extends ToolState = ToolState> = {
+    /** Description of the tool's purpose. */
+    description: string;
+    /** Zod schema defining the tool's input parameters. */
+    inputSchema: z.ZodType;
+    /** Optional Zod schema describing the tool's structured output. */
+    outputSchema?: z.ZodType;
+    /** Function that executes the tool. Receives parsed input and the agent's state. */
+    execute: (input: any, state: S) => Promise<any>;
+    /** Compact one-liner for the intent classifier prompt. */
+    classificationPrompt?: string;
+    /** Category tags (e.g. 'location', 'routing'). */
+    tags?: string[];
+    /** Usage examples (e.g. 'geocode("Amsterdam")'). */
+    examples?: string[];
+    /** Natural language prompts (e.g. 'Where is the Louvre?'). */
+    examplePrompts?: string[];
+    /** Tool names that are often used together with this tool. */
+    relatedTools?: string[];
+    /** Tool names that must run before this one. */
+    dependsOn?: string[];
+};
+
+/**
+ * Metadata for an agent toolkit tool.
+ *
+ * @group Tools
+ */
+export declare type ToolMetadata = {
+    /** Tool identifier, derived from the config key. */
+    name: string;
+    /** Description of the tool's purpose. Used by the SDK's system prompt. */
+    description: string;
+    /** Compact one-liner for the intent classifier prompt. */
+    classificationPrompt?: string;
+    /** Category tags used by the help tool for filtering (e.g. 'location', 'routing'). */
+    tags?: string[];
+    /** Usage examples (e.g. 'geocode("Amsterdam")'). */
+    examples?: string[];
+    /** Natural language prompts shown by the help tool (e.g. 'Where is the Louvre?'). */
+    examplePrompts?: string[];
+    /** Tool names that are often used together with this tool. */
+    relatedTools?: ToolNameHint[];
+    /** Tool names that must run before this one. */
+    dependsOn?: ToolNameHint[];
+};
+
+/** Union of all default tool names. */
+export declare type ToolName = keyof typeof DEFAULT_TOOLS;
+
+/**
+ * Autocomplete hint for tool names. Suggests known default tool names
+ * while allowing arbitrary custom names via `string & {}`.
+ *
+ * @group Tools
+ */
+export declare type ToolNameHint = ToolName | (string & {});
+
+/**
+ * State passed to tool factory functions. Organized by feature area,
+ * each sub-state mixes lazy module access with the current service data
+ * produced during the session.
+ *
+ * @example
+ * ```typescript
+ * function createMyTool(state: ToolState) {
+ *   return tool({
+ *     execute: async () => {
+ *       const module = await state.places.getPlacesModule();
+ *       state.routing.currentRoutes;  // most recent routes
+ *       state.baseMap.mapLibreMap;    // MapLibre instance
+ *     }
+ *   });
+ * }
+ * ```
+ */
+export declare type ToolState = {
+    /** Place search, geocoding, and geometries state. */
+    places: PlacesState;
+    /** Map POI layer: visibility, filtering, and category management. */
+    mapPOIs: MapPOIsState;
+    /** Route calculation, waypoint management, and planning parameter state. */
+    routing: RoutingState;
+    /** Base map display: style, language, viewport, layers, and hillshade. */
+    baseMap: BaseMapState;
+    /** Traffic flow and incident overlay state. */
+    traffic: TrafficState;
+    /** Reachable range results: origin, budgets, and bbox summaries. */
+    ranges: RangeState;
+};
+
+/**
+ * State for traffic: flow layer, incident overlay, and area analytics modules.
+ */
+declare class TrafficState implements StateSlice {
+    private readonly _ttMap;
+    private _trafficFlowModule?;
+    private _trafficIncidentsModule?;
+    private _trafficAreaAnalyticsModule?;
+    private _lastAreaAnalytics?;
+    private _currentAnalyticsConfig?;
+    private _configChangeUnsub?;
+    constructor(_ttMap: TomTomMap);
+    getTrafficFlowModule(): Promise<TrafficFlowModule>;
+    getTrafficIncidentsModule(): Promise<TrafficIncidentsModule>;
+    getTrafficAreaAnalyticsModule(): Promise<TrafficAreaAnalyticsModule>;
+    get trafficAreaAnalyticsModule(): TrafficAreaAnalyticsModule | undefined;
+    get lastAreaAnalytics(): TrafficAreaAnalytics | undefined;
+    setLastAreaAnalytics(result: TrafficAreaAnalytics): void;
+    /** Current visualization config, updated by module configChange events. */
+    get currentAnalyticsConfig(): TrafficAreaAnalyticsConfig | undefined;
+    onAnalyticsShown?: (analytics: TrafficAreaAnalytics, module: TrafficAreaAnalyticsModule) => void;
+    onAnalyticsCleared?: () => void;
+    reset(): void;
+}
+
+/** Input schema for zoom-in-or-out. */
+declare const zoomInOrOutSchema: z.ZodObject<{
+    delta: z.ZodNumber;
+}, z.core.$strip>;
+
+export { }