@mapbox/mcp-server 0.11.0 → 0.12.3

package/dist/esm/tools/length-tool/LengthTool.input.schema.d.ts

@@ -1,13 +1,12 @@
 import { z } from 'zod';
 export declare const LengthInputSchema: z.ZodObject<{
-    coordinates: z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">;
-    units: z.ZodDefault<z.ZodEnum<["kilometers", "miles", "meters", "feet"]>>;
-}, "strip", z.ZodTypeAny, {
-    units: "kilometers" | "miles" | "meters" | "feet";
-    coordinates: number[][];
-}, {
-    coordinates: number[][];
-    units?: "kilometers" | "miles" | "meters" | "feet" | undefined;
-}>;
+    coordinates: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+    units: z.ZodDefault<z.ZodEnum<{
+        kilometers: "kilometers";
+        miles: "miles";
+        meters: "meters";
+        feet: "feet";
+    }>>;
+}, z.core.$strip>;
 export type LengthInput = z.infer<typeof LengthInputSchema>;
 //# sourceMappingURL=LengthTool.input.schema.d.ts.map

package/dist/esm/tools/length-tool/LengthTool.input.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LengthTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/length-tool/LengthTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,iBAAiB;;;;;;;;;EAU5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
+{"version":3,"file":"LengthTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/length-tool/LengthTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,iBAAiB;;;;;;;;iBAU5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/esm/tools/length-tool/LengthTool.output.schema.d.ts

@@ -3,14 +3,6 @@ export declare const LengthOutputSchema: z.ZodObject<{
     length: z.ZodNumber;
     units: z.ZodString;
     num_coordinates: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    length: number;
-    units: string;
-    num_coordinates: number;
-}, {
-    length: number;
-    units: string;
-    num_coordinates: number;
-}>;
+}, z.core.$strip>;
 export type LengthOutput = z.infer<typeof LengthOutputSchema>;
 //# sourceMappingURL=LengthTool.output.schema.d.ts.map

package/dist/esm/tools/length-tool/LengthTool.output.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LengthTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/length-tool/LengthTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAM7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
+{"version":3,"file":"LengthTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/length-tool/LengthTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;iBAM7B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/esm/tools/map-matching-tool/MapMatchingTool.input.schema.d.ts

@@ -3,41 +3,31 @@ export declare const MapMatchingInputSchema: z.ZodObject<{
     coordinates: z.ZodArray<z.ZodObject<{
         longitude: z.ZodNumber;
         latitude: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        longitude: number;
-        latitude: number;
-    }, {
-        longitude: number;
-        latitude: number;
-    }>, "many">;
-    profile: z.ZodDefault<z.ZodEnum<["driving", "driving-traffic", "walking", "cycling"]>>;
-    timestamps: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
-    radiuses: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
-    annotations: z.ZodOptional<z.ZodArray<z.ZodEnum<["speed", "distance", "duration", "congestion"]>, "many">>;
-    overview: z.ZodDefault<z.ZodEnum<["full", "simplified", "false"]>>;
-    geometries: z.ZodDefault<z.ZodEnum<["geojson", "polyline", "polyline6"]>>;
-}, "strip", z.ZodTypeAny, {
-    coordinates: {
-        longitude: number;
-        latitude: number;
-    }[];
-    geometries: "geojson" | "polyline" | "polyline6";
-    overview: "false" | "simplified" | "full";
-    profile: "driving" | "driving-traffic" | "walking" | "cycling";
-    annotations?: ("duration" | "distance" | "speed" | "congestion")[] | undefined;
-    timestamps?: number[] | undefined;
-    radiuses?: number[] | undefined;
-}, {
-    coordinates: {
-        longitude: number;
-        latitude: number;
-    }[];
-    annotations?: ("duration" | "distance" | "speed" | "congestion")[] | undefined;
-    geometries?: "geojson" | "polyline" | "polyline6" | undefined;
-    overview?: "false" | "simplified" | "full" | undefined;
-    profile?: "driving" | "driving-traffic" | "walking" | "cycling" | undefined;
-    timestamps?: number[] | undefined;
-    radiuses?: number[] | undefined;
-}>;
+    }, z.core.$strip>>;
+    profile: z.ZodDefault<z.ZodEnum<{
+        driving: "driving";
+        "driving-traffic": "driving-traffic";
+        walking: "walking";
+        cycling: "cycling";
+    }>>;
+    timestamps: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    radiuses: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    annotations: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        duration: "duration";
+        distance: "distance";
+        speed: "speed";
+        congestion: "congestion";
+    }>>>;
+    overview: z.ZodDefault<z.ZodEnum<{
+        false: "false";
+        simplified: "simplified";
+        full: "full";
+    }>>;
+    geometries: z.ZodDefault<z.ZodEnum<{
+        geojson: "geojson";
+        polyline: "polyline";
+        polyline6: "polyline6";
+    }>>;
+}, z.core.$strip>;
 export type MapMatchingInput = z.infer<typeof MapMatchingInputSchema>;
 //# sourceMappingURL=MapMatchingTool.input.schema.d.ts.map

