@opencrvs/toolkit 2.1.0-rc.e773220 → 2.1.0-rc.eb366a1

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.
Files changed (31) hide show
  1. package/dist/application-config/index.js +210 -187
  2. package/dist/commons/api/router.d.ts +613 -20
  3. package/dist/commons/conditionals/conditionals.d.ts +6 -6
  4. package/dist/commons/conditionals/validate.d.ts +2 -1
  5. package/dist/commons/events/ActionConfig.d.ts +54 -0
  6. package/dist/commons/events/ActionDocument.d.ts +45 -7
  7. package/dist/commons/events/ActionInput.d.ts +26 -0
  8. package/dist/commons/events/ActionStatus.d.ts +14 -0
  9. package/dist/commons/events/ActionType.d.ts +6 -1
  10. package/dist/commons/events/AdvancedSearchConfig.d.ts +12 -0
  11. package/dist/commons/events/AuditLog.d.ts +2 -0
  12. package/dist/commons/events/CountryConfigQueryInput.d.ts +18 -0
  13. package/dist/commons/events/Draft.d.ts +2 -0
  14. package/dist/commons/events/EventDocument.d.ts +22 -0
  15. package/dist/commons/events/EventIndex.d.ts +5 -24
  16. package/dist/commons/events/EventMetadata.d.ts +2 -1
  17. package/dist/commons/events/FieldConfig.d.ts +10 -0
  18. package/dist/commons/events/Flag.d.ts +48 -0
  19. package/dist/commons/events/WorkqueueColumnConfig.d.ts +4 -4
  20. package/dist/commons/events/WorkqueueConfig.d.ts +25 -7
  21. package/dist/commons/events/scopes.d.ts +1 -0
  22. package/dist/commons/events/test.utils.d.ts +9 -1
  23. package/dist/commons/events/utils.d.ts +23 -1
  24. package/dist/conditionals/index.js +305 -55
  25. package/dist/events/index.js +3261 -3141
  26. package/dist/notification/index.js +1481 -882
  27. package/dist/scopes/index.d.ts +257 -1
  28. package/dist/scopes/index.js +306 -55
  29. package/opencrvs-toolkit-2.1.0-rc.eb366a1.tgz +0 -0
  30. package/package.json +1 -1
  31. package/opencrvs-toolkit-2.1.0-rc.e773220.tgz +0 -0
@@ -47,14 +47,14 @@ function joinUrl(base, path) {
47
47
  }
48
48
 
49
49
  // ../commons/src/events/AuditLog.ts
50
- var z5 = __toESM(require("zod/v4"));
50
+ var z8 = __toESM(require("zod/v4"));
51
51
 
52
52
  // ../commons/src/authentication.ts
53
53
  var import_jwt_decode = __toESM(require("jwt-decode"));
54
- var z3 = __toESM(require("zod/v4"));
54
+ var z7 = __toESM(require("zod/v4"));
55
55
 
56
56
  // ../commons/src/scopes.ts
57
- var z2 = __toESM(require("zod/v4"));
57
+ var z6 = __toESM(require("zod/v4"));
58
58
  var qs = __toESM(require("qs"));
59
59
 
60
60
  // ../commons/src/uuid.ts
@@ -65,12 +65,264 @@ 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
+
68
320
  // ../commons/src/scopes.ts
