@deepintel-ltd/farmpro-contracts 1.7.6 → 1.7.9

package/dist/schemas/livestock-map.schemas.d.ts

@@ -0,0 +1,328 @@
+import { z } from 'zod';
+export declare const livestockLocationSchema: z.ZodObject<{
+    id: z.ZodString;
+    livestockId: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodString>;
+    coordinates: z.ZodObject<{
+        lat: z.ZodNumber;
+        lng: z.ZodNumber;
+        accuracy: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        lat: number;
+        lng: number;
+        accuracy?: number | undefined;
+    }, {
+        lat: number;
+        lng: number;
+        accuracy?: number | undefined;
+    }>;
+    timestamp: z.ZodString;
+    source: z.ZodEnum<["gps_collar", "manual", "rfid_reader", "app"]>;
+    batteryLevel: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    coordinates: {
+        lat: number;
+        lng: number;
+        accuracy?: number | undefined;
+    };
+    id: string;
+    source: "manual" | "gps_collar" | "rfid_reader" | "app";
+    timestamp: string;
+    batteryLevel?: number | undefined;
+    groupId?: string | undefined;
+    livestockId?: string | undefined;
+}, {
+    coordinates: {
+        lat: number;
+        lng: number;
+        accuracy?: number | undefined;
+    };
+    id: string;
+    source: "manual" | "gps_collar" | "rfid_reader" | "app";
+    timestamp: string;
+    batteryLevel?: number | undefined;
+    groupId?: string | undefined;
+    livestockId?: string | undefined;
+}>;
+export declare const movementTrailPointSchema: z.ZodObject<{
+    lat: z.ZodNumber;
+    lng: z.ZodNumber;
+    timestamp: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    lat: number;
+    lng: number;
+}, {
+    timestamp: string;
+    lat: number;
+    lng: number;
+}>;
+export declare const livestockMovementTrailSchema: z.ZodObject<{
+    livestockId: z.ZodString;
+    points: z.ZodArray<z.ZodObject<{
+        lat: z.ZodNumber;
+        lng: z.ZodNumber;
+        timestamp: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        lat: number;
+        lng: number;
+    }, {
+        timestamp: string;
+        lat: number;
+        lng: number;
+    }>, "many">;
+    dateRange: z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        start: string;
+        end: string;
+    }, {
+        start: string;
+        end: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    dateRange: {
+        start: string;
+        end: string;
+    };
+    livestockId: string;
+    points: {
+        timestamp: string;
+        lat: number;
+        lng: number;
+    }[];
+}, {
+    dateRange: {
+        start: string;
+        end: string;
+    };
+    livestockId: string;
+    points: {
+        timestamp: string;
+        lat: number;
+        lng: number;
+    }[];
+}>;
+export declare const heatmapPointSchema: z.ZodObject<{
+    lat: z.ZodNumber;
+    lng: z.ZodNumber;
+    intensity: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    lat: number;
+    lng: number;
+    intensity: number;
+}, {
+    lat: number;
+    lng: number;
+    intensity: number;
+}>;
+export declare const grazingZoneSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    geometry: z.ZodObject<{
+        type: z.ZodEnum<["Polygon", "MultiPolygon", "Point", "LineString"]>;
+        coordinates: z.ZodUnion<[z.ZodArray<z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">, "many">, z.ZodArray<z.ZodArray<z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">, "many">, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "Polygon" | "MultiPolygon" | "Point" | "LineString";
+        coordinates: number[] | number[][] | number[][][] | number[][][][];
+    }, {
+        type: "Polygon" | "MultiPolygon" | "Point" | "LineString";
+        coordinates: number[] | number[][] | number[][][] | number[][][][];
+    }>;
+    type: z.ZodEnum<["paddock", "shelter", "water_source", "feeding_area"]>;
+    currentOccupancy: z.ZodOptional<z.ZodNumber>;
+    capacity: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "paddock" | "shelter" | "water_source" | "feeding_area";
+    id: string;
+    name: string;
+    geometry: {
+        type: "Polygon" | "MultiPolygon" | "Point" | "LineString";
+        coordinates: number[] | number[][] | number[][][] | number[][][][];
+    };
+    currentOccupancy?: number | undefined;
+    capacity?: number | undefined;
+}, {
+    type: "paddock" | "shelter" | "water_source" | "feeding_area";
+    id: string;
+    name: string;
+    geometry: {
+        type: "Polygon" | "MultiPolygon" | "Point" | "LineString";
+        coordinates: number[] | number[][] | number[][][] | number[][][][];
+    };
+    currentOccupancy?: number | undefined;
+    capacity?: number | undefined;
+}>;
+export declare const updateLocationBodySchema: z.ZodObject<{
+    coordinates: z.ZodObject<{
+        lat: z.ZodNumber;
+        lng: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        lat: number;
+        lng: number;
+    }, {
+        lat: number;
+        lng: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    coordinates: {
+        lat: number;
+        lng: number;
+    };
+}, {
+    coordinates: {
+        lat: number;
+        lng: number;
+    };
+}>;
+export declare const livestockLocationListResponseSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    livestockId: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodString>;
+    coordinates: z.ZodObject<{
+        lat: z.ZodNumber;
+        lng: z.ZodNumber;
+        accuracy: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        lat: number;
+        lng: number;
+        accuracy?: number | undefined;
+    }, {
+        lat: number;
+        lng: number;
+        accuracy?: number | undefined;
+    }>;
+    timestamp: z.ZodString;
+    source: z.ZodEnum<["gps_collar", "manual", "rfid_reader", "app"]>;
+    batteryLevel: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    coordinates: {
+        lat: number;
+        lng: number;
+        accuracy?: number | undefined;
+    };
+    id: string;
+    source: "manual" | "gps_collar" | "rfid_reader" | "app";
+    timestamp: string;
+    batteryLevel?: number | undefined;
+    groupId?: string | undefined;
+    livestockId?: string | undefined;
+}, {
+    coordinates: {
+        lat: number;
+        lng: number;
+        accuracy?: number | undefined;
+    };
+    id: string;
+    source: "manual" | "gps_collar" | "rfid_reader" | "app";
+    timestamp: string;
+    batteryLevel?: number | undefined;
+    groupId?: string | undefined;
+    livestockId?: string | undefined;
+}>, "many">;
+export declare const movementTrailListResponseSchema: z.ZodArray<z.ZodObject<{
+    livestockId: z.ZodString;
+    points: z.ZodArray<z.ZodObject<{
+        lat: z.ZodNumber;
+        lng: z.ZodNumber;
+        timestamp: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        lat: number;
+        lng: number;
+    }, {
+        timestamp: string;
+        lat: number;
+        lng: number;
+    }>, "many">;
+    dateRange: z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        start: string;
+        end: string;
+    }, {
+        start: string;
+        end: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    dateRange: {
+        start: string;
+        end: string;
+    };
+    livestockId: string;
+    points: {
+        timestamp: string;
+        lat: number;
+        lng: number;
+    }[];
+}, {
+    dateRange: {
+        start: string;
+        end: string;
+    };
+    livestockId: string;
+    points: {
+        timestamp: string;
+        lat: number;
+        lng: number;
+    }[];
+}>, "many">;
+export declare const heatmapResponseSchema: z.ZodArray<z.ZodObject<{
+    lat: z.ZodNumber;
+    lng: z.ZodNumber;
+    intensity: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    lat: number;
+    lng: number;
+    intensity: number;
+}, {
+    lat: number;
+    lng: number;
+    intensity: number;
+}>, "many">;
+export declare const grazingZoneListResponseSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    geometry: z.ZodObject<{
+        type: z.ZodEnum<["Polygon", "MultiPolygon", "Point", "LineString"]>;
+        coordinates: z.ZodUnion<[z.ZodArray<z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">, "many">, z.ZodArray<z.ZodArray<z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">, "many">, "many">, z.ZodArray<z.ZodNumber, "many">, z.ZodArray<z.ZodArray<z.ZodNumber, "many">, "many">]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "Polygon" | "MultiPolygon" | "Point" | "LineString";
+        coordinates: number[] | number[][] | number[][][] | number[][][][];
+    }, {
+        type: "Polygon" | "MultiPolygon" | "Point" | "LineString";
+        coordinates: number[] | number[][] | number[][][] | number[][][][];
+    }>;
+    type: z.ZodEnum<["paddock", "shelter", "water_source", "feeding_area"]>;
+    currentOccupancy: z.ZodOptional<z.ZodNumber>;
+    capacity: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    type: "paddock" | "shelter" | "water_source" | "feeding_area";
+    id: string;
+    name: string;
+    geometry: {
+        type: "Polygon" | "MultiPolygon" | "Point" | "LineString";
+        coordinates: number[] | number[][] | number[][][] | number[][][][];
+    };
+    currentOccupancy?: number | undefined;
+    capacity?: number | undefined;
+}, {
+    type: "paddock" | "shelter" | "water_source" | "feeding_area";
+    id: string;
+    name: string;
+    geometry: {
+        type: "Polygon" | "MultiPolygon" | "Point" | "LineString";
+        coordinates: number[] | number[][] | number[][][] | number[][][][];
+    };
+    currentOccupancy?: number | undefined;
+    capacity?: number | undefined;
+}>, "many">;
+export type LivestockLocationResponse = z.infer<typeof livestockLocationSchema>;
+export type LivestockMovementTrailResponse = z.infer<typeof livestockMovementTrailSchema>;
+export type HeatmapPointResponse = z.infer<typeof heatmapPointSchema>;
+export type GrazingZoneResponse = z.infer<typeof grazingZoneSchema>;
+export type UpdateLocationBody = z.infer<typeof updateLocationBodySchema>;
+//# sourceMappingURL=livestock-map.schemas.d.ts.map