package/dist/esm/tools/map-matching-tool/MapMatchingTool.input.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MapMatchingTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/map-matching-tool/MapMatchingTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiEjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}
+{"version":3,"file":"MapMatchingTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/map-matching-tool/MapMatchingTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/esm/tools/map-matching-tool/MapMatchingTool.output.schema.d.ts

@@ -5,166 +5,28 @@ export declare const MapMatchingOutputSchema: z.ZodObject<{
         confidence: z.ZodNumber;
         distance: z.ZodNumber;
         duration: z.ZodNumber;
-        geometry: z.ZodUnion<[z.ZodObject<{
+        geometry: z.ZodUnion<readonly [z.ZodObject<{
             type: z.ZodLiteral<"LineString">;
-            coordinates: z.ZodArray<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            type: "LineString";
-            coordinates: ([number, number] | [number, number, number])[];
-        }, {
-            type: "LineString";
-            coordinates: ([number, number] | [number, number, number])[];
-        }>, z.ZodString]>;
+            coordinates: z.ZodArray<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>]>>;
+        }, z.core.$strip>, z.ZodString]>;
         legs: z.ZodOptional<z.ZodArray<z.ZodObject<{
             distance: z.ZodNumber;
             duration: z.ZodNumber;
             annotation: z.ZodOptional<z.ZodObject<{
-                speed: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
-                distance: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
-                duration: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
-                congestion: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-            }, "strip", z.ZodTypeAny, {
-                duration?: number[] | undefined;
-                distance?: number[] | undefined;
-                speed?: number[] | undefined;
-                congestion?: string[] | undefined;
-            }, {
-                duration?: number[] | undefined;
-                distance?: number[] | undefined;
-                speed?: number[] | undefined;
-                congestion?: string[] | undefined;
-            }>>;
-        }, "strip", z.ZodTypeAny, {
-            duration: number;
-            distance: number;
-            annotation?: {
-                duration?: number[] | undefined;
-                distance?: number[] | undefined;
-                speed?: number[] | undefined;
-                congestion?: string[] | undefined;
-            } | undefined;
-        }, {
-            duration: number;
-            distance: number;
-            annotation?: {
-                duration?: number[] | undefined;
-                distance?: number[] | undefined;
-                speed?: number[] | undefined;
-                congestion?: string[] | undefined;
-            } | undefined;
-        }>, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        duration: number;
-        geometry: string | {
-            type: "LineString";
-            coordinates: ([number, number] | [number, number, number])[];
-        };
-        distance: number;
-        confidence: number;
-        legs?: {
-            duration: number;
-            distance: number;
-            annotation?: {
-                duration?: number[] | undefined;
-                distance?: number[] | undefined;
-                speed?: number[] | undefined;
-                congestion?: string[] | undefined;
-            } | undefined;
-        }[] | undefined;
-    }, {
-        duration: number;
-        geometry: string | {
-            type: "LineString";
-            coordinates: ([number, number] | [number, number, number])[];
-        };
-        distance: number;
-        confidence: number;
-        legs?: {
-            duration: number;
-            distance: number;
-            annotation?: {
-                duration?: number[] | undefined;
-                distance?: number[] | undefined;
-                speed?: number[] | undefined;
-                congestion?: string[] | undefined;
-            } | undefined;
-        }[] | undefined;
-    }>, "many">;
+                speed: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                distance: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                duration: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                congestion: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
     tracepoints: z.ZodArray<z.ZodNullable<z.ZodObject<{
         name: z.ZodOptional<z.ZodString>;
         location: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
         waypoint_index: z.ZodOptional<z.ZodNumber>;
         matchings_index: z.ZodNumber;
         alternatives_count: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        location: [number, number];
-        matchings_index: number;
-        alternatives_count: number;
-        name?: string | undefined;
-        waypoint_index?: number | undefined;
-    }, {
-        location: [number, number];
-        matchings_index: number;
-        alternatives_count: number;
-        name?: string | undefined;
-        waypoint_index?: number | undefined;
-    }>>, "many">;
-}, "strip", z.ZodTypeAny, {
-    code: string;
-    matchings: {
-        duration: number;
-        geometry: string | {
-            type: "LineString";
-            coordinates: ([number, number] | [number, number, number])[];
-        };
-        distance: number;
-        confidence: number;
-        legs?: {
-            duration: number;
-            distance: number;
-            annotation?: {
-                duration?: number[] | undefined;
-                distance?: number[] | undefined;
-                speed?: number[] | undefined;
-                congestion?: string[] | undefined;
-            } | undefined;
-        }[] | undefined;
-    }[];
-    tracepoints: ({
-        location: [number, number];
-        matchings_index: number;
-        alternatives_count: number;
-        name?: string | undefined;
-        waypoint_index?: number | undefined;
-    } | null)[];
-}, {
-    code: string;
-    matchings: {
-        duration: number;
-        geometry: string | {
-            type: "LineString";
-            coordinates: ([number, number] | [number, number, number])[];
-        };
-        distance: number;
-        confidence: number;
-        legs?: {
-            duration: number;
-            distance: number;
-            annotation?: {
-                duration?: number[] | undefined;
-                distance?: number[] | undefined;
-                speed?: number[] | undefined;
-                congestion?: string[] | undefined;
-            } | undefined;
-        }[] | undefined;
-    }[];
-    tracepoints: ({
-        location: [number, number];
-        matchings_index: number;
-        alternatives_count: number;
-        name?: string | undefined;
-        waypoint_index?: number | undefined;
-    } | null)[];
-}>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 export type MapMatchingOutput = z.infer<typeof MapMatchingOutputSchema>;
 //# sourceMappingURL=MapMatchingTool.output.schema.d.ts.map

