@deepintel-ltd/farmpro-contracts 1.3.1 → 1.3.4

package/dist/schemas/field-observations.schemas.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.observationStatsQuerySchema = exports.observationListQuerySchema = exports.observationListResponseSchema = exports.observationResponseSchema = exports.updateObservationActionInputSchema = exports.createObservationInputSchema = exports.observationResourceSchema = exports.updateObservationActionAttributesSchema = exports.createObservationAttributesSchema = exports.observationAttributesSchema = void 0;
 const zod_1 = require("zod");
 const common_schemas_1 = require("./common.schemas");
+const recommendations_schemas_1 = require("./recommendations.schemas");
 /**
  * Field Observation schemas - JSON:API compliant
  */
@@ -83,30 +84,7 @@ exports.observationAttributesSchema = zod_1.z.object({
         historicalMatches: zod_1.z.array(zod_1.z.any()).optional(),
     })
         .nullable(),
-    recommendations: zod_1.z
-        .array(zod_1.z.object({
-        priority: zod_1.z.number(),
-        action: zod_1.z.string(),
-        details: zod_1.z.string(),
-        timing: zod_1.z.string(),
-        materials: zod_1.z
-            .array(zod_1.z.object({
-            inventoryItemId: zod_1.z.string().uuid().optional(),
-            name: zod_1.z.string(),
-            quantity: zod_1.z.number(),
-            unit: zod_1.z.string(),
-            costPerUnit: zod_1.z.number().optional(),
-            totalCost: zod_1.z.number().optional(),
-            availability: zod_1.z.string().optional(),
-        }))
-            .optional(),
-        applicationMethod: zod_1.z.string().optional(),
-        expectedOutcome: zod_1.z.string().optional(),
-        preventiveMeasures: zod_1.z.array(zod_1.z.string()).optional(),
-        estimatedTime: zod_1.z.string().optional(),
-        riskLevel: zod_1.z.string().optional(),
-    }))
-        .nullable(),
+    recommendations: zod_1.z.array(recommendations_schemas_1.recommendationSchema).nullable(),
     estimatedCost: zod_1.z.number().nullable(),
     urgencyScore: zod_1.z.number().min(1).max(10).nullable(),
     similarCasesCount: zod_1.z.number().nullable(),

package/dist/schemas/health.schemas.d.ts

