Variable DEFAULT_TOOLSConst

DEFAULT_TOOLS: {
    addStopToRoute: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeAddStopToRoute;
        inputSchema: ZodObject<
            {
                location: ZodOptional<
                    ZodUnion<
                        readonly [
                            ZodObject<
                                { locationType: ZodEnum<(...)>; query: ZodString },
                                $strip,
                            >,
                            ZodObject<{ position: ZodObject<(...), (...)> }, $strip>,
                        ],
                    >,
                >;
                showOnMap: ZodBoolean;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        count: ZodNumber;
                        routes: ZodArray<
                            ZodObject<
                                {
                                    index: ZodNumber;
                                    legSummaries: ZodOptional<(...)>;
                                    summary: ZodObject<(...), (...)>;
                                },
                                $strip,
                            >,
                        >;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    calculateBBox: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeCalculateBBox;
        inputSchema: ZodObject<
            {
                geoJson: ZodUnion<
                    readonly [
                        ZodRecord<ZodString, ZodUnknown>,
                        ZodArray<ZodRecord<ZodString, ZodUnknown>>,
                    ],
                >;
            },
            $strip,
        >;
        relatedTools: string[];
        tags: string[];
    };
    clearMap: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeClearMap;
        inputSchema: ZodObject<
            {
                layers: ZodOptional<
                    ZodArray<
                        ZodEnum<
                            {
                                analytics: "analytics";
                                geometries: "geometries";
                                places: "places";
                                routes: "routes";
                            },
                        >,
                    >,
                >;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    { cleared: ZodArray<ZodString>; success: ZodLiteral<true> },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    discoverPlaces: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeDiscoverPlaces;
        inputSchema: ZodObject<
            {
                limit: ZodOptional<ZodNumber>;
                poiCategories: ZodOptional<ZodArray<ZodString>>;
                query: ZodOptional<ZodString>;
                radiusMeters: ZodOptional<ZodNumber>;
                show: ZodOptional<
                    ZodObject<
                        {
                            markerType: ZodEnum<{ none: "none"; pin: "pin" }>;
                            zoomMode: ZodEnum<{ auto: "auto"; none: "none" }>;
                        },
                        $strip,
                    >,
                >;
                where: ZodOptional<
                    ZodUnion<
                        readonly [
                            ZodObject<{ position: ZodArray<(...)> }, $strip>,
                            ZodObject<{ boundingBox: ZodUnion<(...)> }, $strip>,
                            ZodLiteral<"within-map-bounds">,
                            ZodLiteral<"nearby-map-center">,
                            ZodLiteral<"global">,
                            ZodString,
                        ],
                    >,
                >;
                withinRange: ZodOptional<ZodString>;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        count: ZodNumber;
                        features: ZodArray<
                            ZodObject<
                                {
                                    address: ZodOptional<(...)>;
                                    name: ZodOptional<(...)>;
                                    position: ZodArray<(...)>;
                                },
                                $strip,
                            >,
                        >;
                        placeResultIndex: ZodOptional<ZodString>;
                        shown: ZodOptional<
                            ZodObject<
                                { markerType: ZodBoolean; zoomMode: ZodBoolean },
                                $strip,
                            >,
                        >;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    executeMaplibreCode: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeExecuteMaplibreCode;
        inputSchema: ZodObject<{ code: ZodString }, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        layers: ZodObject<
                            {
                                added: ZodArray<ZodString>;
                                removed: ZodArray<ZodString>;
                                updated: ZodArray<ZodString>;
                            },
                            $strip,
                        >;
                        result: ZodOptional<ZodUnknown>;
                        sources: ZodObject<
                            {
                                added: ZodArray<ZodString>;
                                removed: ZodArray<ZodString>;
                                updated: ZodArray<ZodString>;
                            },
                            $strip,
                        >;
                        success: ZodLiteral<true>;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    findReachableArea: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeFindReachableArea;
        inputSchema: ZodObject<
            {
                budgets: ZodArray<
                    ZodObject<
                        {
                            type: ZodEnum<
                                { distanceKM: "distanceKM"; timeMinutes: "timeMinutes" },
                            >;
                            value: ZodNumber;
                        },
                        $strip,
                    >,
                >;
                origin: ZodUnion<
                    readonly [
                        ZodObject<
                            {
                                locationType: ZodEnum<{ default: ...; poi: ... }>;
                                query: ZodString;
                            },
                            $strip,
                        >,
                        ZodObject<
                            { position: ZodObject<{ lat: ...; lng: ... }, $strip> },
                            $strip,
                        >,
                    ],
                >;
                showOnMap: ZodBoolean;
                showOriginPin: ZodOptional<ZodBoolean>;
                theme: ZodOptional<
                    ZodEnum<
                        { filled: "filled"; inverted: "inverted"; outline: "outline" },
                    >,
                >;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        budgets: ZodArray<
                            ZodObject<{ type: ZodEnum<(...)>; value: ZodNumber }, $strip>,
                        >;
                        originName: ZodString;
                        rangeId: ZodString;
                    },
                    $strip,
                >,
                ZodObject<
                    {
                        status: ZodEnum<
                            { no_results: "no_results"; not_found: "not_found" },
                        >;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    fitRouteSection: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeFitRouteSection;
        inputSchema: ZodObject<
            {
                id: ZodString;
                padding: ZodOptional<ZodNumber>;
                sectionType: ZodEnum<
                    {
                        carpool: "carpool";
                        carTrain: "carTrain";
                        country: "country";
                        ferry: "ferry";
                        importantRoadStretch: "importantRoadStretch";
                        lanes: "lanes";
                        leg: "leg";
                        lowEmissionZone: "lowEmissionZone";
                        motorway: "motorway";
                        pedestrian: "pedestrian";
                        roadShields: "roadShields";
                        speedLimit: "speedLimit";
                        toll: "toll";
                        tollVignette: "tollVignette";
                        traffic: "traffic";
                        tunnel: "tunnel";
                        unpaved: "unpaved";
                        urban: "urban";
                        vehicleRestricted: "vehicleRestricted";
                    },
                >;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<{ success: ZodLiteral<true> }, $strip>,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    flyTo: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeFlyTo;
        inputSchema: ZodObject<
            {
                where: ZodUnion<
                    readonly [
                        ZodObject<
                            {
                                boundingBox: ZodUnion<readonly (...)>;
                                padding: ZodOptional<ZodNumber>;
                            },
                            $strip,
                        >,
                        ZodObject<
                            { position: ZodArray<ZodNumber>; zoom: ZodOptional<ZodNumber> },
                            $strip,
                        >,
                    ],
                >;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<{ success: ZodLiteral<true> }, $strip>,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    formatDistance: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeFormatDistance;
        inputSchema: ZodObject<
            {
                meters: ZodNumber;
                unitType: ZodOptional<
                    ZodEnum<
                        {
                            imperial_uk: "imperial_uk";
                            imperial_us: "imperial_us";
                            metric: "metric";
                        },
                    >,
                >;
            },
            $strip,
        >;
        relatedTools: string[];
        tags: string[];
    };
    formatDuration: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeFormatDuration;
        inputSchema: ZodObject<{ seconds: ZodNumber }, $strip>;
        relatedTools: string[];
        tags: string[];
    };
    getCurrentLocation: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetCurrentLocation;
        inputSchema: ZodObject<{}, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        accuracy: ZodNumber;
                        position: ZodArray<ZodNumber>;
                        timestamp: ZodNumber;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    getCurrentWaypoints: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetCurrentWaypoints;
        inputSchema: ZodObject<
            {
                includeEmptySlots: ZodOptional<ZodBoolean>;
                limit: ZodOptional<ZodNumber>;
                offset: ZodOptional<ZodNumber>;
                slotIndex: ZodOptional<ZodNumber>;
            },
            $strip,
        >;
        outputSchema: ZodObject<
            {
                filledSlots: ZodNumber;
                hasMore: ZodBoolean;
                matchedCount: ZodNumber;
                nextOffset: ZodOptional<ZodNumber>;
                offset: ZodNumber;
                returnedCount: ZodNumber;
                totalSlots: ZodNumber;
                waypoints: ZodArray<
                    ZodObject<
                        {
                            address: ZodOptional<ZodString>;
                            isFilled: ZodBoolean;
                            position: ZodOptional<ZodArray<ZodNumber>>;
                            slotIndex: ZodNumber;
                        },
                        $strip,
                    >,
                >;
            },
            $strip,
        >;
        relatedTools: string[];
        tags: string[];
    };
    getMapStyleLayers: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetMapStyleLayers;
        inputSchema: ZodObject<
            {
                include: ZodArray<ZodEnum<{ layout: "layout"; paint: "paint" }>>;
                layerIdQuery: ZodOptional<ZodString>;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        layers: ZodArray<
                            ZodObject<
                                {
                                    id: ZodString;
                                    layout: ZodOptional<(...)>;
                                    paint: ZodOptional<(...)>;
                                },
                                $strip,
                            >,
                        >;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    getPOICategoryCodes: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetPoiCategoryCodes;
        inputSchema: ZodObject<
            { filters: ZodOptional<ZodArray<ZodString>>; language: ZodString },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<{ codes: ZodArray<ZodString>; count: ZodNumber }, $strip>,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    getRouteProgress: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetRouteProgress;
        inputSchema: ZodObject<
            {
                clockTime: ZodOptional<ZodString>;
                routeIndex: ZodOptional<ZodNumber>;
                traveledDistanceInMeters: ZodOptional<ZodNumber>;
                traveledTimeInSeconds: ZodOptional<ZodNumber>;
            },
            $strip,
        >;
        relatedTools: string[];
        tags: string[];
    };
    getSectionBBox: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetSectionBBox;
        inputSchema: ZodObject<
            {
                id: ZodString;
                sectionType: ZodEnum<
                    {
                        carpool: "carpool";
                        carTrain: "carTrain";
                        country: "country";
                        ferry: "ferry";
                        importantRoadStretch: "importantRoadStretch";
                        lanes: "lanes";
                        leg: "leg";
                        lowEmissionZone: "lowEmissionZone";
                        motorway: "motorway";
                        pedestrian: "pedestrian";
                        roadShields: "roadShields";
                        speedLimit: "speedLimit";
                        toll: "toll";
                        tollVignette: "tollVignette";
                        traffic: "traffic";
                        tunnel: "tunnel";
                        unpaved: "unpaved";
                        urban: "urban";
                        vehicleRestricted: "vehicleRestricted";
                    },
                >;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<{ bbox: ZodArray<ZodNumber> }, $strip>,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    getSectionProgress: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetSectionProgress;
        inputSchema: ZodObject<
            {
                ids: ZodOptional<ZodArray<ZodString>>;
                sectionType: ZodEnum<
                    {
                        carpool: "carpool";
                        carTrain: "carTrain";
                        country: "country";
                        ferry: "ferry";
                        importantRoadStretch: "importantRoadStretch";
                        lanes: "lanes";
                        leg: "leg";
                        lowEmissionZone: "lowEmissionZone";
                        motorway: "motorway";
                        pedestrian: "pedestrian";
                        roadShields: "roadShields";
                        speedLimit: "speedLimit";
                        toll: "toll";
                        tollVignette: "tollVignette";
                        traffic: "traffic";
                        tunnel: "tunnel";
                        unpaved: "unpaved";
                        urban: "urban";
                        vehicleRestricted: "vehicleRestricted";
                    },
                >;
            },
            $strip,
        >;
        relatedTools: string[];
        tags: string[];
    };
    getShownIncidents: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetShownIncidents;
        inputSchema: ZodObject<{}, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        count: ZodNumber;
                        trafficIncidents: ZodArray<
                            ZodObject<
                                {
                                    averageSpeedKmph: ZodOptional<(...)>;
                                    category: ZodString;
                                    delayInSeconds: ZodOptional<(...)>;
                                    description: ZodOptional<(...)>;
                                    id: ZodString;
                                    magnitudeOfDelay: ZodString;
                                    roadCategory: ZodOptional<(...)>;
                                },
                                $strip,
                            >,
                        >;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    getShownPlaces: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetShownPlaces;
        inputSchema: ZodObject<{}, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        count: ZodNumber;
                        features: ZodArray<
                            ZodObject<
                                {
                                    address: ZodOptional<(...)>;
                                    name: ZodOptional<(...)>;
                                    position: ZodArray<(...)>;
                                },
                                $strip,
                            >,
                        >;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    getShownRoutes: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetShownRoutes;
        inputSchema: ZodObject<{}, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        count: ZodNumber;
                        routes: ZodArray<
                            ZodObject<
                                {
                                    index: ZodNumber;
                                    legSummaries: ZodOptional<(...)>;
                                    summary: ZodObject<(...), (...)>;
                                },
                                $strip,
                            >,
                        >;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    getShownRouteSections: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetShownRouteSections;
        inputSchema: ZodObject<
            {
                sectionType: ZodEnum<
                    {
                        carpool: "carpool";
                        carTrain: "carTrain";
                        country: "country";
                        ferry: "ferry";
                        importantRoadStretch: "importantRoadStretch";
                        lanes: "lanes";
                        leg: "leg";
                        lowEmissionZone: "lowEmissionZone";
                        motorway: "motorway";
                        pedestrian: "pedestrian";
                        roadShields: "roadShields";
                        speedLimit: "speedLimit";
                        toll: "toll";
                        tollVignette: "tollVignette";
                        traffic: "traffic";
                        tunnel: "tunnel";
                        unpaved: "unpaved";
                        urban: "urban";
                        vehicleRestricted: "vehicleRestricted";
                    },
                >;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        routes: ZodArray<
                            ZodObject<
                                { routeIndex: ZodNumber; sections: ZodArray<(...)> },
                                $strip,
                            >,
                        >;
                        sectionType: ZodString;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    getShownRouteTrafficIncidents: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetShownRouteTrafficIncidents;
        inputSchema: ZodObject<{}, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        count: ZodNumber;
                        trafficIncidents: ZodArray<
                            ZodObject<
                                {
                                    categories: ZodOptional<(...)>;
                                    delayInSeconds: ZodOptional<(...)>;
                                    effectiveSpeedInKmh: ZodOptional<(...)>;
                                    id: ZodString;
                                    magnitudeOfDelay: ZodString;
                                    title: ZodOptional<(...)>;
                                },
                                $strip,
                            >,
                        >;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    getShownWaypoints: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetShownWaypoints;
        inputSchema: ZodObject<{}, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        count: ZodNumber;
                        waypoints: ZodArray<
                            ZodObject<
                                { name: ZodOptional<(...)>; position: ZodArray<(...)> },
                                $strip,
                            >,
                        >;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    getStandardMapStyles: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetStandardMapStyles;
        inputSchema: ZodObject<{}, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<{ styles: ZodReadonly<ZodArray<ZodString>> }, $strip>,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    getTrafficAreaAnalytics: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetTrafficAreaAnalytics;
        inputSchema: ZodObject<
            {
                bbox: ZodOptional<ZodArray<ZodNumber>>;
                days: ZodOptional<ZodArray<ZodString>>;
                endDate: ZodOptional<ZodString>;
                functionalRoadClasses: ZodOptional<
                    ZodUnion<
                        readonly [
                            ZodLiteral<"all">,
                            ZodArray<
                                ZodEnum<
                                    {
                                        LOCAL_CONNECTING_ROAD: ...;
                                        LOCAL_ROAD: ...;
                                        LOCAL_ROAD_HIGH_IMPORTANCE: ...;
                                        LOCAL_ROAD_MINOR_IMPORTANCE: ...;
                                        MAJOR_ROAD: ...;
                                        MOTORWAY: ...;
                                        OTHER_MAJOR_ROAD: ...;
                                        OTHER_ROAD: ...;
                                        SECONDARY_ROAD: ...;
                                    },
                                >,
                            >,
                        ],
                    >,
                >;
                hours: ZodOptional<
                    ZodUnion<readonly [ZodLiteral<"all">, ZodArray<ZodNumber>]>,
                >;
                location: ZodOptional<
                    ZodUnion<
                        readonly [
                            ZodObject<
                                { locationType: ZodEnum<(...)>; query: ZodString },
                                $strip,
                            >,
                            ZodObject<{ position: ZodObject<(...), (...)> }, $strip>,
                        ],
                    >,
                >;
                metrics: ZodUnion<
                    readonly [
                        ZodLiteral<"all">,
                        ZodArray<
                            ZodEnum<
                                {
                                    congestionLevel: "congestionLevel";
                                    freeFlowSpeed: "freeFlowSpeed";
                                    networkLength: "networkLength";
                                    speed: "speed";
                                    travelTime: "travelTime";
                                },
                            >,
                        >,
                    ],
                >;
                showOnMap: ZodOptional<ZodBoolean>;
                startDate: ZodOptional<ZodString>;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        availableGranularities: ZodArray<ZodString>;
                        baseData: ZodObject<
                            {
                                congestionLevel: ZodOptional<ZodNumber>;
                                freeFlowSpeed: ZodOptional<ZodNumber>;
                                networkLength: ZodOptional<ZodNumber>;
                                speed: ZodOptional<ZodNumber>;
                                travelTime: ZodOptional<ZodNumber>;
                            },
                            $strip,
                        >;
                        dateRange: ZodObject<{ end: ZodString; start: ZodString }, $strip>;
                        metrics: ZodArray<ZodString>;
                        name: ZodOptional<ZodString>;
                        tileCount: ZodNumber;
                        timezone: ZodOptional<ZodString>;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    getTrafficIncidents: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetTrafficIncidents;
        inputSchema: ZodObject<
            {
                bbox: ZodOptional<ZodArray<ZodNumber>>;
                categoryFilter: ZodOptional<
                    ZodArray<
                        ZodEnum<
                            {
                                accident: "accident";
                                "animals-on-road": "animals-on-road";
                                "broken-down-vehicle": "broken-down-vehicle";
                                danger: "danger";
                                flooding: "flooding";
                                fog: "fog";
                                frost: "frost";
                                jam: "jam";
                                "lane-closed": "lane-closed";
                                "narrow-lanes": "narrow-lanes";
                                other: "other";
                                rain: "rain";
                                "road-closed": "road-closed";
                                roadworks: "roadworks";
                                wind: "wind";
                            },
                        >,
                    >,
                >;
                ids: ZodOptional<ZodArray<ZodString>>;
                timeValidityFilter: ZodOptional<
                    ZodArray<ZodEnum<{ future: "future"; present: "present" }>>,
                >;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        count: ZodNumber;
                        incidents: ZodArray<
                            ZodObject<
                                {
                                    category: ZodString;
                                    delayInSeconds: ZodOptional<(...)>;
                                    endTime: ZodOptional<(...)>;
                                    events: ZodArray<(...)>;
                                    from: ZodOptional<(...)>;
                                    id: ZodString;
                                    lengthInMeters: ZodOptional<(...)>;
                                    magnitudeOfDelay: ZodString;
                                    roadNumbers: ZodOptional<(...)>;
                                    startTime: ZodOptional<(...)>;
                                    timeValidity: ZodString;
                                    to: ZodOptional<(...)>;
                                },
                                $strip,
                            >,
                        >;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    getViewport: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeGetViewport;
        inputSchema: ZodObject<{}, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        bbox: ZodArray<ZodNumber>;
                        bearing: ZodNumber;
                        center: ZodArray<ZodNumber>;
                        pitch: ZodNumber;
                        zoom: ZodNumber;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    help: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: () => Promise<never>;
        inputSchema: ZodObject<
            {
                mode: ZodEnum<{ detail: "detail"; summary: "summary" }>;
                query: ZodOptional<ZodString>;
                tag: ZodOptional<
                    ZodEnum<
                        {
                            "along-route": "along-route";
                            carpool: "carpool";
                            carTrain: "carTrain";
                            country: "country";
                            coverage: "coverage";
                            detour: "detour";
                            discover: "discover";
                            EV: "EV";
                            ferry: "ferry";
                            importantRoadStretch: "importantRoadStretch";
                            isochrone: "isochrone";
                            lanes: "lanes";
                            leg: "leg";
                            locate: "locate";
                            location: "location";
                            lowEmissionZone: "lowEmissionZone";
                            "map style": "map style";
                            motorway: "motorway";
                            pedestrian: "pedestrian";
                            place: "place";
                            range: "range";
                            "reachable-range": "reachable-range";
                            recall: "recall";
                            roadShields: "roadShields";
                            route: "route";
                            search: "search";
                            speedLimit: "speedLimit";
                            state: "state";
                            toll: "toll";
                            tollVignette: "tollVignette";
                            traffic: "traffic";
                            tunnel: "tunnel";
                            unpaved: "unpaved";
                            urban: "urban";
                            utilities: "utilities";
                            vehicleRestricted: "vehicleRestricted";
                            waypoint: "waypoint";
                        },
                    >,
                >;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    { examplePrompts: ZodArray<ZodString>; mode: ZodLiteral<"summary"> },
                    $strip,
                >,
                ZodObject<
                    {
                        matchedTools: ZodArray<
                            ZodObject<
                                {
                                    description: ZodString;
                                    examplePrompts: ZodArray<(...)>;
                                    name: ZodString;
                                    relatedTools: ZodOptional<(...)>;
                                },
                                $strip,
                            >,
                        >;
                        mode: ZodLiteral<"detail">;
                        query: ZodOptional<ZodString>;
                        tag: ZodOptional<
                            ZodEnum<
                                {
                                    "along-route": "along-route";
                                    carpool: "carpool";
                                    carTrain: "carTrain";
                                    country: "country";
                                    coverage: "coverage";
                                    detour: "detour";
                                    discover: "discover";
                                    EV: "EV";
                                    ferry: "ferry";
                                    importantRoadStretch: "importantRoadStretch";
                                    isochrone: "isochrone";
                                    lanes: "lanes";
                                    leg: "leg";
                                    locate: "locate";
                                    location: "location";
                                    lowEmissionZone: "lowEmissionZone";
                                    "map style": "map style";
                                    motorway: "motorway";
                                    pedestrian: "pedestrian";
                                    place: "place";
                                    range: "range";
                                    "reachable-range": "reachable-range";
                                    recall: "recall";
                                    roadShields: "roadShields";
                                    route: "route";
                                    search: "search";
                                    speedLimit: "speedLimit";
                                    state: "state";
                                    toll: "toll";
                                    tollVignette: "tollVignette";
                                    traffic: "traffic";
                                    tunnel: "tunnel";
                                    unpaved: "unpaved";
                                    urban: "urban";
                                    utilities: "utilities";
                                    vehicleRestricted: "vehicleRestricted";
                                    waypoint: "waypoint";
                                },
                            >,
                        >;
                        totalMatched: ZodNumber;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        tags: string[];
    };
    locatePlace: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeLocatePlace;
        inputSchema: ZodObject<
            {
                locationType: ZodEnum<{ default: "default"; poi: "poi" }>;
                query: ZodString;
                show: ZodOptional<
                    ZodObject<
                        {
                            markerType: ZodEnum<{ none: "none"; pin: "pin" }>;
                            zoomMode: ZodEnum<{ auto: "auto"; none: "none" }>;
                        },
                        $strip,
                    >,
                >;
                waypointIndex: ZodOptional<ZodNumber>;
                where: ZodUnion<
                    readonly [
                        ZodObject<{ position: ZodArray<ZodNumber> }, $strip>,
                        ZodObject<{ boundingBox: ZodUnion<readonly (...)> }, $strip>,
                        ZodLiteral<"within-map-bounds">,
                        ZodLiteral<"nearby-map-center">,
                        ZodLiteral<"global">,
                        ZodString,
                    ],
                >;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        address: ZodOptional<ZodString>;
                        name: ZodOptional<ZodString>;
                        position: ZodArray<ZodNumber>;
                        shown: ZodOptional<
                            ZodObject<
                                { markerType: ZodBoolean; zoomMode: ZodBoolean },
                                $strip,
                            >,
                        >;
                        waypointIndex: ZodOptional<ZodNumber>;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    queryTrafficAnalytics: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeQueryTrafficAnalytics;
        inputSchema: ZodObject<
            {
                dayOfWeek: ZodOptional<ZodArray<ZodNumber>>;
                endDate: ZodOptional<ZodString>;
                granularity: ZodOptional<
                    ZodEnum<
                        {
                            average: "average";
                            daily: "daily";
                            hourly: "hourly";
                            monthly: "monthly";
                            weekly: "weekly";
                            yearly: "yearly";
                        },
                    >,
                >;
                hourEnd: ZodOptional<ZodNumber>;
                hourStart: ZodOptional<ZodNumber>;
                metric: ZodOptional<
                    ZodEnum<
                        {
                            congestionLevel: "congestionLevel";
                            freeFlowSpeed: "freeFlowSpeed";
                            networkLength: "networkLength";
                            speed: "speed";
                            travelTime: "travelTime";
                        },
                    >,
                >;
                startDate: ZodOptional<ZodString>;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        count: ZodNumber;
                        currentVisualization: ZodOptional<
                            ZodObject<
                                {
                                    activeMetric: ZodOptional<(...)>;
                                    displayMode: ZodOptional<(...)>;
                                },
                                $strip,
                            >,
                        >;
                        entries: ZodArray<
                            ZodObject<
                                {
                                    congestionLevel: ZodOptional<(...)>;
                                    date: ZodOptional<(...)>;
                                    day: ZodOptional<(...)>;
                                    freeFlowSpeed: ZodOptional<(...)>;
                                    hour: ZodOptional<(...)>;
                                    month: ZodOptional<(...)>;
                                    networkLength: ZodOptional<(...)>;
                                    speed: ZodOptional<(...)>;
                                    travelTime: ZodOptional<(...)>;
                                    week: ZodOptional<(...)>;
                                    year: ZodOptional<(...)>;
                                },
                                $strip,
                            >,
                        >;
                        granularity: ZodString;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    recallPlaces: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeRecallPlaces;
        inputSchema: ZodObject<{ id: ZodOptional<ZodString> }, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        entries: ZodArray<
                            ZodObject<
                                { id: ZodString; label: ZodString; timestamp: ZodNumber },
                                $strip,
                            >,
                        >;
                    },
                    $strip,
                >,
                ZodObject<
                    {
                        id: ZodString;
                        label: ZodString;
                        places: ZodObject<
                            { count: ZodNumber; features: ZodArray<ZodObject<(...), (...)>> },
                            $strip,
                        >;
                        timestamp: ZodNumber;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    recallRanges: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeRecallRanges;
        inputSchema: ZodObject<{ id: ZodOptional<ZodString> }, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        entries: ZodArray<
                            ZodObject<
                                { id: ZodString; label: ZodString; timestamp: ZodNumber },
                                $strip,
                            >,
                        >;
                    },
                    $strip,
                >,
                ZodObject<
                    {
                        budgets: ZodArray<
                            ZodObject<{ type: ZodString; value: ZodNumber }, $strip>,
                        >;
                        id: ZodString;
                        label: ZodString;
                        origin: ZodObject<
                            {
                                position: ZodTuple<[(...), (...)], null>;
                                query: ZodOptional<ZodString>;
                            },
                            $strip,
                        >;
                        timestamp: ZodNumber;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    recallRoutes: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeRecallRoutes;
        inputSchema: ZodObject<{ id: ZodOptional<ZodString> }, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        entries: ZodArray<
                            ZodObject<
                                { id: ZodString; label: ZodString; timestamp: ZodNumber },
                                $strip,
                            >,
                        >;
                    },
                    $strip,
                >,
                ZodObject<
                    {
                        id: ZodString;
                        label: ZodString;
                        params: ZodObject<
                            {
                                costModel: ZodOptional<ZodObject<(...), (...)>>;
                                maxAlternatives: ZodOptional<ZodNumber>;
                                when: ZodOptional<ZodObject<(...), (...)>>;
                            },
                            $strip,
                        >;
                        routes: ZodObject<
                            { count: ZodNumber; routes: ZodArray<ZodObject<(...), (...)>> },
                            $strip,
                        >;
                        timestamp: ZodNumber;
                        waypoints: ZodArray<ZodObject<{ position: ZodArray<(...)> }, $strip>>;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    removeStopFromRoute: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeRemoveStopFromRoute;
        inputSchema: ZodObject<
            { showOnMap: ZodBoolean; stopIndex: ZodNumber },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        count: ZodNumber;
                        routes: ZodArray<
                            ZodObject<
                                {
                                    index: ZodNumber;
                                    legSummaries: ZodOptional<(...)>;
                                    summary: ZodObject<(...), (...)>;
                                },
                                $strip,
                            >,
                        >;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    reverseGeocode: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeReverseGeocode;
        inputSchema: ZodObject<{ position: ZodArray<ZodNumber> }, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        address: ZodOptional<ZodString>;
                        name: ZodOptional<ZodString>;
                        position: ZodArray<ZodNumber>;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    searchAlongRoute: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeSearchAlongRoute;
        inputSchema: ZodObject<
            {
                limit: ZodOptional<ZodNumber>;
                maxDetourTimeSeconds: ZodNumber;
                poiCategories: ZodOptional<ZodArray<ZodString>>;
                query: ZodOptional<ZodString>;
                routeId: ZodOptional<ZodString>;
                show: ZodOptional<
                    ZodObject<
                        {
                            markerType: ZodEnum<{ none: "none"; pin: "pin" }>;
                            zoomMode: ZodEnum<{ auto: "auto"; none: "none" }>;
                        },
                        $strip,
                    >,
                >;
                sortBy: ZodOptional<
                    ZodEnum<{ detourOffset: "detourOffset"; detourTime: "detourTime" }>,
                >;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        count: ZodNumber;
                        features: ZodArray<
                            ZodObject<
                                {
                                    address: ZodOptional<(...)>;
                                    name: ZodOptional<(...)>;
                                    position: ZodArray<(...)>;
                                },
                                $strip,
                            >,
                        >;
                        placeResultIndex: ZodString;
                        shown: ZodOptional<
                            ZodObject<
                                { markerType: ZodBoolean; zoomMode: ZodBoolean },
                                $strip,
                            >,
                        >;
                    },
                    $strip,
                >,
                ZodObject<{ status: ZodLiteral<"no_route"> }, $strip>,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    setLanguage: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeSetLanguage;
        inputSchema: ZodObject<{ language: ZodString }, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<{ language: ZodString; success: ZodLiteral<true> }, $strip>,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    setLayoutProperties: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeSetLayoutProperties;
        inputSchema: ZodObject<
            {
                changes: ZodArray<
                    ZodObject<
                        { layerId: ZodString; propertyName: ZodString; value: ZodAny },
                        $strip,
                    >,
                >;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    { results: ZodArray<ZodUnion<readonly [(...), (...)]>> },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    setMapStandardStyle: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeSetMapStandardStyle;
        inputSchema: ZodObject<
            {
                style: ZodEnum<
                    {
                        drivingDark: "drivingDark";
                        drivingLight: "drivingLight";
                        monoDark: "monoDark";
                        monoLight: "monoLight";
                        satellite: "satellite";
                        standardDark: "standardDark";
                        standardLight: "standardLight";
                    },
                >;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<{ style: ZodString; success: ZodLiteral<true> }, $strip>,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    setPaintProperties: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeSetPaintProperties;
        inputSchema: ZodObject<
            {
                changes: ZodArray<
                    ZodObject<
                        { layerId: ZodString; propertyName: ZodString; value: ZodAny },
                        $strip,
                    >,
                >;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    { results: ZodArray<ZodUnion<readonly [(...), (...)]>> },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    setPitchBearing: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeSetPitchBearing;
        inputSchema: ZodObject<
            { bearing: ZodOptional<ZodNumber>; pitch: ZodOptional<ZodNumber> },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<{ success: ZodLiteral<true> }, $strip>,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    setRouteLocations: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeSetRouteLocations;
        inputSchema: ZodObject<
            {
                locations: ZodArray<
                    ZodUnion<
                        readonly [
                            ZodObject<
                                { locationType: ZodEnum<(...)>; query: ZodString },
                                $strip,
                            >,
                            ZodObject<{ position: ZodObject<(...), (...)> }, $strip>,
                        ],
                    >,
                >;
                showOnMap: ZodBoolean;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        count: ZodNumber;
                        routes: ZodArray<
                            ZodObject<
                                {
                                    index: ZodNumber;
                                    legSummaries: ZodOptional<(...)>;
                                    summary: ZodObject<(...), (...)>;
                                },
                                $strip,
                            >,
                        >;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    setRouteParameters: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeSetRouteParameters;
        inputSchema: ZodObject<
            {
                costModel: ZodOptional<
                    ZodObject<
                        {
                            avoid: ZodOptional<
                                ZodArray<
                                    ZodEnum<
                                        {
                                            alreadyUsedRoads: ...;
                                            borderCrossings: ...;
                                            carpools: ...;
                                            carTrains: ...;
                                            ferries: ...;
                                            lowEmissionZones: ...;
                                            motorways: ...;
                                            tollRoads: ...;
                                            tunnels: ...;
                                            unpavedRoads: ...;
                                        },
                                    >,
                                >,
                            >;
                            avoidAreas: ZodOptional<ZodArray<ZodArray<ZodNumber>>>;
                            routeType: ZodOptional<
                                ZodEnum<
                                    {
                                        efficient: "efficient";
                                        fast: "fast";
                                        short: "short";
                                        thrilling: "thrilling";
                                    },
                                >,
                            >;
                            traffic: ZodOptional<
                                ZodEnum<{ historical: "historical"; live: "live" }>,
                            >;
                        },
                        $strip,
                    >,
                >;
                maxAlternatives: ZodOptional<ZodNumber>;
                showOnMap: ZodBoolean;
                when: ZodOptional<
                    ZodObject<
                        {
                            date: ZodString;
                            option: ZodEnum<{ arriveBy: "arriveBy"; departAt: "departAt" }>;
                        },
                        $strip,
                    >,
                >;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        count: ZodNumber;
                        routes: ZodArray<
                            ZodObject<
                                {
                                    index: ZodNumber;
                                    legSummaries: ZodOptional<(...)>;
                                    summary: ZodObject<(...), (...)>;
                                },
                                $strip,
                            >,
                        >;
                    },
                    $strip,
                >,
                ZodObject<{ success: ZodLiteral<true> }, $strip>,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    setRouteTheme: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeSetRouteTheme;
        inputSchema: ZodObject<{ mainColor: ZodOptional<ZodString> }, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        success: ZodLiteral<true>;
                        theme: ZodObject<{ mainColor: ZodOptional<ZodString> }, $strip>;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    showPlaces: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeShowPlaces;
        inputSchema: ZodObject<
            { fitBounds: ZodOptional<ZodBoolean>; id: ZodOptional<ZodString> },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<{ count: ZodNumber; success: ZodLiteral<true> }, $strip>,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    showRoute: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeShowRoutes;
        inputSchema: ZodObject<
            {
                fitBounds: ZodOptional<ZodBoolean>;
                id: ZodOptional<ZodString>;
                selectedIndex: ZodOptional<ZodNumber>;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        displayedRoute: ZodNumber;
                        routeCount: ZodNumber;
                        success: ZodLiteral<true>;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    showTrafficAreaAnalytics: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeShowTrafficAreaAnalytics;
        inputSchema: ZodObject<
            {
                colorTheme: ZodOptional<
                    ZodEnum<
                        {
                            heat: "heat";
                            monochrome: "monochrome";
                            plasma: "plasma";
                            trafficLight: "trafficLight";
                            viridis: "viridis";
                        },
                    >,
                >;
                filter: ZodOptional<
                    ZodObject<
                        { max: ZodOptional<ZodNumber>; min: ZodOptional<ZodNumber> },
                        $strip,
                    >,
                >;
                fitBounds: ZodOptional<ZodBoolean>;
                heightScale: ZodOptional<ZodNumber>;
                metric: ZodOptional<
                    ZodEnum<
                        {
                            congestionLevel: "congestionLevel";
                            speed: "speed";
                            travelTime: "travelTime";
                        },
                    >,
                >;
                mode: ZodOptional<
                    ZodEnum<
                        {
                            heatmap: "heatmap";
                            "hexgrid-2d": "hexgrid-2d";
                            "hexgrid-3d": "hexgrid-3d";
                            "square-2d": "square-2d";
                            "square-3d": "square-3d";
                        },
                    >,
                >;
                scaleMode: ZodOptional<
                    ZodEnum<
                        {
                            currentRange: "currentRange";
                            predefinedRange: "predefinedRange";
                            raw: "raw";
                        },
                    >,
                >;
                visible: ZodOptional<ZodBoolean>;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        colorTheme: ZodString;
                        filtered: ZodBoolean;
                        metric: ZodString;
                        mode: ZodString;
                        success: ZodLiteral<true>;
                        visible: ZodBoolean;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    showWaypoints: {
        classificationPrompt: string;
        dependsOn: string[];
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeShowWaypoints;
        inputSchema: ZodObject<{}, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<{ count: ZodNumber; success: ZodLiteral<true> }, $strip>,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    toggleBaseMapLayerGroups: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeToggleBaseMapLayerGroups;
        inputSchema: ZodObject<
            {
                layerGroups: ZodArray<
                    ZodEnum<
                        {
                            borders: "borders";
                            buildings2D: "buildings2D";
                            buildings3D: "buildings3D";
                            capitalLabels: "capitalLabels";
                            cityLabels: "cityLabels";
                            countryLabels: "countryLabels";
                            houseNumbers: "houseNumbers";
                            land: "land";
                            placeLabels: "placeLabels";
                            roadLabels: "roadLabels";
                            roadLines: "roadLines";
                            roadShields: "roadShields";
                            smallerTownLabels: "smallerTownLabels";
                            stateLabels: "stateLabels";
                            water: "water";
                        },
                    >,
                >;
                visible: ZodBoolean;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        layerGroups: ZodArray<ZodString>;
                        success: ZodLiteral<true>;
                        visible: ZodBoolean;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    togglePOIs: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeTogglePOIs;
        inputSchema: ZodObject<
            {
                allMapPOIsVisible: ZodOptional<ZodBoolean>;
                filterCategories: ZodOptional<
                    ZodObject<
                        {
                            show: ZodEnum<{ all_except: "all_except"; only: "only" }>;
                            values: ZodArray<ZodString>;
                        },
                        $strip,
                    >,
                >;
                reset: ZodOptional<ZodBoolean>;
            },
            $strip,
        >;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    {
                        allMapPOIsVisible: ZodOptional<ZodBoolean>;
                        filterCategories: ZodOptional<
                            ZodObject<
                                { show: ZodEnum<(...)>; values: ZodArray<(...)> },
                                $strip,
                            >,
                        >;
                        reset: ZodOptional<ZodBoolean>;
                        success: ZodLiteral<true>;
                    },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    toggleTrafficFlow: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeToggleTrafficFlow;
        inputSchema: ZodObject<{ visible: ZodBoolean }, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    { success: ZodLiteral<true>; trafficFlowVisible: ZodBoolean },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    toggleTrafficIncidents: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeToggleTrafficIncidents;
        inputSchema: ZodObject<{ visible: ZodBoolean }, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<
                    { success: ZodLiteral<true>; trafficIncidentsVisible: ZodBoolean },
                    $strip,
                >,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
    zoomInOrOut: {
        classificationPrompt: string;
        description: string;
        examplePrompts: string[];
        examples: string[];
        execute: typeof executeZoomInOrOut;
        inputSchema: ZodObject<{ delta: ZodNumber }, $strip>;
        outputSchema: ZodUnion<
            readonly [
                ZodObject<{ zoom: ZodNumber }, $strip>,
                ZodObject<{ error: ZodString }, $strip>,
            ],
        >;
        relatedTools: string[];
        tags: string[];
    };
}