package/dist/esm/tools/map-matching-tool/MapMatchingTool.output.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MapMatchingTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/map-matching-tool/MapMatchingTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8CxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}
+{"version":3,"file":"MapMatchingTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/map-matching-tool/MapMatchingTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8CxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/esm/tools/matrix-tool/MatrixTool.input.schema.d.ts

@@ -3,40 +3,22 @@ export declare const MatrixInputSchema: z.ZodObject<{
     coordinates: z.ZodArray<z.ZodObject<{
         longitude: z.ZodNumber;
         latitude: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        longitude: number;
-        latitude: number;
-    }, {
-        longitude: number;
-        latitude: number;
-    }>, "many">;
-    profile: z.ZodEnum<["mapbox/driving-traffic", "mapbox/driving", "mapbox/walking", "mapbox/cycling"]>;
-    annotations: z.ZodOptional<z.ZodEnum<["duration", "distance", "duration,distance", "distance,duration"]>>;
+    }, z.core.$strip>>;
+    profile: z.ZodEnum<{
+        "mapbox/driving-traffic": "mapbox/driving-traffic";
+        "mapbox/driving": "mapbox/driving";
+        "mapbox/walking": "mapbox/walking";
+        "mapbox/cycling": "mapbox/cycling";
+    }>;
+    annotations: z.ZodOptional<z.ZodEnum<{
+        duration: "duration";
+        distance: "distance";
+        "duration,distance": "duration,distance";
+        "distance,duration": "distance,duration";
+    }>>;
     approaches: z.ZodOptional<z.ZodString>;
     bearings: z.ZodOptional<z.ZodString>;
     destinations: z.ZodOptional<z.ZodString>;
     sources: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    coordinates: {
-        longitude: number;
-        latitude: number;
-    }[];
-    profile: "mapbox/driving-traffic" | "mapbox/driving" | "mapbox/walking" | "mapbox/cycling";
-    annotations?: "duration" | "distance" | "duration,distance" | "distance,duration" | undefined;
-    bearings?: string | undefined;
-    destinations?: string | undefined;
-    approaches?: string | undefined;
-    sources?: string | undefined;
-}, {
-    coordinates: {
-        longitude: number;
-        latitude: number;
-    }[];
-    profile: "mapbox/driving-traffic" | "mapbox/driving" | "mapbox/walking" | "mapbox/cycling";
-    annotations?: "duration" | "distance" | "duration,distance" | "distance,duration" | undefined;
-    bearings?: string | undefined;
-    destinations?: string | undefined;
-    approaches?: string | undefined;
-    sources?: string | undefined;
-}>;
+}, z.core.$strip>;
 //# sourceMappingURL=MatrixTool.input.schema.d.ts.map

