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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/README.md +1 -1
  2. package/dist/index.d.ts +174 -3858
  3. package/dist/index.es.js +2 -0
  4. package/dist/index.es.js.map +1 -0
  5. package/package.json +2 -2
  6. package/dist/index.es.js.js +0 -2
  7. package/dist/index.es.js.js.map +0 -1
package/dist/index.d.ts CHANGED
@@ -1,31 +1,22 @@
1
- import { $strip } from 'zod/v4/core';
2
1
  import { BaseMapModule } from '../../map/dist';
3
- import { BBox } from '../../../../core/dist';
4
- import { ColorArraySpecification } from 'maplibre-gl';
5
- import { ColorSpecification } from 'maplibre-gl';
6
- import { DataDrivenPropertyValueSpecification } from 'maplibre-gl';
7
- import { ExpressionSpecification } from 'maplibre-gl';
8
- import { FormattedSpecification } from 'maplibre-gl';
9
2
  import { GeometriesModule } from '../../map/dist';
10
3
  import { GeometryTheme } from '../../map/dist';
11
4
  import { HillshadeModule } from '../../map/dist';
12
5
  import { LanguageModel } from 'ai';
13
6
  import { Map as Map_2 } from 'maplibre-gl';
14
7
  import { ModelMessage } from 'ai';
15
- import { NumberArraySpecification } from 'maplibre-gl';
16
- import { PaddingSpecification } from 'maplibre-gl';
17
- import { Place } from '../../core/dist';
8
+ import { Place } from '../../../core/dist';
9
+ import { Place as Place_2 } from '../../core/dist';
18
10
  import { Places } from '../../core/dist';
19
11
  import { PlacesModule } from '../../map/dist';
20
12
  import { PlanningWaypoint } from '../../map/dist';
21
13
  import { POIsModule } from '../../map/dist';
22
- import { PolygonFeatures } from '../../core/dist';
14
+ import { PolygonFeatures } from '../../../core/dist';
23
15
  import { Position } from 'geojson';
24
16
  import { PrepareStepFunction } from 'ai';
25
- import { PropertyValueSpecification } from 'maplibre-gl';
26
- import { ReachableRangeBudget } from '../../services/dist';
27
- import { ResolvedImageSpecification } from 'maplibre-gl';
28
- import { Routes } from '../../core/dist';
17
+ import { ReachableRangeBudget } from '../../../services/dist';
18
+ import { Routes } from '../../../core/dist';
19
+ import { Routes as Routes_2 } from '../../core/dist';
29
20
  import { RoutingModule } from '../../map/dist';
30
21
  import { TomTomMap } from '../../map/dist';
31
22
  import { ToolLoopAgent } from 'ai';
@@ -34,77 +25,9 @@ import { TrafficAreaAnalyticsConfig } from '../../map/dist';
34
25
  import { TrafficAreaAnalyticsModule } from '../../map/dist';
35
26
  import { TrafficFlowModule } from '../../map/dist';
36
27
  import { TrafficIncidentsModule } from '../../map/dist';
37
- import { TransitionSpecification } from 'maplibre-gl';
38
- import { VariableAnchorOffsetCollectionSpecification } from 'maplibre-gl';
39
- import { VisibilitySpecification } from 'maplibre-gl';
40
- import { WaypointLike } from '../../core/dist';
28
+ import { WaypointLike } from '../../../core/dist';
29
+ import { WaypointLike as WaypointLike_2 } from '../../core/dist';
41
30
  import { z } from 'zod';
42
- import { ZodAny } from 'zod';
43
- import { ZodArray } from 'zod';
44
- import { ZodBoolean } from 'zod';
45
- import { ZodDate } from 'zod';
46
- import { ZodEnum } from 'zod';
47
- import { ZodLiteral } from 'zod';
48
- import { ZodNumber } from 'zod';
49
- import { ZodObject } from 'zod';
50
- import { ZodOptional } from 'zod';
51
- import { ZodReadonly } from 'zod';
52
- import { ZodRecord } from 'zod';
53
- import { ZodString } from 'zod';
54
- import { ZodTuple } from 'zod';
55
- import { ZodUnion } from 'zod';
56
- import { ZodUnknown } from 'zod';
57
-
58
- /** Output schema for the add-stop-to-route tool. */
59
- declare const addStopToRouteOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
60
- count: z.ZodNumber;
61
- routes: z.ZodArray<z.ZodObject<{
62
- index: z.ZodNumber;
63
- summary: z.ZodObject<{
64
- travelTimeInSeconds: z.ZodNumber;
65
- lengthInMeters: z.ZodNumber;
66
- trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
67
- trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
68
- departureTime: z.ZodOptional<z.ZodString>;
69
- arrivalTime: z.ZodOptional<z.ZodString>;
70
- noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
71
- historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
72
- liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
73
- }, z.core.$strip>;
74
- legSummaries: z.ZodOptional<z.ZodArray<z.ZodObject<{
75
- travelTimeInSeconds: z.ZodNumber;
76
- lengthInMeters: z.ZodNumber;
77
- trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
78
- trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
79
- departureTime: z.ZodOptional<z.ZodString>;
80
- arrivalTime: z.ZodOptional<z.ZodString>;
81
- noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
82
- historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
83
- liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
84
- }, z.core.$strip>>>;
85
- }, z.core.$strip>>;
86
- }, z.core.$strip>, z.ZodObject<{
87
- error: z.ZodString;
88
- }, z.core.$strip>]>;
89
-
90
- /**
91
- * Tool schema for adding a stop to existing route.
92
- */
93
- declare const addStopToRouteSchema: z.ZodObject<{
94
- location: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
95
- query: z.ZodString;
96
- locationType: z.ZodEnum<{
97
- default: "default";
98
- poi: "poi";
99
- }>;
100
- }, z.core.$strip>, z.ZodObject<{
101
- position: z.ZodObject<{
102
- lng: z.ZodNumber;
103
- lat: z.ZodNumber;
104
- }, z.core.$strip>;
105
- }, z.core.$strip>]>>;
106
- showOnMap: z.ZodBoolean;
107
- }, z.core.$strip>;
108
31
 
109
32
  /**
110
33
  * The base system prompt that teaches the LLM how to use the agent toolkit tools.
@@ -123,7 +46,7 @@ declare const addStopToRouteSchema: z.ZodObject<{
123
46
  * });
124
47
  * ```
125
48
  *
126
- * @group System Prompt
49
+ * @group Agent Toolkit
127
50
  */
128
51
  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";
129
52
 
@@ -132,6 +55,8 @@ export declare const BASE_SYSTEM_PROMPT = "You are a helpful map assistant with
132
55
  *
133
56
  * Provides direct access to the TomTomMap and MapLibre instances alongside
134
57
  * lazy-initialized BaseMapModule and HillshadeModule.
58
+ *
59
+ * @group Agent Toolkit
135
60
  */
