@nira-opencrvs/toolkit 1.9.13-rc.cdfd84c → 1.9.13-rc.ce5957d

package/dist/notification/index.js

@@ -50,7 +50,7 @@ var TENNIS_CLUB_MEMBERSHIP = "tennis-club-membership";
 var BIRTH_EVENT = "birth";
 
 // ../commons/src/events/ActionConfig.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 
 // ../commons/src/events/TranslationConfig.ts
 var import_zod = require("zod");
@@ -173,7 +173,7 @@ var META_ACTIONS = [
 ];
 
 // ../commons/src/events/FieldConfig.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 
 // ../commons/src/events/Conditional.ts
 var import_zod3 = require("zod");
@@ -269,7 +269,8 @@ var FieldType = {
   QUERY_PARAM_READER: "QUERY_PARAM_READER",
   QR_READER: "QR_READER",
   ID_READER: "ID_READER",
-  LOADER: "LOADER"
+  LOADER: "LOADER",
+  ICD11: "ICD11"
 };
 var FileFieldType = import_zod4.z.enum([
   FieldType.FILE,
@@ -299,7 +300,7 @@ var FieldTypesToHideInReview = [
 ];
 
 // ../commons/src/events/FieldValue.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 
 // ../commons/src/documents.ts
 var import_zod5 = require("zod");
@@ -408,44 +409,55 @@ var NumberWithUnitFieldUpdateValue = import_zod6.z.object({
   unit: import_zod6.z.string().optional()
 });
 
-// ../commons/src/events/PlainDate.ts
+// ../commons/src/events/Icd11.ts
 var import_zod7 = require("zod");
-var PlainDate = import_zod7.z.string().date().brand("PlainDate").describe("Date in the format YYYY-MM-DD");
+var Icd11FieldValue = import_zod7.z.object({
+  code: import_zod7.z.string(),
+  label: import_zod7.z.string()
+});
+var Icd11FieldUpdateValue = import_zod7.z.object({
+  code: import_zod7.z.string().optional(),
+  label: import_zod7.z.string().optional()
+});
+
+// ../commons/src/events/PlainDate.ts
+var import_zod8 = require("zod");
+var PlainDate = import_zod8.z.string().date().brand("PlainDate").describe("Date in the format YYYY-MM-DD");
 
 // ../commons/src/events/FieldValue.ts
-var TextValue = import_zod8.z.string();
+var TextValue = import_zod9.z.string();
 var NonEmptyTextValue = TextValue.min(1);
-var AgeValue = import_zod8.z.object({
-  age: import_zod8.z.number(),
-  asOfDateRef: import_zod8.z.string()
+var AgeValue = import_zod9.z.object({
+  age: import_zod9.z.number(),
+  asOfDateRef: import_zod9.z.string()
 });
 var AgeUpdateValue = AgeValue.optional().nullable();
-var TimeValue = import_zod8.z.string().regex(/^([01][0-9]|2[0-3]):[0-5][0-9]$/);
-var DatetimeValue = import_zod8.z.string().datetime();
-var SelectDateRangeValue = import_zod8.z.enum([
+var TimeValue = import_zod9.z.string().regex(/^([01][0-9]|2[0-3]):[0-5][0-9]$/);
+var DatetimeValue = import_zod9.z.string().datetime();
+var SelectDateRangeValue = import_zod9.z.enum([
   "last7Days",
   "last30Days",
   "last90Days",
   "last365Days"
 ]);
-var DateRangeFieldValue = import_zod8.z.object({
+var DateRangeFieldValue = import_zod9.z.object({
   start: PlainDate,
   end: PlainDate
 }).or(PlainDate).describe(
   "Date range with start and end dates in the format YYYY-MM-DD. Inclusive start, exclusive end."
 );
-var EmailValue = import_zod8.z.string().email();
-var CheckboxFieldValue = import_zod8.z.boolean();
-var NumberFieldValue = import_zod8.z.number();
-var SignatureFieldValue = import_zod8.z.string();
-var ButtonFieldValue = import_zod8.z.number();
-var VerificationStatusValue = import_zod8.z.enum([
+var EmailValue = import_zod9.z.string().email();
+var CheckboxFieldValue = import_zod9.z.boolean();
+var NumberFieldValue = import_zod9.z.number();
+var SignatureFieldValue = import_zod9.z.string();
+var ButtonFieldValue = import_zod9.z.number();
+var VerificationStatusValue = import_zod9.z.enum([
   "verified",
   "authenticated",
   "failed",
   "pending"
 ]);
-var LeafFieldValues = import_zod8.z.union([
+var LeafFieldValues = import_zod9.z.union([
   AddressFieldValue,
   TextValue,
   PlainDate,
@@ -466,13 +478,15 @@ var LeafFieldValues = import_zod8.z.union([
   QrReaderFieldValue,
   IdReaderFieldValue,
   NumberWithUnitFieldValue,
-  NumberWithUnitFieldUpdateValue
+  NumberWithUnitFieldUpdateValue,
+  Icd11FieldValue,
+  Icd11FieldUpdateValue
 ]);
-var FieldGroupValue = import_zod8.z.record(import_zod8.z.string(), LeafFieldValues);
-var DataFieldValue = import_zod8.z.object({
-  data: import_zod8.z.record(import_zod8.z.string(), LeafFieldValues)
+var FieldGroupValue = import_zod9.z.record(import_zod9.z.string(), LeafFieldValues);
+var DataFieldValue = import_zod9.z.object({
+  data: import_zod9.z.record(import_zod9.z.string(), LeafFieldValues)
 }).nullish();
-var FieldValue = import_zod8.z.union([
+var FieldValue = import_zod9.z.union([
   LeafFieldValues,
   DataFieldValue,
   FieldGroupValue
@@ -500,7 +514,7 @@ function schemaPriority(schema) {
   return idx === -1 ? 9999 : idx;
 }
 function safeUnion(schemas) {
-  return import_zod8.z.custom((val) => {
+  return import_zod9.z.custom((val) => {
     const successful = schemas.filter((s) => s.safeParse(val).success);
     if (successful.length === 1) {
       return true;
@@ -530,7 +544,8 @@ var FieldUpdateValue = safeUnion([
   FieldGroupValue.describe("GroupFieldValue"),
   NameFieldUpdateValue.describe("NameFieldUpdateValue"),
   HttpFieldUpdateValue.describe("HttpFieldUpdateValue"),
-  QueryParamReaderFieldUpdateValue.describe("QueryParamReaderFieldUpdateValue")
+  QueryParamReaderFieldUpdateValue.describe("QueryParamReaderFieldUpdateValue"),
+  Icd11FieldUpdateValue.describe("Icd11FieldUpdateValue")
 ]);
 
 // ../commons/src/events/FieldConfig.ts
@@ -538,16 +553,16 @@ var import_zod_openapi6 = require("zod-openapi");
 
 // ../commons/src/uuid.ts
 var import_uuid = require("uuid");
-var import_zod9 = require("zod");
-var UUID = import_zod9.z.string().uuid().brand("UUID");
+var import_zod10 = require("zod");
+var UUID = import_zod10.z.string().uuid().brand("UUID");
 function getUUID() {
   return (0, import_uuid.v4)();
 }
 
 // ../commons/src/events/serializers/user/serializer.ts
-var import_zod10 = require("zod");
-var SerializedUserField = import_zod10.z.object({
-  $userField: import_zod10.z.enum([
+var import_zod11 = require("zod");
+var SerializedUserField = import_zod11.z.object({
+  $userField: import_zod11.z.enum([
     "id",
     "name",
     "role",
@@ -562,7 +577,7 @@ var SerializedUserField = import_zod10.z.object({
     "mobile",
     "email"
   ]),
-  $location: import_zod10.z.string().optional()
+  $location: import_zod11.z.string().optional()
 });
 function userSerializer(userField) {
   return {
@@ -580,8 +595,8 @@ function userSerializer(userField) {
     }
   };
 }
-var SerializedUserDataField = import_zod10.z.object({
-  $userDataField: import_zod10.z.string()
+var SerializedUserDataField = import_zod11.z.object({
+  $userDataField: import_zod11.z.string()
 });
 function userDataSerializer(key) {
   return {
@@ -593,13 +608,13 @@ function userDataSerializer(key) {
 }
 
 // ../commons/src/events/EventIndex.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 
 // ../commons/src/events/EventMetadata.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 
 // ../commons/src/events/ActionDocument.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 var import_zod_openapi4 = require("zod-openapi");
 
 // ../commons/src/events/CreatedAtLocation.ts
@@ -607,10 +622,10 @@ var CreatedAtLocation = UUID.nullish();
 
 // ../commons/src/authentication.ts
 var import_jwt_decode = __toESM(require("jwt-decode"));
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 
 // ../commons/src/scopes.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var SCOPES = {
   // TODO v1.8 legacy scopes
   BYPASSRATELIMIT: "bypassratelimit",
@@ -689,91 +704,91 @@ var SCOPES = {
   // data seeding
   USER_DATA_SEEDING: "user.data-seeding"
 };
-var LegacyScopes = import_zod11.z.union([
-  import_zod11.z.literal(SCOPES.BYPASSRATELIMIT),
-  import_zod11.z.literal(SCOPES.REGISTER),
-  import_zod11.z.literal(SCOPES.DEMO),
-  import_zod11.z.literal(SCOPES.CONFIG)
+var LegacyScopes = import_zod12.z.union([
+  import_zod12.z.literal(SCOPES.BYPASSRATELIMIT),
+  import_zod12.z.literal(SCOPES.REGISTER),
+  import_zod12.z.literal(SCOPES.DEMO),
+  import_zod12.z.literal(SCOPES.CONFIG)
 ]);
-var IntegrationScopes = import_zod11.z.union([
-  import_zod11.z.literal(SCOPES.WEBHOOK),
-  import_zod11.z.literal(SCOPES.NATIONALID),
-  import_zod11.z.literal(SCOPES.NOTIFICATION_API),
-  import_zod11.z.literal(SCOPES.RECORDSEARCH)
+var IntegrationScopes = import_zod12.z.union([
+  import_zod12.z.literal(SCOPES.WEBHOOK),
+  import_zod12.z.literal(SCOPES.NATIONALID),
+  import_zod12.z.literal(SCOPES.NOTIFICATION_API),
+  import_zod12.z.literal(SCOPES.RECORDSEARCH)
 ]);
-var InternalOperationsScopes = import_zod11.z.union([
-  import_zod11.z.literal(SCOPES.RECORD_REINDEX),
-  import_zod11.z.literal(SCOPES.RECORD_IMPORT)
+var InternalOperationsScopes = import_zod12.z.union([
+  import_zod12.z.literal(SCOPES.RECORD_REINDEX),
+  import_zod12.z.literal(SCOPES.RECORD_IMPORT)
 ]);
-var DeclareScopes = import_zod11.z.union([
-  import_zod11.z.literal(SCOPES.RECORD_DECLARE_BIRTH),
-  import_zod11.z.literal(SCOPES.RECORD_DECLARE_BIRTH_MY_JURISDICTION),
-  import_zod11.z.literal(SCOPES.RECORD_DECLARE_DEATH),
-  import_zod11.z.literal(SCOPES.RECORD_DECLARE_DEATH_MY_JURISDICTION),
-  import_zod11.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE),
-  import_zod11.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE_MY_JURISDICTION),
-  import_zod11.z.literal(SCOPES.RECORD_SUBMIT_INCOMPLETE),
-  import_zod11.z.literal(SCOPES.RECORD_SUBMIT_FOR_REVIEW)
+var DeclareScopes = import_zod12.z.union([
+  import_zod12.z.literal(SCOPES.RECORD_DECLARE_BIRTH),
+  import_zod12.z.literal(SCOPES.RECORD_DECLARE_BIRTH_MY_JURISDICTION),
+  import_zod12.z.literal(SCOPES.RECORD_DECLARE_DEATH),
+  import_zod12.z.literal(SCOPES.RECORD_DECLARE_DEATH_MY_JURISDICTION),
+  import_zod12.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE),
+  import_zod12.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE_MY_JURISDICTION),
+  import_zod12.z.literal(SCOPES.RECORD_SUBMIT_INCOMPLETE),
+  import_zod12.z.literal(SCOPES.RECORD_SUBMIT_FOR_REVIEW)
 ]);
-var UnassignScope = import_zod11.z.literal(SCOPES.RECORD_UNASSIGN_OTHERS);
-var ValidateScopes = import_zod11.z.union([
-  import_zod11.z.literal(SCOPES.RECORD_SUBMIT_FOR_APPROVAL),
-  import_zod11.z.literal(SCOPES.RECORD_SUBMIT_FOR_UPDATES),
-  import_zod11.z.literal(SCOPES.RECORD_DECLARATION_EDIT),
-  import_zod11.z.literal(SCOPES.RECORD_REVIEW_DUPLICATES),
-  import_zod11.z.literal(SCOPES.RECORD_DECLARATION_ARCHIVE),
-  import_zod11.z.literal(SCOPES.RECORD_DECLARATION_REINSTATE)
+var UnassignScope = import_zod12.z.literal(SCOPES.RECORD_UNASSIGN_OTHERS);
+var ValidateScopes = import_zod12.z.union([
+  import_zod12.z.literal(SCOPES.RECORD_SUBMIT_FOR_APPROVAL),
+  import_zod12.z.literal(SCOPES.RECORD_SUBMIT_FOR_UPDATES),
+  import_zod12.z.literal(SCOPES.RECORD_DECLARATION_EDIT),
+  import_zod12.z.literal(SCOPES.RECORD_REVIEW_DUPLICATES),
+  import_zod12.z.literal(SCOPES.RECORD_DECLARATION_ARCHIVE),
+  import_zod12.z.literal(SCOPES.RECORD_DECLARATION_REINSTATE)
 ]);
-var RegisterScope = import_zod11.z.literal(SCOPES.RECORD_REGISTER);
-var CorrectionScopes = import_zod11.z.union([
-  import_zod11.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_CORRECTION),
-  import_zod11.z.literal(SCOPES.RECORD_REGISTRATION_CORRECT),
-  import_zod11.z.literal(SCOPES.RECORD_CONFIRM_REGISTRATION),
-  import_zod11.z.literal(SCOPES.RECORD_REJECT_REGISTRATION)
+var RegisterScope = import_zod12.z.literal(SCOPES.RECORD_REGISTER);
+var CorrectionScopes = import_zod12.z.union([
+  import_zod12.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_CORRECTION),
+  import_zod12.z.literal(SCOPES.RECORD_REGISTRATION_CORRECT),
+  import_zod12.z.literal(SCOPES.RECORD_CONFIRM_REGISTRATION),
+  import_zod12.z.literal(SCOPES.RECORD_REJECT_REGISTRATION)
 ]);
-var SearchScopes = import_zod11.z.union([
-  import_zod11.z.literal(SCOPES.SEARCH_BIRTH_MY_JURISDICTION),
-  import_zod11.z.literal(SCOPES.SEARCH_BIRTH),
-  import_zod11.z.literal(SCOPES.SEARCH_DEATH_MY_JURISDICTION),
-  import_zod11.z.literal(SCOPES.SEARCH_DEATH),
-  import_zod11.z.literal(SCOPES.SEARCH_MARRIAGE_MY_JURISDICTION),
-  import_zod11.z.literal(SCOPES.SEARCH_MARRIAGE)
+var SearchScopes = import_zod12.z.union([
+  import_zod12.z.literal(SCOPES.SEARCH_BIRTH_MY_JURISDICTION),
+  import_zod12.z.literal(SCOPES.SEARCH_BIRTH),
+  import_zod12.z.literal(SCOPES.SEARCH_DEATH_MY_JURISDICTION),
+  import_zod12.z.literal(SCOPES.SEARCH_DEATH),
+  import_zod12.z.literal(SCOPES.SEARCH_MARRIAGE_MY_JURISDICTION),
+  import_zod12.z.literal(SCOPES.SEARCH_MARRIAGE)
 ]);
-var AuditScopes = import_zod11.z.literal(SCOPES.RECORD_READ);
-var PerformanceScopes = import_zod11.z.union([
-  import_zod11.z.literal(SCOPES.PERFORMANCE_READ),
-  import_zod11.z.literal(SCOPES.PERFORMANCE_READ_DASHBOARDS),
-  import_zod11.z.literal(SCOPES.PERFORMANCE_EXPORT_VITAL_STATISTICS)
+var AuditScopes = import_zod12.z.literal(SCOPES.RECORD_READ);
+var PerformanceScopes = import_zod12.z.union([
+  import_zod12.z.literal(SCOPES.PERFORMANCE_READ),
+  import_zod12.z.literal(SCOPES.PERFORMANCE_READ_DASHBOARDS),
+  import_zod12.z.literal(SCOPES.PERFORMANCE_EXPORT_VITAL_STATISTICS)
 ]);
-var OrganisationScopes = import_zod11.z.union([
-  import_zod11.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS),
-  import_zod11.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_OFFICE),
-  import_zod11.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_JURISDICTION)
+var OrganisationScopes = import_zod12.z.union([
+  import_zod12.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS),
+  import_zod12.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_OFFICE),
+  import_zod12.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_JURISDICTION)
 ]);
-var UserScopes = import_zod11.z.union([
-  import_zod11.z.literal(SCOPES.USER_READ),
-  import_zod11.z.literal(SCOPES.USER_READ_MY_OFFICE),
-  import_zod11.z.literal(SCOPES.USER_READ_MY_JURISDICTION),
-  import_zod11.z.literal(SCOPES.USER_READ_ONLY_MY_AUDIT),
-  import_zod11.z.literal(SCOPES.USER_CREATE),
-  import_zod11.z.literal(SCOPES.USER_CREATE_MY_JURISDICTION),
-  import_zod11.z.literal(SCOPES.USER_UPDATE),
-  import_zod11.z.literal(SCOPES.USER_UPDATE_MY_JURISDICTION)
+var UserScopes = import_zod12.z.union([
+  import_zod12.z.literal(SCOPES.USER_READ),
+  import_zod12.z.literal(SCOPES.USER_READ_MY_OFFICE),
+  import_zod12.z.literal(SCOPES.USER_READ_MY_JURISDICTION),
+  import_zod12.z.literal(SCOPES.USER_READ_ONLY_MY_AUDIT),
+  import_zod12.z.literal(SCOPES.USER_CREATE),
+  import_zod12.z.literal(SCOPES.USER_CREATE_MY_JURISDICTION),
+  import_zod12.z.literal(SCOPES.USER_UPDATE),
+  import_zod12.z.literal(SCOPES.USER_UPDATE_MY_JURISDICTION)
 ]);
-var ConfigScope = import_zod11.z.literal(SCOPES.CONFIG_UPDATE_ALL);
-var DataSeedingScope = import_zod11.z.literal(SCOPES.USER_DATA_SEEDING);
-var LiteralScopes = import_zod11.z.union([
+var ConfigScope = import_zod12.z.literal(SCOPES.CONFIG_UPDATE_ALL);
+var DataSeedingScope = import_zod12.z.literal(SCOPES.USER_DATA_SEEDING);
+var LiteralScopes = import_zod12.z.union([
   LegacyScopes,
   IntegrationScopes,
   UnassignScope,
   DeclareScopes,
   ValidateScopes,
   RegisterScope,
-  import_zod11.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
+  import_zod12.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
   CorrectionScopes,
   SearchScopes,
   AuditScopes,
-  import_zod11.z.literal(SCOPES.PROFILE_ELECTRONIC_SIGNATURE),
+  import_zod12.z.literal(SCOPES.PROFILE_ELECTRONIC_SIGNATURE),
   PerformanceScopes,
   OrganisationScopes,
   UserScopes,
@@ -782,42 +797,42 @@ var LiteralScopes = import_zod11.z.union([
   InternalOperationsScopes
 ]);
 var rawConfigurableScopeRegex = /^([a-zA-Z][a-zA-Z0-9.-]*(?:\.[a-zA-Z0-9.-]+)*)\[((?:\w+=[\w.-]+(?:\|[\w.-]+)*)(?:,[\w]+=[\w.-]+(?:\|[\w.-]+)*)*)\]$/;
-var rawConfigurableScope = import_zod11.z.string().regex(rawConfigurableScopeRegex);
-var CreateUserScope = import_zod11.z.object({
-  type: import_zod11.z.literal("user.create"),
-  options: import_zod11.z.object({
-    role: import_zod11.z.array(import_zod11.z.string())
+var rawConfigurableScope = import_zod12.z.string().regex(rawConfigurableScopeRegex);
+var CreateUserScope = import_zod12.z.object({
+  type: import_zod12.z.literal("user.create"),
+  options: import_zod12.z.object({
+    role: import_zod12.z.array(import_zod12.z.string())
   })
 });
-var EditUserScope = import_zod11.z.object({
-  type: import_zod11.z.literal("user.edit"),
-  options: import_zod11.z.object({
-    role: import_zod11.z.array(import_zod11.z.string())
+var EditUserScope = import_zod12.z.object({
+  type: import_zod12.z.literal("user.edit"),
+  options: import_zod12.z.object({
+    role: import_zod12.z.array(import_zod12.z.string())
   })
 });
-var WorkqueueScope = import_zod11.z.object({
-  type: import_zod11.z.literal("workqueue"),
-  options: import_zod11.z.object({
-    id: import_zod11.z.array(import_zod11.z.string())
+var WorkqueueScope = import_zod12.z.object({
+  type: import_zod12.z.literal("workqueue"),
+  options: import_zod12.z.object({
+    id: import_zod12.z.array(import_zod12.z.string())
   })
 });
-var SearchScope = import_zod11.z.object({
-  type: import_zod11.z.literal("search"),
-  options: import_zod11.z.object({
-    event: import_zod11.z.array(import_zod11.z.string()).length(1),
-    access: import_zod11.z.array(import_zod11.z.enum(["my-jurisdiction", "all"])).length(1)
+var SearchScope = import_zod12.z.object({
+  type: import_zod12.z.literal("search"),
+  options: import_zod12.z.object({
+    event: import_zod12.z.array(import_zod12.z.string()).length(1),
+    access: import_zod12.z.array(import_zod12.z.enum(["my-jurisdiction", "all"])).length(1)
   })
 });
-var PrintCertifiedCopiesScope = import_zod11.z.object({
-  type: import_zod11.z.literal("record.registered.print-certified-copies"),
-  options: import_zod11.z.object({
-    event: import_zod11.z.array(import_zod11.z.string()).describe("Event type, e.g. birth, death"),
-    templates: import_zod11.z.array(import_zod11.z.string()).optional().describe(
+var PrintCertifiedCopiesScope = import_zod12.z.object({
+  type: import_zod12.z.literal("record.registered.print-certified-copies"),
+  options: import_zod12.z.object({
+    event: import_zod12.z.array(import_zod12.z.string()).describe("Event type, e.g. birth, death"),
+    templates: import_zod12.z.array(import_zod12.z.string()).optional().describe(
       "Template IDs for certified copies. If not provided, all templates will be used."
     )
   })
 });
-var RecordScopeType = import_zod11.z.enum([
+var RecordScopeType = import_zod12.z.enum([
   "record.create",
   "record.read",
   "record.declare",
@@ -831,15 +846,15 @@ var RecordScopeType = import_zod11.z.enum([
   "record.registered.correct",
   "record.unassign-others"
 ]);
-var RecordScope = import_zod11.z.object({
+var RecordScope = import_zod12.z.object({
   type: RecordScopeType,
-  options: import_zod11.z.object({
-    event: import_zod11.z.array(import_zod11.z.string()).describe("Event type, e.g. birth, death")
+  options: import_zod12.z.object({
+    event: import_zod12.z.array(import_zod12.z.string()).describe("Event type, e.g. birth, death")
   })
 }).describe(
   "Scopes used to check user's permission to perform actions on a record."
 );
-var ConfigurableRawScopes = import_zod11.z.discriminatedUnion("type", [
+var ConfigurableRawScopes = import_zod12.z.discriminatedUnion("type", [
   SearchScope,
   PrintCertifiedCopiesScope,
   CreateUserScope,
@@ -848,11 +863,11 @@ var ConfigurableRawScopes = import_zod11.z.discriminatedUnion("type", [
   RecordScope
 ]);
 var scopes = Object.values(SCOPES);
-var ActionScopes = import_zod11.z.union([
+var ActionScopes = import_zod12.z.union([
   DeclareScopes,
   ValidateScopes,
   RegisterScope,
-  import_zod11.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
+  import_zod12.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
   CorrectionScopes
 ]);
 
@@ -986,15 +1001,15 @@ var DEFAULT_ROLES_DEFINITION = [
     ]
   }
 ];
-var TokenUserType = import_zod12.z.enum(["user", "system"]);
-var TokenWithBearer = import_zod12.z.string().regex(/^Bearer\s/);
+var TokenUserType = import_zod13.z.enum(["user", "system"]);
+var TokenWithBearer = import_zod13.z.string().regex(/^Bearer\s/);
 
 // ../commons/src/events/ActionDocument.ts
-(0, import_zod_openapi4.extendZodWithOpenApi)(import_zod13.z);
-var ActionUpdate = import_zod13.z.record(import_zod13.z.string(), FieldUpdateValue).describe(
+(0, import_zod_openapi4.extendZodWithOpenApi)(import_zod14.z);
+var ActionUpdate = import_zod14.z.record(import_zod14.z.string(), FieldUpdateValue).describe(
   "Record of field-level changes made by an action. Supports partial updates and nullable values."
 );
-var EventState = import_zod13.z.record(import_zod13.z.string(), FieldValue).describe(
+var EventState = import_zod14.z.record(import_zod14.z.string(), FieldValue).describe(
   "Aggregate representation of event data after all actions have been applied, with all updates consolidated and null values removed."
 );
 var ActionStatus = {
@@ -1002,16 +1017,16 @@ var ActionStatus = {
   Accepted: "Accepted",
   Rejected: "Rejected"
 };
-var ActionBase = import_zod13.z.object({
+var ActionBase = import_zod14.z.object({
   id: UUID.describe("Unique identifier of the action."),
-  transactionId: import_zod13.z.string().describe("Unique identifier of the transaction."),
+  transactionId: import_zod14.z.string().describe("Unique identifier of the transaction."),
   createdByUserType: TokenUserType.describe(
     "Indicates whether the action was created by a human-user or by a system-user."
   ),
-  createdAt: import_zod13.z.string().datetime().describe("Timestamp indicating when the action was created."),
-  createdBy: import_zod13.z.string().describe("Identifier of the user who created the action."),
-  createdByRole: import_zod13.z.string().describe("Role of the user who created the action."),
-  createdBySignature: import_zod13.z.string().nullish().describe("Reference to the signature of the user who created the action."),
+  createdAt: import_zod14.z.string().datetime().describe("Timestamp indicating when the action was created."),
+  createdBy: import_zod14.z.string().describe("Identifier of the user who created the action."),
+  createdByRole: import_zod14.z.string().describe("Role of the user who created the action."),
+  createdBySignature: import_zod14.z.string().nullish().describe("Reference to the signature of the user who created the action."),
   createdAtLocation: CreatedAtLocation.describe(
     "Reference to the location of the user who created the action."
   ),
@@ -1019,7 +1034,7 @@ var ActionBase = import_zod13.z.object({
     "Declaration data defined by the ActionConfig. Supports partial updates."
   ),
   annotation: ActionUpdate.optional().nullable().describe("Action-specific metadata used to annotate the event."),
-  status: import_zod13.z.enum([
+  status: import_zod14.z.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
@@ -1031,129 +1046,129 @@ var ActionBase = import_zod13.z.object({
   )
 });
 var AssignedAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod13.z.string().describe("Identifier of the user to whom the action is assigned.")
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.ASSIGN),
+    assignedTo: import_zod14.z.string().describe("Identifier of the user to whom the action is assigned.")
     // TODO move into 'content' property
   })
 );
 var UnassignedAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.UNASSIGN)
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.UNASSIGN)
   })
 );
 var RegisterAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.REGISTER),
-    registrationNumber: import_zod13.z.string().optional().describe(
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.REGISTER),
+    registrationNumber: import_zod14.z.string().optional().describe(
       "Registration number of the event. Always present for accepted registrations."
     )
     // TODO move into 'content' property
   })
 );
 var DeclareAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.DECLARE)
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.DECLARE)
   })
 );
 var ValidateAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.VALIDATE)
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.VALIDATE)
   })
 );
-var ReasonContent = import_zod13.z.object({
-  reason: import_zod13.z.string().min(1, { message: "Message cannot be empty" }).describe(
+var ReasonContent = import_zod14.z.object({
+  reason: import_zod14.z.string().min(1, { message: "Message cannot be empty" }).describe(
     "Message describing the reason for rejecting or archiving the event."
   )
 });
 var EscalateAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.ESCALATE),
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.ESCALATE),
     content: ReasonContent
   })
 );
 var RejectAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.REJECT),
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.REJECT),
     content: ReasonContent
   })
 );
-var PotentialDuplicate = import_zod13.z.object({
+var PotentialDuplicate = import_zod14.z.object({
   id: UUID,
-  trackingId: import_zod13.z.string()
+  trackingId: import_zod14.z.string()
 });
 var DuplicateDetectedAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.DUPLICATE_DETECTED),
-    content: import_zod13.z.object({
-      duplicates: import_zod13.z.array(PotentialDuplicate)
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.DUPLICATE_DETECTED),
+    content: import_zod14.z.object({
+      duplicates: import_zod14.z.array(PotentialDuplicate)
     })
   })
 );
 var MarkNotDuplicateAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.MARK_AS_NOT_DUPLICATE)
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.MARK_AS_NOT_DUPLICATE)
   })
 );
 var MarkAsDuplicateAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.MARK_AS_DUPLICATE),
-    content: import_zod13.z.object({
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.MARK_AS_DUPLICATE),
+    content: import_zod14.z.object({
       duplicateOf: UUID
     }).optional()
   })
 );
 var ArchiveAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.ARCHIVE),
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.ARCHIVE),
     content: ReasonContent
   })
 );
 var CreatedAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.CREATE)
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.CREATE)
   })
 );
 var NotifiedAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.NOTIFY)
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.NOTIFY)
   })
 );
-var PrintContent = import_zod13.z.object({
-  templateId: import_zod13.z.string().optional()
+var PrintContent = import_zod14.z.object({
+  templateId: import_zod14.z.string().optional()
 });
 var PrintCertificateAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.PRINT_CERTIFICATE),
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.PRINT_CERTIFICATE),
     content: PrintContent.optional().nullable()
   })
 );
 var RequestedCorrectionAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.REQUEST_CORRECTION)
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.REQUEST_CORRECTION)
   })
 );
 var ApprovedCorrectionAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.APPROVE_CORRECTION),
-    requestId: import_zod13.z.string()
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.APPROVE_CORRECTION),
+    requestId: import_zod14.z.string()
     // TODO move into 'content' property
   })
 );
 var RejectedCorrectionAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.REJECT_CORRECTION),
-    requestId: import_zod13.z.string(),
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.REJECT_CORRECTION),
+    requestId: import_zod14.z.string(),
     // TODO move into 'content' property
     content: ReasonContent
   })
 );
 var ReadAction = ActionBase.merge(
-  import_zod13.z.object({
-    type: import_zod13.z.literal(ActionType.READ)
+  import_zod14.z.object({
+    type: import_zod14.z.literal(ActionType.READ)
   })
 );
-var ActionDocument = import_zod13.z.discriminatedUnion("type", [
+var ActionDocument = import_zod14.z.discriminatedUnion("type", [
   CreatedAction.openapi({ ref: "CreatedAction" }),
   ValidateAction.openapi({ ref: "ValidateAction" }),
   EscalateAction.openapi({ ref: "EscalateAction" }),
@@ -1179,15 +1194,15 @@ var AsyncRejectActionDocument = ActionBase.omit({
   declaration: true,
   annotation: true
 }).merge(
-  import_zod13.z.object({
-    type: import_zod13.z.enum(ConfirmableActions),
-    status: import_zod13.z.literal(ActionStatus.Rejected)
+  import_zod14.z.object({
+    type: import_zod14.z.enum(ConfirmableActions),
+    status: import_zod14.z.literal(ActionStatus.Rejected)
   })
 );
-var Action = import_zod13.z.union([ActionDocument, AsyncRejectActionDocument]);
+var Action = import_zod14.z.union([ActionDocument, AsyncRejectActionDocument]);
 
 // ../commons/src/events/EventMetadata.ts
-var EventStatus = import_zod14.z.enum([
+var EventStatus = import_zod15.z.enum([
   "CREATED",
   "NOTIFIED",
   "DECLARED",
@@ -1203,7 +1218,7 @@ var InherentFlags = {
   POTENTIAL_DUPLICATE: "potential-duplicate",
   ESCALATED: "escalated"
 };
-var ActionFlag = import_zod14.z.string().regex(
+var ActionFlag = import_zod15.z.string().regex(
   new RegExp(
     `^(${Object.values(ActionType).join("|").toLowerCase()}):(${Object.values(
       ActionStatus
@@ -1211,60 +1226,60 @@ var ActionFlag = import_zod14.z.string().regex(
   ),
   "Flag must be in the format ActionType:ActionStatus (lowerCase)"
 );
-var Flag = ActionFlag.or(import_zod14.z.nativeEnum(InherentFlags));
-var ZodDate = import_zod14.z.string().date();
-var ZodDateTime = import_zod14.z.string().datetime();
-var ActionCreationMetadata = import_zod14.z.object({
-  createdAt: import_zod14.z.string().datetime().describe("The timestamp when the action request was created."),
-  createdBy: import_zod14.z.string().describe("ID of the user who created the action request."),
+var Flag = ActionFlag.or(import_zod15.z.nativeEnum(InherentFlags));
+var ZodDate = import_zod15.z.string().date();
+var ZodDateTime = import_zod15.z.string().datetime();
+var ActionCreationMetadata = import_zod15.z.object({
+  createdAt: import_zod15.z.string().datetime().describe("The timestamp when the action request was created."),
+  createdBy: import_zod15.z.string().describe("ID of the user who created the action request."),
   createdAtLocation: CreatedAtLocation.describe(
     "Location of the user who created the action request."
   ),
-  createdByUserType: import_zod14.z.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
-  acceptedAt: import_zod14.z.string().datetime().describe("Timestamp when the action request was accepted."),
-  createdByRole: import_zod14.z.string().describe("Role of the user at the time of action request creation."),
-  createdBySignature: import_zod14.z.string().nullish().describe("Signature of the user who created the action request.")
+  createdByUserType: import_zod15.z.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
+  acceptedAt: import_zod15.z.string().datetime().describe("Timestamp when the action request was accepted."),
+  createdByRole: import_zod15.z.string().describe("Role of the user at the time of action request creation."),
+  createdBySignature: import_zod15.z.string().nullish().describe("Signature of the user who created the action request.")
 });
 var RegistrationCreationMetadata = ActionCreationMetadata.extend({
-  registrationNumber: import_zod14.z.string().describe(
+  registrationNumber: import_zod15.z.string().describe(
     "Registration number of the event. Always present for accepted registrations."
   )
 });
-var LegalStatuses = import_zod14.z.object({
+var LegalStatuses = import_zod15.z.object({
   [EventStatus.enum.DECLARED]: ActionCreationMetadata.nullish(),
   [EventStatus.enum.REGISTERED]: RegistrationCreationMetadata.nullish()
 });
-var EventMetadata = import_zod14.z.object({
+var EventMetadata = import_zod15.z.object({
   id: UUID,
-  type: import_zod14.z.string().describe("The type of event, such as birth, death, or marriage."),
+  type: import_zod15.z.string().describe("The type of event, such as birth, death, or marriage."),
   status: EventStatus,
   legalStatuses: LegalStatuses.describe(
     "Metadata related to the legal registration of the event, such as who registered it and when."
   ),
-  createdAt: import_zod14.z.string().datetime().describe("The timestamp when the event was first created and saved."),
+  createdAt: import_zod15.z.string().datetime().describe("The timestamp when the event was first created and saved."),
   dateOfEvent: ZodDate.nullish(),
-  createdBy: import_zod14.z.string().describe("ID of the user who created the event."),
-  createdByUserType: import_zod14.z.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
-  updatedByUserRole: import_zod14.z.string().describe("Role of the user who last changed the status."),
+  createdBy: import_zod15.z.string().describe("ID of the user who created the event."),
+  createdByUserType: import_zod15.z.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
+  updatedByUserRole: import_zod15.z.string().describe("Role of the user who last changed the status."),
   createdAtLocation: CreatedAtLocation.describe(
     "Location of the user who created the event."
   ),
-  createdBySignature: import_zod14.z.string().nullish().describe("Signature of the user who created the event."),
+  createdBySignature: import_zod15.z.string().nullish().describe("Signature of the user who created the event."),
   updatedAtLocation: UUID.nullish().describe(
     "Location of the user who last changed the status."
   ),
-  updatedAt: import_zod14.z.string().datetime().describe(
+  updatedAt: import_zod15.z.string().datetime().describe(
     "Timestamp of the most recent *accepted* status change. Possibly 3rd party update, if action is validation asynchronously."
   ),
-  assignedTo: import_zod14.z.string().nullish().describe("ID of the user currently assigned to the event."),
-  updatedBy: import_zod14.z.string().nullish().describe("ID of the user who last changed the status."),
-  trackingId: import_zod14.z.string().describe(
+  assignedTo: import_zod15.z.string().nullish().describe("ID of the user currently assigned to the event."),
+  updatedBy: import_zod15.z.string().nullish().describe("ID of the user who last changed the status."),
+  trackingId: import_zod15.z.string().describe(
     "System-generated tracking ID used by informants or registrars to look up the event."
   ),
-  potentialDuplicates: import_zod14.z.array(PotentialDuplicate).describe(
+  potentialDuplicates: import_zod15.z.array(PotentialDuplicate).describe(
     "List of event IDs and their tracking IDs that this event could be a duplicate of."
   ),
-  flags: import_zod14.z.array(Flag)
+  flags: import_zod15.z.array(Flag)
 });
 var EventMetadataKeysArray = [
   "id",
@@ -1284,8 +1299,8 @@ var EventMetadataKeysArray = [
   "legalStatuses",
   "flags"
 ];
-var EventMetadataKeys = import_zod14.z.enum(EventMetadataKeysArray);
-var EventMetadataDateFieldIdInput = import_zod14.z.enum([
+var EventMetadataKeys = import_zod15.z.enum(EventMetadataKeysArray);
+var EventMetadataDateFieldIdInput = import_zod15.z.enum([
   "createdAt",
   "updatedAt",
   "legalStatuses.DECLARED.createdAt",
@@ -1293,7 +1308,7 @@ var EventMetadataDateFieldIdInput = import_zod14.z.enum([
   "legalStatuses.REGISTERED.createdAt",
   "legalStatuses.REGISTERED.acceptedAt"
 ]);
-var EventMetadataDateFieldId = import_zod14.z.enum([
+var EventMetadataDateFieldId = import_zod15.z.enum([
   "event.createdAt",
   "event.updatedAt",
   "event.legalStatuses.DECLARED.createdAt",
@@ -1304,116 +1319,116 @@ var EventMetadataDateFieldId = import_zod14.z.enum([
 
 // ../commons/src/events/EventIndex.ts
 var import_zod_openapi5 = require("zod-openapi");
-(0, import_zod_openapi5.extendZodWithOpenApi)(import_zod15.z);
+(0, import_zod_openapi5.extendZodWithOpenApi)(import_zod16.z);
 var EventIndex = EventMetadata.extend({
   declaration: EventState
 }).openapi({
   ref: "EventIndex"
 });
-var EventSearchIndex = import_zod15.z.record(import_zod15.z.string(), import_zod15.z.any()).and(
-  import_zod15.z.object({
-    type: import_zod15.z.string()
+var EventSearchIndex = import_zod16.z.record(import_zod16.z.string(), import_zod16.z.any()).and(
+  import_zod16.z.object({
+    type: import_zod16.z.string()
     // Ensures "type" (event-id) exists and is a string
   })
 ).openapi({
   ref: "EventSearchIndex"
 });
-var Fuzzy = import_zod15.z.object({ type: import_zod15.z.literal("fuzzy"), term: import_zod15.z.string() }).openapi({
+var Fuzzy = import_zod16.z.object({ type: import_zod16.z.literal("fuzzy"), term: import_zod16.z.string() }).openapi({
   ref: "Fuzzy"
 });
-var Exact = import_zod15.z.object({ type: import_zod15.z.literal("exact"), term: import_zod15.z.string() }).openapi({
+var Exact = import_zod16.z.object({ type: import_zod16.z.literal("exact"), term: import_zod16.z.string() }).openapi({
   ref: "Exact"
 });
-var ExactStatus = import_zod15.z.object({
-  type: import_zod15.z.literal("exact"),
+var ExactStatus = import_zod16.z.object({
+  type: import_zod16.z.literal("exact"),
   term: EventStatus
 }).openapi({
   ref: "ExactStatus"
 });
-var ExactUserType = import_zod15.z.object({
-  type: import_zod15.z.literal("exact"),
+var ExactUserType = import_zod16.z.object({
+  type: import_zod16.z.literal("exact"),
   term: TokenUserType
 }).openapi({
   ref: "ExactUserType"
 });
-var AnyOf = import_zod15.z.object({
-  type: import_zod15.z.literal("anyOf"),
-  terms: import_zod15.z.array(import_zod15.z.string())
+var AnyOf = import_zod16.z.object({
+  type: import_zod16.z.literal("anyOf"),
+  terms: import_zod16.z.array(import_zod16.z.string())
 }).openapi({
   ref: "AnyOf"
 });
-var AnyOfStatus = import_zod15.z.object({
-  type: import_zod15.z.literal("anyOf"),
-  terms: import_zod15.z.array(EventStatus)
+var AnyOfStatus = import_zod16.z.object({
+  type: import_zod16.z.literal("anyOf"),
+  terms: import_zod16.z.array(EventStatus)
 }).openapi({
   ref: "AnyOfStatus"
 });
-var Range = import_zod15.z.object({
-  type: import_zod15.z.literal("range"),
-  gte: import_zod15.z.string(),
-  lte: import_zod15.z.string()
+var Range = import_zod16.z.object({
+  type: import_zod16.z.literal("range"),
+  gte: import_zod16.z.string(),
+  lte: import_zod16.z.string()
 }).openapi({
   ref: "Range"
 });
-var ContainsFlags = import_zod15.z.object({
-  anyOf: import_zod15.z.array(Flag).optional(),
-  noneOf: import_zod15.z.array(Flag).optional()
+var ContainsFlags = import_zod16.z.object({
+  anyOf: import_zod16.z.array(Flag).optional(),
+  noneOf: import_zod16.z.array(Flag).optional()
 }).openapi({
   ref: "ContainsFlags"
 });
-var Within = import_zod15.z.object({ type: import_zod15.z.literal("within"), location: import_zod15.z.string() }).openapi({
+var Within = import_zod16.z.object({ type: import_zod16.z.literal("within"), location: import_zod16.z.string() }).openapi({
   ref: "Within"
 });
-var RangeDate = import_zod15.z.object({
-  type: import_zod15.z.literal("range"),
-  gte: import_zod15.z.string().date().or(import_zod15.z.string().datetime()),
-  lte: import_zod15.z.string().date().or(import_zod15.z.string().datetime())
+var RangeDate = import_zod16.z.object({
+  type: import_zod16.z.literal("range"),
+  gte: import_zod16.z.string().date().or(import_zod16.z.string().datetime()),
+  lte: import_zod16.z.string().date().or(import_zod16.z.string().datetime())
 }).openapi({ ref: "RangeDate" });
 var ExactDate = Exact.extend({
-  term: import_zod15.z.string().date().or(import_zod15.z.string().datetime())
+  term: import_zod16.z.string().date().or(import_zod16.z.string().datetime())
 }).openapi({
   ref: "ExactDate"
 });
-var TimePeriod = import_zod15.z.object({
-  type: import_zod15.z.literal("timePeriod"),
+var TimePeriod = import_zod16.z.object({
+  type: import_zod16.z.literal("timePeriod"),
   term: SelectDateRangeValue
 }).openapi({
   ref: "TimePeriod"
 });
-var DateCondition = import_zod15.z.union([ExactDate, RangeDate, TimePeriod]).openapi({
+var DateCondition = import_zod16.z.union([ExactDate, RangeDate, TimePeriod]).openapi({
   ref: "DateCondition"
 });
-var QueryInput = import_zod15.z.lazy(
-  () => import_zod15.z.union([
-    import_zod15.z.discriminatedUnion("type", [Fuzzy, Exact, Range, Within, AnyOf]),
-    import_zod15.z.record(import_zod15.z.string(), QueryInput)
+var QueryInput = import_zod16.z.lazy(
+  () => import_zod16.z.union([
+    import_zod16.z.discriminatedUnion("type", [Fuzzy, Exact, Range, Within, AnyOf]),
+    import_zod16.z.record(import_zod16.z.string(), QueryInput)
   ])
 ).openapi({
   ref: "QueryInput"
 });
-var QueryExpression = import_zod15.z.object({
-  id: import_zod15.z.optional(import_zod15.z.string()),
-  eventType: import_zod15.z.string(),
-  status: import_zod15.z.optional(import_zod15.z.union([AnyOfStatus, ExactStatus])),
-  createdAt: import_zod15.z.optional(DateCondition),
-  updatedAt: import_zod15.z.optional(DateCondition),
-  "legalStatuses.REGISTERED.acceptedAt": import_zod15.z.optional(DateCondition),
-  "legalStatuses.DECLARED.createdAtLocation": import_zod15.z.optional(
-    import_zod15.z.union([Within, Exact])
+var QueryExpression = import_zod16.z.object({
+  id: import_zod16.z.optional(import_zod16.z.string()),
+  eventType: import_zod16.z.string(),
+  status: import_zod16.z.optional(import_zod16.z.union([AnyOfStatus, ExactStatus])),
+  createdAt: import_zod16.z.optional(DateCondition),
+  updatedAt: import_zod16.z.optional(DateCondition),
+  "legalStatuses.REGISTERED.acceptedAt": import_zod16.z.optional(DateCondition),
+  "legalStatuses.DECLARED.createdAtLocation": import_zod16.z.optional(
+    import_zod16.z.union([Within, Exact])
   ),
-  "legalStatuses.REGISTERED.createdAtLocation": import_zod15.z.optional(
-    import_zod15.z.union([Within, Exact])
+  "legalStatuses.REGISTERED.createdAtLocation": import_zod16.z.optional(
+    import_zod16.z.union([Within, Exact])
   ),
-  "legalStatuses.REGISTERED.registrationNumber": import_zod15.z.optional(Exact),
-  createdAtLocation: import_zod15.z.optional(import_zod15.z.union([Within, Exact])),
-  updatedAtLocation: import_zod15.z.optional(import_zod15.z.union([Within, Exact])),
-  assignedTo: import_zod15.z.optional(Exact),
-  createdByUserType: import_zod15.z.optional(ExactUserType),
-  updatedByUserRole: import_zod15.z.optional(Exact),
-  createdBy: import_zod15.z.optional(Exact),
-  updatedBy: import_zod15.z.optional(Exact),
-  trackingId: import_zod15.z.optional(Exact),
-  flags: import_zod15.z.optional(ContainsFlags),
+  "legalStatuses.REGISTERED.registrationNumber": import_zod16.z.optional(Exact),
+  createdAtLocation: import_zod16.z.optional(import_zod16.z.union([Within, Exact])),
+  updatedAtLocation: import_zod16.z.optional(import_zod16.z.union([Within, Exact])),
+  assignedTo: import_zod16.z.optional(Exact),
+  createdByUserType: import_zod16.z.optional(ExactUserType),
+  updatedByUserRole: import_zod16.z.optional(Exact),
+  createdBy: import_zod16.z.optional(Exact),
+  updatedBy: import_zod16.z.optional(Exact),
+  trackingId: import_zod16.z.optional(Exact),
+  flags: import_zod16.z.optional(ContainsFlags),
   // @todo: The type for this comes out as "any"
   data: QueryInput
 }).partial().refine((obj) => Object.values(obj).some((val) => val !== void 0), {
@@ -1421,10 +1436,10 @@ var QueryExpression = import_zod15.z.object({
 }).openapi({
   ref: "QueryExpression"
 });
-var QueryType = import_zod15.z.lazy(
-  () => import_zod15.z.object({
-    type: import_zod15.z.literal("and").or(import_zod15.z.literal("or")).openapi({ default: "and" }),
-    clauses: import_zod15.z.array(import_zod15.z.union([QueryExpression, QueryType])).nonempty("At least one clause is required.").openapi({
+var QueryType = import_zod16.z.lazy(
+  () => import_zod16.z.object({
+    type: import_zod16.z.literal("and").or(import_zod16.z.literal("or")).openapi({ default: "and" }),
+    clauses: import_zod16.z.array(import_zod16.z.union([QueryExpression, QueryType])).nonempty("At least one clause is required.").openapi({
       default: [
         {
           eventType: TENNIS_CLUB_MEMBERSHIP,
@@ -1451,8 +1466,8 @@ function parseStringifiedQueryField(val) {
   }
   return val;
 }
-var SearchQuery = import_zod15.z.object({
-  query: import_zod15.z.preprocess(parseStringifiedQueryField, QueryType).openapi({
+var SearchQuery = import_zod16.z.object({
+  query: import_zod16.z.preprocess(parseStringifiedQueryField, QueryType).openapi({
     default: {
       type: "and",
       clauses: [
@@ -1472,33 +1487,36 @@ var SearchQuery = import_zod15.z.object({
       ]
     }
   }),
-  limit: import_zod15.z.number().optional().default(100),
-  offset: import_zod15.z.number().optional().default(0),
-  sort: import_zod15.z.preprocess(
+  limit: import_zod16.z.number().optional().default(100),
+  offset: import_zod16.z.number().optional().default(0),
+  sort: import_zod16.z.preprocess(
     parseStringifiedQueryField,
-    import_zod15.z.array(
-      import_zod15.z.object({
-        field: import_zod15.z.string(),
-        direction: import_zod15.z.enum(["asc", "desc"]).default("asc")
+    import_zod16.z.array(
+      import_zod16.z.object({
+        field: import_zod16.z.string(),
+        direction: import_zod16.z.enum(["asc", "desc"]).default("asc")
       })
     )
-  ).optional()
+  ).optional(),
+  excludeDrafts: import_zod16.z.boolean().optional().describe(
+    'When true, undeclared drafts (events in status CREATED) are excluded from the results. Used by workqueues so that drafts only appear in the dedicated "My Draft" view, while explicit searches (e.g. by tracking ID) can still find them.'
+  )
 }).openapi({
   ref: "SearchQuery"
 });
 
 // ../commons/src/events/serializers/date/serializer.ts
-var import_zod16 = require("zod");
-var SerializedNowDateTime = import_zod16.z.object({
-  $$now: import_zod16.z.literal(true)
+var import_zod17 = require("zod");
+var SerializedNowDateTime = import_zod17.z.object({
+  $$now: import_zod17.z.literal(true)
 });
 function todayDateTimeValueSerializer() {
   return { $$now: true };
 }
 
 // ../commons/src/events/FieldConfig.ts
-(0, import_zod_openapi6.extendZodWithOpenApi)(import_zod17.z);
-var FieldId = import_zod17.z.string().refine(
+(0, import_zod_openapi6.extendZodWithOpenApi)(import_zod18.z);
+var FieldId = import_zod18.z.string().refine(
   /*
    * Disallow underscores '_' in field ids.
    * Why? Theres two reasons:
@@ -1511,163 +1529,163 @@ var FieldId = import_zod17.z.string().refine(
     message: `id: '${val}' must not contain underscores '_'`
   })
 ).describe("Unique identifier for the field");
-var FieldReference = import_zod17.z.object({
+var FieldReference = import_zod18.z.object({
   $$field: FieldId,
-  $$subfield: import_zod17.z.array(import_zod17.z.string()).optional().default([]).describe(
+  $$subfield: import_zod18.z.array(import_zod18.z.string()).optional().default([]).describe(
     'If the FieldValue is an object, subfield can be used to refer to e.g. `["foo", "bar"]` in `{ foo: { bar: 3 } }`'
   )
 }).describe("Reference to a field by its ID");
-var ValidationConfig = import_zod17.z.object({
+var ValidationConfig = import_zod18.z.object({
   validator: Conditional,
   message: TranslationConfig
 });
-var requiredSchema = import_zod17.z.union([
-  import_zod17.z.boolean(),
-  import_zod17.z.object({
+var requiredSchema = import_zod18.z.union([
+  import_zod18.z.boolean(),
+  import_zod18.z.object({
     message: TranslationConfig.describe("Custom required validation message")
   })
 ]).default(false).optional();
-var BaseField = import_zod17.z.object({
+var BaseField = import_zod18.z.object({
   id: FieldId.describe("Unique identifier of the field."),
   label: TranslationConfig.describe("Human-readable label of the field."),
-  parent: FieldReference.or(import_zod17.z.array(FieldReference)).optional().describe(
+  parent: FieldReference.or(import_zod18.z.array(FieldReference)).optional().describe(
     "Reference to the parent field or fields. When a parent field changes, this field is reset."
   ),
   required: requiredSchema.describe(
     "Indicates whether the field is mandatory."
   ),
-  conditionals: import_zod17.z.array(FieldConditional).default([]).optional().describe(
+  conditionals: import_zod18.z.array(FieldConditional).default([]).optional().describe(
     "Conditions determining when the field is shown or enabled. By default, the field is always shown and enabled."
   ),
-  secured: import_zod17.z.boolean().default(false).optional().describe(
+  secured: import_zod18.z.boolean().default(false).optional().describe(
     "Indicates whether the field is secured. Secured fields are not indexed for search and are only visible when explicitly assigned."
   ),
   placeholder: TranslationConfig.optional(),
-  validation: import_zod17.z.array(ValidationConfig).default([]).optional().describe("Additional validation rules applied to the field."),
+  validation: import_zod18.z.array(ValidationConfig).default([]).optional().describe("Additional validation rules applied to the field."),
   helperText: TranslationConfig.optional(),
-  hideLabel: import_zod17.z.boolean().default(false).optional(),
-  uncorrectable: import_zod17.z.boolean().default(false).optional().describe(
+  hideLabel: import_zod18.z.boolean().default(false).optional(),
+  uncorrectable: import_zod18.z.boolean().default(false).optional().describe(
     "Indicates whether the field can be modified during record correction."
   ),
-  value: FieldReference.or(import_zod17.z.array(FieldReference)).optional().describe(
+  value: FieldReference.or(import_zod18.z.array(FieldReference)).optional().describe(
     "Reference to the source field or fields. When a value is defined, it is copied from the parent field when changed. If multiple references are provided, the first truthy value is used."
   ),
-  analytics: import_zod17.z.boolean().default(false).optional().describe(
+  analytics: import_zod18.z.boolean().default(false).optional().describe(
     "Indicates whether the field is included in analytics. When enabled, its value becomes available in the analytics dashboard."
   ),
-  persistWhenHidden: import_zod17.z.boolean().default(false).optional().describe(
+  persistWhenHidden: import_zod18.z.boolean().default(false).optional().describe(
     "Preserves field value during hidden field cleanup."
   )
 }).describe("Common properties shared across all field types.");
 var Divider = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.DIVIDER)
+  type: import_zod18.z.literal(FieldType.DIVIDER)
 });
 var TextField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.TEXT),
-  defaultValue: import_zod17.z.union([NonEmptyTextValue, SerializedUserField, SerializedUserDataField]).optional(),
-  configuration: import_zod17.z.object({
-    maxLength: import_zod17.z.number().optional().describe("Maximum length of the text"),
-    type: import_zod17.z.enum(["text", "password"]).optional(),
+  type: import_zod18.z.literal(FieldType.TEXT),
+  defaultValue: import_zod18.z.union([NonEmptyTextValue, SerializedUserField, SerializedUserDataField]).optional(),
+  configuration: import_zod18.z.object({
+    maxLength: import_zod18.z.number().optional().describe("Maximum length of the text"),
+    type: import_zod18.z.enum(["text", "password"]).optional(),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).default({ type: "text" }).optional()
 }).describe("Text input");
 var NumberField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.NUMBER),
+  type: import_zod18.z.literal(FieldType.NUMBER),
   defaultValue: NumberFieldValue.optional(),
-  configuration: import_zod17.z.object({
-    min: import_zod17.z.number().optional().describe("Minimum value"),
-    max: import_zod17.z.number().optional().describe("Maximum value"),
+  configuration: import_zod18.z.object({
+    min: import_zod18.z.number().optional().describe("Minimum value"),
+    max: import_zod18.z.number().optional().describe("Maximum value"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).optional()
 }).describe("Number input");
 var TextAreaField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.TEXTAREA),
+  type: import_zod18.z.literal(FieldType.TEXTAREA),
   defaultValue: NonEmptyTextValue.optional(),
-  configuration: import_zod17.z.object({
-    maxLength: import_zod17.z.number().optional().describe("Maximum length of the text"),
-    rows: import_zod17.z.number().optional().describe("Number of visible text lines"),
-    cols: import_zod17.z.number().optional().describe("Number of visible columns"),
+  configuration: import_zod18.z.object({
+    maxLength: import_zod18.z.number().optional().describe("Maximum length of the text"),
+    rows: import_zod18.z.number().optional().describe("Number of visible text lines"),
+    cols: import_zod18.z.number().optional().describe("Number of visible columns"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).default({ rows: 4 }).optional()
 }).describe("Multiline text input");
-var ImageMimeType = import_zod17.z.enum([
+var ImageMimeType = import_zod18.z.enum([
   "image/png",
   "image/jpg",
   "image/jpeg",
   "image/svg+xml"
 ]);
-var DocumentMimeType = import_zod17.z.enum([
+var DocumentMimeType = import_zod18.z.enum([
   "application/pdf",
   "application/msword",
   "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
   "application/vnd.oasis.opendocument.text"
 ]);
-var MimeType = import_zod17.z.enum([
+var MimeType = import_zod18.z.enum([
   ...ImageMimeType.options,
   ...DocumentMimeType.options
 ]);
 var DEFAULT_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
 var SignatureField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.SIGNATURE),
+  type: import_zod18.z.literal(FieldType.SIGNATURE),
   signaturePromptLabel: TranslationConfig.describe(
     "Title of the signature modal"
   ),
   defaultValue: SignatureFieldValue.optional(),
-  configuration: import_zod17.z.object({
-    maxFileSize: import_zod17.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+  configuration: import_zod18.z.object({
+    maxFileSize: import_zod18.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
     acceptedFileTypes: MimeType.array().optional().describe("List of allowed file formats for the signature")
   }).default({
     maxFileSize: DEFAULT_MAX_FILE_SIZE_BYTES
   })
 }).describe("Signature input field");
 var EmailField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.EMAIL),
-  configuration: import_zod17.z.object({
-    maxLength: import_zod17.z.number().optional().describe("Maximum length of the text")
+  type: import_zod18.z.literal(FieldType.EMAIL),
+  configuration: import_zod18.z.object({
+    maxLength: import_zod18.z.number().optional().describe("Maximum length of the text")
   }).default({ maxLength: 10 }).optional(),
-  defaultValue: import_zod17.z.union([NonEmptyTextValue, SerializedUserField]).optional()
+  defaultValue: import_zod18.z.union([NonEmptyTextValue, SerializedUserField]).optional()
 });
 var DateField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.DATE),
+  type: import_zod18.z.literal(FieldType.DATE),
   defaultValue: SerializedNowDateTime.or(PlainDate).optional().openapi({ effectType: "input", type: "string" }).describe("Default date value(yyyy-MM-dd)"),
-  configuration: import_zod17.z.object({
+  configuration: import_zod18.z.object({
     notice: TranslationConfig.describe(
       "Text to display above the date input"
     ).optional()
   }).optional()
 }).describe("A single date input (yyyy-MM-dd)");
 var AgeField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.AGE),
+  type: import_zod18.z.literal(FieldType.AGE),
   defaultValue: NumberFieldValue.optional(),
-  configuration: import_zod17.z.object({
+  configuration: import_zod18.z.object({
     asOfDate: FieldReference,
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   })
 }).describe("An age input field which uses the current date as the asOfDate");
 var TimeField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.TIME),
+  type: import_zod18.z.literal(FieldType.TIME),
   defaultValue: SerializedNowDateTime.or(TimeValue).optional().openapi({ effectType: "input", type: "object" }).describe("Default time value (HH-mm)"),
-  configuration: import_zod17.z.object({
-    use12HourFormat: import_zod17.z.boolean().optional().describe("Whether to use 12-hour format"),
+  configuration: import_zod18.z.object({
+    use12HourFormat: import_zod18.z.boolean().optional().describe("Whether to use 12-hour format"),
     notice: TranslationConfig.describe(
       "Text to display above the time input"
     ).optional()
   }).optional()
 }).describe("A single date input (HH-mm)");
 var DateRangeField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.DATE_RANGE),
+  type: import_zod18.z.literal(FieldType.DATE_RANGE),
   defaultValue: DateRangeFieldValue.optional(),
-  configuration: import_zod17.z.object({
+  configuration: import_zod18.z.object({
     notice: TranslationConfig.describe(
       "Text to display above the date input"
     ).optional()
   }).optional()
 }).describe("A date range input ({ start: yyyy-MM-dd, end: yyyy-MM-dd })");
-var HtmlFontVariant = import_zod17.z.enum([
+var HtmlFontVariant = import_zod18.z.enum([
   "reg12",
   "reg14",
   "reg16",
@@ -1677,32 +1695,32 @@ var HtmlFontVariant = import_zod17.z.enum([
   "h2",
   "h1"
 ]);
-var ParagraphConfiguration = import_zod17.z.object({
-  styles: import_zod17.z.object({
+var ParagraphConfiguration = import_zod18.z.object({
+  styles: import_zod18.z.object({
     fontVariant: HtmlFontVariant.optional().describe(
       "Font variant to use for the paragraph text"
     ),
-    hint: import_zod17.z.boolean().optional().describe("When true, paragraph is styled as a hint with grey color")
+    hint: import_zod18.z.boolean().optional().describe("When true, paragraph is styled as a hint with grey color")
   }).optional()
 }).default({});
 var Paragraph = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.PARAGRAPH),
+  type: import_zod18.z.literal(FieldType.PARAGRAPH),
   configuration: ParagraphConfiguration
 }).describe("A read-only HTML <p> paragraph");
 var PageHeader = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.PAGE_HEADER)
+  type: import_zod18.z.literal(FieldType.PAGE_HEADER)
 }).describe("A read-only header component for form pages");
 var File = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.FILE),
+  type: import_zod18.z.literal(FieldType.FILE),
   defaultValue: FileFieldValue.optional(),
-  configuration: import_zod17.z.object({
-    maxFileSize: import_zod17.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+  configuration: import_zod18.z.object({
+    maxFileSize: import_zod18.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
     acceptedFileTypes: MimeType.array().optional().describe("List of allowed file formats for the signature"),
-    maxImageSize: import_zod17.z.object({
-      targetSize: import_zod17.z.object({ width: import_zod17.z.number(), height: import_zod17.z.number() })
+    maxImageSize: import_zod18.z.object({
+      targetSize: import_zod18.z.object({ width: import_zod18.z.number(), height: import_zod18.z.number() })
     }).optional(),
-    style: import_zod17.z.object({
-      width: import_zod17.z.enum(["full", "auto"]).optional().describe(
+    style: import_zod18.z.object({
+      width: import_zod18.z.enum(["full", "auto"]).optional().describe(
         "Whether the file upload button should take the full width of the container or not"
       )
     }).optional(),
@@ -1711,46 +1729,46 @@ var File = BaseField.extend({
     maxFileSize: DEFAULT_MAX_FILE_SIZE_BYTES
   })
 }).describe("File upload");
-var SelectOption = import_zod17.z.object({
-  value: import_zod17.z.string().describe("The value of the option"),
-  label: import_zod17.z.union([import_zod17.z.string(), TranslationConfig]).describe("The label of the option"),
-  conditionals: import_zod17.z.array(ActionConditional).default([]).optional()
+var SelectOption = import_zod18.z.object({
+  value: import_zod18.z.string().describe("The value of the option"),
+  label: import_zod18.z.union([import_zod18.z.string(), TranslationConfig]).describe("The label of the option"),
+  conditionals: import_zod18.z.array(ActionConditional).default([]).optional()
 });
 var NumberWithUnitField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.NUMBER_WITH_UNIT),
+  type: import_zod18.z.literal(FieldType.NUMBER_WITH_UNIT),
   defaultValue: NumberWithUnitFieldValue.optional(),
-  options: import_zod17.z.array(SelectOption).describe("A list of options for the unit select"),
-  configuration: import_zod17.z.object({
-    min: import_zod17.z.number().optional().describe("Minimum value of the number field"),
-    max: import_zod17.z.number().optional().describe("Maximum value of the number field"),
+  options: import_zod18.z.array(SelectOption).describe("A list of options for the unit select"),
+  configuration: import_zod18.z.object({
+    min: import_zod18.z.number().optional().describe("Minimum value of the number field"),
+    max: import_zod18.z.number().optional().describe("Maximum value of the number field"),
     numberFieldPlaceholder: TranslationConfig.optional().describe(
       "Placeholder for the number field"
     )
   }).optional()
 }).describe("Number with unit input");
 var RadioGroup = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.RADIO_GROUP),
+  type: import_zod18.z.literal(FieldType.RADIO_GROUP),
   defaultValue: TextValue.optional(),
-  options: import_zod17.z.array(SelectOption).describe("A list of options"),
-  configuration: import_zod17.z.object({
-    styles: import_zod17.z.object({
-      size: import_zod17.z.enum(["NORMAL", "LARGE"]).optional()
+  options: import_zod18.z.array(SelectOption).describe("A list of options"),
+  configuration: import_zod18.z.object({
+    styles: import_zod18.z.object({
+      size: import_zod18.z.enum(["NORMAL", "LARGE"]).optional()
     }).optional()
   }).optional()
 }).describe("Grouped radio options");
 var BulletList = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.BULLET_LIST),
-  items: import_zod17.z.array(TranslationConfig).describe("A list of items"),
-  configuration: import_zod17.z.object({
-    styles: import_zod17.z.object({
+  type: import_zod18.z.literal(FieldType.BULLET_LIST),
+  items: import_zod18.z.array(TranslationConfig).describe("A list of items"),
+  configuration: import_zod18.z.object({
+    styles: import_zod18.z.object({
       fontVariant: HtmlFontVariant.optional()
     }).optional()
   }).default({})
 }).describe("A list of bullet points");
 var Select = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.SELECT),
-  defaultValue: import_zod17.z.union([NonEmptyTextValue, SerializedUserDataField]).optional(),
-  options: import_zod17.z.array(SelectOption).describe("A list of options"),
+  type: import_zod18.z.literal(FieldType.SELECT),
+  defaultValue: import_zod18.z.union([NonEmptyTextValue, SerializedUserDataField]).optional(),
+  options: import_zod18.z.array(SelectOption).describe("A list of options"),
   noOptionsMessage: TranslationConfig.optional().describe(
     `
     A translation configuration object used to display a message when no options are available.
@@ -1762,37 +1780,37 @@ var Select = BaseField.extend({
   `
   )
 }).describe("Select input");
-var SelectDateRangeOption = import_zod17.z.object({
+var SelectDateRangeOption = import_zod18.z.object({
   value: SelectDateRangeValue.describe("The value of the option"),
   label: TranslationConfig.describe("The label of the option")
 });
 var SelectDateRangeField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.SELECT_DATE_RANGE),
+  type: import_zod18.z.literal(FieldType.SELECT_DATE_RANGE),
   defaultValue: SelectDateRangeValue.optional(),
-  options: import_zod17.z.array(SelectDateRangeOption).describe("A list of options")
+  options: import_zod18.z.array(SelectDateRangeOption).describe("A list of options")
 }).describe("Select input with date range options");
-var NameConfig = import_zod17.z.object({
-  firstname: import_zod17.z.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional(),
-  middlename: import_zod17.z.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional(),
-  surname: import_zod17.z.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional()
+var NameConfig = import_zod18.z.object({
+  firstname: import_zod18.z.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional(),
+  middlename: import_zod18.z.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional(),
+  surname: import_zod18.z.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional()
 });
 var NameField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.NAME),
-  defaultValue: import_zod17.z.object({
+  type: import_zod18.z.literal(FieldType.NAME),
+  defaultValue: import_zod18.z.object({
     firstname: SerializedUserField.or(NonEmptyTextValue).optional(),
     middlename: SerializedUserField.or(NonEmptyTextValue).optional(),
     surname: SerializedUserField.or(NonEmptyTextValue).optional()
   }).optional(),
-  configuration: import_zod17.z.object({
+  configuration: import_zod18.z.object({
     name: NameConfig.default({
       firstname: { required: true },
       surname: { required: true }
     }).optional(),
-    order: import_zod17.z.array(import_zod17.z.enum(["firstname", "middlename", "surname"])).optional(),
-    maxLength: import_zod17.z.number().optional().describe("Maximum length of the text"),
+    order: import_zod18.z.array(import_zod18.z.enum(["firstname", "middlename", "surname"])).optional(),
+    maxLength: import_zod18.z.number().optional().describe("Maximum length of the text"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional(),
-    showParentFieldError: import_zod17.z.boolean().default(false).optional().describe(
+    showParentFieldError: import_zod18.z.boolean().default(false).optional().describe(
       `If true, shows the parent field error and hides the subfield error`
     )
   }).default({
@@ -1803,53 +1821,53 @@ var NameField = BaseField.extend({
   }).optional()
 }).describe("Name input field");
 var PhoneField = BaseField.extend({
-  defaultValue: import_zod17.z.union([NonEmptyTextValue, SerializedUserField]).optional(),
-  type: import_zod17.z.literal(FieldType.PHONE)
+  defaultValue: import_zod18.z.union([NonEmptyTextValue, SerializedUserField]).optional(),
+  type: import_zod18.z.literal(FieldType.PHONE)
 }).describe("Phone input field");
 var IdField = BaseField.extend({
-  defaultValue: import_zod17.z.union([NonEmptyTextValue, SerializedUserDataField]).optional(),
-  type: import_zod17.z.literal(FieldType.ID)
+  defaultValue: import_zod18.z.union([NonEmptyTextValue, SerializedUserDataField]).optional(),
+  type: import_zod18.z.literal(FieldType.ID)
 }).describe("ID input field");
 var Checkbox = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.CHECKBOX),
+  type: import_zod18.z.literal(FieldType.CHECKBOX),
   defaultValue: CheckboxFieldValue.default(false)
 }).describe("Boolean checkbox field");
 var Country = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.COUNTRY),
+  type: import_zod18.z.literal(FieldType.COUNTRY),
   defaultValue: NonEmptyTextValue.optional(),
-  optionOverrides: import_zod17.z.array(SelectOption.omit({ label: true })).optional().describe(
+  optionOverrides: import_zod18.z.array(SelectOption.omit({ label: true })).optional().describe(
     "Conditionals for specific countries. Countries not listed are always shown and enabled."
   )
 }).describe("Country select field");
-var AdministrativeAreas = import_zod17.z.enum([
+var AdministrativeAreas = import_zod18.z.enum([
   "ADMIN_STRUCTURE",
   "HEALTH_FACILITY",
   "CRVS_OFFICE"
 ]);
-var AdministrativeAreaConfiguration = import_zod17.z.object({
+var AdministrativeAreaConfiguration = import_zod18.z.object({
   partOf: FieldReference.optional(),
   type: AdministrativeAreas
 }).describe("Administrative area options");
 var AdministrativeArea = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.ADMINISTRATIVE_AREA),
-  defaultValue: import_zod17.z.union([NonEmptyTextValue, SerializedUserField]).optional(),
+  type: import_zod18.z.literal(FieldType.ADMINISTRATIVE_AREA),
+  defaultValue: import_zod18.z.union([NonEmptyTextValue, SerializedUserField]).optional(),
   configuration: AdministrativeAreaConfiguration
 }).describe("Administrative area input field e.g. facility, office");
 var LocationInput = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.LOCATION),
+  type: import_zod18.z.literal(FieldType.LOCATION),
   defaultValue: NonEmptyTextValue.optional(),
-  configuration: import_zod17.z.object({
-    searchableResource: import_zod17.z.array(import_zod17.z.enum(["locations", "facilities", "offices"]))
+  configuration: import_zod18.z.object({
+    searchableResource: import_zod18.z.array(import_zod18.z.enum(["locations", "facilities", "offices"]))
   })
 }).describe("Input field for a location");
 var FileUploadWithOptions = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.FILE_WITH_OPTIONS),
-  options: import_zod17.z.array(SelectOption).describe("A list of options"),
+  type: import_zod18.z.literal(FieldType.FILE_WITH_OPTIONS),
+  options: import_zod18.z.array(SelectOption).describe("A list of options"),
   defaultValue: FileFieldWithOptionValue.optional(),
-  configuration: import_zod17.z.object({
-    maxFileSize: import_zod17.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
-    maxImageSize: import_zod17.z.object({
-      targetSize: import_zod17.z.object({ width: import_zod17.z.number(), height: import_zod17.z.number() })
+  configuration: import_zod18.z.object({
+    maxFileSize: import_zod18.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+    maxImageSize: import_zod18.z.object({
+      targetSize: import_zod18.z.object({ width: import_zod18.z.number(), height: import_zod18.z.number() })
     }).optional(),
     acceptedFileTypes: MimeType.array().optional().describe("List of allowed file formats for the signature")
   }).default({
@@ -1857,15 +1875,15 @@ var FileUploadWithOptions = BaseField.extend({
   })
 });
 var Facility = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.FACILITY),
-  defaultValue: import_zod17.z.union([NonEmptyTextValue, SerializedUserField, SerializedUserDataField]).optional()
+  type: import_zod18.z.literal(FieldType.FACILITY),
+  defaultValue: import_zod18.z.union([NonEmptyTextValue, SerializedUserField, SerializedUserDataField]).optional()
 }).describe("Input field for a facility");
 var Office = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.OFFICE),
+  type: import_zod18.z.literal(FieldType.OFFICE),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("Input field for an office");
 var DefaultAddressFieldValue = DomesticAddressFieldValue.extend({
-  administrativeArea: import_zod17.z.union([UUID, SerializedUserField]).optional()
+  administrativeArea: import_zod18.z.union([UUID, SerializedUserField]).optional()
 });
 var commonDomesticFieldProps = {
   id: true,
@@ -1881,86 +1899,86 @@ var DomesticAddressField = Country.partial().pick({
   AdministrativeArea.partial().pick(commonDomesticFieldProps).required({ id: true, type: true })
 );
 var Address = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.ADDRESS),
-  configuration: import_zod17.z.object({
-    lineSeparator: import_zod17.z.string().optional(),
-    fields: import_zod17.z.array(DomesticAddressField).optional(),
-    streetAddressForm: import_zod17.z.array(
-      import_zod17.z.object({
-        id: import_zod17.z.string(),
+  type: import_zod18.z.literal(FieldType.ADDRESS),
+  configuration: import_zod18.z.object({
+    lineSeparator: import_zod18.z.string().optional(),
+    fields: import_zod18.z.array(DomesticAddressField).optional(),
+    streetAddressForm: import_zod18.z.array(
+      import_zod18.z.object({
+        id: import_zod18.z.string(),
         required: requiredSchema,
         label: TranslationConfig,
-        type: import_zod17.z.literal(FieldType.TEXT),
-        conditionals: import_zod17.z.array(FieldConditional).default([]).optional(),
+        type: import_zod18.z.literal(FieldType.TEXT),
+        conditionals: import_zod18.z.array(FieldConditional).default([]).optional(),
         parent: FieldReference.optional()
       })
     ).optional()
   }).optional(),
   defaultValue: DefaultAddressFieldValue.optional()
 }).describe("Address input field \u2013 a combination of location and text fields");
-var StaticDataEntry = import_zod17.z.object({
-  id: import_zod17.z.string().describe("ID for the data entry."),
+var StaticDataEntry = import_zod18.z.object({
+  id: import_zod18.z.string().describe("ID for the data entry."),
   label: TranslationConfig,
-  value: TranslationConfig.or(import_zod17.z.string()).or(FieldReference)
+  value: TranslationConfig.or(import_zod18.z.string()).or(FieldReference)
 }).describe("Static data entry");
-var DataEntry = import_zod17.z.union([StaticDataEntry, import_zod17.z.object({ fieldId: import_zod17.z.string() })]).describe(
+var DataEntry = import_zod18.z.union([StaticDataEntry, import_zod18.z.object({ fieldId: import_zod18.z.string() })]).describe(
   "Data entry can be either a static data entry, or a reference to another field in the current form or the declaration."
 );
 var DataField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.DATA),
-  configuration: import_zod17.z.object({
+  type: import_zod18.z.literal(FieldType.DATA),
+  configuration: import_zod18.z.object({
     subtitle: TranslationConfig.optional(),
-    data: import_zod17.z.array(DataEntry)
+    data: import_zod18.z.array(DataEntry)
   })
 }).describe("Data field for displaying read-only data");
 var ButtonField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.BUTTON),
+  type: import_zod18.z.literal(FieldType.BUTTON),
   defaultValue: ButtonFieldValue.optional(),
-  configuration: import_zod17.z.object({
-    icon: import_zod17.z.string().optional().describe(
+  configuration: import_zod18.z.object({
+    icon: import_zod18.z.string().optional().describe(
       "Icon for the button. You can find icons from OpenCRVS UI-Kit."
     ),
-    loading: import_zod17.z.boolean().optional().describe("Whether the button is in a loading state and shows a spinner"),
+    loading: import_zod18.z.boolean().optional().describe("Whether the button is in a loading state and shows a spinner"),
     text: TranslationConfig.describe("Text to display on the button")
   })
 }).describe("Generic button without any built-in functionality");
 var FieldGroup = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.FIELD_GROUP),
+  type: import_zod18.z.literal(FieldType.FIELD_GROUP),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  fields: import_zod17.z.lazy(() => import_zod17.z.array(FieldConfig))
+  fields: import_zod18.z.lazy(() => import_zod18.z.array(FieldConfig))
 });
 var AlphaPrintButton = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.ALPHA_PRINT_BUTTON),
-  configuration: import_zod17.z.object({
-    template: import_zod17.z.string().describe("Template ID from countryconfig templates to use for printing"),
+  type: import_zod18.z.literal(FieldType.ALPHA_PRINT_BUTTON),
+  configuration: import_zod18.z.object({
+    template: import_zod18.z.string().describe("Template ID from countryconfig templates to use for printing"),
     buttonLabel: TranslationConfig.optional().describe(
       "Label for the print button"
     )
   })
 }).describe("Print button field for printing certificates");
 var HttpField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.HTTP),
+  type: import_zod18.z.literal(FieldType.HTTP),
   defaultValue: HttpFieldValue.optional(),
-  configuration: import_zod17.z.object({
+  configuration: import_zod18.z.object({
     trigger: FieldReference,
-    url: import_zod17.z.string().describe("URL to send the HTTP request to"),
-    method: import_zod17.z.enum(["GET", "POST", "PUT", "DELETE"]),
-    headers: import_zod17.z.record(import_zod17.z.string()).optional(),
-    body: import_zod17.z.record(import_zod17.z.any()).optional(),
-    errorValue: import_zod17.z.any().optional().describe("Value to set if the request fails"),
-    params: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.union([import_zod17.z.string(), FieldReference])).optional(),
-    timeout: import_zod17.z.number().default(15e3).describe("Request timeout in milliseconds")
+    url: import_zod18.z.string().describe("URL to send the HTTP request to"),
+    method: import_zod18.z.enum(["GET", "POST", "PUT", "DELETE"]),
+    headers: import_zod18.z.record(import_zod18.z.string()).optional(),
+    body: import_zod18.z.record(import_zod18.z.any()).optional(),
+    errorValue: import_zod18.z.any().optional().describe("Value to set if the request fails"),
+    params: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.union([import_zod18.z.string(), FieldReference])).optional(),
+    timeout: import_zod18.z.number().default(15e3).describe("Request timeout in milliseconds")
   })
 }).describe("HTTP request function triggered by a button click or other event");
 var SearchField = HttpField.extend({
-  type: import_zod17.z.literal(FieldType.SEARCH),
+  type: import_zod18.z.literal(FieldType.SEARCH),
   configuration: SearchQuery.pick({
     query: true,
     limit: true,
     offset: true
   }).extend({
     validation: ValidationConfig,
-    indicators: import_zod17.z.object({
+    indicators: import_zod18.z.object({
       loading: TranslationConfig.optional().describe(
         "Text to display while the search is in progress"
       ),
@@ -1975,7 +1993,7 @@ var SearchField = HttpField.extend({
       ),
       confirmButton: TranslationConfig.optional(),
       clearButton: TranslationConfig.optional(),
-      clearModal: import_zod17.z.object({
+      clearModal: import_zod18.z.object({
         title: TranslationConfig.optional(),
         description: TranslationConfig.optional(),
         cancel: TranslationConfig.optional(),
@@ -1985,18 +2003,34 @@ var SearchField = HttpField.extend({
     }).optional()
   })
 });
+var Icd11Field = BaseField.extend({
+  type: import_zod18.z.literal(FieldType.ICD11),
+  defaultValue: Icd11FieldValue.optional(),
+  configuration: import_zod18.z.object({
+    url: import_zod18.z.string().describe(
+      "URL of the ICD-11 search endpoint. Should point at a countryconfig-hosted proxy route rather than the WHO API directly, since the WHO access token must stay server-side."
+    ),
+    apiVersion: import_zod18.z.string().default("v2").describe("Value sent as the WHO ICD-11 API `api-version` header"),
+    chapterFilter: import_zod18.z.string().optional().describe(
+      "Semicolon-separated list of ICD-11 chapters to restrict the search to, forwarded as-is to the WHO API `chapterFilter` parameter"
+    ),
+    timeout: import_zod18.z.number().default(15e3).describe("Request timeout in milliseconds")
+  }).describe("ICD-11 search field configuration")
+}).describe(
+  "Debounced, searchable ICD-11 diagnosis code field backed by the WHO ICD-11 search API"
+);
 var LinkButtonField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.LINK_BUTTON),
-  configuration: import_zod17.z.object({
-    url: import_zod17.z.string().describe("URL to open"),
+  type: import_zod18.z.literal(FieldType.LINK_BUTTON),
+  configuration: import_zod18.z.object({
+    url: import_zod18.z.string().describe("URL to open"),
     text: TranslationConfig.describe("Text to display on the button"),
-    icon: import_zod17.z.string().optional().describe("Icon for the button. You can find icons from OpenCRVS UI-Kit.")
+    icon: import_zod18.z.string().optional().describe("Icon for the button. You can find icons from OpenCRVS UI-Kit.")
   })
 }).describe("Button that opens a link");
 var VerificationStatus = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.VERIFICATION_STATUS),
+  type: import_zod18.z.literal(FieldType.VERIFICATION_STATUS),
   defaultValue: VerificationStatusValue.optional(),
-  configuration: import_zod17.z.object({
+  configuration: import_zod18.z.object({
     status: TranslationConfig.describe("Text to display on the status pill."),
     description: TranslationConfig.describe(
       "Explaining text on the banner in form."
@@ -2004,38 +2038,38 @@ var VerificationStatus = BaseField.extend({
   })
 });
 var QueryParamReaderField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.QUERY_PARAM_READER),
-  configuration: import_zod17.z.object({
-    pickParams: import_zod17.z.array(import_zod17.z.string()).describe("List of query parameters to read from the URL")
+  type: import_zod18.z.literal(FieldType.QUERY_PARAM_READER),
+  configuration: import_zod18.z.object({
+    pickParams: import_zod18.z.array(import_zod18.z.string()).describe("List of query parameters to read from the URL")
   })
 }).describe(
   "A field that maps URL query params into form values and clears them afterward"
 );
 var QrReaderField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.QR_READER),
+  type: import_zod18.z.literal(FieldType.QR_READER),
   defaultValue: QrReaderFieldValue.optional(),
-  configuration: import_zod17.z.object({
-    validator: import_zod17.z.custom(
+  configuration: import_zod18.z.object({
+    validator: import_zod18.z.custom(
       (val) => typeof val === "object" && val !== null
     )
   }).optional()
 });
 var IdReaderField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.ID_READER),
+  type: import_zod18.z.literal(FieldType.ID_READER),
   defaultValue: IdReaderFieldValue.optional(),
-  methods: import_zod17.z.array(
-    import_zod17.z.union([QrReaderField, LinkButtonField]).describe("Methods for reading an ID")
+  methods: import_zod18.z.array(
+    import_zod18.z.union([QrReaderField, LinkButtonField]).describe("Methods for reading an ID")
   )
 });
 var LoaderField = BaseField.extend({
-  type: import_zod17.z.literal(FieldType.LOADER),
-  configuration: import_zod17.z.object({
+  type: import_zod18.z.literal(FieldType.LOADER),
+  configuration: import_zod18.z.object({
     text: TranslationConfig.describe("Display text above the loading spinner")
   })
 }).describe(
   "A non-interactive field that indicates an in progress operation in form"
 );
-var FieldConfig = import_zod17.z.discriminatedUnion("type", [
+var FieldConfig = import_zod18.z.discriminatedUnion("type", [
   FieldGroup,
   Address,
   TextField,
@@ -2076,32 +2110,33 @@ var FieldConfig = import_zod17.z.discriminatedUnion("type", [
   IdReaderField,
   QueryParamReaderField,
   LoaderField,
-  SearchField
+  SearchField,
+  Icd11Field
 ]).openapi({
   description: "Form field configuration",
   ref: "FieldConfig"
 });
-var AnyFileField = import_zod17.z.discriminatedUnion("type", [
+var AnyFileField = import_zod18.z.discriminatedUnion("type", [
   SignatureField,
   File,
   FileUploadWithOptions
 ]);
 
 // ../commons/src/events/FormConfig.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 
 // ../commons/src/events/PageConfig.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 var import_zod_openapi7 = require("zod-openapi");
-(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod18.z);
-var PageTypes = import_zod18.z.enum(["FORM", "VERIFICATION"]);
-var PageConfigBase = import_zod18.z.object({
-  id: import_zod18.z.string().describe("Unique identifier for the page"),
+(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod19.z);
+var PageTypes = import_zod19.z.enum(["FORM", "VERIFICATION"]);
+var PageConfigBase = import_zod19.z.object({
+  id: import_zod19.z.string().describe("Unique identifier for the page"),
   title: TranslationConfig.describe("Header title of the page"),
-  requireCompletionToContinue: import_zod18.z.boolean().default(false).describe(
+  requireCompletionToContinue: import_zod19.z.boolean().default(false).describe(
     "If true, all required fields must be filled before continuing to the next page"
   ),
-  fields: import_zod18.z.array(FieldConfig).describe("Fields to be rendered on the page"),
+  fields: import_zod19.z.array(FieldConfig).describe("Fields to be rendered on the page"),
   conditional: Conditional.optional().describe(
     "Page will be shown if condition is met. If conditional is not defined, the page will be always shown."
   )
@@ -2110,13 +2145,13 @@ var PageConfigBase = import_zod18.z.object({
   ref: "FormPageConfig"
 });
 var FormPageConfig = PageConfigBase.extend({
-  type: import_zod18.z.literal(PageTypes.enum.FORM).default(PageTypes.enum.FORM)
+  type: import_zod19.z.literal(PageTypes.enum.FORM).default(PageTypes.enum.FORM)
 });
-var VerificationActionConfig = import_zod18.z.object({
-  verify: import_zod18.z.object({ label: TranslationConfig }),
-  cancel: import_zod18.z.object({
+var VerificationActionConfig = import_zod19.z.object({
+  verify: import_zod19.z.object({ label: TranslationConfig }),
+  cancel: import_zod19.z.object({
     label: TranslationConfig,
-    confirmation: import_zod18.z.object({
+    confirmation: import_zod19.z.object({
       title: TranslationConfig,
       body: TranslationConfig
     })
@@ -2126,33 +2161,33 @@ var VerificationActionConfig = import_zod18.z.object({
   ref: "VerificationActionConfig"
 });
 var VerificationPageConfig = FormPageConfig.extend({
-  type: import_zod18.z.literal(PageTypes.enum.VERIFICATION),
+  type: import_zod19.z.literal(PageTypes.enum.VERIFICATION),
   actions: VerificationActionConfig
 });
-var PageConfig = import_zod18.z.discriminatedUnion("type", [
+var PageConfig = import_zod19.z.discriminatedUnion("type", [
   FormPageConfig,
   VerificationPageConfig
 ]);
 
 // ../commons/src/events/FormConfig.ts
-var DeclarationFormConfig = import_zod19.z.object({
+var DeclarationFormConfig = import_zod20.z.object({
   label: TranslationConfig.describe("Human readable description of the form"),
-  pages: import_zod19.z.array(FormPageConfig)
+  pages: import_zod20.z.array(FormPageConfig)
 }).describe("Configuration of the declaration form.");
-var ActionFormConfig = import_zod19.z.object({
+var ActionFormConfig = import_zod20.z.object({
   label: TranslationConfig.describe("Human readable description of the form"),
-  pages: import_zod19.z.array(PageConfig)
+  pages: import_zod20.z.array(PageConfig)
 }).describe(
   "Configuration of the form used for system actions beyond declaration, supporting a wider range of page types."
 );
-var FormConfig = import_zod19.z.union([DeclarationFormConfig, ActionFormConfig]);
+var FormConfig = import_zod20.z.union([DeclarationFormConfig, ActionFormConfig]);
 
 // ../commons/src/events/DeduplicationConfig.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 var import_zod_openapi8 = require("zod-openapi");
-(0, import_zod_openapi8.extendZodWithOpenApi)(import_zod20.z);
-var FieldReference2 = import_zod20.z.string();
-var Matcher = import_zod20.z.object({
+(0, import_zod_openapi8.extendZodWithOpenApi)(import_zod21.z);
+var FieldReference2 = import_zod21.z.string();
+var Matcher = import_zod21.z.object({
   /**
    * Reference to the field used in matching.
    *
@@ -2160,23 +2195,23 @@ var Matcher = import_zod20.z.object({
    * be used as the origin date to calculate the distance from.
    */
   fieldId: FieldReference2,
-  options: import_zod20.z.object({
-    boost: import_zod20.z.number().optional(),
+  options: import_zod21.z.object({
+    boost: import_zod21.z.number().optional(),
     matchAgainst: FieldReference2.optional()
   }).optional().default({
     boost: 1
   })
 });
 var FuzzyMatcher = Matcher.extend({
-  type: import_zod20.z.literal("fuzzy"),
-  options: import_zod20.z.object({
+  type: import_zod21.z.literal("fuzzy"),
+  options: import_zod21.z.object({
     /**
      * Names of length 3 or less characters = 0 edits allowed
      * Names of length 4 - 6 characters = 1 edit allowed
      * Names of length >7 characters = 2 edits allowed
      */
-    fuzziness: import_zod20.z.union([import_zod20.z.string(), import_zod20.z.number()]).optional().default("AUTO:4,7"),
-    boost: import_zod20.z.number().optional().default(1),
+    fuzziness: import_zod21.z.union([import_zod21.z.string(), import_zod21.z.number()]).optional().default("AUTO:4,7"),
+    boost: import_zod21.z.number().optional().default(1),
     matchAgainst: FieldReference2.optional()
   }).optional().default({
     fuzziness: "AUTO:4,7",
@@ -2184,48 +2219,48 @@ var FuzzyMatcher = Matcher.extend({
   })
 });
 var StrictMatcher = Matcher.extend({
-  type: import_zod20.z.literal("strict"),
-  options: import_zod20.z.object({
-    boost: import_zod20.z.number().optional().default(1),
+  type: import_zod21.z.literal("strict"),
+  options: import_zod21.z.object({
+    boost: import_zod21.z.number().optional().default(1),
     /**
      * The constant value to be present in the field for both records
      */
-    value: import_zod20.z.string().optional(),
+    value: import_zod21.z.string().optional(),
     matchAgainst: FieldReference2.optional()
   }).optional().default({
     boost: 1
   })
 });
 var DateRangeMatcher = Matcher.extend({
-  type: import_zod20.z.literal("dateRange"),
-  options: import_zod20.z.object({
+  type: import_zod21.z.literal("dateRange"),
+  options: import_zod21.z.object({
     /**
      * The distance pivot in days. Distance from the origin (the value of
      * fieldId) at which relevance scores receive half of the boost value
      */
-    pivot: import_zod20.z.number().optional(),
-    days: import_zod20.z.number(),
-    boost: import_zod20.z.number().optional().default(1),
+    pivot: import_zod21.z.number().optional(),
+    days: import_zod21.z.number(),
+    boost: import_zod21.z.number().optional().default(1),
     matchAgainst: FieldReference2.optional()
   })
 });
-var Not = import_zod20.z.object({
-  type: import_zod20.z.literal("not"),
+var Not = import_zod21.z.object({
+  type: import_zod21.z.literal("not"),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clause: import_zod20.z.lazy(() => Clause)
+  clause: import_zod21.z.lazy(() => Clause)
 });
-var And = import_zod20.z.object({
-  type: import_zod20.z.literal("and"),
+var And = import_zod21.z.object({
+  type: import_zod21.z.literal("and"),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clauses: import_zod20.z.lazy(() => Clause.array())
+  clauses: import_zod21.z.lazy(() => Clause.array())
 });
-var Or = import_zod20.z.object({
-  type: import_zod20.z.literal("or"),
+var Or = import_zod21.z.object({
+  type: import_zod21.z.literal("or"),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clauses: import_zod20.z.lazy(() => Clause.array())
+  clauses: import_zod21.z.lazy(() => Clause.array())
 });
-var Clause = import_zod20.z.lazy(
-  () => import_zod20.z.discriminatedUnion("type", [
+var Clause = import_zod21.z.lazy(
+  () => import_zod21.z.discriminatedUnion("type", [
     Not,
     And,
     Or,
@@ -2236,22 +2271,22 @@ var Clause = import_zod20.z.lazy(
 ).openapi({
   ref: "Clause"
 });
-var DeduplicationConfig = import_zod20.z.object({
-  id: import_zod20.z.string(),
+var DeduplicationConfig = import_zod21.z.object({
+  id: import_zod21.z.string(),
   label: TranslationConfig,
   query: Clause
 });
 
 // ../commons/src/events/ActionConfig.ts
 var import_zod_openapi9 = require("zod-openapi");
-(0, import_zod_openapi9.extendZodWithOpenApi)(import_zod21.z);
-var DeclarationReviewConfig = import_zod21.z.object({
+(0, import_zod_openapi9.extendZodWithOpenApi)(import_zod22.z);
+var DeclarationReviewConfig = import_zod22.z.object({
   title: TranslationConfig.describe("Title of the review page"),
-  fields: import_zod21.z.array(FieldConfig).describe("Fields displayed on the review page for annotations.")
+  fields: import_zod22.z.array(FieldConfig).describe("Fields displayed on the review page for annotations.")
 }).describe(
   "Configuration of the declaration review page for collecting event-related metadata."
 );
-var ActionConfigBase = import_zod21.z.object({
+var ActionConfigBase = import_zod22.z.object({
   label: TranslationConfig.describe("Human readable description of the action")
 });
 var DeclarationActionBase = ActionConfigBase.extend({
@@ -2259,71 +2294,71 @@ var DeclarationActionBase = ActionConfigBase.extend({
   deduplication: DeduplicationConfig.optional()
 });
 var ReadActionConfig = ActionConfigBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.READ),
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.READ),
     review: DeclarationReviewConfig.describe(
       "Configuration of the review page for read-only view."
     )
   })
 );
 var DeclareConfig = DeclarationActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.DECLARE)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.DECLARE)
   })
 );
 var ValidateConfig = DeclarationActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.VALIDATE)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.VALIDATE)
   })
 );
 var EscalateConfig = DeclarationActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.ESCALATE)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.ESCALATE)
   })
 );
 var RegisterConfig = DeclarationActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.REGISTER)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.REGISTER)
   })
 );
 var RejectDeclarationConfig = ActionConfigBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.REJECT)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.REJECT)
   })
 );
 var ArchiveConfig = ActionConfigBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.ARCHIVE)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.ARCHIVE)
   })
 );
 var DeleteConfig = ActionConfigBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.DELETE)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.DELETE)
   })
 );
 var PrintCertificateActionConfig = ActionConfigBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.PRINT_CERTIFICATE),
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.PRINT_CERTIFICATE),
     printForm: ActionFormConfig
   })
 );
 var RequestCorrectionConfig = ActionConfigBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.REQUEST_CORRECTION),
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.REQUEST_CORRECTION),
     correctionForm: ActionFormConfig
   })
 );
 var RejectCorrectionConfig = ActionConfigBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.REJECT_CORRECTION)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.REJECT_CORRECTION)
   })
 );
 var ApproveCorrectionConfig = ActionConfigBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.APPROVE_CORRECTION)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.APPROVE_CORRECTION)
   })
 );
-var ActionConfig = import_zod21.z.discriminatedUnion("type", [
+var ActionConfig = import_zod22.z.discriminatedUnion("type", [
   /*
    * OpenAPI references are defined here so our generated OpenAPI spec knows to reuse the models
    * and treat them as "models" instead of duplicating the data structure in each endpoint.
@@ -2345,7 +2380,7 @@ var ActionConfig = import_zod21.z.discriminatedUnion("type", [
 ]).describe(
   "Configuration of an action available for an event. Data collected depends on the action type and is accessible through the annotation property in ActionDocument."
 ).openapi({ ref: "ActionConfig" });
-var DeclarationActionConfig = import_zod21.z.discriminatedUnion("type", [
+var DeclarationActionConfig = import_zod22.z.discriminatedUnion("type", [
   DeclareConfig,
   ValidateConfig,
   EscalateConfig,
@@ -2353,80 +2388,87 @@ var DeclarationActionConfig = import_zod21.z.discriminatedUnion("type", [
 ]);
 
 // ../commons/src/events/offline/CertificateConfig.ts
-var import_zod22 = require("zod");
-var FontFamily = import_zod22.z.object({
-  normal: import_zod22.z.string(),
-  bold: import_zod22.z.string(),
-  italics: import_zod22.z.string(),
-  bolditalics: import_zod22.z.string()
-});
-var CertificateConfig = import_zod22.z.object({
-  id: import_zod22.z.string(),
-  event: import_zod22.z.string(),
-  isV2Template: import_zod22.z.boolean().optional(),
+var import_zod23 = require("zod");
+var FontFamily = import_zod23.z.object({
+  normal: import_zod23.z.string(),
+  bold: import_zod23.z.string(),
+  italics: import_zod23.z.string(),
+  bolditalics: import_zod23.z.string()
+});
+var CertificateConfig = import_zod23.z.object({
+  id: import_zod23.z.string(),
+  event: import_zod23.z.string(),
+  isV2Template: import_zod23.z.boolean().optional(),
   label: TranslationConfig,
-  isDefault: import_zod22.z.boolean(),
-  fee: import_zod22.z.object({
-    onTime: import_zod22.z.number(),
-    late: import_zod22.z.number(),
-    delayed: import_zod22.z.number()
+  isDefault: import_zod23.z.boolean(),
+  /**
+   * Whether the `record.registered.print-certified-copies` scope is required to
+   * receive this template. Defaults to `true` when omitted (backward compatible).
+   * Set to `false` for templates that must be available without the print
+   * permission, e.g. Notification Records printed from the declaration review page.
+   */
+  requiresPrintPermission: import_zod23.z.boolean().optional(),
+  fee: import_zod23.z.object({
+    onTime: import_zod23.z.number(),
+    late: import_zod23.z.number(),
+    delayed: import_zod23.z.number()
   }),
-  svgUrl: import_zod22.z.string(),
-  fonts: import_zod22.z.record(FontFamily).optional(),
-  conditionals: import_zod22.z.array(ShowConditional).optional()
+  svgUrl: import_zod23.z.string(),
+  fonts: import_zod23.z.record(FontFamily).optional(),
+  conditionals: import_zod23.z.array(ShowConditional).optional()
 });
 var CertificateTemplateConfig = CertificateConfig.extend({
-  hash: import_zod22.z.string().optional(),
-  svg: import_zod22.z.string()
+  hash: import_zod23.z.string().optional(),
+  svg: import_zod23.z.string()
 });
 
 // ../commons/src/events/offline/LanguageConfig.ts
-var import_zod23 = require("zod");
-var LanguageConfig = import_zod23.z.object({
-  lang: import_zod23.z.string(),
+var import_zod24 = require("zod");
+var LanguageConfig = import_zod24.z.object({
+  lang: import_zod24.z.string(),
   /**
    * client.csv contents
    */
-  messages: import_zod23.z.record(import_zod23.z.string())
+  messages: import_zod24.z.record(import_zod24.z.string())
 });
 
 // ../commons/src/events/EventConfig.ts
-var import_zod29 = require("zod");
+var import_zod30 = require("zod");
 
 // ../commons/src/events/SummaryConfig.ts
-var import_zod24 = require("zod");
-var BaseField2 = import_zod24.z.object({
+var import_zod25 = require("zod");
+var BaseField2 = import_zod25.z.object({
   emptyValueMessage: TranslationConfig.optional().describe(
     "Default message displayed when the field value is empty."
   ),
-  conditionals: import_zod24.z.array(ShowConditional).default([]).optional()
+  conditionals: import_zod25.z.array(ShowConditional).default([]).optional()
 });
 var ReferenceField = BaseField2.extend({
-  fieldId: import_zod24.z.string(),
+  fieldId: import_zod25.z.string(),
   label: TranslationConfig.optional().describe(
     "Overrides the default label from the referenced field when provided."
   )
 }).describe("Field referencing existing event data by field ID.");
 var Field = BaseField2.extend({
-  id: import_zod24.z.string().describe("Identifier of the summary field."),
+  id: import_zod25.z.string().describe("Identifier of the summary field."),
   value: TranslationConfig.describe(
     'Field value template supporting variables from configuration and EventMetadata (e.g. "{informant.phoneNo} {informant.email}").'
   ),
   label: TranslationConfig
 }).describe("Custom field defined for the summary view.");
-var SummaryConfig = import_zod24.z.object({
-  fields: import_zod24.z.array(import_zod24.z.union([Field, ReferenceField])).describe("Fields displayed in the event summary view.")
+var SummaryConfig = import_zod25.z.object({
+  fields: import_zod25.z.array(import_zod25.z.union([Field, ReferenceField])).describe("Fields displayed in the event summary view.")
 }).describe("Configuration of the event summary section.");
 
 // ../commons/src/events/AdvancedSearchConfig.ts
-var import_zod25 = require("zod");
-var MatchType = import_zod25.z.enum(["fuzzy", "exact", "range", "within"]);
-var BaseField3 = import_zod25.z.object({
-  config: import_zod25.z.object({
+var import_zod26 = require("zod");
+var MatchType = import_zod26.z.enum(["fuzzy", "exact", "range", "within"]);
+var BaseField3 = import_zod26.z.object({
+  config: import_zod26.z.object({
     type: MatchType.describe(
       "Determines the search type of field. How to match value."
     ),
-    searchFields: import_zod25.z.array(import_zod25.z.string()).optional().describe(
+    searchFields: import_zod26.z.array(import_zod26.z.string()).optional().describe(
       `
       Defines multiple form fields that should be searched when this field has a value.
       All specified fields will be combined using OR logic.
@@ -2436,7 +2478,7 @@ var BaseField3 = import_zod25.z.object({
       `
     )
   }),
-  type: import_zod25.z.nativeEnum(FieldType).optional().describe(
+  type: import_zod26.z.nativeEnum(FieldType).optional().describe(
     `
       Explicitly specify the field type for searchFields.
       This is required when searchFields is defined, to show the correct control in the UI.
@@ -2450,7 +2492,7 @@ var BaseField3 = import_zod25.z.object({
       This is required when searchFields is defined.            
       `
   ),
-  options: import_zod25.z.array(SelectOption).optional(),
+  options: import_zod26.z.array(SelectOption).optional(),
   searchCriteriaLabelPrefix: TranslationConfig.optional().describe(
     `
     This property determines whether to add a prefix (such as "Child" or "Applicant") before the field label
@@ -2471,7 +2513,7 @@ var BaseField3 = import_zod25.z.object({
     in the country-config > event.advancedSearch configuration. For example: field("child.dob", { searchCriteriaLabelPrefix: TranslationConfig }).
     `
   ),
-  conditionals: import_zod25.z.array(FieldConditional).default([]).optional().describe(
+  conditionals: import_zod26.z.array(FieldConditional).default([]).optional().describe(
     `
        In advanced search, we sometimes need to override the default field visibility conditionals.
 
@@ -2485,20 +2527,20 @@ var BaseField3 = import_zod25.z.object({
        are always rendered in the advanced search form.
       `
   ),
-  validations: import_zod25.z.array(ValidationConfig).default([]).optional().describe(
+  validations: import_zod26.z.array(ValidationConfig).default([]).optional().describe(
     `Option for overriding the field validations specifically for advanced search form.`
   )
 });
-var SearchQueryParams = import_zod25.z.object({
-  eventType: import_zod25.z.string().optional().describe(
+var SearchQueryParams = import_zod26.z.object({
+  eventType: import_zod26.z.string().optional().describe(
     "Defines type of event so that when redirecting to Advanced Search page, appropriate tab can be selected"
   )
 }).catchall(FieldValue);
 var FieldConfigSchema = BaseField3.extend({
-  fieldId: import_zod25.z.string(),
-  fieldType: import_zod25.z.literal("field")
+  fieldId: import_zod26.z.string(),
+  fieldType: import_zod26.z.literal("field")
 });
-var EventFieldIdInput = import_zod25.z.enum([
+var EventFieldIdInput = import_zod26.z.enum([
   "trackingId",
   "status",
   "legalStatuses.REGISTERED.acceptedAt",
@@ -2507,7 +2549,7 @@ var EventFieldIdInput = import_zod25.z.enum([
   "updatedAt"
 ]);
 var METADATA_FIELD_PREFIX = "event.";
-var EventFieldId = import_zod25.z.enum([
+var EventFieldId = import_zod26.z.enum([
   `${METADATA_FIELD_PREFIX}trackingId`,
   `${METADATA_FIELD_PREFIX}status`,
   `${METADATA_FIELD_PREFIX}legalStatuses.REGISTERED.acceptedAt`,
@@ -2517,29 +2559,29 @@ var EventFieldId = import_zod25.z.enum([
 ]);
 var EventFieldConfigSchema = BaseField3.extend({
   fieldId: EventFieldId,
-  fieldType: import_zod25.z.literal("event")
+  fieldType: import_zod26.z.literal("event")
 });
-var AdvancedSearchField = import_zod25.z.discriminatedUnion("fieldType", [FieldConfigSchema, EventFieldConfigSchema]).superRefine((data, ctx) => {
+var AdvancedSearchField = import_zod26.z.discriminatedUnion("fieldType", [FieldConfigSchema, EventFieldConfigSchema]).superRefine((data, ctx) => {
   if (data.config.searchFields && data.config.searchFields.length > 0) {
     if (!data.label) {
       ctx.addIssue({
-        code: import_zod25.z.ZodIssueCode.custom,
+        code: import_zod26.z.ZodIssueCode.custom,
         message: "label is required when config.searchFields is defined.",
         path: ["label"]
       });
     }
     if (!data.type) {
       ctx.addIssue({
-        code: import_zod25.z.ZodIssueCode.custom,
+        code: import_zod26.z.ZodIssueCode.custom,
         message: "type is required when config.searchFields is defined.",
         path: ["type"]
       });
     }
   }
 });
-var AdvancedSearchConfig = import_zod25.z.object({
+var AdvancedSearchConfig = import_zod26.z.object({
   title: TranslationConfig.describe("Advanced search tab title"),
-  fields: import_zod25.z.array(AdvancedSearchField).describe("Advanced search fields within the tab.")
+  fields: import_zod26.z.array(AdvancedSearchField).describe("Advanced search fields within the tab.")
 });
 
 // ../commons/src/events/utils.ts
@@ -2548,14 +2590,14 @@ var import_lodash = require("lodash");
 // ../commons/src/conditionals/validate.ts
 var import__ = __toESM(require("ajv/dist/2019"));
 var import_ajv_formats = __toESM(require("ajv-formats"));
-var import_zod28 = require("zod");
+var import_zod29 = require("zod");
 var import_date_fns = require("date-fns");
 
 // ../commons/src/events/FieldTypeMapping.ts
-var import_zod27 = require("zod");
+var import_zod28 = require("zod");
 
 // ../commons/src/events/DynamicFieldValue.ts
-var import_zod26 = require("zod");
+var import_zod27 = require("zod");
 
 // ../commons/src/conditionals/validate.ts
 var ajv = new import__.default({
@@ -2564,9 +2606,9 @@ var ajv = new import__.default({
   strict: false
   // Allow minContains and other newer features
 });
-var DataContext = import_zod28.z.object({
-  rootData: import_zod28.z.object({
-    $leafAdminStructureLocationIds: import_zod28.z.array(import_zod28.z.object({ id: UUID }))
+var DataContext = import_zod29.z.object({
+  rootData: import_zod29.z.object({
+    $leafAdminStructureLocationIds: import_zod29.z.array(import_zod29.z.object({ id: UUID }))
   })
 });
 function resolveDataPath(rootData, dataPath, instancePath) {
@@ -2643,13 +2685,13 @@ ajv.addKeyword({
 });
 
 // ../commons/src/utils.ts
-var z29 = __toESM(require("zod"));
+var z30 = __toESM(require("zod"));
 var _ = __toESM(require("lodash"));
-var FullNameV1 = z29.array(
-  z29.object({
-    use: z29.string(),
-    family: z29.string(),
-    given: z29.array(z29.string())
+var FullNameV1 = z30.array(
+  z30.object({
+    use: z30.string(),
+    family: z30.string(),
+    given: z30.array(z30.string())
   })
 );
 function omitKeyDeep(obj, keyToRemove) {
@@ -3269,12 +3311,12 @@ function createFieldConditionals(fieldId) {
 }
 
 // ../commons/src/events/EventConfig.ts
-(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod29.z);
-var EventFieldReference = import_zod29.z.object({ $$event: EventMetadataDateFieldIdInput }).describe(
+(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod30.z);
+var EventFieldReference = import_zod30.z.object({ $$event: EventMetadataDateFieldIdInput }).describe(
   "Reference to a field defined in the event metadata, using the field id."
 );
-var EventConfig = import_zod29.z.object({
-  id: import_zod29.z.string().describe(
+var EventConfig = import_zod30.z.object({
+  id: import_zod30.z.string().describe(
     'Machine-readable identifier of the event (e.g. "birth", "death").'
   ),
   dateOfEvent: FieldReference.or(EventFieldReference).optional().describe(
@@ -3292,13 +3334,13 @@ var EventConfig = import_zod29.z.object({
   label: TranslationConfig.describe(
     "Human-readable label for the event type."
   ),
-  actions: import_zod29.z.array(ActionConfig).describe(
+  actions: import_zod30.z.array(ActionConfig).describe(
     "Configuration of system-defined actions associated with the event."
   ),
   declaration: DeclarationFormConfig.describe(
     "Configuration of the form used to gather event data."
   ),
-  advancedSearch: import_zod29.z.array(AdvancedSearchConfig).optional().default([]).describe(
+  advancedSearch: import_zod30.z.array(AdvancedSearchConfig).optional().default([]).describe(
     "Configuration of fields available in the advanced search feature."
   )
 }).superRefine((event2, ctx) => {
@@ -3362,7 +3404,7 @@ var defineActionForm = (actionForm) => ActionFormConfig.parse(actionForm);
 var defineFormPage = (formPage) => FormPageConfig.parse(formPage);
 
 // ../commons/src/events/WorkqueueConfig.ts
-var import_zod33 = require("zod");
+var import_zod34 = require("zod");
 
 // ../commons/src/searchConfigs.ts
 function createSearchConfig(baseField) {
@@ -3563,17 +3605,17 @@ var event = Object.assign(eventFn, {
 });
 
 // ../commons/src/events/WorkqueueColumnConfig.ts
-var import_zod30 = require("zod");
+var import_zod31 = require("zod");
 var WorkqueueColumnKeysArray = [
   ...EventMetadataKeysArray,
   "title",
   "outbox"
 ];
-var WorkqueueColumnKeys = import_zod30.z.enum(WorkqueueColumnKeysArray);
-var WorkqueueColumnValue = import_zod30.z.object({
+var WorkqueueColumnKeys = import_zod31.z.enum(WorkqueueColumnKeysArray);
+var WorkqueueColumnValue = import_zod31.z.object({
   $event: WorkqueueColumnKeys
 });
-var WorkqueueColumn = import_zod30.z.object({
+var WorkqueueColumn = import_zod31.z.object({
   label: TranslationConfig,
   value: WorkqueueColumnValue
 });
@@ -3584,58 +3626,58 @@ function defineWorkqueuesColumns(workqueueColumns) {
 }
 
 // ../commons/src/events/CountryConfigQueryInput.ts
-var import_zod31 = require("zod");
-var SerializableExact = import_zod31.z.object({
-  type: import_zod31.z.literal("exact"),
-  term: import_zod31.z.union([import_zod31.z.string(), SerializedUserField])
-});
-var SerializableWithin = import_zod31.z.object({
-  type: import_zod31.z.literal("within"),
-  location: import_zod31.z.union([import_zod31.z.string(), SerializedUserField])
-});
-var SerializedQueryExpression = import_zod31.z.object({
-  eventType: import_zod31.z.string(),
-  status: import_zod31.z.optional(import_zod31.z.union([AnyOfStatus, ExactStatus])),
-  createdAt: import_zod31.z.optional(DateCondition),
-  updatedAt: import_zod31.z.optional(DateCondition),
-  "legalStatuses.REGISTERED.createdAt": import_zod31.z.optional(DateCondition),
-  "legalStatuses.REGISTERED.createdAtLocation": import_zod31.z.optional(
-    import_zod31.z.union([Within, Exact])
+var import_zod32 = require("zod");
+var SerializableExact = import_zod32.z.object({
+  type: import_zod32.z.literal("exact"),
+  term: import_zod32.z.union([import_zod32.z.string(), SerializedUserField])
+});
+var SerializableWithin = import_zod32.z.object({
+  type: import_zod32.z.literal("within"),
+  location: import_zod32.z.union([import_zod32.z.string(), SerializedUserField])
+});
+var SerializedQueryExpression = import_zod32.z.object({
+  eventType: import_zod32.z.string(),
+  status: import_zod32.z.optional(import_zod32.z.union([AnyOfStatus, ExactStatus])),
+  createdAt: import_zod32.z.optional(DateCondition),
+  updatedAt: import_zod32.z.optional(DateCondition),
+  "legalStatuses.REGISTERED.createdAt": import_zod32.z.optional(DateCondition),
+  "legalStatuses.REGISTERED.createdAtLocation": import_zod32.z.optional(
+    import_zod32.z.union([Within, Exact])
   ),
-  "legalStatuses.REGISTERED.registrationNumber": import_zod31.z.optional(Exact),
-  createdAtLocation: import_zod31.z.optional(
-    import_zod31.z.union([SerializableWithin, SerializableExact])
+  "legalStatuses.REGISTERED.registrationNumber": import_zod32.z.optional(Exact),
+  createdAtLocation: import_zod32.z.optional(
+    import_zod32.z.union([SerializableWithin, SerializableExact])
   ),
-  updatedAtLocation: import_zod31.z.optional(
-    import_zod31.z.union([SerializableWithin, SerializableExact])
+  updatedAtLocation: import_zod32.z.optional(
+    import_zod32.z.union([SerializableWithin, SerializableExact])
   ),
-  updatedByUserRole: import_zod31.z.optional(SerializableExact),
-  assignedTo: import_zod31.z.optional(SerializableExact),
-  createdBy: import_zod31.z.optional(SerializableExact),
+  updatedByUserRole: import_zod32.z.optional(SerializableExact),
+  assignedTo: import_zod32.z.optional(SerializableExact),
+  createdBy: import_zod32.z.optional(SerializableExact),
   createdByUserType: ExactUserType,
-  updatedBy: import_zod31.z.optional(SerializableExact),
-  trackingId: import_zod31.z.optional(Exact),
-  flags: import_zod31.z.optional(ContainsFlags),
+  updatedBy: import_zod32.z.optional(SerializableExact),
+  trackingId: import_zod32.z.optional(Exact),
+  flags: import_zod32.z.optional(ContainsFlags),
   data: QueryInput
 }).partial();
-var Or2 = import_zod31.z.object({
-  type: import_zod31.z.literal("or"),
-  clauses: import_zod31.z.array(SerializedQueryExpression)
+var Or2 = import_zod32.z.object({
+  type: import_zod32.z.literal("or"),
+  clauses: import_zod32.z.array(SerializedQueryExpression)
 });
-var And2 = import_zod31.z.object({
-  type: import_zod31.z.literal("and"),
-  clauses: import_zod31.z.array(SerializedQueryExpression)
+var And2 = import_zod32.z.object({
+  type: import_zod32.z.literal("and"),
+  clauses: import_zod32.z.array(SerializedQueryExpression)
 });
-var CountryConfigQueryType = import_zod31.z.discriminatedUnion("type", [And2, Or2]);
-var CountryConfigQueryInputType = import_zod31.z.union([
+var CountryConfigQueryType = import_zod32.z.discriminatedUnion("type", [And2, Or2]);
+var CountryConfigQueryInputType = import_zod32.z.union([
   SerializedQueryExpression,
   And2,
   Or2
 ]);
 
 // ../commons/src/icons.ts
-var import_zod32 = require("zod");
-var AvailableIcons = import_zod32.z.enum([
+var import_zod33 = require("zod");
+var AvailableIcons = import_zod33.z.enum([
   "Archived",
   "Assigned",
   "Certified",
@@ -3756,23 +3798,23 @@ var mandatoryColumns = defineWorkqueuesColumns([
     value: event.field("updatedAt")
   }
 ]);
-var WorkqueueActionsWithDefault = import_zod33.z.enum([
+var WorkqueueActionsWithDefault = import_zod34.z.enum([
   ...workqueueActions.options,
   "DEFAULT"
 ]);
-var WorkqueueConfig = import_zod33.z.object({
-  slug: import_zod33.z.string().describe("Determines the url of the workqueue."),
+var WorkqueueConfig = import_zod34.z.object({
+  slug: import_zod34.z.string().describe("Determines the url of the workqueue."),
   name: TranslationConfig.describe(
     "Title of the workflow (both in navigation and on the page)"
   ),
   query: CountryConfigQueryType,
-  actions: import_zod33.z.array(
-    import_zod33.z.object({
+  actions: import_zod34.z.array(
+    import_zod34.z.object({
       type: WorkqueueActionsWithDefault,
-      conditionals: import_zod33.z.array(Conditional).optional()
+      conditionals: import_zod34.z.array(Conditional).optional()
     })
   ),
-  columns: import_zod33.z.array(WorkqueueColumn).default(mandatoryColumns),
+  columns: import_zod34.z.array(WorkqueueColumn).default(mandatoryColumns),
   icon: AvailableIcons,
   emptyMessage: TranslationConfig.optional()
 }).describe("Configuration for workqueue.");
@@ -3780,26 +3822,26 @@ var WorkqueueConfigWithoutQuery = WorkqueueConfig.omit({
   query: true,
   columns: true
 });
-var WorkqueueConfigInput = import_zod33.z.object({
-  slug: import_zod33.z.string().describe("Determines the url of the workqueue."),
+var WorkqueueConfigInput = import_zod34.z.object({
+  slug: import_zod34.z.string().describe("Determines the url of the workqueue."),
   name: TranslationConfig.describe(
     "Title of the workflow (both in navigation and on the page)"
   ),
   query: CountryConfigQueryInputType,
-  actions: import_zod33.z.array(
-    import_zod33.z.object({
+  actions: import_zod34.z.array(
+    import_zod34.z.object({
       type: WorkqueueActionsWithDefault,
-      conditionals: import_zod33.z.array(Conditional).optional()
+      conditionals: import_zod34.z.array(Conditional).optional()
     })
   ),
-  columns: import_zod33.z.array(WorkqueueColumn).default(mandatoryColumns),
+  columns: import_zod34.z.array(WorkqueueColumn).default(mandatoryColumns),
   icon: AvailableIcons,
   emptyMessage: TranslationConfig.optional()
 });
-var WorkqueueCountInput = import_zod33.z.array(
-  import_zod33.z.object({ slug: import_zod33.z.string(), query: QueryType })
+var WorkqueueCountInput = import_zod34.z.array(
+  import_zod34.z.object({ slug: import_zod34.z.string(), query: QueryType })
 );
-var WorkqueueCountOutput = import_zod33.z.record(import_zod33.z.string(), import_zod33.z.number());
+var WorkqueueCountOutput = import_zod34.z.record(import_zod34.z.string(), import_zod34.z.number());
 
 // ../commons/src/events/workqueueDefaultColumns.ts
 var defaultWorkqueueColumns = [
@@ -3822,53 +3864,53 @@ var defaultWorkqueueColumns = [
 ];
 
 // ../commons/src/events/Draft.ts
-var import_zod35 = require("zod");
+var import_zod36 = require("zod");
 
 // ../commons/src/events/ActionInput.ts
-var import_zod34 = require("zod");
+var import_zod35 = require("zod");
 var import_zod_openapi11 = require("zod-openapi");
-(0, import_zod_openapi11.extendZodWithOpenApi)(import_zod34.z);
-var BaseActionInput = import_zod34.z.object({
+(0, import_zod_openapi11.extendZodWithOpenApi)(import_zod35.z);
+var BaseActionInput = import_zod35.z.object({
   eventId: UUID,
-  transactionId: import_zod34.z.string(),
+  transactionId: import_zod35.z.string(),
   declaration: ActionUpdate.default({}),
   annotation: ActionUpdate.optional(),
   originalActionId: UUID.optional(),
   // should not be part of base action.
-  keepAssignment: import_zod34.z.boolean().optional(),
-  keepAssignmentIfAccepted: import_zod34.z.boolean().optional(),
-  keepAssignmentIfRejected: import_zod34.z.boolean().optional(),
+  keepAssignment: import_zod35.z.boolean().optional(),
+  keepAssignmentIfAccepted: import_zod35.z.boolean().optional(),
+  keepAssignmentIfRejected: import_zod35.z.boolean().optional(),
   // For normal users, the createdAtLocation is resolved on the backend from the user's primaryOfficeId.
   createdAtLocation: CreatedAtLocation.describe(
     "A valid office location ID. This is required for system users performing actions. The provided location must be a leaf-location, i.e. it must not have any children locations."
   )
 });
 var CreateActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    type: import_zod34.z.literal(ActionType.CREATE).default(ActionType.CREATE),
+  import_zod35.z.object({
+    type: import_zod35.z.literal(ActionType.CREATE).default(ActionType.CREATE),
     createdAtLocation: CreatedAtLocation
   })
 );
 var RegisterActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    type: import_zod34.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
-    registrationNumber: import_zod34.z.string().optional()
+  import_zod35.z.object({
+    type: import_zod35.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
+    registrationNumber: import_zod35.z.string().optional()
   })
 ).strict();
 var ValidateActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    type: import_zod34.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE)
+  import_zod35.z.object({
+    type: import_zod35.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE)
   })
 );
 var EscalateActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    type: import_zod34.z.literal(ActionType.ESCALATE).default(ActionType.ESCALATE),
+  import_zod35.z.object({
+    type: import_zod35.z.literal(ActionType.ESCALATE).default(ActionType.ESCALATE),
     content: ReasonContent
   })
 );
 var NotifyActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    type: import_zod34.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
+  import_zod35.z.object({
+    type: import_zod35.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
   })
 ).openapi({
   default: {
@@ -3880,86 +3922,86 @@ var NotifyActionInput = BaseActionInput.merge(
   }
 });
 var DeclareActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    type: import_zod34.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
+  import_zod35.z.object({
+    type: import_zod35.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
   })
 );
 var PrintCertificateActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    type: import_zod34.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE),
+  import_zod35.z.object({
+    type: import_zod35.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE),
     content: PrintContent.optional()
   })
 );
 var RejectDeclarationActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    type: import_zod34.z.literal(ActionType.REJECT).default(ActionType.REJECT),
+  import_zod35.z.object({
+    type: import_zod35.z.literal(ActionType.REJECT).default(ActionType.REJECT),
     content: ReasonContent
   })
 );
 var DuplicateDetectedActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    type: import_zod34.z.literal(ActionType.DUPLICATE_DETECTED).default(ActionType.DUPLICATE_DETECTED),
-    content: import_zod34.z.object({
-      duplicates: import_zod34.z.array(PotentialDuplicate)
+  import_zod35.z.object({
+    type: import_zod35.z.literal(ActionType.DUPLICATE_DETECTED).default(ActionType.DUPLICATE_DETECTED),
+    content: import_zod35.z.object({
+      duplicates: import_zod35.z.array(PotentialDuplicate)
     })
   })
 );
 var MarkAsDuplicateActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    type: import_zod34.z.literal(ActionType.MARK_AS_DUPLICATE).default(ActionType.MARK_AS_DUPLICATE),
-    content: import_zod34.z.object({
+  import_zod35.z.object({
+    type: import_zod35.z.literal(ActionType.MARK_AS_DUPLICATE).default(ActionType.MARK_AS_DUPLICATE),
+    content: import_zod35.z.object({
       duplicateOf: UUID
     }).optional()
   })
 );
 var MarkNotDuplicateActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    type: import_zod34.z.literal(ActionType.MARK_AS_NOT_DUPLICATE).default(ActionType.MARK_AS_NOT_DUPLICATE)
+  import_zod35.z.object({
+    type: import_zod35.z.literal(ActionType.MARK_AS_NOT_DUPLICATE).default(ActionType.MARK_AS_NOT_DUPLICATE)
   })
 );
 var ArchiveActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    type: import_zod34.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE),
+  import_zod35.z.object({
+    type: import_zod35.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE),
     content: ReasonContent
   })
 );
 var AssignActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    type: import_zod34.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod34.z.string()
+  import_zod35.z.object({
+    type: import_zod35.z.literal(ActionType.ASSIGN),
+    assignedTo: import_zod35.z.string()
   })
 );
 var UnassignActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    type: import_zod34.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
-    assignedTo: import_zod34.z.literal(null).default(null)
+  import_zod35.z.object({
+    type: import_zod35.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
+    assignedTo: import_zod35.z.literal(null).default(null)
   })
 );
 var RequestCorrectionActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    type: import_zod34.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
+  import_zod35.z.object({
+    type: import_zod35.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
   })
 );
 var RejectCorrectionActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    requestId: import_zod34.z.string(),
-    type: import_zod34.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION),
+  import_zod35.z.object({
+    requestId: import_zod35.z.string(),
+    type: import_zod35.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION),
     content: ReasonContent
   })
 );
 var ApproveCorrectionActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    requestId: import_zod34.z.string(),
-    type: import_zod34.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
+  import_zod35.z.object({
+    requestId: import_zod35.z.string(),
+    type: import_zod35.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
   })
 );
 var ReadActionInput = BaseActionInput.merge(
-  import_zod34.z.object({
-    type: import_zod34.z.literal(ActionType.READ).default(ActionType.READ)
+  import_zod35.z.object({
+    type: import_zod35.z.literal(ActionType.READ).default(ActionType.READ)
   })
 );
-var DeleteActionInput = import_zod34.z.object({ eventId: UUID });
-var ActionInput = import_zod34.z.discriminatedUnion("type", [
+var DeleteActionInput = import_zod35.z.object({ eventId: UUID });
+var ActionInput = import_zod35.z.discriminatedUnion("type", [
   CreateActionInput.openapi({ ref: "CreateActionInput" }),
   ValidateActionInput.openapi({ ref: "ValidateActionInput" }),
   EscalateActionInput.openapi({ ref: "EscalateActionInput" }),
@@ -3995,11 +4037,11 @@ var ActionInput = import_zod34.z.discriminatedUnion("type", [
 });
 
 // ../commons/src/events/Draft.ts
-var Draft = import_zod35.z.object({
+var Draft = import_zod36.z.object({
   id: UUID,
   eventId: UUID,
-  transactionId: import_zod35.z.string(),
-  createdAt: import_zod35.z.string().datetime(),
+  transactionId: import_zod36.z.string(),
+  createdAt: import_zod36.z.string().datetime(),
   action: ActionBase.extend({
     type: ActionTypes.exclude([ActionTypes.Enum.DELETE])
   }).omit({ id: true, createdAtLocation: true })
@@ -4008,7 +4050,7 @@ var Draft = import_zod35.z.object({
 );
 var DraftInput = BaseActionInput.extend({
   type: ActionTypes.exclude([ActionTypes.Enum.DELETE]),
-  status: import_zod35.z.enum([
+  status: import_zod36.z.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
@@ -4016,26 +4058,26 @@ var DraftInput = BaseActionInput.extend({
 });
 
 // ../commons/src/events/EventInput.ts
-var import_zod36 = require("zod");
+var import_zod37 = require("zod");
 var import_uuid10 = require("uuid");
-var EventInput = import_zod36.z.object({
-  transactionId: import_zod36.z.string(),
-  type: import_zod36.z.string()
+var EventInput = import_zod37.z.object({
+  transactionId: import_zod37.z.string(),
+  type: import_zod37.z.string()
 }).openapi({ default: { transactionId: (0, import_uuid10.v4)(), type: "birth" } });
 
 // ../commons/src/events/EventDocument.ts
-var import_zod37 = require("zod");
+var import_zod38 = require("zod");
 var import_zod_openapi12 = require("zod-openapi");
-(0, import_zod_openapi12.extendZodWithOpenApi)(import_zod37.z);
-var EventDocument = import_zod37.z.object({
+(0, import_zod_openapi12.extendZodWithOpenApi)(import_zod38.z);
+var EventDocument = import_zod38.z.object({
   id: UUID.describe("Unique identifier of the event."),
-  type: import_zod37.z.string().describe("Type of the event (e.g. birth, death, marriage)."),
-  createdAt: import_zod37.z.string().datetime().describe("Timestamp indicating when the event was created."),
-  updatedAt: import_zod37.z.string().datetime().describe(
+  type: import_zod38.z.string().describe("Type of the event (e.g. birth, death, marriage)."),
+  createdAt: import_zod38.z.string().datetime().describe("Timestamp indicating when the event was created."),
+  updatedAt: import_zod38.z.string().datetime().describe(
     "Timestamp of the last update, excluding changes from actions."
   ),
-  actions: import_zod37.z.array(Action).describe("Ordered list of actions associated with the event."),
-  trackingId: import_zod37.z.string().describe(
+  actions: import_zod38.z.array(Action).describe("Ordered list of actions associated with the event."),
+  trackingId: import_zod38.z.string().describe(
     "System-generated tracking identifier used to look up the event."
   )
 }).openapi({ ref: "EventDocument" });
@@ -6546,8 +6588,8 @@ var digitalIdentityEvent = defineConfig({
 });
 
 // ../commons/src/events/test.utils.ts
-var import_zod38 = require("zod");
-var TestUserRole = import_zod38.z.enum([
+var import_zod39 = require("zod");
+var TestUserRole = import_zod39.z.enum([
   "FIELD_AGENT",
   "LOCAL_REGISTRAR",
   "LOCAL_SYSTEM_ADMIN",
@@ -6654,22 +6696,22 @@ var ACTION_FILTERS = {
 var import_lodash6 = require("lodash");
 
 // ../commons/src/events/locations.ts
-var import_zod39 = require("zod");
-var LocationType = import_zod39.z.enum([
+var import_zod40 = require("zod");
+var LocationType = import_zod40.z.enum([
   "ADMIN_STRUCTURE",
   "CRVS_OFFICE",
   "HEALTH_FACILITY"
 ]);
-var Location = import_zod39.z.object({
+var Location = import_zod40.z.object({
   id: UUID,
-  name: import_zod39.z.string(),
+  name: import_zod40.z.string(),
   parentId: UUID.nullable(),
-  validUntil: import_zod39.z.string().datetime().nullable(),
+  validUntil: import_zod40.z.string().datetime().nullable(),
   locationType: LocationType.nullable()
 });
 
 // ../commons/src/notification/UserNotifications.ts
-var import_zod40 = require("zod");
+var import_zod41 = require("zod");
 var TriggerEvent = {
   USER_CREATED: "user-created",
   USER_UPDATED: "user-updated",
@@ -6681,50 +6723,50 @@ var TriggerEvent = {
   CHANGE_PHONE_NUMBER: "change-phone-number",
   CHANGE_EMAIL_ADDRESS: "change-email-address"
 };
-var Recipient = import_zod40.z.object({
+var Recipient = import_zod41.z.object({
   name: NameFieldValue.optional(),
-  mobile: import_zod40.z.string().optional(),
-  email: import_zod40.z.string().optional(),
-  bcc: import_zod40.z.array(import_zod40.z.string()).optional()
+  mobile: import_zod41.z.string().optional(),
+  email: import_zod41.z.string().optional(),
+  bcc: import_zod41.z.array(import_zod41.z.string()).optional()
 });
-var BasePayload = import_zod40.z.object({
+var BasePayload = import_zod41.z.object({
   recipient: Recipient
 });
 var TriggerPayload = {
   [TriggerEvent.USER_CREATED]: BasePayload.extend({
-    username: import_zod40.z.string(),
-    temporaryPassword: import_zod40.z.string()
+    username: import_zod41.z.string(),
+    temporaryPassword: import_zod41.z.string()
   }),
   [TriggerEvent.USER_UPDATED]: BasePayload.extend({
-    oldUsername: import_zod40.z.string(),
-    newUsername: import_zod40.z.string()
+    oldUsername: import_zod41.z.string(),
+    newUsername: import_zod41.z.string()
   }),
   [TriggerEvent.USERNAME_REMINDER]: BasePayload.extend({
-    username: import_zod40.z.string()
+    username: import_zod41.z.string()
   }),
   [TriggerEvent.RESET_PASSWORD]: BasePayload.extend({
-    code: import_zod40.z.string()
+    code: import_zod41.z.string()
   }),
   [TriggerEvent.RESET_PASSWORD_BY_ADMIN]: BasePayload.extend({
-    temporaryPassword: import_zod40.z.string(),
-    admin: import_zod40.z.object({
-      id: import_zod40.z.string(),
+    temporaryPassword: import_zod41.z.string(),
+    admin: import_zod41.z.object({
+      id: import_zod41.z.string(),
       name: NameFieldValue,
-      role: import_zod40.z.string()
+      role: import_zod41.z.string()
     })
   }),
   [TriggerEvent.TWO_FA]: BasePayload.extend({
-    code: import_zod40.z.string()
+    code: import_zod41.z.string()
   }),
   [TriggerEvent.ALL_USER_NOTIFICATION]: BasePayload.extend({
-    subject: import_zod40.z.string(),
-    body: import_zod40.z.string()
+    subject: import_zod41.z.string(),
+    body: import_zod41.z.string()
   }),
   [TriggerEvent.CHANGE_PHONE_NUMBER]: BasePayload.extend({
-    code: import_zod40.z.string()
+    code: import_zod41.z.string()
   }),
   [TriggerEvent.CHANGE_EMAIL_ADDRESS]: BasePayload.extend({
-    code: import_zod40.z.string()
+    code: import_zod41.z.string()
   })
 };
 async function triggerUserEventNotification({