package/dist/schemas/livestock-map.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"livestock-map.schemas.d.ts","sourceRoot":"","sources":["../../src/schemas/livestock-map.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYlC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;EAInC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOvC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;EAI7B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO5B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;EAKnC,CAAC;AAEH,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAAmC,CAAC;AACpF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAAwC,CAAC;AACrF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;WAA8B,CAAC;AACjE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAA6B,CAAC;AAExE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAChF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAC1F,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACtE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AACpE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/schemas/livestock-map.schemas.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { geoJSONGeometrySchema } from './common.schemas';
+const locationSourceSchema = z.enum(['gps_collar', 'manual', 'rfid_reader', 'app']);
+export const livestockLocationSchema = z.object({
+    id: z.string().uuid(),
+    livestockId: z.string().uuid().optional(),
+    groupId: z.string().uuid().optional(),
+    coordinates: z.object({
+        lat: z.number(),
+        lng: z.number(),
+        accuracy: z.number().optional(),
+    }),
+    timestamp: z.string().datetime(),
+    source: locationSourceSchema,
+    batteryLevel: z.number().min(0).max(100).optional(),
+});
+export const movementTrailPointSchema = z.object({
+    lat: z.number(),
+    lng: z.number(),
+    timestamp: z.string().datetime(),
+});
+export const livestockMovementTrailSchema = z.object({
+    livestockId: z.string().uuid(),
+    points: z.array(movementTrailPointSchema),
+    dateRange: z.object({
+        start: z.string().datetime(),
+        end: z.string().datetime(),
+    }),
+});
+export const heatmapPointSchema = z.object({
+    lat: z.number(),
+    lng: z.number(),
+    intensity: z.number(),
+});
+export const grazingZoneSchema = z.object({
+    id: z.string().uuid(),
+    name: z.string(),
+    geometry: geoJSONGeometrySchema,
+    type: z.enum(['paddock', 'shelter', 'water_source', 'feeding_area']),
+    currentOccupancy: z.number().optional(),
+    capacity: z.number().optional(),
+});
+export const updateLocationBodySchema = z.object({
+    coordinates: z.object({
+        lat: z.number(),
+        lng: z.number(),
+    }),
+});
+export const livestockLocationListResponseSchema = z.array(livestockLocationSchema);
+export const movementTrailListResponseSchema = z.array(livestockMovementTrailSchema);
+export const heatmapResponseSchema = z.array(heatmapPointSchema);
+export const grazingZoneListResponseSchema = z.array(grazingZoneSchema);

package/dist/schemas/measurements.schemas.d.ts

@@ -0,0 +1,234 @@
+import { z } from 'zod';
+/**
+ * Measurement type enum matching Prisma MeasurementType
+ */
+export declare const measurementTypeSchema: z.ZodEnum<["DISTANCE", "AREA", "PERIMETER", "RADIUS"]>;
+/**
+ * Segment schema for multi-point measurements
+ */
+export declare const measurementSegmentSchema: z.ZodObject<{
+    distance: z.ZodNumber;
+    bearing: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    distance: number;
+    bearing?: number | undefined;
+}, {
+    distance: number;
+    bearing?: number | undefined;
+}>;
+/**
+ * Coordinate point schema [lat, lng]
+ */
+export declare const coordinatePointSchema: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+/**
+ * Measurement response schema
+ */
+export declare const measurementSchema: z.ZodObject<{
+    id: z.ZodString;
+    fieldId: z.ZodString;
+    farmId: z.ZodString;
+    type: z.ZodEnum<["DISTANCE", "AREA", "PERIMETER", "RADIUS"]>;
+    label: z.ZodNullable<z.ZodString>;
+    points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
+    result: z.ZodNumber;
+    unit: z.ZodString;
+    segments: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        distance: z.ZodNumber;
+        bearing: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        distance: number;
+        bearing?: number | undefined;
+    }, {
+        distance: number;
+        bearing?: number | undefined;
+    }>, "many">>;
+    createdBy: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "DISTANCE" | "AREA" | "PERIMETER" | "RADIUS";
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    farmId: string;
+    fieldId: string;
+    unit: string;
+    createdBy: string | null;
+    result: number;
+    label: string | null;
+    points: [number, number][];
+    segments: {
+        distance: number;
+        bearing?: number | undefined;
+    }[] | null;
+}, {
+    type: "DISTANCE" | "AREA" | "PERIMETER" | "RADIUS";
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    farmId: string;
+    fieldId: string;
+    unit: string;
+    createdBy: string | null;
+    result: number;
+    label: string | null;
+    points: [number, number][];
+    segments: {
+        distance: number;
+        bearing?: number | undefined;
+    }[] | null;
+}>;
+/**
+ * Create measurement request body schema
+ */
+export declare const createMeasurementBodySchema: z.ZodObject<{
+    type: z.ZodEnum<["DISTANCE", "AREA", "PERIMETER", "RADIUS"]>;
+    label: z.ZodOptional<z.ZodString>;
+    points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
+    result: z.ZodNumber;
+    unit: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "DISTANCE" | "AREA" | "PERIMETER" | "RADIUS";
+    unit: string;
+    result: number;
+    points: [number, number][];
+    label?: string | undefined;
+}, {
+    type: "DISTANCE" | "AREA" | "PERIMETER" | "RADIUS";
+    unit: string;
+    result: number;
+    points: [number, number][];
+    label?: string | undefined;
+}>;
+/**
+ * Query schema for filtering measurements by type
+ */
+export declare const measurementListQuerySchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodEnum<["DISTANCE", "AREA", "PERIMETER", "RADIUS"]>>;
+}, "strip", z.ZodTypeAny, {
+    type?: "DISTANCE" | "AREA" | "PERIMETER" | "RADIUS" | undefined;
+}, {
+    type?: "DISTANCE" | "AREA" | "PERIMETER" | "RADIUS" | undefined;
+}>;
+/**
+ * List response schema
+ */
+export declare const measurementListResponseSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    fieldId: z.ZodString;
+    farmId: z.ZodString;
+    type: z.ZodEnum<["DISTANCE", "AREA", "PERIMETER", "RADIUS"]>;
+    label: z.ZodNullable<z.ZodString>;
+    points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
+    result: z.ZodNumber;
+    unit: z.ZodString;
+    segments: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        distance: z.ZodNumber;
+        bearing: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        distance: number;
+        bearing?: number | undefined;
+    }, {
+        distance: number;
+        bearing?: number | undefined;
+    }>, "many">>;
+    createdBy: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "DISTANCE" | "AREA" | "PERIMETER" | "RADIUS";
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    farmId: string;
+    fieldId: string;
+    unit: string;
+    createdBy: string | null;
+    result: number;
+    label: string | null;
+    points: [number, number][];
+    segments: {
+        distance: number;
+        bearing?: number | undefined;
+    }[] | null;
+}, {
+    type: "DISTANCE" | "AREA" | "PERIMETER" | "RADIUS";
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    farmId: string;
+    fieldId: string;
+    unit: string;
+    createdBy: string | null;
+    result: number;
+    label: string | null;
+    points: [number, number][];
+    segments: {
+        distance: number;
+        bearing?: number | undefined;
+    }[] | null;
+}>, "many">;
+/**
+ * Single measurement response schema
+ */
+export declare const measurementSingleResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    fieldId: z.ZodString;
+    farmId: z.ZodString;
+    type: z.ZodEnum<["DISTANCE", "AREA", "PERIMETER", "RADIUS"]>;
+    label: z.ZodNullable<z.ZodString>;
+    points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, "many">;
+    result: z.ZodNumber;
+    unit: z.ZodString;
+    segments: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        distance: z.ZodNumber;
+        bearing: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        distance: number;
+        bearing?: number | undefined;
+    }, {
+        distance: number;
+        bearing?: number | undefined;
+    }>, "many">>;
+    createdBy: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "DISTANCE" | "AREA" | "PERIMETER" | "RADIUS";
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    farmId: string;
+    fieldId: string;
+    unit: string;
+    createdBy: string | null;
+    result: number;
+    label: string | null;
+    points: [number, number][];
+    segments: {
+        distance: number;
+        bearing?: number | undefined;
+    }[] | null;
+}, {
+    type: "DISTANCE" | "AREA" | "PERIMETER" | "RADIUS";
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    farmId: string;
+    fieldId: string;
+    unit: string;
+    createdBy: string | null;
+    result: number;
+    label: string | null;
+    points: [number, number][];
+    segments: {
+        distance: number;
+        bearing?: number | undefined;
+    }[] | null;
+}>;
+export type MeasurementType = z.infer<typeof measurementTypeSchema>;
+export type MeasurementSegment = z.infer<typeof measurementSegmentSchema>;
+export type MeasurementResponse = z.infer<typeof measurementSchema>;
+export type CreateMeasurementBody = z.infer<typeof createMeasurementBodySchema>;
+export type MeasurementListQuery = z.infer<typeof measurementListQuerySchema>;
+//# sourceMappingURL=measurements.schemas.d.ts.map