136
61
  declare class BaseMapState implements StateSlice {
137
62
  readonly ttMap: TomTomMap;
@@ -147,13 +72,10 @@ declare class BaseMapState implements StateSlice {
147
72
  /* Excluded from this release type: buildSystemPrompt */
148
73
 
149
74
  /**
150
- * Tool schema for calculating a bounding box from GeoJSON.
75
+ * Result returned by {@link classifyUserIntent}.
76
+ *
77
+ * @group Agent Toolkit
151
78
  */
152
- declare const calculateBBoxSchema: z.ZodObject<{
153
- geoJson: z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
154
- }, z.core.$strip>;
155
-
156
- /** Result returned by {@link classifyUserIntent}. */
157
79
  export declare type ClassificationResult = {
158
80
  /** Tool names selected by the classifier. */
159
81
  activeToolNames: string[];
@@ -171,14 +93,14 @@ export declare type ClassificationResult = {
171
93
  * A classifier function that selects which tools to activate for a user message.
172
94
  * Return `null` to activate all tools (fail-open).
173
95
  *
174
- * @group Classifier
96
+ * @group Agent Toolkit
175
97
  */
176
98
  export declare type Classifier = (context: ClassifierContext) => Promise<ClassificationResult | null>;
177
99
 
178
100
  /**
179
101
  * Context passed to a classifier function.
180
102
  *
181
- * @group Classifier
103
+ * @group Agent Toolkit
182
104
  */
183
105
  export declare type ClassifierContext = {
184
106
  /** Full message history for the current conversation. */
@@ -187,8 +109,12 @@ export declare type ClassifierContext = {
187
109
  toolsMetadata: Record<string, ToolMetadata>;
188
110
  };
189
111
 
190
- /** Options passed to {@link classifyUserIntent}. */
191
- declare type ClassifierOptions = {
112
+ /**
113
+ * Options passed to {@link classifyUserIntent}.
114
+ *
115
+ * @group Agent Toolkit
116
+ */
117
+ export declare type ClassifierOptions = {
192
118
  /**
193
119
  * Language model to use for structured generation.
194
120
  * Ideally should be a fast, low-cost model (e.g. gpt-4o-mini).
@@ -212,22 +138,16 @@ declare type ClassifierOptions = {
212
138
  * });
213
139
  * // result.activeToolNames contains the selected tools
214
140
  * ```
141
+ *
142
+ * @group Agent Toolkit
215
143
  */
216
- export declare function classifyUserIntent(conversation: ConversationMessage[], options: ClassifierOptions): Promise<ClassificationResult>;
144
+ export declare const classifyUserIntent: (conversation: ConversationMessage[], options: ClassifierOptions) => Promise<ClassificationResult>;
217
145
 
218
146
  /**
219
- * Tool schema for clearing map features.
147
+ * A single turn in the conversation passed to {@link classifyUserIntent}.
148
+ *
149
+ * @ignore
220
150
  */
221
- declare const clearMapSchema: z.ZodObject<{
222
- layers: z.ZodOptional<z.ZodArray<z.ZodEnum<{
223
- routes: "routes";
224
- places: "places";
225
- geometries: "geometries";
226
- analytics: "analytics";
227
- }>>>;
228
- }, z.core.$strip>;
229
-
230
- /** A single turn in the conversation passed to {@link classifyUserIntent}. */
231
151
  declare type ConversationMessage = {
232
152
  role: 'user' | 'assistant';
233
153
  content: string;
@@ -240,12 +160,14 @@ declare type ConversationMessage = {
240
160
  * @param options.model - Language model for classification (ideally fast/cheap like gpt-4o-mini)
241
161
  * @param options.maxHistoryMessages - Max prior turns for context. Default: 8
242
162
  * @param options.maxHistoryMessageLength - Max chars per history message. Default: 300
163
+ *
164
+ * @group Agent Toolkit
243
165
  */
244
- export declare function createDefaultClassifier(options: {
166
+ export declare const createDefaultClassifier: (options: {
245
167
  model: LanguageModel;
246
168
  maxHistoryMessages?: number;
247
169
  maxHistoryMessageLength?: number;
248
- }): Classifier;
170
+ }) => Classifier;
249
171
 
250
172
  /**
251
173
  * Creates a conversational agent toolkit that gives an LLM control over a TomTom map.
@@ -282,8 +204,9 @@ export declare function createDefaultClassifier(options: {
282
204
  * },
283
205
  * });
284
206
  * ```
207
+ * @group Agent Toolkit
285
208
  */
286
- export declare function createMapAgent<CS extends ToolState = ToolState>(map: TomTomMap, options: MapAgentOptions<CS>): MapAgentInstance<CS>;
209
+ export declare const createMapAgent: <CS extends ToolState = ToolState>(map: TomTomMap, options: MapAgentOptions<CS>) => MapAgentInstance<CS>;
287
210
 
288
211
  /**
289
212
  * Factory that creates a fully initialized ToolState from a TomTomMap instance.
@@ -291,3142 +214,88 @@ export declare function createMapAgent<CS extends ToolState = ToolState>(map: To
291
214
  *
292
215
  * @param map - TomTomMap instance for module initialization
293
216
  * @param customSlices - Additional state slices accessible by custom tools
217
+ *
218
+ * @group Agent Toolkit
294
219
  */
295
- export declare function createToolState<T extends Record<string, unknown> = Record<string, never>>(map: TomTomMap, customSlices?: T): ToolState & T;
220
+ export declare const createToolState: <T extends Record<string, unknown> = Record<string, never>>(map: TomTomMap, customSlices?: T) => ToolState & T;
296
221
 
297
222
  /**
298
223
  * Default tool set for the agent toolkit.
299
224
  * Included automatically by createMapAgent unless includeDefaultTools is false.
300
225
  * Use resolveTools() for manual composition outside createMapAgent.
226
+ *
227
+ * @group Agent Toolkit
301
228
  */
302
229
  export declare const DEFAULT_TOOLS: {
303
- locatePlace: {
304
- description: string;
305
- classificationPrompt: string;
306
- inputSchema: ZodObject< {
307
- query: ZodString;
308
- waypointIndex: ZodOptional<ZodNumber>;
309
- locationType: ZodEnum< {
310
- default: "default";
311
- poi: "poi";
312
- }>;
313
- where: ZodUnion<readonly [ZodObject< {
314
- position: ZodArray<ZodNumber>;
315
- }, $strip>, ZodObject< {
316
- boundingBox: ZodUnion<readonly [ZodUnion<readonly [ZodArray<ZodNumber>]>, ZodObject< {
317
- bbox: ZodUnion<readonly [ZodArray<ZodNumber>]>;
318
- }, $strip>]>;
319
- }, $strip>, ZodLiteral<"within-map-bounds">, ZodLiteral<"nearby-map-center">, ZodLiteral<"global">, ZodString]>;
320
- show: ZodOptional<ZodObject< {
321
- markerType: ZodEnum< {
322
- pin: "pin";
323
- none: "none";
324
- }>;
325
- zoomMode: ZodEnum< {
326
- none: "none";
327
- auto: "auto";
328
- }>;
329
- }, $strip>>;
330
- }, $strip>;
331
- outputSchema: ZodUnion<readonly [ZodObject< {
332
- name: ZodOptional<ZodString>;
333
- address: ZodOptional<ZodString>;
334
- position: ZodArray<ZodNumber>;
335
- waypointIndex: ZodOptional<ZodNumber>;
336
- shown: ZodOptional<ZodObject< {
337
- markerType: ZodBoolean;
338
- zoomMode: ZodBoolean;
339
- }, $strip>>;
340
- }, $strip>, ZodObject< {
341
- error: ZodString;
342
- }, $strip>]>;
343
- execute: typeof executeLocatePlace;
344
- tags: string[];
345
- examples: string[];
346
- examplePrompts: string[];
347
- relatedTools: string[];
348
- };
349
- reverseGeocode: {
350
- description: string;
351
- classificationPrompt: string;
352
- inputSchema: ZodObject< {
353
- position: ZodArray<ZodNumber>;
354
- }, $strip>;
355
- outputSchema: ZodUnion<readonly [ZodObject< {
356
- name: ZodOptional<ZodString>;
357
- address: ZodOptional<ZodString>;
358
- position: ZodArray<ZodNumber>;
359
- }, $strip>, ZodObject< {
360
- error: ZodString;
361
- }, $strip>]>;
362
- execute: typeof executeReverseGeocode;
363
- tags: string[];
364
- examples: string[];
365
- examplePrompts: string[];
366
- relatedTools: string[];
367
- };
368
- discoverPlaces: {
369
- description: string;
370
- classificationPrompt: string;
371
- inputSchema: ZodObject< {
372
- query: ZodOptional<ZodString>;
373
- where: ZodOptional<ZodUnion<readonly [ZodObject< {
374
- position: ZodArray<ZodNumber>;
375
- }, $strip>, ZodObject< {
376
- boundingBox: ZodUnion<readonly [ZodUnion<readonly [ZodArray<ZodNumber>]>, ZodObject< {
377
- bbox: ZodUnion<readonly [ZodArray<ZodNumber>]>;
378
- }, $strip>]>;
379
- }, $strip>, ZodLiteral<"within-map-bounds">, ZodLiteral<"nearby-map-center">, ZodLiteral<"global">, ZodString]>>;
380
- radiusMeters: ZodOptional<ZodNumber>;
381
- limit: ZodOptional<ZodNumber>;
382
- poiCategories: ZodOptional<ZodArray<ZodString>>;
383
- show: ZodOptional<ZodObject< {
384
- markerType: ZodEnum< {
385
- pin: "pin";
386
- none: "none";
387
- }>;
388
- zoomMode: ZodEnum< {
389
- none: "none";
390
- auto: "auto";
391
- }>;
392
- }, $strip>>;
393
- withinRange: ZodOptional<ZodString>;
394
- }, $strip>;
395
- outputSchema: ZodUnion<readonly [ZodObject< {
396
- count: ZodNumber;
397
- features: ZodArray<ZodObject< {
398
- name: ZodOptional<ZodString>;
399
- address: ZodOptional<ZodString>;
400
- position: ZodArray<ZodNumber>;
401
- }, $strip>>;
402
- shown: ZodOptional<ZodObject< {
403
- markerType: ZodBoolean;
404
- zoomMode: ZodBoolean;
405
- }, $strip>>;
406
- placeResultIndex: ZodOptional<ZodString>;
407
- }, $strip>, ZodObject< {
408
- error: ZodString;
409
- }, $strip>]>;
410
- execute: typeof executeDiscoverPlaces;
411
- tags: string[];
412
- examples: string[];
413
- examplePrompts: string[];
414
- relatedTools: string[];
415
- };
416
- setRouteLocations: {
417
- description: string;
418
- classificationPrompt: string;
419
- inputSchema: ZodObject< {
420
- locations: ZodArray<ZodUnion<readonly [ZodObject< {
421
- query: ZodString;
422
- locationType: ZodEnum< {
423
- default: "default";
424
- poi: "poi";
425
- }>;
426
- }, $strip>, ZodObject< {
427
- position: ZodObject< {
428
- lng: ZodNumber;
429
- lat: ZodNumber;
430
- }, $strip>;
431
- }, $strip>]>>;
432
- showOnMap: ZodBoolean;
433
- }, $strip>;
434
- outputSchema: ZodUnion<readonly [ZodObject< {
435
- count: ZodNumber;
436
- routes: ZodArray<ZodObject< {
437
- index: ZodNumber;
438
- summary: ZodObject< {
439
- travelTimeInSeconds: ZodNumber;
440
- lengthInMeters: ZodNumber;
441
- trafficDelayInSeconds: ZodOptional<ZodNumber>;
442
- trafficLengthInMeters: ZodOptional<ZodNumber>;
443
- departureTime: ZodOptional<ZodString>;
444
- arrivalTime: ZodOptional<ZodString>;
445
- noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
446
- historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
447
- liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
448
- }, $strip>;
449
- legSummaries: ZodOptional<ZodArray<ZodObject< {
450
- travelTimeInSeconds: ZodNumber;
451
- lengthInMeters: ZodNumber;
452
- trafficDelayInSeconds: ZodOptional<ZodNumber>;
453
- trafficLengthInMeters: ZodOptional<ZodNumber>;
454
- departureTime: ZodOptional<ZodString>;
455
- arrivalTime: ZodOptional<ZodString>;
456
- noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
457
- historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
458
- liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
459
- }, $strip>>>;
460
- }, $strip>>;
461
- }, $strip>, ZodObject< {
462
- error: ZodString;
463
- }, $strip>]>;
464
- execute: typeof executeSetRouteLocations;
465
- tags: string[];
466
- examples: string[];
467
- examplePrompts: string[];
468
- relatedTools: string[];
469
- };
470
- setRouteParameters: {
471
- description: string;
472
- classificationPrompt: string;
473
- inputSchema: ZodObject< {
474
- maxAlternatives: ZodOptional<ZodNumber>;
475
- costModel: ZodOptional<ZodObject< {
476
- routeType: ZodOptional<ZodEnum< {
477
- fast: "fast";
478
- short: "short";
479
- efficient: "efficient";
480
- thrilling: "thrilling";
481
- }>>;
482
- traffic: ZodOptional<ZodEnum< {
483
- live: "live";
484
- historical: "historical";
485
- }>>;
486
- avoid: ZodOptional<ZodArray<ZodEnum< {
487
- tollRoads: "tollRoads";
488
- motorways: "motorways";
489
- ferries: "ferries";
490
- unpavedRoads: "unpavedRoads";
491
- carpools: "carpools";
492
- alreadyUsedRoads: "alreadyUsedRoads";
493
- borderCrossings: "borderCrossings";
494
- tunnels: "tunnels";
495
- carTrains: "carTrains";
496
- lowEmissionZones: "lowEmissionZones";
497
- }>>>;
498
- avoidAreas: ZodOptional<ZodArray<ZodArray<ZodNumber>>>;
499
- }, $strip>>;
500
- when: ZodOptional<ZodObject< {
501
- option: ZodEnum< {
502
- departAt: "departAt";
503
- arriveBy: "arriveBy";
504
- }>;
505
- date: ZodString;
506
- }, $strip>>;
507
- showOnMap: ZodBoolean;
508
- }, $strip>;
509
- outputSchema: ZodUnion<readonly [ZodObject< {
510
- count: ZodNumber;
511
- routes: ZodArray<ZodObject< {
512
- index: ZodNumber;
513
- summary: ZodObject< {
514
- travelTimeInSeconds: ZodNumber;
515
- lengthInMeters: ZodNumber;
516
- trafficDelayInSeconds: ZodOptional<ZodNumber>;
517
- trafficLengthInMeters: ZodOptional<ZodNumber>;
518
- departureTime: ZodOptional<ZodString>;
519
- arrivalTime: ZodOptional<ZodString>;
520
- noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
521
- historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
522
- liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
523
- }, $strip>;
524
- legSummaries: ZodOptional<ZodArray<ZodObject< {
525
- travelTimeInSeconds: ZodNumber;
526
- lengthInMeters: ZodNumber;
527
- trafficDelayInSeconds: ZodOptional<ZodNumber>;
528
- trafficLengthInMeters: ZodOptional<ZodNumber>;
529
- departureTime: ZodOptional<ZodString>;
530
- arrivalTime: ZodOptional<ZodString>;
531
- noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
532
- historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
533
- liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
534
- }, $strip>>>;
535
- }, $strip>>;
536
- }, $strip>, ZodObject< {
537
- success: ZodLiteral<true>;
538
- }, $strip>, ZodObject< {
539
- error: ZodString;
540
- }, $strip>]>;
541
- execute: typeof executeSetRouteParameters;
542
- tags: string[];
543
- examples: string[];
544
- examplePrompts: string[];
545
- relatedTools: string[];
546
- };
547
- addStopToRoute: {
548
- description: string;
549
- classificationPrompt: string;
550
- inputSchema: ZodObject< {
551
- location: ZodOptional<ZodUnion<readonly [ZodObject< {
552
- query: ZodString;
553
- locationType: ZodEnum< {
554
- default: "default";
555
- poi: "poi";
556
- }>;
557
- }, $strip>, ZodObject< {
558
- position: ZodObject< {
559
- lng: ZodNumber;
560
- lat: ZodNumber;
561
- }, $strip>;
562
- }, $strip>]>>;
563
- showOnMap: ZodBoolean;
564
- }, $strip>;
565
- outputSchema: ZodUnion<readonly [ZodObject< {
566
- count: ZodNumber;
567
- routes: ZodArray<ZodObject< {
568
- index: ZodNumber;
569
- summary: ZodObject< {
570
- travelTimeInSeconds: ZodNumber;
571
- lengthInMeters: ZodNumber;
572
- trafficDelayInSeconds: ZodOptional<ZodNumber>;
573
- trafficLengthInMeters: ZodOptional<ZodNumber>;
574
- departureTime: ZodOptional<ZodString>;
575
- arrivalTime: ZodOptional<ZodString>;
576
- noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
577
- historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
578
- liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
579
- }, $strip>;
580
- legSummaries: ZodOptional<ZodArray<ZodObject< {
581
- travelTimeInSeconds: ZodNumber;
582
- lengthInMeters: ZodNumber;
583
- trafficDelayInSeconds: ZodOptional<ZodNumber>;
584
- trafficLengthInMeters: ZodOptional<ZodNumber>;
585
- departureTime: ZodOptional<ZodString>;
586
- arrivalTime: ZodOptional<ZodString>;
587
- noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
588
- historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
589
- liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
590
- }, $strip>>>;
591
- }, $strip>>;
592
- }, $strip>, ZodObject< {
593
- error: ZodString;
594
- }, $strip>]>;
595
- execute: typeof executeAddStopToRoute;
596
- tags: string[];
597
- examples: string[];
598
- examplePrompts: string[];
599
- relatedTools: string[];
600
- dependsOn: string[];
601
- };
602
- removeStopFromRoute: {
603
- description: string;
604
- classificationPrompt: string;
605
- inputSchema: ZodObject< {
606
- stopIndex: ZodNumber;
607
- showOnMap: ZodBoolean;
608
- }, $strip>;
609
- outputSchema: ZodUnion<readonly [ZodObject< {
610
- count: ZodNumber;
611
- routes: ZodArray<ZodObject< {
612
- index: ZodNumber;
613
- summary: ZodObject< {
614
- travelTimeInSeconds: ZodNumber;
615
- lengthInMeters: ZodNumber;
616
- trafficDelayInSeconds: ZodOptional<ZodNumber>;
617
- trafficLengthInMeters: ZodOptional<ZodNumber>;
618
- departureTime: ZodOptional<ZodString>;
619
- arrivalTime: ZodOptional<ZodString>;
620
- noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
621
- historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
622
- liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
623
- }, $strip>;
624
- legSummaries: ZodOptional<ZodArray<ZodObject< {
625
- travelTimeInSeconds: ZodNumber;
626
- lengthInMeters: ZodNumber;
627
- trafficDelayInSeconds: ZodOptional<ZodNumber>;
628
- trafficLengthInMeters: ZodOptional<ZodNumber>;
629
- departureTime: ZodOptional<ZodString>;
630
- arrivalTime: ZodOptional<ZodString>;
631
- noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
632
- historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
633
- liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
634
- }, $strip>>>;
635
- }, $strip>>;
636
- }, $strip>, ZodObject< {
637
- error: ZodString;
638
- }, $strip>]>;
639
- execute: typeof executeRemoveStopFromRoute;
640
- tags: string[];
641
- examples: string[];
642
- examplePrompts: string[];
643
- relatedTools: string[];
644
- dependsOn: string[];
645
- };
646
- getPOICategoryCodes: {
647
- description: string;
648
- classificationPrompt: string;
649
- inputSchema: ZodObject< {
650
- filters: ZodOptional<ZodArray<ZodString>>;
651
- language: ZodString;
652
- }, $strip>;
653
- outputSchema: ZodUnion<readonly [ZodObject< {
654
- count: ZodNumber;
655
- codes: ZodArray<ZodString>;
656
- }, $strip>, ZodObject< {
657
- error: ZodString;
658
- }, $strip>]>;
659
- execute: typeof executeGetPoiCategoryCodes;
660
- tags: string[];
661
- examples: string[];
662
- examplePrompts: string[];
663
- relatedTools: string[];
664
- };
665
- getTrafficIncidents: {
666
- description: string;
667
- classificationPrompt: string;
668
- inputSchema: ZodObject< {
669
- bbox: ZodOptional<ZodArray<ZodNumber>>;
670
- ids: ZodOptional<ZodArray<ZodString>>;
671
- categoryFilter: ZodOptional<ZodArray<ZodEnum< {
672
- accident: "accident";
673
- "animals-on-road": "animals-on-road";
674
- "broken-down-vehicle": "broken-down-vehicle";
675
- danger: "danger";
676
- flooding: "flooding";
677
- fog: "fog";
678
- frost: "frost";
679
- jam: "jam";
680
- "lane-closed": "lane-closed";
681
- "narrow-lanes": "narrow-lanes";
682
- other: "other";
683
- rain: "rain";
684
- "road-closed": "road-closed";
685
- roadworks: "roadworks";
686
- wind: "wind";
687
- }>>>;
688
- timeValidityFilter: ZodOptional<ZodArray<ZodEnum< {
689
- present: "present";
690
- future: "future";
691
- }>>>;
692
- }, $strip>;
693
- outputSchema: ZodUnion<readonly [ZodObject< {
694
- count: ZodNumber;
695
- incidents: ZodArray<ZodObject< {
696
- id: ZodString;
697
- category: ZodString;
698
- magnitudeOfDelay: ZodString;
699
- timeValidity: ZodString;
700
- events: ZodArray<ZodObject< {
701
- description: ZodString;
702
- category: ZodString;
703
- }, $strip>>;
704
- from: ZodOptional<ZodString>;
705
- to: ZodOptional<ZodString>;
706
- roadNumbers: ZodOptional<ZodArray<ZodString>>;
707
- lengthInMeters: ZodOptional<ZodNumber>;
708
- delayInSeconds: ZodOptional<ZodNumber>;
709
- startTime: ZodOptional<ZodDate>;
710
- endTime: ZodOptional<ZodDate>;
711
- }, $strip>>;
712
- }, $strip>, ZodObject< {
713
- error: ZodString;
714
- }, $strip>]>;
715
- execute: typeof executeGetTrafficIncidents;
716
- tags: string[];
717
- examples: string[];
718
- examplePrompts: string[];
719
- relatedTools: string[];
720
- };
721
- getTrafficAreaAnalytics: {
722
- description: string;
723
- classificationPrompt: string;
724
- inputSchema: ZodObject< {
725
- location: ZodOptional<ZodUnion<readonly [ZodObject< {
726
- query: ZodString;
727
- locationType: ZodEnum< {
728
- default: "default";
729
- poi: "poi";
730
- }>;
731
- }, $strip>, ZodObject< {
732
- position: ZodObject< {
733
- lng: ZodNumber;
734
- lat: ZodNumber;
735
- }, $strip>;
736
- }, $strip>]>>;
737
- bbox: ZodOptional<ZodArray<ZodNumber>>;
738
- showOnMap: ZodOptional<ZodBoolean>;
739
- startDate: ZodOptional<ZodString>;
740
- endDate: ZodOptional<ZodString>;
741
- days: ZodOptional<ZodArray<ZodString>>;
742
- metrics: ZodUnion<readonly [ZodLiteral<"all">, ZodArray<ZodEnum< {
743
- speed: "speed";
744
- congestionLevel: "congestionLevel";
745
- freeFlowSpeed: "freeFlowSpeed";
746
- travelTime: "travelTime";
747
- networkLength: "networkLength";
748
- }>>]>;
749
- functionalRoadClasses: ZodOptional<ZodUnion<readonly [ZodLiteral<"all">, ZodArray<ZodEnum< {
750
- MOTORWAY: "MOTORWAY";
751
- MAJOR_ROAD: "MAJOR_ROAD";
752
- OTHER_MAJOR_ROAD: "OTHER_MAJOR_ROAD";
753
- SECONDARY_ROAD: "SECONDARY_ROAD";
754
- LOCAL_CONNECTING_ROAD: "LOCAL_CONNECTING_ROAD";
755
- LOCAL_ROAD_HIGH_IMPORTANCE: "LOCAL_ROAD_HIGH_IMPORTANCE";
756
- LOCAL_ROAD: "LOCAL_ROAD";
757
- LOCAL_ROAD_MINOR_IMPORTANCE: "LOCAL_ROAD_MINOR_IMPORTANCE";
758
- OTHER_ROAD: "OTHER_ROAD";
759
- }>>]>>;
760
- hours: ZodOptional<ZodUnion<readonly [ZodLiteral<"all">, ZodArray<ZodNumber>]>>;
761
- }, $strip>;
762
- outputSchema: ZodUnion<readonly [ZodObject< {
763
- name: ZodOptional<ZodString>;
764
- timezone: ZodOptional<ZodString>;
765
- dateRange: ZodObject< {
766
- start: ZodString;
767
- end: ZodString;
768
- }, $strip>;
769
- baseData: ZodObject< {
770
- speed: ZodOptional<ZodNumber>;
771
- freeFlowSpeed: ZodOptional<ZodNumber>;
772
- congestionLevel: ZodOptional<ZodNumber>;
773
- travelTime: ZodOptional<ZodNumber>;
774
- networkLength: ZodOptional<ZodNumber>;
775
- }, $strip>;
776
- metrics: ZodArray<ZodString>;
777
- tileCount: ZodNumber;
778
- availableGranularities: ZodArray<ZodString>;
779
- }, $strip>, ZodObject< {
780
- error: ZodString;
781
- }, $strip>]>;
782
- execute: typeof executeGetTrafficAreaAnalytics;
783
- tags: string[];
784
- examples: string[];
785
- examplePrompts: string[];
786
- relatedTools: string[];
787
- dependsOn: string[];
788
- };
789
- queryTrafficAnalytics: {
790
- description: string;
791
- classificationPrompt: string;
792
- inputSchema: ZodObject< {
793
- granularity: ZodOptional<ZodEnum< {
794
- yearly: "yearly";
795
- monthly: "monthly";
796
- weekly: "weekly";
797
- daily: "daily";
798
- hourly: "hourly";
799
- average: "average";
800
- }>>;
801
- metric: ZodOptional<ZodEnum< {
802
- speed: "speed";
803
- congestionLevel: "congestionLevel";
804
- freeFlowSpeed: "freeFlowSpeed";
805
- travelTime: "travelTime";
806
- networkLength: "networkLength";
807
- }>>;
808
- startDate: ZodOptional<ZodString>;
809
- endDate: ZodOptional<ZodString>;
810
- hourStart: ZodOptional<ZodNumber>;
811
- hourEnd: ZodOptional<ZodNumber>;
812
- dayOfWeek: ZodOptional<ZodArray<ZodNumber>>;
813
- }, $strip>;
814
- outputSchema: ZodUnion<readonly [ZodObject< {
815
- granularity: ZodString;
816
- count: ZodNumber;
817
- entries: ZodArray<ZodObject< {
818
- speed: ZodOptional<ZodNumber>;
819
- freeFlowSpeed: ZodOptional<ZodNumber>;
820
- congestionLevel: ZodOptional<ZodNumber>;
821
- travelTime: ZodOptional<ZodNumber>;
822
- networkLength: ZodOptional<ZodNumber>;
823
- date: ZodOptional<ZodString>;
824
- hour: ZodOptional<ZodNumber>;
825
- year: ZodOptional<ZodNumber>;
826
- month: ZodOptional<ZodNumber>;
827
- week: ZodOptional<ZodNumber>;
828
- day: ZodOptional<ZodNumber>;
829
- }, $strip>>;
830
- currentVisualization: ZodOptional<ZodObject< {
831
- activeMetric: ZodOptional<ZodString>;
832
- displayMode: ZodOptional<ZodString>;
833
- }, $strip>>;
834
- }, $strip>, ZodObject< {
835
- error: ZodString;
836
- }, $strip>]>;
837
- execute: typeof executeQueryTrafficAnalytics;
838
- tags: string[];
839
- examples: string[];
840
- examplePrompts: string[];
841
- relatedTools: string[];
842
- dependsOn: string[];
843
- };
844
- showPlaces: {
845
- description: string;
846
- classificationPrompt: string;
847
- inputSchema: ZodObject< {
848
- id: ZodOptional<ZodString>;
849
- fitBounds: ZodOptional<ZodBoolean>;
850
- }, $strip>;
851
- outputSchema: ZodUnion<readonly [ZodObject< {
852
- success: ZodLiteral<true>;
853
- count: ZodNumber;
854
- }, $strip>, ZodObject< {
855
- error: ZodString;
856
- }, $strip>]>;
857
- execute: typeof executeShowPlaces;
858
- tags: string[];
859
- examples: string[];
860
- examplePrompts: string[];
861
- relatedTools: string[];
862
- dependsOn: string[];
863
- };
864
- showRoute: {
865
- description: string;
866
- classificationPrompt: string;
867
- inputSchema: ZodObject< {
868
- id: ZodOptional<ZodString>;
869
- selectedIndex: ZodOptional<ZodNumber>;
870
- fitBounds: ZodOptional<ZodBoolean>;
871
- }, $strip>;
872
- outputSchema: ZodUnion<readonly [ZodObject< {
873
- success: ZodLiteral<true>;
874
- displayedRoute: ZodNumber;
875
- routeCount: ZodNumber;
876
- }, $strip>, ZodObject< {
877
- error: ZodString;
878
- }, $strip>]>;
879
- execute: typeof executeShowRoutes;
880
- tags: string[];
881
- examples: string[];
882
- examplePrompts: string[];
883
- relatedTools: string[];
884
- dependsOn: string[];
885
- };
886
- showTrafficAreaAnalytics: {
887
- description: string;
888
- classificationPrompt: string;
889
- inputSchema: ZodObject< {
890
- mode: ZodOptional<ZodEnum< {
891
- heatmap: "heatmap";
892
- "hexgrid-3d": "hexgrid-3d";
893
- "hexgrid-2d": "hexgrid-2d";
894
- "square-3d": "square-3d";
895
- "square-2d": "square-2d";
896
- }>>;
897
- metric: ZodOptional<ZodEnum< {
898
- speed: "speed";
899
- congestionLevel: "congestionLevel";
900
- travelTime: "travelTime";
901
- }>>;
902
- colorTheme: ZodOptional<ZodEnum< {
903
- trafficLight: "trafficLight";
904
- heat: "heat";
905
- monochrome: "monochrome";
906
- viridis: "viridis";
907
- plasma: "plasma";
908
- }>>;
909
- heightScale: ZodOptional<ZodNumber>;
910
- scaleMode: ZodOptional<ZodEnum< {
911
- raw: "raw";
912
- predefinedRange: "predefinedRange";
913
- currentRange: "currentRange";
914
- }>>;
915
- filter: ZodOptional<ZodObject< {
916
- min: ZodOptional<ZodNumber>;
917
- max: ZodOptional<ZodNumber>;
918
- }, $strip>>;
919
- visible: ZodOptional<ZodBoolean>;
920
- fitBounds: ZodOptional<ZodBoolean>;
921
- }, $strip>;
922
- outputSchema: ZodUnion<readonly [ZodObject< {
923
- success: ZodLiteral<true>;
924
- mode: ZodString;
925
- metric: ZodString;
926
- colorTheme: ZodString;
927
- visible: ZodBoolean;
928
- filtered: ZodBoolean;
929
- }, $strip>, ZodObject< {
930
- error: ZodString;
931
- }, $strip>]>;
932
- execute: typeof executeShowTrafficAreaAnalytics;
933
- tags: string[];
934
- examples: string[];
935
- examplePrompts: string[];
936
- relatedTools: string[];
937
- dependsOn: string[];
938
- };
939
- showWaypoints: {
940
- description: string;
941
- classificationPrompt: string;
942
- inputSchema: ZodObject< {}, $strip>;
943
- outputSchema: ZodUnion<readonly [ZodObject< {
944
- success: ZodLiteral<true>;
945
- count: ZodNumber;
946
- }, $strip>, ZodObject< {
947
- error: ZodString;
948
- }, $strip>]>;
949
- execute: typeof executeShowWaypoints;
950
- tags: string[];
951
- examples: string[];
952
- examplePrompts: string[];
953
- relatedTools: string[];
954
- dependsOn: string[];
955
- };
956
- getShownPlaces: {
957
- description: string;
958
- classificationPrompt: string;
959
- inputSchema: ZodObject< {}, $strip>;
960
- outputSchema: ZodUnion<readonly [ZodObject< {
961
- count: ZodNumber;
962
- features: ZodArray<ZodObject< {
963
- name: ZodOptional<ZodString>;
964
- address: ZodOptional<ZodString>;
965
- position: ZodArray<ZodNumber>;
966
- }, $strip>>;
967
- }, $strip>, ZodObject< {
968
- error: ZodString;
969
- }, $strip>]>;
970
- execute: typeof executeGetShownPlaces;
971
- tags: string[];
972
- examples: string[];
973
- examplePrompts: string[];
974
- relatedTools: string[];
975
- dependsOn: string[];
976
- };
977
- getShownRoutes: {
978
- description: string;
979
- classificationPrompt: string;
980
- inputSchema: ZodObject< {}, $strip>;
981
- outputSchema: ZodUnion<readonly [ZodObject< {
982
- count: ZodNumber;
983
- routes: ZodArray<ZodObject< {
984
- index: ZodNumber;
985
- summary: ZodObject< {
986
- travelTimeInSeconds: ZodNumber;
987
- lengthInMeters: ZodNumber;
988
- trafficDelayInSeconds: ZodOptional<ZodNumber>;
989
- trafficLengthInMeters: ZodOptional<ZodNumber>;
990
- departureTime: ZodOptional<ZodString>;
991
- arrivalTime: ZodOptional<ZodString>;
992
- noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
993
- historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
994
- liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
995
- }, $strip>;
996
- legSummaries: ZodOptional<ZodArray<ZodObject< {
997
- travelTimeInSeconds: ZodNumber;
998
- lengthInMeters: ZodNumber;
999
- trafficDelayInSeconds: ZodOptional<ZodNumber>;
1000
- trafficLengthInMeters: ZodOptional<ZodNumber>;
1001
- departureTime: ZodOptional<ZodString>;
1002
- arrivalTime: ZodOptional<ZodString>;
1003
- noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
1004
- historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
1005
- liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
1006
- }, $strip>>>;
1007
- }, $strip>>;
1008
- }, $strip>, ZodObject< {
1009
- error: ZodString;
1010
- }, $strip>]>;
1011
- execute: typeof executeGetShownRoutes;
1012
- tags: string[];
1013
- examples: string[];
1014
- examplePrompts: string[];
1015
- relatedTools: string[];
1016
- dependsOn: string[];
1017
- };
1018
- getShownWaypoints: {
1019
- description: string;
1020
- classificationPrompt: string;
1021
- inputSchema: ZodObject< {}, $strip>;
1022
- outputSchema: ZodUnion<readonly [ZodObject< {
1023
- count: ZodNumber;
1024
- waypoints: ZodArray<ZodObject< {
1025
- name: ZodOptional<ZodUnknown>;
1026
- position: ZodArray<ZodNumber>;
1027
- }, $strip>>;
1028
- }, $strip>, ZodObject< {
1029
- error: ZodString;
1030
- }, $strip>]>;
1031
- execute: typeof executeGetShownWaypoints;
1032
- tags: string[];
1033
- examples: string[];
1034
- examplePrompts: string[];
1035
- relatedTools: string[];
1036
- dependsOn: string[];
1037
- };
1038
- getShownRouteTrafficIncidents: {
1039
- description: string;
1040
- classificationPrompt: string;
1041
- inputSchema: ZodObject< {}, $strip>;
1042
- outputSchema: ZodUnion<readonly [ZodObject< {
1043
- count: ZodNumber;
1044
- trafficIncidents: ZodArray<ZodObject< {
1045
- id: ZodString;
1046
- magnitudeOfDelay: ZodString;
1047
- title: ZodOptional<ZodString>;
1048
- delayInSeconds: ZodOptional<ZodNumber>;
1049
- effectiveSpeedInKmh: ZodOptional<ZodNumber>;
1050
- categories: ZodOptional<ZodArray<ZodString>>;
1051
- }, $strip>>;
1052
- }, $strip>, ZodObject< {
1053
- error: ZodString;
1054
- }, $strip>]>;
1055
- execute: typeof executeGetShownRouteTrafficIncidents;
1056
- tags: string[];
1057
- examples: string[];
1058
- examplePrompts: string[];
1059
- relatedTools: string[];
1060
- dependsOn: string[];
1061
- };
1062
- getShownRouteSections: {
1063
- description: string;
1064
- classificationPrompt: string;
1065
- inputSchema: ZodObject< {
1066
- sectionType: ZodEnum< {
1067
- leg: "leg";
1068
- traffic: "traffic";
1069
- carpool: "carpool";
1070
- carTrain: "carTrain";
1071
- country: "country";
1072
- ferry: "ferry";
1073
- importantRoadStretch: "importantRoadStretch";
1074
- lanes: "lanes";
1075
- lowEmissionZone: "lowEmissionZone";
1076
- motorway: "motorway";
1077
- pedestrian: "pedestrian";
1078
- roadShields: "roadShields";
1079
- speedLimit: "speedLimit";
1080
- toll: "toll";
1081
- tollVignette: "tollVignette";
1082
- tunnel: "tunnel";
1083
- unpaved: "unpaved";
1084
- urban: "urban";
1085
- vehicleRestricted: "vehicleRestricted";
1086
- }>;
1087
- }, $strip>;
1088
- outputSchema: ZodUnion<readonly [ZodObject< {
1089
- sectionType: ZodString;
1090
- routes: ZodArray<ZodObject< {
1091
- routeIndex: ZodNumber;
1092
- sections: ZodArray<ZodUnknown>;
1093
- }, $strip>>;
1094
- }, $strip>, ZodObject< {
1095
- error: ZodString;
1096
- }, $strip>]>;
1097
- execute: typeof executeGetShownRouteSections;
1098
- tags: string[];
1099
- examples: string[];
1100
- examplePrompts: string[];
1101
- relatedTools: string[];
1102
- dependsOn: string[];
1103
- };
1104
- getShownIncidents: {
1105
- description: string;
1106
- classificationPrompt: string;
1107
- inputSchema: ZodObject< {}, $strip>;
1108
- outputSchema: ZodUnion<readonly [ZodObject< {
1109
- count: ZodNumber;
1110
- trafficIncidents: ZodArray<ZodObject< {
1111
- id: ZodString;
1112
- category: ZodString;
1113
- magnitudeOfDelay: ZodString;
1114
- description: ZodOptional<ZodString>;
1115
- delayInSeconds: ZodOptional<ZodNumber>;
1116
- roadCategory: ZodOptional<ZodString>;
1117
- averageSpeedKmph: ZodOptional<ZodNumber>;
1118
- }, $strip>>;
1119
- }, $strip>, ZodObject< {
1120
- error: ZodString;
1121
- }, $strip>]>;
1122
- execute: typeof executeGetShownIncidents;
1123
- tags: string[];
1124
- examples: string[];
1125
- examplePrompts: string[];
1126
- relatedTools: string[];
1127
- dependsOn: string[];
1128
- };
1129
- clearMap: {
1130
- description: string;
1131
- classificationPrompt: string;
1132
- inputSchema: ZodObject< {
1133
- layers: ZodOptional<ZodArray<ZodEnum< {
1134
- routes: "routes";
1135
- places: "places";
1136
- geometries: "geometries";
1137
- analytics: "analytics";
1138
- }>>>;
1139
- }, $strip>;
1140
- outputSchema: ZodUnion<readonly [ZodObject< {
1141
- success: ZodLiteral<true>;
1142
- cleared: ZodArray<ZodString>;
1143
- }, $strip>, ZodObject< {
1144
- error: ZodString;
1145
- }, $strip>]>;
1146
- execute: typeof executeClearMap;
1147
- tags: string[];
1148
- examples: string[];
1149
- examplePrompts: string[];
1150
- relatedTools: string[];
1151
- };
1152
- flyTo: {
1153
- description: string;
1154
- classificationPrompt: string;
1155
- inputSchema: ZodObject< {
1156
- where: ZodUnion<readonly [ZodObject< {
1157
- boundingBox: ZodUnion<readonly [ZodUnion<readonly [ZodArray<ZodNumber>]>, ZodObject< {
1158
- bbox: ZodUnion<readonly [ZodArray<ZodNumber>]>;
1159
- }, $strip>]>;
1160
- padding: ZodOptional<ZodNumber>;
1161
- }, $strip>, ZodObject< {
1162
- position: ZodArray<ZodNumber>;
1163
- zoom: ZodOptional<ZodNumber>;
1164
- }, $strip>]>;
1165
- }, $strip>;
1166
- outputSchema: ZodUnion<readonly [ZodObject< {
1167
- success: ZodLiteral<true>;
1168
- }, $strip>, ZodObject< {
1169
- error: ZodString;
1170
- }, $strip>]>;
1171
- execute: typeof executeFlyTo;
1172
- tags: string[];
1173
- examples: string[];
1174
- examplePrompts: string[];
1175
- relatedTools: string[];
1176
- };
1177
- fitRouteSection: {
1178
- description: string;
1179
- classificationPrompt: string;
1180
- inputSchema: ZodObject< {
1181
- sectionType: ZodEnum< {
1182
- leg: "leg";
1183
- traffic: "traffic";
1184
- carpool: "carpool";
1185
- carTrain: "carTrain";
1186
- country: "country";
1187
- ferry: "ferry";
1188
- importantRoadStretch: "importantRoadStretch";
1189
- lanes: "lanes";
1190
- lowEmissionZone: "lowEmissionZone";
1191
- motorway: "motorway";
1192
- pedestrian: "pedestrian";
1193
- roadShields: "roadShields";
1194
- speedLimit: "speedLimit";
1195
- toll: "toll";
1196
- tollVignette: "tollVignette";
1197
- tunnel: "tunnel";
1198
- unpaved: "unpaved";
1199
- urban: "urban";
1200
- vehicleRestricted: "vehicleRestricted";
1201
- }>;
1202
- id: ZodString;
1203
- padding: ZodOptional<ZodNumber>;
1204
- }, $strip>;
1205
- outputSchema: ZodUnion<readonly [ZodObject< {
1206
- success: ZodLiteral<true>;
1207
- }, $strip>, ZodObject< {
1208
- error: ZodString;
1209
- }, $strip>]>;
1210
- execute: typeof executeFitRouteSection;
1211
- tags: string[];
1212
- examples: string[];
1213
- examplePrompts: string[];
1214
- relatedTools: string[];
1215
- dependsOn: string[];
1216
- };
1217
- getViewport: {
1218
- description: string;
1219
- classificationPrompt: string;
1220
- inputSchema: ZodObject< {}, $strip>;
1221
- outputSchema: ZodUnion<readonly [ZodObject< {
1222
- center: ZodArray<ZodNumber>;
1223
- zoom: ZodNumber;
1224
- bbox: ZodArray<ZodNumber>;
1225
- pitch: ZodNumber;
1226
- bearing: ZodNumber;
1227
- }, $strip>, ZodObject< {
1228
- error: ZodString;
1229
- }, $strip>]>;
1230
- execute: typeof executeGetViewport;
1231
- tags: string[];
1232
- examples: string[];
1233
- examplePrompts: string[];
1234
- relatedTools: string[];
1235
- };
1236
- recallPlaces: {
1237
- description: string;
1238
- classificationPrompt: string;
1239
- inputSchema: ZodObject< {
1240
- id: ZodOptional<ZodString>;
1241
- }, $strip>;
1242
- outputSchema: ZodUnion<readonly [ZodObject< {
1243
- entries: ZodArray<ZodObject< {
1244
- id: ZodString;
1245
- label: ZodString;
1246
- timestamp: ZodNumber;
1247
- }, $strip>>;
1248
- }, $strip>, ZodObject< {
1249
- id: ZodString;
1250
- label: ZodString;
1251
- timestamp: ZodNumber;
1252
- places: ZodObject< {
1253
- count: ZodNumber;
1254
- features: ZodArray<ZodObject< {
1255
- name: ZodOptional<ZodString>;
1256
- address: ZodOptional<ZodString>;
1257
- position: ZodArray<ZodNumber>;
1258
- }, $strip>>;
1259
- }, $strip>;
1260
- }, $strip>, ZodObject< {
1261
- error: ZodString;
1262
- }, $strip>]>;
1263
- execute: typeof executeRecallPlaces;
1264
- tags: string[];
1265
- examples: string[];
1266
- examplePrompts: string[];
1267
- relatedTools: string[];
1268
- dependsOn: string[];
1269
- };
1270
- recallRoutes: {
1271
- description: string;
1272
- classificationPrompt: string;
1273
- inputSchema: ZodObject< {
1274
- id: ZodOptional<ZodString>;
1275
- }, $strip>;
1276
- outputSchema: ZodUnion<readonly [ZodObject< {
1277
- entries: ZodArray<ZodObject< {
1278
- id: ZodString;
1279
- label: ZodString;
1280
- timestamp: ZodNumber;
1281
- }, $strip>>;
1282
- }, $strip>, ZodObject< {
1283
- id: ZodString;
1284
- label: ZodString;
1285
- timestamp: ZodNumber;
1286
- routes: ZodObject< {
1287
- count: ZodNumber;
1288
- routes: ZodArray<ZodObject< {
1289
- index: ZodNumber;
1290
- summary: ZodObject< {
1291
- travelTimeInSeconds: ZodNumber;
1292
- lengthInMeters: ZodNumber;
1293
- trafficDelayInSeconds: ZodOptional<ZodNumber>;
1294
- trafficLengthInMeters: ZodOptional<ZodNumber>;
1295
- departureTime: ZodOptional<ZodString>;
1296
- arrivalTime: ZodOptional<ZodString>;
1297
- noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
1298
- historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
1299
- liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
1300
- }, $strip>;
1301
- legSummaries: ZodOptional<ZodArray<ZodObject< {
1302
- travelTimeInSeconds: ZodNumber;
1303
- lengthInMeters: ZodNumber;
1304
- trafficDelayInSeconds: ZodOptional<ZodNumber>;
1305
- trafficLengthInMeters: ZodOptional<ZodNumber>;
1306
- departureTime: ZodOptional<ZodString>;
1307
- arrivalTime: ZodOptional<ZodString>;
1308
- noTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
1309
- historicTrafficTravelTimeInSeconds: ZodOptional<ZodNumber>;
1310
- liveTrafficIncidentsTravelTimeInSeconds: ZodOptional<ZodNumber>;
1311
- }, $strip>>>;
1312
- }, $strip>>;
1313
- }, $strip>;
1314
- waypoints: ZodArray<ZodObject< {
1315
- position: ZodArray<ZodNumber>;
1316
- }, $strip>>;
1317
- params: ZodObject< {
1318
- maxAlternatives: ZodOptional<ZodNumber>;
1319
- costModel: ZodOptional<ZodObject< {
1320
- routeType: ZodOptional<ZodEnum< {
1321
- fast: "fast";
1322
- short: "short";
1323
- efficient: "efficient";
1324
- thrilling: "thrilling";
1325
- }>>;
1326
- traffic: ZodOptional<ZodEnum< {
1327
- live: "live";
1328
- historical: "historical";
1329
- }>>;
1330
- avoid: ZodOptional<ZodArray<ZodEnum< {
1331
- tollRoads: "tollRoads";
1332
- motorways: "motorways";
1333
- ferries: "ferries";
1334
- unpavedRoads: "unpavedRoads";
1335
- carpools: "carpools";
1336
- alreadyUsedRoads: "alreadyUsedRoads";
1337
- borderCrossings: "borderCrossings";
1338
- tunnels: "tunnels";
1339
- carTrains: "carTrains";
1340
- lowEmissionZones: "lowEmissionZones";
1341
- }>>>;
1342
- avoidAreas: ZodOptional<ZodArray<ZodArray<ZodNumber>>>;
1343
- }, $strip>>;
1344
- when: ZodOptional<ZodObject< {
1345
- option: ZodEnum< {
1346
- departAt: "departAt";
1347
- arriveBy: "arriveBy";
1348
- }>;
1349
- date: ZodString;
1350
- }, $strip>>;
1351
- }, $strip>;
1352
- }, $strip>, ZodObject< {
1353
- error: ZodString;
1354
- }, $strip>]>;
1355
- execute: typeof executeRecallRoutes;
1356
- tags: string[];
1357
- examples: string[];
1358
- examplePrompts: string[];
1359
- relatedTools: string[];
1360
- dependsOn: string[];
1361
- };
1362
- getCurrentWaypoints: {
1363
- description: string;
1364
- classificationPrompt: string;
1365
- inputSchema: ZodObject< {
1366
- slotIndex: ZodOptional<ZodNumber>;
1367
- includeEmptySlots: ZodOptional<ZodBoolean>;
1368
- offset: ZodOptional<ZodNumber>;
1369
- limit: ZodOptional<ZodNumber>;
1370
- }, $strip>;
1371
- outputSchema: ZodObject< {
1372
- totalSlots: ZodNumber;
1373
- filledSlots: ZodNumber;
1374
- matchedCount: ZodNumber;
1375
- returnedCount: ZodNumber;
1376
- offset: ZodNumber;
1377
- hasMore: ZodBoolean;
1378
- nextOffset: ZodOptional<ZodNumber>;
1379
- waypoints: ZodArray<ZodObject< {
1380
- slotIndex: ZodNumber;
1381
- isFilled: ZodBoolean;
1382
- address: ZodOptional<ZodString>;
1383
- position: ZodOptional<ZodArray<ZodNumber>>;
1384
- }, $strip>>;
1385
- }, $strip>;
1386
- execute: typeof executeGetCurrentWaypoints;
1387
- tags: string[];
1388
- examples: string[];
1389
- examplePrompts: string[];
1390
- relatedTools: string[];
1391
- };
1392
- getStandardMapStyles: {
1393
- description: string;
1394
- classificationPrompt: string;
1395
- inputSchema: ZodObject< {}, $strip>;
1396
- outputSchema: ZodUnion<readonly [ZodObject< {
1397
- styles: ZodReadonly<ZodArray<ZodString>>;
1398
- }, $strip>, ZodObject< {
1399
- error: ZodString;
1400
- }, $strip>]>;
1401
- execute: typeof executeGetStandardMapStyles;
1402
- tags: string[];
1403
- examples: string[];
1404
- examplePrompts: string[];
1405
- relatedTools: string[];
1406
- };
1407
- setMapStandardStyle: {
1408
- description: string;
1409
- classificationPrompt: string;
1410
- inputSchema: ZodObject< {
1411
- style: ZodEnum< {
1412
- standardLight: "standardLight";
1413
- standardDark: "standardDark";
1414
- drivingLight: "drivingLight";
1415
- drivingDark: "drivingDark";
1416
- monoLight: "monoLight";
1417
- monoDark: "monoDark";
1418
- satellite: "satellite";
1419
- }>;
1420
- }, $strip>;
1421
- outputSchema: ZodUnion<readonly [ZodObject< {
1422
- success: ZodLiteral<true>;
1423
- style: ZodString;
1424
- }, $strip>, ZodObject< {
1425
- error: ZodString;
1426
- }, $strip>]>;
1427
- execute: typeof executeSetMapStandardStyle;
1428
- tags: string[];
1429
- examples: string[];
1430
- examplePrompts: string[];
1431
- relatedTools: string[];
1432
- };
1433
- setRouteTheme: {
1434
- description: string;
1435
- classificationPrompt: string;
1436
- inputSchema: ZodObject< {
1437
- mainColor: ZodOptional<ZodString>;
1438
- }, $strip>;
1439
- outputSchema: ZodUnion<readonly [ZodObject< {
1440
- success: ZodLiteral<true>;
1441
- theme: ZodObject< {
1442
- mainColor: ZodOptional<ZodString>;
1443
- }, $strip>;
1444
- }, $strip>, ZodObject< {
1445
- error: ZodString;
1446
- }, $strip>]>;
1447
- execute: typeof executeSetRouteTheme;
1448
- tags: string[];
1449
- examples: string[];
1450
- examplePrompts: string[];
1451
- relatedTools: string[];
1452
- dependsOn: string[];
1453
- };
1454
- setLanguage: {
1455
- description: string;
1456
- classificationPrompt: string;
1457
- inputSchema: ZodObject< {
1458
- language: ZodString;
1459
- }, $strip>;
1460
- outputSchema: ZodUnion<readonly [ZodObject< {
1461
- success: ZodLiteral<true>;
1462
- language: ZodString;
1463
- }, $strip>, ZodObject< {
1464
- error: ZodString;
1465
- }, $strip>]>;
1466
- execute: typeof executeSetLanguage;
1467
- tags: string[];
1468
- examples: string[];
1469
- examplePrompts: string[];
1470
- relatedTools: string[];
1471
- };
1472
- toggleBaseMapLayerGroups: {
1473
- description: string;
1474
- classificationPrompt: string;
1475
- inputSchema: ZodObject< {
1476
- visible: ZodBoolean;
1477
- layerGroups: ZodArray<ZodEnum< {
1478
- roadShields: "roadShields";
1479
- land: "land";
1480
- water: "water";
1481
- borders: "borders";
1482
- buildings2D: "buildings2D";
1483
- buildings3D: "buildings3D";
1484
- houseNumbers: "houseNumbers";
1485
- roadLines: "roadLines";
1486
- roadLabels: "roadLabels";
1487
- placeLabels: "placeLabels";
1488
- smallerTownLabels: "smallerTownLabels";
1489
- cityLabels: "cityLabels";
1490
- capitalLabels: "capitalLabels";
1491
- stateLabels: "stateLabels";
1492
- countryLabels: "countryLabels";
1493
- }>>;
1494
- }, $strip>;
1495
- outputSchema: ZodUnion<readonly [ZodObject< {
1496
- success: ZodLiteral<true>;
1497
- visible: ZodBoolean;
1498
- layerGroups: ZodArray<ZodString>;
1499
- }, $strip>, ZodObject< {
1500
- error: ZodString;
1501
- }, $strip>]>;
1502
- execute: typeof executeToggleBaseMapLayerGroups;
1503
- tags: string[];
1504
- examples: string[];
1505
- examplePrompts: string[];
1506
- relatedTools: string[];
1507
- };
1508
- togglePOIs: {
1509
- description: string;
1510
- classificationPrompt: string;
1511
- inputSchema: ZodObject< {
1512
- reset: ZodOptional<ZodBoolean>;
1513
- allMapPOIsVisible: ZodOptional<ZodBoolean>;
1514
- filterCategories: ZodOptional<ZodObject< {
1515
- show: ZodEnum< {
1516
- only: "only";
1517
- all_except: "all_except";
1518
- }>;
1519
- values: ZodArray<ZodString>;
1520
- }, $strip>>;
1521
- }, $strip>;
1522
- outputSchema: ZodUnion<readonly [ZodObject< {
1523
- success: ZodLiteral<true>;
1524
- allMapPOIsVisible: ZodOptional<ZodBoolean>;
1525
- filterCategories: ZodOptional<ZodObject< {
1526
- show: ZodEnum< {
1527
- only: "only";
1528
- all_except: "all_except";
1529
- }>;
1530
- values: ZodArray<ZodString>;
1531
- }, $strip>>;
1532
- reset: ZodOptional<ZodBoolean>;
1533
- }, $strip>, ZodObject< {
1534
- error: ZodString;
1535
- }, $strip>]>;
1536
- execute: typeof executeTogglePOIs;
1537
- tags: string[];
1538
- examples: string[];
1539
- examplePrompts: string[];
1540
- relatedTools: string[];
1541
- };
1542
- toggleTrafficFlow: {
1543
- description: string;
1544
- classificationPrompt: string;
1545
- inputSchema: ZodObject< {
1546
- visible: ZodBoolean;
1547
- }, $strip>;
1548
- outputSchema: ZodUnion<readonly [ZodObject< {
1549
- success: ZodLiteral<true>;
1550
- trafficFlowVisible: ZodBoolean;
1551
- }, $strip>, ZodObject< {
1552
- error: ZodString;
1553
- }, $strip>]>;
1554
- execute: typeof executeToggleTrafficFlow;
1555
- tags: string[];
1556
- examples: string[];
1557
- examplePrompts: string[];
1558
- relatedTools: string[];
1559
- };
1560
- toggleTrafficIncidents: {
1561
- description: string;
1562
- classificationPrompt: string;
1563
- inputSchema: ZodObject< {
1564
- visible: ZodBoolean;
1565
- }, $strip>;
1566
- outputSchema: ZodUnion<readonly [ZodObject< {
1567
- success: ZodLiteral<true>;
1568
- trafficIncidentsVisible: ZodBoolean;
1569
- }, $strip>, ZodObject< {
1570
- error: ZodString;
1571
- }, $strip>]>;
1572
- execute: typeof executeToggleTrafficIncidents;
1573
- tags: string[];
1574
- examples: string[];
1575
- examplePrompts: string[];
1576
- relatedTools: string[];
1577
- };
1578
- getMapStyleLayers: {
1579
- description: string;
1580
- classificationPrompt: string;
1581
- inputSchema: ZodObject< {
1582
- layerIdQuery: ZodOptional<ZodString>;
1583
- include: ZodArray<ZodEnum< {
1584
- layout: "layout";
1585
- paint: "paint";
1586
- }>>;
1587
- }, $strip>;
1588
- outputSchema: ZodUnion<readonly [ZodObject< {
1589
- layers: ZodArray<ZodObject< {
1590
- id: ZodString;
1591
- layout: ZodOptional<ZodUnknown>;
1592
- paint: ZodOptional<ZodUnknown>;
1593
- }, $strip>>;
1594
- }, $strip>, ZodObject< {
1595
- error: ZodString;
1596
- }, $strip>]>;
1597
- execute: typeof executeGetMapStyleLayers;
1598
- tags: string[];
1599
- examples: string[];
1600
- examplePrompts: string[];
1601
- relatedTools: string[];
1602
- };
1603
- setLayoutProperties: {
1604
- description: string;
1605
- classificationPrompt: string;
1606
- inputSchema: ZodObject< {
1607
- changes: ZodArray<ZodObject< {
1608
- layerId: ZodString;
1609
- propertyName: ZodString;
1610
- value: ZodAny;
1611
- }, $strip>>;
1612
- }, $strip>;
1613
- outputSchema: ZodUnion<readonly [ZodObject< {
1614
- results: ZodArray<ZodUnion<readonly [ZodObject< {
1615
- layerId: ZodString;
1616
- propertyName: ZodString;
1617
- value: ZodUnknown;
1618
- success: ZodLiteral<true>;
1619
- }, $strip>, ZodObject< {
1620
- layerId: ZodString;
1621
- propertyName: ZodString;
1622
- error: ZodString;
1623
- }, $strip>]>>;
1624
- }, $strip>, ZodObject< {
1625
- error: ZodString;
1626
- }, $strip>]>;
1627
- execute: typeof executeSetLayoutProperties;
1628
- tags: string[];
1629
- examples: string[];
1630
- examplePrompts: string[];
1631
- relatedTools: string[];
1632
- dependsOn: string[];
1633
- };
1634
- setPaintProperties: {
1635
- description: string;
1636
- classificationPrompt: string;
1637
- inputSchema: ZodObject< {
1638
- changes: ZodArray<ZodObject< {
1639
- layerId: ZodString;
1640
- propertyName: ZodString;
1641
- value: ZodAny;
1642
- }, $strip>>;
1643
- }, $strip>;
1644
- outputSchema: ZodUnion<readonly [ZodObject< {
1645
- results: ZodArray<ZodUnion<readonly [ZodObject< {
1646
- layerId: ZodString;
1647
- propertyName: ZodString;
1648
- value: ZodUnknown;
1649
- success: ZodLiteral<true>;
1650
- }, $strip>, ZodObject< {
1651
- layerId: ZodString;
1652
- propertyName: ZodString;
1653
- error: ZodString;
1654
- }, $strip>]>>;
1655
- }, $strip>, ZodObject< {
1656
- error: ZodString;
1657
- }, $strip>]>;
1658
- execute: typeof executeSetPaintProperties;
1659
- tags: string[];
1660
- examples: string[];
1661
- examplePrompts: string[];
1662
- relatedTools: string[];
1663
- dependsOn: string[];
1664
- };
1665
- setPitchBearing: {
1666
- description: string;
1667
- classificationPrompt: string;
1668
- inputSchema: ZodObject< {
1669
- pitch: ZodOptional<ZodNumber>;
1670
- bearing: ZodOptional<ZodNumber>;
1671
- }, $strip>;
1672
- outputSchema: ZodUnion<readonly [ZodObject< {
1673
- success: ZodLiteral<true>;
1674
- }, $strip>, ZodObject< {
1675
- error: ZodString;
1676
- }, $strip>]>;
1677
- execute: typeof executeSetPitchBearing;
1678
- tags: string[];
1679
- examples: string[];
1680
- examplePrompts: string[];
1681
- relatedTools: string[];
1682
- };
1683
- zoomInOrOut: {
1684
- description: string;
1685
- classificationPrompt: string;
1686
- inputSchema: ZodObject< {
1687
- delta: ZodNumber;
1688
- }, $strip>;
1689
- outputSchema: ZodUnion<readonly [ZodObject< {
1690
- zoom: ZodNumber;
1691
- }, $strip>, ZodObject< {
1692
- error: ZodString;
1693
- }, $strip>]>;
1694
- execute: typeof executeZoomInOrOut;
1695
- tags: string[];
1696
- examples: string[];
1697
- examplePrompts: string[];
1698
- relatedTools: string[];
1699
- };
1700
- executeMaplibreCode: {
1701
- description: string;
1702
- classificationPrompt: string;
1703
- inputSchema: ZodObject< {
1704
- code: ZodString;
1705
- }, $strip>;
1706
- outputSchema: ZodUnion<readonly [ZodObject< {
1707
- success: ZodLiteral<true>;
1708
- result: ZodOptional<ZodUnknown>;
1709
- sources: ZodObject< {
1710
- added: ZodArray<ZodString>;
1711
- removed: ZodArray<ZodString>;
1712
- updated: ZodArray<ZodString>;
1713
- }, $strip>;
1714
- layers: ZodObject< {
1715
- added: ZodArray<ZodString>;
1716
- removed: ZodArray<ZodString>;
1717
- updated: ZodArray<ZodString>;
1718
- }, $strip>;
1719
- }, $strip>, ZodObject< {
1720
- error: ZodString;
1721
- }, $strip>]>;
1722
- execute: typeof executeExecuteMaplibreCode;
1723
- tags: string[];
1724
- examples: string[];
1725
- examplePrompts: string[];
1726
- relatedTools: string[];
1727
- dependsOn: string[];
1728
- };
1729
- calculateBBox: {
1730
- description: string;
1731
- classificationPrompt: string;
1732
- inputSchema: ZodObject< {
1733
- geoJson: ZodUnion<readonly [ZodRecord<ZodString, ZodUnknown>, ZodArray<ZodRecord<ZodString, ZodUnknown>>]>;
1734
- }, $strip>;
1735
- execute: typeof executeCalculateBBox;
1736
- tags: string[];
1737
- examples: string[];
1738
- examplePrompts: string[];
1739
- relatedTools: string[];
1740
- };
1741
- formatDistance: {
1742
- description: string;
1743
- classificationPrompt: string;
1744
- inputSchema: ZodObject< {
1745
- meters: ZodNumber;
1746
- unitType: ZodOptional<ZodEnum< {
1747
- metric: "metric";
1748
- imperial_us: "imperial_us";
1749
- imperial_uk: "imperial_uk";
1750
- }>>;
1751
- }, $strip>;
1752
- execute: typeof executeFormatDistance;
1753
- tags: string[];
1754
- examples: string[];
1755
- examplePrompts: string[];
1756
- relatedTools: string[];
1757
- };
1758
- formatDuration: {
1759
- description: string;
1760
- classificationPrompt: string;
1761
- inputSchema: ZodObject< {
1762
- seconds: ZodNumber;
1763
- }, $strip>;
1764
- execute: typeof executeFormatDuration;
1765
- tags: string[];
1766
- examples: string[];
1767
- examplePrompts: string[];
1768
- relatedTools: string[];
1769
- };
1770
- getSectionProgress: {
1771
- description: string;
1772
- classificationPrompt: string;
1773
- inputSchema: ZodObject< {
1774
- sectionType: ZodEnum< {
1775
- leg: "leg";
1776
- traffic: "traffic";
1777
- carpool: "carpool";
1778
- carTrain: "carTrain";
1779
- country: "country";
1780
- ferry: "ferry";
1781
- importantRoadStretch: "importantRoadStretch";
1782
- lanes: "lanes";
1783
- lowEmissionZone: "lowEmissionZone";
1784
- motorway: "motorway";
1785
- pedestrian: "pedestrian";
1786
- roadShields: "roadShields";
1787
- speedLimit: "speedLimit";
1788
- toll: "toll";
1789
- tollVignette: "tollVignette";
1790
- tunnel: "tunnel";
1791
- unpaved: "unpaved";
1792
- urban: "urban";
1793
- vehicleRestricted: "vehicleRestricted";
1794
- }>;
1795
- ids: ZodOptional<ZodArray<ZodString>>;
1796
- }, $strip>;
1797
- execute: typeof executeGetSectionProgress;
1798
- tags: string[];
1799
- examples: string[];
1800
- examplePrompts: string[];
1801
- relatedTools: string[];
1802
- dependsOn: string[];
1803
- };
1804
- getSectionBBox: {
1805
- description: string;
1806
- classificationPrompt: string;
1807
- inputSchema: ZodObject< {
1808
- sectionType: ZodEnum< {
1809
- leg: "leg";
1810
- traffic: "traffic";
1811
- carpool: "carpool";
1812
- carTrain: "carTrain";
1813
- country: "country";
1814
- ferry: "ferry";
1815
- importantRoadStretch: "importantRoadStretch";
1816
- lanes: "lanes";
1817
- lowEmissionZone: "lowEmissionZone";
1818
- motorway: "motorway";
1819
- pedestrian: "pedestrian";
1820
- roadShields: "roadShields";
1821
- speedLimit: "speedLimit";
1822
- toll: "toll";
1823
- tollVignette: "tollVignette";
1824
- tunnel: "tunnel";
1825
- unpaved: "unpaved";
1826
- urban: "urban";
1827
- vehicleRestricted: "vehicleRestricted";
1828
- }>;
1829
- id: ZodString;
1830
- }, $strip>;
1831
- outputSchema: ZodUnion<readonly [ZodObject< {
1832
- bbox: ZodArray<ZodNumber>;
1833
- }, $strip>, ZodObject< {
1834
- error: ZodString;
1835
- }, $strip>]>;
1836
- execute: typeof executeGetSectionBBox;
1837
- tags: string[];
1838
- examples: string[];
1839
- examplePrompts: string[];
1840
- relatedTools: string[];
1841
- dependsOn: string[];
1842
- };
1843
- getRouteProgress: {
1844
- description: string;
1845
- classificationPrompt: string;
1846
- inputSchema: ZodObject< {
1847
- routeIndex: ZodOptional<ZodNumber>;
1848
- traveledTimeInSeconds: ZodOptional<ZodNumber>;
1849
- traveledDistanceInMeters: ZodOptional<ZodNumber>;
1850
- clockTime: ZodOptional<ZodString>;
1851
- }, $strip>;
1852
- execute: typeof executeGetRouteProgress;
1853
- tags: string[];
1854
- examples: string[];
1855
- examplePrompts: string[];
1856
- relatedTools: string[];
1857
- dependsOn: string[];
1858
- };
1859
- getCurrentLocation: {
1860
- description: string;
1861
- classificationPrompt: string;
1862
- inputSchema: ZodObject< {}, $strip>;
1863
- outputSchema: ZodUnion<readonly [ZodObject< {
1864
- position: ZodArray<ZodNumber>;
1865
- accuracy: ZodNumber;
1866
- timestamp: ZodNumber;
1867
- }, $strip>, ZodObject< {
1868
- error: ZodString;
1869
- }, $strip>]>;
1870
- execute: typeof executeGetCurrentLocation;
1871
- tags: string[];
1872
- examples: string[];
1873
- examplePrompts: string[];
1874
- relatedTools: string[];
1875
- };
1876
- help: {
1877
- description: string;
1878
- classificationPrompt: string;
1879
- inputSchema: ZodObject< {
1880
- mode: ZodEnum< {
1881
- summary: "summary";
1882
- detail: "detail";
1883
- }>;
1884
- query: ZodOptional<ZodString>;
1885
- tag: ZodOptional<ZodEnum< {
1886
- place: "place";
1887
- leg: "leg";
1888
- location: "location";
1889
- route: "route";
1890
- traffic: "traffic";
1891
- carpool: "carpool";
1892
- carTrain: "carTrain";
1893
- country: "country";
1894
- ferry: "ferry";
1895
- importantRoadStretch: "importantRoadStretch";
1896
- lanes: "lanes";
1897
- lowEmissionZone: "lowEmissionZone";
1898
- motorway: "motorway";
1899
- pedestrian: "pedestrian";
1900
- roadShields: "roadShields";
1901
- speedLimit: "speedLimit";
1902
- toll: "toll";
1903
- tollVignette: "tollVignette";
1904
- tunnel: "tunnel";
1905
- unpaved: "unpaved";
1906
- urban: "urban";
1907
- vehicleRestricted: "vehicleRestricted";
1908
- waypoint: "waypoint";
1909
- locate: "locate";
1910
- discover: "discover";
1911
- "map style": "map style";
1912
- utilities: "utilities";
1913
- search: "search";
1914
- detour: "detour";
1915
- "along-route": "along-route";
1916
- "reachable-range": "reachable-range";
1917
- isochrone: "isochrone";
1918
- range: "range";
1919
- EV: "EV";
1920
- coverage: "coverage";
1921
- recall: "recall";
1922
- state: "state";
1923
- }>>;
1924
- }, $strip>;
1925
- outputSchema: ZodUnion<readonly [ZodObject< {
1926
- mode: ZodLiteral<"summary">;
1927
- examplePrompts: ZodArray<ZodString>;
1928
- }, $strip>, ZodObject< {
1929
- mode: ZodLiteral<"detail">;
1930
- query: ZodOptional<ZodString>;
1931
- tag: ZodOptional<ZodEnum< {
1932
- place: "place";
1933
- leg: "leg";
1934
- location: "location";
1935
- route: "route";
1936
- traffic: "traffic";
1937
- carpool: "carpool";
1938
- carTrain: "carTrain";
1939
- country: "country";
1940
- ferry: "ferry";
1941
- importantRoadStretch: "importantRoadStretch";
1942
- lanes: "lanes";
1943
- lowEmissionZone: "lowEmissionZone";
1944
- motorway: "motorway";
1945
- pedestrian: "pedestrian";
1946
- roadShields: "roadShields";
1947
- speedLimit: "speedLimit";
1948
- toll: "toll";
1949
- tollVignette: "tollVignette";
1950
- tunnel: "tunnel";
1951
- unpaved: "unpaved";
1952
- urban: "urban";
1953
- vehicleRestricted: "vehicleRestricted";
1954
- waypoint: "waypoint";
1955
- locate: "locate";
1956
- discover: "discover";
1957
- "map style": "map style";
1958
- utilities: "utilities";
1959
- search: "search";
1960
- detour: "detour";
1961
- "along-route": "along-route";
1962
- "reachable-range": "reachable-range";
1963
- isochrone: "isochrone";
1964
- range: "range";
1965
- EV: "EV";
1966
- coverage: "coverage";
1967
- recall: "recall";
1968
- state: "state";
1969
- }>>;
1970
- matchedTools: ZodArray<ZodObject< {
1971
- name: ZodString;
1972
- description: ZodString;
1973
- examplePrompts: ZodArray<ZodString>;
1974
- relatedTools: ZodOptional<ZodArray<ZodString>>;
1975
- }, $strip>>;
1976
- totalMatched: ZodNumber;
1977
- }, $strip>, ZodObject< {
1978
- error: ZodString;
1979
- }, $strip>]>;
1980
- execute: () => Promise<never>;
1981
- tags: string[];
1982
- examples: string[];
1983
- examplePrompts: string[];
1984
- };
1985
- searchAlongRoute: {
1986
- description: string;
1987
- classificationPrompt: string;
1988
- inputSchema: ZodObject< {
1989
- query: ZodOptional<ZodString>;
1990
- poiCategories: ZodOptional<ZodArray<ZodString>>;
1991
- routeId: ZodOptional<ZodString>;
1992
- maxDetourTimeSeconds: ZodNumber;
1993
- sortBy: ZodOptional<ZodEnum< {
1994
- detourTime: "detourTime";
1995
- detourOffset: "detourOffset";
1996
- }>>;
1997
- limit: ZodOptional<ZodNumber>;
1998
- show: ZodOptional<ZodObject< {
1999
- markerType: ZodEnum< {
2000
- pin: "pin";
2001
- none: "none";
2002
- }>;
2003
- zoomMode: ZodEnum< {
2004
- none: "none";
2005
- auto: "auto";
2006
- }>;
2007
- }, $strip>>;
2008
- }, $strip>;
2009
- outputSchema: ZodUnion<readonly [ZodObject< {
2010
- count: ZodNumber;
2011
- features: ZodArray<ZodObject< {
2012
- name: ZodOptional<ZodString>;
2013
- address: ZodOptional<ZodString>;
2014
- position: ZodArray<ZodNumber>;
2015
- }, $strip>>;
2016
- placeResultIndex: ZodString;
2017
- shown: ZodOptional<ZodObject< {
2018
- markerType: ZodBoolean;
2019
- zoomMode: ZodBoolean;
2020
- }, $strip>>;
2021
- }, $strip>, ZodObject< {
2022
- status: ZodLiteral<"no_route">;
2023
- }, $strip>, ZodObject< {
2024
- error: ZodString;
2025
- }, $strip>]>;
2026
- execute: typeof executeSearchAlongRoute;
2027
- tags: string[];
2028
- examples: string[];
2029
- examplePrompts: string[];
2030
- relatedTools: string[];
2031
- dependsOn: string[];
2032
- };
2033
- findReachableArea: {
2034
- description: string;
2035
- classificationPrompt: string;
2036
- inputSchema: ZodObject< {
2037
- origin: ZodUnion<readonly [ZodObject< {
2038
- query: ZodString;
2039
- locationType: ZodEnum< {
2040
- default: "default";
2041
- poi: "poi";
2042
- }>;
2043
- }, $strip>, ZodObject< {
2044
- position: ZodObject< {
2045
- lng: ZodNumber;
2046
- lat: ZodNumber;
2047
- }, $strip>;
2048
- }, $strip>]>;
2049
- budgets: ZodArray<ZodObject< {
2050
- type: ZodEnum< {
2051
- timeMinutes: "timeMinutes";
2052
- distanceKM: "distanceKM";
2053
- }>;
2054
- value: ZodNumber;
2055
- }, $strip>>;
2056
- theme: ZodOptional<ZodEnum< {
2057
- filled: "filled";
2058
- outline: "outline";
2059
- inverted: "inverted";
2060
- }>>;
2061
- showOnMap: ZodBoolean;
2062
- showOriginPin: ZodOptional<ZodBoolean>;
2063
- }, $strip>;
2064
- outputSchema: ZodUnion<readonly [ZodObject< {
2065
- rangeId: ZodString;
2066
- originName: ZodString;
2067
- budgets: ZodArray<ZodObject< {
2068
- type: ZodEnum< {
2069
- timeMinutes: "timeMinutes";
2070
- distanceKM: "distanceKM";
2071
- }>;
2072
- value: ZodNumber;
2073
- }, $strip>>;
2074
- }, $strip>, ZodObject< {
2075
- status: ZodEnum< {
2076
- not_found: "not_found";
2077
- no_results: "no_results";
2078
- }>;
2079
- }, $strip>, ZodObject< {
2080
- error: ZodString;
2081
- }, $strip>]>;
2082
- execute: typeof executeFindReachableArea;
2083
- tags: string[];
2084
- examples: string[];
2085
- examplePrompts: string[];
2086
- relatedTools: string[];
2087
- };
2088
- recallRanges: {
2089
- description: string;
2090
- classificationPrompt: string;
2091
- inputSchema: ZodObject< {
2092
- id: ZodOptional<ZodString>;
2093
- }, $strip>;
2094
- outputSchema: ZodUnion<readonly [ZodObject< {
2095
- entries: ZodArray<ZodObject< {
2096
- id: ZodString;
2097
- label: ZodString;
2098
- timestamp: ZodNumber;
2099
- }, $strip>>;
2100
- }, $strip>, ZodObject< {
2101
- id: ZodString;
2102
- label: ZodString;
2103
- timestamp: ZodNumber;
2104
- origin: ZodObject< {
2105
- query: ZodOptional<ZodString>;
2106
- position: ZodTuple<[ZodNumber, ZodNumber], null>;
2107
- }, $strip>;
2108
- budgets: ZodArray<ZodObject< {
2109
- type: ZodString;
2110
- value: ZodNumber;
2111
- }, $strip>>;
2112
- }, $strip>, ZodObject< {
2113
- error: ZodString;
2114
- }, $strip>]>;
2115
- execute: typeof executeRecallRanges;
2116
- tags: string[];
2117
- examples: string[];
2118
- examplePrompts: string[];
2119
- relatedTools: string[];
2120
- };
230
+ locatePlace: ToolEntry;
231
+ reverseGeocode: ToolEntry;
232
+ discoverPlaces: ToolEntry;
233
+ setRouteLocations: ToolEntry;
234
+ setRouteParameters: ToolEntry;
235
+ addStopToRoute: ToolEntry;
236
+ removeStopFromRoute: ToolEntry;
237
+ getPOICategoryCodes: ToolEntry;
238
+ getTrafficIncidents: ToolEntry;
239
+ getTrafficAreaAnalytics: ToolEntry;
240
+ queryTrafficAnalytics: ToolEntry;
241
+ showPlaces: ToolEntry;
242
+ managePlaces: ToolEntry;
243
+ showRoute: ToolEntry;
244
+ showTrafficAreaAnalytics: ToolEntry;
245
+ showWaypoints: ToolEntry;
246
+ getShownPlaces: ToolEntry;
247
+ getShownRoutes: ToolEntry;
248
+ getShownWaypoints: ToolEntry;
249
+ getShownRouteTrafficIncidents: ToolEntry;
250
+ getShownRouteSections: ToolEntry;
251
+ getShownIncidents: ToolEntry;
252
+ clearMap: ToolEntry;
253
+ flyTo: ToolEntry;
254
+ fitRouteSection: ToolEntry;
255
+ getViewport: ToolEntry;
256
+ recallPlaces: ToolEntry;
257
+ recallRoutes: ToolEntry;
258
+ getCurrentWaypoints: ToolEntry;
259
+ getStandardMapStyles: ToolEntry;
260
+ setMapStandardStyle: ToolEntry;
261
+ setRouteTheme: ToolEntry;
262
+ setLanguage: ToolEntry;
263
+ toggleBaseMapLayerGroups: ToolEntry;
264
+ togglePOIs: ToolEntry;
265
+ toggleTrafficFlow: ToolEntry;
266
+ toggleTrafficIncidents: ToolEntry;
267
+ getMapStyleLayers: ToolEntry;
268
+ setLayoutProperties: ToolEntry;
269
+ setPaintProperties: ToolEntry;
270
+ setPitchBearing: ToolEntry;
271
+ zoomInOrOut: ToolEntry;
272
+ executeMaplibreCode: ToolEntry;
273
+ calculateBBox: ToolEntry;
274
+ formatDistance: ToolEntry;
275
+ formatDuration: ToolEntry;
276
+ getSectionProgress: ToolEntry;
277
+ getSectionBBox: ToolEntry;
278
+ getRouteProgress: ToolEntry;
279
+ getCurrentLocation: ToolEntry;
280
+ help: ToolEntry;
281
+ searchAlongRoute: ToolEntry;
282
+ findReachableArea: ToolEntry;
283
+ recallRanges: ToolEntry;
2121
284
  };
2122
285
 
2123
- /** Output schema for the discover-places tool. */
2124
- declare const discoverPlacesOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
2125
- count: z.ZodNumber;
2126
- features: z.ZodArray<z.ZodObject<{
2127
- name: z.ZodOptional<z.ZodString>;
2128
- address: z.ZodOptional<z.ZodString>;
2129
- position: z.ZodArray<z.ZodNumber>;
2130
- }, z.core.$strip>>;
2131
- shown: z.ZodOptional<z.ZodObject<{
2132
- markerType: z.ZodBoolean;
2133
- zoomMode: z.ZodBoolean;
2134
- }, z.core.$strip>>;
2135
- placeResultIndex: z.ZodOptional<z.ZodString>;
2136
- }, z.core.$strip>, z.ZodObject<{
2137
- error: z.ZodString;
2138
- }, z.core.$strip>]>;
2139
-
2140
- /**
2141
- * Tool schema for discovering places.
2142
- */
2143
- declare const discoverPlacesSchema: z.ZodObject<{
2144
- query: z.ZodOptional<z.ZodString>;
2145
- where: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
2146
- position: z.ZodArray<z.ZodNumber>;
2147
- }, z.core.$strip>, z.ZodObject<{
2148
- boundingBox: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodNumber>]>, z.ZodObject<{
2149
- bbox: z.ZodUnion<readonly [z.ZodArray<z.ZodNumber>]>;
2150
- }, z.core.$strip>]>;
2151
- }, z.core.$strip>, z.ZodLiteral<"within-map-bounds">, z.ZodLiteral<"nearby-map-center">, z.ZodLiteral<"global">, z.ZodString]>>;
2152
- radiusMeters: z.ZodOptional<z.ZodNumber>;
2153
- limit: z.ZodOptional<z.ZodNumber>;
2154
- poiCategories: z.ZodOptional<z.ZodArray<z.ZodString>>;
2155
- show: z.ZodOptional<z.ZodObject<{
2156
- markerType: z.ZodEnum<{
2157
- pin: "pin";
2158
- none: "none";
2159
- }>;
2160
- zoomMode: z.ZodEnum<{
2161
- none: "none";
2162
- auto: "auto";
2163
- }>;
2164
- }, z.core.$strip>>;
2165
- withinRange: z.ZodOptional<z.ZodString>;
2166
- }, z.core.$strip>;
2167
-
2168
- /**
2169
- * Create the add stop to route tool.
2170
- */
2171
- /** Standalone execute for ToolEntry format. */
2172
- declare function executeAddStopToRoute(params: z.infer<typeof addStopToRouteSchema>, state: ToolState): Promise<z.infer<typeof addStopToRouteOutputSchema>>;
2173
-
2174
- /** Execute function for calculateBBox — usable with ToolEntry format. */
2175
- declare function executeCalculateBBox(params: z.infer<typeof calculateBBoxSchema>, _state: ToolState): Promise<{
2176
- error: string;
2177
- bbox?: undefined;
2178
- minLng?: undefined;
2179
- minLat?: undefined;
2180
- maxLng?: undefined;
2181
- maxLat?: undefined;
2182
- } | {
2183
- bbox: BBox;
2184
- minLng: number;
2185
- minLat: number;
2186
- maxLng: number;
2187
- maxLat: number;
2188
- error?: undefined;
2189
- }>;
2190
-
2191
- /**
2192
- * Execute clear map.
2193
- */
2194
- declare function executeClearMap(params: z.infer<typeof clearMapSchema>, state: ToolState): Promise<{
2195
- success: boolean;
2196
- cleared: ("routes" | "places" | "geometries" | "analytics")[];
2197
- error?: undefined;
2198
- } | {
2199
- error: string;
2200
- success?: undefined;
2201
- cleared?: undefined;
2202
- }>;
2203
-
2204
- /**
2205
- * Create the discover places tool.
2206
- */
2207
- /** Standalone execute for ToolEntry format. */
2208
- declare function executeDiscoverPlaces(params: z.infer<typeof discoverPlacesSchema>, state: ToolState): Promise<z.infer<typeof discoverPlacesOutputSchema>>;
2209
-
2210
- /** Execute function for executeMaplibreCode — usable with ToolEntry format. */
2211
- declare function executeExecuteMaplibreCode(params: z.infer<typeof executeMaplibreCodeSchema>, state: ToolState): Promise<{
2212
- success: boolean;
2213
- result: {} | undefined;
2214
- sources: {
2215
- added: string[];
2216
- removed: string[];
2217
- updated: string[];
2218
- };
2219
- layers: {
2220
- added: string[];
2221
- removed: string[];
2222
- updated: string[];
2223
- };
2224
- error?: undefined;
2225
- } | {
2226
- error: string;
2227
- success?: undefined;
2228
- result?: undefined;
2229
- sources?: undefined;
2230
- layers?: undefined;
2231
- }>;
2232
-
2233
- /** Standalone execute for ToolEntry format. */
2234
- declare function executeFindReachableArea(params: z.infer<typeof findReachableAreaSchema>, state: ToolState): Promise<z.infer<typeof findReachableAreaOutputSchema>>;
2235
-
2236
- /**
2237
- * Execute fit route section.
2238
- */
2239
- declare function executeFitRouteSection(params: z.infer<typeof fitRouteSectionSchema>, state: ToolState): Promise<{
2240
- error: string;
2241
- success?: undefined;
2242
- } | {
2243
- success: boolean;
2244
- error?: undefined;
2245
- }>;
2246
-
2247
- /** Execute function for flyTo — usable with ToolEntry format. */
2248
- declare function executeFlyTo(params: z.infer<typeof flyToSchema>, state: ToolState): Promise<{
2249
- error: string;
2250
- success?: undefined;
2251
- } | {
2252
- success: boolean;
2253
- error?: undefined;
2254
- }>;
2255
-
2256
- /** Execute function for formatDistance — usable with ToolEntry format. */
2257
- declare function executeFormatDistance(params: z.infer<typeof formatDistanceSchema>, _state: ToolState): Promise<{
2258
- formatted: string;
2259
- input: {
2260
- meters: number;
2261
- unitType: "metric" | "imperial_us" | "imperial_uk";
2262
- };
2263
- error?: undefined;
2264
- } | {
2265
- error: string;
2266
- formatted?: undefined;
2267
- input?: undefined;
2268
- }>;
2269
-
2270
- /** Execute function for formatDuration — usable with ToolEntry format. */
2271
- declare function executeFormatDuration(params: z.infer<typeof formatDurationSchema>, _state: ToolState): Promise<{
2272
- formatted: undefined;
2273
- message: string;
2274
- input: {
2275
- seconds: number;
2276
- };
2277
- error?: undefined;
2278
- } | {
2279
- formatted: string;
2280
- input: {
2281
- seconds: number;
2282
- };
2283
- message?: undefined;
2284
- error?: undefined;
2285
- } | {
2286
- error: string;
2287
- formatted?: undefined;
2288
- message?: undefined;
2289
- input?: undefined;
2290
- }>;
2291
-
2292
- /** Execute function for getCurrentLocation — usable with ToolEntry format. */
2293
- declare function executeGetCurrentLocation(_params: z.infer<typeof getCurrentLocationSchema>, _state: ToolState): Promise<z.infer<typeof getCurrentLocationOutputSchema>>;
2294
-
2295
- declare function executeGetCurrentWaypoints(params: z.infer<typeof getCurrentWaypointsSchema>, state: ToolState): Promise<z.infer<typeof getCurrentWaypointsOutputSchema>>;
2296
-
2297
- /** Execute function for getMapStyleLayers — usable with ToolEntry format. */
2298
- declare function executeGetMapStyleLayers(params: z.infer<typeof getMapStyleLayersSchema>, state: ToolState): Promise<{
2299
- error: string;
2300
- layers?: undefined;
2301
- } | {
2302
- layers: {
2303
- layout?: {
2304
- "fill-sort-key"?: DataDrivenPropertyValueSpecification<number>;
2305
- visibility?: VisibilitySpecification;
2306
- } | {
2307
- "line-cap"?: DataDrivenPropertyValueSpecification<"butt" | "round" | "square">;
2308
- "line-join"?: DataDrivenPropertyValueSpecification<"bevel" | "round" | "miter">;
2309
- "line-miter-limit"?: DataDrivenPropertyValueSpecification<number>;
2310
- "line-round-limit"?: DataDrivenPropertyValueSpecification<number>;
2311
- "line-sort-key"?: DataDrivenPropertyValueSpecification<number>;
2312
- visibility?: VisibilitySpecification;
2313
- } | {
2314
- "symbol-placement"?: PropertyValueSpecification<"point" | "line" | "line-center">;
2315
- "symbol-spacing"?: PropertyValueSpecification<number>;
2316
- "symbol-avoid-edges"?: PropertyValueSpecification<boolean>;
2317
- "symbol-sort-key"?: DataDrivenPropertyValueSpecification<number>;
2318
- "symbol-z-order"?: PropertyValueSpecification<"auto" | "viewport-y" | "source">;
2319
- "icon-allow-overlap"?: PropertyValueSpecification<boolean>;
2320
- "icon-overlap"?: PropertyValueSpecification<"never" | "always" | "cooperative">;
2321
- "icon-ignore-placement"?: PropertyValueSpecification<boolean>;
2322
- "icon-optional"?: PropertyValueSpecification<boolean>;
2323
- "icon-rotation-alignment"?: PropertyValueSpecification<"map" | "viewport" | "auto">;
2324
- "icon-size"?: DataDrivenPropertyValueSpecification<number>;
2325
- "icon-text-fit"?: PropertyValueSpecification<"none" | "width" | "height" | "both">;
2326
- "icon-text-fit-padding"?: PropertyValueSpecification<[number, number, number, number]>;
2327
- "icon-image"?: DataDrivenPropertyValueSpecification<ResolvedImageSpecification>;
2328
- "icon-rotate"?: DataDrivenPropertyValueSpecification<number>;
2329
- "icon-padding"?: DataDrivenPropertyValueSpecification<PaddingSpecification>;
2330
- "icon-keep-upright"?: PropertyValueSpecification<boolean>;
2331
- "icon-offset"?: DataDrivenPropertyValueSpecification<[number, number]>;
2332
- "icon-anchor"?: DataDrivenPropertyValueSpecification<"center" | "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right">;
2333
- "icon-pitch-alignment"?: PropertyValueSpecification<"map" | "viewport" | "auto">;
2334
- "text-pitch-alignment"?: PropertyValueSpecification<"map" | "viewport" | "auto">;
2335
- "text-rotation-alignment"?: PropertyValueSpecification<"map" | "viewport" | "viewport-glyph" | "auto">;
2336
- "text-field"?: DataDrivenPropertyValueSpecification<FormattedSpecification>;
2337
- "text-font"?: DataDrivenPropertyValueSpecification<Array<string>>;
2338
- "text-size"?: DataDrivenPropertyValueSpecification<number>;
2339
- "text-max-width"?: DataDrivenPropertyValueSpecification<number>;
2340
- "text-line-height"?: PropertyValueSpecification<number>;
2341
- "text-letter-spacing"?: DataDrivenPropertyValueSpecification<number>;
2342
- "text-justify"?: DataDrivenPropertyValueSpecification<"auto" | "left" | "center" | "right">;
2343
- "text-radial-offset"?: DataDrivenPropertyValueSpecification<number>;
2344
- "text-variable-anchor"?: PropertyValueSpecification<Array<"center" | "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right">>;
2345
- "text-variable-anchor-offset"?: DataDrivenPropertyValueSpecification<VariableAnchorOffsetCollectionSpecification>;
2346
- "text-anchor"?: DataDrivenPropertyValueSpecification<"center" | "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right">;
2347
- "text-max-angle"?: PropertyValueSpecification<number>;
2348
- "text-writing-mode"?: PropertyValueSpecification<Array<"horizontal" | "vertical">>;
2349
- "text-rotate"?: DataDrivenPropertyValueSpecification<number>;
2350
- "text-padding"?: PropertyValueSpecification<number>;
2351
- "text-keep-upright"?: PropertyValueSpecification<boolean>;
2352
- "text-transform"?: DataDrivenPropertyValueSpecification<"none" | "uppercase" | "lowercase">;
2353
- "text-offset"?: DataDrivenPropertyValueSpecification<[number, number]>;
2354
- "text-allow-overlap"?: PropertyValueSpecification<boolean>;
2355
- "text-overlap"?: PropertyValueSpecification<"never" | "always" | "cooperative">;
2356
- "text-ignore-placement"?: PropertyValueSpecification<boolean>;
2357
- "text-optional"?: PropertyValueSpecification<boolean>;
2358
- visibility?: VisibilitySpecification;
2359
- } | {
2360
- "circle-sort-key"?: DataDrivenPropertyValueSpecification<number>;
2361
- visibility?: VisibilitySpecification;
2362
- } | {
2363
- visibility?: VisibilitySpecification;
2364
- } | {
2365
- visibility?: VisibilitySpecification;
2366
- } | {
2367
- visibility?: VisibilitySpecification;
2368
- } | {
2369
- visibility?: VisibilitySpecification;
2370
- } | {
2371
- visibility?: VisibilitySpecification;
2372
- } | {
2373
- visibility?: VisibilitySpecification;
2374
- } | undefined;
2375
- paint?: {
2376
- "fill-antialias"?: PropertyValueSpecification<boolean>;
2377
- "fill-opacity"?: DataDrivenPropertyValueSpecification<number>;
2378
- "fill-opacity-transition"?: TransitionSpecification;
2379
- "fill-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
2380
- "fill-color-transition"?: TransitionSpecification;
2381
- "fill-outline-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
2382
- "fill-outline-color-transition"?: TransitionSpecification;
2383
- "fill-translate"?: PropertyValueSpecification<[number, number]>;
2384
- "fill-translate-transition"?: TransitionSpecification;
2385
- "fill-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
2386
- "fill-pattern"?: DataDrivenPropertyValueSpecification<ResolvedImageSpecification>;
2387
- "fill-pattern-transition"?: TransitionSpecification;
2388
- } | {
2389
- "line-opacity"?: DataDrivenPropertyValueSpecification<number>;
2390
- "line-opacity-transition"?: TransitionSpecification;
2391
- "line-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
2392
- "line-color-transition"?: TransitionSpecification;
2393
- "line-translate"?: PropertyValueSpecification<[number, number]>;
2394
- "line-translate-transition"?: TransitionSpecification;
2395
- "line-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
2396
- "line-width"?: DataDrivenPropertyValueSpecification<number>;
2397
- "line-width-transition"?: TransitionSpecification;
2398
- "line-gap-width"?: DataDrivenPropertyValueSpecification<number>;
2399
- "line-gap-width-transition"?: TransitionSpecification;
2400
- "line-offset"?: DataDrivenPropertyValueSpecification<number>;
2401
- "line-offset-transition"?: TransitionSpecification;
2402
- "line-blur"?: DataDrivenPropertyValueSpecification<number>;
2403
- "line-blur-transition"?: TransitionSpecification;
2404
- "line-dasharray"?: DataDrivenPropertyValueSpecification<Array<number>>;
2405
- "line-dasharray-transition"?: TransitionSpecification;
2406
- "line-pattern"?: DataDrivenPropertyValueSpecification<ResolvedImageSpecification>;
2407
- "line-pattern-transition"?: TransitionSpecification;
2408
- "line-gradient"?: ExpressionSpecification;
2409
- } | {
2410
- "icon-opacity"?: DataDrivenPropertyValueSpecification<number>;
2411
- "icon-opacity-transition"?: TransitionSpecification;
2412
- "icon-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
2413
- "icon-color-transition"?: TransitionSpecification;
2414
- "icon-halo-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
2415
- "icon-halo-color-transition"?: TransitionSpecification;
2416
- "icon-halo-width"?: DataDrivenPropertyValueSpecification<number>;
2417
- "icon-halo-width-transition"?: TransitionSpecification;
2418
- "icon-halo-blur"?: DataDrivenPropertyValueSpecification<number>;
2419
- "icon-halo-blur-transition"?: TransitionSpecification;
2420
- "icon-translate"?: PropertyValueSpecification<[number, number]>;
2421
- "icon-translate-transition"?: TransitionSpecification;
2422
- "icon-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
2423
- "text-opacity"?: DataDrivenPropertyValueSpecification<number>;
2424
- "text-opacity-transition"?: TransitionSpecification;
2425
- "text-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
2426
- "text-color-transition"?: TransitionSpecification;
2427
- "text-halo-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
2428
- "text-halo-color-transition"?: TransitionSpecification;
2429
- "text-halo-width"?: DataDrivenPropertyValueSpecification<number>;
2430
- "text-halo-width-transition"?: TransitionSpecification;
2431
- "text-halo-blur"?: DataDrivenPropertyValueSpecification<number>;
2432
- "text-halo-blur-transition"?: TransitionSpecification;
2433
- "text-translate"?: PropertyValueSpecification<[number, number]>;
2434
- "text-translate-transition"?: TransitionSpecification;
2435
- "text-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
2436
- } | {
2437
- "circle-radius"?: DataDrivenPropertyValueSpecification<number>;
2438
- "circle-radius-transition"?: TransitionSpecification;
2439
- "circle-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
2440
- "circle-color-transition"?: TransitionSpecification;
2441
- "circle-blur"?: DataDrivenPropertyValueSpecification<number>;
2442
- "circle-blur-transition"?: TransitionSpecification;
2443
- "circle-opacity"?: DataDrivenPropertyValueSpecification<number>;
2444
- "circle-opacity-transition"?: TransitionSpecification;
2445
- "circle-translate"?: PropertyValueSpecification<[number, number]>;
2446
- "circle-translate-transition"?: TransitionSpecification;
2447
- "circle-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
2448
- "circle-pitch-scale"?: PropertyValueSpecification<"map" | "viewport">;
2449
- "circle-pitch-alignment"?: PropertyValueSpecification<"map" | "viewport">;
2450
- "circle-stroke-width"?: DataDrivenPropertyValueSpecification<number>;
2451
- "circle-stroke-width-transition"?: TransitionSpecification;
2452
- "circle-stroke-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
2453
- "circle-stroke-color-transition"?: TransitionSpecification;
2454
- "circle-stroke-opacity"?: DataDrivenPropertyValueSpecification<number>;
2455
- "circle-stroke-opacity-transition"?: TransitionSpecification;
2456
- } | {
2457
- "heatmap-radius"?: DataDrivenPropertyValueSpecification<number>;
2458
- "heatmap-radius-transition"?: TransitionSpecification;
2459
- "heatmap-weight"?: DataDrivenPropertyValueSpecification<number>;
2460
- "heatmap-intensity"?: PropertyValueSpecification<number>;
2461
- "heatmap-intensity-transition"?: TransitionSpecification;
2462
- "heatmap-color"?: ExpressionSpecification;
2463
- "heatmap-opacity"?: PropertyValueSpecification<number>;
2464
- "heatmap-opacity-transition"?: TransitionSpecification;
2465
- } | {
2466
- "fill-extrusion-opacity"?: PropertyValueSpecification<number>;
2467
- "fill-extrusion-opacity-transition"?: TransitionSpecification;
2468
- "fill-extrusion-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
2469
- "fill-extrusion-color-transition"?: TransitionSpecification;
2470
- "fill-extrusion-translate"?: PropertyValueSpecification<[number, number]>;
2471
- "fill-extrusion-translate-transition"?: TransitionSpecification;
2472
- "fill-extrusion-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
2473
- "fill-extrusion-pattern"?: DataDrivenPropertyValueSpecification<ResolvedImageSpecification>;
2474
- "fill-extrusion-pattern-transition"?: TransitionSpecification;
2475
- "fill-extrusion-height"?: DataDrivenPropertyValueSpecification<number>;
2476
- "fill-extrusion-height-transition"?: TransitionSpecification;
2477
- "fill-extrusion-base"?: DataDrivenPropertyValueSpecification<number>;
2478
- "fill-extrusion-base-transition"?: TransitionSpecification;
2479
- "fill-extrusion-vertical-gradient"?: PropertyValueSpecification<boolean>;
2480
- } | {
2481
- "raster-opacity"?: PropertyValueSpecification<number>;
2482
- "raster-opacity-transition"?: TransitionSpecification;
2483
- "raster-hue-rotate"?: PropertyValueSpecification<number>;
2484
- "raster-hue-rotate-transition"?: TransitionSpecification;
2485
- "raster-brightness-min"?: PropertyValueSpecification<number>;
2486
- "raster-brightness-min-transition"?: TransitionSpecification;
2487
- "raster-brightness-max"?: PropertyValueSpecification<number>;
2488
- "raster-brightness-max-transition"?: TransitionSpecification;
2489
- "raster-saturation"?: PropertyValueSpecification<number>;
2490
- "raster-saturation-transition"?: TransitionSpecification;
2491
- "raster-contrast"?: PropertyValueSpecification<number>;
2492
- "raster-contrast-transition"?: TransitionSpecification;
2493
- resampling?: PropertyValueSpecification<"linear" | "nearest">;
2494
- "raster-resampling"?: PropertyValueSpecification<"linear" | "nearest">;
2495
- "raster-fade-duration"?: PropertyValueSpecification<number>;
2496
- } | {
2497
- "hillshade-illumination-direction"?: PropertyValueSpecification<NumberArraySpecification>;
2498
- "hillshade-illumination-altitude"?: PropertyValueSpecification<NumberArraySpecification>;
2499
- "hillshade-illumination-anchor"?: PropertyValueSpecification<"map" | "viewport">;
2500
- "hillshade-exaggeration"?: PropertyValueSpecification<number>;
2501
- "hillshade-exaggeration-transition"?: TransitionSpecification;
2502
- "hillshade-shadow-color"?: PropertyValueSpecification<ColorArraySpecification>;
2503
- "hillshade-shadow-color-transition"?: TransitionSpecification;
2504
- "hillshade-highlight-color"?: PropertyValueSpecification<ColorArraySpecification>;
2505
- "hillshade-highlight-color-transition"?: TransitionSpecification;
2506
- "hillshade-accent-color"?: PropertyValueSpecification<ColorSpecification>;
2507
- "hillshade-accent-color-transition"?: TransitionSpecification;
2508
- "hillshade-method"?: PropertyValueSpecification<"standard" | "basic" | "combined" | "igor" | "multidirectional">;
2509
- resampling?: PropertyValueSpecification<"linear" | "nearest">;
2510
- } | {
2511
- "color-relief-opacity"?: PropertyValueSpecification<number>;
2512
- "color-relief-opacity-transition"?: TransitionSpecification;
2513
- "color-relief-color"?: ExpressionSpecification;
2514
- resampling?: PropertyValueSpecification<"linear" | "nearest">;
2515
- } | {
2516
- "background-color"?: PropertyValueSpecification<ColorSpecification>;
2517
- "background-color-transition"?: TransitionSpecification;
2518
- "background-pattern"?: PropertyValueSpecification<ResolvedImageSpecification>;
2519
- "background-pattern-transition"?: TransitionSpecification;
2520
- "background-opacity"?: PropertyValueSpecification<number>;
2521
- "background-opacity-transition"?: TransitionSpecification;
2522
- } | undefined;
2523
- id: string;
2524
- }[];
2525
- error?: undefined;
2526
- }>;
2527
-
2528
- /**
2529
- * Create the get-poi-category-codes tool.
2530
- */
2531
- /** Standalone execute for ToolEntry format. */
2532
- declare function executeGetPoiCategoryCodes(params: z.infer<typeof getPoiCategoryCodesSchema>, _state: ToolState): Promise<z.infer<typeof getPoiCategoryCodesOutputSchema>>;
2533
-
2534
- /** Execute function for getRouteProgress — usable with ToolEntry format. */
2535
- declare function executeGetRouteProgress(params: z.infer<typeof getRouteProgressSchema>, state: ToolState): Promise<{
2536
- error: string;
2537
- } | {
2538
- longitude: number;
2539
- latitude: number;
2540
- travelTimeInSeconds: number;
2541
- distanceInMeters: number;
2542
- }>;
2543
-
2544
- /** Execute function for getSectionBBox — usable with ToolEntry format. */
2545
- declare function executeGetSectionBBox(params: z.infer<typeof getSectionBBoxSchema>, state: ToolState): Promise<z.infer<typeof getSectionBBoxOutputSchema>>;
2546
-
2547
- /** Execute function for getSectionProgress — usable with ToolEntry format. */
2548
- declare function executeGetSectionProgress(params: z.infer<typeof getSectionProgressSchema>, state: ToolState): Promise<{
2549
- error: string;
2550
- sectionType?: undefined;
2551
- sections?: undefined;
2552
- } | {
2553
- sectionType: "leg" | "traffic" | "carpool" | "carTrain" | "country" | "ferry" | "importantRoadStretch" | "lanes" | "lowEmissionZone" | "motorway" | "pedestrian" | "roadShields" | "speedLimit" | "toll" | "tollVignette" | "tunnel" | "unpaved" | "urban" | "vehicleRestricted";
2554
- sections: object[];
2555
- error?: undefined;
2556
- }>;
2557
-
2558
- /**
2559
- * Execute get shown incidents.
2560
- */
2561
- declare function executeGetShownIncidents(_params: z.infer<typeof getShownIncidentsSchema>, state: ToolState): Promise<z.infer<typeof getShownIncidentsOutputSchema>>;
2562
-
2563
- /**
2564
- * Execute get shown places.
2565
- */
2566
- declare function executeGetShownPlaces(_params: z.infer<typeof getShownPlacesSchema>, state: ToolState): Promise<{
2567
- count: number;
2568
- features: {
2569
- name: string | undefined;
2570
- address: string;
2571
- position: Position;
2572
- }[];
2573
- error?: undefined;
2574
- } | {
2575
- error: string;
2576
- count?: undefined;
2577
- features?: undefined;
2578
- }>;
2579
-
2580
- /**
2581
- * Execute get shown routes.
2582
- */
2583
- declare function executeGetShownRoutes(_params: z.infer<typeof getShownRoutesSchema>, state: ToolState): Promise<z.infer<typeof getShownRoutesOutputSchema>>;
2584
-
2585
- /**
2586
- * Execute get shown route sections.
2587
- */
2588
- declare function executeGetShownRouteSections(params: z.infer<typeof getShownRouteSectionsSchema>, state: ToolState): Promise<z.infer<typeof getShownRouteSectionsOutputSchema>>;
2589
-
2590
- /**
2591
- * Execute get shown route traffic incidents.
2592
- */
2593
- declare function executeGetShownRouteTrafficIncidents(_params: z.infer<typeof getShownRouteTrafficIncidentsSchema>, state: ToolState): Promise<z.infer<typeof getShownRouteTrafficIncidentsOutputSchema>>;
2594
-
2595
- /**
2596
- * Execute get shown waypoints.
2597
- */
2598
- declare function executeGetShownWaypoints(_params: z.infer<typeof getShownWaypointsSchema>, state: ToolState): Promise<z.infer<typeof getShownWaypointsOutputSchema>>;
2599
-
2600
- /**
2601
- * Execute get standard map styles.
2602
- */
2603
- declare function executeGetStandardMapStyles(_params: z.infer<typeof getStandardMapStylesSchema>, _state: ToolState): Promise<z.infer<typeof getStandardMapStylesOutputSchema>>;
2604
-
2605
- /**
2606
- * Create the get traffic area analytics tool.
2607
- */
2608
- /** Standalone execute for ToolEntry format. */
2609
- declare function executeGetTrafficAreaAnalytics(params: z.infer<typeof getTrafficAreaAnalyticsSchema>, state: ToolState): Promise<z.infer<typeof getTrafficAreaAnalyticsOutputSchema>>;
2610
-
2611
- /**
2612
- * Create the get traffic incidents tool.
2613
- */
2614
- /** Standalone execute for ToolEntry format. */
2615
- declare function executeGetTrafficIncidents(params: z.infer<typeof getTrafficIncidentsSchema>, _state: ToolState): Promise<z.infer<typeof getTrafficIncidentsOutputSchema>>;
2616
-
2617
- /** Execute function for getViewport — usable with ToolEntry format. */
2618
- declare function executeGetViewport(_params: z.infer<typeof getViewportSchema>, state: ToolState): Promise<{
2619
- center: [number, number];
2620
- zoom: number;
2621
- bbox: BBox;
2622
- pitch: number;
2623
- bearing: number;
2624
- error?: undefined;
2625
- } | {
2626
- error: string;
2627
- center?: undefined;
2628
- zoom?: undefined;
2629
- bbox?: undefined;
2630
- pitch?: undefined;
2631
- bearing?: undefined;
2632
- }>;
2633
-
2634
- /** Standalone execute for ToolEntry format. */
2635
- declare function executeLocatePlace(params: z.infer<typeof locatePlaceSchema>, state: ToolState): Promise<z.infer<typeof locatePlaceOutputSchema>>;
2636
-
2637
- /** Input schema for the executeMaplibreCode tool. */
2638
- declare const executeMaplibreCodeSchema: z.ZodObject<{
2639
- code: z.ZodString;
2640
- }, z.core.$strip>;
2641
-
2642
- /**
2643
- * Create the query traffic analytics tool.
2644
- */
2645
- /** Standalone execute for ToolEntry format. */
2646
- declare function executeQueryTrafficAnalytics(params: z.infer<typeof queryTrafficAnalyticsSchema>, state: ToolState): Promise<z.infer<typeof queryTrafficAnalyticsOutputSchema>>;
2647
-
2648
- declare function executeRecallPlaces(params: z.infer<typeof recallPlacesSchema>, state: ToolState): Promise<z.infer<typeof recallPlacesOutputSchema>>;
2649
-
2650
- declare function executeRecallRanges(params: z.infer<typeof recallRangesSchema>, state: ToolState): Promise<z.infer<typeof recallRangesOutputSchema>>;
2651
-
2652
- declare function executeRecallRoutes(params: z.infer<typeof recallRoutesSchema>, state: ToolState): Promise<z.infer<typeof recallRoutesOutputSchema>>;
2653
-
2654
- /**
2655
- * Create the remove stop from route tool.
2656
- */
2657
- /** Standalone execute for ToolEntry format. */
2658
- declare function executeRemoveStopFromRoute(params: z.infer<typeof removeStopFromRouteSchema>, state: ToolState): Promise<z.infer<typeof removeStopFromRouteOutputSchema>>;
2659
-
2660
- /**
2661
- * Create the reverse geocode tool.
2662
- */
2663
- /** Standalone execute for ToolEntry format. */
2664
- declare function executeReverseGeocode(params: z.infer<typeof reverseGeocodeSchema>, state: ToolState): Promise<z.infer<typeof reverseGeocodeOutputSchema>>;
2665
-
2666
- /** Standalone execute for ToolEntry format. */
2667
- declare function executeSearchAlongRoute(params: z.infer<typeof searchAlongRouteSchema>, state: ToolState): Promise<z.infer<typeof searchAlongRouteOutputSchema>>;
2668
-
2669
- /**
2670
- * Execute set language.
2671
- */
2672
- declare function executeSetLanguage(params: z.infer<typeof setLanguageSchema>, state: ToolState): Promise<{
2673
- success: boolean;
2674
- language: string;
2675
- error?: undefined;
2676
- } | {
2677
- error: string;
2678
- success?: undefined;
2679
- language?: undefined;
2680
- }>;
2681
-
2682
- /** Execute function for setLayoutProperties — usable with ToolEntry format. */
2683
- declare function executeSetLayoutProperties(params: z.infer<typeof setLayoutPropertiesSchema>, state: ToolState): Promise<{
2684
- results: ({
2685
- layerId: string;
2686
- propertyName: string;
2687
- value: any;
2688
- success: true;
2689
- error?: undefined;
2690
- } | {
2691
- layerId: string;
2692
- propertyName: string;
2693
- error: string;
2694
- value?: undefined;
2695
- success?: undefined;
2696
- })[];
2697
- error?: undefined;
2698
- } | {
2699
- error: string;
2700
- results?: undefined;
2701
- }>;
2702
-
2703
- /**
2704
- * Execute set map standard style.
2705
- */
2706
- declare function executeSetMapStandardStyle(params: z.infer<typeof setMapStandardStyleSchema>, state: ToolState): Promise<{
2707
- success: boolean;
2708
- style: "standardLight" | "standardDark" | "drivingLight" | "drivingDark" | "monoLight" | "monoDark" | "satellite";
2709
- error?: undefined;
2710
- } | {
2711
- error: string;
2712
- success?: undefined;
2713
- style?: undefined;
2714
- }>;
2715
-
2716
- /** Execute function for setPaintProperties — usable with ToolEntry format. */
2717
- declare function executeSetPaintProperties(params: z.infer<typeof setPaintPropertiesSchema>, state: ToolState): Promise<{
2718
- results: ({
2719
- layerId: string;
2720
- propertyName: string;
2721
- value: any;
2722
- success: true;
2723
- error?: undefined;
2724
- } | {
2725
- layerId: string;
2726
- propertyName: string;
2727
- error: string;
2728
- value?: undefined;
2729
- success?: undefined;
2730
- })[];
2731
- error?: undefined;
2732
- } | {
2733
- error: string;
2734
- results?: undefined;
2735
- }>;
2736
-
2737
- /** Execute function for setPitchBearing — usable with ToolEntry format. */
2738
- declare function executeSetPitchBearing(params: z.infer<typeof setPitchBearingSchema>, state: ToolState): Promise<{
2739
- error: string;
2740
- success?: undefined;
2741
- } | {
2742
- success: boolean;
2743
- error?: undefined;
2744
- }>;
2745
-
2746
- /**
2747
- * Create the set-route-locations tool.
2748
- */
2749
- /** Standalone execute for ToolEntry format. */
2750
- declare function executeSetRouteLocations(params: z.infer<typeof setRouteLocationsSchema>, state: ToolState): Promise<z.infer<typeof setRouteLocationsOutputSchema>>;
2751
-
2752
- /**
2753
- * Create the set-route-parameters tool.
2754
- */
2755
- /** Standalone execute for ToolEntry format. */
2756
- declare function executeSetRouteParameters(params: z.infer<typeof setRouteParametersSchema>, state: ToolState): Promise<z.infer<typeof setRouteParametersOutputSchema>>;
2757
-
2758
- /**
2759
- * Execute set route theme.
2760
- */
2761
- declare function executeSetRouteTheme(params: z.infer<typeof setRouteThemeSchema>, state: ToolState): Promise<{
2762
- success: true;
2763
- theme: {
2764
- mainColor?: string;
2765
- };
2766
- error?: undefined;
2767
- } | {
2768
- error: string;
2769
- success?: undefined;
2770
- theme?: undefined;
2771
- }>;
2772
-
2773
- /**
2774
- * Execute show places.
2775
- */
2776
- declare function executeShowPlaces(params: z.infer<typeof showPlacesSchema>, state: ToolState): Promise<{
2777
- error: string;
2778
- success?: undefined;
2779
- count?: undefined;
2780
- } | {
2781
- success: boolean;
2782
- count: number;
2783
- error?: undefined;
2784
- }>;
2785
-
2786
- /**
2787
- * Execute show routes.
2788
- */
2789
- declare function executeShowRoutes(params: z.infer<typeof showRouteSchema>, state: ToolState): Promise<{
2790
- error: string;
2791
- success?: undefined;
2792
- displayedRoute?: undefined;
2793
- routeCount?: undefined;
2794
- } | {
2795
- success: boolean;
2796
- displayedRoute: number;
2797
- routeCount: number;
2798
- error?: undefined;
2799
- }>;
2800
-
2801
- /**
2802
- * Execute show traffic area analytics.
2803
- */
2804
- declare function executeShowTrafficAreaAnalytics(params: z.infer<typeof showTrafficAreaAnalyticsSchema>, state: ToolState): Promise<z.infer<typeof showTrafficAreaAnalyticsOutputSchema>>;
2805
-
2806
- /**
2807
- * Execute show waypoints.
2808
- */
2809
- declare function executeShowWaypoints(_params: z.infer<typeof showWaypointsSchema>, state: ToolState): Promise<z.infer<typeof showWaypointsOutputSchema>>;
2810
-
2811
- /**
2812
- * Execute toggle base map layer groups.
2813
- */
2814
- declare function executeToggleBaseMapLayerGroups(params: z.infer<typeof toggleBaseMapLayerGroupsSchema>, state: ToolState): Promise<{
2815
- success: boolean;
2816
- visible: boolean;
2817
- layerGroups: ("roadShields" | "land" | "water" | "borders" | "buildings2D" | "buildings3D" | "houseNumbers" | "roadLines" | "roadLabels" | "placeLabels" | "smallerTownLabels" | "cityLabels" | "capitalLabels" | "stateLabels" | "countryLabels")[];
2818
- error?: undefined;
2819
- } | {
2820
- error: string;
2821
- success?: undefined;
2822
- visible?: undefined;
2823
- layerGroups?: undefined;
2824
- }>;
2825
-
2826
- /**
2827
- * Execute toggle POIs.
2828
- */
2829
- declare function executeTogglePOIs(params: z.infer<typeof togglePOIsSchema>, state: ToolState): Promise<z.infer<typeof togglePOIsOutputSchema>>;
2830
-
2831
- /**
2832
- * Execute toggle traffic flow.
2833
- */
2834
- declare function executeToggleTrafficFlow(params: z.infer<typeof toggleTrafficFlowSchema>, state: ToolState): Promise<{
2835
- success: boolean;
2836
- trafficFlowVisible: boolean;
2837
- error?: undefined;
2838
- } | {
2839
- error: string;
2840
- success?: undefined;
2841
- trafficFlowVisible?: undefined;
2842
- }>;
2843
-
2844
- /**
2845
- * Execute toggle traffic incidents.
2846
- */
2847
- declare function executeToggleTrafficIncidents(params: z.infer<typeof toggleTrafficIncidentsSchema>, state: ToolState): Promise<{
2848
- success: boolean;
2849
- trafficIncidentsVisible: boolean;
2850
- error?: undefined;
2851
- } | {
2852
- error: string;
2853
- success?: undefined;
2854
- trafficIncidentsVisible?: undefined;
2855
- }>;
2856
-
2857
- /** Execute function for zoomInOrOut — usable with ToolEntry format. */
2858
- declare function executeZoomInOrOut(params: z.infer<typeof zoomInOrOutSchema>, state: ToolState): Promise<{
2859
- zoom: number;
2860
- error?: undefined;
2861
- } | {
2862
- error: string;
2863
- zoom?: undefined;
2864
- }>;
2865
-
2866
286
  /**
2867
287
  * Extracts the text content of the last user message in a message array.
2868
288
  * Returns null if no user message is found or if content has no text.
289
+ *
290
+ * @group Agent Toolkit
2869
291
  */
2870
- export declare function extractLastUserText(messages: ReadonlyArray<ModelMessage>): string | null;
2871
-
2872
- declare const findReachableAreaOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
2873
- rangeId: z.ZodString;
2874
- originName: z.ZodString;
2875
- budgets: z.ZodArray<z.ZodObject<{
2876
- type: z.ZodEnum<{
2877
- timeMinutes: "timeMinutes";
2878
- distanceKM: "distanceKM";
2879
- }>;
2880
- value: z.ZodNumber;
2881
- }, z.core.$strip>>;
2882
- }, z.core.$strip>, z.ZodObject<{
2883
- status: z.ZodEnum<{
2884
- not_found: "not_found";
2885
- no_results: "no_results";
2886
- }>;
2887
- }, z.core.$strip>, z.ZodObject<{
2888
- error: z.ZodString;
2889
- }, z.core.$strip>]>;
2890
-
2891
- declare const findReachableAreaSchema: z.ZodObject<{
2892
- origin: z.ZodUnion<readonly [z.ZodObject<{
2893
- query: z.ZodString;
2894
- locationType: z.ZodEnum<{
2895
- default: "default";
2896
- poi: "poi";
2897
- }>;
2898
- }, z.core.$strip>, z.ZodObject<{
2899
- position: z.ZodObject<{
2900
- lng: z.ZodNumber;
2901
- lat: z.ZodNumber;
2902
- }, z.core.$strip>;
2903
- }, z.core.$strip>]>;
2904
- budgets: z.ZodArray<z.ZodObject<{
2905
- type: z.ZodEnum<{
2906
- timeMinutes: "timeMinutes";
2907
- distanceKM: "distanceKM";
2908
- }>;
2909
- value: z.ZodNumber;
2910
- }, z.core.$strip>>;
2911
- theme: z.ZodOptional<z.ZodEnum<{
2912
- filled: "filled";
2913
- outline: "outline";
2914
- inverted: "inverted";
2915
- }>>;
2916
- showOnMap: z.ZodBoolean;
2917
- showOriginPin: z.ZodOptional<z.ZodBoolean>;
2918
- }, z.core.$strip>;
2919
-
2920
- /**
2921
- * Tool schema for fitting route section bounds.
2922
- */
2923
- declare const fitRouteSectionSchema: z.ZodObject<{
2924
- sectionType: z.ZodEnum<{
2925
- leg: "leg";
2926
- traffic: "traffic";
2927
- carpool: "carpool";
2928
- carTrain: "carTrain";
2929
- country: "country";
2930
- ferry: "ferry";
2931
- importantRoadStretch: "importantRoadStretch";
2932
- lanes: "lanes";
2933
- lowEmissionZone: "lowEmissionZone";
2934
- motorway: "motorway";
2935
- pedestrian: "pedestrian";
2936
- roadShields: "roadShields";
2937
- speedLimit: "speedLimit";
2938
- toll: "toll";
2939
- tollVignette: "tollVignette";
2940
- tunnel: "tunnel";
2941
- unpaved: "unpaved";
2942
- urban: "urban";
2943
- vehicleRestricted: "vehicleRestricted";
2944
- }>;
2945
- id: z.ZodString;
2946
- padding: z.ZodOptional<z.ZodNumber>;
2947
- }, z.core.$strip>;
2948
-
2949
- /** Input schema for fly-to. */
2950
- declare const flyToSchema: z.ZodObject<{
2951
- where: z.ZodUnion<readonly [z.ZodObject<{
2952
- boundingBox: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodNumber>]>, z.ZodObject<{
2953
- bbox: z.ZodUnion<readonly [z.ZodArray<z.ZodNumber>]>;
2954
- }, z.core.$strip>]>;
2955
- padding: z.ZodOptional<z.ZodNumber>;
2956
- }, z.core.$strip>, z.ZodObject<{
2957
- position: z.ZodArray<z.ZodNumber>;
2958
- zoom: z.ZodOptional<z.ZodNumber>;
2959
- }, z.core.$strip>]>;
2960
- }, z.core.$strip>;
2961
-
2962
- /**
2963
- * Tool schema for formatting distance.
2964
- */
2965
- declare const formatDistanceSchema: z.ZodObject<{
2966
- meters: z.ZodNumber;
2967
- unitType: z.ZodOptional<z.ZodEnum<{
2968
- metric: "metric";
2969
- imperial_us: "imperial_us";
2970
- imperial_uk: "imperial_uk";
2971
- }>>;
2972
- }, z.core.$strip>;
2973
-
2974
- /**
2975
- * Tool schema for formatting duration.
2976
- */
2977
- declare const formatDurationSchema: z.ZodObject<{
2978
- seconds: z.ZodNumber;
2979
- }, z.core.$strip>;
2980
-
2981
- /**
2982
- * Output schema for current location tool.
2983
- */
2984
- declare const getCurrentLocationOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
2985
- position: z.ZodArray<z.ZodNumber>;
2986
- accuracy: z.ZodNumber;
2987
- timestamp: z.ZodNumber;
2988
- }, z.core.$strip>, z.ZodObject<{
2989
- error: z.ZodString;
2990
- }, z.core.$strip>]>;
2991
-
2992
- /**
2993
- * Tool schema for retrieving browser current location.
2994
- */
2995
- declare const getCurrentLocationSchema: z.ZodObject<{}, z.core.$strip>;
2996
-
2997
- declare const getCurrentWaypointsOutputSchema: z.ZodObject<{
2998
- totalSlots: z.ZodNumber;
2999
- filledSlots: z.ZodNumber;
3000
- matchedCount: z.ZodNumber;
3001
- returnedCount: z.ZodNumber;
3002
- offset: z.ZodNumber;
3003
- hasMore: z.ZodBoolean;
3004
- nextOffset: z.ZodOptional<z.ZodNumber>;
3005
- waypoints: z.ZodArray<z.ZodObject<{
3006
- slotIndex: z.ZodNumber;
3007
- isFilled: z.ZodBoolean;
3008
- address: z.ZodOptional<z.ZodString>;
3009
- position: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
3010
- }, z.core.$strip>>;
3011
- }, z.core.$strip>;
3012
-
3013
- declare const getCurrentWaypointsSchema: z.ZodObject<{
3014
- slotIndex: z.ZodOptional<z.ZodNumber>;
3015
- includeEmptySlots: z.ZodOptional<z.ZodBoolean>;
3016
- offset: z.ZodOptional<z.ZodNumber>;
3017
- limit: z.ZodOptional<z.ZodNumber>;
3018
- }, z.core.$strip>;
3019
-
3020
- /**
3021
- * Tool schema for getting map style layers.
3022
- */
3023
- declare const getMapStyleLayersSchema: z.ZodObject<{
3024
- layerIdQuery: z.ZodOptional<z.ZodString>;
3025
- include: z.ZodArray<z.ZodEnum<{
3026
- layout: "layout";
3027
- paint: "paint";
3028
- }>>;
3029
- }, z.core.$strip>;
3030
-
3031
- /** Output schema for the get-poi-category-codes tool. */
3032
- declare const getPoiCategoryCodesOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3033
- count: z.ZodNumber;
3034
- codes: z.ZodArray<z.ZodString>;
3035
- }, z.core.$strip>, z.ZodObject<{
3036
- error: z.ZodString;
3037
- }, z.core.$strip>]>;
3038
-
3039
- /**
3040
- * Tool input schema for fetching POI category codes.
3041
- */
3042
- declare const getPoiCategoryCodesSchema: z.ZodObject<{
3043
- filters: z.ZodOptional<z.ZodArray<z.ZodString>>;
3044
- language: z.ZodString;
3045
- }, z.core.$strip>;
3046
-
3047
- /**
3048
- * Tool schema for getting a coordinate position along a route.
3049
- * The three progress inputs are mutually exclusive — provide exactly one.
3050
- */
3051
- declare const getRouteProgressSchema: z.ZodObject<{
3052
- routeIndex: z.ZodOptional<z.ZodNumber>;
3053
- traveledTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3054
- traveledDistanceInMeters: z.ZodOptional<z.ZodNumber>;
3055
- clockTime: z.ZodOptional<z.ZodString>;
3056
- }, z.core.$strip>;
3057
-
3058
- /** Output schema for the get-section-bbox tool. */
3059
- declare const getSectionBBoxOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3060
- bbox: z.ZodArray<z.ZodNumber>;
3061
- }, z.core.$strip>, z.ZodObject<{
3062
- error: z.ZodString;
3063
- }, z.core.$strip>]>;
3064
-
3065
- /** Input schema for the get-section-bbox tool. */
3066
- declare const getSectionBBoxSchema: z.ZodObject<{
3067
- sectionType: z.ZodEnum<{
3068
- leg: "leg";
3069
- traffic: "traffic";
3070
- carpool: "carpool";
3071
- carTrain: "carTrain";
3072
- country: "country";
3073
- ferry: "ferry";
3074
- importantRoadStretch: "importantRoadStretch";
3075
- lanes: "lanes";
3076
- lowEmissionZone: "lowEmissionZone";
3077
- motorway: "motorway";
3078
- pedestrian: "pedestrian";
3079
- roadShields: "roadShields";
3080
- speedLimit: "speedLimit";
3081
- toll: "toll";
3082
- tollVignette: "tollVignette";
3083
- tunnel: "tunnel";
3084
- unpaved: "unpaved";
3085
- urban: "urban";
3086
- vehicleRestricted: "vehicleRestricted";
3087
- }>;
3088
- id: z.ZodString;
3089
- }, z.core.$strip>;
3090
-
3091
- /**
3092
- * Tool schema for getting section progress.
3093
- */
3094
- declare const getSectionProgressSchema: z.ZodObject<{
3095
- sectionType: z.ZodEnum<{
3096
- leg: "leg";
3097
- traffic: "traffic";
3098
- carpool: "carpool";
3099
- carTrain: "carTrain";
3100
- country: "country";
3101
- ferry: "ferry";
3102
- importantRoadStretch: "importantRoadStretch";
3103
- lanes: "lanes";
3104
- lowEmissionZone: "lowEmissionZone";
3105
- motorway: "motorway";
3106
- pedestrian: "pedestrian";
3107
- roadShields: "roadShields";
3108
- speedLimit: "speedLimit";
3109
- toll: "toll";
3110
- tollVignette: "tollVignette";
3111
- tunnel: "tunnel";
3112
- unpaved: "unpaved";
3113
- urban: "urban";
3114
- vehicleRestricted: "vehicleRestricted";
3115
- }>;
3116
- ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
3117
- }, z.core.$strip>;
3118
-
3119
- /** Output schema for the get-shown-incidents tool. */
3120
- declare const getShownIncidentsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3121
- count: z.ZodNumber;
3122
- trafficIncidents: z.ZodArray<z.ZodObject<{
3123
- id: z.ZodString;
3124
- category: z.ZodString;
3125
- magnitudeOfDelay: z.ZodString;
3126
- description: z.ZodOptional<z.ZodString>;
3127
- delayInSeconds: z.ZodOptional<z.ZodNumber>;
3128
- roadCategory: z.ZodOptional<z.ZodString>;
3129
- averageSpeedKmph: z.ZodOptional<z.ZodNumber>;
3130
- }, z.core.$strip>>;
3131
- }, z.core.$strip>, z.ZodObject<{
3132
- error: z.ZodString;
3133
- }, z.core.$strip>]>;
3134
-
3135
- /**
3136
- * Tool schema for getting shown traffic incidents on map.
3137
- */
3138
- declare const getShownIncidentsSchema: z.ZodObject<{}, z.core.$strip>;
3139
-
3140
- /**
3141
- * Tool schema for getting shown places on map.
3142
- */
3143
- declare const getShownPlacesSchema: z.ZodObject<{}, z.core.$strip>;
3144
-
3145
- /** Output schema for the get-shown-route-sections tool. */
3146
- declare const getShownRouteSectionsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3147
- sectionType: z.ZodString;
3148
- routes: z.ZodArray<z.ZodObject<{
3149
- routeIndex: z.ZodNumber;
3150
- sections: z.ZodArray<z.ZodUnknown>;
3151
- }, z.core.$strip>>;
3152
- }, z.core.$strip>, z.ZodObject<{
3153
- error: z.ZodString;
3154
- }, z.core.$strip>]>;
3155
-
3156
- /** Input schema for the get-shown-route-sections tool. */
3157
- declare const getShownRouteSectionsSchema: z.ZodObject<{
3158
- sectionType: z.ZodEnum<{
3159
- leg: "leg";
3160
- traffic: "traffic";
3161
- carpool: "carpool";
3162
- carTrain: "carTrain";
3163
- country: "country";
3164
- ferry: "ferry";
3165
- importantRoadStretch: "importantRoadStretch";
3166
- lanes: "lanes";
3167
- lowEmissionZone: "lowEmissionZone";
3168
- motorway: "motorway";
3169
- pedestrian: "pedestrian";
3170
- roadShields: "roadShields";
3171
- speedLimit: "speedLimit";
3172
- toll: "toll";
3173
- tollVignette: "tollVignette";
3174
- tunnel: "tunnel";
3175
- unpaved: "unpaved";
3176
- urban: "urban";
3177
- vehicleRestricted: "vehicleRestricted";
3178
- }>;
3179
- }, z.core.$strip>;
3180
-
3181
- /** Output schema for the get-shown-routes tool. */
3182
- declare const getShownRoutesOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3183
- count: z.ZodNumber;
3184
- routes: z.ZodArray<z.ZodObject<{
3185
- index: z.ZodNumber;
3186
- summary: z.ZodObject<{
3187
- travelTimeInSeconds: z.ZodNumber;
3188
- lengthInMeters: z.ZodNumber;
3189
- trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
3190
- trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
3191
- departureTime: z.ZodOptional<z.ZodString>;
3192
- arrivalTime: z.ZodOptional<z.ZodString>;
3193
- noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3194
- historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3195
- liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3196
- }, z.core.$strip>;
3197
- legSummaries: z.ZodOptional<z.ZodArray<z.ZodObject<{
3198
- travelTimeInSeconds: z.ZodNumber;
3199
- lengthInMeters: z.ZodNumber;
3200
- trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
3201
- trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
3202
- departureTime: z.ZodOptional<z.ZodString>;
3203
- arrivalTime: z.ZodOptional<z.ZodString>;
3204
- noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3205
- historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3206
- liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3207
- }, z.core.$strip>>>;
3208
- }, z.core.$strip>>;
3209
- }, z.core.$strip>, z.ZodObject<{
3210
- error: z.ZodString;
3211
- }, z.core.$strip>]>;
3212
-
3213
- /**
3214
- * Tool schema for getting shown routes on map.
3215
- */
3216
- declare const getShownRoutesSchema: z.ZodObject<{}, z.core.$strip>;
3217
-
3218
- /** Output schema for the get-shown-route-traffic-incidents tool. */
3219
- declare const getShownRouteTrafficIncidentsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3220
- count: z.ZodNumber;
3221
- trafficIncidents: z.ZodArray<z.ZodObject<{
3222
- id: z.ZodString;
3223
- magnitudeOfDelay: z.ZodString;
3224
- title: z.ZodOptional<z.ZodString>;
3225
- delayInSeconds: z.ZodOptional<z.ZodNumber>;
3226
- effectiveSpeedInKmh: z.ZodOptional<z.ZodNumber>;
3227
- categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
3228
- }, z.core.$strip>>;
3229
- }, z.core.$strip>, z.ZodObject<{
3230
- error: z.ZodString;
3231
- }, z.core.$strip>]>;
3232
-
3233
- /**
3234
- * Tool schema for getting shown route traffic incidents on map.
3235
- */
3236
- declare const getShownRouteTrafficIncidentsSchema: z.ZodObject<{}, z.core.$strip>;
3237
-
3238
- /** Output schema for the get-shown-waypoints tool. */
3239
- declare const getShownWaypointsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3240
- count: z.ZodNumber;
3241
- waypoints: z.ZodArray<z.ZodObject<{
3242
- name: z.ZodOptional<z.ZodUnknown>;
3243
- position: z.ZodArray<z.ZodNumber>;
3244
- }, z.core.$strip>>;
3245
- }, z.core.$strip>, z.ZodObject<{
3246
- error: z.ZodString;
3247
- }, z.core.$strip>]>;
3248
-
3249
- /**
3250
- * Tool schema for getting shown waypoints on map.
3251
- */
3252
- declare const getShownWaypointsSchema: z.ZodObject<{}, z.core.$strip>;
3253
-
3254
- /** Output schema for the get-standard-map-styles tool. */
3255
- declare const getStandardMapStylesOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3256
- styles: z.ZodReadonly<z.ZodArray<z.ZodString>>;
3257
- }, z.core.$strip>, z.ZodObject<{
3258
- error: z.ZodString;
3259
- }, z.core.$strip>]>;
3260
-
3261
- /**
3262
- * Tool schema for getting standard map styles.
3263
- */
3264
- declare const getStandardMapStylesSchema: z.ZodObject<{}, z.core.$strip>;
3265
-
3266
- /** Output schema for the get-traffic-area-analytics tool. */
3267
- declare const getTrafficAreaAnalyticsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3268
- name: z.ZodOptional<z.ZodString>;
3269
- timezone: z.ZodOptional<z.ZodString>;
3270
- dateRange: z.ZodObject<{
3271
- start: z.ZodString;
3272
- end: z.ZodString;
3273
- }, z.core.$strip>;
3274
- baseData: z.ZodObject<{
3275
- speed: z.ZodOptional<z.ZodNumber>;
3276
- freeFlowSpeed: z.ZodOptional<z.ZodNumber>;
3277
- congestionLevel: z.ZodOptional<z.ZodNumber>;
3278
- travelTime: z.ZodOptional<z.ZodNumber>;
3279
- networkLength: z.ZodOptional<z.ZodNumber>;
3280
- }, z.core.$strip>;
3281
- metrics: z.ZodArray<z.ZodString>;
3282
- tileCount: z.ZodNumber;
3283
- availableGranularities: z.ZodArray<z.ZodString>;
3284
- }, z.core.$strip>, z.ZodObject<{
3285
- error: z.ZodString;
3286
- }, z.core.$strip>]>;
3287
-
3288
- /**
3289
- * Tool schema for fetching traffic area analytics.
3290
- */
3291
- declare const getTrafficAreaAnalyticsSchema: z.ZodObject<{
3292
- location: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
3293
- query: z.ZodString;
3294
- locationType: z.ZodEnum<{
3295
- default: "default";
3296
- poi: "poi";
3297
- }>;
3298
- }, z.core.$strip>, z.ZodObject<{
3299
- position: z.ZodObject<{
3300
- lng: z.ZodNumber;
3301
- lat: z.ZodNumber;
3302
- }, z.core.$strip>;
3303
- }, z.core.$strip>]>>;
3304
- bbox: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
3305
- showOnMap: z.ZodOptional<z.ZodBoolean>;
3306
- startDate: z.ZodOptional<z.ZodString>;
3307
- endDate: z.ZodOptional<z.ZodString>;
3308
- days: z.ZodOptional<z.ZodArray<z.ZodString>>;
3309
- metrics: z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodEnum<{
3310
- speed: "speed";
3311
- congestionLevel: "congestionLevel";
3312
- freeFlowSpeed: "freeFlowSpeed";
3313
- travelTime: "travelTime";
3314
- networkLength: "networkLength";
3315
- }>>]>;
3316
- functionalRoadClasses: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodEnum<{
3317
- MOTORWAY: "MOTORWAY";
3318
- MAJOR_ROAD: "MAJOR_ROAD";
3319
- OTHER_MAJOR_ROAD: "OTHER_MAJOR_ROAD";
3320
- SECONDARY_ROAD: "SECONDARY_ROAD";
3321
- LOCAL_CONNECTING_ROAD: "LOCAL_CONNECTING_ROAD";
3322
- LOCAL_ROAD_HIGH_IMPORTANCE: "LOCAL_ROAD_HIGH_IMPORTANCE";
3323
- LOCAL_ROAD: "LOCAL_ROAD";
3324
- LOCAL_ROAD_MINOR_IMPORTANCE: "LOCAL_ROAD_MINOR_IMPORTANCE";
3325
- OTHER_ROAD: "OTHER_ROAD";
3326
- }>>]>>;
3327
- hours: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodNumber>]>>;
3328
- }, z.core.$strip>;
3329
-
3330
- /** Output schema for the get-traffic-incidents tool. */
3331
- declare const getTrafficIncidentsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3332
- count: z.ZodNumber;
3333
- incidents: z.ZodArray<z.ZodObject<{
3334
- id: z.ZodString;
3335
- category: z.ZodString;
3336
- magnitudeOfDelay: z.ZodString;
3337
- timeValidity: z.ZodString;
3338
- events: z.ZodArray<z.ZodObject<{
3339
- description: z.ZodString;
3340
- category: z.ZodString;
3341
- }, z.core.$strip>>;
3342
- from: z.ZodOptional<z.ZodString>;
3343
- to: z.ZodOptional<z.ZodString>;
3344
- roadNumbers: z.ZodOptional<z.ZodArray<z.ZodString>>;
3345
- lengthInMeters: z.ZodOptional<z.ZodNumber>;
3346
- delayInSeconds: z.ZodOptional<z.ZodNumber>;
3347
- startTime: z.ZodOptional<z.ZodDate>;
3348
- endTime: z.ZodOptional<z.ZodDate>;
3349
- }, z.core.$strip>>;
3350
- }, z.core.$strip>, z.ZodObject<{
3351
- error: z.ZodString;
3352
- }, z.core.$strip>]>;
3353
-
3354
- /**
3355
- * Tool schema for fetching traffic incident details.
3356
- */
3357
- declare const getTrafficIncidentsSchema: z.ZodObject<{
3358
- bbox: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
3359
- ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
3360
- categoryFilter: z.ZodOptional<z.ZodArray<z.ZodEnum<{
3361
- accident: "accident";
3362
- "animals-on-road": "animals-on-road";
3363
- "broken-down-vehicle": "broken-down-vehicle";
3364
- danger: "danger";
3365
- flooding: "flooding";
3366
- fog: "fog";
3367
- frost: "frost";
3368
- jam: "jam";
3369
- "lane-closed": "lane-closed";
3370
- "narrow-lanes": "narrow-lanes";
3371
- other: "other";
3372
- rain: "rain";
3373
- "road-closed": "road-closed";
3374
- roadworks: "roadworks";
3375
- wind: "wind";
3376
- }>>>;
3377
- timeValidityFilter: z.ZodOptional<z.ZodArray<z.ZodEnum<{
3378
- present: "present";
3379
- future: "future";
3380
- }>>>;
3381
- }, z.core.$strip>;
3382
-
3383
- /**
3384
- * Tool schema for getting viewport.
3385
- */
3386
- declare const getViewportSchema: z.ZodObject<{}, z.core.$strip>;
3387
-
3388
- declare const locatePlaceOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3389
- name: z.ZodOptional<z.ZodString>;
3390
- address: z.ZodOptional<z.ZodString>;
3391
- position: z.ZodArray<z.ZodNumber>;
3392
- waypointIndex: z.ZodOptional<z.ZodNumber>;
3393
- shown: z.ZodOptional<z.ZodObject<{
3394
- markerType: z.ZodBoolean;
3395
- zoomMode: z.ZodBoolean;
3396
- }, z.core.$strip>>;
3397
- }, z.core.$strip>, z.ZodObject<{
3398
- error: z.ZodString;
3399
- }, z.core.$strip>]>;
3400
-
3401
- declare const locatePlaceSchema: z.ZodObject<{
3402
- query: z.ZodString;
3403
- waypointIndex: z.ZodOptional<z.ZodNumber>;
3404
- locationType: z.ZodEnum<{
3405
- default: "default";
3406
- poi: "poi";
3407
- }>;
3408
- where: z.ZodUnion<readonly [z.ZodObject<{
3409
- position: z.ZodArray<z.ZodNumber>;
3410
- }, z.core.$strip>, z.ZodObject<{
3411
- boundingBox: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodArray<z.ZodNumber>]>, z.ZodObject<{
3412
- bbox: z.ZodUnion<readonly [z.ZodArray<z.ZodNumber>]>;
3413
- }, z.core.$strip>]>;
3414
- }, z.core.$strip>, z.ZodLiteral<"within-map-bounds">, z.ZodLiteral<"nearby-map-center">, z.ZodLiteral<"global">, z.ZodString]>;
3415
- show: z.ZodOptional<z.ZodObject<{
3416
- markerType: z.ZodEnum<{
3417
- pin: "pin";
3418
- none: "none";
3419
- }>;
3420
- zoomMode: z.ZodEnum<{
3421
- none: "none";
3422
- auto: "auto";
3423
- }>;
3424
- }, z.core.$strip>>;
3425
- }, z.core.$strip>;
292
+ export declare const extractLastUserText: (messages: ReadonlyArray<ModelMessage>) => string | null;
3426
293
 
