@opencrvs/toolkit 2.1.0-rc.9254c79 → 2.1.0-rc.93572dd

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.
@@ -47,14 +47,14 @@ function joinUrl(base, path) {
47
47
  }
48
48
 
49
49
  // ../commons/src/events/AuditLog.ts
50
- var z8 = __toESM(require("zod/v4"));
50
+ var z5 = __toESM(require("zod/v4"));
51
51
 
52
52
  // ../commons/src/authentication.ts
53
53
  var import_jwt_decode = __toESM(require("jwt-decode"));
54
- var z7 = __toESM(require("zod/v4"));
54
+ var z3 = __toESM(require("zod/v4"));
55
55
 
56
56
  // ../commons/src/scopes.ts
57
- var z6 = __toESM(require("zod/v4"));
57
+ var z2 = __toESM(require("zod/v4"));
58
58
  var qs = __toESM(require("qs"));
59
59
 
60
60
  // ../commons/src/uuid.ts
@@ -65,264 +65,12 @@ function getUUID() {
65
65
  return (0, import_uuid.v4)();
66
66
  }
67
67
 
68
- // ../commons/src/events/ActionType.ts
69
- var z2 = __toESM(require("zod/v4"));
70
- var ActionType = {
71
- // Pre-declaration actions
72
- DELETE: "DELETE",
73
- CREATE: "CREATE",
74
- NOTIFY: "NOTIFY",
75
- // Declaration actions
76
- DECLARE: "DECLARE",
77
- REGISTER: "REGISTER",
78
- EDIT: "EDIT",
79
- // Declaration system actions. Non-configurable.
80
- DUPLICATE_DETECTED: "DUPLICATE_DETECTED",
81
- REJECT: "REJECT",
82
- // REJECT_DECLARATION
83
- MARK_AS_DUPLICATE: "MARK_AS_DUPLICATE",
84
- MARK_AS_NOT_DUPLICATE: "MARK_AS_NOT_DUPLICATE",
85
- ARCHIVE: "ARCHIVE",
86
- UNARCHIVE: "UNARCHIVE",
87
- // Record actions
88
- PRINT_CERTIFICATE: "PRINT_CERTIFICATE",
89
- REQUEST_CORRECTION: "REQUEST_CORRECTION",
90
- REJECT_CORRECTION: "REJECT_CORRECTION",
91
- APPROVE_CORRECTION: "APPROVE_CORRECTION",
92
- // General actions
93
- READ: "READ",
94
- ASSIGN: "ASSIGN",
95
- UNASSIGN: "UNASSIGN",
96
- // Custom action
97
- CUSTOM: "CUSTOM"
98
- };
99
- var ConfirmableActions = [
100
- ActionType.NOTIFY,
101
- ActionType.DECLARE,
102
- ActionType.EDIT,
103
- ActionType.REGISTER,
104
- ActionType.REJECT,
105
- ActionType.ARCHIVE,
106
- ActionType.UNARCHIVE,
107
- ActionType.PRINT_CERTIFICATE,
108
- ActionType.REQUEST_CORRECTION,
109
- ActionType.APPROVE_CORRECTION,
110
- ActionType.REJECT_CORRECTION,
111
- ActionType.CUSTOM
112
- ];
113
- var ActionTypes = z2.enum([
114
- "DELETE",
115
- "CREATE",
116
- "NOTIFY",
117
- "DECLARE",
118
- "EDIT",
119
- "REGISTER",
120
- "DUPLICATE_DETECTED",
121
- "REJECT",
122
- "MARK_AS_DUPLICATE",
123
- "MARK_AS_NOT_DUPLICATE",
124
- "ARCHIVE",
125
- "UNARCHIVE",
126
- "PRINT_CERTIFICATE",
127
- "REQUEST_CORRECTION",
128
- "REJECT_CORRECTION",
129
- "APPROVE_CORRECTION",
130
- "READ",
131
- "ASSIGN",
132
- "UNASSIGN",
133
- "CUSTOM"
134
- ]);
135
- var ClientSpecificAction = {
136
- REVIEW_CORRECTION_REQUEST: "REVIEW_CORRECTION_REQUEST"
137
- };
138
- var declarationActionValues = [
139
- ActionTypes.enum.DECLARE,
140
- ActionTypes.enum.EDIT,
141
- ActionTypes.enum.REGISTER,
142
- ActionTypes.enum.NOTIFY,
143
- ActionTypes.enum.DUPLICATE_DETECTED
144
- ];
145
- var DeclarationActions = ActionTypes.extract(declarationActionValues);
146
- var declarationUpdateActionValues = [
147
- ...declarationActionValues,
148
- ActionTypes.enum.REQUEST_CORRECTION
149
- ];
150
- var DeclarationUpdateActions = ActionTypes.extract(
151
- declarationUpdateActionValues
152
- );
153
- var annotationActions = ActionTypes.exclude(declarationActionValues);
154
- var writeActions = ActionTypes.exclude([
155
- ActionType.CREATE,
156
- ActionType.READ,
157
- ActionType.ASSIGN,
158
- ActionType.UNASSIGN
159
- ]);
160
- var WorkqueueActionType = ActionTypes.extract([
161
- ActionType.READ,
162
- ActionType.DELETE,
163
- ActionType.DECLARE,
164
- ActionType.REGISTER,
165
- ActionType.EDIT,
166
- ActionType.REJECT,
167
- ActionType.MARK_AS_DUPLICATE,
168
- ActionType.ARCHIVE,
169
- ActionType.UNARCHIVE,
170
- ActionType.PRINT_CERTIFICATE,
171
- ActionType.REQUEST_CORRECTION
172
- ]);
173
- var META_ACTIONS = [
174
- ActionType.ASSIGN,
175
- ActionType.UNASSIGN,
176
- ActionType.READ
177
- ];
178
- function isMetaAction(actionType) {
179
- return META_ACTIONS.includes(actionType);
180
- }
181
-
182
- // ../commons/src/events/ActionStatus.ts
183
- var ActionStatus = {
184
- Requested: "Requested",
185
- Accepted: "Accepted",
186
- Rejected: "Rejected"
187
- };
188
-
189
- // ../commons/src/events/Flag.ts
190
- var z5 = __toESM(require("zod/v4"));
191
-
192
- // ../commons/src/events/TranslationConfig.ts
193
- var z3 = __toESM(require("zod/v4"));
194
- var TranslationConfig = z3.object({
195
- id: z3.string().describe(
196
- "The identifier of the translation referred in translation CSV files"
197
- ),
198
- defaultMessage: z3.string().describe("Default translation message"),
199
- description: z3.string().describe(
200
- "Describe the translation for a translator to be able to identify it."
201
- )
202
- }).meta({
203
- description: "Translation configuration",
204
- id: "TranslationConfig"
205
- });
206
-
207
- // ../commons/src/events/Conditional.ts
208
- var z4 = __toESM(require("zod/v4"));
209
- var Conditional = z4.any().describe("JSONSchema").meta({
210
- description: "JSON schema conditional configuration",
211
- id: "Conditional"
212
- });
213
- var ConditionalType = {
214
- SHOW: "SHOW",
215
- ENABLE: "ENABLE",
216
- DISPLAY_ON_REVIEW: "DISPLAY_ON_REVIEW"
217
- };
218
- var ShowConditional = z4.object({
219
- type: z4.literal(ConditionalType.SHOW),
220
- conditional: Conditional
221
- }).describe(
222
- "If 'SHOW' conditional is defined, the component is shown to the user only if the condition is met"
223
- );
224
- var EnableConditional = z4.object({
225
- type: z4.literal(ConditionalType.ENABLE),
226
- conditional: Conditional
227
- }).describe(
228
- "If 'ENABLE' conditional is defined, the component is enabled only if the condition is met"
229
- );
230
- var ActionConditional = z4.discriminatedUnion("type", [
231
- // Action can be shown / hidden
232
- ShowConditional,
233
- // Action can be shown to the user in the list but as disabled
234
- EnableConditional
235
- ]).meta({
236
- id: "ActionConditional",
237
- description: "Conditional gating whether an action is shown (SHOW) or enabled (ENABLE). When omitted from an action, the action is shown and enabled for everyone."
238
- });
239
- var DisplayOnReviewConditional = z4.object({
240
- type: z4.literal(ConditionalType.DISPLAY_ON_REVIEW),
241
- conditional: Conditional
242
- }).describe(
243
- "If 'DISPLAY_ON_REVIEW' conditional is defined, the component is shown on the review page only if both the 'DISPLAY_ON_REVIEW' and 'SHOW' conditions are met. This should only be used for fields within declaration forms, as they are the only ones with review pages."
244
- );
245
- var FieldConditional = z4.discriminatedUnion("type", [
246
- // Field input can be shown / hidden
247
- ShowConditional,
248
- // Field input can be shown to the user but as disabled
249
- EnableConditional,
250
- // Field output can be shown / hidden on the review page
251
- DisplayOnReviewConditional
252
- ]).meta({
253
- id: "FieldConditional",
254
- description: "Conditional gating whether a form field is shown (SHOW), enabled (ENABLE), or displayed on the review page (DISPLAY_ON_REVIEW). When omitted, the field is shown and enabled for everyone, and is displayed on review whenever it has a value."
255
- });
256
-
257
- // ../commons/src/events/Flag.ts
258
- var InherentFlags = {
259
- INCOMPLETE: "incomplete",
260
- REJECTED: "rejected",
261
- CORRECTION_REQUESTED: "correction-requested",
262
- POTENTIAL_DUPLICATE: "potential-duplicate",
263
- /**
264
- * This flag is set by the Edit-action and removed after the declaration or registration.
265
- * A record should never stay with the EDIT_IN_PROGRESS flag, since it should always be declared or registered right after.
266
- *
267
- * We only use this flag to determine that a NOTIFY, DECLARE or REGISTER action is allowed next.
268
- */
269
- EDIT_IN_PROGRESS: "edit-in-progress",
270
- SEALED: "sealed"
271
- };
272
- var actionFlagPattern;
273
- function getActionFlagPattern() {
274
- actionFlagPattern ??= new RegExp(
275
- `^(${Object.values(ActionType).join("|").toLowerCase()}):(${Object.values(
276
- ActionStatus
277
- ).join("|").toLowerCase()})$`
278
- );
279
- return actionFlagPattern;
280
- }
281
- var ActionFlag = z5.string().refine((value) => getActionFlagPattern().test(value), {
282
- message: "Flag must be in the format ActionType:ActionStatus (lowerCase)"
283
- });
284
- var CustomFlag = z5.string().refine((val) => !Object.values(InherentFlags).includes(val), {
285
- message: `Custom flag cannot be one of the inherent flags: ${Object.values(
286
- InherentFlags
287
- ).join(", ")}`
288
- }).refine((val) => !ActionFlag.safeParse(val).success, {
289
- message: "Custom flag cannot match the ActionFlag pattern (ActionType:ActionStatus)."
290
- }).describe("Custom flag identifier defined by the country config.");
291
- var Flag = ActionFlag.or(z5.enum(InherentFlags)).or(CustomFlag);
292
- var ContainsFlags = z5.object({
293
- anyOf: z5.array(Flag).optional(),
294
- noneOf: z5.array(Flag).optional(),
295
- allOf: z5.array(Flag).optional()
296
- }).meta({
297
- id: "ContainsFlags"
298
- });
299
- var FlagConfig = z5.object({
300
- id: CustomFlag,
301
- requiresAction: z5.boolean().describe(
302
- "Indicates if this flag expects an action to be performed to be cleared."
303
- ),
304
- label: TranslationConfig.describe("Human readable label of the flag.")
305
- }).meta({
306
- id: "FlagConfig",
307
- description: "Configuration for a custom flag that can be added to or removed from records by event actions."
308
- });
309
- var ActionFlagConfig = z5.object({
310
- id: Flag,
311
- operation: z5.enum(["add", "remove"]).describe("Operation to perform on the flag."),
312
- conditional: Conditional.optional().describe(
313
- "When conditional is met, the operation is performed on the flag. If not provided, the operation is performed unconditionally."
314
- )
315
- }).meta({
316
- id: "ActionFlagConfig",
317
- description: "Add or remove operation applied to a flag when the parent action is accepted. Optionally gated by a conditional."
318
- });
319
-
320
68
  // ../commons/src/scopes.ts