package/dist/schemas/measurements.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measurements.schemas.d.ts","sourceRoot":"","sources":["../../src/schemas/measurements.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,qBAAqB,wDAAsD,CAAC;AAEzF;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;EAGnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,qBAAqB,8CAAoC,CAAC;AAEvE;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;EAMtC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;;EAErC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAA6B,CAAC;AAExE;;GAEG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAoB,CAAC;AAGjE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AACpE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/dist/schemas/measurements.schemas.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+/**
+ * Measurement type enum matching Prisma MeasurementType
+ */
+export const measurementTypeSchema = z.enum(['DISTANCE', 'AREA', 'PERIMETER', 'RADIUS']);
+/**
+ * Segment schema for multi-point measurements
+ */
+export const measurementSegmentSchema = z.object({
+    distance: z.number(),
+    bearing: z.number().optional(),
+});
+/**
+ * Coordinate point schema [lat, lng]
+ */
+export const coordinatePointSchema = z.tuple([z.number(), z.number()]);
+/**
+ * Measurement response schema
+ */
+export const measurementSchema = z.object({
+    id: z.string().uuid(),
+    fieldId: z.string().uuid(),
+    farmId: z.string().uuid(),
+    type: measurementTypeSchema,
+    label: z.string().nullable(),
+    points: z.array(coordinatePointSchema),
+    result: z.number(),
+    unit: z.string(),
+    segments: z.array(measurementSegmentSchema).nullable(),
+    createdBy: z.string().uuid().nullable(),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+});
+/**
+ * Create measurement request body schema
+ */
+export const createMeasurementBodySchema = z.object({
+    type: measurementTypeSchema,
+    label: z.string().max(200).optional(),
+    points: z.array(coordinatePointSchema).min(1, 'At least one point is required'),
+    result: z.number(),
+    unit: z.string().max(20),
+});
+/**
+ * Query schema for filtering measurements by type
+ */
+export const measurementListQuerySchema = z.object({
+    type: measurementTypeSchema.optional(),
+});
+/**
+ * List response schema
+ */
+export const measurementListResponseSchema = z.array(measurementSchema);
+/**
+ * Single measurement response schema
+ */
+export const measurementSingleResponseSchema = measurementSchema;