@deepintel-ltd/farmpro-contracts 1.36.3 → 1.36.5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.ts +4 -3
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +2 -2
- package/dist/routes/accounting.routes.d.ts +18 -18
- package/dist/routes/agent-workflows.routes.d.ts +56 -56
- package/dist/routes/cooperative.routes.d.ts +6 -6
- package/dist/routes/crop-care.routes.d.ts +2 -2
- package/dist/routes/extension.routes.d.ts +18 -18
- package/dist/routes/farm-status.routes.d.ts +8 -8
- package/dist/routes/fertigation.routes.d.ts +556 -556
- package/dist/routes/field-monitoring.routes.d.ts +89 -89
- package/dist/routes/field-observations.routes.d.ts +50 -50
- package/dist/routes/index.d.ts +0 -3
- package/dist/routes/index.d.ts.map +1 -1
- package/dist/routes/index.js +0 -2
- package/dist/routes/integrations.routes.d.ts +4 -4
- package/dist/routes/inventory.routes.d.ts +966 -0
- package/dist/routes/inventory.routes.d.ts.map +1 -1
- package/dist/routes/invoices.routes.d.ts +30 -30
- package/dist/routes/irrigation.routes.d.ts +20 -20
- package/dist/routes/measurements.routes.d.ts +6 -6
- package/dist/routes/monitoring-visualization.routes.d.ts +16 -16
- package/dist/routes/nutrient-plan.routes.d.ts +1520 -350
- package/dist/routes/nutrient-plan.routes.d.ts.map +1 -1
- package/dist/routes/nutrient-plan.routes.js +46 -0
- package/dist/routes/orchard-plan.routes.d.ts +10 -10
- package/dist/routes/purchase-orders.routes.d.ts +6 -6
- package/dist/routes/session.routes.d.ts +36 -36
- package/dist/routes/soil-tests.routes.d.ts +126 -126
- package/dist/routes/team-payments.routes.d.ts +36 -36
- package/dist/routes/waybills.routes.d.ts +12 -12
- package/dist/routes/weather.routes.d.ts +12 -12
- package/dist/routes/yield-prediction.routes.d.ts +8 -8
- package/dist/schemas/accounting.schemas.d.ts +20 -20
- package/dist/schemas/agent-workflows.schemas.d.ts +64 -64
- package/dist/schemas/cooperative.schemas.d.ts +8 -8
- package/dist/schemas/crop-care.schemas.d.ts +2 -2
- package/dist/schemas/extension.schemas.d.ts +18 -18
- package/dist/schemas/farm-fertilizers.schemas.d.ts +1301 -0
- package/dist/schemas/farm-fertilizers.schemas.d.ts.map +1 -0
- package/dist/schemas/farm-fertilizers.schemas.js +175 -0
- package/dist/schemas/farm-status.schemas.d.ts +14 -14
- package/dist/schemas/fertigation-board.schemas.d.ts +356 -0
- package/dist/schemas/fertigation-board.schemas.d.ts.map +1 -0
- package/dist/schemas/fertigation-board.schemas.js +55 -0
- package/dist/schemas/fertigation.schemas.d.ts +214 -214
- package/dist/schemas/field-monitoring.schemas.d.ts +69 -69
- package/dist/schemas/field-observations.schemas.d.ts +34 -34
- package/dist/schemas/integrations.schemas.d.ts +6 -6
- package/dist/schemas/inventory.schemas.d.ts +1298 -0
- package/dist/schemas/inventory.schemas.d.ts.map +1 -1
- package/dist/schemas/inventory.schemas.js +7 -0
- package/dist/schemas/invoices.schemas.d.ts +18 -18
- package/dist/schemas/irrigation.schemas.d.ts +12 -12
- package/dist/schemas/measurements.schemas.d.ts +6 -6
- package/dist/schemas/monitoring-visualization.schemas.d.ts +16 -16
- package/dist/schemas/nutrient-plan.schemas.d.ts +98 -98
- package/dist/schemas/orchard-plan.schemas.d.ts +26 -26
- package/dist/schemas/purchase-orders.schemas.d.ts +6 -6
- package/dist/schemas/recommendations.schemas.d.ts +6 -6
- package/dist/schemas/session.schemas.d.ts +36 -36
- package/dist/schemas/soil-tests.schemas.d.ts +120 -120
- package/dist/schemas/team-payments.schemas.d.ts +30 -30
- package/dist/schemas/waybills.schemas.d.ts +12 -12
- package/dist/schemas/weather.schemas.d.ts +36 -36
- package/dist/schemas/yield-prediction.schemas.d.ts +4 -4
- package/package.json +1 -1
- package/dist/routes/fertilizer-stock.routes.d.ts +0 -868
- package/dist/routes/fertilizer-stock.routes.d.ts.map +0 -1
- package/dist/routes/fertilizer-stock.routes.js +0 -56
- package/dist/schemas/fertilizer-stock.schemas.d.ts +0 -855
- package/dist/schemas/fertilizer-stock.schemas.d.ts.map +0 -1
- package/dist/schemas/fertilizer-stock.schemas.js +0 -124
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"farm-fertilizers.schemas.d.ts","sourceRoot":"","sources":["../../src/schemas/farm-fertilizers.schemas.ts"],"names":[],"mappings":"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"}
|
|
@@ -0,0 +1,175 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
export const applicationMethodSchema = z.enum(['fertigation', 'foliar', 'soil']);
|
|
3
|
+
export const fertilizerFormSchema = z.enum(['soluble', 'granular', 'liquid']);
|
|
4
|
+
const percent = z.number().min(0).max(100);
|
|
5
|
+
/** Percent of product mass can never add up past 100, and a bag with no analysis cannot be dosed. */
|
|
6
|
+
const analysisAddsUp = (value) => {
|
|
7
|
+
const total = value.nitrogen + value.phosphorus + value.potassium + value.calcium + value.magnesium;
|
|
8
|
+
return total > 0 && total <= 100;
|
|
9
|
+
};
|
|
10
|
+
/** Bag analysis stored on a fertilizer supply item. Stock stays on the inventory item, in kilograms. */
|
|
11
|
+
export const fertilizerProfileInputSchema = z
|
|
12
|
+
.object({
|
|
13
|
+
brand: z.string().trim().max(100).nullable().optional(),
|
|
14
|
+
nitrogen: percent,
|
|
15
|
+
phosphorus: percent,
|
|
16
|
+
potassium: percent,
|
|
17
|
+
calcium: percent,
|
|
18
|
+
magnesium: percent,
|
|
19
|
+
sulfate: z.boolean().default(false),
|
|
20
|
+
micronutrients: z.record(z.string(), z.number().min(0).max(100)).nullable().optional(),
|
|
21
|
+
form: fertilizerFormSchema.default('soluble'),
|
|
22
|
+
applicationMethods: z.array(applicationMethodSchema).min(1),
|
|
23
|
+
labelDirections: z.string().max(1000).nullable().optional(),
|
|
24
|
+
bagSizeKg: z.number().positive().max(1000).nullable().optional(),
|
|
25
|
+
catalogueProductId: z.string().max(60).nullable().optional(),
|
|
26
|
+
})
|
|
27
|
+
.refine(analysisAddsUp, {
|
|
28
|
+
message: 'The analysis must add up to more than 0% and no more than 100%',
|
|
29
|
+
path: ['nitrogen'],
|
|
30
|
+
});
|
|
31
|
+
/** What reading a bag photo returns. Nothing in it reaches a plan until the farmer confirms it. */
|
|
32
|
+
export const fertilizerLabelDraftSchema = z.object({
|
|
33
|
+
name: z.string(),
|
|
34
|
+
brand: z.string().nullable(),
|
|
35
|
+
nitrogen: percent,
|
|
36
|
+
phosphorus: percent,
|
|
37
|
+
potassium: percent,
|
|
38
|
+
calcium: percent,
|
|
39
|
+
magnesium: percent,
|
|
40
|
+
sulfate: z.boolean(),
|
|
41
|
+
micronutrients: z.record(z.string(), z.number()).nullable(),
|
|
42
|
+
form: fertilizerFormSchema,
|
|
43
|
+
applicationMethods: z.array(applicationMethodSchema),
|
|
44
|
+
labelDirections: z.string().nullable(),
|
|
45
|
+
bagSizeKg: z.number().nullable(),
|
|
46
|
+
catalogueProductId: z.string().nullable(),
|
|
47
|
+
/** Whether the analysis was printed on the bag or filled in from the standard salt. */
|
|
48
|
+
analysisFrom: z.enum(['bag', 'catalogue']),
|
|
49
|
+
legibility: z.enum(['clear', 'partial', 'poor']),
|
|
50
|
+
roles: z.array(z.string()),
|
|
51
|
+
questions: z.array(z.object({ id: z.enum(['use-unclear', 'analysis-missing', 'stock']), text: z.string() })),
|
|
52
|
+
});
|
|
53
|
+
export const farmFertilizerSchema = z.object({
|
|
54
|
+
id: z.string(),
|
|
55
|
+
name: z.string(),
|
|
56
|
+
brand: z.string().nullable(),
|
|
57
|
+
catalogueProductId: z.string().nullable(),
|
|
58
|
+
nitrogen: percent,
|
|
59
|
+
phosphorus: percent,
|
|
60
|
+
potassium: percent,
|
|
61
|
+
calcium: percent,
|
|
62
|
+
magnesium: percent,
|
|
63
|
+
sulfate: z.boolean(),
|
|
64
|
+
micronutrients: z.record(z.string(), z.number()).nullable(),
|
|
65
|
+
form: fertilizerFormSchema,
|
|
66
|
+
applicationMethods: z.array(applicationMethodSchema),
|
|
67
|
+
roles: z.array(z.string()),
|
|
68
|
+
labelDirections: z.string().nullable(),
|
|
69
|
+
bagSizeKg: z.number().nullable(),
|
|
70
|
+
/** Kilograms on hand, or null when stock is not tracked. */
|
|
71
|
+
stockKg: z.number().nullable(),
|
|
72
|
+
/** The plan may put it through the drip. */
|
|
73
|
+
fertigationSafe: z.boolean(),
|
|
74
|
+
});
|
|
75
|
+
export const fertilizerProfileViewSchema = farmFertilizerSchema.omit({
|
|
76
|
+
id: true,
|
|
77
|
+
name: true,
|
|
78
|
+
stockKg: true,
|
|
79
|
+
});
|
|
80
|
+
export const farmFertilizerListSchema = z.object({ items: z.array(farmFertilizerSchema) });
|
|
81
|
+
export const createFarmFertilizerBodySchema = z
|
|
82
|
+
.object({
|
|
83
|
+
name: z.string().trim().min(1).max(200),
|
|
84
|
+
brand: z.string().trim().max(100).nullable().optional(),
|
|
85
|
+
nitrogen: percent,
|
|
86
|
+
phosphorus: percent,
|
|
87
|
+
potassium: percent,
|
|
88
|
+
calcium: percent,
|
|
89
|
+
magnesium: percent,
|
|
90
|
+
sulfate: z.boolean().default(false),
|
|
91
|
+
micronutrients: z.record(z.string(), z.number().min(0).max(100)).nullable().optional(),
|
|
92
|
+
form: fertilizerFormSchema.default('soluble'),
|
|
93
|
+
applicationMethods: z.array(applicationMethodSchema).min(1),
|
|
94
|
+
labelDirections: z.string().max(1000).nullable().optional(),
|
|
95
|
+
bagSizeKg: z.number().positive().max(1000).nullable().optional(),
|
|
96
|
+
catalogueProductId: z.string().max(60).nullable().optional(),
|
|
97
|
+
/** Kilograms on hand now (bags times bag size). Omit to leave stock untracked. */
|
|
98
|
+
stockKg: z.number().min(0).max(1_000_000).nullable().optional(),
|
|
99
|
+
})
|
|
100
|
+
.refine(analysisAddsUp, {
|
|
101
|
+
message: 'The analysis must add up to more than 0% and no more than 100%',
|
|
102
|
+
path: ['nitrogen'],
|
|
103
|
+
});
|
|
104
|
+
export const updateFarmFertilizerBodySchema = z.object({
|
|
105
|
+
name: z.string().trim().min(1).max(200).optional(),
|
|
106
|
+
applicationMethods: z.array(applicationMethodSchema).min(1).optional(),
|
|
107
|
+
bagSizeKg: z.number().positive().max(1000).nullable().optional(),
|
|
108
|
+
stockKg: z.number().min(0).max(1_000_000).optional(),
|
|
109
|
+
});
|
|
110
|
+
const guidanceSchema = z.object({
|
|
111
|
+
why: z.string(),
|
|
112
|
+
when: z.string(),
|
|
113
|
+
how: z.array(z.string()),
|
|
114
|
+
warning: z.string().nullable(),
|
|
115
|
+
});
|
|
116
|
+
/**
|
|
117
|
+
* One fertilizer's place in a field's plan: its dose from the live plan, what the field and the farm need over
|
|
118
|
+
* the planning weeks, what the farm has, what to buy, and the plain-language guidance for using it.
|
|
119
|
+
*/
|
|
120
|
+
export const fertilizerRequirementSchema = z.object({
|
|
121
|
+
id: z.string(),
|
|
122
|
+
name: z.string(),
|
|
123
|
+
brand: z.string().nullable(),
|
|
124
|
+
role: z.string().nullable(),
|
|
125
|
+
tank: z.enum(['A', 'B']).nullable(),
|
|
126
|
+
/** on-farm: confirmed and counted. not-recorded: the plan's own suggestion; the farm has not said what it has. */
|
|
127
|
+
availability: z.enum(['on-farm', 'not-recorded']),
|
|
128
|
+
gramsPerPlantPerFeed: z.number().nullable(),
|
|
129
|
+
fieldKgPerFeed: z.number().nullable(),
|
|
130
|
+
gramsPerPlantPerWeek: z.number().nullable(),
|
|
131
|
+
fieldKgPerWeek: z.number().nullable(),
|
|
132
|
+
/** Kilograms this field needs over the planning weeks at the current stage's rate. */
|
|
133
|
+
fieldNeedKg: z.number().nullable(),
|
|
134
|
+
/** Kilograms every field on the farm needs over the planning weeks. Stock is one pool, so this is what it is held against. */
|
|
135
|
+
farmNeedKg: z.number().nullable(),
|
|
136
|
+
/** How many of the farm's fields use this fertilizer. */
|
|
137
|
+
fieldCount: z.number(),
|
|
138
|
+
stockKg: z.number().nullable(),
|
|
139
|
+
/** Weeks the farm's stock lasts across all its fields. */
|
|
140
|
+
weeksOfCover: z.number().nullable(),
|
|
141
|
+
/** Kilograms to buy so the farm covers every field for the planning weeks. */
|
|
142
|
+
purchaseKg: z.number().nullable(),
|
|
143
|
+
purchaseBags: z.number().nullable(),
|
|
144
|
+
bagSizeKg: z.number().nullable(),
|
|
145
|
+
/** Anything else the bag supplies, e.g. "Boron 0.3%". */
|
|
146
|
+
additionalNutrients: z.string().nullable(),
|
|
147
|
+
/** The label's own words on use and rate. */
|
|
148
|
+
labelDirections: z.string().nullable(),
|
|
149
|
+
guidance: guidanceSchema,
|
|
150
|
+
});
|
|
151
|
+
export const uncoveredRoleSchema = z.object({
|
|
152
|
+
role: z.string(),
|
|
153
|
+
message: z.string(),
|
|
154
|
+
suggestedProduct: z.string().nullable(),
|
|
155
|
+
});
|
|
156
|
+
export const fertilizerRequirementsResponseSchema = z.object({
|
|
157
|
+
fieldId: z.string(),
|
|
158
|
+
status: z.enum(['ok', 'no-plan']),
|
|
159
|
+
message: z.string().nullable(),
|
|
160
|
+
stage: z.object({ id: z.string(), label: z.string() }).nullable(),
|
|
161
|
+
fertilizerSet: z.object({ id: z.string(), name: z.string() }).nullable(),
|
|
162
|
+
/** True when the plan is built from the fertilizers this farm confirmed. */
|
|
163
|
+
usesFarmFertilizers: z.boolean(),
|
|
164
|
+
plantCount: z.number().nullable(),
|
|
165
|
+
planningWeeks: z.number(),
|
|
166
|
+
/** In the plan this stage, through the drip. */
|
|
167
|
+
fertigation: z.array(fertilizerRequirementSchema),
|
|
168
|
+
/** Confirmed for fertigation but with no job at this stage. */
|
|
169
|
+
standby: z.array(fertilizerRequirementSchema),
|
|
170
|
+
foliar: z.array(fertilizerRequirementSchema),
|
|
171
|
+
soil: z.array(fertilizerRequirementSchema),
|
|
172
|
+
/** Jobs the stage needs done that no fertilizer on the farm can do. */
|
|
173
|
+
uncoveredRoles: z.array(uncoveredRoleSchema),
|
|
174
|
+
warnings: z.array(z.string()),
|
|
175
|
+
});
|
|
@@ -61,11 +61,11 @@ export declare const ndviSummarySchema: z.ZodObject<{
|
|
|
61
61
|
average: z.ZodNullable<z.ZodNumber>;
|
|
62
62
|
fieldCount: z.ZodNumber;
|
|
63
63
|
}, "strip", z.ZodTypeAny, {
|
|
64
|
-
average: number | null;
|
|
65
64
|
fieldCount: number;
|
|
66
|
-
}, {
|
|
67
65
|
average: number | null;
|
|
66
|
+
}, {
|
|
68
67
|
fieldCount: number;
|
|
68
|
+
average: number | null;
|
|
69
69
|
}>;
|
|
70
70
|
export declare const farmStatusAttributesSchema: z.ZodObject<{
|
|
71
71
|
farmId: z.ZodString;
|
|
@@ -127,18 +127,18 @@ export declare const farmStatusAttributesSchema: z.ZodObject<{
|
|
|
127
127
|
average: z.ZodNullable<z.ZodNumber>;
|
|
128
128
|
fieldCount: z.ZodNumber;
|
|
129
129
|
}, "strip", z.ZodTypeAny, {
|
|
130
|
-
average: number | null;
|
|
131
130
|
fieldCount: number;
|
|
132
|
-
}, {
|
|
133
131
|
average: number | null;
|
|
132
|
+
}, {
|
|
134
133
|
fieldCount: number;
|
|
134
|
+
average: number | null;
|
|
135
135
|
}>;
|
|
136
136
|
computedAt: z.ZodString;
|
|
137
137
|
}, "strip", z.ZodTypeAny, {
|
|
138
138
|
farmId: string;
|
|
139
139
|
ndvi: {
|
|
140
|
-
average: number | null;
|
|
141
140
|
fieldCount: number;
|
|
141
|
+
average: number | null;
|
|
142
142
|
};
|
|
143
143
|
health: {
|
|
144
144
|
overall: number;
|
|
@@ -164,8 +164,8 @@ export declare const farmStatusAttributesSchema: z.ZodObject<{
|
|
|
164
164
|
}, {
|
|
165
165
|
farmId: string;
|
|
166
166
|
ndvi: {
|
|
167
|
-
average: number | null;
|
|
168
167
|
fieldCount: number;
|
|
168
|
+
average: number | null;
|
|
169
169
|
};
|
|
170
170
|
health: {
|
|
171
171
|
overall: number;
|
|
@@ -253,18 +253,18 @@ export declare const farmStatusResponseSchema: z.ZodObject<{
|
|
|
253
253
|
average: z.ZodNullable<z.ZodNumber>;
|
|
254
254
|
fieldCount: z.ZodNumber;
|
|
255
255
|
}, "strip", z.ZodTypeAny, {
|
|
256
|
-
average: number | null;
|
|
257
256
|
fieldCount: number;
|
|
258
|
-
}, {
|
|
259
257
|
average: number | null;
|
|
258
|
+
}, {
|
|
260
259
|
fieldCount: number;
|
|
260
|
+
average: number | null;
|
|
261
261
|
}>;
|
|
262
262
|
computedAt: z.ZodString;
|
|
263
263
|
}, "strip", z.ZodTypeAny, {
|
|
264
264
|
farmId: string;
|
|
265
265
|
ndvi: {
|
|
266
|
-
average: number | null;
|
|
267
266
|
fieldCount: number;
|
|
267
|
+
average: number | null;
|
|
268
268
|
};
|
|
269
269
|
health: {
|
|
270
270
|
overall: number;
|
|
@@ -290,8 +290,8 @@ export declare const farmStatusResponseSchema: z.ZodObject<{
|
|
|
290
290
|
}, {
|
|
291
291
|
farmId: string;
|
|
292
292
|
ndvi: {
|
|
293
|
-
average: number | null;
|
|
294
293
|
fieldCount: number;
|
|
294
|
+
average: number | null;
|
|
295
295
|
};
|
|
296
296
|
health: {
|
|
297
297
|
overall: number;
|
|
@@ -321,8 +321,8 @@ export declare const farmStatusResponseSchema: z.ZodObject<{
|
|
|
321
321
|
attributes: {
|
|
322
322
|
farmId: string;
|
|
323
323
|
ndvi: {
|
|
324
|
-
average: number | null;
|
|
325
324
|
fieldCount: number;
|
|
325
|
+
average: number | null;
|
|
326
326
|
};
|
|
327
327
|
health: {
|
|
328
328
|
overall: number;
|
|
@@ -352,8 +352,8 @@ export declare const farmStatusResponseSchema: z.ZodObject<{
|
|
|
352
352
|
attributes: {
|
|
353
353
|
farmId: string;
|
|
354
354
|
ndvi: {
|
|
355
|
-
average: number | null;
|
|
356
355
|
fieldCount: number;
|
|
356
|
+
average: number | null;
|
|
357
357
|
};
|
|
358
358
|
health: {
|
|
359
359
|
overall: number;
|
|
@@ -385,8 +385,8 @@ export declare const farmStatusResponseSchema: z.ZodObject<{
|
|
|
385
385
|
attributes: {
|
|
386
386
|
farmId: string;
|
|
387
387
|
ndvi: {
|
|
388
|
-
average: number | null;
|
|
389
388
|
fieldCount: number;
|
|
389
|
+
average: number | null;
|
|
390
390
|
};
|
|
391
391
|
health: {
|
|
392
392
|
overall: number;
|
|
@@ -418,8 +418,8 @@ export declare const farmStatusResponseSchema: z.ZodObject<{
|
|
|
418
418
|
attributes: {
|
|
419
419
|
farmId: string;
|
|
420
420
|
ndvi: {
|
|
421
|
-
average: number | null;
|
|
422
421
|
fieldCount: number;
|
|
422
|
+
average: number | null;
|
|
423
423
|
};
|
|
424
424
|
health: {
|
|
425
425
|
overall: number;
|
|
@@ -0,0 +1,356 @@
|
|
|
1
|
+
import { z } from 'zod';
|
|
2
|
+
export declare const fertigationBoardLineSchema: z.ZodObject<{
|
|
3
|
+
productId: z.ZodString;
|
|
4
|
+
name: z.ZodString;
|
|
5
|
+
tank: z.ZodEnum<["A", "B"]>;
|
|
6
|
+
gramsPerPlant: z.ZodNumber;
|
|
7
|
+
fieldKg: z.ZodNullable<z.ZodNumber>;
|
|
8
|
+
inventoryItemId: z.ZodNullable<z.ZodString>;
|
|
9
|
+
stockKg: z.ZodNullable<z.ZodNumber>;
|
|
10
|
+
bagSizeKg: z.ZodNullable<z.ZodNumber>;
|
|
11
|
+
/** False when the plan names a product the farm has not entered as a supply item. */
|
|
12
|
+
inStockList: z.ZodBoolean;
|
|
13
|
+
}, "strip", z.ZodTypeAny, {
|
|
14
|
+
name: string;
|
|
15
|
+
inventoryItemId: string | null;
|
|
16
|
+
bagSizeKg: number | null;
|
|
17
|
+
stockKg: number | null;
|
|
18
|
+
tank: "A" | "B";
|
|
19
|
+
productId: string;
|
|
20
|
+
gramsPerPlant: number;
|
|
21
|
+
fieldKg: number | null;
|
|
22
|
+
inStockList: boolean;
|
|
23
|
+
}, {
|
|
24
|
+
name: string;
|
|
25
|
+
inventoryItemId: string | null;
|
|
26
|
+
bagSizeKg: number | null;
|
|
27
|
+
stockKg: number | null;
|
|
28
|
+
tank: "A" | "B";
|
|
29
|
+
productId: string;
|
|
30
|
+
gramsPerPlant: number;
|
|
31
|
+
fieldKg: number | null;
|
|
32
|
+
inStockList: boolean;
|
|
33
|
+
}>;
|
|
34
|
+
export declare const fertigationBoardFieldSchema: z.ZodObject<{
|
|
35
|
+
fieldId: z.ZodString;
|
|
36
|
+
fieldName: z.ZodString;
|
|
37
|
+
stageLabel: z.ZodNullable<z.ZodString>;
|
|
38
|
+
fieldDay: z.ZodNullable<z.ZodNumber>;
|
|
39
|
+
plantCount: z.ZodNullable<z.ZodNumber>;
|
|
40
|
+
kind: z.ZodEnum<["feed", "water", "none"]>;
|
|
41
|
+
tank: z.ZodNullable<z.ZodEnum<["A", "B"]>>;
|
|
42
|
+
due: z.ZodBoolean;
|
|
43
|
+
overdue: z.ZodBoolean;
|
|
44
|
+
feedHold: z.ZodBoolean;
|
|
45
|
+
blockers: z.ZodArray<z.ZodString, "many">;
|
|
46
|
+
warnings: z.ZodArray<z.ZodString, "many">;
|
|
47
|
+
lines: z.ZodArray<z.ZodObject<{
|
|
48
|
+
productId: z.ZodString;
|
|
49
|
+
name: z.ZodString;
|
|
50
|
+
tank: z.ZodEnum<["A", "B"]>;
|
|
51
|
+
gramsPerPlant: z.ZodNumber;
|
|
52
|
+
fieldKg: z.ZodNullable<z.ZodNumber>;
|
|
53
|
+
inventoryItemId: z.ZodNullable<z.ZodString>;
|
|
54
|
+
stockKg: z.ZodNullable<z.ZodNumber>;
|
|
55
|
+
bagSizeKg: z.ZodNullable<z.ZodNumber>;
|
|
56
|
+
/** False when the plan names a product the farm has not entered as a supply item. */
|
|
57
|
+
inStockList: z.ZodBoolean;
|
|
58
|
+
}, "strip", z.ZodTypeAny, {
|
|
59
|
+
name: string;
|
|
60
|
+
inventoryItemId: string | null;
|
|
61
|
+
bagSizeKg: number | null;
|
|
62
|
+
stockKg: number | null;
|
|
63
|
+
tank: "A" | "B";
|
|
64
|
+
productId: string;
|
|
65
|
+
gramsPerPlant: number;
|
|
66
|
+
fieldKg: number | null;
|
|
67
|
+
inStockList: boolean;
|
|
68
|
+
}, {
|
|
69
|
+
name: string;
|
|
70
|
+
inventoryItemId: string | null;
|
|
71
|
+
bagSizeKg: number | null;
|
|
72
|
+
stockKg: number | null;
|
|
73
|
+
tank: "A" | "B";
|
|
74
|
+
productId: string;
|
|
75
|
+
gramsPerPlant: number;
|
|
76
|
+
fieldKg: number | null;
|
|
77
|
+
inStockList: boolean;
|
|
78
|
+
}>, "many">;
|
|
79
|
+
message: z.ZodNullable<z.ZodString>;
|
|
80
|
+
}, "strip", z.ZodTypeAny, {
|
|
81
|
+
message: string | null;
|
|
82
|
+
kind: "none" | "water" | "feed";
|
|
83
|
+
plantCount: number | null;
|
|
84
|
+
fieldId: string;
|
|
85
|
+
fieldName: string;
|
|
86
|
+
tank: "A" | "B" | null;
|
|
87
|
+
warnings: string[];
|
|
88
|
+
overdue: boolean;
|
|
89
|
+
lines: {
|
|
90
|
+
name: string;
|
|
91
|
+
inventoryItemId: string | null;
|
|
92
|
+
bagSizeKg: number | null;
|
|
93
|
+
stockKg: number | null;
|
|
94
|
+
tank: "A" | "B";
|
|
95
|
+
productId: string;
|
|
96
|
+
gramsPerPlant: number;
|
|
97
|
+
fieldKg: number | null;
|
|
98
|
+
inStockList: boolean;
|
|
99
|
+
}[];
|
|
100
|
+
stageLabel: string | null;
|
|
101
|
+
fieldDay: number | null;
|
|
102
|
+
due: boolean;
|
|
103
|
+
feedHold: boolean;
|
|
104
|
+
blockers: string[];
|
|
105
|
+
}, {
|
|
106
|
+
message: string | null;
|
|
107
|
+
kind: "none" | "water" | "feed";
|
|
108
|
+
plantCount: number | null;
|
|
109
|
+
fieldId: string;
|
|
110
|
+
fieldName: string;
|
|
111
|
+
tank: "A" | "B" | null;
|
|
112
|
+
warnings: string[];
|
|
113
|
+
overdue: boolean;
|
|
114
|
+
lines: {
|
|
115
|
+
name: string;
|
|
116
|
+
inventoryItemId: string | null;
|
|
117
|
+
bagSizeKg: number | null;
|
|
118
|
+
stockKg: number | null;
|
|
119
|
+
tank: "A" | "B";
|
|
120
|
+
productId: string;
|
|
121
|
+
gramsPerPlant: number;
|
|
122
|
+
fieldKg: number | null;
|
|
123
|
+
inStockList: boolean;
|
|
124
|
+
}[];
|
|
125
|
+
stageLabel: string | null;
|
|
126
|
+
fieldDay: number | null;
|
|
127
|
+
due: boolean;
|
|
128
|
+
feedHold: boolean;
|
|
129
|
+
blockers: string[];
|
|
130
|
+
}>;
|
|
131
|
+
export declare const fertigationBoardSchema: z.ZodObject<{
|
|
132
|
+
today: z.ZodString;
|
|
133
|
+
fields: z.ZodArray<z.ZodObject<{
|
|
134
|
+
fieldId: z.ZodString;
|
|
135
|
+
fieldName: z.ZodString;
|
|
136
|
+
stageLabel: z.ZodNullable<z.ZodString>;
|
|
137
|
+
fieldDay: z.ZodNullable<z.ZodNumber>;
|
|
138
|
+
plantCount: z.ZodNullable<z.ZodNumber>;
|
|
139
|
+
kind: z.ZodEnum<["feed", "water", "none"]>;
|
|
140
|
+
tank: z.ZodNullable<z.ZodEnum<["A", "B"]>>;
|
|
141
|
+
due: z.ZodBoolean;
|
|
142
|
+
overdue: z.ZodBoolean;
|
|
143
|
+
feedHold: z.ZodBoolean;
|
|
144
|
+
blockers: z.ZodArray<z.ZodString, "many">;
|
|
145
|
+
warnings: z.ZodArray<z.ZodString, "many">;
|
|
146
|
+
lines: z.ZodArray<z.ZodObject<{
|
|
147
|
+
productId: z.ZodString;
|
|
148
|
+
name: z.ZodString;
|
|
149
|
+
tank: z.ZodEnum<["A", "B"]>;
|
|
150
|
+
gramsPerPlant: z.ZodNumber;
|
|
151
|
+
fieldKg: z.ZodNullable<z.ZodNumber>;
|
|
152
|
+
inventoryItemId: z.ZodNullable<z.ZodString>;
|
|
153
|
+
stockKg: z.ZodNullable<z.ZodNumber>;
|
|
154
|
+
bagSizeKg: z.ZodNullable<z.ZodNumber>;
|
|
155
|
+
/** False when the plan names a product the farm has not entered as a supply item. */
|
|
156
|
+
inStockList: z.ZodBoolean;
|
|
157
|
+
}, "strip", z.ZodTypeAny, {
|
|
158
|
+
name: string;
|
|
159
|
+
inventoryItemId: string | null;
|
|
160
|
+
bagSizeKg: number | null;
|
|
161
|
+
stockKg: number | null;
|
|
162
|
+
tank: "A" | "B";
|
|
163
|
+
productId: string;
|
|
164
|
+
gramsPerPlant: number;
|
|
165
|
+
fieldKg: number | null;
|
|
166
|
+
inStockList: boolean;
|
|
167
|
+
}, {
|
|
168
|
+
name: string;
|
|
169
|
+
inventoryItemId: string | null;
|
|
170
|
+
bagSizeKg: number | null;
|
|
171
|
+
stockKg: number | null;
|
|
172
|
+
tank: "A" | "B";
|
|
173
|
+
productId: string;
|
|
174
|
+
gramsPerPlant: number;
|
|
175
|
+
fieldKg: number | null;
|
|
176
|
+
inStockList: boolean;
|
|
177
|
+
}>, "many">;
|
|
178
|
+
message: z.ZodNullable<z.ZodString>;
|
|
179
|
+
}, "strip", z.ZodTypeAny, {
|
|
180
|
+
message: string | null;
|
|
181
|
+
kind: "none" | "water" | "feed";
|
|
182
|
+
plantCount: number | null;
|
|
183
|
+
fieldId: string;
|
|
184
|
+
fieldName: string;
|
|
185
|
+
tank: "A" | "B" | null;
|
|
186
|
+
warnings: string[];
|
|
187
|
+
overdue: boolean;
|
|
188
|
+
lines: {
|
|
189
|
+
name: string;
|
|
190
|
+
inventoryItemId: string | null;
|
|
191
|
+
bagSizeKg: number | null;
|
|
192
|
+
stockKg: number | null;
|
|
193
|
+
tank: "A" | "B";
|
|
194
|
+
productId: string;
|
|
195
|
+
gramsPerPlant: number;
|
|
196
|
+
fieldKg: number | null;
|
|
197
|
+
inStockList: boolean;
|
|
198
|
+
}[];
|
|
199
|
+
stageLabel: string | null;
|
|
200
|
+
fieldDay: number | null;
|
|
201
|
+
due: boolean;
|
|
202
|
+
feedHold: boolean;
|
|
203
|
+
blockers: string[];
|
|
204
|
+
}, {
|
|
205
|
+
message: string | null;
|
|
206
|
+
kind: "none" | "water" | "feed";
|
|
207
|
+
plantCount: number | null;
|
|
208
|
+
fieldId: string;
|
|
209
|
+
fieldName: string;
|
|
210
|
+
tank: "A" | "B" | null;
|
|
211
|
+
warnings: string[];
|
|
212
|
+
overdue: boolean;
|
|
213
|
+
lines: {
|
|
214
|
+
name: string;
|
|
215
|
+
inventoryItemId: string | null;
|
|
216
|
+
bagSizeKg: number | null;
|
|
217
|
+
stockKg: number | null;
|
|
218
|
+
tank: "A" | "B";
|
|
219
|
+
productId: string;
|
|
220
|
+
gramsPerPlant: number;
|
|
221
|
+
fieldKg: number | null;
|
|
222
|
+
inStockList: boolean;
|
|
223
|
+
}[];
|
|
224
|
+
stageLabel: string | null;
|
|
225
|
+
fieldDay: number | null;
|
|
226
|
+
due: boolean;
|
|
227
|
+
feedHold: boolean;
|
|
228
|
+
blockers: string[];
|
|
229
|
+
}>, "many">;
|
|
230
|
+
}, "strip", z.ZodTypeAny, {
|
|
231
|
+
fields: {
|
|
232
|
+
message: string | null;
|
|
233
|
+
kind: "none" | "water" | "feed";
|
|
234
|
+
plantCount: number | null;
|
|
235
|
+
fieldId: string;
|
|
236
|
+
fieldName: string;
|
|
237
|
+
tank: "A" | "B" | null;
|
|
238
|
+
warnings: string[];
|
|
239
|
+
overdue: boolean;
|
|
240
|
+
lines: {
|
|
241
|
+
name: string;
|
|
242
|
+
inventoryItemId: string | null;
|
|
243
|
+
bagSizeKg: number | null;
|
|
244
|
+
stockKg: number | null;
|
|
245
|
+
tank: "A" | "B";
|
|
246
|
+
productId: string;
|
|
247
|
+
gramsPerPlant: number;
|
|
248
|
+
fieldKg: number | null;
|
|
249
|
+
inStockList: boolean;
|
|
250
|
+
}[];
|
|
251
|
+
stageLabel: string | null;
|
|
252
|
+
fieldDay: number | null;
|
|
253
|
+
due: boolean;
|
|
254
|
+
feedHold: boolean;
|
|
255
|
+
blockers: string[];
|
|
256
|
+
}[];
|
|
257
|
+
today: string;
|
|
258
|
+
}, {
|
|
259
|
+
fields: {
|
|
260
|
+
message: string | null;
|
|
261
|
+
kind: "none" | "water" | "feed";
|
|
262
|
+
plantCount: number | null;
|
|
263
|
+
fieldId: string;
|
|
264
|
+
fieldName: string;
|
|
265
|
+
tank: "A" | "B" | null;
|
|
266
|
+
warnings: string[];
|
|
267
|
+
overdue: boolean;
|
|
268
|
+
lines: {
|
|
269
|
+
name: string;
|
|
270
|
+
inventoryItemId: string | null;
|
|
271
|
+
bagSizeKg: number | null;
|
|
272
|
+
stockKg: number | null;
|
|
273
|
+
tank: "A" | "B";
|
|
274
|
+
productId: string;
|
|
275
|
+
gramsPerPlant: number;
|
|
276
|
+
fieldKg: number | null;
|
|
277
|
+
inStockList: boolean;
|
|
278
|
+
}[];
|
|
279
|
+
stageLabel: string | null;
|
|
280
|
+
fieldDay: number | null;
|
|
281
|
+
due: boolean;
|
|
282
|
+
feedHold: boolean;
|
|
283
|
+
blockers: string[];
|
|
284
|
+
}[];
|
|
285
|
+
today: string;
|
|
286
|
+
}>;
|
|
287
|
+
export type FertigationBoard = z.infer<typeof fertigationBoardSchema>;
|
|
288
|
+
export declare const recordFeedBodySchema: z.ZodObject<{
|
|
289
|
+
plannedFor: z.ZodString;
|
|
290
|
+
idempotencyKey: z.ZodString;
|
|
291
|
+
/** Actual kilograms, keyed by product id. Omitted lines use the planned dose. */
|
|
292
|
+
actualKg: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
|
|
293
|
+
note: z.ZodOptional<z.ZodString>;
|
|
294
|
+
skipReason: z.ZodOptional<z.ZodString>;
|
|
295
|
+
}, "strip", z.ZodTypeAny, {
|
|
296
|
+
plannedFor: string;
|
|
297
|
+
idempotencyKey: string;
|
|
298
|
+
note?: string | undefined;
|
|
299
|
+
actualKg?: Record<string, number> | undefined;
|
|
300
|
+
skipReason?: string | undefined;
|
|
301
|
+
}, {
|
|
302
|
+
plannedFor: string;
|
|
303
|
+
idempotencyKey: string;
|
|
304
|
+
note?: string | undefined;
|
|
305
|
+
actualKg?: Record<string, number> | undefined;
|
|
306
|
+
skipReason?: string | undefined;
|
|
307
|
+
}>;
|
|
308
|
+
export declare const fertigationFeedSchema: z.ZodObject<{
|
|
309
|
+
id: z.ZodString;
|
|
310
|
+
fieldId: z.ZodString;
|
|
311
|
+
plannedFor: z.ZodString;
|
|
312
|
+
status: z.ZodEnum<["done", "skipped", "void"]>;
|
|
313
|
+
tank: z.ZodEnum<["A", "B"]>;
|
|
314
|
+
lines: z.ZodArray<z.ZodObject<{
|
|
315
|
+
productName: z.ZodString;
|
|
316
|
+
inventoryItemId: z.ZodNullable<z.ZodString>;
|
|
317
|
+
plannedKg: z.ZodNumber;
|
|
318
|
+
actualKg: z.ZodNullable<z.ZodNumber>;
|
|
319
|
+
}, "strip", z.ZodTypeAny, {
|
|
320
|
+
productName: string;
|
|
321
|
+
inventoryItemId: string | null;
|
|
322
|
+
actualKg: number | null;
|
|
323
|
+
plannedKg: number;
|
|
324
|
+
}, {
|
|
325
|
+
productName: string;
|
|
326
|
+
inventoryItemId: string | null;
|
|
327
|
+
actualKg: number | null;
|
|
328
|
+
plannedKg: number;
|
|
329
|
+
}>, "many">;
|
|
330
|
+
}, "strip", z.ZodTypeAny, {
|
|
331
|
+
status: "void" | "skipped" | "done";
|
|
332
|
+
id: string;
|
|
333
|
+
fieldId: string;
|
|
334
|
+
tank: "A" | "B";
|
|
335
|
+
lines: {
|
|
336
|
+
productName: string;
|
|
337
|
+
inventoryItemId: string | null;
|
|
338
|
+
actualKg: number | null;
|
|
339
|
+
plannedKg: number;
|
|
340
|
+
}[];
|
|
341
|
+
plannedFor: string;
|
|
342
|
+
}, {
|
|
343
|
+
status: "void" | "skipped" | "done";
|
|
344
|
+
id: string;
|
|
345
|
+
fieldId: string;
|
|
346
|
+
tank: "A" | "B";
|
|
347
|
+
lines: {
|
|
348
|
+
productName: string;
|
|
349
|
+
inventoryItemId: string | null;
|
|
350
|
+
actualKg: number | null;
|
|
351
|
+
plannedKg: number;
|
|
352
|
+
}[];
|
|
353
|
+
plannedFor: string;
|
|
354
|
+
}>;
|
|
355
|
+
export type FertigationFeedContract = z.infer<typeof fertigationFeedSchema>;
|
|
356
|
+
//# sourceMappingURL=fertigation-board.schemas.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"fertigation-board.schemas.d.ts","sourceRoot":"","sources":["../../src/schemas/fertigation-board.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,0BAA0B;;;;;;;;;IASrC,qFAAqF;;;;;;;;;;;;;;;;;;;;;;EAErF,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;QAJtC,qFAAqF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBrF,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;YArBjC,qFAAqF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBrF,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,oBAAoB;;;IAG/B,iFAAiF;;;;;;;;;;;;;;;;EAIjF,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAchC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}
|