3427
294
  /**
3428
295
  * The return type of createMapAgent().
3429
296
  * A real ToolLoopAgent instance with state access and cleanup.
297
+ *
298
+ * @group Agent Toolkit
3430
299
  */
3431
300
  export declare type MapAgentInstance<CS extends ToolState = ToolState> = ToolLoopAgent & {
3432
301
  /** Live agent state (built-in + custom slices). */
@@ -3440,6 +309,8 @@ export declare type MapAgentInstance<CS extends ToolState = ToolState> = ToolLoo
3440
309
  *
3441
310
  * @typeParam CS - Full state type. Must extend `ToolState`. Defaults to base `ToolState` (no custom slices).
3442
311
  *
312
+ * @group Agent Toolkit
313
+ *
3443
314
  * @example Custom state
3444
315
  * ```typescript
3445
316
  * interface MyState extends ToolState {
@@ -3532,6 +403,8 @@ export declare type MapAgentOptions<CS extends ToolState = ToolState> = {
3532
403
  *
3533
404
  * Holds the lazy-initialized POIsModule for showing, hiding, and filtering
3534
405
  * the built-in POI categories rendered on the base map.
406
+ *
407
+ * @group Agent Toolkit
3535
408
  */
3536
409
  declare class MapPOIsState implements StateSlice {
3537
410
  private readonly _ttMap;
@@ -3542,23 +415,32 @@ declare class MapPOIsState implements StateSlice {
3542
415
  reset(): void;
3543
416
  }
3544
417
 
3545
- declare interface PlacesEntry {
418
+ /**
419
+ * A single entry in the place search history.
420
+ *
421
+ * @group Agent Toolkit
422
+ */
423
+ export declare type PlacesEntry = {
3546
424
  id: string;
3547
425
  timestamp: number;
3548
426
  label: string;
3549
427
  data: Place[];
3550
- }
428
+ };
3551
429
 
3552
430
  /**
3553
431
  * State for place search, geocoding, and geometries.
3554
432
  *
3555
433
  * Holds lazy-initialized PlacesModule and GeometriesModule alongside an
3556
434
  * append-only history of place and search results produced during the session.
435
+ *
436
+ * @group Agent Toolkit
3557
437
  */
3558
438
  declare class PlacesState implements StateSlice {
3559
439
  private readonly _ttMap;
3560
440
  private _placesModule?;
3561
441
  private _entries;
442
+ /** IDs of entries currently rendered on the map. */
443
+ private _shownEntryIds;
3562
444
  constructor(_ttMap: TomTomMap);
3563
445
  getPlacesModule(): Promise<PlacesModule>;
3564
446
  get placesModule(): PlacesModule | undefined;
@@ -3567,60 +449,30 @@ declare class PlacesState implements StateSlice {
3567
449
  * This is used purely to pass data between tools in a context-dependent way,
3568
450
  * so we assume the most recent entry is the relevant one to show on the map.
3569
451
  */
3570
- get latestPlace(): Place[] | undefined;
3571
- addPlaceResult(place: Place | Places, label: string): string;
452
+ get latestPlace(): Place_2[] | undefined;
453
+ addPlaceResult(place: Place_2 | Places, label: string): string;
454
+ /** IDs of entries currently shown on the map. */
455
+ get shownEntryIds(): ReadonlySet<PlacesEntry['id']>;
456
+ /** Return the union of all features belonging to currently-shown entries. */
457
+ getShownFeatures(): Place_2[];
458
+ /** Replace the shown set with exactly these ids and re-render. */
459
+ setShownEntries(ids: readonly PlacesEntry['id'][]): Promise<Place_2[]>;
460
+ /** Add ids to the shown set and re-render. */
461
+ addShownEntries(ids: readonly PlacesEntry['id'][]): Promise<Place_2[]>;
462
+ /** Remove ids from the shown set and re-render. */
463
+ removeShownEntries(ids: readonly PlacesEntry['id'][]): Promise<Place_2[]>;
464
+ /** Clear everything from the map (does not touch entries history). */
465
+ clearShownEntries(): Promise<void>;
466
+ private _renderShown;
3572
467
  reset(): void;
3573
468
  }
3574
469
 
3575
- /** Output schema for the query-traffic-analytics tool. */
3576
- declare const queryTrafficAnalyticsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3577
- granularity: z.ZodString;
3578
- count: z.ZodNumber;
3579
- entries: z.ZodArray<z.ZodObject<{
3580
- speed: z.ZodOptional<z.ZodNumber>;
3581
- freeFlowSpeed: z.ZodOptional<z.ZodNumber>;
3582
- congestionLevel: z.ZodOptional<z.ZodNumber>;
3583
- travelTime: z.ZodOptional<z.ZodNumber>;
3584
- networkLength: z.ZodOptional<z.ZodNumber>;
3585
- date: z.ZodOptional<z.ZodString>;
3586
- hour: z.ZodOptional<z.ZodNumber>;
3587
- year: z.ZodOptional<z.ZodNumber>;
3588
- month: z.ZodOptional<z.ZodNumber>;
3589
- week: z.ZodOptional<z.ZodNumber>;
3590
- day: z.ZodOptional<z.ZodNumber>;
3591
- }, z.core.$strip>>;
3592
- currentVisualization: z.ZodOptional<z.ZodObject<{
3593
- activeMetric: z.ZodOptional<z.ZodString>;
3594
- displayMode: z.ZodOptional<z.ZodString>;
3595
- }, z.core.$strip>>;
3596
- }, z.core.$strip>, z.ZodObject<{
3597
- error: z.ZodString;
3598
- }, z.core.$strip>]>;
3599
-
3600
- declare const queryTrafficAnalyticsSchema: z.ZodObject<{
3601
- granularity: z.ZodOptional<z.ZodEnum<{
3602
- yearly: "yearly";
3603
- monthly: "monthly";
3604
- weekly: "weekly";
3605
- daily: "daily";
3606
- hourly: "hourly";
3607
- average: "average";
3608
- }>>;
3609
- metric: z.ZodOptional<z.ZodEnum<{
3610
- speed: "speed";
3611
- congestionLevel: "congestionLevel";
3612
- freeFlowSpeed: "freeFlowSpeed";
3613
- travelTime: "travelTime";
3614
- networkLength: "networkLength";
3615
- }>>;
3616
- startDate: z.ZodOptional<z.ZodString>;
3617
- endDate: z.ZodOptional<z.ZodString>;
3618
- hourStart: z.ZodOptional<z.ZodNumber>;
3619
- hourEnd: z.ZodOptional<z.ZodNumber>;
3620
- dayOfWeek: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
3621
- }, z.core.$strip>;
3622
-
3623
- declare interface RangeEntry {
470
+ /**
471
+ * A single entry in the reachable range history.
472
+ *
473
+ * @group Agent Toolkit
474
+ */
475
+ export declare type RangeEntry = {
3624
476
  id: string;
3625
477
  timestamp: number;
3626
478
  label: string;
@@ -3631,7 +483,7 @@ declare interface RangeEntry {
3631
483
  budgets: ReachableRangeBudget[];
3632
484
  /** Raw polygon result for use in subsequent geometry searches. Not exposed to the agent. */
3633
485
  polygon?: PolygonFeatures;
3634
- }
486
+ };
3635
487
 
3636
488
  /**
3637
489
  * State for reachable range results.
@@ -3639,6 +491,8 @@ declare interface RangeEntry {
3639
491
  * Stores semantic summaries of calculated ranges (origin, budgets).
3640
492
  * Also retains raw polygon geometry internally for use in geometry searches
3641
493
  * (e.g. discoverPlaces withinRange). Displayed on the map via GeometriesModule.
494
+ *
495
+ * @group Agent Toolkit
3642
496
  */
3643
497
  declare class RangeState implements StateSlice {
3644
498
  private readonly _ttMap;
@@ -3656,182 +510,6 @@ declare class RangeState implements StateSlice {
3656
510
  reset(): void;
3657
511
  }
3658
512
 
3659
- declare const recallPlacesOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3660
- entries: z.ZodArray<z.ZodObject<{
3661
- id: z.ZodString;
3662
- label: z.ZodString;
3663
- timestamp: z.ZodNumber;
3664
- }, z.core.$strip>>;
3665
- }, z.core.$strip>, z.ZodObject<{
3666
- id: z.ZodString;
3667
- label: z.ZodString;
3668
- timestamp: z.ZodNumber;
3669
- places: z.ZodObject<{
3670
- count: z.ZodNumber;
3671
- features: z.ZodArray<z.ZodObject<{
3672
- name: z.ZodOptional<z.ZodString>;
3673
- address: z.ZodOptional<z.ZodString>;
3674
- position: z.ZodArray<z.ZodNumber>;
3675
- }, z.core.$strip>>;
3676
- }, z.core.$strip>;
3677
- }, z.core.$strip>, z.ZodObject<{
3678
- error: z.ZodString;
3679
- }, z.core.$strip>]>;
3680
-
3681
- declare const recallPlacesSchema: z.ZodObject<{
3682
- id: z.ZodOptional<z.ZodString>;
3683
- }, z.core.$strip>;
3684
-
3685
- declare const recallRangesOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3686
- entries: z.ZodArray<z.ZodObject<{
3687
- id: z.ZodString;
3688
- label: z.ZodString;
3689
- timestamp: z.ZodNumber;
3690
- }, z.core.$strip>>;
3691
- }, z.core.$strip>, z.ZodObject<{
3692
- id: z.ZodString;
3693
- label: z.ZodString;
3694
- timestamp: z.ZodNumber;
3695
- origin: z.ZodObject<{
3696
- query: z.ZodOptional<z.ZodString>;
3697
- position: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
3698
- }, z.core.$strip>;
3699
- budgets: z.ZodArray<z.ZodObject<{
3700
- type: z.ZodString;
3701
- value: z.ZodNumber;
3702
- }, z.core.$strip>>;
3703
- }, z.core.$strip>, z.ZodObject<{
3704
- error: z.ZodString;
3705
- }, z.core.$strip>]>;
3706
-
3707
- declare const recallRangesSchema: z.ZodObject<{
3708
- id: z.ZodOptional<z.ZodString>;
3709
- }, z.core.$strip>;
3710
-
3711
- declare const recallRoutesOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3712
- entries: z.ZodArray<z.ZodObject<{
3713
- id: z.ZodString;
3714
- label: z.ZodString;
3715
- timestamp: z.ZodNumber;
3716
- }, z.core.$strip>>;
3717
- }, z.core.$strip>, z.ZodObject<{
3718
- id: z.ZodString;
3719
- label: z.ZodString;
3720
- timestamp: z.ZodNumber;
3721
- routes: z.ZodObject<{
3722
- count: z.ZodNumber;
3723
- routes: z.ZodArray<z.ZodObject<{
3724
- index: z.ZodNumber;
3725
- summary: z.ZodObject<{
3726
- travelTimeInSeconds: z.ZodNumber;
3727
- lengthInMeters: z.ZodNumber;
3728
- trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
3729
- trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
3730
- departureTime: z.ZodOptional<z.ZodString>;
3731
- arrivalTime: z.ZodOptional<z.ZodString>;
3732
- noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3733
- historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3734
- liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3735
- }, z.core.$strip>;
3736
- legSummaries: z.ZodOptional<z.ZodArray<z.ZodObject<{
3737
- travelTimeInSeconds: z.ZodNumber;
3738
- lengthInMeters: z.ZodNumber;
3739
- trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
3740
- trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
3741
- departureTime: z.ZodOptional<z.ZodString>;
3742
- arrivalTime: z.ZodOptional<z.ZodString>;
3743
- noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3744
- historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3745
- liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3746
- }, z.core.$strip>>>;
3747
- }, z.core.$strip>>;
3748
- }, z.core.$strip>;
3749
- waypoints: z.ZodArray<z.ZodObject<{
3750
- position: z.ZodArray<z.ZodNumber>;
3751
- }, z.core.$strip>>;
3752
- params: z.ZodObject<{
3753
- maxAlternatives: z.ZodOptional<z.ZodNumber>;
3754
- costModel: z.ZodOptional<z.ZodObject<{
3755
- routeType: z.ZodOptional<z.ZodEnum<{
3756
- fast: "fast";
3757
- short: "short";
3758
- efficient: "efficient";
3759
- thrilling: "thrilling";
3760
- }>>;
3761
- traffic: z.ZodOptional<z.ZodEnum<{
3762
- live: "live";
3763
- historical: "historical";
3764
- }>>;
3765
- avoid: z.ZodOptional<z.ZodArray<z.ZodEnum<{
3766
- tollRoads: "tollRoads";
3767
- motorways: "motorways";
3768
- ferries: "ferries";
3769
- unpavedRoads: "unpavedRoads";
3770
- carpools: "carpools";
3771
- alreadyUsedRoads: "alreadyUsedRoads";
3772
- borderCrossings: "borderCrossings";
3773
- tunnels: "tunnels";
3774
- carTrains: "carTrains";
3775
- lowEmissionZones: "lowEmissionZones";
3776
- }>>>;
3777
- avoidAreas: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNumber>>>;
3778
- }, z.core.$strip>>;
3779
- when: z.ZodOptional<z.ZodObject<{
3780
- option: z.ZodEnum<{
3781
- departAt: "departAt";
3782
- arriveBy: "arriveBy";
3783
- }>;
3784
- date: z.ZodString;
3785
- }, z.core.$strip>>;
3786
- }, z.core.$strip>;
3787
- }, z.core.$strip>, z.ZodObject<{
3788
- error: z.ZodString;
3789
- }, z.core.$strip>]>;
3790
-
3791
- declare const recallRoutesSchema: z.ZodObject<{
3792
- id: z.ZodOptional<z.ZodString>;
3793
- }, z.core.$strip>;
3794
-
3795
- /** Output schema for the remove-stop-from-route tool. */
3796
- declare const removeStopFromRouteOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3797
- count: z.ZodNumber;
3798
- routes: z.ZodArray<z.ZodObject<{
3799
- index: z.ZodNumber;
3800
- summary: z.ZodObject<{
3801
- travelTimeInSeconds: z.ZodNumber;
3802
- lengthInMeters: z.ZodNumber;
3803
- trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
3804
- trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
3805
- departureTime: z.ZodOptional<z.ZodString>;
3806
- arrivalTime: z.ZodOptional<z.ZodString>;
3807
- noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3808
- historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3809
- liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3810
- }, z.core.$strip>;
3811
- legSummaries: z.ZodOptional<z.ZodArray<z.ZodObject<{
3812
- travelTimeInSeconds: z.ZodNumber;
3813
- lengthInMeters: z.ZodNumber;
3814
- trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
3815
- trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
3816
- departureTime: z.ZodOptional<z.ZodString>;
3817
- arrivalTime: z.ZodOptional<z.ZodString>;
3818
- noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3819
- historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3820
- liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
3821
- }, z.core.$strip>>>;
3822
- }, z.core.$strip>>;
3823
- }, z.core.$strip>, z.ZodObject<{
3824
- error: z.ZodString;
3825
- }, z.core.$strip>]>;
3826
-
3827
- /**
3828
- * Tool schema for removing a stop from an existing route.
3829
- */
3830
- declare const removeStopFromRouteSchema: z.ZodObject<{
3831
- stopIndex: z.ZodNumber;
3832
- showOnMap: z.ZodBoolean;
3833
- }, z.core.$strip>;
3834
-
3835
513
  /**
3836
514
  * Merges default tools with user overrides.
3837
515
  *
@@ -3842,32 +520,18 @@ declare const removeStopFromRouteSchema: z.ZodObject<{
3842
520
  * @param defaults - Base tool record (typically DEFAULT_TOOLS or empty).
3843
521
  * @param overrides - User-provided additions, replacements, and exclusions.
3844
522
  * @returns Resolved tool record ready for setupTools.
523
+ *
524
+ * @group Agent Toolkit
3845
525
  */
3846
- export declare function resolveTools<S extends ToolState>(defaults: Record<string, ToolEntry<S>>, overrides?: {
3847
- [K in ToolNameHint]?: ToolEntry<S> | false | undefined;
3848
- }): Record<string, ToolEntry<S>>;
3849
-
3850
- /** Output schema for the reverse-geocode tool. */
3851
- declare const reverseGeocodeOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3852
- name: z.ZodOptional<z.ZodString>;
3853
- address: z.ZodOptional<z.ZodString>;
3854
- position: z.ZodArray<z.ZodNumber>;
3855
- }, z.core.$strip>, z.ZodObject<{
3856
- error: z.ZodString;
3857
- }, z.core.$strip>]>;
3858
-
3859
- /**
3860
- * Tool schema for reverse geocoding (coordinates to address).
3861
- */
3862
- declare const reverseGeocodeSchema: z.ZodObject<{
3863
- position: z.ZodArray<z.ZodNumber>;
3864
- }, z.core.$strip>;
526
+ export declare const resolveTools: <S extends ToolState>(defaults: Record<string, ToolEntry<S>>, overrides?: { [K in ToolNameHint]?: ToolEntry<S> | false | undefined; }) => Record<string, ToolEntry<S>>;
3865
527
 
3866
528
  /**
3867
529
  * Route planning parameters stored in routing state.
3868
530
  * Consumed by setRouteLocations, addStopToRoute, and removeStopFromRoute.
531
+ *
532
+ * @group Agent Toolkit
3869
533
  */
3870
- declare interface RouteParams {
534
+ export declare type RouteParams = {
3871
535
  maxAlternatives?: number;
3872
536
  costModel?: {
3873
537
  routeType?: string;
@@ -3879,16 +543,21 @@ declare interface RouteParams {
3879
543
  option: 'departAt' | 'arriveBy';
3880
544
  date: string;
3881
545
  };
3882
- }
546
+ };
3883
547
 
3884
- declare interface RoutesEntry {
548
+ /**
549
+ * A single entry in the route calculation history.
550
+ *
551
+ * @group Agent Toolkit
552
+ */
553
+ export declare type RoutesEntry = {
3885
554
  id: string;
3886
555
  timestamp: number;
3887
556
  label: string;
3888
557
  data: Routes;
3889
558
  waypoints: WaypointLike[];
3890
559
  params: RouteParams;
3891
- }
560
+ };
3892
561
 
3893
562
  /**
3894
563
  * State for route calculation, waypoint management, and route planning parameters.
@@ -3896,6 +565,8 @@ declare interface RoutesEntry {
3896
565
  * Holds the lazy-initialized RoutingModule alongside an append-only history of
3897
566
  * calculated routes, sparse planning slots (being assembled before a calculation),
3898
567
  * and current route parameters.
568
+ *
569
+ * @group Agent Toolkit
3899
570
  */
3900
571
  declare class RoutingState implements StateSlice {
3901
572
  private readonly _ttMap;
@@ -3907,393 +578,35 @@ declare class RoutingState implements StateSlice {
3907
578
  getRoutingModule(): Promise<RoutingModule>;
3908
579
  get routingModule(): RoutingModule | undefined;
3909
580
  get entries(): readonly RoutesEntry[];
3910
- get currentRoutes(): Routes | undefined;
3911
- get currentWaypoints(): WaypointLike[] | undefined;
581
+ get currentRoutes(): Routes_2 | undefined;
582
+ get currentWaypoints(): WaypointLike_2[] | undefined;
3912
583
  /** Sparse nullable slots being assembled before triggering a route calculation. */
3913
584
  get planningSlots(): PlanningWaypoint[];
3914
585
  get params(): RouteParams;
3915
- addRoutes(routes: Routes, waypoints: WaypointLike[], label: string): void;
3916
- setWaypointAt(index: number, waypoint: WaypointLike): void;
586
+ addRoutes(routes: Routes_2, waypoints: WaypointLike_2[], label: string): void;
587
+ setWaypointAt(index: number, waypoint: WaypointLike_2): void;
3917
588
  setParams(params: Partial<RouteParams>): void;
3918
589
  reset(): void;
3919
590
  }
3920
591
 
3921
- declare const searchAlongRouteOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
3922
- count: z.ZodNumber;
3923
- features: z.ZodArray<z.ZodObject<{
3924
- name: z.ZodOptional<z.ZodString>;
3925
- address: z.ZodOptional<z.ZodString>;
3926
- position: z.ZodArray<z.ZodNumber>;
3927
- }, z.core.$strip>>;
3928
- placeResultIndex: z.ZodString;
3929
- shown: z.ZodOptional<z.ZodObject<{
3930
- markerType: z.ZodBoolean;
3931
- zoomMode: z.ZodBoolean;
3932
- }, z.core.$strip>>;
3933
- }, z.core.$strip>, z.ZodObject<{
3934
- status: z.ZodLiteral<"no_route">;
3935
- }, z.core.$strip>, z.ZodObject<{
3936
- error: z.ZodString;
3937
- }, z.core.$strip>]>;
3938
-
3939
- declare const searchAlongRouteSchema: z.ZodObject<{
3940
- query: z.ZodOptional<z.ZodString>;
3941
- poiCategories: z.ZodOptional<z.ZodArray<z.ZodString>>;
3942
- routeId: z.ZodOptional<z.ZodString>;
3943
- maxDetourTimeSeconds: z.ZodNumber;
3944
- sortBy: z.ZodOptional<z.ZodEnum<{
3945
- detourTime: "detourTime";
3946
- detourOffset: "detourOffset";
3947
- }>>;
3948
- limit: z.ZodOptional<z.ZodNumber>;
3949
- show: z.ZodOptional<z.ZodObject<{
3950
- markerType: z.ZodEnum<{
3951
- pin: "pin";
3952
- none: "none";
3953
- }>;
3954
- zoomMode: z.ZodEnum<{
3955
- none: "none";
3956
- auto: "auto";
3957
- }>;
3958
- }, z.core.$strip>>;
3959
- }, z.core.$strip>;
3960
-
3961
- /**
3962
- * Tool schema for setting language.
3963
- */
3964
- declare const setLanguageSchema: z.ZodObject<{
3965
- language: z.ZodString;
3966
- }, z.core.$strip>;
3967
-
3968
- /** Input schema for the setLayoutProperties tool. */
3969
- declare const setLayoutPropertiesSchema: z.ZodObject<{
3970
- changes: z.ZodArray<z.ZodObject<{
3971
- layerId: z.ZodString;
3972
- propertyName: z.ZodString;
3973
- value: z.ZodAny;
3974
- }, z.core.$strip>>;
3975
- }, z.core.$strip>;
3976
-
3977
- /**
3978
- * Tool schema for setting a standard map style.
3979
- */
3980
- declare const setMapStandardStyleSchema: z.ZodObject<{
3981
- style: z.ZodEnum<{
3982
- standardLight: "standardLight";
3983
- standardDark: "standardDark";
3984
- drivingLight: "drivingLight";
3985
- drivingDark: "drivingDark";
3986
- monoLight: "monoLight";
3987
- monoDark: "monoDark";
3988
- satellite: "satellite";
3989
- }>;
3990
- }, z.core.$strip>;
3991
-
3992
- /** Input schema for the setPaintProperties tool. */
3993
- declare const setPaintPropertiesSchema: z.ZodObject<{
3994
- changes: z.ZodArray<z.ZodObject<{
3995
- layerId: z.ZodString;
3996
- propertyName: z.ZodString;
3997
- value: z.ZodAny;
3998
- }, z.core.$strip>>;
3999
- }, z.core.$strip>;
4000
-
4001
- /**
4002
- * Tool schema for setting pitch and bearing.
4003
- */
4004
- declare const setPitchBearingSchema: z.ZodObject<{
4005
- pitch: z.ZodOptional<z.ZodNumber>;
4006
- bearing: z.ZodOptional<z.ZodNumber>;
4007
- }, z.core.$strip>;
4008
-
4009
- /** Output schema for the set-route-locations tool. */
4010
- declare const setRouteLocationsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
4011
- count: z.ZodNumber;
4012
- routes: z.ZodArray<z.ZodObject<{
4013
- index: z.ZodNumber;
4014
- summary: z.ZodObject<{
4015
- travelTimeInSeconds: z.ZodNumber;
4016
- lengthInMeters: z.ZodNumber;
4017
- trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
4018
- trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
4019
- departureTime: z.ZodOptional<z.ZodString>;
4020
- arrivalTime: z.ZodOptional<z.ZodString>;
4021
- noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
4022
- historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
4023
- liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
4024
- }, z.core.$strip>;
4025
- legSummaries: z.ZodOptional<z.ZodArray<z.ZodObject<{
4026
- travelTimeInSeconds: z.ZodNumber;
4027
- lengthInMeters: z.ZodNumber;
4028
- trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
4029
- trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
4030
- departureTime: z.ZodOptional<z.ZodString>;
4031
- arrivalTime: z.ZodOptional<z.ZodString>;
4032
- noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
4033
- historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
4034
- liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
4035
- }, z.core.$strip>>>;
4036
- }, z.core.$strip>>;
4037
- }, z.core.$strip>, z.ZodObject<{
4038
- error: z.ZodString;
4039
- }, z.core.$strip>]>;
4040
-
4041
- /** Input schema for set-route-locations. */
4042
- declare const setRouteLocationsSchema: z.ZodObject<{
4043
- locations: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
4044
- query: z.ZodString;
4045
- locationType: z.ZodEnum<{
4046
- default: "default";
4047
- poi: "poi";
4048
- }>;
4049
- }, z.core.$strip>, z.ZodObject<{
4050
- position: z.ZodObject<{
4051
- lng: z.ZodNumber;
4052
- lat: z.ZodNumber;
4053
- }, z.core.$strip>;
4054
- }, z.core.$strip>]>>;
4055
- showOnMap: z.ZodBoolean;
4056
- }, z.core.$strip>;
4057
-
4058
- /** Output schema for set-route-parameters. */
4059
- declare const setRouteParametersOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
4060
- count: z.ZodNumber;
4061
- routes: z.ZodArray<z.ZodObject<{
4062
- index: z.ZodNumber;
4063
- summary: z.ZodObject<{
4064
- travelTimeInSeconds: z.ZodNumber;
4065
- lengthInMeters: z.ZodNumber;
4066
- trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
4067
- trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
4068
- departureTime: z.ZodOptional<z.ZodString>;
4069
- arrivalTime: z.ZodOptional<z.ZodString>;
4070
- noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
4071
- historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
4072
- liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
4073
- }, z.core.$strip>;
4074
- legSummaries: z.ZodOptional<z.ZodArray<z.ZodObject<{
4075
- travelTimeInSeconds: z.ZodNumber;
4076
- lengthInMeters: z.ZodNumber;
4077
- trafficDelayInSeconds: z.ZodOptional<z.ZodNumber>;
4078
- trafficLengthInMeters: z.ZodOptional<z.ZodNumber>;
4079
- departureTime: z.ZodOptional<z.ZodString>;
4080
- arrivalTime: z.ZodOptional<z.ZodString>;
4081
- noTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
4082
- historicTrafficTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
4083
- liveTrafficIncidentsTravelTimeInSeconds: z.ZodOptional<z.ZodNumber>;
4084
- }, z.core.$strip>>>;
4085
- }, z.core.$strip>>;
4086
- }, z.core.$strip>, z.ZodObject<{
4087
- success: z.ZodLiteral<true>;
4088
- }, z.core.$strip>, z.ZodObject<{
4089
- error: z.ZodString;
4090
- }, z.core.$strip>]>;
4091
-
4092
- /** Input schema for set-route-parameters. */
4093
- declare const setRouteParametersSchema: z.ZodObject<{
4094
- maxAlternatives: z.ZodOptional<z.ZodNumber>;
4095
- costModel: z.ZodOptional<z.ZodObject<{
4096
- routeType: z.ZodOptional<z.ZodEnum<{
4097
- fast: "fast";
4098
- short: "short";
4099
- efficient: "efficient";
4100
- thrilling: "thrilling";
4101
- }>>;
4102
- traffic: z.ZodOptional<z.ZodEnum<{
4103
- live: "live";
4104
- historical: "historical";
4105
- }>>;
4106
- avoid: z.ZodOptional<z.ZodArray<z.ZodEnum<{
4107
- tollRoads: "tollRoads";
4108
- motorways: "motorways";
4109
- ferries: "ferries";
4110
- unpavedRoads: "unpavedRoads";
4111
- carpools: "carpools";
4112
- alreadyUsedRoads: "alreadyUsedRoads";
4113
- borderCrossings: "borderCrossings";
4114
- tunnels: "tunnels";
4115
- carTrains: "carTrains";
4116
- lowEmissionZones: "lowEmissionZones";
4117
- }>>>;
4118
- avoidAreas: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNumber>>>;
4119
- }, z.core.$strip>>;
4120
- when: z.ZodOptional<z.ZodObject<{
4121
- option: z.ZodEnum<{
4122
- departAt: "departAt";
4123
- arriveBy: "arriveBy";
4124
- }>;
4125
- date: z.ZodString;
4126
- }, z.core.$strip>>;
4127
- showOnMap: z.ZodBoolean;
4128
- }, z.core.$strip>;
4129
-
4130
- /**
4131
- * Tool schema for setting route theme.
4132
- */
4133
- declare const setRouteThemeSchema: z.ZodObject<{
4134
- mainColor: z.ZodOptional<z.ZodString>;
4135
- }, z.core.$strip>;
4136
-
4137
- /**
4138
- * Tool schema for showing places on the map.
4139
- */
4140
- declare const showPlacesSchema: z.ZodObject<{
4141
- id: z.ZodOptional<z.ZodString>;
4142
- fitBounds: z.ZodOptional<z.ZodBoolean>;
4143
- }, z.core.$strip>;
4144
-
4145
- /**
4146
- * Tool schema for showing routes on the map.
4147
- */
4148
- declare const showRouteSchema: z.ZodObject<{
4149
- id: z.ZodOptional<z.ZodString>;
4150
- selectedIndex: z.ZodOptional<z.ZodNumber>;
4151
- fitBounds: z.ZodOptional<z.ZodBoolean>;
4152
- }, z.core.$strip>;
4153
-
4154
- /** Output schema for the show-traffic-area-analytics tool. */
4155
- declare const showTrafficAreaAnalyticsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
4156
- success: z.ZodLiteral<true>;
4157
- mode: z.ZodString;
4158
- metric: z.ZodString;
4159
- colorTheme: z.ZodString;
4160
- visible: z.ZodBoolean;
4161
- filtered: z.ZodBoolean;
4162
- }, z.core.$strip>, z.ZodObject<{
4163
- error: z.ZodString;
4164
- }, z.core.$strip>]>;
4165
-
4166
- /**
4167
- * Tool schema for showing traffic area analytics on the map.
4168
- */
4169
- declare const showTrafficAreaAnalyticsSchema: z.ZodObject<{
4170
- mode: z.ZodOptional<z.ZodEnum<{
4171
- heatmap: "heatmap";
4172
- "hexgrid-3d": "hexgrid-3d";
4173
- "hexgrid-2d": "hexgrid-2d";
4174
- "square-3d": "square-3d";
4175
- "square-2d": "square-2d";
4176
- }>>;
4177
- metric: z.ZodOptional<z.ZodEnum<{
4178
- speed: "speed";
4179
- congestionLevel: "congestionLevel";
4180
- travelTime: "travelTime";
4181
- }>>;
4182
- colorTheme: z.ZodOptional<z.ZodEnum<{
4183
- trafficLight: "trafficLight";
4184
- heat: "heat";
4185
- monochrome: "monochrome";
4186
- viridis: "viridis";
4187
- plasma: "plasma";
4188
- }>>;
4189
- heightScale: z.ZodOptional<z.ZodNumber>;
4190
- scaleMode: z.ZodOptional<z.ZodEnum<{
4191
- raw: "raw";
4192
- predefinedRange: "predefinedRange";
4193
- currentRange: "currentRange";
4194
- }>>;
4195
- filter: z.ZodOptional<z.ZodObject<{
4196
- min: z.ZodOptional<z.ZodNumber>;
4197
- max: z.ZodOptional<z.ZodNumber>;
4198
- }, z.core.$strip>>;
4199
- visible: z.ZodOptional<z.ZodBoolean>;
4200
- fitBounds: z.ZodOptional<z.ZodBoolean>;
4201
- }, z.core.$strip>;
4202
-
4203
- /** Output schema for the show-waypoints tool. */
4204
- declare const showWaypointsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
4205
- success: z.ZodLiteral<true>;
4206
- count: z.ZodNumber;
4207
- }, z.core.$strip>, z.ZodObject<{
4208
- error: z.ZodString;
4209
- }, z.core.$strip>]>;
4210
-
4211
- /**
4212
- * Tool schema for showing waypoints on the map.
4213
- */
4214
- declare const showWaypointsSchema: z.ZodObject<{}, z.core.$strip>;
4215
-
4216
592
  /**
4217
593
  * Common interface for state slices. Implement `reset()` to participate
4218
594
  * in cleanup when `destroy()` is called on the agent.
4219
595
  *
4220
596
  * All built-in state classes implement this. Custom slices can optionally
4221
597
  * implement it to get automatic cleanup.
598
+ *
599
+ * @group Agent Toolkit
4222
600
  */
4223
601
  export declare interface StateSlice {
4224
602
  reset(): void;
4225
603
  }
4226
604
 
4227
605
  /**
4228
- * Tool schema for toggling base map layer groups.
4229
- */
4230
- declare const toggleBaseMapLayerGroupsSchema: z.ZodObject<{
4231
- visible: z.ZodBoolean;
4232
- layerGroups: z.ZodArray<z.ZodEnum<{
4233
- roadShields: "roadShields";
4234
- land: "land";
4235
- water: "water";
4236
- borders: "borders";
4237
- buildings2D: "buildings2D";
4238
- buildings3D: "buildings3D";
4239
- houseNumbers: "houseNumbers";
4240
- roadLines: "roadLines";
4241
- roadLabels: "roadLabels";
4242
- placeLabels: "placeLabels";
4243
- smallerTownLabels: "smallerTownLabels";
4244
- cityLabels: "cityLabels";
4245
- capitalLabels: "capitalLabels";
4246
- stateLabels: "stateLabels";
4247
- countryLabels: "countryLabels";
4248
- }>>;
4249
- }, z.core.$strip>;
4250
-
4251
- /** Output schema for the toggle-pois tool. */
4252
- declare const togglePOIsOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
4253
- success: z.ZodLiteral<true>;
4254
- allMapPOIsVisible: z.ZodOptional<z.ZodBoolean>;
4255
- filterCategories: z.ZodOptional<z.ZodObject<{
4256
- show: z.ZodEnum<{
4257
- only: "only";
4258
- all_except: "all_except";
4259
- }>;
4260
- values: z.ZodArray<z.ZodString>;
4261
- }, z.core.$strip>>;
4262
- reset: z.ZodOptional<z.ZodBoolean>;
4263
- }, z.core.$strip>, z.ZodObject<{
4264
- error: z.ZodString;
4265
- }, z.core.$strip>]>;
4266
-
4267
- /**
4268
- * Tool schema for toggling POIs.
4269
- */
4270
- declare const togglePOIsSchema: z.ZodObject<{
4271
- reset: z.ZodOptional<z.ZodBoolean>;
4272
- allMapPOIsVisible: z.ZodOptional<z.ZodBoolean>;
4273
- filterCategories: z.ZodOptional<z.ZodObject<{
4274
- show: z.ZodEnum<{
4275
- only: "only";
4276
- all_except: "all_except";
4277
- }>;
4278
- values: z.ZodArray<z.ZodString>;
4279
- }, z.core.$strip>>;
4280
- }, z.core.$strip>;
4281
-
4282
- /**
4283
- * Tool schema for toggling traffic flow.
4284
- */
4285
- declare const toggleTrafficFlowSchema: z.ZodObject<{
4286
- visible: z.ZodBoolean;
4287
- }, z.core.$strip>;
4288
-
4289
- /**
4290
- * Tool schema for toggling traffic incidents.
606
+ * All valid default tool names, derived from {@link DEFAULT_TOOLS}.
607
+ *
608
+ * @group Agent Toolkit
4291
609
  */
4292
- declare const toggleTrafficIncidentsSchema: z.ZodObject<{
4293
- visible: z.ZodBoolean;
4294
- }, z.core.$strip>;
4295
-
4296
- /** All valid default tool names, derived from {@link DEFAULT_TOOLS}. */
4297
610
  export declare const TOOL_NAMES: ToolName[];
4298
611
 
4299
612
  /**
@@ -4302,7 +615,7 @@ export declare const TOOL_NAMES: ToolName[];
4302
615
  *
4303
616
  * @typeParam S - The ToolState shape this tool requires. Default: base `ToolState`.
4304
617
  *
4305
- * @group Tools
618
+ * @group Agent Toolkit
4306
619
  */
4307
620
  export declare type ToolEntry<S extends ToolState = ToolState> = {
4308
621
  /** Description of the tool's purpose. */
@@ -4330,7 +643,7 @@ export declare type ToolEntry<S extends ToolState = ToolState> = {
4330
643
  /**
4331
644
  * Metadata for an agent toolkit tool.
4332
645
  *
4333
- * @group Tools
646
+ * @group Agent Toolkit
4334
647
  */
4335
648
  export declare type ToolMetadata = {
4336
649
  /** Tool identifier, derived from the config key. */
@@ -4351,14 +664,18 @@ export declare type ToolMetadata = {
4351
664
  dependsOn?: ToolNameHint[];
4352
665
  };
4353
666
 
4354
- /** Union of all default tool names. */
667
+ /**
668
+ * Union of all default tool names.
669
+ *
670
+ * @group Agent Toolkit
671
+ */
4355
672
  export declare type ToolName = keyof typeof DEFAULT_TOOLS;
4356
673
 
4357
674
  /**
4358
675
  * Autocomplete hint for tool names. Suggests known default tool names
4359
676
  * while allowing arbitrary custom names via `string & {}`.
4360
677
  *
4361
- * @group Tools
678
+ * @group Agent Toolkit
4362
679
  */
4363
680
  export declare type ToolNameHint = ToolName | (string & {});
4364
681
 
@@ -4367,6 +684,8 @@ export declare type ToolNameHint = ToolName | (string & {});
4367
684
  * each sub-state mixes lazy module access with the current service data
4368
685
  * produced during the session.
4369
686
  *
687
+ * @group Agent Toolkit
688
+ *
4370
689
  * @example
4371
690
  * ```typescript
4372
691
  * function createMyTool(state: ToolState) {
@@ -4397,6 +716,8 @@ export declare type ToolState = {
4397
716
 
4398
717
  /**
4399
718
  * State for traffic: flow layer, incident overlay, and area analytics modules.
719
+ *
720
+ * @group Agent Toolkit
4400
721
  */
4401
722
  declare class TrafficState implements StateSlice {
4402
723
  private readonly _ttMap;
@@ -4420,9 +741,4 @@ declare class TrafficState implements StateSlice {
4420
741
  reset(): void;
4421
742
  }
4422
743
 
4423
- /** Input schema for zoom-in-or-out. */
4424
- declare const zoomInOrOutSchema: z.ZodObject<{
4425
- delta: z.ZodNumber;
4426
- }, z.core.$strip>;
4427
-
4428
744
  export { }