package/dist/esm/tools/matrix-tool/MatrixTool.input.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MatrixTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/matrix-tool/MatrixTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8D5B,CAAC"}
+{"version":3,"file":"MatrixTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/matrix-tool/MatrixTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;iBA8D5B,CAAC"}

package/dist/esm/tools/matrix-tool/MatrixTool.output.schema.d.ts

@@ -3,77 +3,23 @@ declare const MatrixWaypointSchema: z.ZodObject<{
     name: z.ZodString;
     location: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
     distance: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    distance: number;
-    location: [number, number];
-}, {
-    name: string;
-    distance: number;
-    location: [number, number];
-}>;
+}, z.core.$strip>;
 export declare const MatrixResponseSchema: z.ZodObject<{
     code: z.ZodString;
-    durations: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNullable<z.ZodNumber>, "many">, "many">>;
-    distances: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNullable<z.ZodNumber>, "many">, "many">>;
+    durations: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNullable<z.ZodNumber>>>>;
+    distances: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNullable<z.ZodNumber>>>>;
     sources: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         location: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
         distance: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        distance: number;
-        location: [number, number];
-    }, {
-        name: string;
-        distance: number;
-        location: [number, number];
-    }>, "many">;
+    }, z.core.$strip>>;
     destinations: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         location: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
         distance: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        name: string;
-        distance: number;
-        location: [number, number];
-    }, {
-        name: string;
-        distance: number;
-        location: [number, number];
-    }>, "many">;
+    }, z.core.$strip>>;
     message: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    code: string;
-    destinations: {
-        name: string;
-        distance: number;
-        location: [number, number];
-    }[];
-    sources: {
-        name: string;
-        distance: number;
-        location: [number, number];
-    }[];
-    message?: string | undefined;
-    durations?: (number | null)[][] | undefined;
-    distances?: (number | null)[][] | undefined;
-}, {
-    code: string;
-    destinations: {
-        name: string;
-        distance: number;
-        location: [number, number];
-    }[];
-    sources: {
-        name: string;
-        distance: number;
-        location: [number, number];
-    }[];
-    message?: string | undefined;
-    durations?: (number | null)[][] | undefined;
-    distances?: (number | null)[][] | undefined;
-}>;
+}, z.core.$strip>;
 export type MatrixResponse = z.infer<typeof MatrixResponseSchema>;
 export type MatrixWaypoint = z.infer<typeof MatrixWaypointSchema>;
 export {};

package/dist/esm/tools/matrix-tool/MatrixTool.output.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MatrixTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/matrix-tool/MatrixTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,QAAA,MAAM,oBAAoB;;;;;;;;;;;;EAIxB,CAAC;AAGH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"MatrixTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/matrix-tool/MatrixTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,QAAA,MAAM,oBAAoB;;;;iBAIxB,CAAC;AAGH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;iBAO/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/esm/tools/midpoint-tool/MidpointTool.input.schema.d.ts

@@ -6,42 +6,12 @@ export declare const MidpointInputSchema: z.ZodObject<{
     from: z.ZodObject<{
         longitude: z.ZodNumber;
         latitude: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        longitude: number;
-        latitude: number;
-    }, {
-        longitude: number;
-        latitude: number;
-    }>;
+    }, z.z.core.$strip>;
     to: z.ZodObject<{
         longitude: z.ZodNumber;
         latitude: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        longitude: number;
-        latitude: number;
-    }, {
-        longitude: number;
-        latitude: number;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    from: {
-        longitude: number;
-        latitude: number;
-    };
-    to: {
-        longitude: number;
-        latitude: number;
-    };
-}, {
-    from: {
-        longitude: number;
-        latitude: number;
-    };
-    to: {
-        longitude: number;
-        latitude: number;
-    };
-}>;
+    }, z.z.core.$strip>;
+}, z.z.core.$strip>;
 /**
  * Type inference for MidpointInput
  */

