@mailwoman/api 9.2.0 → 9.4.0
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/{app.ts → lib/app.ts} +27 -10
- package/{engine.ts → lib/engine.ts} +2 -2
- package/{index.ts → lib/index.ts} +4 -4
- package/{routes.ts → lib/routes.ts} +35 -22
- package/{schema.ts → lib/schema.ts} +125 -15
- package/out/app.d.ts +9 -2
- package/out/app.d.ts.map +1 -1
- package/out/app.js +10 -7
- package/out/app.js.map +1 -1
- package/out/engine.d.ts +2 -2
- package/out/engine.d.ts.map +1 -1
- package/out/engine.js.map +1 -1
- package/out/index.d.ts +4 -4
- package/out/index.d.ts.map +1 -1
- package/out/index.js +4 -4
- package/out/index.js.map +1 -1
- package/out/routes.d.ts +8 -3
- package/out/routes.d.ts.map +1 -1
- package/out/routes.js +20 -19
- package/out/routes.js.map +1 -1
- package/out/schema.d.ts +341 -11
- package/out/schema.d.ts.map +1 -1
- package/out/schema.js +112 -14
- package/out/schema.js.map +1 -1
- package/package.json +23 -9
package/out/schema.d.ts
CHANGED
|
@@ -16,10 +16,15 @@
|
|
|
16
16
|
* and error alike, from this one file.
|
|
17
17
|
*/
|
|
18
18
|
import { z } from "@hono/zod-openapi";
|
|
19
|
-
|
|
19
|
+
import type { AddressNode } from "@mailwoman/core/decoder";
|
|
20
20
|
/**
|
|
21
21
|
* `POST /v1/parse` request body.
|
|
22
22
|
*/
|
|
23
|
+
/**
|
|
24
|
+
* One node of the decoded address tree. The decoder's `AddressNode` is a recursive union the OpenAPI generator cannot
|
|
25
|
+
* derive a schema for on its own, so it is registered as an open object; the shape is documented by the type.
|
|
26
|
+
*/
|
|
27
|
+
export declare const AddressNodeSchema: z.ZodCustom<AddressNode, AddressNode>;
|
|
23
28
|
/**
|
|
24
29
|
* The input register (Decision A / GTM B10): `fragmented` = the map-search register (evidence-bundle channels feed);
|
|
25
30
|
* `formatted` = the validation/record register (channels off). Unset → the engine derives it from the input's shape.
|
|
@@ -73,7 +78,8 @@ export declare const ParseOutcomeSchema: z.ZodObject<{
|
|
|
73
78
|
value: z.ZodString;
|
|
74
79
|
}, z.core.$strip>>;
|
|
75
80
|
tree: z.ZodObject<{
|
|
76
|
-
|
|
81
|
+
raw: z.ZodString;
|
|
82
|
+
roots: z.ZodArray<z.ZodCustom<AddressNode, AddressNode>>;
|
|
77
83
|
}, z.core.$loose>;
|
|
78
84
|
debug: z.ZodOptional<z.ZodString>;
|
|
79
85
|
}, z.core.$strip>;
|
|
@@ -87,6 +93,59 @@ export declare const GeocodeRequestSchema: z.ZodObject<{
|
|
|
87
93
|
formatted: "formatted";
|
|
88
94
|
}>>;
|
|
89
95
|
}, z.core.$strip>;
|
|
96
|
+
/**
|
|
97
|
+
* The derivation behind a geocode answer, present only when the engine was asked to trace — `@mailwoman/evidence`'s
|
|
98
|
+
* `DerivationProjection` on the wire.
|
|
99
|
+
*/
|
|
100
|
+
export declare const DerivationProjectionSchema: z.ZodObject<{
|
|
101
|
+
status: z.ZodEnum<{
|
|
102
|
+
designated: "designated";
|
|
103
|
+
observed: "observed";
|
|
104
|
+
derived: "derived";
|
|
105
|
+
inferred: "inferred";
|
|
106
|
+
unresolved: "unresolved";
|
|
107
|
+
}>;
|
|
108
|
+
constraints: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
109
|
+
label: z.ZodString;
|
|
110
|
+
evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
111
|
+
kind: z.ZodLiteral<"observation">;
|
|
112
|
+
source: z.ZodString;
|
|
113
|
+
vintage: z.ZodNullable<z.ZodString>;
|
|
114
|
+
value: z.ZodUnknown;
|
|
115
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
116
|
+
kind: z.ZodLiteral<"exclusion">;
|
|
117
|
+
source: z.ZodString;
|
|
118
|
+
vintage: z.ZodString;
|
|
119
|
+
scope: z.ZodObject<{
|
|
120
|
+
layer: z.ZodString;
|
|
121
|
+
h3Cell: z.ZodNumber;
|
|
122
|
+
basis: z.ZodEnum<{
|
|
123
|
+
designated: "designated";
|
|
124
|
+
surveyed: "surveyed";
|
|
125
|
+
source_present: "source_present";
|
|
126
|
+
}>;
|
|
127
|
+
fold: z.ZodString;
|
|
128
|
+
}, z.core.$strip>;
|
|
129
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
130
|
+
kind: z.ZodLiteral<"relation">;
|
|
131
|
+
source: z.ZodString;
|
|
132
|
+
vintage: z.ZodString;
|
|
133
|
+
relationship: z.ZodString;
|
|
134
|
+
assertion: z.ZodEnum<{
|
|
135
|
+
inferred: "inferred";
|
|
136
|
+
authoritative: "authoritative";
|
|
137
|
+
}>;
|
|
138
|
+
score: z.ZodOptional<z.ZodNumber>;
|
|
139
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
140
|
+
kind: z.ZodLiteral<"prior">;
|
|
141
|
+
source: z.ZodString;
|
|
142
|
+
label: z.ZodString;
|
|
143
|
+
weight: z.ZodNumber;
|
|
144
|
+
}, z.core.$strip>], "kind">;
|
|
145
|
+
contribution: z.ZodString;
|
|
146
|
+
}, z.core.$strip>>>;
|
|
147
|
+
uncertaintyM: z.ZodNullable<z.ZodNumber>;
|
|
148
|
+
}, z.core.$strip>;
|
|
90
149
|
/**
|
|
91
150
|
* `POST /v1/geocode` response — a hand-modeled mirror of `GeocodeResult`'s wire shape (`mailwoman/geocode-core.ts`),
|
|
92
151
|
* `.loose()` so a field the engine adds that this schema doesn't yet know about still rides through undocumented rather
|
|
@@ -94,8 +153,8 @@ export declare const GeocodeRequestSchema: z.ZodObject<{
|
|
|
94
153
|
* (`GeocodeOutcome = Record<string, unknown>`, `api/engine.ts`) — nothing here validates a real response, so a
|
|
95
154
|
* schema/engine mismatch can never reject or mutate a result at runtime. Deliberately carries NO import from
|
|
96
155
|
* `mailwoman` (the engine-agnosticism boundary — `mailwoman` is the one workspace allowed to depend on
|
|
97
|
-
* `@mailwoman/api`, never the reverse). `mailwoman/test/api-schema-drift.test.ts` is the compile-time
|
|
98
|
-
* catches this shape drifting from the real `GeocodeResult` interface.
|
|
156
|
+
* `@mailwoman/api`, never the reverse). `mailwoman/test/api-schema-drift.test.ts` is the compile-time regression check
|
|
157
|
+
* that catches this shape drifting from the real `GeocodeResult` interface.
|
|
99
158
|
*/
|
|
100
159
|
export declare const GeocodeOutcomeLikeSchema: z.ZodObject<{
|
|
101
160
|
input: z.ZodString;
|
|
@@ -125,6 +184,7 @@ export declare const GeocodeOutcomeLikeSchema: z.ZodObject<{
|
|
|
125
184
|
sub_block: "sub_block";
|
|
126
185
|
building_number: "building_number";
|
|
127
186
|
building_name: "building_name";
|
|
187
|
+
locality_unit: "locality_unit";
|
|
128
188
|
}> & z.core.$partial, z.ZodString>;
|
|
129
189
|
lat: z.ZodNullable<z.ZodNumber>;
|
|
130
190
|
lon: z.ZodNullable<z.ZodNumber>;
|
|
@@ -136,6 +196,62 @@ export declare const GeocodeOutcomeLikeSchema: z.ZodObject<{
|
|
|
136
196
|
admin: "admin";
|
|
137
197
|
plus_code: "plus_code";
|
|
138
198
|
}>;
|
|
199
|
+
epistemic_status: z.ZodEnum<{
|
|
200
|
+
designated: "designated";
|
|
201
|
+
observed: "observed";
|
|
202
|
+
derived: "derived";
|
|
203
|
+
inferred: "inferred";
|
|
204
|
+
unresolved: "unresolved";
|
|
205
|
+
}>;
|
|
206
|
+
derivation: z.ZodOptional<z.ZodObject<{
|
|
207
|
+
status: z.ZodEnum<{
|
|
208
|
+
designated: "designated";
|
|
209
|
+
observed: "observed";
|
|
210
|
+
derived: "derived";
|
|
211
|
+
inferred: "inferred";
|
|
212
|
+
unresolved: "unresolved";
|
|
213
|
+
}>;
|
|
214
|
+
constraints: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
215
|
+
label: z.ZodString;
|
|
216
|
+
evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
217
|
+
kind: z.ZodLiteral<"observation">;
|
|
218
|
+
source: z.ZodString;
|
|
219
|
+
vintage: z.ZodNullable<z.ZodString>;
|
|
220
|
+
value: z.ZodUnknown;
|
|
221
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
222
|
+
kind: z.ZodLiteral<"exclusion">;
|
|
223
|
+
source: z.ZodString;
|
|
224
|
+
vintage: z.ZodString;
|
|
225
|
+
scope: z.ZodObject<{
|
|
226
|
+
layer: z.ZodString;
|
|
227
|
+
h3Cell: z.ZodNumber;
|
|
228
|
+
basis: z.ZodEnum<{
|
|
229
|
+
designated: "designated";
|
|
230
|
+
surveyed: "surveyed";
|
|
231
|
+
source_present: "source_present";
|
|
232
|
+
}>;
|
|
233
|
+
fold: z.ZodString;
|
|
234
|
+
}, z.core.$strip>;
|
|
235
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
236
|
+
kind: z.ZodLiteral<"relation">;
|
|
237
|
+
source: z.ZodString;
|
|
238
|
+
vintage: z.ZodString;
|
|
239
|
+
relationship: z.ZodString;
|
|
240
|
+
assertion: z.ZodEnum<{
|
|
241
|
+
inferred: "inferred";
|
|
242
|
+
authoritative: "authoritative";
|
|
243
|
+
}>;
|
|
244
|
+
score: z.ZodOptional<z.ZodNumber>;
|
|
245
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
246
|
+
kind: z.ZodLiteral<"prior">;
|
|
247
|
+
source: z.ZodString;
|
|
248
|
+
label: z.ZodString;
|
|
249
|
+
weight: z.ZodNumber;
|
|
250
|
+
}, z.core.$strip>], "kind">;
|
|
251
|
+
contribution: z.ZodString;
|
|
252
|
+
}, z.core.$strip>>>;
|
|
253
|
+
uncertaintyM: z.ZodNullable<z.ZodNumber>;
|
|
254
|
+
}, z.core.$strip>>;
|
|
139
255
|
entity: z.ZodOptional<z.ZodObject<{
|
|
140
256
|
name: z.ZodString;
|
|
141
257
|
categoryID: z.ZodNullable<z.ZodString>;
|
|
@@ -174,6 +290,8 @@ export declare const GeocodeOutcomeLikeSchema: z.ZodObject<{
|
|
|
174
290
|
postcode: z.ZodOptional<z.ZodString>;
|
|
175
291
|
}, z.core.$strip>>;
|
|
176
292
|
postcode_country_scope: z.ZodNullable<z.ZodString>;
|
|
293
|
+
capital_promotion: z.ZodOptional<z.ZodString>;
|
|
294
|
+
variant_alias_exemption: z.ZodOptional<z.ZodLiteral<true>>;
|
|
177
295
|
intent_markers: z.ZodArray<z.ZodObject<{
|
|
178
296
|
kind: z.ZodEnum<{
|
|
179
297
|
intersection: "intersection";
|
|
@@ -194,6 +312,8 @@ export declare const GeocodeOutcomeLikeSchema: z.ZodObject<{
|
|
|
194
312
|
declared_ambiguity: "declared_ambiguity";
|
|
195
313
|
declared_fork: "declared_fork";
|
|
196
314
|
focus_point_required: "focus_point_required";
|
|
315
|
+
coverage_qualified_absence: "coverage_qualified_absence";
|
|
316
|
+
authority_designation: "authority_designation";
|
|
197
317
|
}>;
|
|
198
318
|
mechanism: z.ZodString;
|
|
199
319
|
message: z.ZodString;
|
|
@@ -213,6 +333,33 @@ export declare const GeocodeOutcomeLikeSchema: z.ZodObject<{
|
|
|
213
333
|
unverifiable: "unverifiable";
|
|
214
334
|
}>;
|
|
215
335
|
}, z.core.$strip>>;
|
|
336
|
+
authoritative: z.ZodOptional<z.ZodObject<{
|
|
337
|
+
provider: z.ZodString;
|
|
338
|
+
status: z.ZodEnum<{
|
|
339
|
+
matched: "matched";
|
|
340
|
+
ambiguous: "ambiguous";
|
|
341
|
+
refused: "refused";
|
|
342
|
+
transport_error: "transport_error";
|
|
343
|
+
}>;
|
|
344
|
+
matches: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
345
|
+
provider_place_id: z.ZodString;
|
|
346
|
+
object_ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
347
|
+
canonical_fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
348
|
+
lat: z.ZodOptional<z.ZodNumber>;
|
|
349
|
+
lon: z.ZodOptional<z.ZodNumber>;
|
|
350
|
+
precision: z.ZodOptional<z.ZodString>;
|
|
351
|
+
match_status: z.ZodEnum<{
|
|
352
|
+
exact: "exact";
|
|
353
|
+
approximate: "approximate";
|
|
354
|
+
}>;
|
|
355
|
+
provider_score: z.ZodOptional<z.ZodNumber>;
|
|
356
|
+
}, z.core.$strip>>>;
|
|
357
|
+
attribution: z.ZodOptional<z.ZodString>;
|
|
358
|
+
license: z.ZodOptional<z.ZodString>;
|
|
359
|
+
retrieved_at: z.ZodOptional<z.ZodString>;
|
|
360
|
+
dataset_version: z.ZodOptional<z.ZodString>;
|
|
361
|
+
error: z.ZodOptional<z.ZodString>;
|
|
362
|
+
}, z.core.$strip>>;
|
|
216
363
|
dropped_components: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
217
364
|
tag: z.ZodEnum<{
|
|
218
365
|
country: "country";
|
|
@@ -240,6 +387,7 @@ export declare const GeocodeOutcomeLikeSchema: z.ZodObject<{
|
|
|
240
387
|
sub_block: "sub_block";
|
|
241
388
|
building_number: "building_number";
|
|
242
389
|
building_name: "building_name";
|
|
390
|
+
locality_unit: "locality_unit";
|
|
243
391
|
}>;
|
|
244
392
|
value: z.ZodString;
|
|
245
393
|
kept: z.ZodString;
|
|
@@ -253,8 +401,8 @@ export type GeocodeOutcomeLike = z.infer<typeof GeocodeOutcomeLikeSchema>;
|
|
|
253
401
|
* (`GeocodeOutcome = Record<string, unknown>`, `api/engine.ts`) — nothing here validates a real response, so a
|
|
254
402
|
* schema/engine mismatch can never reject or mutate a result at runtime. Deliberately carries NO import from
|
|
255
403
|
* `mailwoman` (the engine-agnosticism boundary — `mailwoman` is the one workspace allowed to depend on
|
|
256
|
-
* `@mailwoman/api`, never the reverse). `mailwoman/test/api-schema-drift.test.ts` is the compile-time
|
|
257
|
-
* catches this shape drifting from the real `GeocodeResult` interface.
|
|
404
|
+
* `@mailwoman/api`, never the reverse). `mailwoman/test/api-schema-drift.test.ts` is the compile-time regression check
|
|
405
|
+
* that catches this shape drifting from the real `GeocodeResult` interface.
|
|
258
406
|
*/
|
|
259
407
|
export declare const GeocodeOutcomeSchema: z.ZodObject<{
|
|
260
408
|
input: z.ZodString;
|
|
@@ -284,6 +432,7 @@ export declare const GeocodeOutcomeSchema: z.ZodObject<{
|
|
|
284
432
|
sub_block: "sub_block";
|
|
285
433
|
building_number: "building_number";
|
|
286
434
|
building_name: "building_name";
|
|
435
|
+
locality_unit: "locality_unit";
|
|
287
436
|
}> & z.core.$partial, z.ZodString>;
|
|
288
437
|
lat: z.ZodNullable<z.ZodNumber>;
|
|
289
438
|
lon: z.ZodNullable<z.ZodNumber>;
|
|
@@ -295,6 +444,62 @@ export declare const GeocodeOutcomeSchema: z.ZodObject<{
|
|
|
295
444
|
admin: "admin";
|
|
296
445
|
plus_code: "plus_code";
|
|
297
446
|
}>;
|
|
447
|
+
epistemic_status: z.ZodEnum<{
|
|
448
|
+
designated: "designated";
|
|
449
|
+
observed: "observed";
|
|
450
|
+
derived: "derived";
|
|
451
|
+
inferred: "inferred";
|
|
452
|
+
unresolved: "unresolved";
|
|
453
|
+
}>;
|
|
454
|
+
derivation: z.ZodOptional<z.ZodObject<{
|
|
455
|
+
status: z.ZodEnum<{
|
|
456
|
+
designated: "designated";
|
|
457
|
+
observed: "observed";
|
|
458
|
+
derived: "derived";
|
|
459
|
+
inferred: "inferred";
|
|
460
|
+
unresolved: "unresolved";
|
|
461
|
+
}>;
|
|
462
|
+
constraints: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
463
|
+
label: z.ZodString;
|
|
464
|
+
evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
465
|
+
kind: z.ZodLiteral<"observation">;
|
|
466
|
+
source: z.ZodString;
|
|
467
|
+
vintage: z.ZodNullable<z.ZodString>;
|
|
468
|
+
value: z.ZodUnknown;
|
|
469
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
470
|
+
kind: z.ZodLiteral<"exclusion">;
|
|
471
|
+
source: z.ZodString;
|
|
472
|
+
vintage: z.ZodString;
|
|
473
|
+
scope: z.ZodObject<{
|
|
474
|
+
layer: z.ZodString;
|
|
475
|
+
h3Cell: z.ZodNumber;
|
|
476
|
+
basis: z.ZodEnum<{
|
|
477
|
+
designated: "designated";
|
|
478
|
+
surveyed: "surveyed";
|
|
479
|
+
source_present: "source_present";
|
|
480
|
+
}>;
|
|
481
|
+
fold: z.ZodString;
|
|
482
|
+
}, z.core.$strip>;
|
|
483
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
484
|
+
kind: z.ZodLiteral<"relation">;
|
|
485
|
+
source: z.ZodString;
|
|
486
|
+
vintage: z.ZodString;
|
|
487
|
+
relationship: z.ZodString;
|
|
488
|
+
assertion: z.ZodEnum<{
|
|
489
|
+
inferred: "inferred";
|
|
490
|
+
authoritative: "authoritative";
|
|
491
|
+
}>;
|
|
492
|
+
score: z.ZodOptional<z.ZodNumber>;
|
|
493
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
494
|
+
kind: z.ZodLiteral<"prior">;
|
|
495
|
+
source: z.ZodString;
|
|
496
|
+
label: z.ZodString;
|
|
497
|
+
weight: z.ZodNumber;
|
|
498
|
+
}, z.core.$strip>], "kind">;
|
|
499
|
+
contribution: z.ZodString;
|
|
500
|
+
}, z.core.$strip>>>;
|
|
501
|
+
uncertaintyM: z.ZodNullable<z.ZodNumber>;
|
|
502
|
+
}, z.core.$strip>>;
|
|
298
503
|
entity: z.ZodOptional<z.ZodObject<{
|
|
299
504
|
name: z.ZodString;
|
|
300
505
|
categoryID: z.ZodNullable<z.ZodString>;
|
|
@@ -333,6 +538,8 @@ export declare const GeocodeOutcomeSchema: z.ZodObject<{
|
|
|
333
538
|
postcode: z.ZodOptional<z.ZodString>;
|
|
334
539
|
}, z.core.$strip>>;
|
|
335
540
|
postcode_country_scope: z.ZodNullable<z.ZodString>;
|
|
541
|
+
capital_promotion: z.ZodOptional<z.ZodString>;
|
|
542
|
+
variant_alias_exemption: z.ZodOptional<z.ZodLiteral<true>>;
|
|
336
543
|
intent_markers: z.ZodArray<z.ZodObject<{
|
|
337
544
|
kind: z.ZodEnum<{
|
|
338
545
|
intersection: "intersection";
|
|
@@ -353,6 +560,8 @@ export declare const GeocodeOutcomeSchema: z.ZodObject<{
|
|
|
353
560
|
declared_ambiguity: "declared_ambiguity";
|
|
354
561
|
declared_fork: "declared_fork";
|
|
355
562
|
focus_point_required: "focus_point_required";
|
|
563
|
+
coverage_qualified_absence: "coverage_qualified_absence";
|
|
564
|
+
authority_designation: "authority_designation";
|
|
356
565
|
}>;
|
|
357
566
|
mechanism: z.ZodString;
|
|
358
567
|
message: z.ZodString;
|
|
@@ -372,6 +581,33 @@ export declare const GeocodeOutcomeSchema: z.ZodObject<{
|
|
|
372
581
|
unverifiable: "unverifiable";
|
|
373
582
|
}>;
|
|
374
583
|
}, z.core.$strip>>;
|
|
584
|
+
authoritative: z.ZodOptional<z.ZodObject<{
|
|
585
|
+
provider: z.ZodString;
|
|
586
|
+
status: z.ZodEnum<{
|
|
587
|
+
matched: "matched";
|
|
588
|
+
ambiguous: "ambiguous";
|
|
589
|
+
refused: "refused";
|
|
590
|
+
transport_error: "transport_error";
|
|
591
|
+
}>;
|
|
592
|
+
matches: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
593
|
+
provider_place_id: z.ZodString;
|
|
594
|
+
object_ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
595
|
+
canonical_fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
596
|
+
lat: z.ZodOptional<z.ZodNumber>;
|
|
597
|
+
lon: z.ZodOptional<z.ZodNumber>;
|
|
598
|
+
precision: z.ZodOptional<z.ZodString>;
|
|
599
|
+
match_status: z.ZodEnum<{
|
|
600
|
+
exact: "exact";
|
|
601
|
+
approximate: "approximate";
|
|
602
|
+
}>;
|
|
603
|
+
provider_score: z.ZodOptional<z.ZodNumber>;
|
|
604
|
+
}, z.core.$strip>>>;
|
|
605
|
+
attribution: z.ZodOptional<z.ZodString>;
|
|
606
|
+
license: z.ZodOptional<z.ZodString>;
|
|
607
|
+
retrieved_at: z.ZodOptional<z.ZodString>;
|
|
608
|
+
dataset_version: z.ZodOptional<z.ZodString>;
|
|
609
|
+
error: z.ZodOptional<z.ZodString>;
|
|
610
|
+
}, z.core.$strip>>;
|
|
375
611
|
dropped_components: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
376
612
|
tag: z.ZodEnum<{
|
|
377
613
|
country: "country";
|
|
@@ -399,6 +635,7 @@ export declare const GeocodeOutcomeSchema: z.ZodObject<{
|
|
|
399
635
|
sub_block: "sub_block";
|
|
400
636
|
building_number: "building_number";
|
|
401
637
|
building_name: "building_name";
|
|
638
|
+
locality_unit: "locality_unit";
|
|
402
639
|
}>;
|
|
403
640
|
value: z.ZodString;
|
|
404
641
|
kept: z.ZodString;
|
|
@@ -447,6 +684,7 @@ export declare const BatchResponseSchema: z.ZodObject<{
|
|
|
447
684
|
sub_block: "sub_block";
|
|
448
685
|
building_number: "building_number";
|
|
449
686
|
building_name: "building_name";
|
|
687
|
+
locality_unit: "locality_unit";
|
|
450
688
|
}> & z.core.$partial, z.ZodString>;
|
|
451
689
|
lat: z.ZodNullable<z.ZodNumber>;
|
|
452
690
|
lon: z.ZodNullable<z.ZodNumber>;
|
|
@@ -458,6 +696,62 @@ export declare const BatchResponseSchema: z.ZodObject<{
|
|
|
458
696
|
admin: "admin";
|
|
459
697
|
plus_code: "plus_code";
|
|
460
698
|
}>;
|
|
699
|
+
epistemic_status: z.ZodEnum<{
|
|
700
|
+
designated: "designated";
|
|
701
|
+
observed: "observed";
|
|
702
|
+
derived: "derived";
|
|
703
|
+
inferred: "inferred";
|
|
704
|
+
unresolved: "unresolved";
|
|
705
|
+
}>;
|
|
706
|
+
derivation: z.ZodOptional<z.ZodObject<{
|
|
707
|
+
status: z.ZodEnum<{
|
|
708
|
+
designated: "designated";
|
|
709
|
+
observed: "observed";
|
|
710
|
+
derived: "derived";
|
|
711
|
+
inferred: "inferred";
|
|
712
|
+
unresolved: "unresolved";
|
|
713
|
+
}>;
|
|
714
|
+
constraints: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
715
|
+
label: z.ZodString;
|
|
716
|
+
evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
717
|
+
kind: z.ZodLiteral<"observation">;
|
|
718
|
+
source: z.ZodString;
|
|
719
|
+
vintage: z.ZodNullable<z.ZodString>;
|
|
720
|
+
value: z.ZodUnknown;
|
|
721
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
722
|
+
kind: z.ZodLiteral<"exclusion">;
|
|
723
|
+
source: z.ZodString;
|
|
724
|
+
vintage: z.ZodString;
|
|
725
|
+
scope: z.ZodObject<{
|
|
726
|
+
layer: z.ZodString;
|
|
727
|
+
h3Cell: z.ZodNumber;
|
|
728
|
+
basis: z.ZodEnum<{
|
|
729
|
+
designated: "designated";
|
|
730
|
+
surveyed: "surveyed";
|
|
731
|
+
source_present: "source_present";
|
|
732
|
+
}>;
|
|
733
|
+
fold: z.ZodString;
|
|
734
|
+
}, z.core.$strip>;
|
|
735
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
736
|
+
kind: z.ZodLiteral<"relation">;
|
|
737
|
+
source: z.ZodString;
|
|
738
|
+
vintage: z.ZodString;
|
|
739
|
+
relationship: z.ZodString;
|
|
740
|
+
assertion: z.ZodEnum<{
|
|
741
|
+
inferred: "inferred";
|
|
742
|
+
authoritative: "authoritative";
|
|
743
|
+
}>;
|
|
744
|
+
score: z.ZodOptional<z.ZodNumber>;
|
|
745
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
746
|
+
kind: z.ZodLiteral<"prior">;
|
|
747
|
+
source: z.ZodString;
|
|
748
|
+
label: z.ZodString;
|
|
749
|
+
weight: z.ZodNumber;
|
|
750
|
+
}, z.core.$strip>], "kind">;
|
|
751
|
+
contribution: z.ZodString;
|
|
752
|
+
}, z.core.$strip>>>;
|
|
753
|
+
uncertaintyM: z.ZodNullable<z.ZodNumber>;
|
|
754
|
+
}, z.core.$strip>>;
|
|
461
755
|
entity: z.ZodOptional<z.ZodObject<{
|
|
462
756
|
name: z.ZodString;
|
|
463
757
|
categoryID: z.ZodNullable<z.ZodString>;
|
|
@@ -496,6 +790,8 @@ export declare const BatchResponseSchema: z.ZodObject<{
|
|
|
496
790
|
postcode: z.ZodOptional<z.ZodString>;
|
|
497
791
|
}, z.core.$strip>>;
|
|
498
792
|
postcode_country_scope: z.ZodNullable<z.ZodString>;
|
|
793
|
+
capital_promotion: z.ZodOptional<z.ZodString>;
|
|
794
|
+
variant_alias_exemption: z.ZodOptional<z.ZodLiteral<true>>;
|
|
499
795
|
intent_markers: z.ZodArray<z.ZodObject<{
|
|
500
796
|
kind: z.ZodEnum<{
|
|
501
797
|
intersection: "intersection";
|
|
@@ -516,6 +812,8 @@ export declare const BatchResponseSchema: z.ZodObject<{
|
|
|
516
812
|
declared_ambiguity: "declared_ambiguity";
|
|
517
813
|
declared_fork: "declared_fork";
|
|
518
814
|
focus_point_required: "focus_point_required";
|
|
815
|
+
coverage_qualified_absence: "coverage_qualified_absence";
|
|
816
|
+
authority_designation: "authority_designation";
|
|
519
817
|
}>;
|
|
520
818
|
mechanism: z.ZodString;
|
|
521
819
|
message: z.ZodString;
|
|
@@ -535,6 +833,33 @@ export declare const BatchResponseSchema: z.ZodObject<{
|
|
|
535
833
|
unverifiable: "unverifiable";
|
|
536
834
|
}>;
|
|
537
835
|
}, z.core.$strip>>;
|
|
836
|
+
authoritative: z.ZodOptional<z.ZodObject<{
|
|
837
|
+
provider: z.ZodString;
|
|
838
|
+
status: z.ZodEnum<{
|
|
839
|
+
matched: "matched";
|
|
840
|
+
ambiguous: "ambiguous";
|
|
841
|
+
refused: "refused";
|
|
842
|
+
transport_error: "transport_error";
|
|
843
|
+
}>;
|
|
844
|
+
matches: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
845
|
+
provider_place_id: z.ZodString;
|
|
846
|
+
object_ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
847
|
+
canonical_fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
848
|
+
lat: z.ZodOptional<z.ZodNumber>;
|
|
849
|
+
lon: z.ZodOptional<z.ZodNumber>;
|
|
850
|
+
precision: z.ZodOptional<z.ZodString>;
|
|
851
|
+
match_status: z.ZodEnum<{
|
|
852
|
+
exact: "exact";
|
|
853
|
+
approximate: "approximate";
|
|
854
|
+
}>;
|
|
855
|
+
provider_score: z.ZodOptional<z.ZodNumber>;
|
|
856
|
+
}, z.core.$strip>>>;
|
|
857
|
+
attribution: z.ZodOptional<z.ZodString>;
|
|
858
|
+
license: z.ZodOptional<z.ZodString>;
|
|
859
|
+
retrieved_at: z.ZodOptional<z.ZodString>;
|
|
860
|
+
dataset_version: z.ZodOptional<z.ZodString>;
|
|
861
|
+
error: z.ZodOptional<z.ZodString>;
|
|
862
|
+
}, z.core.$strip>>;
|
|
538
863
|
dropped_components: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
539
864
|
tag: z.ZodEnum<{
|
|
540
865
|
country: "country";
|
|
@@ -562,6 +887,7 @@ export declare const BatchResponseSchema: z.ZodObject<{
|
|
|
562
887
|
sub_block: "sub_block";
|
|
563
888
|
building_number: "building_number";
|
|
564
889
|
building_name: "building_name";
|
|
890
|
+
locality_unit: "locality_unit";
|
|
565
891
|
}>;
|
|
566
892
|
value: z.ZodString;
|
|
567
893
|
kept: z.ZodString;
|
|
@@ -577,7 +903,8 @@ export declare const BatchResponseSchema: z.ZodObject<{
|
|
|
577
903
|
*/
|
|
578
904
|
export declare const ResolveRequestSchema: z.ZodObject<{
|
|
579
905
|
tree: z.ZodObject<{
|
|
580
|
-
|
|
906
|
+
raw: z.ZodString;
|
|
907
|
+
roots: z.ZodArray<z.ZodCustom<AddressNode, AddressNode>>;
|
|
581
908
|
}, z.core.$loose>;
|
|
582
909
|
opts: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
|
|
583
910
|
}, z.core.$strip>;
|
|
@@ -586,7 +913,8 @@ export declare const ResolveRequestSchema: z.ZodObject<{
|
|
|
586
913
|
*/
|
|
587
914
|
export declare const ResolveResponseSchema: z.ZodObject<{
|
|
588
915
|
tree: z.ZodObject<{
|
|
589
|
-
|
|
916
|
+
raw: z.ZodString;
|
|
917
|
+
roots: z.ZodArray<z.ZodCustom<AddressNode, AddressNode>>;
|
|
590
918
|
}, z.core.$loose>;
|
|
591
919
|
}, z.core.$strip>;
|
|
592
920
|
/**
|
|
@@ -609,9 +937,11 @@ export declare const FormatResponseSchema: z.ZodObject<{
|
|
|
609
937
|
}, z.core.$strip>;
|
|
610
938
|
/**
|
|
611
939
|
* `GET /health` response — `status`/`uptime_s` are stamped by the ROUTE itself, unconditionally, regardless of engine
|
|
612
|
-
* (`api/routes.ts`'s `healthRoute` handler: `{ status: "ok", uptime_s, ...engine.health?.() }`), so those two are
|
|
613
|
-
*
|
|
614
|
-
*
|
|
940
|
+
* (`api/routes.ts`'s `healthRoute` handler: `{ status: "ok", uptime_s, ...engine.health?.() }`), so those two are
|
|
941
|
+
* cheap
|
|
942
|
+
*
|
|
943
|
+
* - Accurate to pin. Everything else is `HealthData` (`api/engine.ts`) — an engine-defined block (model card, data-root
|
|
944
|
+
* inventory for `mailwoman serve`; something else entirely for another engine) — stays loose.
|
|
615
945
|
*/
|
|
616
946
|
export declare const HealthResponseSchema: z.ZodObject<{
|
|
617
947
|
status: z.ZodLiteral<"ok">;
|
package/out/schema.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAA;
|
|
1
|
+
{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../lib/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAA;AACrC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAG1D;;GAEG;AACH;;;GAGG;AACH,eAAO,MAAM,iBAAiB,uCAK5B,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;EAA2D,CAAA;AAEvF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,OAAO,CAAA;AAEtC;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;iBAMN,CAAA;AAEzB;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;iBAA6E,CAAA;AAE9G;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;iBAON,CAAA;AAEzB;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;iBAKN,CAAA;AAgK3B;;;GAGG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIrC,CAAA;AAUF;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmGnC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA6D,CAAA;AAE9F,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;iBAUN,CAAA;AAYzB;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIN,CAAA;AAE1B;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;iBAKN,CAAA;AAE3B;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;iBAIN,CAAA;AAQ5B;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;iBAMN,CAAA;AAE1B;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;iBAKN,CAAA;AAE3B;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB;;;iBAMN,CAAA"}
|