@@ -0,0 +1,176 @@
+import { z } from 'zod';
+/**
+ * Health status for individual services
+ */
+export declare const serviceHealthSchema: z.ZodObject<{
+    status: z.ZodEnum<["healthy", "unhealthy", "degraded"]>;
+    message: z.ZodOptional<z.ZodString>;
+    responseTime: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status: "healthy" | "unhealthy" | "degraded";
+    message?: string | undefined;
+    responseTime?: number | undefined;
+}, {
+    status: "healthy" | "unhealthy" | "degraded";
+    message?: string | undefined;
+    responseTime?: number | undefined;
+}>;
+/**
+ * Overall health check response
+ */
+export declare const healthCheckResponseSchema: z.ZodObject<{
+    status: z.ZodEnum<["healthy", "unhealthy", "degraded"]>;
+    timestamp: z.ZodString;
+    uptime: z.ZodNumber;
+    services: z.ZodObject<{
+        database: z.ZodObject<{
+            status: z.ZodEnum<["healthy", "unhealthy", "degraded"]>;
+            message: z.ZodOptional<z.ZodString>;
+            responseTime: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        }, {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        }>;
+        redis: z.ZodObject<{
+            status: z.ZodEnum<["healthy", "unhealthy", "degraded"]>;
+            message: z.ZodOptional<z.ZodString>;
+            responseTime: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        }, {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        }>;
+        storage: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<["healthy", "unhealthy", "degraded"]>;
+            message: z.ZodOptional<z.ZodString>;
+            responseTime: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        }, {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        }>>;
+        timescale: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<["healthy", "unhealthy", "degraded"]>;
+            message: z.ZodOptional<z.ZodString>;
+            responseTime: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        }, {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        database: {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        };
+        redis: {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        };
+        storage?: {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        } | undefined;
+        timescale?: {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        } | undefined;
+    }, {
+        database: {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        };
+        redis: {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        };
+        storage?: {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        } | undefined;
+        timescale?: {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    status: "healthy" | "unhealthy" | "degraded";
+    timestamp: string;
+    uptime: number;
+    services: {
+        database: {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        };
+        redis: {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        };
+        storage?: {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        } | undefined;
+        timescale?: {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        } | undefined;
+    };
+}, {
+    status: "healthy" | "unhealthy" | "degraded";
+    timestamp: string;
+    uptime: number;
+    services: {
+        database: {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        };
+        redis: {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        };
+        storage?: {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        } | undefined;
+        timescale?: {
+            status: "healthy" | "unhealthy" | "degraded";
+            message?: string | undefined;
+            responseTime?: number | undefined;
+        } | undefined;
+    };
+}>;
+export type ServiceHealth = z.infer<typeof serviceHealthSchema>;
+export type HealthCheckResponse = z.infer<typeof healthCheckResponseSchema>;
+//# sourceMappingURL=health.schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"health.schemas.d.ts","sourceRoot":"","sources":["../../src/schemas/health.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAI9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUpC,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/schemas/health.schemas.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.healthCheckResponseSchema = exports.serviceHealthSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Health status for individual services
+ */
+exports.serviceHealthSchema = zod_1.z.object({
+    status: zod_1.z.enum(['healthy', 'unhealthy', 'degraded']),
+    message: zod_1.z.string().optional(),
+    responseTime: zod_1.z.number().optional(), // in milliseconds
+});
+/**
+ * Overall health check response
+ */
+exports.healthCheckResponseSchema = zod_1.z.object({
+    status: zod_1.z.enum(['healthy', 'unhealthy', 'degraded']),
+    timestamp: zod_1.z.string().datetime(),
+    uptime: zod_1.z.number(), // in seconds
+    services: zod_1.z.object({
+        database: exports.serviceHealthSchema,
+        redis: exports.serviceHealthSchema,
+        storage: exports.serviceHealthSchema.optional(),
+        timescale: exports.serviceHealthSchema.optional(),
+    }),
+});

package/dist/schemas/recommendations.schemas.d.ts

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+/**
+ * Centralized Recommendation Schemas
+ */
+export declare const recommendationMaterialSchema: z.ZodObject<{
+    inventoryItemId: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    quantity: z.ZodNumber;
+    unit: z.ZodString;
+    costPerUnit: z.ZodOptional<z.ZodNumber>;
+    totalCost: z.ZodOptional<z.ZodNumber>;
+    availability: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    unit: string;
+    quantity: number;
+    inventoryItemId?: string | undefined;
+    totalCost?: number | undefined;
+    costPerUnit?: number | undefined;
+    availability?: string | undefined;
+}, {
+    name: string;
+    unit: string;
+    quantity: number;
+    inventoryItemId?: string | undefined;
+    totalCost?: number | undefined;
+    costPerUnit?: number | undefined;
+    availability?: string | undefined;
+}>;
+export declare const recommendationSchema: z.ZodObject<{
+    priority: z.ZodNumber;
+    action: z.ZodString;
+    details: z.ZodString;
+    timing: z.ZodString;
+    severity: z.ZodOptional<z.ZodEnum<["low", "medium", "high", "critical"]>>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    materials: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        inventoryItemId: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        quantity: z.ZodNumber;
+        unit: z.ZodString;
+        costPerUnit: z.ZodOptional<z.ZodNumber>;
+        totalCost: z.ZodOptional<z.ZodNumber>;
+        availability: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        unit: string;
+        quantity: number;
+        inventoryItemId?: string | undefined;
+        totalCost?: number | undefined;
+        costPerUnit?: number | undefined;
+        availability?: string | undefined;
+    }, {
+        name: string;
+        unit: string;
+        quantity: number;
+        inventoryItemId?: string | undefined;
+        totalCost?: number | undefined;
+        costPerUnit?: number | undefined;
+        availability?: string | undefined;
+    }>, "many">>;
+    applicationMethod: z.ZodOptional<z.ZodString>;
+    expectedOutcome: z.ZodOptional<z.ZodString>;
+    preventiveMeasures: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    estimatedTime: z.ZodOptional<z.ZodString>;
+    riskLevel: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    priority: number;
+    action: string;
+    details: string;
+    timing: string;
+    severity?: "critical" | "low" | "medium" | "high" | undefined;
+    confidence?: number | undefined;
+    materials?: {
+        name: string;
+        unit: string;
+        quantity: number;
+        inventoryItemId?: string | undefined;
+        totalCost?: number | undefined;
+        costPerUnit?: number | undefined;
+        availability?: string | undefined;
+    }[] | undefined;
+    applicationMethod?: string | undefined;
+    expectedOutcome?: string | undefined;
+    preventiveMeasures?: string[] | undefined;
+    estimatedTime?: string | undefined;
+    riskLevel?: string | undefined;
+}, {
+    priority: number;
+    action: string;
+    details: string;
+    timing: string;
+    severity?: "critical" | "low" | "medium" | "high" | undefined;
+    confidence?: number | undefined;
+    materials?: {
+        name: string;
+        unit: string;
+        quantity: number;
+        inventoryItemId?: string | undefined;
+        totalCost?: number | undefined;
+        costPerUnit?: number | undefined;
+        availability?: string | undefined;
+    }[] | undefined;
+    applicationMethod?: string | undefined;
+    expectedOutcome?: string | undefined;
+    preventiveMeasures?: string[] | undefined;
+    estimatedTime?: string | undefined;
+    riskLevel?: string | undefined;
+}>;
+export type RecommendationMaterial = z.infer<typeof recommendationMaterialSchema>;
+export type Recommendation = z.infer<typeof recommendationSchema>;
+//# sourceMappingURL=recommendations.schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recommendations.schemas.d.ts","sourceRoot":"","sources":["../../src/schemas/recommendations.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AAGH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;EAQvC,CAAC;AAGH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa/B,CAAC;AAGH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/schemas/recommendations.schemas.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recommendationSchema = exports.recommendationMaterialSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Centralized Recommendation Schemas
+ */
+// Schema for materials suggested in a recommendation
+exports.recommendationMaterialSchema = zod_1.z.object({
+    inventoryItemId: zod_1.z.string().uuid().optional(),
+    name: zod_1.z.string(),
+    quantity: zod_1.z.number(),
+    unit: zod_1.z.string(),
+    costPerUnit: zod_1.z.number().optional(),
+    totalCost: zod_1.z.number().optional(),
+    availability: zod_1.z.string().optional(),
+});
+// The core, reusable recommendation schema
+exports.recommendationSchema = zod_1.z.object({
+    priority: zod_1.z.number().min(1).max(5),
+    action: zod_1.z.string(),
+    details: zod_1.z.string(),
+    timing: zod_1.z.string(),
+    severity: zod_1.z.enum(['low', 'medium', 'high', 'critical']).optional(),
+    confidence: zod_1.z.number().min(0).max(1).optional(),
+    materials: zod_1.z.array(exports.recommendationMaterialSchema).optional(),
+    applicationMethod: zod_1.z.string().optional(),
+    expectedOutcome: zod_1.z.string().optional(),
+    preventiveMeasures: zod_1.z.array(zod_1.z.string()).optional(),
+    estimatedTime: zod_1.z.string().optional(),
+    riskLevel: zod_1.z.string().optional(),
+});