321
- var JurisdictionFilter = z6.enum(["administrativeArea", "location", "all"]).describe(
69
+ var JurisdictionFilter = z2.enum(["administrativeArea", "location", "all"]).describe(
322
70
  "Filters based on user jurisdiction relative to their office location in hierarchy."
323
71
  );
324
- var UserFilter = z6.enum(["user"]).describe("Filters based on the user. Limits to self.");
325
- var RecordScopeTypeV2 = z6.enum([
72
+ var UserFilter = z2.enum(["user"]).describe("Filters based on the user. Limits to self.");
73
+ var RecordScopeTypeV2 = z2.enum([
326
74
  "record.search",
327
75
  "record.create",
328
76
  "record.read",
@@ -340,7 +88,7 @@ var RecordScopeTypeV2 = z6.enum([
340
88
  "record.unassign-others",
341
89
  "record.custom-action"
342
90
  ]);
343
- var PlainScopeType = z6.enum([
91
+ var PlainScopeType = z2.enum([
344
92
  // Misc. system scopes
345
93
  "bypassratelimit",
346
94
  "record.reindex",
@@ -359,15 +107,15 @@ var PlainScopeType = z6.enum([
359
107
  "record.confirm-registration",
360
108
  "record.reject-registration"
361
109
  ]);
362
- var scopeByEvent = z6.preprocess(
110
+ var scopeByEvent = z2.preprocess(
363
111
  (val) => val === void 0 ? void 0 : [val].flat(),
364
- z6.array(z6.string()).optional()
112
+ z2.array(z2.string()).optional()
365
113
  ).describe("Event type, e.g. birth, death");
366
- var userRole = z6.preprocess(
114
+ var userRole = z2.preprocess(
367
115
  (val) => val === void 0 ? void 0 : [val].flat(),
368
- z6.array(z6.string()).optional()
116
+ z2.array(z2.string()).optional()
369
117
  ).describe("User role, e.g. admin, field agent");
370
- var scopeOptionsPlaceEvent = z6.object({
118
+ var scopeOptionsPlaceEvent = z2.object({
371
119
  event: scopeByEvent,
372
120
  placeOfEvent: JurisdictionFilter.optional()
373
121
  }).describe("Options applicable to all record scopes.");
@@ -379,37 +127,36 @@ var scopeOptionsDeclaredOrNotified = scopeOptionsPlaceEvent.extend({
379
127
  }).describe("Options applicable to actions that may take place after DECLARE");
380
128
  var AllRecordScopeOptions = scopeOptionsDeclaredOrNotified.extend({
381
129
  registeredIn: JurisdictionFilter.optional(),
382
- registeredBy: UserFilter.optional(),
383
- flags: ContainsFlags.optional()
130
+ registeredBy: UserFilter.optional()
384
131
  }).describe(
385
132
  "Options applicable to actions that may take place after REGISTER, with full filtering capabilities."
386
133
  );
387
134
  var CustomActionScopeOptions = AllRecordScopeOptions.extend({
388
- customActionTypes: z6.preprocess(
135
+ customActionTypes: z2.preprocess(
389
136
  (val) => val === void 0 ? void 0 : [val].flat(),
390
- z6.array(z6.string()).optional()
137
+ z2.array(z2.string()).optional()
391
138
  ).describe("Allowed custom action types")
392
139
  });
393
- var AccessLevelOptions = z6.object({
140
+ var AccessLevelOptions = z2.object({
394
141
  accessLevel: JurisdictionFilter.optional()
395
142
  });
396
143
  var AllUserScopeOptions = AccessLevelOptions.extend({
397
144
  role: userRole.optional()
398
145
  });
399
- var WorkqueueOrDashboardOptions = z6.object({
400
- ids: z6.preprocess(
146
+ var WorkqueueOrDashboardOptions = z2.object({
147
+ ids: z2.preprocess(
401
148
  (val) => val === void 0 ? void 0 : [val].flat(),
402
- z6.array(z6.string())
149
+ z2.array(z2.string())
403
150
  ).describe("Must contain a list of workqueue or dashboard ids.")
404
151
  });
405
- var AllScopeOptions = z6.object({
152
+ var AllScopeOptions = z2.object({
406
153
  ...AllRecordScopeOptions.shape,
407
154
  ...AccessLevelOptions.shape,
408
155
  ...AllUserScopeOptions.shape,
409
156
  ...WorkqueueOrDashboardOptions.shape
410
157
  });
411
158
  var ScopeOptionKey = AllScopeOptions.keyof();
412
- var ResolvedScopeOptionsPlaceEvent = z6.object({
159
+ var ResolvedScopeOptionsPlaceEvent = z2.object({
413
160
  event: scopeByEvent,
414
161
  placeOfEvent: UUID.nullish()
415
162
  }).describe(
@@ -417,16 +164,15 @@ var ResolvedScopeOptionsPlaceEvent = z6.object({
417
164
  );
418
165
  var ResolvedScopeOptionsDeclared = ResolvedScopeOptionsPlaceEvent.extend({
419
166
  notifiedIn: UUID.nullish(),
420
- notifiedBy: z6.string().optional(),
167
+ notifiedBy: z2.string().optional(),
421
168
  declaredIn: UUID.nullish(),
422
- declaredBy: z6.string().optional()
169
+ declaredBy: z2.string().optional()
423
170
  }).describe(
424
171
  "Resolved options applicable to actions that may take place after DECLARE, with location ID and user ID instead of filters."
425
172
  );
426
173
  var ResolvedScopeOptionsFull = ResolvedScopeOptionsDeclared.extend({
427
174
  registeredIn: UUID.nullish(),
428
- registeredBy: z6.string().optional(),
429
- flags: ContainsFlags.optional()
175
+ registeredBy: z2.string().optional()
430
176
  }).describe(
431
177
  "Resolved options applicable to actions that may take place after REGISTER, with full filtering capabilities and location/user IDs instead of filters."
432
178
  );
@@ -451,38 +197,38 @@ var ScopesWithFullOptions = RecordScopeTypeV2.extract([
451
197
  "record.unassign-others"
452
198
  ]);
453
199
  var ScopeOptionsPrintCertifiedCopies = AllRecordScopeOptions.extend({
454
- templates: z6.preprocess(
200
+ templates: z2.preprocess(
455
201
  (val) => val === void 0 ? void 0 : [val].flat(),
456
- z6.array(z6.string()).optional()
202
+ z2.array(z2.string()).optional()
457
203
  ).describe(
458
204
  "Template IDs for certified copies. Controls which certificate templates are returned to the client via the config service. Certificate printing is a client-side operation \u2014 this option is not validated when the printCertificate action is submitted."
459
205
  )
460
206
  });
461
- var RecordScopeV2 = z6.discriminatedUnion("type", [
462
- z6.object({
207
+ var RecordScopeV2 = z2.discriminatedUnion("type", [
208
+ z2.object({
463
209
  type: ScopesWithPlaceEventOptions,
464
210
  options: scopeOptionsPlaceEvent.optional()
465
211
  }),
466
- z6.object({
212
+ z2.object({
467
213
  type: ScopesWithDeclaredOptions,
468
214
  options: scopeOptionsDeclaredOrNotified.optional()
469
215
  }),
470
- z6.object({
216
+ z2.object({
471
217
  type: ScopesWithFullOptions,
472
218
  options: AllRecordScopeOptions.optional()
473
219
  }),
474
- z6.object({
475
- type: z6.literal("record.custom-action"),
220
+ z2.object({
221
+ type: z2.literal("record.custom-action"),
476
222
  options: CustomActionScopeOptions.optional()
477
223
  }),
478
- z6.object({
479
- type: z6.literal("record.print-certified-copies"),
224
+ z2.object({
225
+ type: z2.literal("record.print-certified-copies"),
480
226
  options: ScopeOptionsPrintCertifiedCopies.optional()
481
227
  })
482
228
  ]).describe(
483
229
  "Scopes used to check user's permission to perform actions on a record."
484
230
  );
485
- var SystemScopeType = z6.enum([
231
+ var SystemScopeType = z2.enum([
486
232
  "organisation.read-locations",
487
233
  "user.read",
488
234
  "user.create",
@@ -496,61 +242,61 @@ var UserScopeType = SystemScopeType.extract([
496
242
  "user.search"
497
243
  ]);
498
244
  var ScopesWithRoleOption = UserScopeType.extract(["user.edit", "user.create"]);
499
- var UserScopeV2 = z6.discriminatedUnion("type", [
500
- z6.object({
245
+ var UserScopeV2 = z2.discriminatedUnion("type", [
246
+ z2.object({
501
247
  type: ScopesWithRoleOption,
502
248
  options: AllUserScopeOptions.optional()
503
249
  }),
504
- z6.object({
250
+ z2.object({
505
251
  type: UserScopeType.extract(["user.read", "user.search"]),
506
252
  options: AccessLevelOptions.optional()
507
253
  })
508
254
  ]);
509
- var ResolvedRecordScopeV2 = z6.discriminatedUnion("type", [
510
- z6.object({
255
+ var ResolvedRecordScopeV2 = z2.discriminatedUnion("type", [
256
+ z2.object({
511
257
  type: ScopesWithPlaceEventOptions,
512
258
  options: ResolvedScopeOptionsPlaceEvent.optional()
513
259
  }),
514
- z6.object({
260
+ z2.object({
515
261
  type: ScopesWithDeclaredOptions,
516
262
  options: ResolvedScopeOptionsDeclared.optional()
517
263
  }),
518
- z6.object({
264
+ z2.object({
519
265
  type: ScopesWithFullOptions,
520
266
  options: ResolvedScopeOptionsFull.optional()
521
267
  }),
522
- z6.object({
523
- type: z6.literal("record.print-certified-copies"),
268
+ z2.object({
269
+ type: z2.literal("record.print-certified-copies"),
524
270
  options: ResolvedScopeOptionsFull.extend({
525
- templates: z6.array(z6.string()).optional()
271
+ templates: z2.array(z2.string()).optional()
526
272
  }).optional()
527
273
  })
528
274
  ]).describe("Resolved scope with location/user IDs instead of filters.");
529
- var Scope = z6.discriminatedUnion("type", [
530
- z6.object({ type: PlainScopeType }),
275
+ var Scope = z2.discriminatedUnion("type", [
276
+ z2.object({ type: PlainScopeType }),
531
277
  ...RecordScopeV2.options,
532
278
  ...UserScopeV2.options,
533
- z6.object({
534
- type: z6.literal("organisation.read-locations"),
279
+ z2.object({
280
+ type: z2.literal("organisation.read-locations"),
535
281
  options: AccessLevelOptions.optional()
536
282
  }),
537
- z6.object({
538
- type: z6.literal("workqueue"),
283
+ z2.object({
284
+ type: z2.literal("workqueue"),
539
285
  options: WorkqueueOrDashboardOptions
540
286
  }),
541
- z6.object({
542
- type: z6.literal("dashboard.view"),
287
+ z2.object({
288
+ type: z2.literal("dashboard.view"),
543
289
  options: WorkqueueOrDashboardOptions
544
290
  })
545
291
  ]);
546
- var ScopeType = z6.enum([
292
+ var ScopeType = z2.enum([
547
293
  ...SystemScopeType.options,
548
294
  ...RecordScopeTypeV2.options,
549
295
  ...PlainScopeType.options,
550
296
  "workqueue",
551
297
  "dashboard.view"
552
298
  ]);
553
- var EncodedScope = z6.string().brand("EncodedScope");
299
+ var EncodedScope = z2.string().brand("EncodedScope");
554
300
  var DEFAULT_SCOPE_OPTIONS = {
555
301
  placeOfEvent: JurisdictionFilter.enum.all,
556
302
  accessLevel: JurisdictionFilter.enum.all,
@@ -560,147 +306,258 @@ var DEFAULT_SCOPE_OPTIONS = {
560
306
  };
561
307
 
562
308
  // ../commons/src/authentication.ts
563
- var TokenUserType = z7.enum(["user", "system"]);
564
- var TokenWithBearer = z7.string().regex(/^Bearer\s/);
309
+ var TokenUserType = z3.enum(["user", "system"]);
310
+ var TokenWithBearer = z3.string().regex(/^Bearer\s/);
565
311
 
566
- // ../commons/src/events/AuditLog.ts
567
- var AuditLogEntryBase = z8.object({
568
- id: z8.string(),
569
- clientId: z8.string(),
570
- clientType: TokenUserType,
571
- createdAt: z8.string()
572
- });
573
- var EventCreateEntrySchema = AuditLogEntryBase.extend({
574
- operation: z8.literal("event.create"),
575
- requestData: z8.object({
576
- transactionId: z8.string(),
577
- type: z8.string(),
578
- createdAtLocation: z8.string().nullable()
579
- }),
580
- responseSummary: z8.object({
581
- eventId: z8.string(),
582
- trackingId: z8.string()
583
- })
584
- });
585
- var EventGetEntrySchema = AuditLogEntryBase.extend({
586
- operation: z8.literal("event.get"),
587
- requestData: z8.object({ eventId: z8.string() }),
588
- responseSummary: z8.object({
589
- eventType: z8.string(),
590
- trackingId: z8.string()
591
- })
592
- });
593
- var EventSearchEntrySchema = AuditLogEntryBase.extend({
594
- operation: z8.literal("event.search"),
595
- clientType: z8.literal("system"),
596
- requestData: z8.object({
597
- query: z8.record(z8.string(), z8.unknown()).nullable(),
598
- limit: z8.number().nullable(),
599
- offset: z8.number().nullable()
600
- }),
601
- responseSummary: z8.object({
602
- total: z8.number(),
603
- eventIds: z8.array(z8.string())
604
- })
605
- });
606
- var EventActionEntrySchema = AuditLogEntryBase.extend({
607
- operation: z8.enum([
608
- "event.actions.notify.request",
609
- "event.actions.declare.request",
610
- "event.actions.register.request",
611
- "event.actions.reject.request",
612
- "event.actions.validate.request",
613
- "event.actions.edit.request",
614
- "event.actions.assign.request",
615
- "event.actions.unassign.request",
616
- "event.actions.read.request",
617
- "event.actions.archive.request",
618
- "event.actions.unarchive.request",
619
- "event.actions.reinstate.request",
620
- "event.actions.print_certificate.request",
621
- "event.actions.correction.request.request",
622
- "event.actions.correction.approve.request",
623
- "event.actions.correction.reject.request",
624
- "event.actions.mark_as_duplicate.request",
625
- "event.actions.mark_as_not_duplicate.request"
312
+ // ../commons/src/events/ActionType.ts
313
+ var z4 = __toESM(require("zod/v4"));
314
+ var ActionType = {
315
+ // Pre-declaration actions
316
+ DELETE: "DELETE",
317
+ CREATE: "CREATE",
318
+ NOTIFY: "NOTIFY",
319
+ // Declaration actions
320
+ DECLARE: "DECLARE",
321
+ REGISTER: "REGISTER",
322
+ EDIT: "EDIT",
323
+ // Declaration system actions. Non-configurable.
324
+ DUPLICATE_DETECTED: "DUPLICATE_DETECTED",
325
+ REJECT: "REJECT",
326
+ // REJECT_DECLARATION
327
+ MARK_AS_DUPLICATE: "MARK_AS_DUPLICATE",
328
+ MARK_AS_NOT_DUPLICATE: "MARK_AS_NOT_DUPLICATE",
329
+ ARCHIVE: "ARCHIVE",
330
+ UNARCHIVE: "UNARCHIVE",
331
+ // Record actions
332
+ PRINT_CERTIFICATE: "PRINT_CERTIFICATE",
333
+ REQUEST_CORRECTION: "REQUEST_CORRECTION",
334
+ REJECT_CORRECTION: "REJECT_CORRECTION",
335
+ APPROVE_CORRECTION: "APPROVE_CORRECTION",
336
+ // General actions
337
+ READ: "READ",
338
+ ASSIGN: "ASSIGN",
339
+ UNASSIGN: "UNASSIGN",
340
+ // Custom action
341
+ CUSTOM: "CUSTOM"
342
+ };
343
+ var ConfirmableActions = [
344
+ ActionType.NOTIFY,
345
+ ActionType.DECLARE,
346
+ ActionType.EDIT,
347
+ ActionType.REGISTER,
348
+ ActionType.REJECT,
349
+ ActionType.ARCHIVE,
350
+ ActionType.UNARCHIVE,
351
+ ActionType.PRINT_CERTIFICATE,
352
+ ActionType.REQUEST_CORRECTION,
353
+ ActionType.APPROVE_CORRECTION,
354
+ ActionType.REJECT_CORRECTION,
355
+ ActionType.CUSTOM
356
+ ];
357
+ var ActionTypes = z4.enum([
358
+ "DELETE",
359
+ "CREATE",
360
+ "NOTIFY",
361
+ "DECLARE",
362
+ "EDIT",
363
+ "REGISTER",
364
+ "DUPLICATE_DETECTED",
365
+ "REJECT",
366
+ "MARK_AS_DUPLICATE",
367
+ "MARK_AS_NOT_DUPLICATE",
368
+ "ARCHIVE",
369
+ "UNARCHIVE",
370
+ "PRINT_CERTIFICATE",
371
+ "REQUEST_CORRECTION",
372
+ "REJECT_CORRECTION",
373
+ "APPROVE_CORRECTION",
374
+ "READ",
375
+ "ASSIGN",
376
+ "UNASSIGN",
377
+ "CUSTOM"
378
+ ]);
379
+ var ClientSpecificAction = {
380
+ REVIEW_CORRECTION_REQUEST: "REVIEW_CORRECTION_REQUEST"
381
+ };
382
+ var declarationActionValues = [
383
+ ActionTypes.enum.DECLARE,
384
+ ActionTypes.enum.EDIT,
385
+ ActionTypes.enum.REGISTER,
386
+ ActionTypes.enum.NOTIFY,
387
+ ActionTypes.enum.DUPLICATE_DETECTED
388
+ ];
389
+ var DeclarationActions = ActionTypes.extract(declarationActionValues);
390
+ var declarationUpdateActionValues = [
391
+ ...declarationActionValues,
392
+ ActionTypes.enum.REQUEST_CORRECTION
393
+ ];
394
+ var DeclarationUpdateActions = ActionTypes.extract(
395
+ declarationUpdateActionValues
396
+ );
397
+ var annotationActions = ActionTypes.exclude(declarationActionValues);
398
+ var writeActions = ActionTypes.exclude([
399
+ ActionType.CREATE,
400
+ ActionType.READ,
401
+ ActionType.ASSIGN,
402
+ ActionType.UNASSIGN
403
+ ]);
404
+ var WorkqueueActionType = ActionTypes.extract([
405
+ ActionType.READ,
406
+ ActionType.DELETE,
407
+ ActionType.DECLARE,
408
+ ActionType.REGISTER,
409
+ ActionType.EDIT,
410
+ ActionType.REJECT,
411
+ ActionType.MARK_AS_DUPLICATE,
412
+ ActionType.ARCHIVE,
413
+ ActionType.UNARCHIVE,
414
+ ActionType.PRINT_CERTIFICATE,
415
+ ActionType.REQUEST_CORRECTION
416
+ ]);
417
+ var META_ACTIONS = [
418
+ ActionType.ASSIGN,
419
+ ActionType.UNASSIGN,
420
+ ActionType.READ
421
+ ];
422
+
423
+ // ../commons/src/events/AuditLog.ts
424
+ var AuditLogEntryBase = z5.object({
425
+ id: z5.string(),
426
+ clientId: z5.string(),
427
+ clientType: TokenUserType,
428
+ createdAt: z5.string()
429
+ });
430
+ var EventCreateEntrySchema = AuditLogEntryBase.extend({
431
+ operation: z5.literal("event.create"),
432
+ requestData: z5.object({
433
+ transactionId: z5.string(),
434
+ type: z5.string(),
435
+ createdAtLocation: z5.string().nullable()
436
+ }),
437
+ responseSummary: z5.object({
438
+ eventId: z5.string(),
439
+ trackingId: z5.string()
440
+ })
441
+ });
442
+ var EventGetEntrySchema = AuditLogEntryBase.extend({
443
+ operation: z5.literal("event.get"),
444
+ requestData: z5.object({ eventId: z5.string() }),
445
+ responseSummary: z5.object({
446
+ eventType: z5.string(),
447
+ trackingId: z5.string()
448
+ })
449
+ });
450
+ var EventSearchEntrySchema = AuditLogEntryBase.extend({
451
+ operation: z5.literal("event.search"),
452
+ clientType: z5.literal("system"),
453
+ requestData: z5.object({
454
+ query: z5.record(z5.string(), z5.unknown()).nullable(),
455
+ limit: z5.number().nullable(),
456
+ offset: z5.number().nullable()
457
+ }),
458
+ responseSummary: z5.object({
459
+ total: z5.number(),
460
+ eventIds: z5.array(z5.string())
461
+ })
462
+ });
463
+ var EventActionEntrySchema = AuditLogEntryBase.extend({
464
+ operation: z5.enum([
465
+ "event.actions.notify.request",
466
+ "event.actions.declare.request",
467
+ "event.actions.register.request",
468
+ "event.actions.reject.request",
469
+ "event.actions.validate.request",
470
+ "event.actions.edit.request",
471
+ "event.actions.assign.request",
472
+ "event.actions.unassign.request",
473
+ "event.actions.read.request",
474
+ "event.actions.archive.request",
475
+ "event.actions.unarchive.request",
476
+ "event.actions.reinstate.request",
477
+ "event.actions.print_certificate.request",
478
+ "event.actions.correction.request.request",
479
+ "event.actions.correction.approve.request",
480
+ "event.actions.correction.reject.request",
481
+ "event.actions.mark_as_duplicate.request",
482
+ "event.actions.mark_as_not_duplicate.request"
626
483
  ]),
627
- requestData: z8.object({
628
- eventId: z8.string(),
629
- actionType: z8.string(),
630
- eventType: z8.string(),
631
- trackingId: z8.string(),
632
- transactionId: z8.string()
484
+ requestData: z5.object({
485
+ eventId: z5.string(),
486
+ actionType: z5.string(),
487
+ eventType: z5.string(),
488
+ trackingId: z5.string(),
489
+ transactionId: z5.string()
633
490
  })
634
491
  });
635
492
  var EventCustomActionEntrySchema = AuditLogEntryBase.extend({
636
- operation: z8.literal("event.actions.custom.request"),
637
- requestData: z8.object({
638
- eventId: z8.string(),
639
- actionType: z8.literal(ActionType.CUSTOM),
640
- customAction: z8.string(),
641
- eventType: z8.string(),
642
- trackingId: z8.string(),
643
- transactionId: z8.string()
493
+ operation: z5.literal("event.actions.custom.request"),
494
+ requestData: z5.object({
495
+ eventId: z5.string(),
496
+ actionType: z5.literal(ActionType.CUSTOM),
497
+ customAction: z5.string(),
498
+ eventType: z5.string(),
499
+ trackingId: z5.string(),
500
+ transactionId: z5.string()
644
501
  })
645
502
  });
646
503
  var IntegrationCreateEntrySchema = AuditLogEntryBase.extend({
647
- operation: z8.literal("integrations.create"),
648
- requestData: z8.object({ name: z8.string(), scopes: z8.array(z8.string()) }),
649
- responseSummary: z8.object({ clientId: z8.string() })
504
+ operation: z5.literal("integrations.create"),
505
+ requestData: z5.object({ name: z5.string(), scopes: z5.array(z5.string()) }),
506
+ responseSummary: z5.object({ clientId: z5.string() })
650
507
  });
651
508
  var IntegrationRefreshTokenEntrySchema = AuditLogEntryBase.extend({
652
- operation: z8.literal("integrations.refreshToken"),
653
- requestData: z8.object({ clientId: z8.string() }),
654
- responseSummary: z8.object({ clientId: z8.string() })
509
+ operation: z5.literal("integrations.refreshToken"),
510
+ requestData: z5.object({ clientId: z5.string() }),
511
+ responseSummary: z5.object({ clientId: z5.string() })
655
512
  });
656
513
  var IntegrationDeactivateEntrySchema = AuditLogEntryBase.extend({
657
- operation: z8.literal("integrations.deactivate"),
658
- requestData: z8.object({ id: z8.string() }),
659
- responseSummary: z8.object({ id: z8.string(), status: z8.string() })
514
+ operation: z5.literal("integrations.deactivate"),
515
+ requestData: z5.object({ id: z5.string() }),
516
+ responseSummary: z5.object({ id: z5.string(), status: z5.string() })
660
517
  });
661
518
  var IntegrationActivateEntrySchema = AuditLogEntryBase.extend({
662
- operation: z8.literal("integrations.activate"),
663
- requestData: z8.object({ id: z8.string() }),
664
- responseSummary: z8.object({ id: z8.string(), status: z8.string() })
519
+ operation: z5.literal("integrations.activate"),
520
+ requestData: z5.object({ id: z5.string() }),
521
+ responseSummary: z5.object({ id: z5.string(), status: z5.string() })
665
522
  });
666
523
  var IntegrationDeleteEntrySchema = AuditLogEntryBase.extend({
667
- operation: z8.literal("integrations.delete"),
668
- requestData: z8.object({ id: z8.string() }),
669
- responseSummary: z8.object({ id: z8.string(), name: z8.string() })
524
+ operation: z5.literal("integrations.delete"),
525
+ requestData: z5.object({ id: z5.string() }),
526
+ responseSummary: z5.object({ id: z5.string(), name: z5.string() })
670
527
  });
671
528
  var IntegrationRefreshSecretEntrySchema = AuditLogEntryBase.extend({
672
- operation: z8.literal("integrations.refreshSecret"),
673
- requestData: z8.object({ id: z8.string() }),
674
- responseSummary: z8.object({ clientId: z8.string() })
529
+ operation: z5.literal("integrations.refreshSecret"),
530
+ requestData: z5.object({ id: z5.string() }),
531
+ responseSummary: z5.object({ clientId: z5.string() })
675
532
  });
676
533
  var AttachmentUploadEntrySchema = AuditLogEntryBase.extend({
677
- operation: z8.literal("attachments.upload"),
678
- requestData: z8.object({
679
- transactionId: z8.string(),
680
- path: z8.string().nullable()
534
+ operation: z5.literal("attachments.upload"),
535
+ requestData: z5.object({
536
+ transactionId: z5.string(),
537
+ path: z5.string().nullable()
681
538
  }),
682
- responseSummary: z8.object({ fileUrl: z8.string() })
539
+ responseSummary: z5.object({ fileUrl: z5.string() })
683
540
  });
684
- var subjectOnly = z8.object({ subjectId: z8.string() });
685
- var subjectWithReason = z8.object({
686
- subjectId: z8.string(),
687
- reason: z8.string(),
688
- comment: z8.string().optional()
541
+ var subjectOnly = z5.object({ subjectId: z5.string() });
542
+ var subjectWithReason = z5.object({
543
+ subjectId: z5.string(),
544
+ reason: z5.string(),
545
+ comment: z5.string().optional()
689
546
  });
690
547
  var UserCreateEntrySchema = AuditLogEntryBase.extend({
691
- operation: z8.literal("user.create_user"),
692
- requestData: z8.object({
693
- subjectId: z8.string(),
694
- role: z8.string(),
695
- primaryOfficeId: z8.string()
548
+ operation: z5.literal("user.create_user"),
549
+ requestData: z5.object({
550
+ subjectId: z5.string(),
551
+ role: z5.string(),
552
+ primaryOfficeId: z5.string()
696
553
  })
697
554
  });
698
555
  var UserReasonEntrySchema = AuditLogEntryBase.extend({
699
- operation: z8.enum(["user.deactivate", "user.reactivate"]),
556
+ operation: z5.enum(["user.deactivate", "user.reactivate"]),
700
557
  requestData: subjectWithReason
701
558
  });
702
559
  var UserSubjectOnlyEntrySchema = AuditLogEntryBase.extend({
703
- operation: z8.enum([
560
+ operation: z5.enum([
704
561
  "user.edit_user",
705
562
  "user.logged_in",
706
563
  "user.logged_out",
@@ -714,14 +571,14 @@ var UserSubjectOnlyEntrySchema = AuditLogEntryBase.extend({
714
571
  requestData: subjectOnly
715
572
  });
716
573
  var UserEmailChangedEntrySchema = AuditLogEntryBase.extend({
717
- operation: z8.literal("user.email_address_changed"),
574
+ operation: z5.literal("user.email_address_changed"),
718
575
  requestData: subjectOnly,
719
- responseSummary: z8.object({ email: z8.string() })
576
+ responseSummary: z5.object({ email: z5.string() })
720
577
  });
721
578
  var UserPhoneChangedEntrySchema = AuditLogEntryBase.extend({
722
- operation: z8.literal("user.phone_number_changed"),
579
+ operation: z5.literal("user.phone_number_changed"),
723
580
  requestData: subjectOnly,
724
- responseSummary: z8.object({ phoneNumber: z8.string() })
581
+ responseSummary: z5.object({ phoneNumber: z5.string() })
725
582
  });
726
583
  var userBaseOmit = {
727
584
  id: true,
@@ -729,14 +586,14 @@ var userBaseOmit = {
729
586
  clientType: true,
730
587
  createdAt: true
731
588
  };
732
- var UserAuditRecordInput = z8.discriminatedUnion("operation", [
589
+ var UserAuditRecordInput = z5.discriminatedUnion("operation", [
733
590
  UserCreateEntrySchema.omit(userBaseOmit),
734
591
  UserReasonEntrySchema.omit(userBaseOmit),
735
592
  UserSubjectOnlyEntrySchema.omit(userBaseOmit),
736
593
  UserEmailChangedEntrySchema.omit(userBaseOmit),
737
594
  UserPhoneChangedEntrySchema.omit(userBaseOmit)
738
595
  ]);
739
- var AuditLogEntrySchema = z8.discriminatedUnion("operation", [
596
+ var AuditLogEntrySchema = z5.discriminatedUnion("operation", [
740
597
  EventCreateEntrySchema,
741
598
  EventGetEntrySchema,
742
599
  EventSearchEntrySchema,
@@ -763,11 +620,76 @@ var CHILD_ONBOARDING_EVENT = "child-onboarding";
763
620
  // ../commons/src/events/ActionConfig.ts
764
621
  var z24 = __toESM(require("zod/v4"));
765
622
 
623
+ // ../commons/src/events/TranslationConfig.ts
624
+ var z6 = __toESM(require("zod/v4"));
625
+ var TranslationConfig = z6.object({
626
+ id: z6.string().describe(
627
+ "The identifier of the translation referred in translation CSV files"
628
+ ),
629
+ defaultMessage: z6.string().describe("Default translation message"),
630
+ description: z6.string().describe(
631
+ "Describe the translation for a translator to be able to identify it."
632
+ )
633
+ }).meta({
634
+ description: "Translation configuration",
635
+ id: "TranslationConfig"
636
+ });
637
+
766
638
  // ../commons/src/events/FieldConfig.ts
767
639
  var import_v43 = __toESM(require("zod/v4"));
768
640
 
641
+ // ../commons/src/events/Conditional.ts
642
+ var z7 = __toESM(require("zod/v4"));
643
+ var Conditional = z7.any().describe("JSONSchema").meta({
644
+ description: "JSON schema conditional configuration",
645
+ id: "Conditional"
646
+ });
647
+ var ConditionalType = {
648
+ SHOW: "SHOW",
649
+ ENABLE: "ENABLE",
650
+ DISPLAY_ON_REVIEW: "DISPLAY_ON_REVIEW"
651
+ };
652
+ var ShowConditional = z7.object({
653
+ type: z7.literal(ConditionalType.SHOW),
654
+ conditional: Conditional
655
+ }).describe(
656
+ "If 'SHOW' conditional is defined, the component is shown to the user only if the condition is met"
657
+ );
658
+ var EnableConditional = z7.object({
659
+ type: z7.literal(ConditionalType.ENABLE),
660
+ conditional: Conditional
661
+ }).describe(
662
+ "If 'ENABLE' conditional is defined, the component is enabled only if the condition is met"
663
+ );
664
+ var ActionConditional = z7.discriminatedUnion("type", [
665
+ // Action can be shown / hidden
666
+ ShowConditional,
667
+ // Action can be shown to the user in the list but as disabled
668
+ EnableConditional
669
+ ]).meta({
670
+ id: "ActionConditional",
671
+ description: "Conditional gating whether an action is shown (SHOW) or enabled (ENABLE). When omitted from an action, the action is shown and enabled for everyone."
672
+ });
673
+ var DisplayOnReviewConditional = z7.object({
674
+ type: z7.literal(ConditionalType.DISPLAY_ON_REVIEW),
675
+ conditional: Conditional
676
+ }).describe(
677
+ "If 'DISPLAY_ON_REVIEW' conditional is defined, the component is shown on the review page only if both the 'DISPLAY_ON_REVIEW' and 'SHOW' conditions are met. This should only be used for fields within declaration forms, as they are the only ones with review pages."
678
+ );
679
+ var FieldConditional = z7.discriminatedUnion("type", [
680
+ // Field input can be shown / hidden
681
+ ShowConditional,
682
+ // Field input can be shown to the user but as disabled
683
+ EnableConditional,
684
+ // Field output can be shown / hidden on the review page
685
+ DisplayOnReviewConditional
686
+ ]).meta({
687
+ id: "FieldConditional",
688
+ description: "Conditional gating whether a form field is shown (SHOW), enabled (ENABLE), or displayed on the review page (DISPLAY_ON_REVIEW). When omitted, the field is shown and enabled for everyone, and is displayed on review whenever it has a value."
689
+ });
690
+
769
691
  // ../commons/src/events/FieldType.ts
770
- var z9 = __toESM(require("zod/v4"));
692
+ var z8 = __toESM(require("zod/v4"));
771
693
  var FieldType = {
772
694
  NAME: "NAME",
773
695
  PHONE: "PHONE",
@@ -831,7 +753,7 @@ var FieldType = {
831
753
  */
832
754
  _EXPERIMENTAL_CUSTOM: "CUSTOM"
833
755
  };
834
- var FileFieldType = z9.enum([
756
+ var FileFieldType = z8.enum([
835
757
  FieldType.FILE,
836
758
  FieldType.FILE_WITH_OPTIONS,
837
759
  FieldType.SIGNATURE
@@ -867,164 +789,160 @@ var HiddenFieldTypes = [
867
789
  ];
868
790
 
869
791
  // ../commons/src/events/FieldValue.ts
870
- var z13 = __toESM(require("zod/v4"));
792
+ var z12 = __toESM(require("zod/v4"));
871
793
 
872
794
  // ../commons/src/documents.ts
873
- var z10 = __toESM(require("zod/v4"));
874
- var FullDocumentUrl = z10.string().brand("FullDocumentUrl").describe(
795
+ var z9 = __toESM(require("zod/v4"));
796
+ var FullDocumentUrl = z9.string().brand("FullDocumentUrl").describe(
875
797
  "A full url with protocol, host, bucket name, starting from the root of the S3 server, https://minio.opencrvs.com/bucket-name/document-id.jpg"
876
798
  );
877
- var FullDocumentPath = z10.string().overwrite((val) => val.startsWith("/") ? val : `/${val}`).meta({ effectType: "input", type: "string" }).describe(
799
+ var FullDocumentPath = z9.string().overwrite((val) => val.startsWith("/") ? val : `/${val}`).meta({ effectType: "input", type: "string" }).describe(
878
800
  "A full absolute path with bucket name, starting from the root of the S3 server, /bucket-name/document-id.jpg"
879
801
  );
880
- var DocumentPath = z10.string().brand("DocumentPath").describe(
802
+ var DocumentPath = z9.string().brand("DocumentPath").describe(
881
803
  "A relative path within the S3 bucket, never starting with /. e.g. document-id.jpg or directory/document-id.jpg. The document service constructs the full /bucket/path internally."
882
804
  );
883
805
 
884
806
  // ../commons/src/events/CompositeFieldValue.ts
885
- var z11 = __toESM(require("zod/v4"));
807
+ var z10 = __toESM(require("zod/v4"));
886
808
  var AddressType = {
887
809
  DOMESTIC: "DOMESTIC",
888
810
  INTERNATIONAL: "INTERNATIONAL"
889
811
  };
890
- var FileFieldValue = z11.object({
812
+ var FileFieldValue = z10.object({
891
813
  path: DocumentPath,
892
- originalFilename: z11.string(),
893
- type: z11.string()
894
- });
895
- var NameFieldValue = z11.object({
896
- firstname: z11.string(),
897
- surname: z11.string(),
898
- middlename: z11.string().optional()
899
- });
900
- var NameFieldUpdateValue = z11.object({
901
- firstname: z11.string().nullish(),
902
- surname: z11.string().nullish(),
903
- middlename: z11.string().nullish()
904
- }).or(z11.null()).or(z11.undefined());
905
- var StreetLevelDetailsValue = z11.record(z11.string(), z11.string()).optional();
906
- var StreetLevelDetailsUpdateValue = z11.record(z11.string(), z11.string().nullable()).nullish();
907
- var BaseAddressFieldValue = z11.object({
908
- country: z11.string(),
814
+ originalFilename: z10.string(),
815
+ type: z10.string()
816
+ });
817
+ var NameFieldValue = z10.object({
818
+ firstname: z10.string(),
819
+ surname: z10.string(),
820
+ middlename: z10.string().optional()
821
+ });
822
+ var NameFieldUpdateValue = z10.object({
823
+ firstname: z10.string().nullish(),
824
+ surname: z10.string().nullish(),
825
+ middlename: z10.string().nullish()
826
+ }).or(z10.null()).or(z10.undefined());
827
+ var StreetLevelDetailsValue = z10.record(z10.string(), z10.string()).optional();
828
+ var StreetLevelDetailsUpdateValue = z10.record(z10.string(), z10.string().nullable()).nullish();
829
+ var BaseAddressFieldValue = z10.object({
830
+ country: z10.string(),
909
831
  streetLevelDetails: StreetLevelDetailsValue
910
832
  });
911
- var BaseAddressFieldUpdateValue = z11.object({
912
- country: z11.string().nullish(),
833
+ var BaseAddressFieldUpdateValue = z10.object({
834
+ country: z10.string().nullish(),
913
835
  streetLevelDetails: StreetLevelDetailsUpdateValue
914
836
  });
915
837
  var DomesticAddressFieldValue = BaseAddressFieldValue.extend({
916
- addressType: z11.literal(AddressType.DOMESTIC),
917
- administrativeArea: z11.string().uuid()
838
+ addressType: z10.literal(AddressType.DOMESTIC),
839
+ administrativeArea: z10.string().uuid()
918
840
  });
919
841
  var InternationalAddressFieldValue = BaseAddressFieldValue.extend({
920
- addressType: z11.literal(AddressType.INTERNATIONAL)
842
+ addressType: z10.literal(AddressType.INTERNATIONAL)
921
843
  });
922
- var AddressFieldValue = z11.discriminatedUnion("addressType", [
844
+ var AddressFieldValue = z10.discriminatedUnion("addressType", [
923
845
  DomesticAddressFieldValue,
924
846
  InternationalAddressFieldValue
925
847
  ]);
926
848
  var DomesticAddressUpdateFieldValue = BaseAddressFieldUpdateValue.extend({
927
- addressType: z11.literal(AddressType.DOMESTIC),
928
- administrativeArea: z11.string().uuid().nullish()
849
+ addressType: z10.literal(AddressType.DOMESTIC),
850
+ administrativeArea: z10.string().uuid().nullish()
929
851
  /* Leaf level admin structure */
930
852
  });
931
853
  var InternationalAddressUpdateFieldValue = BaseAddressFieldUpdateValue.extend(
932
854
  {
933
- addressType: z11.literal(AddressType.INTERNATIONAL)
855
+ addressType: z10.literal(AddressType.INTERNATIONAL)
934
856
  }
935
857
  );
936
- var AddressFieldUpdateValue = z11.discriminatedUnion("addressType", [
858
+ var AddressFieldUpdateValue = z10.discriminatedUnion("addressType", [
937
859
  DomesticAddressUpdateFieldValue,
938
860
  InternationalAddressUpdateFieldValue
939
861
  ]).nullish();
940
- var FileFieldValueWithOption = z11.object({
862
+ var FileFieldValueWithOption = z10.object({
941
863
  path: DocumentPath,
942
- originalFilename: z11.string(),
943
- type: z11.string(),
944
- option: z11.string()
945
- });
946
- var FileFieldWithOptionValue = z11.array(FileFieldValueWithOption);
947
- var HttpFieldValue = z11.object({
948
- loading: z11.boolean(),
949
- error: z11.object({ statusCode: z11.number(), message: z11.string() }).nullish(),
950
- data: z11.any()
951
- });
952
- var HttpFieldUpdateValue = z11.object({
953
- loading: z11.boolean().nullish(),
954
- error: z11.object({ statusCode: z11.number(), message: z11.string() }).nullish(),
955
- data: z11.any().nullish()
956
- }).or(z11.null()).or(z11.undefined());
957
- var QueryParamReaderFieldValue = z11.object({
958
- data: z11.record(z11.string(), z11.string()),
959
- updatedAt: z11.iso.datetime()
864
+ originalFilename: z10.string(),
865
+ type: z10.string(),
866
+ option: z10.string()
867
+ });
868
+ var FileFieldWithOptionValue = z10.array(FileFieldValueWithOption);
869
+ var HttpFieldValue = z10.object({
870
+ loading: z10.boolean(),
871
+ error: z10.object({ statusCode: z10.number(), message: z10.string() }).nullish(),
872
+ data: z10.any()
873
+ });
874
+ var HttpFieldUpdateValue = z10.object({
875
+ loading: z10.boolean().nullish(),
876
+ error: z10.object({ statusCode: z10.number(), message: z10.string() }).nullish(),
877
+ data: z10.any().nullish()
878
+ }).or(z10.null()).or(z10.undefined());
879
+ var QueryParamReaderFieldValue = z10.object({
880
+ data: z10.record(z10.string(), z10.string()),
881
+ updatedAt: z10.iso.datetime()
960
882
  }).nullish();
961
- var QueryParamReaderFieldUpdateValue = z11.object({
962
- data: z11.record(z11.string(), z11.string())
883
+ var QueryParamReaderFieldUpdateValue = z10.object({
884
+ data: z10.record(z10.string(), z10.string())
963
885
  });
964
- var ReadDataValue = z11.object({
965
- data: z11.any()
886
+ var ReadDataValue = z10.object({
887
+ data: z10.any()
966
888
  });
967
889
  var QrReaderFieldValue = ReadDataValue;
968
890
  var IdReaderFieldValue = ReadDataValue;
969
- var NumberWithUnitFieldValue = z11.object({
970
- numericValue: z11.number(),
971
- unit: z11.string()
891
+ var NumberWithUnitFieldValue = z10.object({
892
+ numericValue: z10.number(),
893
+ unit: z10.string()
972
894
  });
973
- var NumberWithUnitFieldUpdateValue = z11.object({
974
- numericValue: z11.number().optional(),
975
- unit: z11.string().optional()
895
+ var NumberWithUnitFieldUpdateValue = z10.object({
896
+ numericValue: z10.number().optional(),
897
+ unit: z10.string().optional()
976
898
  });
977
- var CustomFieldValue = z11.unknown().brand("CustomFieldValue");
899
+ var CustomFieldValue = z10.unknown().brand("CustomFieldValue");
978
900
 
979
901
  // ../commons/src/events/PlainDate.ts
980
902
  var import_zod = require("zod");
981
903
  var PlainDate = import_zod.z.string().date().brand("PlainDate").describe("Date in the format YYYY-MM-DD");
982
- function plainDateToLocalDate(date) {
983
- const [year, month, day] = date.split("-").map(Number);
984
- return new Date(year, month - 1, day);
985
- }
986
904
 
987
905
  // ../commons/src/events/FieldValue.ts
988
- var TextValue = z13.string();
989
- var HiddenFieldValue = z13.string();
990
- var NonEmptyTextValue = z13.string().trim().min(1);
991
- var DateValue = z13.iso.date().describe("Date in the format YYYY-MM-DD");
992
- var AgeValue = z13.object({
993
- age: z13.number(),
994
- asOfDateRef: z13.string()
906
+ var TextValue = z12.string();
907
+ var HiddenFieldValue = z12.string();
908
+ var NonEmptyTextValue = z12.string().trim().min(1);
909
+ var DateValue = z12.iso.date().describe("Date in the format YYYY-MM-DD");
910
+ var AgeValue = z12.object({
911
+ age: z12.number(),
912
+ asOfDateRef: z12.string()
995
913
  });
996
914
  var AgeUpdateValue = AgeValue.optional().nullable();
997
- var AutocompleteValue = z13.object({
998
- label: z13.string(),
999
- value: z13.string()
915
+ var AutocompleteValue = z12.object({
916
+ label: z12.string(),
917
+ value: z12.string()
1000
918
  });
1001
919
  var AutocompleteUpdateValue = AutocompleteValue.optional().nullable();
1002
- var TimeValue = z13.string().regex(/^([01][0-9]|2[0-3]):[0-5][0-9]$/);
1003
- var DatetimeValue = z13.iso.datetime();
1004
- var SelectDateRangeValue = z13.enum([
920
+ var TimeValue = z12.string().regex(/^([01][0-9]|2[0-3]):[0-5][0-9]$/);
921
+ var DatetimeValue = z12.iso.datetime();
922
+ var SelectDateRangeValue = z12.enum([
1005
923
  "last7Days",
1006
924
  "last30Days",
1007
925
  "last90Days",
1008
926
  "last365Days"
1009
927
  ]);
1010
- var DateRangeFieldValue = z13.object({
928
+ var DateRangeFieldValue = z12.object({
1011
929
  start: PlainDate,
1012
930
  end: PlainDate
1013
931
  }).or(PlainDate).describe(
1014
932
  "Date range with start and end dates in the format YYYY-MM-DD. Inclusive start, exclusive end."
1015
933
  );
1016
- var EmailValue = z13.email();
1017
- var CheckboxFieldValue = z13.boolean();
1018
- var NumberFieldValue = z13.number();
934
+ var EmailValue = z12.email();
935
+ var CheckboxFieldValue = z12.boolean();
936
+ var NumberFieldValue = z12.number();
1019
937
  var SignatureFieldValue = FileFieldValue;
1020
- var ButtonFieldValue = z13.number();
1021
- var VerificationStatusValue = z13.enum([
938
+ var ButtonFieldValue = z12.number();
939
+ var VerificationStatusValue = z12.enum([
1022
940
  "verified",
1023
941
  "authenticated",
1024
942
  "failed",
1025
943
  "pending"
1026
944
  ]);
1027
- var LeafFieldValues = z13.union([
945
+ var LeafFieldValues = z12.union([
1028
946
  AddressFieldValue,
1029
947
  TextValue,
1030
948
  PlainDate,
@@ -1050,11 +968,11 @@ var LeafFieldValues = z13.union([
1050
968
  AutocompleteValue,
1051
969
  AutocompleteUpdateValue
1052
970
  ]);
1053
- var FieldGroupValue = z13.record(z13.string(), LeafFieldValues);
1054
- var DataFieldValue = z13.object({
1055
- data: z13.record(z13.string(), LeafFieldValues)
971
+ var FieldGroupValue = z12.record(z12.string(), LeafFieldValues);
972
+ var DataFieldValue = z12.object({
973
+ data: z12.record(z12.string(), LeafFieldValues)
1056
974
  }).nullish();
1057
- var FieldValue = z13.union([
975
+ var FieldValue = z12.union([
1058
976
  LeafFieldValues,
1059
977
  DataFieldValue,
1060
978
  FieldGroupValue
@@ -1088,7 +1006,7 @@ function safeUnion(schemas) {
1088
1006
  const sortedSchemas = [...schemas].sort(
1089
1007
  (a, b) => schemaPriority(a) - schemaPriority(b)
1090
1008
  );
1091
- return z13.any().superRefine((val, ctx) => {
1009
+ return z12.any().superRefine((val, ctx) => {
1092
1010
  for (const schema of sortedSchemas) {
1093
1011
  if (schema.safeParse(val).success) {
1094
1012
  return;
@@ -1127,9 +1045,9 @@ var FieldUpdateValue = safeUnion([
1127
1045
  ]);
1128
1046
 
1129
1047
  // ../commons/src/events/serializers/user/serializer.ts
1130
- var z14 = __toESM(require("zod/v4"));
1131
- var SerializedUserField = z14.object({
1132
- $userField: z14.enum([
1048
+ var z13 = __toESM(require("zod/v4"));
1049
+ var SerializedUserField = z13.object({
1050
+ $userField: z13.enum([
1133
1051
  "id",
1134
1052
  "name",
1135
1053
  "role",
@@ -1143,7 +1061,7 @@ var SerializedUserField = z14.object({
1143
1061
  "primaryOfficeId",
1144
1062
  "administrativeAreaId"
1145
1063
  ]),
1146
- $location: z14.string().optional()
1064
+ $location: z13.string().optional()
1147
1065
  });
1148
1066
  function userSerializer(userField) {
1149
1067
  return {
@@ -1169,22 +1087,27 @@ var import_v4 = require("zod/v4");
1169
1087
  var z16 = __toESM(require("zod/v4"));
1170
1088
 
1171
1089
  // ../commons/src/events/ActionDocument.ts
1172
- var z15 = __toESM(require("zod/v4"));
1173
- var ActionUpdate = z15.record(z15.string(), FieldUpdateValue).describe(
1090
+ var z14 = __toESM(require("zod/v4"));
1091
+ var ActionUpdate = z14.record(z14.string(), FieldUpdateValue).describe(
1174
1092
  "Record of field-level changes made by an action. Supports partial updates and nullable values."
1175
1093
  );
1176
- var EventState = z15.record(z15.string(), FieldValue).describe(
1094
+ var EventState = z14.record(z14.string(), FieldValue).describe(
1177
1095
  "Aggregate representation of event data after all actions have been applied, with all updates consolidated and null values removed."
1178
1096
  );
1179
- var ActionBase = z15.object({
1097
+ var ActionStatus = {
1098
+ Requested: "Requested",
1099
+ Accepted: "Accepted",
1100
+ Rejected: "Rejected"
1101
+ };
1102
+ var ActionBase = z14.object({
1180
1103
  id: UUID.describe("Unique identifier of the action."),
1181
- transactionId: z15.string().describe("Unique identifier of the transaction."),
1104
+ transactionId: z14.string().describe("Unique identifier of the transaction."),
1182
1105
  createdByUserType: TokenUserType.describe(
1183
1106
  "Indicates whether the action was created by a human-user or by a system-user."
1184
1107
  ),
1185
- createdAt: z15.string().datetime().describe("Timestamp indicating when the action was created."),
1186
- createdBy: z15.string().describe("Identifier of the user who created the action."),
1187
- createdByRole: z15.string().optional().describe("Role of the user who created the action."),
1108
+ createdAt: z14.string().datetime().describe("Timestamp indicating when the action was created."),
1109
+ createdBy: z14.string().describe("Identifier of the user who created the action."),
1110
+ createdByRole: z14.string().optional().describe("Role of the user who created the action."),
1188
1111
  createdBySignature: DocumentPath.nullish().describe(
1189
1112
  "Reference to the signature of the user who created the action."
1190
1113
  ),
@@ -1196,7 +1119,7 @@ var ActionBase = z15.object({
1196
1119
  "Declaration data defined by the ActionConfig. Supports partial updates."
1197
1120
  ),
1198
1121
  annotation: ActionUpdate.optional().nullable().describe("Action-specific metadata used to annotate the event."),
1199
- status: z15.enum([
1122
+ status: z14.enum([
1200
1123
  ActionStatus.Requested,
1201
1124
  ActionStatus.Accepted,
1202
1125
  ActionStatus.Rejected
@@ -1208,139 +1131,139 @@ var ActionBase = z15.object({
1208
1131
  )
1209
1132
  });
1210
1133
  var AssignedAction = ActionBase.extend(
1211
- z15.object({
1212
- type: z15.literal(ActionType.ASSIGN),
1213
- assignedTo: z15.string().describe("Identifier of the user to whom the action is assigned.")
1134
+ z14.object({
1135
+ type: z14.literal(ActionType.ASSIGN),
1136
+ assignedTo: z14.string().describe("Identifier of the user to whom the action is assigned.")
1214
1137
  // TODO move into 'content' property
1215
1138
  }).shape
1216
1139
  );
1217
1140
  var UnassignedAction = ActionBase.extend(
1218
- z15.object({
1219
- type: z15.literal(ActionType.UNASSIGN)
1141
+ z14.object({
1142
+ type: z14.literal(ActionType.UNASSIGN)
1220
1143
  }).shape
1221
1144
  );
1222
1145
  var RegisterAction = ActionBase.extend(
1223
- z15.object({
1224
- type: z15.literal(ActionType.REGISTER),
1225
- registrationNumber: z15.string().optional().describe(
1146
+ z14.object({
1147
+ type: z14.literal(ActionType.REGISTER),
1148
+ registrationNumber: z14.string().optional().describe(
1226
1149
  "Registration number of the event. Always present for accepted registrations."
1227
1150
  )
1228
1151
  // TODO move into 'content' property
1229
1152
  }).shape
1230
1153
  );
1231
1154
  var DeclareAction = ActionBase.extend(
1232
- z15.object({
1233
- type: z15.literal(ActionType.DECLARE)
1155
+ z14.object({
1156
+ type: z14.literal(ActionType.DECLARE)
1234
1157
  }).shape
1235
1158
  );
1236
- var ReasonContent = z15.object({
1237
- reason: z15.string().min(1, { error: "Message cannot be empty" }).describe(
1159
+ var ReasonContent = z14.object({
1160
+ reason: z14.string().min(1, { error: "Message cannot be empty" }).describe(
1238
1161
  "Message describing the reason for rejecting or archiving the event."
1239
1162
  )
1240
1163
  });
1241
1164
  var RejectAction = ActionBase.extend(
1242
- z15.object({
1243
- type: z15.literal(ActionType.REJECT),
1165
+ z14.object({
1166
+ type: z14.literal(ActionType.REJECT),
1244
1167
  content: ReasonContent
1245
1168
  }).shape
1246
1169
  );
1247
- var PotentialDuplicate = z15.object({
1170
+ var PotentialDuplicate = z14.object({
1248
1171
  id: UUID,
1249
- trackingId: z15.string()
1172
+ trackingId: z14.string()
1250
1173
  });
1251
1174
  var DuplicateDetectedAction = ActionBase.extend(
1252
- z15.object({
1253
- type: z15.literal(ActionType.DUPLICATE_DETECTED),
1254
- content: z15.object({
1255
- duplicates: z15.array(PotentialDuplicate)
1175
+ z14.object({
1176
+ type: z14.literal(ActionType.DUPLICATE_DETECTED),
1177
+ content: z14.object({
1178
+ duplicates: z14.array(PotentialDuplicate)
1256
1179
  })
1257
1180
  }).shape
1258
1181
  );
1259
1182
  var MarkNotDuplicateAction = ActionBase.extend(
1260
- z15.object({
1261
- type: z15.literal(ActionType.MARK_AS_NOT_DUPLICATE)
1183
+ z14.object({
1184
+ type: z14.literal(ActionType.MARK_AS_NOT_DUPLICATE)
1262
1185
  }).shape
1263
1186
  );
1264
1187
  var MarkAsDuplicateAction = ActionBase.extend(
1265
- z15.object({
1266
- type: z15.literal(ActionType.MARK_AS_DUPLICATE),
1267
- content: z15.object({
1188
+ z14.object({
1189
+ type: z14.literal(ActionType.MARK_AS_DUPLICATE),
1190
+ content: z14.object({
1268
1191
  duplicateOf: UUID
1269
1192
  }).optional()
1270
1193
  }).shape
1271
1194
  );
1272
1195
  var ArchiveAction = ActionBase.extend(
1273
- z15.object({
1274
- type: z15.literal(ActionType.ARCHIVE),
1196
+ z14.object({
1197
+ type: z14.literal(ActionType.ARCHIVE),
1275
1198
  content: ReasonContent
1276
1199
  }).shape
1277
1200
  );
1278
1201
  var UnarchiveAction = ActionBase.extend(
1279
- z15.object({
1280
- type: z15.literal(ActionType.UNARCHIVE)
1202
+ z14.object({
1203
+ type: z14.literal(ActionType.UNARCHIVE)
1281
1204
  }).shape
1282
1205
  );
1283
1206
  var CreatedAction = ActionBase.extend(
1284
- z15.object({
1285
- type: z15.literal(ActionType.CREATE)
1207
+ z14.object({
1208
+ type: z14.literal(ActionType.CREATE)
1286
1209
  }).shape
1287
1210
  );
1288
1211
  var NotifiedAction = ActionBase.extend(
1289
- z15.object({
1290
- type: z15.literal(ActionType.NOTIFY)
1212
+ z14.object({
1213
+ type: z14.literal(ActionType.NOTIFY)
1291
1214
  }).shape
1292
1215
  );
1293
1216
  var EditAction = ActionBase.extend(
1294
- z15.object({
1295
- type: z15.literal(ActionType.EDIT),
1217
+ z14.object({
1218
+ type: z14.literal(ActionType.EDIT),
1296
1219
  /** @deprecated New Edit-actions should no longer contain content. This is kept for old 2.0 edits. */
1297
- content: z15.object({
1298
- comment: z15.string().describe("Comment for the edit action.").optional()
1220
+ content: z14.object({
1221
+ comment: z14.string().describe("Comment for the edit action.").optional()
1299
1222
  }).optional()
1300
1223
  }).shape
1301
1224
  );
1302
- var PrintContent = z15.object({
1303
- templateId: z15.string().optional()
1225
+ var PrintContent = z14.object({
1226
+ templateId: z14.string().optional()
1304
1227
  });
1305
1228
  var PrintCertificateAction = ActionBase.extend(
1306
- z15.object({
1307
- type: z15.literal(ActionType.PRINT_CERTIFICATE),
1229
+ z14.object({
1230
+ type: z14.literal(ActionType.PRINT_CERTIFICATE),
1308
1231
  content: PrintContent.optional().nullable()
1309
1232
  }).shape
1310
1233
  );
1311
1234
  var RequestedCorrectionAction = ActionBase.extend(
1312
- z15.object({
1313
- type: z15.literal(ActionType.REQUEST_CORRECTION)
1235
+ z14.object({
1236
+ type: z14.literal(ActionType.REQUEST_CORRECTION)
1314
1237
  }).shape
1315
1238
  );
1316
1239
  var ApprovedCorrectionAction = ActionBase.extend(
1317
- z15.object({
1318
- type: z15.literal(ActionType.APPROVE_CORRECTION),
1319
- requestId: z15.string(),
1240
+ z14.object({
1241
+ type: z14.literal(ActionType.APPROVE_CORRECTION),
1242
+ requestId: z14.string(),
1320
1243
  // TODO move into 'content' property
1321
- content: z15.object({ immediateCorrection: z15.boolean().optional() }).optional()
1244
+ content: z14.object({ immediateCorrection: z14.boolean().optional() }).optional()
1322
1245
  }).shape
1323
1246
  );
1324
1247
  var RejectedCorrectionAction = ActionBase.extend(
1325
- z15.object({
1326
- type: z15.literal(ActionType.REJECT_CORRECTION),
1327
- requestId: z15.string(),
1248
+ z14.object({
1249
+ type: z14.literal(ActionType.REJECT_CORRECTION),
1250
+ requestId: z14.string(),
1328
1251
  // TODO move into 'content' property
1329
1252
  content: ReasonContent
1330
1253
  }).shape
1331
1254
  );
1332
1255
  var ReadAction = ActionBase.extend(
1333
- z15.object({
1334
- type: z15.literal(ActionType.READ)
1256
+ z14.object({
1257
+ type: z14.literal(ActionType.READ)
1335
1258
  }).shape
1336
1259
  );
1337
1260
  var CustomAction = ActionBase.merge(
1338
- z15.object({
1339
- type: z15.literal(ActionType.CUSTOM),
1340
- customActionType: z15.string()
1261
+ z14.object({
1262
+ type: z14.literal(ActionType.CUSTOM),
1263
+ customActionType: z14.string()
1341
1264
  })
1342
1265
  );
1343
- var ActionDocument = z15.discriminatedUnion("type", [
1266
+ var ActionDocument = z14.discriminatedUnion("type", [
1344
1267
  CreatedAction.meta({ id: "CreatedAction" }),
1345
1268
  RejectAction.meta({ id: "RejectAction" }),
1346
1269
  DuplicateDetectedAction.meta({ id: "DuplicateDetectedAction" }),
@@ -1367,12 +1290,64 @@ var AsyncRejectActionDocument = ActionBase.omit({
1367
1290
  declaration: true,
1368
1291
  annotation: true
1369
1292
  }).extend(
1370
- z15.object({
1371
- type: z15.enum(ConfirmableActions),
1372
- status: z15.literal(ActionStatus.Rejected)
1293
+ z14.object({
1294
+ type: z14.enum(ConfirmableActions),
1295
+ status: z14.literal(ActionStatus.Rejected)
1373
1296
  }).shape
1374
1297
  );
1375
- var Action = z15.union([ActionDocument, AsyncRejectActionDocument]);
1298
+ var Action = z14.union([ActionDocument, AsyncRejectActionDocument]);
1299
+
1300
+ // ../commons/src/events/Flag.ts
1301
+ var z15 = __toESM(require("zod/v4"));
1302
+ var InherentFlags = {
1303
+ INCOMPLETE: "incomplete",
1304
+ REJECTED: "rejected",
1305
+ CORRECTION_REQUESTED: "correction-requested",
1306
+ POTENTIAL_DUPLICATE: "potential-duplicate",
1307
+ /**
1308
+ * This flag is set by the Edit-action and removed after the declaration or registration.
1309
+ * A record should never stay with the EDIT_IN_PROGRESS flag, since it should always be declared or registered right after.
1310
+ *
1311
+ * We only use this flag to determine that a NOTIFY, DECLARE or REGISTER action is allowed next.
1312
+ */
1313
+ EDIT_IN_PROGRESS: "edit-in-progress"
1314
+ };
1315
+ var ActionFlag = z15.string().regex(
1316
+ new RegExp(
1317
+ `^(${Object.values(ActionType).join("|").toLowerCase()}):(${Object.values(
1318
+ ActionStatus
1319
+ ).join("|").toLowerCase()})$`
1320
+ ),
1321
+ "Flag must be in the format ActionType:ActionStatus (lowerCase)"
1322
+ );
1323
+ var CustomFlag = z15.string().refine((val) => !Object.values(InherentFlags).includes(val), {
1324
+ message: `Custom flag cannot be one of the inherent flags: ${Object.values(
1325
+ InherentFlags
1326
+ ).join(", ")}`
1327
+ }).refine((val) => !ActionFlag.safeParse(val).success, {
1328
+ message: "Custom flag cannot match the ActionFlag pattern (ActionType:ActionStatus)."
1329
+ }).describe("Custom flag identifier defined by the country config.");
1330
+ var Flag = ActionFlag.or(z15.enum(InherentFlags)).or(CustomFlag);
1331
+ var FlagConfig = z15.object({
1332
+ id: CustomFlag,
1333
+ requiresAction: z15.boolean().describe(
1334
+ "Indicates if this flag expects an action to be performed to be cleared."
1335
+ ),
1336
+ label: TranslationConfig.describe("Human readable label of the flag.")
1337
+ }).meta({
1338
+ id: "FlagConfig",
1339
+ description: "Configuration for a custom flag that can be added to or removed from records by event actions."
1340
+ });
1341
+ var ActionFlagConfig = z15.object({
1342
+ id: Flag,
1343
+ operation: z15.enum(["add", "remove"]).describe("Operation to perform on the flag."),
1344
+ conditional: Conditional.optional().describe(
1345
+ "When conditional is met, the operation is performed on the flag. If not provided, the operation is performed unconditionally."
1346
+ )
1347
+ }).meta({
1348
+ id: "ActionFlagConfig",
1349
+ description: "Add or remove operation applied to a flag when the parent action is accepted. Optionally gated by a conditional."
1350
+ });
1376
1351
 
1377
1352
  // ../commons/src/events/EventMetadata.ts
1378
1353
  var EventStatus = z16.enum([
@@ -1530,6 +1505,13 @@ var Range = import_v4.z.object({
1530
1505
  }).meta({
1531
1506
  id: "Range"
1532
1507
  });
1508
+ var ContainsFlags = import_v4.z.object({
1509
+ anyOf: import_v4.z.array(Flag).optional(),
1510
+ noneOf: import_v4.z.array(Flag).optional(),
1511
+ allOf: import_v4.z.array(Flag).optional()
1512
+ }).meta({
1513
+ id: "ContainsFlags"
1514
+ });
1533
1515
  var Within = import_v4.z.object({ type: import_v4.z.literal("within"), location: import_v4.z.string() }).meta({
1534
1516
  id: "Within"
1535
1517
  });
@@ -3163,13 +3145,13 @@ var AdvancedSearchConfig = z28.object({
3163
3145
  });
3164
3146
 
3165
3147
  // ../commons/src/events/utils.ts
3166
- var import_lodash4 = require("lodash");
3148
+ var import_lodash = require("lodash");
3167
3149
 
3168
3150
  // ../commons/src/conditionals/validate.ts
3169
3151
  var import__ = __toESM(require("ajv/dist/2019"));
3170
3152
  var import_ajv_formats = __toESM(require("ajv-formats"));
3171
- var z32 = __toESM(require("zod/v4"));
3172
- var import_date_fns2 = require("date-fns");
3153
+ var z31 = __toESM(require("zod/v4"));
3154
+ var import_date_fns = require("date-fns");
3173
3155
 
3174
3156
  // ../commons/src/events/FieldTypeMapping.ts
3175
3157
  var z30 = __toESM(require("zod/v4"));
@@ -3177,26 +3159,152 @@ var z30 = __toESM(require("zod/v4"));
3177
3159
  // ../commons/src/events/DynamicFieldValue.ts
3178
3160
  var z29 = __toESM(require("zod/v4"));
3179
3161
 
3180
- // ../commons/src/events/state/index.ts
3181
- var import_lodash3 = require("lodash");
3182
-
3183
- // ../commons/src/utils.ts
3184
- var z31 = __toESM(require("zod/v4"));
3185
- var _ = __toESM(require("lodash"));
3186
- function getOrThrow(x, message) {
3187
- if (x === void 0 || x === null) {
3188
- throw new Error(message);
3162
+ // ../commons/src/conditionals/validate.ts
3163
+ var ajv = new import__.default({
3164
+ $data: true,
3165
+ allowUnionTypes: true,
3166
+ strict: false
3167
+ // Allow minContains and other newer features
3168
+ });
3169
+ var DataContext = z31.object({
3170
+ rootData: z31.object({
3171
+ $leafAdminStructureLocationIds: z31.array(z31.object({ id: UUID }))
3172
+ })
3173
+ });
3174
+ function resolveDataPath(rootData, dataPath, instancePath) {
3175
+ const pathParts = dataPath.split("/");
3176
+ const levels = parseInt(pathParts[0], 10);
3177
+ const referencePath = pathParts.slice(1);
3178
+ const instanceParts = instancePath.split("/").filter(Boolean);
3179
+ const traversedParts = instanceParts.slice(0, -levels);
3180
+ let current = rootData;
3181
+ for (const part of traversedParts) {
3182
+ if (current === null || current === void 0) {
3183
+ return void 0;
3184
+ }
3185
+ current = current[part];
3186
+ }
3187
+ for (const part of referencePath) {
3188
+ if (current === null || current === void 0) {
3189
+ return void 0;
3190
+ }
3191
+ current = current[part];
3192
+ }
3193
+ return current;
3194
+ }
3195
+ function todayISO() {
3196
+ return (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" });
3197
+ }
3198
+ var compiledFunctionCache = /* @__PURE__ */ new Map();
3199
+ function compileClientFunction(code) {
3200
+ let fn = compiledFunctionCache.get(code);
3201
+ if (!fn) {
3202
+ fn = new Function(`return (${code})`)();
3203
+ compiledFunctionCache.set(code, fn);
3189
3204
  }
3190
- return x;
3205
+ return fn;
3206
+ }
3207
+ (0, import_ajv_formats.default)(ajv);
3208
+ function buildClientFunctionContext(input) {
3209
+ return {
3210
+ $form: input.form,
3211
+ $now: todayISO(),
3212
+ // eslint-disable-next-line @typescript-eslint/no-use-before-define
3213
+ $online: isOnline(),
3214
+ $user: input.validatorContext?.user,
3215
+ $event: input.validatorContext?.event,
3216
+ $leafAdminStructureLocationIds: input.validatorContext?.leafAdminStructureLocationIds ?? [],
3217
+ user: input.systemVariables?.user,
3218
+ $window: input.systemVariables?.$window,
3219
+ locations: input.locations,
3220
+ adminLevelIds: input.adminLevelIds
3221
+ };
3222
+ }
3223
+ function runClientFunction(code, data, context) {
3224
+ return compileClientFunction(code)(data, context);
3191
3225
  }
3192
- function joinValues(values, separator = " ") {
3193
- return values.filter((value) => !!value).join(separator).trim();
3226
+ ajv.addKeyword({
3227
+ keyword: "daysFromDate",
3228
+ type: "string",
3229
+ schemaType: "object",
3230
+ $data: true,
3231
+ errors: true,
3232
+ validate(schema, data, _2, dataContext) {
3233
+ if (!(dataContext && dataContext.rootData && typeof dataContext.rootData === "object" && "$now" in dataContext.rootData && typeof dataContext.rootData.$now === "string")) {
3234
+ throw new Error("Validation context must contain $now");
3235
+ }
3236
+ const { days, clause } = schema;
3237
+ if (typeof data !== "string") {
3238
+ return false;
3239
+ }
3240
+ const date = new Date(data);
3241
+ if (isNaN(date.getTime())) {
3242
+ return false;
3243
+ }
3244
+ let referenceDate = schema.referenceDate;
3245
+ if (referenceDate && typeof referenceDate === "object" && "$data" in referenceDate) {
3246
+ referenceDate = resolveDataPath(
3247
+ dataContext.rootData,
3248
+ referenceDate.$data,
3249
+ dataContext.instancePath
3250
+ );
3251
+ }
3252
+ if (!referenceDate) {
3253
+ referenceDate = dataContext.rootData.$now;
3254
+ }
3255
+ const baseDate = new Date(referenceDate);
3256
+ if (isNaN(baseDate.getTime())) {
3257
+ return false;
3258
+ }
3259
+ const offsetDate = new Date(baseDate.getTime() + days * 24 * 60 * 60 * 1e3);
3260
+ return clause === "after" ? (0, import_date_fns.isAfter)(date, offsetDate) : (0, import_date_fns.isBefore)(date, offsetDate);
3261
+ }
3262
+ });
3263
+ ajv.addKeyword({
3264
+ keyword: "isLeafLevelLocation",
3265
+ type: "string",
3266
+ schemaType: "boolean",
3267
+ $data: true,
3268
+ errors: true,
3269
+ // @ts-ignore -- Force type. We will move this away from AJV next. Parsing the array will take seconds and is only called by core.
3270
+ validate(_schema, data, _2, dataContext) {
3271
+ const locationIdInput = data;
3272
+ const locations = dataContext?.rootData.$leafAdminStructureLocationIds ?? [];
3273
+ return locations.some((location) => location.id === locationIdInput);
3274
+ }
3275
+ });
3276
+ ajv.addKeyword({
3277
+ keyword: "customClientValidator",
3278
+ schemaType: "object",
3279
+ errors: true,
3280
+ // @ts-expect-error -- AJV's public types don't expose `rootData`. All
3281
+ // `validate()` callers build root data via `buildClientFunctionContext`,
3282
+ // so the cast holds.
3283
+ validate(schema, data, _2, dataContext) {
3284
+ return Boolean(
3285
+ runClientFunction(
3286
+ schema.code,
3287
+ data,
3288
+ dataContext?.rootData ?? buildClientFunctionContext({ form: {} })
3289
+ )
3290
+ );
3291
+ }
3292
+ });
3293
+ function isOnline() {
3294
+ if (typeof window !== "undefined" && typeof navigator !== "undefined") {
3295
+ return navigator.onLine;
3296
+ }
3297
+ return true;
3194
3298
  }
3195
- var FullNameV1 = z31.array(
3196
- z31.object({
3197
- use: z31.string(),
3198
- family: z31.string(),
3199
- given: z31.array(z31.string())
3299
+
3300
+ // ../commons/src/utils.ts
3301
+ var z32 = __toESM(require("zod/v4"));
3302
+ var _ = __toESM(require("lodash"));
3303
+ var FullNameV1 = z32.array(
3304
+ z32.object({
3305
+ use: z32.string(),
3306
+ family: z32.string(),
3307
+ given: z32.array(z32.string())
3200
3308
  })
3201
3309
  );
3202
3310
  function omitKeyDeep(obj, keyToRemove) {
@@ -3215,297 +3323,71 @@ function omitKeyDeep(obj, keyToRemove) {
3215
3323
  return newObj;
3216
3324
  }
3217
3325
 
3218
- // ../commons/src/events/state/utils.ts
3219
- var import_lodash = require("lodash");
3220
- function getActionRequests(actionType, actions) {
3221
- const filtered = actions.filter((action) => action.type === actionType).reverse();
3222
- const accept = filtered.find(
3223
- (action) => action.status === ActionStatus.Accepted
3224
- );
3225
- const request = filtered.find(
3226
- (action) => action.status === ActionStatus.Requested
3227
- );
3228
- const reject = filtered.find(
3229
- (action) => action.status === ActionStatus.Rejected
3230
- );
3231
- return {
3232
- reject,
3233
- accept,
3234
- request
3235
- };
3326
+ // ../commons/src/events/utils.ts
3327
+ var import_date_fns2 = require("date-fns");
3328
+ function getDeclarationFields(configuration) {
3329
+ return configuration.declaration.pages.flatMap(({ fields }) => fields);
3236
3330
  }
3237
- function getDeclarationActionCreationMetadata(actionType, actions) {
3238
- const { accept: acceptAction, request: requestAction } = getActionRequests(
3239
- actionType,
3240
- actions
3241
- );
3242
- if (!acceptAction) {
3243
- return null;
3331
+ var getActionAnnotationFields = (actionConfig) => {
3332
+ if (actionConfig.type === ActionType.REQUEST_CORRECTION) {
3333
+ return actionConfig.correctionForm.pages.flatMap(({ fields }) => fields);
3244
3334
  }
3245
- const registrationNumber = acceptAction.type === ActionType.REGISTER ? acceptAction.registrationNumber : null;
3335
+ if (actionConfig.type === ActionType.PRINT_CERTIFICATE) {
3336
+ return actionConfig.printForm.pages.flatMap(({ fields }) => fields);
3337
+ }
3338
+ const reviewFields = "review" in actionConfig && actionConfig.review != null ? actionConfig.review.fields : [];
3339
+ const formFields = "form" in actionConfig && actionConfig.form != null ? actionConfig.form : [];
3340
+ return [...reviewFields, ...formFields];
3341
+ };
3342
+ function getAllAnnotationFields(config) {
3343
+ return (0, import_lodash.flattenDeep)(config.actions.map(getActionAnnotationFields));
3344
+ }
3345
+ var findAllFields = (config) => {
3346
+ return (0, import_lodash.flattenDeep)([
3347
+ ...getDeclarationFields(config),
3348
+ ...getAllAnnotationFields(config)
3349
+ ]);
3350
+ };
3351
+ var EXCLUDED_ACTIONS = [
3352
+ ActionType.REQUEST_CORRECTION,
3353
+ ActionType.PRINT_CERTIFICATE,
3354
+ ActionType.REJECT_CORRECTION
3355
+ ];
3356
+
3357
+ // ../commons/src/conditionals/conditionals.ts
3358
+ var objectHash = __toESM(require("object-hash"));
3359
+ function defineConditional(schema) {
3360
+ const schemaWithooutIDRef = omitKeyDeep(schema, "$id");
3246
3361
  return {
3247
- // When 3rd party API returns 200 OK, we assume that the request was accepted, and persist single 'accepted' action.
3248
- createdAt: requestAction?.createdAt ?? acceptAction.createdAt,
3249
- createdBy: requestAction?.createdBy ?? acceptAction.createdBy,
3250
- createdByUserType: requestAction?.createdByUserType ?? acceptAction.createdByUserType,
3251
- createdAtLocation: requestAction?.createdAtLocation ?? acceptAction.createdAtLocation,
3252
- acceptedAt: acceptAction.createdAt,
3253
- createdByRole: requestAction?.createdByRole ?? acceptAction.createdByRole,
3254
- registrationNumber
3362
+ $id: `https://opencrvs.org/conditionals/${objectHash.sha1(schemaWithooutIDRef)}`,
3363
+ ...schemaWithooutIDRef
3255
3364
  };
3256
3365
  }
3257
- var updateActions = ActionTypes.extract([
3258
- ActionType.CREATE,
3259
- ActionType.NOTIFY,
3260
- ActionType.EDIT,
3261
- ActionType.DECLARE,
3262
- ActionType.REGISTER,
3263
- ActionType.REJECT,
3264
- ActionType.ARCHIVE,
3265
- ActionType.UNARCHIVE,
3266
- ActionType.PRINT_CERTIFICATE,
3267
- ActionType.REQUEST_CORRECTION,
3268
- ActionType.APPROVE_CORRECTION,
3269
- ActionType.REJECT_CORRECTION,
3270
- ActionType.CUSTOM
3271
- ]);
3272
- function getActionUpdateMetadata(actions) {
3273
- const createAction = getOrThrow(
3274
- actions.find((action) => action.type === ActionType.CREATE),
3275
- `Event has no ${ActionType.CREATE} action`
3276
- );
3277
- const metadataFields = [
3278
- "createdAt",
3279
- "createdBy",
3280
- "createdByUserType",
3281
- "createdAtLocation",
3282
- "createdByRole"
3283
- ];
3284
- return actions.filter(({ type }) => updateActions.safeParse(type).success).reduce(
3285
- (_2, action) => {
3286
- if (action.originalActionId) {
3287
- const originalAction = actions.find(({ id }) => id === action.originalActionId) ?? action;
3288
- return (0, import_lodash.pick)(originalAction, metadataFields);
3289
- }
3290
- return (0, import_lodash.pick)(action, metadataFields);
3366
+ function defineFormConditional(schema) {
3367
+ const schemaWithForm = {
3368
+ type: "object",
3369
+ properties: {
3370
+ $form: schema
3291
3371
  },
3292
- (0, import_lodash.pick)(createAction, metadataFields)
3293
- );
3294
- }
3295
- function getLegalStatuses(actions) {
3296
- return {
3297
- [EventStatus.enum.NOTIFIED]: getDeclarationActionCreationMetadata(
3298
- ActionType.NOTIFY,
3299
- actions
3300
- ),
3301
- [EventStatus.enum.DECLARED]: getDeclarationActionCreationMetadata(
3302
- ActionType.DECLARE,
3303
- actions
3304
- ),
3305
- [EventStatus.enum.REGISTERED]: getDeclarationActionCreationMetadata(
3306
- ActionType.REGISTER,
3307
- actions
3308
- )
3372
+ required: ["$form"]
3309
3373
  };
3374
+ return defineConditional(schemaWithForm);
3310
3375
  }
3311
-
3312
- // ../commons/src/events/state/flags.ts
3313
- var import_lodash2 = require("lodash");
3314
- var import_date_fns = require("date-fns");
3315
- function isFlagConditionMet(conditional, form, action) {
3316
- const now2 = (0, import_date_fns.isValid)((0, import_date_fns.parseISO)(action.createdAt)) ? (0, import_date_fns.formatISO)((0, import_date_fns.parseISO)(action.createdAt), { representation: "date" }) : (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" });
3317
- return validate(conditional, {
3318
- $form: form,
3319
- $now: now2,
3320
- $online: true,
3321
- $user: {
3322
- sub: "",
3323
- exp: "",
3324
- role: action.createdByRole,
3325
- algorithm: "",
3326
- scope: [],
3327
- userType: action.createdByUserType
3328
- }
3376
+ function alwaysTrue() {
3377
+ return {};
3378
+ }
3379
+ function and(...conditions) {
3380
+ return defineConditional({
3381
+ type: "object",
3382
+ allOf: conditions,
3383
+ required: []
3329
3384
  });
3330
3385
  }
3331
- function actionConfigRemovesFlag(action, flagId, actionsUpToAndIncluding, event2, eventConfiguration) {
3332
- if (!isActionConfigType(action.type)) {
3333
- return false;
3334
- }
3335
- const actionConfig = getActionConfig({
3336
- eventConfiguration,
3337
- actionType: action.type,
3338
- customActionType: "customActionType" in action ? action.customActionType : void 0
3339
- });
3340
- const removeOperations = (actionConfig?.flags ?? []).filter(
3341
- ({ id, operation }) => id === flagId && operation === "remove"
3342
- );
3343
- if (removeOperations.length === 0) {
3344
- return false;
3345
- }
3346
- const eventUpToThisAction = { ...event2, actions: actionsUpToAndIncluding };
3347
- const declaration = aggregateActionDeclarations(eventUpToThisAction);
3348
- const annotation = aggregateActionAnnotations(eventUpToThisAction);
3349
- const form = { ...declaration, ...annotation };
3350
- return removeOperations.some(
3351
- ({ conditional }) => conditional ? isFlagConditionMet(conditional, form, action) : true
3352
- );
3353
- }
3354
- var INHERENT_FLAG_RULES = [
3355
- {
3356
- flag: InherentFlags.CORRECTION_REQUESTED,
3357
- setOn: [ActionType.REQUEST_CORRECTION],
3358
- resetOn: [ActionType.APPROVE_CORRECTION, ActionType.REJECT_CORRECTION]
3359
- },
3360
- {
3361
- // INCOMPLETE mirrors the NOTIFIED status: set by NOTIFY, cleared by any
3362
- // other status-changing action (see getStatusFromActions). ARCHIVE/UNARCHIVE
3363
- // are deliberately excluded so the flag freezes across an archive/unarchive
3364
- // round trip and comes back exactly as it was.
3365
- flag: InherentFlags.INCOMPLETE,
3366
- setOn: [ActionType.NOTIFY],
3367
- resetOn: [ActionType.CREATE, ActionType.DECLARE, ActionType.REGISTER]
3368
- },
3369
- {
3370
- flag: InherentFlags.REJECTED,
3371
- setOn: [ActionType.REJECT],
3372
- resetOn: [
3373
- ActionType.NOTIFY,
3374
- ActionType.DECLARE,
3375
- ActionType.EDIT,
3376
- ActionType.REGISTER
3377
- ]
3378
- },
3379
- {
3380
- flag: InherentFlags.POTENTIAL_DUPLICATE,
3381
- setOn: [ActionType.DUPLICATE_DETECTED],
3382
- resetOn: [ActionType.MARK_AS_DUPLICATE, ActionType.MARK_AS_NOT_DUPLICATE]
3383
- },
3384
- {
3385
- flag: InherentFlags.EDIT_IN_PROGRESS,
3386
- setOn: [ActionType.EDIT],
3387
- resetOnAnyOtherAction: true
3388
- }
3389
- ];
3390
- function resolveInherentFlag(rule, acceptedActions, event2, eventConfiguration) {
3391
- return acceptedActions.reduce((present, action, idx) => {
3392
- if (rule.setOn.includes(action.type)) {
3393
- return true;
3394
- }
3395
- if (rule.resetOnAnyOtherAction || (rule.resetOn ?? []).includes(action.type)) {
3396
- return false;
3397
- }
3398
- if (actionConfigRemovesFlag(
3399
- action,
3400
- rule.flag,
3401
- acceptedActions.slice(0, idx + 1),
3402
- event2,
3403
- eventConfiguration
3404
- )) {
3405
- return false;
3406
- }
3407
- return present;
3408
- }, false);
3409
- }
3410
- function resolveEventCustomFlags(event2, eventConfiguration) {
3411
- const actions = getAcceptedActions(event2).filter(({ type }) => !isMetaAction(type)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
3412
- return actions.reduce((acc, action, idx) => {
3413
- let actionConfig;
3414
- if (isActionConfigType(action.type)) {
3415
- actionConfig = getActionConfig({
3416
- eventConfiguration,
3417
- actionType: action.type,
3418
- customActionType: "customActionType" in action ? action.customActionType : void 0
3419
- });
3420
- }
3421
- if (!actionConfig) {
3422
- return acc;
3423
- }
3424
- const eventUpToThisAction = {
3425
- ...event2,
3426
- actions: actions.slice(0, idx + 1)
3427
- };
3428
- const declaration = aggregateActionDeclarations(eventUpToThisAction);
3429
- const annotation = aggregateActionAnnotations(eventUpToThisAction);
3430
- const form = { ...declaration, ...annotation };
3431
- const flagsWithMetConditions = (actionConfig.flags ?? []).filter(
3432
- ({ conditional }) => (
3433
- // If conditional is not provided, the flag is resolved
3434
- conditional ? isFlagConditionMet(conditional, form, action) : true
3435
- )
3436
- );
3437
- const addedFlags = flagsWithMetConditions.filter(({ operation }) => operation === "add").map(({ id }) => id);
3438
- const removedFlags = flagsWithMetConditions.filter(({ operation }) => operation === "remove").map(({ id }) => id);
3439
- const flags = [...acc, ...addedFlags].filter(
3440
- (flagId) => !removedFlags.includes(flagId)
3441
- );
3442
- return (0, import_lodash2.uniq)(flags);
3443
- }, []);
3444
- }
3445
- function getActionStatusFlags(sortedActions) {
3446
- const actionStatus = sortedActions.reduce(
3447
- (actionStatuses, { type, status }) => ({
3448
- ...actionStatuses,
3449
- [type]: status
3450
- }),
3451
- {}
3452
- );
3453
- return Object.entries(actionStatus).filter(([, status]) => status !== ActionStatus.Accepted).map(([type, status]) => {
3454
- const flag = joinValues([type, status], ":").toLowerCase();
3455
- return flag;
3456
- });
3457
- }
3458
- function getInherentFlags(sortedActions, event2, eventConfiguration) {
3459
- const acceptedActions = sortedActions.filter(
3460
- ({ status }) => status === ActionStatus.Accepted
3461
- );
3462
- return INHERENT_FLAG_RULES.filter(
3463
- (rule) => resolveInherentFlag(rule, acceptedActions, event2, eventConfiguration)
3464
- ).map(({ flag }) => flag);
3465
- }
3466
- function getEventFlags(event2, config) {
3467
- const sortedActions = event2.actions.filter(({ type }) => !isMetaAction(type)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
3468
- return [
3469
- ...getActionStatusFlags(sortedActions),
3470
- ...getInherentFlags(sortedActions, event2, config),
3471
- ...resolveEventCustomFlags(event2, config)
3472
- ];
3473
- }
3474
-
3475
- // ../commons/src/conditionals/conditionals.ts
3476
- var objectHash = __toESM(require("object-hash"));
3477
- function defineConditional(schema) {
3478
- const schemaWithooutIDRef = omitKeyDeep(schema, "$id");
3479
- return {
3480
- $id: `https://opencrvs.org/conditionals/${objectHash.sha1(schemaWithooutIDRef)}`,
3481
- ...schemaWithooutIDRef
3482
- };
3483
- }
3484
- function defineFormConditional(schema) {
3485
- const schemaWithForm = {
3486
- type: "object",
3487
- properties: {
3488
- $form: schema
3489
- },
3490
- required: ["$form"]
3491
- };
3492
- return defineConditional(schemaWithForm);
3493
- }
3494
- function alwaysTrue() {
3495
- return {};
3496
- }
3497
- function and(...conditions) {
3498
- return defineConditional({
3499
- type: "object",
3500
- allOf: conditions,
3501
- required: []
3502
- });
3503
- }
3504
- function not(condition) {
3505
- return defineConditional({
3506
- type: "object",
3507
- not: condition,
3508
- required: []
3386
+ function not(condition) {
3387
+ return defineConditional({
3388
+ type: "object",
3389
+ not: condition,
3390
+ required: []
3509
3391
  });
3510
3392
  }
3511
3393
  function never2() {
@@ -3969,620 +3851,114 @@ function createFieldConditionals(fieldId) {
3969
3851
  },
3970
3852
  /**
3971
3853
  * Checks if the field value matches a given regular expression pattern.
3972
- * @param pattern - The regular expression pattern to match the field value against.
3973
- * @returns A JSONSchema conditional that validates the field value against the pattern.
3974
- */
3975
- matches(pattern) {
3976
- return defineFormConditional({
3977
- type: "object",
3978
- properties: wrapToPath(
3979
- {
3980
- [fieldId]: {
3981
- type: "string",
3982
- pattern
3983
- }
3984
- },
3985
- this.$$subfield
3986
- ),
3987
- required: [fieldId]
3988
- });
3989
- },
3990
- isBetween(min, max) {
3991
- return defineFormConditional({
3992
- type: "object",
3993
- properties: {
3994
- [fieldId]: wrapToPath(
3995
- {
3996
- type: "number",
3997
- minimum: min,
3998
- maximum: max
3999
- },
4000
- this.$$subfield
4001
- )
4002
- },
4003
- required: [fieldId]
4004
- });
4005
- },
4006
- getId: () => ({ fieldId }),
4007
- /**
4008
- * @deprecated
4009
- * use field(fieldId).get(nestedProperty) instead
4010
- * with 'and' combinator e.g.
4011
- * and(
4012
- * field('child.name').get('firstname').isEqualTo('John'),
4013
- * field('child.name').get('surname').isEqualTo('Doe')
4014
- * )
4015
- */
4016
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
4017
- object: (options) => defineFormConditional({
4018
- type: "object",
4019
- properties: {
4020
- [fieldId]: {
4021
- type: "object",
4022
- properties: Object.fromEntries(
4023
- Object.entries(options).map(([key, value]) => {
4024
- return [key, value.properties.$form.properties[key]];
4025
- })
4026
- ),
4027
- required: Object.keys(options)
4028
- }
4029
- },
4030
- required: [fieldId]
4031
- }),
4032
- /**
4033
- * Custom client-side validator. The provided function is serialised and executed
4034
- * just-in-time on the client only. External references (e.g. lodash) are not
4035
- * available inside the function body — all logic must be self-contained.
4036
- *
4037
- * @example
4038
- * field('nid').customClientValidator((value) => {
4039
- * // LUHN check — all logic must be inline
4040
- * const digits = String(value).split('').map(Number)
4041
- * // ...
4042
- * return isValid
4043
- * })
4044
- */
4045
- customClientValidator(validationFn) {
4046
- const code = validationFn.toString();
4047
- return defineFormConditional({
4048
- type: "object",
4049
- properties: wrapToPath(
4050
- { [fieldId]: { customClientValidator: { code } } },
4051
- this.$$subfield
4052
- ),
4053
- required: [fieldId]
4054
- });
4055
- },
4056
- /**
4057
- * Custom client-side evaluation. Returns a {@link FieldReference} descriptor
4058
- * that can be used as the `value` property or a DATA component entry.
4059
- * The function receives the referenced field's value as the first argument and
4060
- * the full form context as the second; its return value replaces the field reference.
4061
- * The function is serialised and executed just-in-time on the client only.
4062
- * External references (e.g. lodash) are not available inside the function body.
4063
- *
4064
- * For computing a default value without referencing a specific field, use
4065
- * `evaluate(fn)` in the `defaultValue` property instead.
4066
- *
4067
- * @example
4068
- * field('a').customClientEvaluation((aValue, ctx) =>
4069
- * Number(aValue) + Number(ctx.$form.b)
4070
- * )
4071
- */
4072
- customClientEvaluation(computationFn) {
4073
- return {
4074
- $$code: computationFn.toString(),
4075
- $$field: fieldId,
4076
- $$subfield: this.$$subfield
4077
- };
4078
- }
4079
- };
4080
- }
4081
-
4082
- // ../commons/src/events/state/index.ts
4083
- function getStatusFromActions(actions) {
4084
- const acceptedActions = actions.filter(
4085
- ({ status }) => status === ActionStatus.Accepted
4086
- );
4087
- const isCurrentlyArchived = acceptedActions.reduce(
4088
- (archived, action) => {
4089
- if (action.type === ActionType.ARCHIVE) {
4090
- return true;
4091
- }
4092
- if (action.type === ActionType.UNARCHIVE) {
4093
- return false;
4094
- }
4095
- return archived;
4096
- },
4097
- false
4098
- );
4099
- if (isCurrentlyArchived) {
4100
- return EventStatus.enum.ARCHIVED;
4101
- }
4102
- return acceptedActions.filter(
4103
- ({ type }) => type !== ActionType.ARCHIVE && type !== ActionType.UNARCHIVE
4104
- ).reduce((status, action) => {
4105
- switch (action.type) {
4106
- case ActionType.CREATE:
4107
- return EventStatus.enum.CREATED;
4108
- case ActionType.DECLARE:
4109
- return EventStatus.enum.DECLARED;
4110
- case ActionType.REGISTER:
4111
- return EventStatus.enum.REGISTERED;
4112
- case ActionType.NOTIFY:
4113
- return EventStatus.enum.NOTIFIED;
4114
- // Already filtered out above; listed here only to satisfy exhaustiveness.
4115
- case ActionType.ARCHIVE:
4116
- case ActionType.UNARCHIVE:
4117
- case ActionType.CUSTOM:
4118
- case ActionType.PRINT_CERTIFICATE:
4119
- case ActionType.ASSIGN:
4120
- case ActionType.UNASSIGN:
4121
- case ActionType.REJECT:
4122
- case ActionType.REQUEST_CORRECTION:
4123
- case ActionType.APPROVE_CORRECTION:
4124
- case ActionType.DUPLICATE_DETECTED:
4125
- case ActionType.MARK_AS_NOT_DUPLICATE:
4126
- case ActionType.MARK_AS_DUPLICATE:
4127
- case ActionType.REJECT_CORRECTION:
4128
- case ActionType.READ:
4129
- case ActionType.EDIT:
4130
- default:
4131
- return status;
4132
- }
4133
- }, EventStatus.enum.CREATED);
4134
- }
4135
- function getAssignedUserFromActions(actions) {
4136
- return actions.reduce((user2, action) => {
4137
- if (action.type === ActionType.ASSIGN) {
4138
- return action.assignedTo;
4139
- }
4140
- if (action.type === ActionType.UNASSIGN) {
4141
- return null;
4142
- }
4143
- return user2;
4144
- }, null);
4145
- }
4146
- function deepDropNulls(obj) {
4147
- if (Array.isArray(obj)) {
4148
- return obj.map(deepDropNulls);
4149
- }
4150
- if (obj !== null && typeof obj === "object") {
4151
- return Object.entries(obj).reduce((acc, [key, value]) => {
4152
- const cleanedValue = deepDropNulls(value);
4153
- if (cleanedValue !== null) {
4154
- ;
4155
- acc[key] = cleanedValue;
4156
- }
4157
- return acc;
4158
- }, {});
4159
- }
4160
- return obj;
4161
- }
4162
- var DEFAULT_DATE_OF_EVENT_PROPERTY = "createdAt";
4163
- function extractDateString(dateTime) {
4164
- return dateTime.split("T")[0];
4165
- }
4166
- function resolveDateOfEvent(eventIndex, declaration, config) {
4167
- if (!config.dateOfEvent) {
4168
- return extractDateString(eventIndex[DEFAULT_DATE_OF_EVENT_PROPERTY]);
4169
- }
4170
- const parsedDate = isFieldReference(config.dateOfEvent) ? ZodDate.safeParse(declaration[config.dateOfEvent.$$field]) : ZodDateTime.safeParse(
4171
- getMixedPath(eventIndex, config.dateOfEvent.$$event)
4172
- );
4173
- return parsedDate.success ? extractDateString(parsedDate.data) : void 0;
4174
- }
4175
- var DEFAULT_PLACE_OF_EVENT_PROPERTY = "createdAtLocation";
4176
- function getParsedUUID(value, oldValue) {
4177
- const parsed = UUID.safeParse(value);
4178
- return parsed.success ? parsed.data : oldValue;
4179
- }
4180
- function resolvePlaceOfEvent(eventMetadata, declaration, config) {
4181
- let placeOfEvent = getParsedUUID(
4182
- eventMetadata[DEFAULT_PLACE_OF_EVENT_PROPERTY]
4183
- );
4184
- if (config.placeOfEvent) {
4185
- const addressFieldValue = AddressFieldValue.safeParse(
4186
- declaration[config.placeOfEvent.$$field]
4187
- );
4188
- if (addressFieldValue.success && addressFieldValue.data.addressType === AddressType.DOMESTIC && addressFieldValue.data.administrativeArea) {
4189
- placeOfEvent = getParsedUUID(
4190
- addressFieldValue.data.administrativeArea,
4191
- placeOfEvent
4192
- );
4193
- } else {
4194
- placeOfEvent = getParsedUUID(
4195
- declaration[config.placeOfEvent.$$field],
4196
- placeOfEvent
4197
- );
4198
- }
4199
- }
4200
- return placeOfEvent;
4201
- }
4202
- function extractPotentialDuplicatesFromActions(actions) {
4203
- return actions.reduce((duplicates, action) => {
4204
- if (action.type === ActionType.DUPLICATE_DETECTED) {
4205
- duplicates = action.content.duplicates;
4206
- }
4207
- if (action.type === ActionType.MARK_AS_NOT_DUPLICATE || action.type === ActionType.MARK_AS_DUPLICATE) {
4208
- duplicates = [];
4209
- }
4210
- return duplicates;
4211
- }, []);
4212
- }
4213
- function getCurrentEventState(event2, config) {
4214
- const sortedActions = event2.actions.slice().sort((a, b) => a.createdAt.localeCompare(b.createdAt));
4215
- const creationAction = sortedActions.find(
4216
- (action) => action.type === ActionType.CREATE
4217
- );
4218
- if (!creationAction) {
4219
- throw new Error(`Event ${event2.id} has no creation action`);
4220
- }
4221
- const acceptedActions = getAcceptedActions(event2).sort(
4222
- (a, b) => a.createdAt.localeCompare(b.createdAt)
4223
- );
4224
- const requestActionMetadata = getActionUpdateMetadata(sortedActions);
4225
- const acceptedActionMetadata = getActionUpdateMetadata(acceptedActions);
4226
- const declaration = aggregateActionDeclarations(event2);
4227
- const status = getStatusFromActions(sortedActions);
4228
- const legalStatuses = getLegalStatuses(sortedActions);
4229
- const base = deepDropNulls({
4230
- id: event2.id,
4231
- type: event2.type,
4232
- status,
4233
- legalStatuses,
4234
- createdAt: creationAction.createdAt,
4235
- createdBy: creationAction.createdBy,
4236
- createdByUserType: creationAction.createdByUserType,
4237
- createdAtLocation: creationAction.createdAtLocation,
4238
- updatedAt: acceptedActionMetadata.createdAt,
4239
- assignedTo: getAssignedUserFromActions(acceptedActions),
4240
- updatedBy: requestActionMetadata.createdBy,
4241
- updatedAtLocation: requestActionMetadata.createdAtLocation,
4242
- declaration,
4243
- trackingId: event2.trackingId,
4244
- updatedByUserRole: requestActionMetadata.createdByRole,
4245
- placeOfEvent: resolvePlaceOfEvent(
4246
- { createdAtLocation: creationAction.createdAtLocation },
4247
- declaration,
4248
- config
4249
- ),
4250
- potentialDuplicates: extractPotentialDuplicatesFromActions(sortedActions),
4251
- flags: getEventFlags(event2, config)
4252
- });
4253
- return deepDropNulls({
4254
- ...base,
4255
- dateOfEvent: resolveDateOfEvent(base, declaration, config)
4256
- });
4257
- }
4258
-
4259
- // ../commons/src/conditionals/validate.ts
4260
- var ajv = new import__.default({
4261
- $data: true,
4262
- allowUnionTypes: true,
4263
- strict: false
4264
- // Allow minContains and other newer features
4265
- });
4266
- var DataContext = z32.object({
4267
- rootData: z32.object({
4268
- $leafAdminStructureLocationIds: z32.array(z32.object({ id: UUID }))
4269
- })
4270
- });
4271
- function resolveDataPath(rootData, dataPath, instancePath) {
4272
- const pathParts = dataPath.split("/");
4273
- const levels = parseInt(pathParts[0], 10);
4274
- const referencePath = pathParts.slice(1);
4275
- const instanceParts = instancePath.split("/").filter(Boolean);
4276
- const traversedParts = instanceParts.slice(0, -levels);
4277
- let current = rootData;
4278
- for (const part of traversedParts) {
4279
- if (current === null || current === void 0) {
4280
- return void 0;
4281
- }
4282
- current = current[part];
4283
- }
4284
- for (const part of referencePath) {
4285
- if (current === null || current === void 0) {
4286
- return void 0;
4287
- }
4288
- current = current[part];
4289
- }
4290
- return current;
4291
- }
4292
- function todayISO() {
4293
- return (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" });
4294
- }
4295
- var compiledFunctionCache = /* @__PURE__ */ new Map();
4296
- function compileClientFunction(code) {
4297
- let fn = compiledFunctionCache.get(code);
4298
- if (!fn) {
4299
- fn = new Function(`return (${code})`)();
4300
- compiledFunctionCache.set(code, fn);
4301
- }
4302
- return fn;
4303
- }
4304
- (0, import_ajv_formats.default)(ajv);
4305
- function buildClientFunctionContext(input) {
4306
- const flags = input.validatorContext?.event && input.validatorContext?.eventConfig ? getCurrentEventState(
4307
- input.validatorContext?.event,
4308
- input.validatorContext?.eventConfig
4309
- )?.flags : [];
4310
- return {
4311
- $form: input.form,
4312
- $flags: flags,
4313
- $now: todayISO(),
4314
- // eslint-disable-next-line @typescript-eslint/no-use-before-define
4315
- $online: isOnline(),
4316
- $user: input.validatorContext?.user,
4317
- $event: input.validatorContext?.event,
4318
- $leafAdminStructureLocationIds: input.validatorContext?.leafAdminStructureLocationIds ?? [],
4319
- user: input.systemVariables?.user,
4320
- $window: input.systemVariables?.$window,
4321
- locations: input.locations,
4322
- adminLevelIds: input.adminLevelIds
4323
- };
4324
- }
4325
- function runClientFunction(code, data, context) {
4326
- return compileClientFunction(code)(data, context);
4327
- }
4328
- ajv.addKeyword({
4329
- keyword: "daysFromDate",
4330
- type: "string",
4331
- schemaType: "object",
4332
- $data: true,
4333
- errors: true,
4334
- validate(schema, data, _2, dataContext) {
4335
- if (!(dataContext && dataContext.rootData && typeof dataContext.rootData === "object" && "$now" in dataContext.rootData && typeof dataContext.rootData.$now === "string")) {
4336
- throw new Error("Validation context must contain $now");
4337
- }
4338
- const { days, clause } = schema;
4339
- if (typeof data !== "string") {
4340
- return false;
4341
- }
4342
- const date = new Date(data);
4343
- if (isNaN(date.getTime())) {
4344
- return false;
4345
- }
4346
- let referenceDate = schema.referenceDate;
4347
- if (referenceDate && typeof referenceDate === "object" && "$data" in referenceDate) {
4348
- referenceDate = resolveDataPath(
4349
- dataContext.rootData,
4350
- referenceDate.$data,
4351
- dataContext.instancePath
4352
- );
4353
- }
4354
- if (!referenceDate) {
4355
- referenceDate = dataContext.rootData.$now;
4356
- }
4357
- const baseDate = new Date(referenceDate);
4358
- if (isNaN(baseDate.getTime())) {
4359
- return false;
4360
- }
4361
- const offsetDate = new Date(baseDate.getTime() + days * 24 * 60 * 60 * 1e3);
4362
- return clause === "after" ? (0, import_date_fns2.isAfter)(date, offsetDate) : (0, import_date_fns2.isBefore)(date, offsetDate);
4363
- }
4364
- });
4365
- ajv.addKeyword({
4366
- keyword: "isLeafLevelLocation",
4367
- type: "string",
4368
- schemaType: "boolean",
4369
- $data: true,
4370
- errors: true,
4371
- // @ts-ignore -- Force type. We will move this away from AJV next. Parsing the array will take seconds and is only called by core.
4372
- validate(_schema, data, _2, dataContext) {
4373
- const locationIdInput = data;
4374
- const locations = dataContext?.rootData.$leafAdminStructureLocationIds ?? [];
4375
- return locations.some((location) => location.id === locationIdInput);
4376
- }
4377
- });
4378
- function isAgeValue(value) {
4379
- return typeof value === "object" && value !== null && "age" in value && typeof value.age === "number";
4380
- }
4381
- ajv.addKeyword({
4382
- keyword: "customClientValidator",
4383
- schemaType: "object",
4384
- errors: true,
4385
- // @ts-expect-error -- AJV's public types don't expose `rootData`. All
4386
- // `validate()` callers build root data via `buildClientFunctionContext`,
4387
- // so the cast holds.
4388
- validate(schema, data, _2, dataContext) {
4389
- return Boolean(
4390
- runClientFunction(
4391
- schema.code,
4392
- data,
4393
- dataContext?.rootData ?? buildClientFunctionContext({ form: {} })
4394
- )
4395
- );
4396
- }
4397
- });
4398
- function validate(schema, data) {
4399
- const validator = ajv.getSchema(schema.$id) || ajv.compile(schema);
4400
- if ("$form" in data) {
4401
- const entries = Object.entries(data.$form).map(([key, value]) => {
4402
- if (!isAgeValue(value)) {
4403
- return [key, value];
4404
- }
4405
- const age = value.age;
4406
- const maybeAsOfDate = PlainDate.safeParse(data.$form[value.asOfDateRef]);
4407
- return [
4408
- key,
4409
- {
4410
- age,
4411
- dob: ageToDate(
4412
- age,
4413
- maybeAsOfDate.success ? maybeAsOfDate.data : PlainDate.parse(data.$now)
3854
+ * @param pattern - The regular expression pattern to match the field value against.
3855
+ * @returns A JSONSchema conditional that validates the field value against the pattern.
3856
+ */
3857
+ matches(pattern) {
3858
+ return defineFormConditional({
3859
+ type: "object",
3860
+ properties: wrapToPath(
3861
+ {
3862
+ [fieldId]: {
3863
+ type: "string",
3864
+ pattern
3865
+ }
3866
+ },
3867
+ this.$$subfield
3868
+ ),
3869
+ required: [fieldId]
3870
+ });
3871
+ },
3872
+ isBetween(min, max) {
3873
+ return defineFormConditional({
3874
+ type: "object",
3875
+ properties: {
3876
+ [fieldId]: wrapToPath(
3877
+ {
3878
+ type: "number",
3879
+ minimum: min,
3880
+ maximum: max
3881
+ },
3882
+ this.$$subfield
4414
3883
  )
3884
+ },
3885
+ required: [fieldId]
3886
+ });
3887
+ },
3888
+ getId: () => ({ fieldId }),
3889
+ /**
3890
+ * @deprecated
3891
+ * use field(fieldId).get(nestedProperty) instead
3892
+ * with 'and' combinator e.g.
3893
+ * and(
3894
+ * field('child.name').get('firstname').isEqualTo('John'),
3895
+ * field('child.name').get('surname').isEqualTo('Doe')
3896
+ * )
3897
+ */
3898
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
3899
+ object: (options) => defineFormConditional({
3900
+ type: "object",
3901
+ properties: {
3902
+ [fieldId]: {
3903
+ type: "object",
3904
+ properties: Object.fromEntries(
3905
+ Object.entries(options).map(([key, value]) => {
3906
+ return [key, value.properties.$form.properties[key]];
3907
+ })
3908
+ ),
3909
+ required: Object.keys(options)
4415
3910
  }
4416
- ];
4417
- });
4418
- data.$form = Object.fromEntries(entries);
4419
- }
4420
- const result = validator(data);
4421
- return result;
4422
- }
4423
- function isOnline() {
4424
- if (typeof window !== "undefined" && typeof navigator !== "undefined") {
4425
- return navigator.onLine;
4426
- }
4427
- return true;
4428
- }
4429
-
4430
- // ../commons/src/events/utils.ts
4431
- var import_date_fns3 = require("date-fns");
4432
- function ageToDate(age, asOfDate) {
4433
- const date = plainDateToLocalDate(asOfDate);
4434
- return PlainDate.parse((0, import_date_fns3.format)((0, import_date_fns3.subYears)(date, age), "yyyy-MM-dd"));
4435
- }
4436
- function getDeclarationFields(configuration) {
4437
- return configuration.declaration.pages.flatMap(({ fields }) => fields);
4438
- }
4439
- function isActionConfigType(type) {
4440
- return actionConfigTypes.has(type);
4441
- }
4442
- function getActionConfig({
4443
- eventConfiguration,
4444
- actionType,
4445
- customActionType
4446
- }) {
4447
- if (actionType === ActionType.NOTIFY) {
4448
- return eventConfiguration.actions.find((a) => a.type === ActionType.NOTIFY) ?? eventConfiguration.actions.find((a) => a.type === ActionType.DECLARE);
4449
- }
4450
- return eventConfiguration.actions.find((a) => {
4451
- if (a.type === ActionType.CUSTOM && customActionType) {
4452
- return a.customActionType === customActionType;
4453
- }
4454
- return a.type === actionType;
4455
- });
4456
- }
4457
- var getActionAnnotationFields = (actionConfig) => {
4458
- if (actionConfig.type === ActionType.REQUEST_CORRECTION) {
4459
- return actionConfig.correctionForm.pages.flatMap(({ fields }) => fields);
4460
- }
4461
- if (actionConfig.type === ActionType.PRINT_CERTIFICATE) {
4462
- return actionConfig.printForm.pages.flatMap(({ fields }) => fields);
4463
- }
4464
- const reviewFields = "review" in actionConfig && actionConfig.review != null ? actionConfig.review.fields : [];
4465
- const formFields = "form" in actionConfig && actionConfig.form != null ? actionConfig.form : [];
4466
- return [...reviewFields, ...formFields];
4467
- };
4468
- function getAllAnnotationFields(config) {
4469
- return (0, import_lodash4.flattenDeep)(config.actions.map(getActionAnnotationFields));
4470
- }
4471
- function deepMerge(currentDocument, actionDocument) {
4472
- const currentDocumentClone = (0, import_lodash4.cloneDeep)(currentDocument);
4473
- return (0, import_lodash4.mergeWith)(
4474
- (0, import_lodash4.cloneDeep)(currentDocumentClone),
4475
- actionDocument,
4476
- (previousValue, incomingValue) => {
4477
- if (incomingValue === void 0) {
4478
- return previousValue;
4479
- }
4480
- if ((0, import_lodash4.isArray)(incomingValue)) {
4481
- return incomingValue;
4482
- }
4483
- if ((0, import_lodash4.isObject)(previousValue) && (0, import_lodash4.isObject)(incomingValue)) {
4484
- return void 0;
4485
- }
4486
- return incomingValue;
4487
- }
4488
- );
4489
- }
4490
- var findAllFields = (config) => {
4491
- return (0, import_lodash4.flattenDeep)([
4492
- ...getDeclarationFields(config),
4493
- ...getAllAnnotationFields(config)
4494
- ]);
4495
- };
4496
- function getMixedPath(obj, path, defaultValue) {
4497
- const parts = path.split(".");
4498
- const resolve = (current, segments) => {
4499
- if (current == null || segments.length === 0) {
4500
- return current;
4501
- }
4502
- for (let i = segments.length; i > 0; i--) {
4503
- const compoundKey = segments.slice(0, i).join(".");
4504
- if ((0, import_lodash4.has)(current, compoundKey)) {
4505
- const next = (0, import_lodash4.get)(current, compoundKey);
4506
- return resolve(next, segments.slice(i));
4507
- }
3911
+ },
3912
+ required: [fieldId]
3913
+ }),
3914
+ /**
3915
+ * Custom client-side validator. The provided function is serialised and executed
3916
+ * just-in-time on the client only. External references (e.g. lodash) are not
3917
+ * available inside the function body — all logic must be self-contained.
3918
+ *
3919
+ * @example
3920
+ * field('nid').customClientValidator((value) => {
3921
+ * // LUHN check — all logic must be inline
3922
+ * const digits = String(value).split('').map(Number)
3923
+ * // ...
3924
+ * return isValid
3925
+ * })
3926
+ */
3927
+ customClientValidator(validationFn) {
3928
+ const code = validationFn.toString();
3929
+ return defineFormConditional({
3930
+ type: "object",
3931
+ properties: wrapToPath(
3932
+ { [fieldId]: { customClientValidator: { code } } },
3933
+ this.$$subfield
3934
+ ),
3935
+ required: [fieldId]
3936
+ });
3937
+ },
3938
+ /**
3939
+ * Custom client-side evaluation. Returns a {@link FieldReference} descriptor
3940
+ * that can be used as the `value` property or a DATA component entry.
3941
+ * The function receives the referenced field's value as the first argument and
3942
+ * the full form context as the second; its return value replaces the field reference.
3943
+ * The function is serialised and executed just-in-time on the client only.
3944
+ * External references (e.g. lodash) are not available inside the function body.
3945
+ *
3946
+ * For computing a default value without referencing a specific field, use
3947
+ * `evaluate(fn)` in the `defaultValue` property instead.
3948
+ *
3949
+ * @example
3950
+ * field('a').customClientEvaluation((aValue, ctx) =>
3951
+ * Number(aValue) + Number(ctx.$form.b)
3952
+ * )
3953
+ */
3954
+ customClientEvaluation(computationFn) {
3955
+ return {
3956
+ $$code: computationFn.toString(),
3957
+ $$field: fieldId,
3958
+ $$subfield: this.$$subfield
3959
+ };
4508
3960
  }
4509
- return void 0;
4510
3961
  };
4511
- const result = resolve(obj, parts);
4512
- return (0, import_lodash4.isNil)(result) ? defaultValue : result;
4513
- }
4514
- function isAcceptedAction(a) {
4515
- return a.status === ActionStatus.Accepted;
4516
- }
4517
- function getCompleteActionAnnotation(event2, action) {
4518
- if (action.originalActionId) {
4519
- const originalAction = event2.actions.find(
4520
- ({ id }) => id === action.originalActionId
4521
- );
4522
- if (originalAction?.status === ActionStatus.Requested) {
4523
- return deepMerge(originalAction.annotation ?? {}, action.annotation ?? {});
4524
- }
4525
- }
4526
- return action.annotation ?? {};
4527
- }
4528
- function getCompleteActionDeclaration(declaration, event2, action) {
4529
- if (action.originalActionId) {
4530
- const originalAction = event2.actions.find(
4531
- ({ id }) => id === action.originalActionId
4532
- );
4533
- if (originalAction?.status === ActionStatus.Requested) {
4534
- return deepMerge(
4535
- deepMerge(declaration, originalAction.declaration),
4536
- action.declaration
4537
- );
4538
- }
4539
- }
4540
- return deepMerge(declaration, action.declaration);
4541
- }
4542
- function getAcceptedActions(event2) {
4543
- return event2.actions.filter(isAcceptedAction).map((action) => ({
4544
- ...action,
4545
- declaration: getCompleteActionDeclaration({}, event2, action),
4546
- annotation: getCompleteActionAnnotation(event2, action)
4547
- }));
4548
- }
4549
- var EXCLUDED_ACTIONS = [
4550
- ActionType.REQUEST_CORRECTION,
4551
- ActionType.PRINT_CERTIFICATE,
4552
- ActionType.REJECT_CORRECTION
4553
- ];
4554
- function aggregateActionDeclarations(event2) {
4555
- const allAcceptedActions = getAcceptedActions(event2);
4556
- const aggregatedActions = allAcceptedActions.filter((a) => !EXCLUDED_ACTIONS.some((type) => type === a.type)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
4557
- return aggregatedActions.reduce((declaration, action) => {
4558
- if (action.type === ActionType.APPROVE_CORRECTION) {
4559
- const requestAction = allAcceptedActions.find(
4560
- ({ id }) => id === action.requestId
4561
- );
4562
- if (!requestAction) {
4563
- return declaration;
4564
- }
4565
- const declarationWithApprovedCorrection = getCompleteActionDeclaration(
4566
- declaration,
4567
- event2,
4568
- requestAction
4569
- );
4570
- return getCompleteActionDeclaration(
4571
- declarationWithApprovedCorrection,
4572
- event2,
4573
- action
4574
- );
4575
- }
4576
- return getCompleteActionDeclaration(declaration, event2, action);
4577
- }, {});
4578
- }
4579
- function aggregateActionAnnotations(event2) {
4580
- return event2.actions.reduce((ann, sortedAction) => {
4581
- if (!("annotation" in sortedAction) || !sortedAction.annotation) {
4582
- return ann;
4583
- }
4584
- return deepMerge(ann, sortedAction.annotation);
4585
- }, {});
4586
3962
  }
4587
3963
 
4588
3964
  // ../commons/src/events/eventConfigValidation.ts
@@ -5426,14 +4802,14 @@ var DraftInput = BaseActionInput.omit({ waitFor: true }).extend({
5426
4802
 
5427
4803
  // ../commons/src/events/EventInput.ts
5428
4804
  var z40 = __toESM(require("zod/v4"));
5429
- var import_uuid11 = require("uuid");
4805
+ var import_uuid10 = require("uuid");
5430
4806
  var EventInput = z40.object({
5431
4807
  transactionId: z40.string(),
5432
4808
  type: z40.string(),
5433
4809
  createdAtLocation: UUID.nullish().describe(
5434
4810
  "Location where the event occurred. Required for system users."
5435
4811
  )
5436
- }).meta({ default: { transactionId: (0, import_uuid11.v4)(), type: "birth" } });
4812
+ }).meta({ default: { transactionId: (0, import_uuid10.v4)(), type: "birth" } });
5437
4813
 
5438
4814
  // ../commons/src/events/EventDocument.ts
5439
4815
  var z41 = __toESM(require("zod/v4"));
@@ -5450,6 +4826,67 @@ var EventDocument = z41.object({
5450
4826
  )
5451
4827
  }).meta({ id: "EventDocument" });
5452
4828
 
4829
+ // ../commons/src/events/state/index.ts
4830
+ var import_lodash4 = require("lodash");
4831
+
4832
+ // ../commons/src/events/state/utils.ts
4833
+ var import_lodash2 = require("lodash");
4834
+ var updateActions = ActionTypes.extract([
4835
+ ActionType.CREATE,
4836
+ ActionType.NOTIFY,
4837
+ ActionType.EDIT,
4838
+ ActionType.DECLARE,
4839
+ ActionType.REGISTER,
4840
+ ActionType.REJECT,
4841
+ ActionType.ARCHIVE,
4842
+ ActionType.UNARCHIVE,
4843
+ ActionType.PRINT_CERTIFICATE,
4844
+ ActionType.REQUEST_CORRECTION,
4845
+ ActionType.APPROVE_CORRECTION,
4846
+ ActionType.REJECT_CORRECTION,
4847
+ ActionType.CUSTOM
4848
+ ]);
4849
+
4850
+ // ../commons/src/events/state/flags.ts
4851
+ var import_lodash3 = require("lodash");
4852
+ var import_date_fns3 = require("date-fns");
4853
+ var INHERENT_FLAG_RULES = [
4854
+ {
4855
+ flag: InherentFlags.CORRECTION_REQUESTED,
4856
+ setOn: [ActionType.REQUEST_CORRECTION],
4857
+ resetOn: [ActionType.APPROVE_CORRECTION, ActionType.REJECT_CORRECTION]
4858
+ },
4859
+ {
4860
+ // INCOMPLETE mirrors the NOTIFIED status: set by NOTIFY, cleared by any
4861
+ // other status-changing action (see getStatusFromActions). ARCHIVE/UNARCHIVE
4862
+ // are deliberately excluded so the flag freezes across an archive/unarchive
4863
+ // round trip and comes back exactly as it was.
4864
+ flag: InherentFlags.INCOMPLETE,
4865
+ setOn: [ActionType.NOTIFY],
4866
+ resetOn: [ActionType.CREATE, ActionType.DECLARE, ActionType.REGISTER]
4867
+ },
4868
+ {
4869
+ flag: InherentFlags.REJECTED,
4870
+ setOn: [ActionType.REJECT],
4871
+ resetOn: [
4872
+ ActionType.NOTIFY,
4873
+ ActionType.DECLARE,
4874
+ ActionType.EDIT,
4875
+ ActionType.REGISTER
4876
+ ]
4877
+ },
4878
+ {
4879
+ flag: InherentFlags.POTENTIAL_DUPLICATE,
4880
+ setOn: [ActionType.DUPLICATE_DETECTED],
4881
+ resetOn: [ActionType.MARK_AS_DUPLICATE, ActionType.MARK_AS_NOT_DUPLICATE]
4882
+ },
4883
+ {
4884
+ flag: InherentFlags.EDIT_IN_PROGRESS,
4885
+ setOn: [ActionType.EDIT],
4886
+ resetOnAnyOtherAction: true
4887
+ }
4888
+ ];
4889
+
5453
4890
  // ../commons/src/events/defineConfig.ts
5454
4891
  var IGNORED_EVENT_TYPES = [
5455
4892
  "FOOTBALL_CLUB_MEMBERSHIP",
@@ -7922,21 +7359,44 @@ var LocationTypeV1 = z43.enum([
7922
7359
  "CRVS_OFFICE",
7923
7360
  "HEALTH_FACILITY"
7924
7361
  ]);
7362
+ var LocationStatus = z43.enum(["active", "inactive"]);
7363
+ var LocationVersion = z43.object({
7364
+ versionId: UUID,
7365
+ effectiveFrom: z43.iso.date(),
7366
+ name: z43.string(),
7367
+ externalId: z43.string().nullish(),
7368
+ status: LocationStatus
7369
+ });
7925
7370
  var AdministrativeArea = z43.object({
7926
7371
  id: UUID,
7927
7372
  name: z43.string(),
7928
7373
  externalId: z43.string().nullish(),
7929
7374
  parentId: UUID.nullable(),
7930
- validUntil: z43.iso.datetime().nullable()
7375
+ status: LocationStatus,
7376
+ versions: z43.array(LocationVersion)
7931
7377
  });
7932
7378
  var Location = z43.object({
7933
7379
  id: UUID,
7934
7380
  name: z43.string(),
7935
7381
  externalId: z43.string().nullish(),
7936
7382
  administrativeAreaId: UUID.nullable(),
7937
- validUntil: z43.iso.datetime().nullable(),
7383
+ locationType: z43.string().nullable(),
7384
+ status: LocationStatus,
7385
+ versions: z43.array(LocationVersion)
7386
+ });
7387
+ var SetLocationPayload = z43.object({
7388
+ id: UUID,
7389
+ name: z43.string(),
7390
+ externalId: z43.string().nullish(),
7391
+ administrativeAreaId: UUID.nullable(),
7938
7392
  locationType: z43.string().nullable()
7939
7393
  });
7394
+ var SetAdministrativeAreaPayload = z43.object({
7395
+ id: UUID,
7396
+ name: z43.string(),
7397
+ externalId: z43.string().nullish(),
7398
+ parentId: UUID.nullable()
7399
+ });
7940
7400
 
7941
7401
  // ../commons/src/events/scopes.ts
7942
7402
  var ACTION_SCOPE_MAP = {
@@ -8035,75 +7495,80 @@ var REJECTED_ACTIONS = [
8035
7495
  var import_lodash7 = require("lodash");
8036
7496
 
8037
7497
  // ../commons/src/events/mocks.test.utils.ts
8038
- var V2_DEFAULT_MOCK_ADMINISTRATIVE_AREAS = [
7498
+ function withVersionFields(entity) {
7499
+ return {
7500
+ ...entity,
7501
+ status: "active",
7502
+ versions: [
7503
+ {
7504
+ versionId: entity.id,
7505
+ effectiveFrom: "0001-01-01",
7506
+ name: entity.name,
7507
+ externalId: entity.externalId ?? null,
7508
+ status: "active"
7509
+ }
7510
+ ]
7511
+ };
7512
+ }
7513
+ var MOCK_ADMINISTRATIVE_AREAS_BASE = [
8039
7514
  {
8040
7515
  id: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
8041
7516
  name: "Central",
8042
7517
  parentId: null,
8043
- validUntil: null,
8044
7518
  externalId: "ydyJb1RAy4U1"
8045
7519
  },
8046
7520
  {
8047
7521
  id: "c599b691-fd2d-45e1-abf4-d185de727fb5",
8048
7522
  name: "Sulaka",
8049
7523
  parentId: null,
8050
- validUntil: null,
8051
7524
  externalId: "pQ8nGxWmZ2Q3"
8052
7525
  },
8053
7526
  {
8054
7527
  id: "7ef2b9c7-5e6d-49f6-ae05-656207d0fc64",
8055
7528
  name: "Pualula",
8056
7529
  parentId: null,
8057
- validUntil: null,
8058
7530
  externalId: "Aq91DweLmT8k"
8059
7531
  },
8060
7532
  {
8061
7533
  id: "6d1a59df-988c-4021-a846-ccbc021931a7",
8062
7534
  name: "Chuminga",
8063
7535
  parentId: null,
8064
- validUntil: null,
8065
7536
  externalId: "Rw0fYNh2Xk9a"
8066
7537
  },
8067
7538
  {
8068
7539
  id: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8069
7540
  name: "Ibombo",
8070
7541
  parentId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
8071
- validUntil: null,
8072
7542
  externalId: "k7DsP4vbN1Qe"
8073
7543
  },
8074
7544
  {
8075
7545
  id: "27160bbd-32d1-4625-812f-860226bfb92a",
8076
7546
  name: "Isango",
8077
7547
  parentId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
8078
- validUntil: null,
8079
7548
  externalId: "Gm3Z9eQpHw4L"
8080
7549
  },
8081
7550
  {
8082
7551
  id: "967032fd-3f81-478a-826c-30cb8fe121bd",
8083
7552
  name: "Isamba",
8084
7553
  parentId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
8085
- validUntil: null,
8086
7554
  externalId: "sT0xVu1KqJ7r"
8087
7555
  },
8088
7556
  {
8089
7557
  id: "89a33893-b17d-481d-a26d-6461e7ac1651",
8090
7558
  name: "Itambo",
8091
7559
  parentId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
8092
- validUntil: null,
8093
7560
  externalId: "Nq6Bv2HpL9Te"
8094
7561
  },
8095
7562
  {
8096
7563
  id: "d42ab2fe-e7ed-470e-8b31-4fb27f9b8250",
8097
7564
  name: "Ezhi",
8098
7565
  parentId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
8099
- validUntil: null,
8100
7566
  externalId: "xK8cQ0ZRy5Wd"
8101
7567
  },
8102
7568
  {
8103
7569
  id: "8fbd09d2-212b-47f4-beb3-5e1694931d9f",
8104
7570
  name: "Ilanga",
8105
7571
  parentId: "c599b691-fd2d-45e1-abf4-d185de727fb5",
8106
- validUntil: null,
8107
7572
  externalId: "Cq4Jm1XvN8Ls"
8108
7573
  },
8109
7574
  // Villages under Ibombo (62a0ccb4-880d-4f30-8882-f256007dfff9)
@@ -8111,49 +7576,42 @@ var V2_DEFAULT_MOCK_ADMINISTRATIVE_AREAS = [
8111
7576
  id: "1d4e5f6a-7b8c-4912-8efa-345678901234",
8112
7577
  name: "Klow",
8113
7578
  parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8114
- validUntil: null,
8115
7579
  externalId: "IkYcYBUcyY2"
8116
7580
  },
8117
7581
  {
8118
7582
  id: "2e5f6a7b-8c9d-4a23-8fab-456789012345",
8119
7583
  name: "Mbondo",
8120
7584
  parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8121
- validUntil: null,
8122
7585
  externalId: "Qhvv5hvo3mY"
8123
7586
  },
8124
7587
  {
8125
7588
  id: "3f6a7b8c-9d0e-4b34-8abc-567890123456",
8126
7589
  name: "Ndara",
8127
7590
  parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8128
- validUntil: null,
8129
7591
  externalId: "crXh068O9TR"
8130
7592
  },
8131
7593
  {
8132
7594
  id: "4a7b8c9d-0e1f-4c45-abcd-678901234567",
8133
7595
  name: "Olani",
8134
7596
  parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8135
- validUntil: null,
8136
7597
  externalId: "r00It8Tvvp7"
8137
7598
  },
8138
7599
  {
8139
7600
  id: "5b8c9d0e-1f2a-4d56-bcde-789012345678",
8140
7601
  name: "Pemba",
8141
7602
  parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8142
- validUntil: null,
8143
7603
  externalId: "ZnUWsbONIaH"
8144
7604
  },
8145
7605
  {
8146
7606
  id: "6c9d0e1f-2a3b-4e67-8def-890123456789",
8147
7607
  name: "Quanza",
8148
7608
  parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8149
- validUntil: null,
8150
7609
  externalId: "fDZycvQTa7l"
8151
7610
  },
8152
7611
  {
8153
7612
  id: "7d0e1f2a-3b4c-4f78-8efa-901234567890",
8154
7613
  name: "Rivka",
8155
7614
  parentId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8156
- validUntil: null,
8157
7615
  externalId: "KqswxCGTELa"
8158
7616
  },
8159
7617
  // Villages under Isamba (967032fd-3f81-478a-826c-30cb8fe121bd)
@@ -8161,35 +7619,30 @@ var V2_DEFAULT_MOCK_ADMINISTRATIVE_AREAS = [
8161
7619
  id: "8e1f2a3b-4c5d-4089-8fab-012345678901",
8162
7620
  name: "Mbula",
8163
7621
  parentId: "967032fd-3f81-478a-826c-30cb8fe121bd",
8164
- validUntil: null,
8165
7622
  externalId: "osEbKjRc9Kg"
8166
7623
  },
8167
7624
  {
8168
7625
  id: "9f2a3b4c-5d6e-4190-8abf-123456789012",
8169
7626
  name: "Ndoki",
8170
7627
  parentId: "967032fd-3f81-478a-826c-30cb8fe121bd",
8171
- validUntil: null,
8172
7628
  externalId: "aq4daBUAGr3"
8173
7629
  },
8174
7630
  {
8175
7631
  id: "0a3b4c5d-6e7f-4201-abcd-234567890123",
8176
7632
  name: "Tsanga",
8177
7633
  parentId: "967032fd-3f81-478a-826c-30cb8fe121bd",
8178
- validUntil: null,
8179
7634
  externalId: "cqis6Y8trbJ"
8180
7635
  },
8181
7636
  {
8182
7637
  id: "1b4c5d6e-7f8a-4312-bcde-345678901234",
8183
7638
  name: "Waziri",
8184
7639
  parentId: "967032fd-3f81-478a-826c-30cb8fe121bd",
8185
- validUntil: null,
8186
7640
  externalId: "LMijHPyyx6d"
8187
7641
  },
8188
7642
  {
8189
7643
  id: "2c5d6e7f-8a9b-4423-8def-456789012345",
8190
7644
  name: "Zimbi",
8191
7645
  parentId: "967032fd-3f81-478a-826c-30cb8fe121bd",
8192
- validUntil: null,
8193
7646
  externalId: "pcQYbPuKGZ7"
8194
7647
  },
8195
7648
  // Villages under Itambo (89a33893-b17d-481d-a26d-6461e7ac1651)
@@ -8197,67 +7650,59 @@ var V2_DEFAULT_MOCK_ADMINISTRATIVE_AREAS = [
8197
7650
  id: "3d6e7f8a-9b0c-4534-8efa-567890123456",
8198
7651
  name: "Felani",
8199
7652
  parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
8200
- validUntil: null,
8201
7653
  externalId: "gSqpoCGdMXp"
8202
7654
  },
8203
7655
  {
8204
7656
  id: "4e7f8a9b-0c1d-4645-8fab-678901234567",
8205
7657
  name: "Goroma",
8206
7658
  parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
8207
- validUntil: null,
8208
7659
  externalId: "KvAAIaNqVrp"
8209
7660
  },
8210
7661
  {
8211
7662
  id: "5f8a9b0c-1d2e-4756-8abc-789012345678",
8212
7663
  name: "Halifu",
8213
7664
  parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
8214
- validUntil: null,
8215
7665
  externalId: "qe4UnEVt1hv"
8216
7666
  },
8217
7667
  {
8218
7668
  id: "6a9b0c1d-2e3f-4867-abcd-890123456789",
8219
7669
  name: "Jabari",
8220
7670
  parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
8221
- validUntil: null,
8222
7671
  externalId: "yHH9Nz4rLOt"
8223
7672
  },
8224
7673
  {
8225
7674
  id: "7b0c1d2e-3f4a-4978-bcde-901234567890",
8226
7675
  name: "Kifani",
8227
7676
  parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
8228
- validUntil: null,
8229
7677
  externalId: "eSWmXIGeu1I"
8230
7678
  },
8231
7679
  {
8232
7680
  id: "8c1d2e3f-4a5b-4089-8def-012345678901",
8233
7681
  name: "Lumela",
8234
7682
  parentId: "89a33893-b17d-481d-a26d-6461e7ac1651",
8235
- validUntil: null,
8236
7683
  externalId: "bh0b3aI1uP3"
8237
7684
  }
8238
7685
  ];
8239
- var V2_DEFAULT_MOCK_LOCATIONS = [
7686
+ var V2_DEFAULT_MOCK_ADMINISTRATIVE_AREAS = MOCK_ADMINISTRATIVE_AREAS_BASE.map(withVersionFields);
7687
+ var MOCK_LOCATIONS_BASE = [
8240
7688
  {
8241
7689
  id: "6f6186ce-cd5f-4a5f-810a-2d99e7c4ba12",
8242
7690
  name: "Central Provincial Office",
8243
7691
  locationType: "CRVS_OFFICE",
8244
7692
  administrativeAreaId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
8245
- validUntil: null,
8246
7693
  externalId: "Xr3Df8WpK6Ys"
8247
7694
  },
8248
7695
  {
8249
7696
  id: "b1c2d3e4-f5a6-7890-bcde-f12345678901",
8250
7697
  name: "Central Health Post",
8251
7698
  locationType: "HEALTH_FACILITY",
8252
- administrativeAreaId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
8253
- validUntil: null
7699
+ administrativeAreaId: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c"
8254
7700
  },
8255
7701
  {
8256
7702
  id: "028d2c85-ca31-426d-b5d1-2cef545a4902",
8257
7703
  name: "Ibombo District Office",
8258
7704
  locationType: "CRVS_OFFICE",
8259
7705
  administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8260
- validUntil: null,
8261
7706
  externalId: "Sm4Nw7GrD2Vy"
8262
7707
  },
8263
7708
  {
@@ -8265,7 +7710,6 @@ var V2_DEFAULT_MOCK_LOCATIONS = [
8265
7710
  name: "Isamba District Office",
8266
7711
  locationType: "CRVS_OFFICE",
8267
7712
  administrativeAreaId: "967032fd-3f81-478a-826c-30cb8fe121bd",
8268
- validUntil: null,
8269
7713
  externalId: "Vg1Bq5XeH9Lt"
8270
7714
  },
8271
7715
  {
@@ -8273,7 +7717,6 @@ var V2_DEFAULT_MOCK_LOCATIONS = [
8273
7717
  name: "Isango District Office",
8274
7718
  locationType: "CRVS_OFFICE",
8275
7719
  administrativeAreaId: "27160bbd-32d1-4625-812f-860226bfb92a",
8276
- validUntil: null,
8277
7720
  externalId: "Je7Lm2XqN9Vz"
8278
7721
  },
8279
7722
  {
@@ -8281,7 +7724,6 @@ var V2_DEFAULT_MOCK_LOCATIONS = [
8281
7724
  name: "Sulaka Provincial Office",
8282
7725
  locationType: "CRVS_OFFICE",
8283
7726
  administrativeAreaId: "c599b691-fd2d-45e1-abf4-d185de727fb5",
8284
- validUntil: null,
8285
7727
  externalId: "Ht2Wp9KcX5Qv"
8286
7728
  },
8287
7729
  {
@@ -8289,7 +7731,6 @@ var V2_DEFAULT_MOCK_LOCATIONS = [
8289
7731
  name: "Ilanga District Office",
8290
7732
  locationType: "CRVS_OFFICE",
8291
7733
  administrativeAreaId: "8fbd09d2-212b-47f4-beb3-5e1694931d9f",
8292
- validUntil: null,
8293
7734
  externalId: "Yp6Ds1WqN3Xz"
8294
7735
  },
8295
7736
  {
@@ -8297,7 +7738,6 @@ var V2_DEFAULT_MOCK_LOCATIONS = [
8297
7738
  name: "Chamakubi Health Post",
8298
7739
  locationType: "HEALTH_FACILITY",
8299
7740
  administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8300
- validUntil: null,
8301
7741
  externalId: "M1nFr8LbC2Qy"
8302
7742
  },
8303
7743
  {
@@ -8305,7 +7745,6 @@ var V2_DEFAULT_MOCK_LOCATIONS = [
8305
7745
  name: "Ibombo Rural Health Centre",
8306
7746
  locationType: "HEALTH_FACILITY",
8307
7747
  administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8308
- validUntil: null,
8309
7748
  externalId: "bT7pV6YrW0Xc"
8310
7749
  },
8311
7750
  {
@@ -8313,7 +7752,6 @@ var V2_DEFAULT_MOCK_LOCATIONS = [
8313
7752
  name: "Chikobo Rural Health Centre",
8314
7753
  locationType: "HEALTH_FACILITY",
8315
7754
  administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8316
- validUntil: null,
8317
7755
  externalId: "zE4qPn2SgJ5d"
8318
7756
  },
8319
7757
  {
@@ -8321,7 +7759,6 @@ var V2_DEFAULT_MOCK_LOCATIONS = [
8321
7759
  name: "Chilochabalenje Health Post",
8322
7760
  locationType: "HEALTH_FACILITY",
8323
7761
  administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8324
- validUntil: null,
8325
7762
  externalId: "H8vDs1MqR4Uf"
8326
7763
  },
8327
7764
  {
@@ -8329,7 +7766,6 @@ var V2_DEFAULT_MOCK_LOCATIONS = [
8329
7766
  name: "Chipeso Rural Health Centre",
8330
7767
  locationType: "HEALTH_FACILITY",
8331
7768
  administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8332
- validUntil: null,
8333
7769
  externalId: "Qw3uZ9KfX6Lm"
8334
7770
  },
8335
7771
  {
@@ -8337,7 +7773,6 @@ var V2_DEFAULT_MOCK_LOCATIONS = [
8337
7773
  name: "Chisamba Rural Health Centre",
8338
7774
  locationType: "HEALTH_FACILITY",
8339
7775
  administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8340
- validUntil: null,
8341
7776
  externalId: "Yr0pCg8LdM2s"
8342
7777
  },
8343
7778
  {
@@ -8345,7 +7780,6 @@ var V2_DEFAULT_MOCK_LOCATIONS = [
8345
7780
  name: "Chitanda Rural Health Centre",
8346
7781
  locationType: "HEALTH_FACILITY",
8347
7782
  administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8348
- validUntil: null,
8349
7783
  externalId: "tS9gJ4PwB1Qx"
8350
7784
  },
8351
7785
  {
@@ -8353,7 +7787,6 @@ var V2_DEFAULT_MOCK_LOCATIONS = [
8353
7787
  name: "Golden Valley Rural Health Centre",
8354
7788
  locationType: "HEALTH_FACILITY",
8355
7789
  administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8356
- validUntil: null,
8357
7790
  externalId: "Ld7Qm3XsA8Vr"
8358
7791
  },
8359
7792
  {
@@ -8361,7 +7794,6 @@ var V2_DEFAULT_MOCK_LOCATIONS = [
8361
7794
  name: "Ipongo Rural Health Centre",
8362
7795
  locationType: "HEALTH_FACILITY",
8363
7796
  administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8364
- validUntil: null,
8365
7797
  externalId: "kF2sW9DmH0Bt"
8366
7798
  },
8367
7799
  {
@@ -8369,7 +7801,6 @@ var V2_DEFAULT_MOCK_LOCATIONS = [
8369
7801
  name: "Itumbwe Health Post",
8370
7802
  locationType: "HEALTH_FACILITY",
8371
7803
  administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8372
- validUntil: null,
8373
7804
  externalId: "Ue5Xb3VaC7Pq"
8374
7805
  },
8375
7806
  {
@@ -8377,7 +7808,6 @@ var V2_DEFAULT_MOCK_LOCATIONS = [
8377
7808
  name: "Kabangalala Rural Health Centre",
8378
7809
  locationType: "HEALTH_FACILITY",
8379
7810
  administrativeAreaId: "62a0ccb4-880d-4f30-8882-f256007dfff9",
8380
- validUntil: null,
8381
7811
  externalId: "Pz8Kc1TqH6Jn"
8382
7812
  },
8383
7813
  // Village offices
@@ -8386,10 +7816,10 @@ var V2_DEFAULT_MOCK_LOCATIONS = [
8386
7816
  name: "Klow Village Office",
8387
7817
  locationType: "CRVS_OFFICE",
8388
7818
  administrativeAreaId: "1d4e5f6a-7b8c-4912-8efa-345678901234",
8389
- validUntil: null,
8390
7819
  externalId: "PmAyxAJkxiJ"
8391
7820
  }
8392
7821
  ];
7822
+ var V2_DEFAULT_MOCK_LOCATIONS = MOCK_LOCATIONS_BASE.map(withVersionFields);
8393
7823
  var V2_DEFAULT_MOCK_LOCATIONS_MAP = new Map(
8394
7824
  V2_DEFAULT_MOCK_LOCATIONS.map((l) => [l.id, l])
8395
7825
  );