69
- var JurisdictionFilter = z2.enum(["administrativeArea", "location", "all"]).describe(
321
+ var JurisdictionFilter = z6.enum(["administrativeArea", "location", "all"]).describe(
70
322
  "Filters based on user jurisdiction relative to their office location in hierarchy."
71
323
  );
72
- var UserFilter = z2.enum(["user"]).describe("Filters based on the user. Limits to self.");
73
- var RecordScopeTypeV2 = z2.enum([
324
+ var UserFilter = z6.enum(["user"]).describe("Filters based on the user. Limits to self.");
325
+ var RecordScopeTypeV2 = z6.enum([
74
326
  "record.search",
75
327
  "record.create",
76
328
  "record.read",
@@ -79,6 +331,7 @@ var RecordScopeTypeV2 = z2.enum([
79
331
  "record.edit",
80
332
  "record.reject",
81
333
  "record.archive",
334
+ "record.unarchive",
82
335
  "record.review-duplicates",
83
336
  "record.register",
84
337
  "record.print-certified-copies",
@@ -87,7 +340,7 @@ var RecordScopeTypeV2 = z2.enum([
87
340
  "record.unassign-others",
88
341
  "record.custom-action"
89
342
  ]);
90
- var PlainScopeType = z2.enum([
343
+ var PlainScopeType = z6.enum([
91
344
  // Misc. system scopes
92
345
  "bypassratelimit",
93
346
  "record.reindex",
@@ -106,15 +359,15 @@ var PlainScopeType = z2.enum([
106
359
  "record.confirm-registration",
107
360
  "record.reject-registration"
108
361
  ]);
109
- var scopeByEvent = z2.preprocess(
362
+ var scopeByEvent = z6.preprocess(
110
363
  (val) => val === void 0 ? void 0 : [val].flat(),
111
- z2.array(z2.string()).optional()
364
+ z6.array(z6.string()).optional()
112
365
  ).describe("Event type, e.g. birth, death");
113
- var userRole = z2.preprocess(
366
+ var userRole = z6.preprocess(
114
367
  (val) => val === void 0 ? void 0 : [val].flat(),
115
- z2.array(z2.string()).optional()
368
+ z6.array(z6.string()).optional()
116
369
  ).describe("User role, e.g. admin, field agent");
117
- var scopeOptionsPlaceEvent = z2.object({
370
+ var scopeOptionsPlaceEvent = z6.object({
118
371
  event: scopeByEvent,
119
372
  placeOfEvent: JurisdictionFilter.optional()
120
373
  }).describe("Options applicable to all record scopes.");
@@ -126,36 +379,37 @@ var scopeOptionsDeclaredOrNotified = scopeOptionsPlaceEvent.extend({
126
379
  }).describe("Options applicable to actions that may take place after DECLARE");
127
380
  var AllRecordScopeOptions = scopeOptionsDeclaredOrNotified.extend({
128
381
  registeredIn: JurisdictionFilter.optional(),
129
- registeredBy: UserFilter.optional()
382
+ registeredBy: UserFilter.optional(),
383
+ flags: ContainsFlags.optional()
130
384
  }).describe(
131
385
  "Options applicable to actions that may take place after REGISTER, with full filtering capabilities."
132
386
  );
133
387
  var CustomActionScopeOptions = AllRecordScopeOptions.extend({
134
- customActionTypes: z2.preprocess(
388
+ customActionTypes: z6.preprocess(
135
389
  (val) => val === void 0 ? void 0 : [val].flat(),
136
- z2.array(z2.string()).optional()
390
+ z6.array(z6.string()).optional()
137
391
  ).describe("Allowed custom action types")
138
392
  });
139
- var AccessLevelOptions = z2.object({
393
+ var AccessLevelOptions = z6.object({
140
394
  accessLevel: JurisdictionFilter.optional()
141
395
  });
142
396
  var AllUserScopeOptions = AccessLevelOptions.extend({
143
397
  role: userRole.optional()
144
398
  });
145
- var WorkqueueOrDashboardOptions = z2.object({
146
- ids: z2.preprocess(
399
+ var WorkqueueOrDashboardOptions = z6.object({
400
+ ids: z6.preprocess(
147
401
  (val) => val === void 0 ? void 0 : [val].flat(),
148
- z2.array(z2.string())
402
+ z6.array(z6.string())
149
403
  ).describe("Must contain a list of workqueue or dashboard ids.")
150
404
  });
151
- var AllScopeOptions = z2.object({
405
+ var AllScopeOptions = z6.object({
152
406
  ...AllRecordScopeOptions.shape,
153
407
  ...AccessLevelOptions.shape,
154
408
  ...AllUserScopeOptions.shape,
155
409
  ...WorkqueueOrDashboardOptions.shape
156
410
  });
157
411
  var ScopeOptionKey = AllScopeOptions.keyof();
158
- var ResolvedScopeOptionsPlaceEvent = z2.object({
412
+ var ResolvedScopeOptionsPlaceEvent = z6.object({
159
413
  event: scopeByEvent,
160
414
  placeOfEvent: UUID.nullish()
161
415
  }).describe(
@@ -163,15 +417,16 @@ var ResolvedScopeOptionsPlaceEvent = z2.object({
163
417
  );
164
418
  var ResolvedScopeOptionsDeclared = ResolvedScopeOptionsPlaceEvent.extend({
165
419
  notifiedIn: UUID.nullish(),
166
- notifiedBy: z2.string().optional(),
420
+ notifiedBy: z6.string().optional(),
167
421
  declaredIn: UUID.nullish(),
168
- declaredBy: z2.string().optional()
422
+ declaredBy: z6.string().optional()
169
423
  }).describe(
170
424
  "Resolved options applicable to actions that may take place after DECLARE, with location ID and user ID instead of filters."
171
425
  );
172
426
  var ResolvedScopeOptionsFull = ResolvedScopeOptionsDeclared.extend({
173
427
  registeredIn: UUID.nullish(),
174
- registeredBy: z2.string().optional()
428
+ registeredBy: z6.string().optional(),
429
+ flags: ContainsFlags.optional()
175
430
  }).describe(
176
431
  "Resolved options applicable to actions that may take place after REGISTER, with full filtering capabilities and location/user IDs instead of filters."
177
432
  );
@@ -184,6 +439,7 @@ var ScopesWithDeclaredOptions = RecordScopeTypeV2.extract([
184
439
  "record.edit",
185
440
  "record.reject",
186
441
  "record.archive",
442
+ "record.unarchive",
187
443
  "record.review-duplicates",
188
444
  "record.register"
189
445
  ]);
@@ -195,38 +451,38 @@ var ScopesWithFullOptions = RecordScopeTypeV2.extract([
195
451
  "record.unassign-others"
196
452
  ]);
197
453
  var ScopeOptionsPrintCertifiedCopies = AllRecordScopeOptions.extend({
198
- templates: z2.preprocess(
454
+ templates: z6.preprocess(
199
455
  (val) => val === void 0 ? void 0 : [val].flat(),
200
- z2.array(z2.string()).optional()
456
+ z6.array(z6.string()).optional()
201
457
  ).describe(
202
458
  "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."
203
459
  )
204
460
  });
205
- var RecordScopeV2 = z2.discriminatedUnion("type", [
206
- z2.object({
461
+ var RecordScopeV2 = z6.discriminatedUnion("type", [
462
+ z6.object({
207
463
  type: ScopesWithPlaceEventOptions,
208
464
  options: scopeOptionsPlaceEvent.optional()
209
465
  }),
210
- z2.object({
466
+ z6.object({
211
467
  type: ScopesWithDeclaredOptions,
212
468
  options: scopeOptionsDeclaredOrNotified.optional()
213
469
  }),
214
- z2.object({
470
+ z6.object({
215
471
  type: ScopesWithFullOptions,
216
472
  options: AllRecordScopeOptions.optional()
217
473
  }),
218
- z2.object({
219
- type: z2.literal("record.custom-action"),
474
+ z6.object({
475
+ type: z6.literal("record.custom-action"),
220
476
  options: CustomActionScopeOptions.optional()
221
477
  }),
222
- z2.object({
223
- type: z2.literal("record.print-certified-copies"),
478
+ z6.object({
479
+ type: z6.literal("record.print-certified-copies"),
224
480
  options: ScopeOptionsPrintCertifiedCopies.optional()
225
481
  })
226
482
  ]).describe(
227
483
  "Scopes used to check user's permission to perform actions on a record."
228
484
  );
229
- var SystemScopeType = z2.enum([
485
+ var SystemScopeType = z6.enum([
230
486
  "organisation.read-locations",
231
487
  "user.read",
232
488
  "user.create",
@@ -240,61 +496,61 @@ var UserScopeType = SystemScopeType.extract([
240
496
  "user.search"
241
497
  ]);
242
498
  var ScopesWithRoleOption = UserScopeType.extract(["user.edit", "user.create"]);
243
- var UserScopeV2 = z2.discriminatedUnion("type", [
244
- z2.object({
499
+ var UserScopeV2 = z6.discriminatedUnion("type", [
500
+ z6.object({
245
501
  type: ScopesWithRoleOption,
246
502
  options: AllUserScopeOptions.optional()
247
503
  }),
248
- z2.object({
504
+ z6.object({
249
505
  type: UserScopeType.extract(["user.read", "user.search"]),
250
506
  options: AccessLevelOptions.optional()
251
507
  })
252
508
  ]);
253
- var ResolvedRecordScopeV2 = z2.discriminatedUnion("type", [
254
- z2.object({
509
+ var ResolvedRecordScopeV2 = z6.discriminatedUnion("type", [
510
+ z6.object({
255
511
  type: ScopesWithPlaceEventOptions,
256
512
  options: ResolvedScopeOptionsPlaceEvent.optional()
257
513
  }),
258
- z2.object({
514
+ z6.object({
259
515
  type: ScopesWithDeclaredOptions,
260
516
  options: ResolvedScopeOptionsDeclared.optional()
261
517
  }),
262
- z2.object({
518
+ z6.object({
263
519
  type: ScopesWithFullOptions,
264
520
  options: ResolvedScopeOptionsFull.optional()
265
521
  }),
266
- z2.object({
267
- type: z2.literal("record.print-certified-copies"),
522
+ z6.object({
523
+ type: z6.literal("record.print-certified-copies"),
268
524
  options: ResolvedScopeOptionsFull.extend({
269
- templates: z2.array(z2.string()).optional()
525
+ templates: z6.array(z6.string()).optional()
270
526
  }).optional()
271
527
  })
272
528
  ]).describe("Resolved scope with location/user IDs instead of filters.");
273
- var Scope = z2.discriminatedUnion("type", [
274
- z2.object({ type: PlainScopeType }),
529
+ var Scope = z6.discriminatedUnion("type", [
530
+ z6.object({ type: PlainScopeType }),
275
531
  ...RecordScopeV2.options,
276
532
  ...UserScopeV2.options,
277
- z2.object({
278
- type: z2.literal("organisation.read-locations"),
533
+ z6.object({
534
+ type: z6.literal("organisation.read-locations"),
279
535
  options: AccessLevelOptions.optional()
280
536
  }),
281
- z2.object({
282
- type: z2.literal("workqueue"),
537
+ z6.object({
538
+ type: z6.literal("workqueue"),
283
539
  options: WorkqueueOrDashboardOptions
284
540
  }),
285
- z2.object({
286
- type: z2.literal("dashboard.view"),
541
+ z6.object({
542
+ type: z6.literal("dashboard.view"),
287
543
  options: WorkqueueOrDashboardOptions
288
544
  })
289
545
  ]);
290
- var ScopeType = z2.enum([
546
+ var ScopeType = z6.enum([
291
547
  ...SystemScopeType.options,
292
548
  ...RecordScopeTypeV2.options,
293
549
  ...PlainScopeType.options,
294
550
  "workqueue",
295
551
  "dashboard.view"
296
552
  ]);
297
- var EncodedScope = z2.string().brand("EncodedScope");
553
+ var EncodedScope = z6.string().brand("EncodedScope");
298
554
  var DEFAULT_SCOPE_OPTIONS = {
299
555
  placeOfEvent: JurisdictionFilter.enum.all,
300
556
  accessLevel: JurisdictionFilter.enum.all,
@@ -304,158 +560,51 @@ var DEFAULT_SCOPE_OPTIONS = {
304
560
  };
305
561
 
306
562
  // ../commons/src/authentication.ts
307
- var TokenUserType = z3.enum(["user", "system"]);
308
- var TokenWithBearer = z3.string().regex(/^Bearer\s/);
309
-
310
- // ../commons/src/events/ActionType.ts
311
- var z4 = __toESM(require("zod/v4"));
312
- var ActionType = {
313
- // Pre-declaration actions
314
- DELETE: "DELETE",
315
- CREATE: "CREATE",
316
- NOTIFY: "NOTIFY",
317
- // Declaration actions
318
- DECLARE: "DECLARE",
319
- REGISTER: "REGISTER",
320
- EDIT: "EDIT",
321
- // Declaration system actions. Non-configurable.
322
- DUPLICATE_DETECTED: "DUPLICATE_DETECTED",
323
- REJECT: "REJECT",
324
- // REJECT_DECLARATION
325
- MARK_AS_DUPLICATE: "MARK_AS_DUPLICATE",
326
- MARK_AS_NOT_DUPLICATE: "MARK_AS_NOT_DUPLICATE",
327
- ARCHIVE: "ARCHIVE",
328
- // Record actions
329
- PRINT_CERTIFICATE: "PRINT_CERTIFICATE",
330
- REQUEST_CORRECTION: "REQUEST_CORRECTION",
331
- REJECT_CORRECTION: "REJECT_CORRECTION",
332
- APPROVE_CORRECTION: "APPROVE_CORRECTION",
333
- // General actions
334
- READ: "READ",
335
- ASSIGN: "ASSIGN",
336
- UNASSIGN: "UNASSIGN",
337
- // Custom action
338
- CUSTOM: "CUSTOM"
339
- };
340
- var ConfirmableActions = [
341
- ActionType.NOTIFY,
342
- ActionType.DECLARE,
343
- ActionType.EDIT,
344
- ActionType.REGISTER,
345
- ActionType.REJECT,
346
- ActionType.ARCHIVE,
347
- ActionType.PRINT_CERTIFICATE,
348
- ActionType.REQUEST_CORRECTION,
349
- ActionType.APPROVE_CORRECTION,
350
- ActionType.REJECT_CORRECTION,
351
- ActionType.CUSTOM
352
- ];
353
- var ActionTypes = z4.enum([
354
- "DELETE",
355
- "CREATE",
356
- "NOTIFY",
357
- "DECLARE",
358
- "EDIT",
359
- "REGISTER",
360
- "DUPLICATE_DETECTED",
361
- "REJECT",
362
- "MARK_AS_DUPLICATE",
363
- "MARK_AS_NOT_DUPLICATE",
364
- "ARCHIVE",
365
- "PRINT_CERTIFICATE",
366
- "REQUEST_CORRECTION",
367
- "REJECT_CORRECTION",
368
- "APPROVE_CORRECTION",
369
- "READ",
370
- "ASSIGN",
371
- "UNASSIGN",
372
- "CUSTOM"
373
- ]);
374
- var ClientSpecificAction = {
375
- REVIEW_CORRECTION_REQUEST: "REVIEW_CORRECTION_REQUEST"
376
- };
377
- var declarationActionValues = [
378
- ActionTypes.enum.DECLARE,
379
- ActionTypes.enum.EDIT,
380
- ActionTypes.enum.REGISTER,
381
- ActionTypes.enum.NOTIFY,
382
- ActionTypes.enum.DUPLICATE_DETECTED
383
- ];
384
- var DeclarationActions = ActionTypes.extract(declarationActionValues);
385
- var declarationUpdateActionValues = [
386
- ...declarationActionValues,
387
- ActionTypes.enum.REQUEST_CORRECTION
388
- ];
389
- var DeclarationUpdateActions = ActionTypes.extract(
390
- declarationUpdateActionValues
391
- );
392
- var annotationActions = ActionTypes.exclude(declarationActionValues);
393
- var writeActions = ActionTypes.exclude([
394
- ActionType.CREATE,
395
- ActionType.READ,
396
- ActionType.ASSIGN,
397
- ActionType.UNASSIGN
398
- ]);
399
- var WorkqueueActionType = ActionTypes.extract([
400
- ActionType.READ,
401
- ActionType.DELETE,
402
- ActionType.DECLARE,
403
- ActionType.REGISTER,
404
- ActionType.EDIT,
405
- ActionType.REJECT,
406
- ActionType.MARK_AS_DUPLICATE,
407
- ActionType.ARCHIVE,
408
- ActionType.PRINT_CERTIFICATE,
409
- ActionType.REQUEST_CORRECTION
410
- ]);
411
- var META_ACTIONS = [
412
- ActionType.ASSIGN,
413
- ActionType.UNASSIGN,
414
- ActionType.READ
415
- ];
563
+ var TokenUserType = z7.enum(["user", "system"]);
564
+ var TokenWithBearer = z7.string().regex(/^Bearer\s/);
416
565
 
417
566
  // ../commons/src/events/AuditLog.ts
418
- var AuditLogEntryBase = z5.object({
419
- id: z5.string(),
420
- clientId: z5.string(),
567
+ var AuditLogEntryBase = z8.object({
568
+ id: z8.string(),
569
+ clientId: z8.string(),
421
570
  clientType: TokenUserType,
422
- createdAt: z5.string()
571
+ createdAt: z8.string()
423
572
  });
424
573
  var EventCreateEntrySchema = AuditLogEntryBase.extend({
425
- operation: z5.literal("event.create"),
426
- requestData: z5.object({
427
- transactionId: z5.string(),
428
- type: z5.string(),
429
- createdAtLocation: z5.string().nullable()
574
+ operation: z8.literal("event.create"),
575
+ requestData: z8.object({
576
+ transactionId: z8.string(),
577
+ type: z8.string(),
578
+ createdAtLocation: z8.string().nullable()
430
579
  }),
431
- responseSummary: z5.object({
432
- eventId: z5.string(),
433
- trackingId: z5.string()
580
+ responseSummary: z8.object({
581
+ eventId: z8.string(),
582
+ trackingId: z8.string()
434
583
  })
435
584
  });
436
585
  var EventGetEntrySchema = AuditLogEntryBase.extend({
437
- operation: z5.literal("event.get"),
438
- requestData: z5.object({ eventId: z5.string() }),
439
- responseSummary: z5.object({
440
- eventType: z5.string(),
441
- trackingId: z5.string()
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()
442
591
  })
443
592
  });
444
593
  var EventSearchEntrySchema = AuditLogEntryBase.extend({
445
- operation: z5.literal("event.search"),
446
- clientType: z5.literal("system"),
447
- requestData: z5.object({
448
- query: z5.record(z5.string(), z5.unknown()).nullable(),
449
- limit: z5.number().nullable(),
450
- offset: z5.number().nullable()
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()
451
600
  }),
452
- responseSummary: z5.object({
453
- total: z5.number(),
454
- eventIds: z5.array(z5.string())
601
+ responseSummary: z8.object({
602
+ total: z8.number(),
603
+ eventIds: z8.array(z8.string())
455
604
  })
456
605
  });
457
606
  var EventActionEntrySchema = AuditLogEntryBase.extend({
458
- operation: z5.enum([
607
+ operation: z8.enum([
459
608
  "event.actions.notify.request",
460
609
  "event.actions.declare.request",
461
610
  "event.actions.register.request",
@@ -466,6 +615,7 @@ var EventActionEntrySchema = AuditLogEntryBase.extend({
466
615
  "event.actions.unassign.request",
467
616
  "event.actions.read.request",
468
617
  "event.actions.archive.request",
618
+ "event.actions.unarchive.request",
469
619
  "event.actions.reinstate.request",
470
620
  "event.actions.print_certificate.request",
471
621
  "event.actions.correction.request.request",
@@ -474,83 +624,83 @@ var EventActionEntrySchema = AuditLogEntryBase.extend({
474
624
  "event.actions.mark_as_duplicate.request",
475
625
  "event.actions.mark_as_not_duplicate.request"
476
626
  ]),
477
- requestData: z5.object({
478
- eventId: z5.string(),
479
- actionType: z5.string(),
480
- eventType: z5.string(),
481
- trackingId: z5.string(),
482
- transactionId: z5.string()
627
+ requestData: z8.object({
628
+ eventId: z8.string(),
629
+ actionType: z8.string(),
630
+ eventType: z8.string(),
631
+ trackingId: z8.string(),
632
+ transactionId: z8.string()
483
633
  })
484
634
  });
485
635
  var EventCustomActionEntrySchema = AuditLogEntryBase.extend({
486
- operation: z5.literal("event.actions.custom.request"),
487
- requestData: z5.object({
488
- eventId: z5.string(),
489
- actionType: z5.literal(ActionType.CUSTOM),
490
- customAction: z5.string(),
491
- eventType: z5.string(),
492
- trackingId: z5.string(),
493
- transactionId: z5.string()
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()
494
644
  })
495
645
  });
496
646
  var IntegrationCreateEntrySchema = AuditLogEntryBase.extend({
497
- operation: z5.literal("integrations.create"),
498
- requestData: z5.object({ name: z5.string(), scopes: z5.array(z5.string()) }),
499
- responseSummary: z5.object({ clientId: z5.string() })
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() })
500
650
  });
501
651
  var IntegrationRefreshTokenEntrySchema = AuditLogEntryBase.extend({
502
- operation: z5.literal("integrations.refreshToken"),
503
- requestData: z5.object({ clientId: z5.string() }),
504
- responseSummary: z5.object({ clientId: z5.string() })
652
+ operation: z8.literal("integrations.refreshToken"),
653
+ requestData: z8.object({ clientId: z8.string() }),
654
+ responseSummary: z8.object({ clientId: z8.string() })
505
655
  });
506
656
  var IntegrationDeactivateEntrySchema = AuditLogEntryBase.extend({
507
- operation: z5.literal("integrations.deactivate"),
508
- requestData: z5.object({ id: z5.string() }),
509
- responseSummary: z5.object({ id: z5.string(), status: z5.string() })
657
+ operation: z8.literal("integrations.deactivate"),
658
+ requestData: z8.object({ id: z8.string() }),
659
+ responseSummary: z8.object({ id: z8.string(), status: z8.string() })
510
660
  });
511
661
  var IntegrationActivateEntrySchema = AuditLogEntryBase.extend({
512
- operation: z5.literal("integrations.activate"),
513
- requestData: z5.object({ id: z5.string() }),
514
- responseSummary: z5.object({ id: z5.string(), status: z5.string() })
662
+ operation: z8.literal("integrations.activate"),
663
+ requestData: z8.object({ id: z8.string() }),
664
+ responseSummary: z8.object({ id: z8.string(), status: z8.string() })
515
665
  });
516
666
  var IntegrationDeleteEntrySchema = AuditLogEntryBase.extend({
517
- operation: z5.literal("integrations.delete"),
518
- requestData: z5.object({ id: z5.string() }),
519
- responseSummary: z5.object({ id: z5.string(), name: z5.string() })
667
+ operation: z8.literal("integrations.delete"),
668
+ requestData: z8.object({ id: z8.string() }),
669
+ responseSummary: z8.object({ id: z8.string(), name: z8.string() })
520
670
  });
521
671
  var IntegrationRefreshSecretEntrySchema = AuditLogEntryBase.extend({
522
- operation: z5.literal("integrations.refreshSecret"),
523
- requestData: z5.object({ id: z5.string() }),
524
- responseSummary: z5.object({ clientId: z5.string() })
672
+ operation: z8.literal("integrations.refreshSecret"),
673
+ requestData: z8.object({ id: z8.string() }),
674
+ responseSummary: z8.object({ clientId: z8.string() })
525
675
  });
526
676
  var AttachmentUploadEntrySchema = AuditLogEntryBase.extend({
527
- operation: z5.literal("attachments.upload"),
528
- requestData: z5.object({
529
- transactionId: z5.string(),
530
- path: z5.string().nullable()
677
+ operation: z8.literal("attachments.upload"),
678
+ requestData: z8.object({
679
+ transactionId: z8.string(),
680
+ path: z8.string().nullable()
531
681
  }),
532
- responseSummary: z5.object({ fileUrl: z5.string() })
682
+ responseSummary: z8.object({ fileUrl: z8.string() })
533
683
  });
534
- var subjectOnly = z5.object({ subjectId: z5.string() });
535
- var subjectWithReason = z5.object({
536
- subjectId: z5.string(),
537
- reason: z5.string(),
538
- comment: z5.string().optional()
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()
539
689
  });
540
690
  var UserCreateEntrySchema = AuditLogEntryBase.extend({
541
- operation: z5.literal("user.create_user"),
542
- requestData: z5.object({
543
- subjectId: z5.string(),
544
- role: z5.string(),
545
- primaryOfficeId: z5.string()
691
+ operation: z8.literal("user.create_user"),
692
+ requestData: z8.object({
693
+ subjectId: z8.string(),
694
+ role: z8.string(),
695
+ primaryOfficeId: z8.string()
546
696
  })
547
697
  });
548
698
  var UserReasonEntrySchema = AuditLogEntryBase.extend({
549
- operation: z5.enum(["user.deactivate", "user.reactivate"]),
699
+ operation: z8.enum(["user.deactivate", "user.reactivate"]),
550
700
  requestData: subjectWithReason
551
701
  });
552
702
  var UserSubjectOnlyEntrySchema = AuditLogEntryBase.extend({
553
- operation: z5.enum([
703
+ operation: z8.enum([
554
704
  "user.edit_user",
555
705
  "user.logged_in",
556
706
  "user.logged_out",
@@ -564,14 +714,14 @@ var UserSubjectOnlyEntrySchema = AuditLogEntryBase.extend({
564
714
  requestData: subjectOnly
565
715
  });
566
716
  var UserEmailChangedEntrySchema = AuditLogEntryBase.extend({
567
- operation: z5.literal("user.email_address_changed"),
717
+ operation: z8.literal("user.email_address_changed"),
568
718
  requestData: subjectOnly,
569
- responseSummary: z5.object({ email: z5.string() })
719
+ responseSummary: z8.object({ email: z8.string() })
570
720
  });
571
721
  var UserPhoneChangedEntrySchema = AuditLogEntryBase.extend({
572
- operation: z5.literal("user.phone_number_changed"),
722
+ operation: z8.literal("user.phone_number_changed"),
573
723
  requestData: subjectOnly,
574
- responseSummary: z5.object({ phoneNumber: z5.string() })
724
+ responseSummary: z8.object({ phoneNumber: z8.string() })
575
725
  });
576
726
  var userBaseOmit = {
577
727
  id: true,
@@ -579,14 +729,14 @@ var userBaseOmit = {
579
729
  clientType: true,
580
730
  createdAt: true
581
731
  };
582
- var UserAuditRecordInput = z5.discriminatedUnion("operation", [
732
+ var UserAuditRecordInput = z8.discriminatedUnion("operation", [
583
733
  UserCreateEntrySchema.omit(userBaseOmit),
584
734
  UserReasonEntrySchema.omit(userBaseOmit),
585
735
  UserSubjectOnlyEntrySchema.omit(userBaseOmit),
586
736
  UserEmailChangedEntrySchema.omit(userBaseOmit),
587
737
  UserPhoneChangedEntrySchema.omit(userBaseOmit)
588
738
  ]);
589
- var AuditLogEntrySchema = z5.discriminatedUnion("operation", [
739
+ var AuditLogEntrySchema = z8.discriminatedUnion("operation", [
590
740
  EventCreateEntrySchema,
591
741
  EventGetEntrySchema,
592
742
  EventSearchEntrySchema,
@@ -613,76 +763,11 @@ var CHILD_ONBOARDING_EVENT = "child-onboarding";
613
763
  // ../commons/src/events/ActionConfig.ts
614
764
  var z24 = __toESM(require("zod/v4"));
615
765
 
616
- // ../commons/src/events/TranslationConfig.ts
617
- var z6 = __toESM(require("zod/v4"));
618
- var TranslationConfig = z6.object({
619
- id: z6.string().describe(
620
- "The identifier of the translation referred in translation CSV files"
621
- ),
622
- defaultMessage: z6.string().describe("Default translation message"),
623
- description: z6.string().describe(
624
- "Describe the translation for a translator to be able to identify it."
625
- )
626
- }).meta({
627
- description: "Translation configuration",
628
- id: "TranslationConfig"
629
- });
630
-
631
766
  // ../commons/src/events/FieldConfig.ts
632
767
  var import_v43 = __toESM(require("zod/v4"));
633
768
 
634
- // ../commons/src/events/Conditional.ts
635
- var z7 = __toESM(require("zod/v4"));
636
- var Conditional = z7.any().describe("JSONSchema").meta({
637
- description: "JSON schema conditional configuration",
638
- id: "Conditional"
639
- });
640
- var ConditionalType = {
641
- SHOW: "SHOW",
642
- ENABLE: "ENABLE",
643
- DISPLAY_ON_REVIEW: "DISPLAY_ON_REVIEW"
644
- };
645
- var ShowConditional = z7.object({
646
- type: z7.literal(ConditionalType.SHOW),
647
- conditional: Conditional
648
- }).describe(
649
- "If 'SHOW' conditional is defined, the component is shown to the user only if the condition is met"
650
- );
651
- var EnableConditional = z7.object({
652
- type: z7.literal(ConditionalType.ENABLE),
653
- conditional: Conditional
654
- }).describe(
655
- "If 'ENABLE' conditional is defined, the component is enabled only if the condition is met"
656
- );
657
- var ActionConditional = z7.discriminatedUnion("type", [
658
- // Action can be shown / hidden
659
- ShowConditional,
660
- // Action can be shown to the user in the list but as disabled
661
- EnableConditional
662
- ]).meta({
663
- id: "ActionConditional",
664
- 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."
665
- });
666
- var DisplayOnReviewConditional = z7.object({
667
- type: z7.literal(ConditionalType.DISPLAY_ON_REVIEW),
668
- conditional: Conditional
669
- }).describe(
670
- "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."
671
- );
672
- var FieldConditional = z7.discriminatedUnion("type", [
673
- // Field input can be shown / hidden
674
- ShowConditional,
675
- // Field input can be shown to the user but as disabled
676
- EnableConditional,
677
- // Field output can be shown / hidden on the review page
678
- DisplayOnReviewConditional
679
- ]).meta({
680
- id: "FieldConditional",
681
- 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."
682
- });
683
-
684
769
  // ../commons/src/events/FieldType.ts
685
- var z8 = __toESM(require("zod/v4"));
770
+ var z9 = __toESM(require("zod/v4"));
686
771
  var FieldType = {
687
772
  NAME: "NAME",
688
773
  PHONE: "PHONE",
@@ -746,7 +831,7 @@ var FieldType = {
746
831
  */
747
832
  _EXPERIMENTAL_CUSTOM: "CUSTOM"
748
833
  };
749
- var FileFieldType = z8.enum([
834
+ var FileFieldType = z9.enum([
750
835
  FieldType.FILE,
751
836
  FieldType.FILE_WITH_OPTIONS,
752
837
  FieldType.SIGNATURE
@@ -782,160 +867,164 @@ var HiddenFieldTypes = [
782
867
  ];
783
868
 
784
869
  // ../commons/src/events/FieldValue.ts
785
- var z12 = __toESM(require("zod/v4"));
870
+ var z13 = __toESM(require("zod/v4"));
786
871
 
787
872
  // ../commons/src/documents.ts
788
- var z9 = __toESM(require("zod/v4"));
789
- var FullDocumentUrl = z9.string().brand("FullDocumentUrl").describe(
873
+ var z10 = __toESM(require("zod/v4"));
874
+ var FullDocumentUrl = z10.string().brand("FullDocumentUrl").describe(
790
875
  "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"
791
876
  );
792
- var FullDocumentPath = z9.string().overwrite((val) => val.startsWith("/") ? val : `/${val}`).meta({ effectType: "input", type: "string" }).describe(
877
+ var FullDocumentPath = z10.string().overwrite((val) => val.startsWith("/") ? val : `/${val}`).meta({ effectType: "input", type: "string" }).describe(
793
878
  "A full absolute path with bucket name, starting from the root of the S3 server, /bucket-name/document-id.jpg"
794
879
  );
795
- var DocumentPath = z9.string().brand("DocumentPath").describe(
880
+ var DocumentPath = z10.string().brand("DocumentPath").describe(
796
881
  "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."
797
882
  );
798
883
 
799
884
  // ../commons/src/events/CompositeFieldValue.ts
800
- var z10 = __toESM(require("zod/v4"));
885
+ var z11 = __toESM(require("zod/v4"));
801
886
  var AddressType = {
802
887
  DOMESTIC: "DOMESTIC",
803
888
  INTERNATIONAL: "INTERNATIONAL"
804
889
  };
805
- var FileFieldValue = z10.object({
890
+ var FileFieldValue = z11.object({
806
891
  path: DocumentPath,
807
- originalFilename: z10.string(),
808
- type: z10.string()
809
- });
810
- var NameFieldValue = z10.object({
811
- firstname: z10.string(),
812
- surname: z10.string(),
813
- middlename: z10.string().optional()
814
- });
815
- var NameFieldUpdateValue = z10.object({
816
- firstname: z10.string().nullish(),
817
- surname: z10.string().nullish(),
818
- middlename: z10.string().nullish()
819
- }).or(z10.null()).or(z10.undefined());
820
- var StreetLevelDetailsValue = z10.record(z10.string(), z10.string()).optional();
821
- var StreetLevelDetailsUpdateValue = z10.record(z10.string(), z10.string().nullable()).nullish();
822
- var BaseAddressFieldValue = z10.object({
823
- country: z10.string(),
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(),
824
909
  streetLevelDetails: StreetLevelDetailsValue
825
910
  });
826
- var BaseAddressFieldUpdateValue = z10.object({
827
- country: z10.string().nullish(),
911
+ var BaseAddressFieldUpdateValue = z11.object({
912
+ country: z11.string().nullish(),
828
913
  streetLevelDetails: StreetLevelDetailsUpdateValue
829
914
  });
830
915
  var DomesticAddressFieldValue = BaseAddressFieldValue.extend({
831
- addressType: z10.literal(AddressType.DOMESTIC),
832
- administrativeArea: z10.string().uuid()
916
+ addressType: z11.literal(AddressType.DOMESTIC),
917
+ administrativeArea: z11.string().uuid()
833
918
  });
834
919
  var InternationalAddressFieldValue = BaseAddressFieldValue.extend({
835
- addressType: z10.literal(AddressType.INTERNATIONAL)
920
+ addressType: z11.literal(AddressType.INTERNATIONAL)
836
921
  });
837
- var AddressFieldValue = z10.discriminatedUnion("addressType", [
922
+ var AddressFieldValue = z11.discriminatedUnion("addressType", [
838
923
  DomesticAddressFieldValue,
839
924
  InternationalAddressFieldValue
840
925
  ]);
841
926
  var DomesticAddressUpdateFieldValue = BaseAddressFieldUpdateValue.extend({
842
- addressType: z10.literal(AddressType.DOMESTIC),
843
- administrativeArea: z10.string().uuid().nullish()
927
+ addressType: z11.literal(AddressType.DOMESTIC),
928
+ administrativeArea: z11.string().uuid().nullish()
844
929
  /* Leaf level admin structure */
845
930
  });
846
931
  var InternationalAddressUpdateFieldValue = BaseAddressFieldUpdateValue.extend(
847
932
  {
848
- addressType: z10.literal(AddressType.INTERNATIONAL)
933
+ addressType: z11.literal(AddressType.INTERNATIONAL)
849
934
  }
850
935
  );
851
- var AddressFieldUpdateValue = z10.discriminatedUnion("addressType", [
936
+ var AddressFieldUpdateValue = z11.discriminatedUnion("addressType", [
852
937
  DomesticAddressUpdateFieldValue,
853
938
  InternationalAddressUpdateFieldValue
854
939
  ]).nullish();
855
- var FileFieldValueWithOption = z10.object({
940
+ var FileFieldValueWithOption = z11.object({
856
941
  path: DocumentPath,
857
- originalFilename: z10.string(),
858
- type: z10.string(),
859
- option: z10.string()
860
- });
861
- var FileFieldWithOptionValue = z10.array(FileFieldValueWithOption);
862
- var HttpFieldValue = z10.object({
863
- loading: z10.boolean(),
864
- error: z10.object({ statusCode: z10.number(), message: z10.string() }).nullish(),
865
- data: z10.any()
866
- });
867
- var HttpFieldUpdateValue = z10.object({
868
- loading: z10.boolean().nullish(),
869
- error: z10.object({ statusCode: z10.number(), message: z10.string() }).nullish(),
870
- data: z10.any().nullish()
871
- }).or(z10.null()).or(z10.undefined());
872
- var QueryParamReaderFieldValue = z10.object({
873
- data: z10.record(z10.string(), z10.string()),
874
- updatedAt: z10.iso.datetime()
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()
875
960
  }).nullish();
876
- var QueryParamReaderFieldUpdateValue = z10.object({
877
- data: z10.record(z10.string(), z10.string())
961
+ var QueryParamReaderFieldUpdateValue = z11.object({
962
+ data: z11.record(z11.string(), z11.string())
878
963
  });
879
- var ReadDataValue = z10.object({
880
- data: z10.any()
964
+ var ReadDataValue = z11.object({
965
+ data: z11.any()
881
966
  });
882
967
  var QrReaderFieldValue = ReadDataValue;
883
968
  var IdReaderFieldValue = ReadDataValue;
884
- var NumberWithUnitFieldValue = z10.object({
885
- numericValue: z10.number(),
886
- unit: z10.string()
969
+ var NumberWithUnitFieldValue = z11.object({
970
+ numericValue: z11.number(),
971
+ unit: z11.string()
887
972
  });
888
- var NumberWithUnitFieldUpdateValue = z10.object({
889
- numericValue: z10.number().optional(),
890
- unit: z10.string().optional()
973
+ var NumberWithUnitFieldUpdateValue = z11.object({
974
+ numericValue: z11.number().optional(),
975
+ unit: z11.string().optional()
891
976
  });
892
- var CustomFieldValue = z10.unknown().brand("CustomFieldValue");
977
+ var CustomFieldValue = z11.unknown().brand("CustomFieldValue");
893
978
 
894
979
  // ../commons/src/events/PlainDate.ts
895
980
  var import_zod = require("zod");
896
981
  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
+ }
897
986
 
898
987
  // ../commons/src/events/FieldValue.ts
899
- var TextValue = z12.string();
900
- var HiddenFieldValue = z12.string();
901
- var NonEmptyTextValue = z12.string().trim().min(1);
902
- var DateValue = z12.iso.date().describe("Date in the format YYYY-MM-DD");
903
- var AgeValue = z12.object({
904
- age: z12.number(),
905
- asOfDateRef: z12.string()
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
995
  });
907
996
  var AgeUpdateValue = AgeValue.optional().nullable();
908
- var AutocompleteValue = z12.object({
909
- label: z12.string(),
910
- value: z12.string()
997
+ var AutocompleteValue = z13.object({
998
+ label: z13.string(),
999
+ value: z13.string()
911
1000
  });
912
1001
  var AutocompleteUpdateValue = AutocompleteValue.optional().nullable();
913
- var TimeValue = z12.string().regex(/^([01][0-9]|2[0-3]):[0-5][0-9]$/);
914
- var DatetimeValue = z12.iso.datetime();
915
- var SelectDateRangeValue = z12.enum([
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([
916
1005
  "last7Days",
917
1006
  "last30Days",
918
1007
  "last90Days",
919
1008
  "last365Days"
920
1009
  ]);
921
- var DateRangeFieldValue = z12.object({
1010
+ var DateRangeFieldValue = z13.object({
922
1011
  start: PlainDate,
923
1012
  end: PlainDate
924
1013
  }).or(PlainDate).describe(
925
1014
  "Date range with start and end dates in the format YYYY-MM-DD. Inclusive start, exclusive end."
926
1015
  );
927
- var EmailValue = z12.email();
928
- var CheckboxFieldValue = z12.boolean();
929
- var NumberFieldValue = z12.number();
1016
+ var EmailValue = z13.email();
1017
+ var CheckboxFieldValue = z13.boolean();
1018
+ var NumberFieldValue = z13.number();
930
1019
  var SignatureFieldValue = FileFieldValue;
931
- var ButtonFieldValue = z12.number();
932
- var VerificationStatusValue = z12.enum([
1020
+ var ButtonFieldValue = z13.number();
1021
+ var VerificationStatusValue = z13.enum([
933
1022
  "verified",
934
1023
  "authenticated",
935
1024
  "failed",
936
1025
  "pending"
937
1026
  ]);
938
- var LeafFieldValues = z12.union([
1027
+ var LeafFieldValues = z13.union([
939
1028
  AddressFieldValue,
940
1029
  TextValue,
941
1030
  PlainDate,
@@ -961,11 +1050,11 @@ var LeafFieldValues = z12.union([
961
1050
  AutocompleteValue,
962
1051
  AutocompleteUpdateValue
963
1052
  ]);
964
- var FieldGroupValue = z12.record(z12.string(), LeafFieldValues);
965
- var DataFieldValue = z12.object({
966
- data: z12.record(z12.string(), LeafFieldValues)
1053
+ var FieldGroupValue = z13.record(z13.string(), LeafFieldValues);
1054
+ var DataFieldValue = z13.object({
1055
+ data: z13.record(z13.string(), LeafFieldValues)
967
1056
  }).nullish();
968
- var FieldValue = z12.union([
1057
+ var FieldValue = z13.union([
969
1058
  LeafFieldValues,
970
1059
  DataFieldValue,
971
1060
  FieldGroupValue
@@ -999,7 +1088,7 @@ function safeUnion(schemas) {
999
1088
  const sortedSchemas = [...schemas].sort(
1000
1089
  (a, b) => schemaPriority(a) - schemaPriority(b)
1001
1090
  );
1002
- return z12.any().superRefine((val, ctx) => {
1091
+ return z13.any().superRefine((val, ctx) => {
1003
1092
  for (const schema of sortedSchemas) {
1004
1093
  if (schema.safeParse(val).success) {
1005
1094
  return;
@@ -1038,9 +1127,9 @@ var FieldUpdateValue = safeUnion([
1038
1127
  ]);
1039
1128
 
1040
1129
  // ../commons/src/events/serializers/user/serializer.ts
1041
- var z13 = __toESM(require("zod/v4"));
1042
- var SerializedUserField = z13.object({
1043
- $userField: z13.enum([
1130
+ var z14 = __toESM(require("zod/v4"));
1131
+ var SerializedUserField = z14.object({
1132
+ $userField: z14.enum([
1044
1133
  "id",
1045
1134
  "name",
1046
1135
  "role",
@@ -1054,7 +1143,7 @@ var SerializedUserField = z13.object({
1054
1143
  "primaryOfficeId",
1055
1144
  "administrativeAreaId"
1056
1145
  ]),
1057
- $location: z13.string().optional()
1146
+ $location: z14.string().optional()
1058
1147
  });
1059
1148
  function userSerializer(userField) {
1060
1149
  return {
@@ -1080,27 +1169,22 @@ var import_v4 = require("zod/v4");
1080
1169
  var z16 = __toESM(require("zod/v4"));
1081
1170
 
1082
1171
  // ../commons/src/events/ActionDocument.ts
1083
- var z14 = __toESM(require("zod/v4"));
1084
- var ActionUpdate = z14.record(z14.string(), FieldUpdateValue).describe(
1172
+ var z15 = __toESM(require("zod/v4"));
1173
+ var ActionUpdate = z15.record(z15.string(), FieldUpdateValue).describe(
1085
1174
  "Record of field-level changes made by an action. Supports partial updates and nullable values."
1086
1175
  );
1087
- var EventState = z14.record(z14.string(), FieldValue).describe(
1176
+ var EventState = z15.record(z15.string(), FieldValue).describe(
1088
1177
  "Aggregate representation of event data after all actions have been applied, with all updates consolidated and null values removed."
1089
1178
  );
1090
- var ActionStatus = {
1091
- Requested: "Requested",
1092
- Accepted: "Accepted",
1093
- Rejected: "Rejected"
1094
- };
1095
- var ActionBase = z14.object({
1179
+ var ActionBase = z15.object({
1096
1180
  id: UUID.describe("Unique identifier of the action."),
1097
- transactionId: z14.string().describe("Unique identifier of the transaction."),
1181
+ transactionId: z15.string().describe("Unique identifier of the transaction."),
1098
1182
  createdByUserType: TokenUserType.describe(
1099
1183
  "Indicates whether the action was created by a human-user or by a system-user."
1100
1184
  ),
1101
- createdAt: z14.string().datetime().describe("Timestamp indicating when the action was created."),
1102
- createdBy: z14.string().describe("Identifier of the user who created the action."),
1103
- createdByRole: z14.string().optional().describe("Role of the user who created the action."),
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."),
1104
1188
  createdBySignature: DocumentPath.nullish().describe(
1105
1189
  "Reference to the signature of the user who created the action."
1106
1190
  ),
@@ -1112,7 +1196,7 @@ var ActionBase = z14.object({
1112
1196
  "Declaration data defined by the ActionConfig. Supports partial updates."
1113
1197
  ),
1114
1198
  annotation: ActionUpdate.optional().nullable().describe("Action-specific metadata used to annotate the event."),
1115
- status: z14.enum([
1199
+ status: z15.enum([
1116
1200
  ActionStatus.Requested,
1117
1201
  ActionStatus.Accepted,
1118
1202
  ActionStatus.Rejected
@@ -1124,216 +1208,170 @@ var ActionBase = z14.object({
1124
1208
  )
1125
1209
  });
1126
1210
  var AssignedAction = ActionBase.extend(
1127
- z14.object({
1128
- type: z14.literal(ActionType.ASSIGN),
1129
- assignedTo: z14.string().describe("Identifier of the user to whom the action is assigned.")
1211
+ z15.object({
1212
+ type: z15.literal(ActionType.ASSIGN),
1213
+ assignedTo: z15.string().describe("Identifier of the user to whom the action is assigned.")
1130
1214
  // TODO move into 'content' property
1131
1215
  }).shape
1132
1216
  );
1133
1217
  var UnassignedAction = ActionBase.extend(
1134
- z14.object({
1135
- type: z14.literal(ActionType.UNASSIGN)
1218
+ z15.object({
1219
+ type: z15.literal(ActionType.UNASSIGN)
1136
1220
  }).shape
1137
1221
  );
1138
1222
  var RegisterAction = ActionBase.extend(
1139
- z14.object({
1140
- type: z14.literal(ActionType.REGISTER),
1141
- registrationNumber: z14.string().optional().describe(
1223
+ z15.object({
1224
+ type: z15.literal(ActionType.REGISTER),
1225
+ registrationNumber: z15.string().optional().describe(
1142
1226
  "Registration number of the event. Always present for accepted registrations."
1143
1227
  )
1144
1228
  // TODO move into 'content' property
1145
1229
  }).shape
1146
1230
  );
1147
1231
  var DeclareAction = ActionBase.extend(
1148
- z14.object({
1149
- type: z14.literal(ActionType.DECLARE)
1232
+ z15.object({
1233
+ type: z15.literal(ActionType.DECLARE)
1150
1234
  }).shape
1151
1235
  );
1152
- var ReasonContent = z14.object({
1153
- reason: z14.string().min(1, { error: "Message cannot be empty" }).describe(
1236
+ var ReasonContent = z15.object({
1237
+ reason: z15.string().min(1, { error: "Message cannot be empty" }).describe(
1154
1238
  "Message describing the reason for rejecting or archiving the event."
1155
1239
  )
1156
1240
  });
1157
1241
  var RejectAction = ActionBase.extend(
1158
- z14.object({
1159
- type: z14.literal(ActionType.REJECT),
1242
+ z15.object({
1243
+ type: z15.literal(ActionType.REJECT),
1160
1244
  content: ReasonContent
1161
1245
  }).shape
1162
1246
  );
1163
- var PotentialDuplicate = z14.object({
1247
+ var PotentialDuplicate = z15.object({
1164
1248
  id: UUID,
1165
- trackingId: z14.string()
1249
+ trackingId: z15.string()
1166
1250
  });
1167
1251
  var DuplicateDetectedAction = ActionBase.extend(
1168
- z14.object({
1169
- type: z14.literal(ActionType.DUPLICATE_DETECTED),
1170
- content: z14.object({
1171
- duplicates: z14.array(PotentialDuplicate)
1252
+ z15.object({
1253
+ type: z15.literal(ActionType.DUPLICATE_DETECTED),
1254
+ content: z15.object({
1255
+ duplicates: z15.array(PotentialDuplicate)
1172
1256
  })
1173
1257
  }).shape
1174
1258
  );
1175
1259
  var MarkNotDuplicateAction = ActionBase.extend(
1176
- z14.object({
1177
- type: z14.literal(ActionType.MARK_AS_NOT_DUPLICATE)
1260
+ z15.object({
1261
+ type: z15.literal(ActionType.MARK_AS_NOT_DUPLICATE)
1178
1262
  }).shape
1179
1263
  );
1180
1264
  var MarkAsDuplicateAction = ActionBase.extend(
1181
- z14.object({
1182
- type: z14.literal(ActionType.MARK_AS_DUPLICATE),
1183
- content: z14.object({
1265
+ z15.object({
1266
+ type: z15.literal(ActionType.MARK_AS_DUPLICATE),
1267
+ content: z15.object({
1184
1268
  duplicateOf: UUID
1185
1269
  }).optional()
1186
1270
  }).shape
1187
1271
  );
1188
1272
  var ArchiveAction = ActionBase.extend(
1189
- z14.object({
1190
- type: z14.literal(ActionType.ARCHIVE),
1273
+ z15.object({
1274
+ type: z15.literal(ActionType.ARCHIVE),
1191
1275
  content: ReasonContent
1192
1276
  }).shape
1193
1277
  );
1278
+ var UnarchiveAction = ActionBase.extend(
1279
+ z15.object({
1280
+ type: z15.literal(ActionType.UNARCHIVE)
1281
+ }).shape
1282
+ );
1194
1283
  var CreatedAction = ActionBase.extend(
1195
- z14.object({
1196
- type: z14.literal(ActionType.CREATE)
1284
+ z15.object({
1285
+ type: z15.literal(ActionType.CREATE)
1197
1286
  }).shape
1198
1287
  );
1199
1288
  var NotifiedAction = ActionBase.extend(
1200
- z14.object({
1201
- type: z14.literal(ActionType.NOTIFY)
1289
+ z15.object({
1290
+ type: z15.literal(ActionType.NOTIFY)
1202
1291
  }).shape
1203
1292
  );
1204
1293
  var EditAction = ActionBase.extend(
1205
- z14.object({
1206
- type: z14.literal(ActionType.EDIT),
1207
- content: z14.object({
1208
- comment: z14.string().describe("Comment for the edit action.").optional()
1294
+ z15.object({
1295
+ type: z15.literal(ActionType.EDIT),
1296
+ content: z15.object({
1297
+ comment: z15.string().describe("Comment for the edit action.").optional()
1209
1298
  })
1210
1299
  }).shape
1211
1300
  );
1212
- var PrintContent = z14.object({
1213
- templateId: z14.string().optional()
1301
+ var PrintContent = z15.object({
1302
+ templateId: z15.string().optional()
1214
1303
  });
1215
1304
  var PrintCertificateAction = ActionBase.extend(
1216
- z14.object({
1217
- type: z14.literal(ActionType.PRINT_CERTIFICATE),
1305
+ z15.object({
1306
+ type: z15.literal(ActionType.PRINT_CERTIFICATE),
1218
1307
  content: PrintContent.optional().nullable()
1219
1308
  }).shape
1220
1309
  );
1221
1310
  var RequestedCorrectionAction = ActionBase.extend(
1222
- z14.object({
1223
- type: z14.literal(ActionType.REQUEST_CORRECTION)
1311
+ z15.object({
1312
+ type: z15.literal(ActionType.REQUEST_CORRECTION)
1224
1313
  }).shape
1225
1314
  );
1226
1315
  var ApprovedCorrectionAction = ActionBase.extend(
1227
- z14.object({
1228
- type: z14.literal(ActionType.APPROVE_CORRECTION),
1229
- requestId: z14.string(),
1316
+ z15.object({
1317
+ type: z15.literal(ActionType.APPROVE_CORRECTION),
1318
+ requestId: z15.string(),
1230
1319
  // TODO move into 'content' property
1231
- content: z14.object({ immediateCorrection: z14.boolean().optional() }).optional()
1320
+ content: z15.object({ immediateCorrection: z15.boolean().optional() }).optional()
1232
1321
  }).shape
1233
1322
  );
1234
1323
  var RejectedCorrectionAction = ActionBase.extend(
1235
- z14.object({
1236
- type: z14.literal(ActionType.REJECT_CORRECTION),
1237
- requestId: z14.string(),
1324
+ z15.object({
1325
+ type: z15.literal(ActionType.REJECT_CORRECTION),
1326
+ requestId: z15.string(),
1238
1327
  // TODO move into 'content' property
1239
1328
  content: ReasonContent
1240
1329
  }).shape
1241
1330
  );
1242
1331
  var ReadAction = ActionBase.extend(
1243
- z14.object({
1244
- type: z14.literal(ActionType.READ)
1332
+ z15.object({
1333
+ type: z15.literal(ActionType.READ)
1245
1334
  }).shape
1246
1335
  );
1247
1336
  var CustomAction = ActionBase.merge(
1248
- z14.object({
1249
- type: z14.literal(ActionType.CUSTOM),
1250
- customActionType: z14.string()
1337
+ z15.object({
1338
+ type: z15.literal(ActionType.CUSTOM),
1339
+ customActionType: z15.string()
1251
1340
  })
1252
1341
  );
1253
- var ActionDocument = z14.discriminatedUnion("type", [
1342
+ var ActionDocument = z15.discriminatedUnion("type", [
1254
1343
  CreatedAction.meta({ id: "CreatedAction" }),
1255
1344
  RejectAction.meta({ id: "RejectAction" }),
1256
1345
  DuplicateDetectedAction.meta({ id: "DuplicateDetectedAction" }),
1257
1346
  MarkNotDuplicateAction.meta({ id: "MarkNotDuplicateAction" }),
1258
1347
  MarkAsDuplicateAction.meta({ id: "MarkAsDuplicateAction" }),
1259
1348
  ArchiveAction.meta({ id: "ArchiveAction" }),
1349
+ UnarchiveAction.meta({ id: "UnarchiveAction" }),
1260
1350
  NotifiedAction.meta({ id: "NotifiedAction" }),
1261
- RegisterAction.meta({ id: "RegisterAction" }),
1262
- DeclareAction.meta({ id: "DeclareAction" }),
1263
- AssignedAction.meta({ id: "AssignedAction" }),
1264
- RequestedCorrectionAction.meta({ id: "RequestedCorrectionAction" }),
1265
- ApprovedCorrectionAction.meta({ id: "ApprovedCorrectionAction" }),
1266
- RejectedCorrectionAction.meta({ id: "RejectedCorrectionAction" }),
1267
- UnassignedAction.meta({ id: "UnassignedAction" }),
1268
- PrintCertificateAction.meta({ id: "PrintCertificateAction" }),
1269
- ReadAction.meta({ id: "ReadAction" }),
1270
- EditAction.meta({ id: "EditAction" }),
1271
- CustomAction.meta({ id: "CustomAction" })
1272
- ]).meta({
1273
- id: "ActionDocument"
1274
- });
1275
- var AsyncRejectActionDocument = ActionBase.omit({
1276
- declaration: true,
1277
- annotation: true
1278
- }).extend(
1279
- z14.object({
1280
- type: z14.enum(ConfirmableActions),
1281
- status: z14.literal(ActionStatus.Rejected)
1282
- }).shape
1283
- );
1284
- var Action = z14.union([ActionDocument, AsyncRejectActionDocument]);
1285
-
1286
- // ../commons/src/events/Flag.ts
1287
- var z15 = __toESM(require("zod/v4"));
1288
- var InherentFlags = {
1289
- INCOMPLETE: "incomplete",
1290
- REJECTED: "rejected",
1291
- CORRECTION_REQUESTED: "correction-requested",
1292
- POTENTIAL_DUPLICATE: "potential-duplicate",
1293
- /**
1294
- * This flag is set by the Edit-action and removed after the declaration or registration.
1295
- * A record should never stay with the EDIT_IN_PROGRESS flag, since it should always be declared or registered right after.
1296
- *
1297
- * We only use this flag to determine that a NOTIFY, DECLARE or REGISTER action is allowed next.
1298
- */
1299
- EDIT_IN_PROGRESS: "edit-in-progress"
1300
- };
1301
- var ActionFlag = z15.string().regex(
1302
- new RegExp(
1303
- `^(${Object.values(ActionType).join("|").toLowerCase()}):(${Object.values(
1304
- ActionStatus
1305
- ).join("|").toLowerCase()})$`
1306
- ),
1307
- "Flag must be in the format ActionType:ActionStatus (lowerCase)"
1308
- );
1309
- var CustomFlag = z15.string().refine((val) => !Object.values(InherentFlags).includes(val), {
1310
- message: `Custom flag cannot be one of the inherent flags: ${Object.values(
1311
- InherentFlags
1312
- ).join(", ")}`
1313
- }).refine((val) => !ActionFlag.safeParse(val).success, {
1314
- message: "Custom flag cannot match the ActionFlag pattern (ActionType:ActionStatus)."
1315
- }).describe("Custom flag identifier defined by the country config.");
1316
- var Flag = ActionFlag.or(z15.enum(InherentFlags)).or(CustomFlag);
1317
- var FlagConfig = z15.object({
1318
- id: CustomFlag,
1319
- requiresAction: z15.boolean().describe(
1320
- "Indicates if this flag expects an action to be performed to be cleared."
1321
- ),
1322
- label: TranslationConfig.describe("Human readable label of the flag.")
1323
- }).meta({
1324
- id: "FlagConfig",
1325
- description: "Configuration for a custom flag that can be added to or removed from records by event actions."
1326
- });
1327
- var ActionFlagConfig = z15.object({
1328
- id: Flag,
1329
- operation: z15.enum(["add", "remove"]).describe("Operation to perform on the flag."),
1330
- conditional: Conditional.optional().describe(
1331
- "When conditional is met, the operation is performed on the flag. If not provided, the operation is performed unconditionally."
1332
- )
1333
- }).meta({
1334
- id: "ActionFlagConfig",
1335
- description: "Add or remove operation applied to a flag when the parent action is accepted. Optionally gated by a conditional."
1351
+ RegisterAction.meta({ id: "RegisterAction" }),
1352
+ DeclareAction.meta({ id: "DeclareAction" }),
1353
+ AssignedAction.meta({ id: "AssignedAction" }),
1354
+ RequestedCorrectionAction.meta({ id: "RequestedCorrectionAction" }),
1355
+ ApprovedCorrectionAction.meta({ id: "ApprovedCorrectionAction" }),
1356
+ RejectedCorrectionAction.meta({ id: "RejectedCorrectionAction" }),
1357
+ UnassignedAction.meta({ id: "UnassignedAction" }),
1358
+ PrintCertificateAction.meta({ id: "PrintCertificateAction" }),
1359
+ ReadAction.meta({ id: "ReadAction" }),
1360
+ EditAction.meta({ id: "EditAction" }),
1361
+ CustomAction.meta({ id: "CustomAction" })
1362
+ ]).meta({
1363
+ id: "ActionDocument"
1336
1364
  });
1365
+ var AsyncRejectActionDocument = ActionBase.omit({
1366
+ declaration: true,
1367
+ annotation: true
1368
+ }).extend(
1369
+ z15.object({
1370
+ type: z15.enum(ConfirmableActions),
1371
+ status: z15.literal(ActionStatus.Rejected)
1372
+ }).shape
1373
+ );
1374
+ var Action = z15.union([ActionDocument, AsyncRejectActionDocument]);
1337
1375
 
1338
1376
  // ../commons/src/events/EventMetadata.ts
1339
1377
  var EventStatus = z16.enum([
@@ -1491,13 +1529,6 @@ var Range = import_v4.z.object({
1491
1529
  }).meta({
1492
1530
  id: "Range"
1493
1531
  });
1494
- var ContainsFlags = import_v4.z.object({
1495
- anyOf: import_v4.z.array(Flag).optional(),
1496
- noneOf: import_v4.z.array(Flag).optional(),
1497
- allOf: import_v4.z.array(Flag).optional()
1498
- }).meta({
1499
- id: "ContainsFlags"
1500
- });
1501
1532
  var Within = import_v4.z.object({ type: import_v4.z.literal("within"), location: import_v4.z.string() }).meta({
1502
1533
  id: "Within"
1503
1534
  });
@@ -2681,6 +2712,9 @@ var ActionConfigBase = z24.object({
2681
2712
  var DeclarationActionBase = ActionConfigBase.extend({
2682
2713
  deduplication: DeduplicationConfig.optional()
2683
2714
  });
2715
+ var actionConfirmationForm = z24.array(FieldConfig).optional().describe(
2716
+ "Fields rendered on the action confirmation dialog. Submitted values are stored in the action annotation and shown in the audit history."
2717
+ );
2684
2718
  var ReadActionConfig = ActionConfigBase.extend(
2685
2719
  z24.object({
2686
2720
  type: z24.literal(ActionType.READ),
@@ -2692,7 +2726,8 @@ var ReadActionConfig = ActionConfigBase.extend(
2692
2726
  );
2693
2727
  var NotifyConfig = ActionConfigBase.extend(
2694
2728
  z24.object({
2695
- type: z24.literal(ActionType.NOTIFY)
2729
+ type: z24.literal(ActionType.NOTIFY),
2730
+ form: actionConfirmationForm
2696
2731
  }).shape
2697
2732
  );
2698
2733
  var DuplicateDetectedConfig = ActionConfigBase.extend(
@@ -2747,6 +2782,7 @@ var DeclareConfig = DeclarationActionBase.extend(
2747
2782
  review: DeclarationReviewConfig.describe(
2748
2783
  "Configuration of the review page fields."
2749
2784
  ),
2785
+ form: actionConfirmationForm,
2750
2786
  dialogCopy: z24.object({
2751
2787
  notify: TranslationConfig.describe(
2752
2788
  "Confirmation text for the notify action"
@@ -2762,7 +2798,13 @@ var DeclareConfig = DeclarationActionBase.extend(
2762
2798
  );
2763
2799
  var ArchiveConfig = ActionConfigBase.extend(
2764
2800
  z24.object({
2765
- type: z24.literal(ActionType.ARCHIVE)
2801
+ type: z24.literal(ActionType.ARCHIVE),
2802
+ form: actionConfirmationForm
2803
+ }).shape
2804
+ );
2805
+ var UnarchiveConfig = ActionConfigBase.extend(
2806
+ z24.object({
2807
+ type: z24.literal(ActionType.UNARCHIVE)
2766
2808
  }).shape
2767
2809
  );
2768
2810
  var EditActionConfig = ActionConfigBase.extend(
@@ -2783,12 +2825,14 @@ var EditActionConfig = ActionConfigBase.extend(
2783
2825
  );
2784
2826
  var RejectConfig = ActionConfigBase.extend(
2785
2827
  z24.object({
2786
- type: z24.literal(ActionType.REJECT)
2828
+ type: z24.literal(ActionType.REJECT),
2829
+ form: actionConfirmationForm
2787
2830
  }).shape
2788
2831
  );
2789
2832
  var RegisterConfig = DeclarationActionBase.extend(
2790
2833
  z24.object({
2791
- type: z24.literal(ActionType.REGISTER)
2834
+ type: z24.literal(ActionType.REGISTER),
2835
+ form: actionConfirmationForm
2792
2836
  }).shape
2793
2837
  );
2794
2838
  var PrintCertificateActionConfig = ActionConfigBase.extend(
@@ -2899,6 +2943,10 @@ var ActionConfig = z24.discriminatedUnion("type", [
2899
2943
  id: "ArchiveActionConfig",
2900
2944
  description: "Configuration for archiving a record."
2901
2945
  }),
2946
+ UnarchiveConfig.meta({
2947
+ id: "UnarchiveActionConfig",
2948
+ description: "Configuration for unarchiving a record."
2949
+ }),
2902
2950
  CustomActionConfig.meta({
2903
2951
  id: "CustomActionConfig",
2904
2952
  description: "Configuration for a country-defined custom action. An event may include any number of these."
@@ -3114,13 +3162,13 @@ var AdvancedSearchConfig = z28.object({
3114
3162
  });
3115
3163
 
3116
3164
  // ../commons/src/events/utils.ts
3117
- var import_lodash = require("lodash");
3165
+ var import_lodash4 = require("lodash");
3118
3166
 
3119
3167
  // ../commons/src/conditionals/validate.ts
3120
3168
  var import__ = __toESM(require("ajv/dist/2019"));
3121
3169
  var import_ajv_formats = __toESM(require("ajv-formats"));
3122
- var z31 = __toESM(require("zod/v4"));
3123
- var import_date_fns = require("date-fns");
3170
+ var z32 = __toESM(require("zod/v4"));
3171
+ var import_date_fns2 = require("date-fns");
3124
3172
 
3125
3173
  // ../commons/src/events/FieldTypeMapping.ts
3126
3174
  var z30 = __toESM(require("zod/v4"));
@@ -3128,204 +3176,300 @@ var z30 = __toESM(require("zod/v4"));
3128
3176
  // ../commons/src/events/DynamicFieldValue.ts
3129
3177
  var z29 = __toESM(require("zod/v4"));
3130
3178
 
3131
- // ../commons/src/conditionals/validate.ts
3132
- var ajv = new import__.default({
3133
- $data: true,
3134
- allowUnionTypes: true,
3135
- strict: false
3136
- // Allow minContains and other newer features
3137
- });
3138
- var DataContext = z31.object({
3139
- rootData: z31.object({
3140
- $leafAdminStructureLocationIds: z31.array(z31.object({ id: UUID }))
3179
+ // ../commons/src/events/state/index.ts
3180
+ var import_lodash3 = require("lodash");
3181
+
3182
+ // ../commons/src/utils.ts
3183
+ var z31 = __toESM(require("zod/v4"));
3184
+ var _ = __toESM(require("lodash"));
3185
+ function getOrThrow(x, message) {
3186
+ if (x === void 0 || x === null) {
3187
+ throw new Error(message);
3188
+ }
3189
+ return x;
3190
+ }
3191
+ function joinValues(values, separator = " ") {
3192
+ return values.filter((value) => !!value).join(separator).trim();
3193
+ }
3194
+ var FullNameV1 = z31.array(
3195
+ z31.object({
3196
+ use: z31.string(),
3197
+ family: z31.string(),
3198
+ given: z31.array(z31.string())
3141
3199
  })
3142
- });
3143
- function resolveDataPath(rootData, dataPath, instancePath) {
3144
- const pathParts = dataPath.split("/");
3145
- const levels = parseInt(pathParts[0], 10);
3146
- const referencePath = pathParts.slice(1);
3147
- const instanceParts = instancePath.split("/").filter(Boolean);
3148
- const traversedParts = instanceParts.slice(0, -levels);
3149
- let current = rootData;
3150
- for (const part of traversedParts) {
3151
- if (current === null || current === void 0) {
3152
- return void 0;
3153
- }
3154
- current = current[part];
3200
+ );
3201
+ function omitKeyDeep(obj, keyToRemove) {
3202
+ if (Array.isArray(obj)) {
3203
+ return obj.map((item) => omitKeyDeep(item, keyToRemove));
3155
3204
  }
3156
- for (const part of referencePath) {
3157
- if (current === null || current === void 0) {
3158
- return void 0;
3205
+ if (obj === null || typeof obj !== "object") {
3206
+ return obj;
3207
+ }
3208
+ const newObj = {};
3209
+ for (const key of Object.keys(obj)) {
3210
+ if (key !== keyToRemove) {
3211
+ newObj[key] = omitKeyDeep(obj[key], keyToRemove);
3159
3212
  }
3160
- current = current[part];
3161
3213
  }
3162
- return current;
3214
+ return newObj;
3163
3215
  }
3164
- function todayISO() {
3165
- return (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" });
3216
+
3217
+ // ../commons/src/events/state/utils.ts
3218
+ var import_lodash = require("lodash");
3219
+ function getActionRequests(actionType, actions) {
3220
+ const filtered = actions.filter((action) => action.type === actionType).reverse();
3221
+ const accept = filtered.find(
3222
+ (action) => action.status === ActionStatus.Accepted
3223
+ );
3224
+ const request = filtered.find(
3225
+ (action) => action.status === ActionStatus.Requested
3226
+ );
3227
+ const reject = filtered.find(
3228
+ (action) => action.status === ActionStatus.Rejected
3229
+ );
3230
+ return {
3231
+ reject,
3232
+ accept,
3233
+ request
3234
+ };
3166
3235
  }
3167
- var compiledFunctionCache = /* @__PURE__ */ new Map();
3168
- function compileClientFunction(code) {
3169
- let fn = compiledFunctionCache.get(code);
3170
- if (!fn) {
3171
- fn = new Function(`return (${code})`)();
3172
- compiledFunctionCache.set(code, fn);
3236
+ function getDeclarationActionCreationMetadata(actionType, actions) {
3237
+ const { accept: acceptAction, request: requestAction } = getActionRequests(
3238
+ actionType,
3239
+ actions
3240
+ );
3241
+ if (!acceptAction) {
3242
+ return null;
3173
3243
  }
3174
- return fn;
3175
- }
3176
- (0, import_ajv_formats.default)(ajv);
3177
- function buildClientFunctionContext(input) {
3244
+ const registrationNumber = acceptAction.type === ActionType.REGISTER ? acceptAction.registrationNumber : null;
3178
3245
  return {
3179
- $form: input.form,
3180
- $now: todayISO(),
3181
- // eslint-disable-next-line @typescript-eslint/no-use-before-define
3182
- $online: isOnline(),
3183
- $user: input.validatorContext?.user,
3184
- $event: input.validatorContext?.event,
3185
- $leafAdminStructureLocationIds: input.validatorContext?.leafAdminStructureLocationIds ?? [],
3186
- user: input.systemVariables?.user,
3187
- $window: input.systemVariables?.$window,
3188
- locations: input.locations,
3189
- adminLevelIds: input.adminLevelIds
3246
+ // When 3rd party API returns 200 OK, we assume that the request was accepted, and persist single 'accepted' action.
3247
+ createdAt: requestAction?.createdAt ?? acceptAction.createdAt,
3248
+ createdBy: requestAction?.createdBy ?? acceptAction.createdBy,
3249
+ createdByUserType: requestAction?.createdByUserType ?? acceptAction.createdByUserType,
3250
+ createdAtLocation: requestAction?.createdAtLocation ?? acceptAction.createdAtLocation,
3251
+ acceptedAt: acceptAction.createdAt,
3252
+ createdByRole: requestAction?.createdByRole ?? acceptAction.createdByRole,
3253
+ registrationNumber
3190
3254
  };
3191
3255
  }
3192
- function runClientFunction(code, data, context) {
3193
- return compileClientFunction(code)(data, context);
3256
+ var updateActions = ActionTypes.extract([
3257
+ ActionType.CREATE,
3258
+ ActionType.NOTIFY,
3259
+ ActionType.EDIT,
3260
+ ActionType.DECLARE,
3261
+ ActionType.REGISTER,
3262
+ ActionType.REJECT,
3263
+ ActionType.ARCHIVE,
3264
+ ActionType.UNARCHIVE,
3265
+ ActionType.PRINT_CERTIFICATE,
3266
+ ActionType.REQUEST_CORRECTION,
3267
+ ActionType.APPROVE_CORRECTION,
3268
+ ActionType.REJECT_CORRECTION,
3269
+ ActionType.CUSTOM
3270
+ ]);
3271
+ function getActionUpdateMetadata(actions) {
3272
+ const createAction = getOrThrow(
3273
+ actions.find((action) => action.type === ActionType.CREATE),
3274
+ `Event has no ${ActionType.CREATE} action`
3275
+ );
3276
+ const metadataFields = [
3277
+ "createdAt",
3278
+ "createdBy",
3279
+ "createdByUserType",
3280
+ "createdAtLocation",
3281
+ "createdByRole"
3282
+ ];
3283
+ return actions.filter(({ type }) => updateActions.safeParse(type).success).reduce(
3284
+ (_2, action) => {
3285
+ if (action.originalActionId) {
3286
+ const originalAction = actions.find(({ id }) => id === action.originalActionId) ?? action;
3287
+ return (0, import_lodash.pick)(originalAction, metadataFields);
3288
+ }
3289
+ return (0, import_lodash.pick)(action, metadataFields);
3290
+ },
3291
+ (0, import_lodash.pick)(createAction, metadataFields)
3292
+ );
3194
3293
  }
3195
- ajv.addKeyword({
3196
- keyword: "daysFromDate",
3197
- type: "string",
3198
- schemaType: "object",
3199
- $data: true,
3200
- errors: true,
3201
- validate(schema, data, _2, dataContext) {
3202
- if (!(dataContext && dataContext.rootData && typeof dataContext.rootData === "object" && "$now" in dataContext.rootData && typeof dataContext.rootData.$now === "string")) {
3203
- throw new Error("Validation context must contain $now");
3204
- }
3205
- const { days, clause } = schema;
3206
- if (typeof data !== "string") {
3207
- return false;
3208
- }
3209
- const date = new Date(data);
3210
- if (isNaN(date.getTime())) {
3211
- return false;
3212
- }
3213
- let referenceDate = schema.referenceDate;
3214
- if (referenceDate && typeof referenceDate === "object" && "$data" in referenceDate) {
3215
- referenceDate = resolveDataPath(
3216
- dataContext.rootData,
3217
- referenceDate.$data,
3218
- dataContext.instancePath
3219
- );
3220
- }
3221
- if (!referenceDate) {
3222
- referenceDate = dataContext.rootData.$now;
3223
- }
3224
- const baseDate = new Date(referenceDate);
3225
- if (isNaN(baseDate.getTime())) {
3226
- return false;
3294
+ function getLegalStatuses(actions) {
3295
+ return {
3296
+ [EventStatus.enum.NOTIFIED]: getDeclarationActionCreationMetadata(
3297
+ ActionType.NOTIFY,
3298
+ actions
3299
+ ),
3300
+ [EventStatus.enum.DECLARED]: getDeclarationActionCreationMetadata(
3301
+ ActionType.DECLARE,
3302
+ actions
3303
+ ),
3304
+ [EventStatus.enum.REGISTERED]: getDeclarationActionCreationMetadata(
3305
+ ActionType.REGISTER,
3306
+ actions
3307
+ )
3308
+ };
3309
+ }
3310
+
3311
+ // ../commons/src/events/state/flags.ts
3312
+ var import_lodash2 = require("lodash");
3313
+ var import_date_fns = require("date-fns");
3314
+ function isFlagConditionMet(conditional, form, action) {
3315
+ 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" });
3316
+ return validate(conditional, {
3317
+ $form: form,
3318
+ $now: now2,
3319
+ $online: true,
3320
+ $user: {
3321
+ sub: "",
3322
+ exp: "",
3323
+ role: action.createdByRole,
3324
+ algorithm: "",
3325
+ scope: [],
3326
+ userType: action.createdByUserType
3227
3327
  }
3228
- const offsetDate = new Date(baseDate.getTime() + days * 24 * 60 * 60 * 1e3);
3229
- return clause === "after" ? (0, import_date_fns.isAfter)(date, offsetDate) : (0, import_date_fns.isBefore)(date, offsetDate);
3230
- }
3231
- });
3232
- ajv.addKeyword({
3233
- keyword: "isLeafLevelLocation",
3234
- type: "string",
3235
- schemaType: "boolean",
3236
- $data: true,
3237
- errors: true,
3238
- // @ts-ignore -- Force type. We will move this away from AJV next. Parsing the array will take seconds and is only called by core.
3239
- validate(_schema, data, _2, dataContext) {
3240
- const locationIdInput = data;
3241
- const locations = dataContext?.rootData.$leafAdminStructureLocationIds ?? [];
3242
- return locations.some((location) => location.id === locationIdInput);
3243
- }
3244
- });
3245
- ajv.addKeyword({
3246
- keyword: "customClientValidator",
3247
- schemaType: "object",
3248
- errors: true,
3249
- // @ts-expect-error -- AJV's public types don't expose `rootData`. All
3250
- // `validate()` callers build root data via `buildClientFunctionContext`,
3251
- // so the cast holds.
3252
- validate(schema, data, _2, dataContext) {
3253
- return Boolean(
3254
- runClientFunction(
3255
- schema.code,
3256
- data,
3257
- dataContext?.rootData ?? buildClientFunctionContext({ form: {} })
3258
- )
3259
- );
3328
+ });
3329
+ }
3330
+ function actionConfigRemovesFlag(action, flagId, actionsUpToAndIncluding, event2, eventConfiguration) {
3331
+ if (!isActionConfigType(action.type)) {
3332
+ return false;
3260
3333
  }
3261
- });
3262
- function isOnline() {
3263
- if (typeof window !== "undefined" && typeof navigator !== "undefined") {
3264
- return navigator.onLine;
3334
+ const actionConfig = getActionConfig({
3335
+ eventConfiguration,
3336
+ actionType: action.type,
3337
+ customActionType: "customActionType" in action ? action.customActionType : void 0
3338
+ });
3339
+ const removeOperations = (actionConfig?.flags ?? []).filter(
3340
+ ({ id, operation }) => id === flagId && operation === "remove"
3341
+ );
3342
+ if (removeOperations.length === 0) {
3343
+ return false;
3265
3344
  }
3266
- return true;
3345
+ const eventUpToThisAction = { ...event2, actions: actionsUpToAndIncluding };
3346
+ const declaration = aggregateActionDeclarations(eventUpToThisAction);
3347
+ const annotation = aggregateActionAnnotations(eventUpToThisAction);
3348
+ const form = { ...declaration, ...annotation };
3349
+ return removeOperations.some(
3350
+ ({ conditional }) => conditional ? isFlagConditionMet(conditional, form, action) : true
3351
+ );
3267
3352
  }
3268
-
3269
- // ../commons/src/utils.ts
3270
- var z32 = __toESM(require("zod/v4"));
3271
- var _ = __toESM(require("lodash"));
3272
- var FullNameV1 = z32.array(
3273
- z32.object({
3274
- use: z32.string(),
3275
- family: z32.string(),
3276
- given: z32.array(z32.string())
3277
- })
3278
- );
3279
- function omitKeyDeep(obj, keyToRemove) {
3280
- if (Array.isArray(obj)) {
3281
- return obj.map((item) => omitKeyDeep(item, keyToRemove));
3282
- }
3283
- if (obj === null || typeof obj !== "object") {
3284
- return obj;
3353
+ var INHERENT_FLAG_RULES = [
3354
+ {
3355
+ flag: InherentFlags.CORRECTION_REQUESTED,
3356
+ setOn: [ActionType.REQUEST_CORRECTION],
3357
+ resetOn: [ActionType.APPROVE_CORRECTION, ActionType.REJECT_CORRECTION]
3358
+ },
3359
+ {
3360
+ // INCOMPLETE mirrors the NOTIFIED status: set by NOTIFY, cleared by any
3361
+ // other status-changing action (see getStatusFromActions). ARCHIVE/UNARCHIVE
3362
+ // are deliberately excluded so the flag freezes across an archive/unarchive
3363
+ // round trip and comes back exactly as it was.
3364
+ flag: InherentFlags.INCOMPLETE,
3365
+ setOn: [ActionType.NOTIFY],
3366
+ resetOn: [ActionType.CREATE, ActionType.DECLARE, ActionType.REGISTER]
3367
+ },
3368
+ {
3369
+ flag: InherentFlags.REJECTED,
3370
+ setOn: [ActionType.REJECT],
3371
+ resetOn: [
3372
+ ActionType.NOTIFY,
3373
+ ActionType.DECLARE,
3374
+ ActionType.EDIT,
3375
+ ActionType.REGISTER
3376
+ ]
3377
+ },
3378
+ {
3379
+ flag: InherentFlags.POTENTIAL_DUPLICATE,
3380
+ setOn: [ActionType.DUPLICATE_DETECTED],
3381
+ resetOn: [ActionType.MARK_AS_DUPLICATE, ActionType.MARK_AS_NOT_DUPLICATE]
3382
+ },
3383
+ {
3384
+ flag: InherentFlags.EDIT_IN_PROGRESS,
3385
+ setOn: [ActionType.EDIT],
3386
+ resetOnAnyOtherAction: true
3285
3387
  }
3286
- const newObj = {};
3287
- for (const key of Object.keys(obj)) {
3288
- if (key !== keyToRemove) {
3289
- newObj[key] = omitKeyDeep(obj[key], keyToRemove);
3388
+ ];
3389
+ function resolveInherentFlag(rule, acceptedActions, event2, eventConfiguration) {
3390
+ return acceptedActions.reduce((present, action, idx) => {
3391
+ if (rule.setOn.includes(action.type)) {
3392
+ return true;
3290
3393
  }
3291
- }
3292
- return newObj;
3394
+ if (rule.resetOnAnyOtherAction || (rule.resetOn ?? []).includes(action.type)) {
3395
+ return false;
3396
+ }
3397
+ if (actionConfigRemovesFlag(
3398
+ action,
3399
+ rule.flag,
3400
+ acceptedActions.slice(0, idx + 1),
3401
+ event2,
3402
+ eventConfiguration
3403
+ )) {
3404
+ return false;
3405
+ }
3406
+ return present;
3407
+ }, false);
3293
3408
  }
3294
-
3295
- // ../commons/src/events/utils.ts
3296
- var import_date_fns2 = require("date-fns");
3297
- function getDeclarationFields(configuration) {
3298
- return configuration.declaration.pages.flatMap(({ fields }) => fields);
3409
+ function resolveEventCustomFlags(event2, eventConfiguration) {
3410
+ const actions = getAcceptedActions(event2).filter(({ type }) => !isMetaAction(type)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
3411
+ return actions.reduce((acc, action, idx) => {
3412
+ let actionConfig;
3413
+ if (isActionConfigType(action.type)) {
3414
+ actionConfig = getActionConfig({
3415
+ eventConfiguration,
3416
+ actionType: action.type,
3417
+ customActionType: "customActionType" in action ? action.customActionType : void 0
3418
+ });
3419
+ }
3420
+ if (!actionConfig) {
3421
+ return acc;
3422
+ }
3423
+ const eventUpToThisAction = {
3424
+ ...event2,
3425
+ actions: actions.slice(0, idx + 1)
3426
+ };
3427
+ const declaration = aggregateActionDeclarations(eventUpToThisAction);
3428
+ const annotation = aggregateActionAnnotations(eventUpToThisAction);
3429
+ const form = { ...declaration, ...annotation };
3430
+ const flagsWithMetConditions = (actionConfig.flags ?? []).filter(
3431
+ ({ conditional }) => (
3432
+ // If conditional is not provided, the flag is resolved
3433
+ conditional ? isFlagConditionMet(conditional, form, action) : true
3434
+ )
3435
+ );
3436
+ const addedFlags = flagsWithMetConditions.filter(({ operation }) => operation === "add").map(({ id }) => id);
3437
+ const removedFlags = flagsWithMetConditions.filter(({ operation }) => operation === "remove").map(({ id }) => id);
3438
+ const flags = [...acc, ...addedFlags].filter(
3439
+ (flagId) => !removedFlags.includes(flagId)
3440
+ );
3441
+ return (0, import_lodash2.uniq)(flags);
3442
+ }, []);
3299
3443
  }
3300
- var getActionAnnotationFields = (actionConfig) => {
3301
- if (actionConfig.type === ActionType.REQUEST_CORRECTION) {
3302
- return actionConfig.correctionForm.pages.flatMap(({ fields }) => fields);
3303
- }
3304
- if (actionConfig.type === ActionType.PRINT_CERTIFICATE) {
3305
- return actionConfig.printForm.pages.flatMap(({ fields }) => fields);
3306
- }
3307
- if (actionConfig.type === ActionType.CUSTOM) {
3308
- return actionConfig.form;
3309
- }
3310
- if ("review" in actionConfig && actionConfig.review != null) {
3311
- return actionConfig.review.fields;
3312
- }
3313
- return [];
3314
- };
3315
- function getAllAnnotationFields(config) {
3316
- return (0, import_lodash.flattenDeep)(config.actions.map(getActionAnnotationFields));
3444
+ function getActionStatusFlags(sortedActions) {
3445
+ const actionStatus = sortedActions.reduce(
3446
+ (actionStatuses, { type, status }) => ({
3447
+ ...actionStatuses,
3448
+ [type]: status
3449
+ }),
3450
+ {}
3451
+ );
3452
+ return Object.entries(actionStatus).filter(([, status]) => status !== ActionStatus.Accepted).map(([type, status]) => {
3453
+ const flag = joinValues([type, status], ":").toLowerCase();
3454
+ return flag;
3455
+ });
3456
+ }
3457
+ function getInherentFlags(sortedActions, event2, eventConfiguration) {
3458
+ const acceptedActions = sortedActions.filter(
3459
+ ({ status }) => status === ActionStatus.Accepted
3460
+ );
3461
+ return INHERENT_FLAG_RULES.filter(
3462
+ (rule) => resolveInherentFlag(rule, acceptedActions, event2, eventConfiguration)
3463
+ ).map(({ flag }) => flag);
3464
+ }
3465
+ function getEventFlags(event2, config) {
3466
+ const sortedActions = event2.actions.filter(({ type }) => !isMetaAction(type)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
3467
+ return [
3468
+ ...getActionStatusFlags(sortedActions),
3469
+ ...getInherentFlags(sortedActions, event2, config),
3470
+ ...resolveEventCustomFlags(event2, config)
3471
+ ];
3317
3472
  }
3318
- var findAllFields = (config) => {
3319
- return (0, import_lodash.flattenDeep)([
3320
- ...getDeclarationFields(config),
3321
- ...getAllAnnotationFields(config)
3322
- ]);
3323
- };
3324
- var EXCLUDED_ACTIONS = [
3325
- ActionType.REQUEST_CORRECTION,
3326
- ActionType.PRINT_CERTIFICATE,
3327
- ActionType.REJECT_CORRECTION
3328
- ];
3329
3473
 
3330
3474
  // ../commons/src/conditionals/conditionals.ts
3331
3475
  var objectHash = __toESM(require("object-hash"));
@@ -3854,84 +3998,590 @@ function createFieldConditionals(fieldId) {
3854
3998
  },
3855
3999
  this.$$subfield
3856
4000
  )
3857
- },
3858
- required: [fieldId]
3859
- });
3860
- },
3861
- getId: () => ({ fieldId }),
3862
- /**
3863
- * @deprecated
3864
- * use field(fieldId).get(nestedProperty) instead
3865
- * with 'and' combinator e.g.
3866
- * and(
3867
- * field('child.name').get('firstname').isEqualTo('John'),
3868
- * field('child.name').get('surname').isEqualTo('Doe')
3869
- * )
3870
- */
3871
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
3872
- object: (options) => defineFormConditional({
3873
- type: "object",
3874
- properties: {
3875
- [fieldId]: {
3876
- type: "object",
3877
- properties: Object.fromEntries(
3878
- Object.entries(options).map(([key, value]) => {
3879
- return [key, value.properties.$form.properties[key]];
3880
- })
3881
- ),
3882
- required: Object.keys(options)
4001
+ },
4002
+ required: [fieldId]
4003
+ });
4004
+ },
4005
+ getId: () => ({ fieldId }),
4006
+ /**
4007
+ * @deprecated
4008
+ * use field(fieldId).get(nestedProperty) instead
4009
+ * with 'and' combinator e.g.
4010
+ * and(
4011
+ * field('child.name').get('firstname').isEqualTo('John'),
4012
+ * field('child.name').get('surname').isEqualTo('Doe')
4013
+ * )
4014
+ */
4015
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
4016
+ object: (options) => defineFormConditional({
4017
+ type: "object",
4018
+ properties: {
4019
+ [fieldId]: {
4020
+ type: "object",
4021
+ properties: Object.fromEntries(
4022
+ Object.entries(options).map(([key, value]) => {
4023
+ return [key, value.properties.$form.properties[key]];
4024
+ })
4025
+ ),
4026
+ required: Object.keys(options)
4027
+ }
4028
+ },
4029
+ required: [fieldId]
4030
+ }),
4031
+ /**
4032
+ * Custom client-side validator. The provided function is serialised and executed
4033
+ * just-in-time on the client only. External references (e.g. lodash) are not
4034
+ * available inside the function body — all logic must be self-contained.
4035
+ *
4036
+ * @example
4037
+ * field('nid').customClientValidator((value) => {
4038
+ * // LUHN check — all logic must be inline
4039
+ * const digits = String(value).split('').map(Number)
4040
+ * // ...
4041
+ * return isValid
4042
+ * })
4043
+ */
4044
+ customClientValidator(validationFn) {
4045
+ const code = validationFn.toString();
4046
+ return defineFormConditional({
4047
+ type: "object",
4048
+ properties: wrapToPath(
4049
+ { [fieldId]: { customClientValidator: { code } } },
4050
+ this.$$subfield
4051
+ ),
4052
+ required: [fieldId]
4053
+ });
4054
+ },
4055
+ /**
4056
+ * Custom client-side evaluation. Returns a {@link FieldReference} descriptor
4057
+ * that can be used as the `value` property or a DATA component entry.
4058
+ * The function receives the referenced field's value as the first argument and
4059
+ * the full form context as the second; its return value replaces the field reference.
4060
+ * The function is serialised and executed just-in-time on the client only.
4061
+ * External references (e.g. lodash) are not available inside the function body.
4062
+ *
4063
+ * For computing a default value without referencing a specific field, use
4064
+ * `evaluate(fn)` in the `defaultValue` property instead.
4065
+ *
4066
+ * @example
4067
+ * field('a').customClientEvaluation((aValue, ctx) =>
4068
+ * Number(aValue) + Number(ctx.$form.b)
4069
+ * )
4070
+ */
4071
+ customClientEvaluation(computationFn) {
4072
+ return {
4073
+ $$code: computationFn.toString(),
4074
+ $$field: fieldId,
4075
+ $$subfield: this.$$subfield
4076
+ };
4077
+ }
4078
+ };
4079
+ }
4080
+
4081
+ // ../commons/src/events/state/index.ts
4082
+ function getStatusFromActions(actions) {
4083
+ const acceptedActions = actions.filter(
4084
+ ({ status }) => status === ActionStatus.Accepted
4085
+ );
4086
+ const isCurrentlyArchived = acceptedActions.reduce(
4087
+ (archived, action) => {
4088
+ if (action.type === ActionType.ARCHIVE) {
4089
+ return true;
4090
+ }
4091
+ if (action.type === ActionType.UNARCHIVE) {
4092
+ return false;
4093
+ }
4094
+ return archived;
4095
+ },
4096
+ false
4097
+ );
4098
+ if (isCurrentlyArchived) {
4099
+ return EventStatus.enum.ARCHIVED;
4100
+ }
4101
+ return acceptedActions.filter(
4102
+ ({ type }) => type !== ActionType.ARCHIVE && type !== ActionType.UNARCHIVE
4103
+ ).reduce((status, action) => {
4104
+ switch (action.type) {
4105
+ case ActionType.CREATE:
4106
+ return EventStatus.enum.CREATED;
4107
+ case ActionType.DECLARE:
4108
+ return EventStatus.enum.DECLARED;
4109
+ case ActionType.REGISTER:
4110
+ return EventStatus.enum.REGISTERED;
4111
+ case ActionType.NOTIFY:
4112
+ return EventStatus.enum.NOTIFIED;
4113
+ // Already filtered out above; listed here only to satisfy exhaustiveness.
4114
+ case ActionType.ARCHIVE:
4115
+ case ActionType.UNARCHIVE:
4116
+ case ActionType.CUSTOM:
4117
+ case ActionType.PRINT_CERTIFICATE:
4118
+ case ActionType.ASSIGN:
4119
+ case ActionType.UNASSIGN:
4120
+ case ActionType.REJECT:
4121
+ case ActionType.REQUEST_CORRECTION:
4122
+ case ActionType.APPROVE_CORRECTION:
4123
+ case ActionType.DUPLICATE_DETECTED:
4124
+ case ActionType.MARK_AS_NOT_DUPLICATE:
4125
+ case ActionType.MARK_AS_DUPLICATE:
4126
+ case ActionType.REJECT_CORRECTION:
4127
+ case ActionType.READ:
4128
+ case ActionType.EDIT:
4129
+ default:
4130
+ return status;
4131
+ }
4132
+ }, EventStatus.enum.CREATED);
4133
+ }
4134
+ function getAssignedUserFromActions(actions) {
4135
+ return actions.reduce((user2, action) => {
4136
+ if (action.type === ActionType.ASSIGN) {
4137
+ return action.assignedTo;
4138
+ }
4139
+ if (action.type === ActionType.UNASSIGN) {
4140
+ return null;
4141
+ }
4142
+ return user2;
4143
+ }, null);
4144
+ }
4145
+ function deepDropNulls(obj) {
4146
+ if (Array.isArray(obj)) {
4147
+ return obj.map(deepDropNulls);
4148
+ }
4149
+ if (obj !== null && typeof obj === "object") {
4150
+ return Object.entries(obj).reduce((acc, [key, value]) => {
4151
+ const cleanedValue = deepDropNulls(value);
4152
+ if (cleanedValue !== null) {
4153
+ ;
4154
+ acc[key] = cleanedValue;
4155
+ }
4156
+ return acc;
4157
+ }, {});
4158
+ }
4159
+ return obj;
4160
+ }
4161
+ var DEFAULT_DATE_OF_EVENT_PROPERTY = "createdAt";
4162
+ function extractDateString(dateTime) {
4163
+ return dateTime.split("T")[0];
4164
+ }
4165
+ function resolveDateOfEvent(eventIndex, declaration, config) {
4166
+ if (!config.dateOfEvent) {
4167
+ return extractDateString(eventIndex[DEFAULT_DATE_OF_EVENT_PROPERTY]);
4168
+ }
4169
+ const parsedDate = isFieldReference(config.dateOfEvent) ? ZodDate.safeParse(declaration[config.dateOfEvent.$$field]) : ZodDateTime.safeParse(
4170
+ getMixedPath(eventIndex, config.dateOfEvent.$$event)
4171
+ );
4172
+ return parsedDate.success ? extractDateString(parsedDate.data) : void 0;
4173
+ }
4174
+ var DEFAULT_PLACE_OF_EVENT_PROPERTY = "createdAtLocation";
4175
+ function getParsedUUID(value, oldValue) {
4176
+ const parsed = UUID.safeParse(value);
4177
+ return parsed.success ? parsed.data : oldValue;
4178
+ }
4179
+ function resolvePlaceOfEvent(eventMetadata, declaration, config) {
4180
+ let placeOfEvent = getParsedUUID(
4181
+ eventMetadata[DEFAULT_PLACE_OF_EVENT_PROPERTY]
4182
+ );
4183
+ if (config.placeOfEvent) {
4184
+ const addressFieldValue = AddressFieldValue.safeParse(
4185
+ declaration[config.placeOfEvent.$$field]
4186
+ );
4187
+ if (addressFieldValue.success && addressFieldValue.data.addressType === AddressType.DOMESTIC && addressFieldValue.data.administrativeArea) {
4188
+ placeOfEvent = getParsedUUID(
4189
+ addressFieldValue.data.administrativeArea,
4190
+ placeOfEvent
4191
+ );
4192
+ } else {
4193
+ placeOfEvent = getParsedUUID(
4194
+ declaration[config.placeOfEvent.$$field],
4195
+ placeOfEvent
4196
+ );
4197
+ }
4198
+ }
4199
+ return placeOfEvent;
4200
+ }
4201
+ function extractPotentialDuplicatesFromActions(actions) {
4202
+ return actions.reduce((duplicates, action) => {
4203
+ if (action.type === ActionType.DUPLICATE_DETECTED) {
4204
+ duplicates = action.content.duplicates;
4205
+ }
4206
+ if (action.type === ActionType.MARK_AS_NOT_DUPLICATE || action.type === ActionType.MARK_AS_DUPLICATE) {
4207
+ duplicates = [];
4208
+ }
4209
+ return duplicates;
4210
+ }, []);
4211
+ }
4212
+ function getCurrentEventState(event2, config) {
4213
+ const sortedActions = event2.actions.slice().sort((a, b) => a.createdAt.localeCompare(b.createdAt));
4214
+ const creationAction = sortedActions.find(
4215
+ (action) => action.type === ActionType.CREATE
4216
+ );
4217
+ if (!creationAction) {
4218
+ throw new Error(`Event ${event2.id} has no creation action`);
4219
+ }
4220
+ const acceptedActions = getAcceptedActions(event2).sort(
4221
+ (a, b) => a.createdAt.localeCompare(b.createdAt)
4222
+ );
4223
+ const requestActionMetadata = getActionUpdateMetadata(sortedActions);
4224
+ const acceptedActionMetadata = getActionUpdateMetadata(acceptedActions);
4225
+ const declaration = aggregateActionDeclarations(event2);
4226
+ const status = getStatusFromActions(sortedActions);
4227
+ const legalStatuses = getLegalStatuses(sortedActions);
4228
+ const base = deepDropNulls({
4229
+ id: event2.id,
4230
+ type: event2.type,
4231
+ status,
4232
+ legalStatuses,
4233
+ createdAt: creationAction.createdAt,
4234
+ createdBy: creationAction.createdBy,
4235
+ createdByUserType: creationAction.createdByUserType,
4236
+ createdAtLocation: creationAction.createdAtLocation,
4237
+ updatedAt: acceptedActionMetadata.createdAt,
4238
+ assignedTo: getAssignedUserFromActions(acceptedActions),
4239
+ updatedBy: requestActionMetadata.createdBy,
4240
+ updatedAtLocation: requestActionMetadata.createdAtLocation,
4241
+ declaration,
4242
+ trackingId: event2.trackingId,
4243
+ updatedByUserRole: requestActionMetadata.createdByRole,
4244
+ placeOfEvent: resolvePlaceOfEvent(
4245
+ { createdAtLocation: creationAction.createdAtLocation },
4246
+ declaration,
4247
+ config
4248
+ ),
4249
+ potentialDuplicates: extractPotentialDuplicatesFromActions(sortedActions),
4250
+ flags: getEventFlags(event2, config)
4251
+ });
4252
+ return deepDropNulls({
4253
+ ...base,
4254
+ dateOfEvent: resolveDateOfEvent(base, declaration, config)
4255
+ });
4256
+ }
4257
+
4258
+ // ../commons/src/conditionals/validate.ts
4259
+ var ajv = new import__.default({
4260
+ $data: true,
4261
+ allowUnionTypes: true,
4262
+ strict: false
4263
+ // Allow minContains and other newer features
4264
+ });
4265
+ var DataContext = z32.object({
4266
+ rootData: z32.object({
4267
+ $leafAdminStructureLocationIds: z32.array(z32.object({ id: UUID }))
4268
+ })
4269
+ });
4270
+ function resolveDataPath(rootData, dataPath, instancePath) {
4271
+ const pathParts = dataPath.split("/");
4272
+ const levels = parseInt(pathParts[0], 10);
4273
+ const referencePath = pathParts.slice(1);
4274
+ const instanceParts = instancePath.split("/").filter(Boolean);
4275
+ const traversedParts = instanceParts.slice(0, -levels);
4276
+ let current = rootData;
4277
+ for (const part of traversedParts) {
4278
+ if (current === null || current === void 0) {
4279
+ return void 0;
4280
+ }
4281
+ current = current[part];
4282
+ }
4283
+ for (const part of referencePath) {
4284
+ if (current === null || current === void 0) {
4285
+ return void 0;
4286
+ }
4287
+ current = current[part];
4288
+ }
4289
+ return current;
4290
+ }
4291
+ function todayISO() {
4292
+ return (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" });
4293
+ }
4294
+ var compiledFunctionCache = /* @__PURE__ */ new Map();
4295
+ function compileClientFunction(code) {
4296
+ let fn = compiledFunctionCache.get(code);
4297
+ if (!fn) {
4298
+ fn = new Function(`return (${code})`)();
4299
+ compiledFunctionCache.set(code, fn);
4300
+ }
4301
+ return fn;
4302
+ }
4303
+ (0, import_ajv_formats.default)(ajv);
4304
+ function buildClientFunctionContext(input) {
4305
+ const flags = input.validatorContext?.event && input.validatorContext?.eventConfig ? getCurrentEventState(
4306
+ input.validatorContext?.event,
4307
+ input.validatorContext?.eventConfig
4308
+ )?.flags : [];
4309
+ return {
4310
+ $form: input.form,
4311
+ $flags: flags,
4312
+ $now: todayISO(),
4313
+ // eslint-disable-next-line @typescript-eslint/no-use-before-define
4314
+ $online: isOnline(),
4315
+ $user: input.validatorContext?.user,
4316
+ $event: input.validatorContext?.event,
4317
+ $leafAdminStructureLocationIds: input.validatorContext?.leafAdminStructureLocationIds ?? [],
4318
+ user: input.systemVariables?.user,
4319
+ $window: input.systemVariables?.$window,
4320
+ locations: input.locations,
4321
+ adminLevelIds: input.adminLevelIds
4322
+ };
4323
+ }
4324
+ function runClientFunction(code, data, context) {
4325
+ return compileClientFunction(code)(data, context);
4326
+ }
4327
+ ajv.addKeyword({
4328
+ keyword: "daysFromDate",
4329
+ type: "string",
4330
+ schemaType: "object",
4331
+ $data: true,
4332
+ errors: true,
4333
+ validate(schema, data, _2, dataContext) {
4334
+ if (!(dataContext && dataContext.rootData && typeof dataContext.rootData === "object" && "$now" in dataContext.rootData && typeof dataContext.rootData.$now === "string")) {
4335
+ throw new Error("Validation context must contain $now");
4336
+ }
4337
+ const { days, clause } = schema;
4338
+ if (typeof data !== "string") {
4339
+ return false;
4340
+ }
4341
+ const date = new Date(data);
4342
+ if (isNaN(date.getTime())) {
4343
+ return false;
4344
+ }
4345
+ let referenceDate = schema.referenceDate;
4346
+ if (referenceDate && typeof referenceDate === "object" && "$data" in referenceDate) {
4347
+ referenceDate = resolveDataPath(
4348
+ dataContext.rootData,
4349
+ referenceDate.$data,
4350
+ dataContext.instancePath
4351
+ );
4352
+ }
4353
+ if (!referenceDate) {
4354
+ referenceDate = dataContext.rootData.$now;
4355
+ }
4356
+ const baseDate = new Date(referenceDate);
4357
+ if (isNaN(baseDate.getTime())) {
4358
+ return false;
4359
+ }
4360
+ const offsetDate = new Date(baseDate.getTime() + days * 24 * 60 * 60 * 1e3);
4361
+ return clause === "after" ? (0, import_date_fns2.isAfter)(date, offsetDate) : (0, import_date_fns2.isBefore)(date, offsetDate);
4362
+ }
4363
+ });
4364
+ ajv.addKeyword({
4365
+ keyword: "isLeafLevelLocation",
4366
+ type: "string",
4367
+ schemaType: "boolean",
4368
+ $data: true,
4369
+ errors: true,
4370
+ // @ts-ignore -- Force type. We will move this away from AJV next. Parsing the array will take seconds and is only called by core.
4371
+ validate(_schema, data, _2, dataContext) {
4372
+ const locationIdInput = data;
4373
+ const locations = dataContext?.rootData.$leafAdminStructureLocationIds ?? [];
4374
+ return locations.some((location) => location.id === locationIdInput);
4375
+ }
4376
+ });
4377
+ function isAgeValue(value) {
4378
+ return typeof value === "object" && value !== null && "age" in value && typeof value.age === "number";
4379
+ }
4380
+ ajv.addKeyword({
4381
+ keyword: "customClientValidator",
4382
+ schemaType: "object",
4383
+ errors: true,
4384
+ // @ts-expect-error -- AJV's public types don't expose `rootData`. All
4385
+ // `validate()` callers build root data via `buildClientFunctionContext`,
4386
+ // so the cast holds.
4387
+ validate(schema, data, _2, dataContext) {
4388
+ return Boolean(
4389
+ runClientFunction(
4390
+ schema.code,
4391
+ data,
4392
+ dataContext?.rootData ?? buildClientFunctionContext({ form: {} })
4393
+ )
4394
+ );
4395
+ }
4396
+ });
4397
+ function validate(schema, data) {
4398
+ const validator = ajv.getSchema(schema.$id) || ajv.compile(schema);
4399
+ if ("$form" in data) {
4400
+ const entries = Object.entries(data.$form).map(([key, value]) => {
4401
+ if (!isAgeValue(value)) {
4402
+ return [key, value];
4403
+ }
4404
+ const age = value.age;
4405
+ const maybeAsOfDate = PlainDate.safeParse(data.$form[value.asOfDateRef]);
4406
+ return [
4407
+ key,
4408
+ {
4409
+ age,
4410
+ dob: ageToDate(
4411
+ age,
4412
+ maybeAsOfDate.success ? maybeAsOfDate.data : PlainDate.parse(data.$now)
4413
+ )
3883
4414
  }
3884
- },
3885
- required: [fieldId]
3886
- }),
3887
- /**
3888
- * Custom client-side validator. The provided function is serialised and executed
3889
- * just-in-time on the client only. External references (e.g. lodash) are not
3890
- * available inside the function body — all logic must be self-contained.
3891
- *
3892
- * @example
3893
- * field('nid').customClientValidator((value) => {
3894
- * // LUHN check — all logic must be inline
3895
- * const digits = String(value).split('').map(Number)
3896
- * // ...
3897
- * return isValid
3898
- * })
3899
- */
3900
- customClientValidator(validationFn) {
3901
- const code = validationFn.toString();
3902
- return defineFormConditional({
3903
- type: "object",
3904
- properties: wrapToPath(
3905
- { [fieldId]: { customClientValidator: { code } } },
3906
- this.$$subfield
3907
- ),
3908
- required: [fieldId]
3909
- });
3910
- },
3911
- /**
3912
- * Custom client-side evaluation. Returns a {@link FieldReference} descriptor
3913
- * that can be used as the `value` property or a DATA component entry.
3914
- * The function receives the referenced field's value as the first argument and
3915
- * the full form context as the second; its return value replaces the field reference.
3916
- * The function is serialised and executed just-in-time on the client only.
3917
- * External references (e.g. lodash) are not available inside the function body.
3918
- *
3919
- * For computing a default value without referencing a specific field, use
3920
- * `evaluate(fn)` in the `defaultValue` property instead.
3921
- *
3922
- * @example
3923
- * field('a').customClientEvaluation((aValue, ctx) =>
3924
- * Number(aValue) + Number(ctx.$form.b)
3925
- * )
3926
- */
3927
- customClientEvaluation(computationFn) {
3928
- return {
3929
- $$code: computationFn.toString(),
3930
- $$field: fieldId,
3931
- $$subfield: this.$$subfield
3932
- };
4415
+ ];
4416
+ });
4417
+ data.$form = Object.fromEntries(entries);
4418
+ }
4419
+ const result = validator(data);
4420
+ return result;
4421
+ }
4422
+ function isOnline() {
4423
+ if (typeof window !== "undefined" && typeof navigator !== "undefined") {
4424
+ return navigator.onLine;
4425
+ }
4426
+ return true;
4427
+ }
4428
+
4429
+ // ../commons/src/events/utils.ts
4430
+ var import_date_fns3 = require("date-fns");
4431
+ function ageToDate(age, asOfDate) {
4432
+ const date = plainDateToLocalDate(asOfDate);
4433
+ return PlainDate.parse((0, import_date_fns3.format)((0, import_date_fns3.subYears)(date, age), "yyyy-MM-dd"));
4434
+ }
4435
+ function getDeclarationFields(configuration) {
4436
+ return configuration.declaration.pages.flatMap(({ fields }) => fields);
4437
+ }
4438
+ function isActionConfigType(type) {
4439
+ return actionConfigTypes.has(type);
4440
+ }
4441
+ function getActionConfig({
4442
+ eventConfiguration,
4443
+ actionType,
4444
+ customActionType
4445
+ }) {
4446
+ if (actionType === ActionType.NOTIFY) {
4447
+ return eventConfiguration.actions.find((a) => a.type === ActionType.NOTIFY) ?? eventConfiguration.actions.find((a) => a.type === ActionType.DECLARE);
4448
+ }
4449
+ return eventConfiguration.actions.find((a) => {
4450
+ if (a.type === ActionType.CUSTOM && customActionType) {
4451
+ return a.customActionType === customActionType;
4452
+ }
4453
+ return a.type === actionType;
4454
+ });
4455
+ }
4456
+ var getActionAnnotationFields = (actionConfig) => {
4457
+ if (actionConfig.type === ActionType.REQUEST_CORRECTION) {
4458
+ return actionConfig.correctionForm.pages.flatMap(({ fields }) => fields);
4459
+ }
4460
+ if (actionConfig.type === ActionType.PRINT_CERTIFICATE) {
4461
+ return actionConfig.printForm.pages.flatMap(({ fields }) => fields);
4462
+ }
4463
+ const reviewFields = "review" in actionConfig && actionConfig.review != null ? actionConfig.review.fields : [];
4464
+ const formFields = "form" in actionConfig && actionConfig.form != null ? actionConfig.form : [];
4465
+ return [...reviewFields, ...formFields];
4466
+ };
4467
+ function getAllAnnotationFields(config) {
4468
+ return (0, import_lodash4.flattenDeep)(config.actions.map(getActionAnnotationFields));
4469
+ }
4470
+ function deepMerge(currentDocument, actionDocument) {
4471
+ const currentDocumentClone = (0, import_lodash4.cloneDeep)(currentDocument);
4472
+ return (0, import_lodash4.mergeWith)(
4473
+ (0, import_lodash4.cloneDeep)(currentDocumentClone),
4474
+ actionDocument,
4475
+ (previousValue, incomingValue) => {
4476
+ if (incomingValue === void 0) {
4477
+ return previousValue;
4478
+ }
4479
+ if ((0, import_lodash4.isArray)(incomingValue)) {
4480
+ return incomingValue;
4481
+ }
4482
+ if ((0, import_lodash4.isObject)(previousValue) && (0, import_lodash4.isObject)(incomingValue)) {
4483
+ return void 0;
4484
+ }
4485
+ return incomingValue;
4486
+ }
4487
+ );
4488
+ }
4489
+ var findAllFields = (config) => {
4490
+ return (0, import_lodash4.flattenDeep)([
4491
+ ...getDeclarationFields(config),
4492
+ ...getAllAnnotationFields(config)
4493
+ ]);
4494
+ };
4495
+ function getMixedPath(obj, path, defaultValue) {
4496
+ const parts = path.split(".");
4497
+ const resolve = (current, segments) => {
4498
+ if (current == null || segments.length === 0) {
4499
+ return current;
3933
4500
  }
4501
+ for (let i = segments.length; i > 0; i--) {
4502
+ const compoundKey = segments.slice(0, i).join(".");
4503
+ if ((0, import_lodash4.has)(current, compoundKey)) {
4504
+ const next = (0, import_lodash4.get)(current, compoundKey);
4505
+ return resolve(next, segments.slice(i));
4506
+ }
4507
+ }
4508
+ return void 0;
3934
4509
  };
4510
+ const result = resolve(obj, parts);
4511
+ return (0, import_lodash4.isNil)(result) ? defaultValue : result;
4512
+ }
4513
+ function isAcceptedAction(a) {
4514
+ return a.status === ActionStatus.Accepted;
4515
+ }
4516
+ function getCompleteActionAnnotation(event2, action) {
4517
+ if (action.originalActionId) {
4518
+ const originalAction = event2.actions.find(
4519
+ ({ id }) => id === action.originalActionId
4520
+ );
4521
+ if (originalAction?.status === ActionStatus.Requested) {
4522
+ return deepMerge(originalAction.annotation ?? {}, action.annotation ?? {});
4523
+ }
4524
+ }
4525
+ return action.annotation ?? {};
4526
+ }
4527
+ function getCompleteActionDeclaration(declaration, event2, action) {
4528
+ if (action.originalActionId) {
4529
+ const originalAction = event2.actions.find(
4530
+ ({ id }) => id === action.originalActionId
4531
+ );
4532
+ if (originalAction?.status === ActionStatus.Requested) {
4533
+ return deepMerge(
4534
+ deepMerge(declaration, originalAction.declaration),
4535
+ action.declaration
4536
+ );
4537
+ }
4538
+ }
4539
+ return deepMerge(declaration, action.declaration);
4540
+ }
4541
+ function getAcceptedActions(event2) {
4542
+ return event2.actions.filter(isAcceptedAction).map((action) => ({
4543
+ ...action,
4544
+ declaration: getCompleteActionDeclaration({}, event2, action),
4545
+ annotation: getCompleteActionAnnotation(event2, action)
4546
+ }));
4547
+ }
4548
+ var EXCLUDED_ACTIONS = [
4549
+ ActionType.REQUEST_CORRECTION,
4550
+ ActionType.PRINT_CERTIFICATE,
4551
+ ActionType.REJECT_CORRECTION
4552
+ ];
4553
+ function aggregateActionDeclarations(event2) {
4554
+ const allAcceptedActions = getAcceptedActions(event2);
4555
+ const aggregatedActions = allAcceptedActions.filter((a) => !EXCLUDED_ACTIONS.some((type) => type === a.type)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
4556
+ return aggregatedActions.reduce((declaration, action) => {
4557
+ if (action.type === ActionType.APPROVE_CORRECTION) {
4558
+ const requestAction = allAcceptedActions.find(
4559
+ ({ id }) => id === action.requestId
4560
+ );
4561
+ if (!requestAction) {
4562
+ return declaration;
4563
+ }
4564
+ const declarationWithApprovedCorrection = getCompleteActionDeclaration(
4565
+ declaration,
4566
+ event2,
4567
+ requestAction
4568
+ );
4569
+ return getCompleteActionDeclaration(
4570
+ declarationWithApprovedCorrection,
4571
+ event2,
4572
+ action
4573
+ );
4574
+ }
4575
+ return getCompleteActionDeclaration(declaration, event2, action);
4576
+ }, {});
4577
+ }
4578
+ function aggregateActionAnnotations(event2) {
4579
+ return event2.actions.reduce((ann, sortedAction) => {
4580
+ if (!("annotation" in sortedAction) || !sortedAction.annotation) {
4581
+ return ann;
4582
+ }
4583
+ return deepMerge(ann, sortedAction.annotation);
4584
+ }, {});
3935
4585
  }
3936
4586
 
3937
4587
  // ../commons/src/events/eventConfigValidation.ts
@@ -4671,6 +5321,11 @@ var ArchiveActionInput = BaseActionInput.extend(
4671
5321
  content: ReasonContent
4672
5322
  }).shape
4673
5323
  );
5324
+ var UnarchiveActionInput = BaseActionInput.extend(
5325
+ z38.object({
5326
+ type: z38.literal(ActionType.UNARCHIVE).default(ActionType.UNARCHIVE)
5327
+ }).shape
5328
+ );
4674
5329
  var AssignActionInput = BaseActionInput.extend(
4675
5330
  z38.object({
4676
5331
  type: z38.literal(ActionType.ASSIGN),
@@ -4732,6 +5387,7 @@ var ActionInput = z38.discriminatedUnion("type", [
4732
5387
  id: "MarkNotDuplicateActionInput"
4733
5388
  }),
4734
5389
  ArchiveActionInput.meta({ id: "ArchiveActionInput" }),
5390
+ UnarchiveActionInput.meta({ id: "UnarchiveActionInput" }),
4735
5391
  AssignActionInput.meta({ id: "AssignActionInput" }),
4736
5392
  UnassignActionInput.meta({ id: "UnassignActionInput" }),
4737
5393
  PrintCertificateActionInput.meta({ id: "PrintCertificateActionInput" }),
@@ -4772,14 +5428,14 @@ var DraftInput = BaseActionInput.omit({ waitFor: true }).extend({
4772
5428
 
4773
5429
  // ../commons/src/events/EventInput.ts
4774
5430
  var z40 = __toESM(require("zod/v4"));
4775
- var import_uuid10 = require("uuid");
5431
+ var import_uuid11 = require("uuid");
4776
5432
  var EventInput = z40.object({
4777
5433
  transactionId: z40.string(),
4778
5434
  type: z40.string(),
4779
5435
  createdAtLocation: UUID.nullish().describe(
4780
5436
  "Location where the event occurred. Required for system users."
4781
5437
  )
4782
- }).meta({ default: { transactionId: (0, import_uuid10.v4)(), type: "birth" } });
5438
+ }).meta({ default: { transactionId: (0, import_uuid11.v4)(), type: "birth" } });
4783
5439
 
4784
5440
  // ../commons/src/events/EventDocument.ts
4785
5441
  var z41 = __toESM(require("zod/v4"));
@@ -4796,69 +5452,6 @@ var EventDocument = z41.object({
4796
5452
  )
4797
5453
  }).meta({ id: "EventDocument" });
4798
5454
 
4799
- // ../commons/src/events/state/index.ts
4800
- var import_lodash4 = require("lodash");
4801
-
4802
- // ../commons/src/events/state/utils.ts
4803
- var import_lodash2 = require("lodash");
4804
- var updateActions = ActionTypes.extract([
4805
- ActionType.CREATE,
4806
- ActionType.NOTIFY,
4807
- ActionType.EDIT,
4808
- ActionType.DECLARE,
4809
- ActionType.REGISTER,
4810
- ActionType.REJECT,
4811
- ActionType.ARCHIVE,
4812
- ActionType.PRINT_CERTIFICATE,
4813
- ActionType.REQUEST_CORRECTION,
4814
- ActionType.APPROVE_CORRECTION,
4815
- ActionType.REJECT_CORRECTION,
4816
- ActionType.CUSTOM
4817
- ]);
4818
-
4819
- // ../commons/src/events/state/flags.ts
4820
- var import_lodash3 = require("lodash");
4821
- var import_date_fns3 = require("date-fns");
4822
- var INHERENT_FLAG_RULES = [
4823
- {
4824
- flag: InherentFlags.CORRECTION_REQUESTED,
4825
- setOn: [ActionType.REQUEST_CORRECTION],
4826
- resetOn: [ActionType.APPROVE_CORRECTION, ActionType.REJECT_CORRECTION]
4827
- },
4828
- {
4829
- // INCOMPLETE mirrors the NOTIFIED status: set by NOTIFY, cleared by any
4830
- // other status-changing action (see getStatusFromActions).
4831
- flag: InherentFlags.INCOMPLETE,
4832
- setOn: [ActionType.NOTIFY],
4833
- resetOn: [
4834
- ActionType.CREATE,
4835
- ActionType.DECLARE,
4836
- ActionType.REGISTER,
4837
- ActionType.ARCHIVE
4838
- ]
4839
- },
4840
- {
4841
- flag: InherentFlags.REJECTED,
4842
- setOn: [ActionType.REJECT],
4843
- resetOn: [
4844
- ActionType.NOTIFY,
4845
- ActionType.DECLARE,
4846
- ActionType.EDIT,
4847
- ActionType.REGISTER
4848
- ]
4849
- },
4850
- {
4851
- flag: InherentFlags.POTENTIAL_DUPLICATE,
4852
- setOn: [ActionType.DUPLICATE_DETECTED],
4853
- resetOn: [ActionType.MARK_AS_DUPLICATE, ActionType.MARK_AS_NOT_DUPLICATE]
4854
- },
4855
- {
4856
- flag: InherentFlags.EDIT_IN_PROGRESS,
4857
- setOn: [ActionType.EDIT],
4858
- resetOnAnyOtherAction: true
4859
- }
4860
- ];
4861
-
4862
5455
  // ../commons/src/events/defineConfig.ts
4863
5456
  var IGNORED_EVENT_TYPES = [
4864
5457
  "FOOTBALL_CLUB_MEMBERSHIP",
@@ -7367,6 +7960,7 @@ var ACTION_SCOPE_MAP = {
7367
7960
  [ActionType.MARK_AS_DUPLICATE]: ["record.review-duplicates"],
7368
7961
  [ActionType.MARK_AS_NOT_DUPLICATE]: ["record.review-duplicates"],
7369
7962
  [ActionType.ARCHIVE]: ["record.archive"],
7963
+ [ActionType.UNARCHIVE]: ["record.unarchive"],
7370
7964
  [ActionType.REJECT]: ["record.reject"],
7371
7965
  [ActionType.ASSIGN]: null,
7372
7966
  [ActionType.UNASSIGN]: null,
@@ -7409,7 +8003,11 @@ var AVAILABLE_ACTIONS_BY_EVENT_STATUS = {
7409
8003
  ActionType.CUSTOM,
7410
8004
  ClientSpecificAction.REVIEW_CORRECTION_REQUEST
7411
8005
  ],
7412
- [EventStatus.enum.ARCHIVED]: [ActionType.READ, ActionType.CUSTOM]
8006
+ [EventStatus.enum.ARCHIVED]: [
8007
+ ActionType.READ,
8008
+ ActionType.CUSTOM,
8009
+ ActionType.UNARCHIVE
8010
+ ]
7413
8011
  };
7414
8012
  var ACTION_FILTERS = {
7415
8013
  [ActionType.PRINT_CERTIFICATE]: (flags) => !flags.includes(InherentFlags.CORRECTION_REQUESTED) && !flags.some((flag) => flag.endsWith(":requested")),
@@ -7422,6 +8020,7 @@ var ACTION_FILTERS = {
7422
8020
  [ActionType.REGISTER]: (flags) => !flags.includes(InherentFlags.POTENTIAL_DUPLICATE) && !flags.some((flag) => flag.endsWith(":requested")),
7423
8021
  [ActionType.REJECT]: (flags) => !flags.includes(InherentFlags.REJECTED) && !flags.some((flag) => flag.endsWith(":requested")),
7424
8022
  [ActionType.ARCHIVE]: (flags) => !flags.some((flag) => flag.endsWith(":requested")),
8023
+ [ActionType.UNARCHIVE]: (flags) => !flags.some((flag) => flag.endsWith(":requested")),
7425
8024
  [ActionType.ASSIGN]: (flags) => !flags.some((flag) => flag.endsWith(":requested")),
7426
8025
  [ActionType.UNASSIGN]: (flags) => !flags.some((flag) => flag.endsWith(":requested")),
7427
8026
  [ActionType.CUSTOM]: (flags) => !flags.some((flag) => flag.endsWith(":requested"))