package/dist/esm/tools/midpoint-tool/MidpointTool.input.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MidpointTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/midpoint-tool/MidpointTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa9B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}
+{"version":3,"file":"MidpointTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/midpoint-tool/MidpointTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;mBAa9B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/esm/tools/midpoint-tool/MidpointTool.output.schema.d.ts

@@ -6,60 +6,16 @@ export declare const MidpointOutputSchema: z.ZodObject<{
     midpoint: z.ZodObject<{
         longitude: z.ZodNumber;
         latitude: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        longitude: number;
-        latitude: number;
-    }, {
-        longitude: number;
-        latitude: number;
-    }>;
+    }, z.core.$strip>;
     from: z.ZodObject<{
         longitude: z.ZodNumber;
         latitude: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        longitude: number;
-        latitude: number;
-    }, {
-        longitude: number;
-        latitude: number;
-    }>;
+    }, z.core.$strip>;
     to: z.ZodObject<{
         longitude: z.ZodNumber;
         latitude: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        longitude: number;
-        latitude: number;
-    }, {
-        longitude: number;
-        latitude: number;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    from: {
-        longitude: number;
-        latitude: number;
-    };
-    to: {
-        longitude: number;
-        latitude: number;
-    };
-    midpoint: {
-        longitude: number;
-        latitude: number;
-    };
-}, {
-    from: {
-        longitude: number;
-        latitude: number;
-    };
-    to: {
-        longitude: number;
-        latitude: number;
-    };
-    midpoint: {
-        longitude: number;
-        latitude: number;
-    };
-}>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 /**
  * Type inference for MidpointOutput
  */

package/dist/esm/tools/midpoint-tool/MidpointTool.output.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MidpointTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/midpoint-tool/MidpointTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa/B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"MidpointTool.output.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/midpoint-tool/MidpointTool.output.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;iBAa/B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/esm/tools/nearest-point-on-line-tool/NearestPointOnLineTool.input.schema.d.ts

@@ -3,29 +3,14 @@ export declare const NearestPointOnLineInputSchema: z.ZodObject<{
     point: z.ZodObject<{
         longitude: z.ZodNumber;
         latitude: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        longitude: number;
-        latitude: number;
-    }, {
-        longitude: number;
-        latitude: number;
-    }>;
-    line: z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">;
-    units: z.ZodDefault<z.ZodEnum<["kilometers", "miles", "meters", "feet"]>>;
-}, "strip", z.ZodTypeAny, {
-    units: "kilometers" | "miles" | "meters" | "feet";
-    point: {
-        longitude: number;
-        latitude: number;
-    };
-    line: number[][];
-}, {
-    point: {
-        longitude: number;
-        latitude: number;
-    };
-    line: number[][];
-    units?: "kilometers" | "miles" | "meters" | "feet" | undefined;
-}>;
+    }, z.core.$strip>;
+    line: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+    units: z.ZodDefault<z.ZodEnum<{
+        kilometers: "kilometers";
+        miles: "miles";
+        meters: "meters";
+        feet: "feet";
+    }>>;
+}, z.core.$strip>;
 export type NearestPointOnLineInput = z.infer<typeof NearestPointOnLineInputSchema>;
 //# sourceMappingURL=NearestPointOnLineTool.input.schema.d.ts.map

package/dist/esm/tools/nearest-point-on-line-tool/NearestPointOnLineTool.input.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NearestPointOnLineTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/nearest-point-on-line-tool/NearestPointOnLineTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC"}
+{"version":3,"file":"NearestPointOnLineTool.input.schema.d.ts","sourceRoot":"","sources":["../../../../src/tools/nearest-point-on-line-tool/NearestPointOnLineTool.input.schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,6BAA6B;;;;;;;;;;;;iBAiBxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC"}