@opencrvs/toolkit 1.9.6-rc.b9a5c96 → 1.9.6-rc.bb63e64

package/dist/notification/index.js

@@ -38,6 +38,7 @@ __export(notification_exports, {
   triggerUserEventNotification: () => triggerUserEventNotification
 });
 module.exports = __toCommonJS(notification_exports);
+var z41 = __toESM(require("zod/v4"));
 
 // ../commons/src/url.ts
 function joinUrl(base, path) {
@@ -47,30 +48,28 @@ function joinUrl(base, path) {
 
 // ../commons/src/events/Constants.ts
 var TENNIS_CLUB_MEMBERSHIP = "tennis-club-membership";
-var BIRTH_EVENT = "birth";
+var CHILD_ONBOARDING_EVENT = "child-onboarding";
 
 // ../commons/src/events/ActionConfig.ts
-var import_zod19 = require("zod");
+var z22 = __toESM(require("zod/v4"));
 
 // ../commons/src/events/TranslationConfig.ts
-var import_zod = require("zod");
-var import_zod_openapi = require("zod-openapi");
-(0, import_zod_openapi.extendZodWithOpenApi)(import_zod.z);
-var TranslationConfig = import_zod.z.object({
-  id: import_zod.z.string().describe(
+var z = __toESM(require("zod/v4"));
+var TranslationConfig = z.object({
+  id: z.string().describe(
     "The identifier of the translation referred in translation CSV files"
   ),
-  defaultMessage: import_zod.z.string().describe("Default translation message"),
-  description: import_zod.z.string().describe(
+  defaultMessage: z.string().describe("Default translation message"),
+  description: z.string().describe(
     "Describe the translation for a translator to be able to identify it."
   )
-}).openapi({
+}).meta({
   description: "Translation configuration",
-  ref: "TranslationConfig"
+  id: "TranslationConfig"
 });
 
 // ../commons/src/events/ActionType.ts
-var import_zod2 = require("zod");
+var z2 = __toESM(require("zod/v4"));
 var ActionType = {
   // Pre-declaration actions
   DELETE: "DELETE",
@@ -78,8 +77,8 @@ var ActionType = {
   NOTIFY: "NOTIFY",
   // Declaration actions
   DECLARE: "DECLARE",
-  VALIDATE: "VALIDATE",
   REGISTER: "REGISTER",
+  EDIT: "EDIT",
   // Declaration system actions. Non-configurable.
   DUPLICATE_DETECTED: "DUPLICATE_DETECTED",
   REJECT: "REJECT",
@@ -95,26 +94,29 @@ var ActionType = {
   // General actions
   READ: "READ",
   ASSIGN: "ASSIGN",
-  UNASSIGN: "UNASSIGN"
+  UNASSIGN: "UNASSIGN",
+  // Custom action
+  CUSTOM: "CUSTOM"
 };
 var ConfirmableActions = [
   ActionType.NOTIFY,
   ActionType.DECLARE,
-  ActionType.VALIDATE,
+  ActionType.EDIT,
   ActionType.REGISTER,
   ActionType.REJECT,
   ActionType.ARCHIVE,
   ActionType.PRINT_CERTIFICATE,
   ActionType.REQUEST_CORRECTION,
   ActionType.APPROVE_CORRECTION,
-  ActionType.REJECT_CORRECTION
+  ActionType.REJECT_CORRECTION,
+  ActionType.CUSTOM
 ];
-var ActionTypes = import_zod2.z.enum([
+var ActionTypes = z2.enum([
   "DELETE",
   "CREATE",
   "NOTIFY",
   "DECLARE",
-  "VALIDATE",
+  "EDIT",
   "REGISTER",
   "DUPLICATE_DETECTED",
   "REJECT",
@@ -127,14 +129,15 @@ var ActionTypes = import_zod2.z.enum([
   "APPROVE_CORRECTION",
   "READ",
   "ASSIGN",
-  "UNASSIGN"
+  "UNASSIGN",
+  "CUSTOM"
 ]);
 var ClientSpecificAction = {
   REVIEW_CORRECTION_REQUEST: "REVIEW_CORRECTION_REQUEST"
 };
 var declarationActionValues = [
   ActionTypes.enum.DECLARE,
-  ActionTypes.enum.VALIDATE,
+  ActionTypes.enum.EDIT,
   ActionTypes.enum.REGISTER,
   ActionTypes.enum.NOTIFY,
   ActionTypes.enum.DUPLICATE_DETECTED
@@ -155,13 +158,14 @@ var writeActions = ActionTypes.exclude([
   ActionType.UNASSIGN
 ]);
 var workqueueActions = ActionTypes.exclude([
+  ActionType.READ,
   ActionType.CREATE,
   ActionType.NOTIFY,
   ActionType.DUPLICATE_DETECTED,
-  ActionType.REJECT,
   ActionType.MARK_AS_NOT_DUPLICATE,
   ActionType.REJECT_CORRECTION,
-  ActionType.APPROVE_CORRECTION
+  ActionType.APPROVE_CORRECTION,
+  ActionType.CUSTOM
 ]);
 var META_ACTIONS = [
   ActionType.ASSIGN,
@@ -170,59 +174,57 @@ var META_ACTIONS = [
 ];
 
 // ../commons/src/events/FieldConfig.ts
-var import_zod15 = require("zod");
+var z17 = __toESM(require("zod/v4"));
 
 // ../commons/src/events/Conditional.ts
-var import_zod3 = require("zod");
-var import_zod_openapi2 = require("zod-openapi");
-(0, import_zod_openapi2.extendZodWithOpenApi)(import_zod3.z);
-var Conditional = import_zod3.z.custom((val) => typeof val === "object" && val !== null).openapi({
+var z3 = __toESM(require("zod/v4"));
+var Conditional = z3.any().describe("JSONSchema").meta({
   description: "JSON schema conditional configuration",
-  ref: "Conditional"
+  id: "Conditional"
 });
 var ConditionalType = {
   SHOW: "SHOW",
   ENABLE: "ENABLE",
   DISPLAY_ON_REVIEW: "DISPLAY_ON_REVIEW"
 };
-var ShowConditional = import_zod3.z.object({
-  type: import_zod3.z.literal(ConditionalType.SHOW),
+var ShowConditional = z3.object({
+  type: z3.literal(ConditionalType.SHOW),
   conditional: Conditional
 }).describe(
   "If 'SHOW' conditional is defined, the component is shown to the user only if the condition is met"
 );
-var EnableConditional = import_zod3.z.object({
-  type: import_zod3.z.literal(ConditionalType.ENABLE),
+var EnableConditional = z3.object({
+  type: z3.literal(ConditionalType.ENABLE),
   conditional: Conditional
 }).describe(
   "If 'ENABLE' conditional is defined, the component is enabled only if the condition is met"
 );
-var ActionConditional = import_zod3.z.discriminatedUnion("type", [
+var ActionConditional = z3.discriminatedUnion("type", [
   // Action can be shown / hidden
   ShowConditional,
   // Action can be shown to the user in the list but as disabled
   EnableConditional
 ]);
-var DisplayOnReviewConditional = import_zod3.z.object({
-  type: import_zod3.z.literal(ConditionalType.DISPLAY_ON_REVIEW),
+var DisplayOnReviewConditional = z3.object({
+  type: z3.literal(ConditionalType.DISPLAY_ON_REVIEW),
   conditional: Conditional
 }).describe(
   "If 'DISPLAY_ON_REVIEW' conditional is defined, the component is shown on the review page only if both the 'DISPLAY_ON_REVIEW' and 'SHOW' conditions are met. This should only be used for fields within declaration forms, as they are the only ones with review pages."
 );
-var FieldConditional = import_zod3.z.discriminatedUnion("type", [
+var FieldConditional = z3.discriminatedUnion("type", [
   // Field input can be shown / hidden
   ShowConditional,
   // Field input can be shown to the user but as disabled
   EnableConditional,
   // Field output can be shown / hidden on the review page
   DisplayOnReviewConditional
-]).openapi({
+]).meta({
   description: "Field conditional configuration",
-  ref: "FieldConditional"
+  id: "FieldConditional"
 });
 
 // ../commons/src/events/FieldType.ts
-var import_zod4 = require("zod");
+var z4 = __toESM(require("zod/v4"));
 var FieldType = {
   NAME: "NAME",
   PHONE: "PHONE",
@@ -265,9 +267,21 @@ var FieldType = {
   QUERY_PARAM_READER: "QUERY_PARAM_READER",
   QR_READER: "QR_READER",
   ID_READER: "ID_READER",
-  LOADER: "LOADER"
+  LOADER: "LOADER",
+  ALPHA_HIDDEN: "ALPHA_HIDDEN",
+  /**
+   * @internal
+   * @experimental
+   *
+   * Internal API used by the OpenCRVS core team for experimentation.
+   *
+   * This component is not part of the public, stable API.
+   * Its shape, behavior, or existence may change at any time or be removed
+   * entirely without notice.
+   */
+  _EXPERIMENTAL_CUSTOM: "CUSTOM"
 };
-var FileFieldType = import_zod4.z.enum([
+var FileFieldType = z4.enum([
   FieldType.FILE,
   FieldType.FILE_WITH_OPTIONS,
   FieldType.SIGNATURE
@@ -291,154 +305,155 @@ var FieldTypesToHideInReview = [
   FieldType.LOADER,
   FieldType.HTTP,
   FieldType.QUERY_PARAM_READER,
-  FieldType.DATA
+  FieldType.DATA,
+  FieldType.ALPHA_HIDDEN
 ];
 
 // ../commons/src/events/FieldValue.ts
-var import_zod7 = require("zod");
+var z7 = __toESM(require("zod/v4"));
 
 // ../commons/src/documents.ts
-var import_zod5 = require("zod");
-var import_zod_openapi3 = require("zod-openapi");
-(0, import_zod_openapi3.extendZodWithOpenApi)(import_zod5.z);
-var FullDocumentUrl = import_zod5.z.string().brand("FullDocumentUrl").describe(
+var z5 = __toESM(require("zod/v4"));
+var FullDocumentUrl = z5.string().brand("FullDocumentUrl").describe(
   "A full url with protocol, host, bucket name, starting from the root of the S3 server, https://minio.opencrvs.com/bucket-name/document-id.jpg"
 );
-var FullDocumentPath = import_zod5.z.string().transform((val) => val.startsWith("/") ? val : `/${val}`).openapi({ effectType: "input", type: "string" }).describe(
+var FullDocumentPath = z5.string().overwrite((val) => val.startsWith("/") ? val : `/${val}`).meta({ effectType: "input", type: "string" }).describe(
   "A full absolute path with bucket name, starting from the root of the S3 server, /bucket-name/document-id.jpg"
 );
-var DocumentPath = import_zod5.z.string().brand("DocumentPath").describe(
+var DocumentPath = z5.string().brand("DocumentPath").describe(
   "A full identifier starting from the root of the S3 bucket, e.g. /document-id.jpg or /directory/document-id.jpg but never /bucket-name/document-id.jpg"
 );
 
 // ../commons/src/events/CompositeFieldValue.ts
-var import_zod6 = require("zod");
+var z6 = __toESM(require("zod/v4"));
 var AddressType = {
   DOMESTIC: "DOMESTIC",
   INTERNATIONAL: "INTERNATIONAL"
 };
-var FileFieldValue = import_zod6.z.object({
+var FileFieldValue = z6.object({
   path: FullDocumentPath,
-  originalFilename: import_zod6.z.string(),
-  type: import_zod6.z.string()
-});
-var NameFieldValue = import_zod6.z.object({
-  firstname: import_zod6.z.string(),
-  surname: import_zod6.z.string(),
-  middlename: import_zod6.z.string().optional()
-});
-var NameFieldUpdateValue = import_zod6.z.object({
-  firstname: import_zod6.z.string().nullish(),
-  surname: import_zod6.z.string().nullish(),
-  middlename: import_zod6.z.string().nullish()
-}).or(import_zod6.z.null()).or(import_zod6.z.undefined());
-var StreetLevelDetailsValue = import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).optional();
-var StreetLevelDetailsUpdateValue = import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string().nullable()).nullish();
-var BaseAddressFieldValue = import_zod6.z.object({
-  country: import_zod6.z.string(),
+  originalFilename: z6.string(),
+  type: z6.string()
+});
+var NameFieldValue = z6.object({
+  firstname: z6.string(),
+  surname: z6.string(),
+  middlename: z6.string().optional()
+});
+var NameFieldUpdateValue = z6.object({
+  firstname: z6.string().nullish(),
+  surname: z6.string().nullish(),
+  middlename: z6.string().nullish()
+}).or(z6.null()).or(z6.undefined());
+var StreetLevelDetailsValue = z6.record(z6.string(), z6.string()).optional();
+var StreetLevelDetailsUpdateValue = z6.record(z6.string(), z6.string().nullable()).nullish();
+var BaseAddressFieldValue = z6.object({
+  country: z6.string(),
   streetLevelDetails: StreetLevelDetailsValue
 });
-var BaseAddressFieldUpdateValue = import_zod6.z.object({
-  country: import_zod6.z.string().nullish(),
+var BaseAddressFieldUpdateValue = z6.object({
+  country: z6.string().nullish(),
   streetLevelDetails: StreetLevelDetailsUpdateValue
 });
 var DomesticAddressFieldValue = BaseAddressFieldValue.extend({
-  addressType: import_zod6.z.literal(AddressType.DOMESTIC),
-  administrativeArea: import_zod6.z.string().uuid()
+  addressType: z6.literal(AddressType.DOMESTIC),
+  administrativeArea: z6.string().uuid()
 });
 var InternationalAddressFieldValue = BaseAddressFieldValue.extend({
-  addressType: import_zod6.z.literal(AddressType.INTERNATIONAL)
+  addressType: z6.literal(AddressType.INTERNATIONAL)
 });
-var AddressFieldValue = import_zod6.z.discriminatedUnion("addressType", [
+var AddressFieldValue = z6.discriminatedUnion("addressType", [
   DomesticAddressFieldValue,
   InternationalAddressFieldValue
 ]);
 var DomesticAddressUpdateFieldValue = BaseAddressFieldUpdateValue.extend({
-  addressType: import_zod6.z.literal(AddressType.DOMESTIC),
-  administrativeArea: import_zod6.z.string().uuid().nullish()
+  addressType: z6.literal(AddressType.DOMESTIC),
+  administrativeArea: z6.string().uuid().nullish()
   /* Leaf level admin structure */
 });
 var InternationalAddressUpdateFieldValue = BaseAddressFieldUpdateValue.extend(
   {
-    addressType: import_zod6.z.literal(AddressType.INTERNATIONAL)
+    addressType: z6.literal(AddressType.INTERNATIONAL)
   }
 );
-var AddressFieldUpdateValue = import_zod6.z.discriminatedUnion("addressType", [
+var AddressFieldUpdateValue = z6.discriminatedUnion("addressType", [
   DomesticAddressUpdateFieldValue,
   InternationalAddressUpdateFieldValue
 ]).nullish();
-var FileFieldValueWithOption = import_zod6.z.object({
+var FileFieldValueWithOption = z6.object({
   path: FullDocumentPath,
-  originalFilename: import_zod6.z.string(),
-  type: import_zod6.z.string(),
-  option: import_zod6.z.string()
-});
-var FileFieldWithOptionValue = import_zod6.z.array(FileFieldValueWithOption);
-var HttpFieldValue = import_zod6.z.object({
-  loading: import_zod6.z.boolean(),
-  error: import_zod6.z.object({ statusCode: import_zod6.z.number(), message: import_zod6.z.string() }).nullish(),
-  data: import_zod6.z.any()
-});
-var HttpFieldUpdateValue = import_zod6.z.object({
-  loading: import_zod6.z.boolean().nullish(),
-  error: import_zod6.z.object({ statusCode: import_zod6.z.number(), message: import_zod6.z.string() }).nullish(),
-  data: import_zod6.z.any().nullish()
-}).or(import_zod6.z.null()).or(import_zod6.z.undefined());
-var QueryParamReaderFieldValue = import_zod6.z.object({
-  data: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string())
+  originalFilename: z6.string(),
+  type: z6.string(),
+  option: z6.string()
+});
+var FileFieldWithOptionValue = z6.array(FileFieldValueWithOption);
+var HttpFieldValue = z6.object({
+  loading: z6.boolean(),
+  error: z6.object({ statusCode: z6.number(), message: z6.string() }).nullish(),
+  data: z6.any()
+});
+var HttpFieldUpdateValue = z6.object({
+  loading: z6.boolean().nullish(),
+  error: z6.object({ statusCode: z6.number(), message: z6.string() }).nullish(),
+  data: z6.any().nullish()
+}).or(z6.null()).or(z6.undefined());
+var QueryParamReaderFieldValue = z6.object({
+  data: z6.record(z6.string(), z6.string())
 }).nullish();
-var QueryParamReaderFieldUpdateValue = import_zod6.z.object({
-  data: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string())
+var QueryParamReaderFieldUpdateValue = z6.object({
+  data: z6.record(z6.string(), z6.string())
 });
-var ReadDataValue = import_zod6.z.object({
-  data: import_zod6.z.any()
+var ReadDataValue = z6.object({
+  data: z6.any()
 });
 var QrReaderFieldValue = ReadDataValue;
 var IdReaderFieldValue = ReadDataValue;
-var NumberWithUnitFieldValue = import_zod6.z.object({
-  numericValue: import_zod6.z.number(),
-  unit: import_zod6.z.string()
+var NumberWithUnitFieldValue = z6.object({
+  numericValue: z6.number(),
+  unit: z6.string()
 });
-var NumberWithUnitFieldUpdateValue = import_zod6.z.object({
-  numericValue: import_zod6.z.number().optional(),
-  unit: import_zod6.z.string().optional()
+var NumberWithUnitFieldUpdateValue = z6.object({
+  numericValue: z6.number().optional(),
+  unit: z6.string().optional()
 });
+var CustomFieldValue = z6.unknown().brand("CustomFieldValue");
 
 // ../commons/src/events/FieldValue.ts
-var TextValue = import_zod7.z.string();
+var TextValue = z7.string();
+var HiddenFieldValue = z7.string();
 var NonEmptyTextValue = TextValue.min(1);
-var DateValue = import_zod7.z.string().date().describe("Date in the format YYYY-MM-DD");
-var AgeValue = import_zod7.z.object({
-  age: import_zod7.z.number(),
-  asOfDateRef: import_zod7.z.string()
+var DateValue = z7.iso.date().describe("Date in the format YYYY-MM-DD");
+var AgeValue = z7.object({
+  age: z7.number(),
+  asOfDateRef: z7.string()
 });
 var AgeUpdateValue = AgeValue.optional().nullable();
-var TimeValue = import_zod7.z.string().regex(/^([01][0-9]|2[0-3]):[0-5][0-9]$/);
-var DatetimeValue = import_zod7.z.string().datetime();
-var SelectDateRangeValue = import_zod7.z.enum([
+var TimeValue = z7.string().regex(/^([01][0-9]|2[0-3]):[0-5][0-9]$/);
+var DatetimeValue = z7.iso.datetime();
+var SelectDateRangeValue = z7.enum([
   "last7Days",
   "last30Days",
   "last90Days",
   "last365Days"
 ]);
-var DateRangeFieldValue = import_zod7.z.object({
+var DateRangeFieldValue = z7.object({
   start: DateValue,
   end: DateValue
 }).or(DateValue).describe(
   "Date range with start and end dates in the format YYYY-MM-DD. Inclusive start, exclusive end."
 );
-var EmailValue = import_zod7.z.string().email();
-var CheckboxFieldValue = import_zod7.z.boolean();
-var NumberFieldValue = import_zod7.z.number();
-var SignatureFieldValue = import_zod7.z.string();
-var ButtonFieldValue = import_zod7.z.number();
-var VerificationStatusValue = import_zod7.z.enum([
+var EmailValue = z7.email();
+var CheckboxFieldValue = z7.boolean();
+var NumberFieldValue = z7.number();
+var SignatureFieldValue = z7.string();
+var ButtonFieldValue = z7.number();
+var VerificationStatusValue = z7.enum([
   "verified",
   "authenticated",
   "failed",
   "pending"
 ]);
-var FieldValuesWithoutDataField = import_zod7.z.union([
+var FieldValuesWithoutDataField = z7.union([
   AddressFieldValue,
   TextValue,
   DateValue,
@@ -459,12 +474,13 @@ var FieldValuesWithoutDataField = import_zod7.z.union([
   QrReaderFieldValue,
   IdReaderFieldValue,
   NumberWithUnitFieldValue,
-  NumberWithUnitFieldUpdateValue
+  NumberWithUnitFieldUpdateValue,
+  CustomFieldValue
 ]);
-var DataFieldValue = import_zod7.z.object({
-  data: import_zod7.z.record(import_zod7.z.string(), FieldValuesWithoutDataField)
+var DataFieldValue = z7.object({
+  data: z7.record(z7.string(), FieldValuesWithoutDataField)
 }).nullish();
-var FieldValue = import_zod7.z.union([
+var FieldValue = z7.union([
   FieldValuesWithoutDataField,
   DataFieldValue
 ]);
@@ -485,22 +501,38 @@ var PRIORITY_ORDER = [
   "DataFieldValue"
 ];
 function schemaPriority(schema) {
-  const name = schema._def?.description;
+  const name = schema.description;
+  if (!name) {
+    return 9999;
+  }
   const idx = PRIORITY_ORDER.indexOf(name);
   return idx === -1 ? 9999 : idx;
 }
 function safeUnion(schemas) {
-  return import_zod7.z.custom((val) => {
+  return z7.any().superRefine((val, ctx) => {
     const successful = schemas.filter((s) => s.safeParse(val).success);
     if (successful.length === 1) {
-      return true;
+      return;
     }
     if (successful.length === 0) {
-      return false;
+      ctx.addIssue({
+        code: "invalid_type",
+        expected: "custom",
+        message: "Value does not match any schema"
+      });
+      return;
     }
     successful.sort((a, b) => schemaPriority(a) - schemaPriority(b));
     const best = successful[0];
-    return best.safeParse(val).success;
+    if (!best.safeParse(val).success) {
+      ctx.addIssue({
+        expected: "custom",
+        code: "invalid_type",
+        message: "Value did not match the best schema"
+      });
+    }
+  }).meta({
+    description: "Value that matches exactly one of the possible schema types (TextValue, DateValue, DateRangeFieldValue). The best matching schema is chosen by priority."
   });
 }
 var FieldUpdateValue = safeUnion([
@@ -519,24 +551,23 @@ var FieldUpdateValue = safeUnion([
   DataFieldValue.describe("DataFieldValue"),
   NameFieldUpdateValue.describe("NameFieldUpdateValue"),
   HttpFieldUpdateValue.describe("HttpFieldUpdateValue"),
-  QueryParamReaderFieldUpdateValue.describe("QueryParamReaderFieldUpdateValue")
+  QueryParamReaderFieldUpdateValue.describe("QueryParamReaderFieldUpdateValue"),
+  CustomFieldValue.describe("CustomFieldValue"),
+  HiddenFieldValue.describe("HiddenFieldValue")
 ]);
 
-// ../commons/src/events/FieldConfig.ts
-var import_zod_openapi6 = require("zod-openapi");
-
 // ../commons/src/uuid.ts
 var import_uuid = require("uuid");
-var import_zod8 = require("zod");
-var UUID = import_zod8.z.string().uuid().brand("UUID");
+var z8 = __toESM(require("zod/v4"));
+var UUID = z8.uuid().brand("UUID");
 function getUUID() {
   return (0, import_uuid.v4)();
 }
 
 // ../commons/src/events/serializers/user/serializer.ts
-var import_zod9 = require("zod");
-var SerializedUserField = import_zod9.z.object({
-  $userField: import_zod9.z.enum([
+var z9 = __toESM(require("zod/v4"));
+var SerializedUserField = z9.object({
+  $userField: z9.enum([
     "id",
     "name",
     "role",
@@ -545,11 +576,12 @@ var SerializedUserField = import_zod9.z.object({
     "firstname",
     "middlename",
     "surname",
-    "district",
-    "province",
-    "primaryOfficeId"
+    "signature",
+    "avatar",
+    "primaryOfficeId",
+    "administrativeAreaId"
   ]),
-  $location: import_zod9.z.string().optional()
+  $location: z9.string().optional()
 });
 function userSerializer(userField) {
   return {
@@ -569,24 +601,20 @@ function userSerializer(userField) {
 }
 
 // ../commons/src/events/EventIndex.ts
-var import_zod14 = require("zod");
+var import_v4 = require("zod/v4");
 
 // ../commons/src/events/EventMetadata.ts
-var import_zod13 = require("zod");
+var z14 = __toESM(require("zod/v4"));
 
 // ../commons/src/events/ActionDocument.ts
-var import_zod12 = require("zod");
-var import_zod_openapi4 = require("zod-openapi");
-
-// ../commons/src/events/CreatedAtLocation.ts
-var CreatedAtLocation = UUID.nullish();
+var z12 = __toESM(require("zod/v4"));
 
 // ../commons/src/authentication.ts
 var import_jwt_decode = __toESM(require("jwt-decode"));
-var import_zod11 = require("zod");
+var z11 = __toESM(require("zod/v4"));
 
 // ../commons/src/scopes.ts
-var import_zod10 = require("zod");
+var z10 = __toESM(require("zod/v4"));
 var SCOPES = {
   // TODO v1.8 legacy scopes
   BYPASSRATELIMIT: "bypassratelimit",
@@ -665,91 +693,91 @@ var SCOPES = {
   // data seeding
   USER_DATA_SEEDING: "user.data-seeding"
 };
-var LegacyScopes = import_zod10.z.union([
-  import_zod10.z.literal(SCOPES.BYPASSRATELIMIT),
-  import_zod10.z.literal(SCOPES.REGISTER),
-  import_zod10.z.literal(SCOPES.DEMO),
-  import_zod10.z.literal(SCOPES.CONFIG)
+var LegacyScopes = z10.union([
+  z10.literal(SCOPES.BYPASSRATELIMIT),
+  z10.literal(SCOPES.REGISTER),
+  z10.literal(SCOPES.DEMO),
+  z10.literal(SCOPES.CONFIG)
 ]);
-var IntegrationScopes = import_zod10.z.union([
-  import_zod10.z.literal(SCOPES.WEBHOOK),
-  import_zod10.z.literal(SCOPES.NATIONALID),
-  import_zod10.z.literal(SCOPES.NOTIFICATION_API),
-  import_zod10.z.literal(SCOPES.RECORDSEARCH)
+var IntegrationScopes = z10.union([
+  z10.literal(SCOPES.WEBHOOK),
+  z10.literal(SCOPES.NATIONALID),
+  z10.literal(SCOPES.NOTIFICATION_API),
+  z10.literal(SCOPES.RECORDSEARCH)
 ]);
-var InternalOperationsScopes = import_zod10.z.union([
-  import_zod10.z.literal(SCOPES.RECORD_REINDEX),
-  import_zod10.z.literal(SCOPES.RECORD_IMPORT)
+var InternalOperationsScopes = z10.union([
+  z10.literal(SCOPES.RECORD_REINDEX),
+  z10.literal(SCOPES.RECORD_IMPORT)
 ]);
-var DeclareScopes = import_zod10.z.union([
-  import_zod10.z.literal(SCOPES.RECORD_DECLARE_BIRTH),
-  import_zod10.z.literal(SCOPES.RECORD_DECLARE_BIRTH_MY_JURISDICTION),
-  import_zod10.z.literal(SCOPES.RECORD_DECLARE_DEATH),
-  import_zod10.z.literal(SCOPES.RECORD_DECLARE_DEATH_MY_JURISDICTION),
-  import_zod10.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE),
-  import_zod10.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE_MY_JURISDICTION),
-  import_zod10.z.literal(SCOPES.RECORD_SUBMIT_INCOMPLETE),
-  import_zod10.z.literal(SCOPES.RECORD_SUBMIT_FOR_REVIEW)
+var DeclareScopes = z10.union([
+  z10.literal(SCOPES.RECORD_DECLARE_BIRTH),
+  z10.literal(SCOPES.RECORD_DECLARE_BIRTH_MY_JURISDICTION),
+  z10.literal(SCOPES.RECORD_DECLARE_DEATH),
+  z10.literal(SCOPES.RECORD_DECLARE_DEATH_MY_JURISDICTION),
+  z10.literal(SCOPES.RECORD_DECLARE_MARRIAGE),
+  z10.literal(SCOPES.RECORD_DECLARE_MARRIAGE_MY_JURISDICTION),
+  z10.literal(SCOPES.RECORD_SUBMIT_INCOMPLETE),
+  z10.literal(SCOPES.RECORD_SUBMIT_FOR_REVIEW)
 ]);
-var UnassignScope = import_zod10.z.literal(SCOPES.RECORD_UNASSIGN_OTHERS);
-var ValidateScopes = import_zod10.z.union([
-  import_zod10.z.literal(SCOPES.RECORD_SUBMIT_FOR_APPROVAL),
-  import_zod10.z.literal(SCOPES.RECORD_SUBMIT_FOR_UPDATES),
-  import_zod10.z.literal(SCOPES.RECORD_DECLARATION_EDIT),
-  import_zod10.z.literal(SCOPES.RECORD_REVIEW_DUPLICATES),
-  import_zod10.z.literal(SCOPES.RECORD_DECLARATION_ARCHIVE),
-  import_zod10.z.literal(SCOPES.RECORD_DECLARATION_REINSTATE)
+var UnassignScope = z10.literal(SCOPES.RECORD_UNASSIGN_OTHERS);
+var ValidateScopes = z10.union([
+  z10.literal(SCOPES.RECORD_SUBMIT_FOR_APPROVAL),
+  z10.literal(SCOPES.RECORD_SUBMIT_FOR_UPDATES),
+  z10.literal(SCOPES.RECORD_DECLARATION_EDIT),
+  z10.literal(SCOPES.RECORD_REVIEW_DUPLICATES),
+  z10.literal(SCOPES.RECORD_DECLARATION_ARCHIVE),
+  z10.literal(SCOPES.RECORD_DECLARATION_REINSTATE)
 ]);
-var RegisterScope = import_zod10.z.literal(SCOPES.RECORD_REGISTER);
-var CorrectionScopes = import_zod10.z.union([
-  import_zod10.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_CORRECTION),
-  import_zod10.z.literal(SCOPES.RECORD_REGISTRATION_CORRECT),
-  import_zod10.z.literal(SCOPES.RECORD_CONFIRM_REGISTRATION),
-  import_zod10.z.literal(SCOPES.RECORD_REJECT_REGISTRATION)
+var RegisterScope = z10.literal(SCOPES.RECORD_REGISTER);
+var CorrectionScopes = z10.union([
+  z10.literal(SCOPES.RECORD_REGISTRATION_REQUEST_CORRECTION),
+  z10.literal(SCOPES.RECORD_REGISTRATION_CORRECT),
+  z10.literal(SCOPES.RECORD_CONFIRM_REGISTRATION),
+  z10.literal(SCOPES.RECORD_REJECT_REGISTRATION)
 ]);
-var SearchScopes = import_zod10.z.union([
-  import_zod10.z.literal(SCOPES.SEARCH_BIRTH_MY_JURISDICTION),
-  import_zod10.z.literal(SCOPES.SEARCH_BIRTH),
-  import_zod10.z.literal(SCOPES.SEARCH_DEATH_MY_JURISDICTION),
-  import_zod10.z.literal(SCOPES.SEARCH_DEATH),
-  import_zod10.z.literal(SCOPES.SEARCH_MARRIAGE_MY_JURISDICTION),
-  import_zod10.z.literal(SCOPES.SEARCH_MARRIAGE)
+var SearchScopes = z10.union([
+  z10.literal(SCOPES.SEARCH_BIRTH_MY_JURISDICTION),
+  z10.literal(SCOPES.SEARCH_BIRTH),
+  z10.literal(SCOPES.SEARCH_DEATH_MY_JURISDICTION),
+  z10.literal(SCOPES.SEARCH_DEATH),
+  z10.literal(SCOPES.SEARCH_MARRIAGE_MY_JURISDICTION),
+  z10.literal(SCOPES.SEARCH_MARRIAGE)
 ]);
-var AuditScopes = import_zod10.z.literal(SCOPES.RECORD_READ);
-var PerformanceScopes = import_zod10.z.union([
-  import_zod10.z.literal(SCOPES.PERFORMANCE_READ),
-  import_zod10.z.literal(SCOPES.PERFORMANCE_READ_DASHBOARDS),
-  import_zod10.z.literal(SCOPES.PERFORMANCE_EXPORT_VITAL_STATISTICS)
+var AuditScopes = z10.literal(SCOPES.RECORD_READ);
+var PerformanceScopes = z10.union([
+  z10.literal(SCOPES.PERFORMANCE_READ),
+  z10.literal(SCOPES.PERFORMANCE_READ_DASHBOARDS),
+  z10.literal(SCOPES.PERFORMANCE_EXPORT_VITAL_STATISTICS)
 ]);
-var OrganisationScopes = import_zod10.z.union([
-  import_zod10.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS),
-  import_zod10.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_OFFICE),
-  import_zod10.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_JURISDICTION)
+var OrganisationScopes = z10.union([
+  z10.literal(SCOPES.ORGANISATION_READ_LOCATIONS),
+  z10.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_OFFICE),
+  z10.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_JURISDICTION)
 ]);
-var UserScopes = import_zod10.z.union([
-  import_zod10.z.literal(SCOPES.USER_READ),
-  import_zod10.z.literal(SCOPES.USER_READ_MY_OFFICE),
-  import_zod10.z.literal(SCOPES.USER_READ_MY_JURISDICTION),
-  import_zod10.z.literal(SCOPES.USER_READ_ONLY_MY_AUDIT),
-  import_zod10.z.literal(SCOPES.USER_CREATE),
-  import_zod10.z.literal(SCOPES.USER_CREATE_MY_JURISDICTION),
-  import_zod10.z.literal(SCOPES.USER_UPDATE),
-  import_zod10.z.literal(SCOPES.USER_UPDATE_MY_JURISDICTION)
+var UserScopes = z10.union([
+  z10.literal(SCOPES.USER_READ),
+  z10.literal(SCOPES.USER_READ_MY_OFFICE),
+  z10.literal(SCOPES.USER_READ_MY_JURISDICTION),
+  z10.literal(SCOPES.USER_READ_ONLY_MY_AUDIT),
+  z10.literal(SCOPES.USER_CREATE),
+  z10.literal(SCOPES.USER_CREATE_MY_JURISDICTION),
+  z10.literal(SCOPES.USER_UPDATE),
+  z10.literal(SCOPES.USER_UPDATE_MY_JURISDICTION)
 ]);
-var ConfigScope = import_zod10.z.literal(SCOPES.CONFIG_UPDATE_ALL);
-var DataSeedingScope = import_zod10.z.literal(SCOPES.USER_DATA_SEEDING);
-var LiteralScopes = import_zod10.z.union([
+var ConfigScope = z10.literal(SCOPES.CONFIG_UPDATE_ALL);
+var DataSeedingScope = z10.literal(SCOPES.USER_DATA_SEEDING);
+var LiteralScopes = z10.union([
   LegacyScopes,
   IntegrationScopes,
   UnassignScope,
   DeclareScopes,
   ValidateScopes,
   RegisterScope,
-  import_zod10.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
+  z10.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
   CorrectionScopes,
   SearchScopes,
   AuditScopes,
-  import_zod10.z.literal(SCOPES.PROFILE_ELECTRONIC_SIGNATURE),
+  z10.literal(SCOPES.PROFILE_ELECTRONIC_SIGNATURE),
   PerformanceScopes,
   OrganisationScopes,
   UserScopes,
@@ -758,38 +786,38 @@ var LiteralScopes = import_zod10.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_zod10.z.string().regex(rawConfigurableScopeRegex);
-var CreateUserScope = import_zod10.z.object({
-  type: import_zod10.z.literal("user.create"),
-  options: import_zod10.z.object({
-    role: import_zod10.z.array(import_zod10.z.string())
+var rawConfigurableScope = z10.string().regex(rawConfigurableScopeRegex);
+var CreateUserScope = z10.object({
+  type: z10.literal("user.create"),
+  options: z10.object({
+    role: z10.array(z10.string())
   })
 });
-var EditUserScope = import_zod10.z.object({
-  type: import_zod10.z.literal("user.edit"),
-  options: import_zod10.z.object({
-    role: import_zod10.z.array(import_zod10.z.string())
+var EditUserScope = z10.object({
+  type: z10.literal("user.edit"),
+  options: z10.object({
+    role: z10.array(z10.string())
   })
 });
-var WorkqueueScope = import_zod10.z.object({
-  type: import_zod10.z.literal("workqueue"),
-  options: import_zod10.z.object({
-    id: import_zod10.z.array(import_zod10.z.string())
+var WorkqueueScope = z10.object({
+  type: z10.literal("workqueue"),
+  options: z10.object({
+    id: z10.array(z10.string())
   })
 });
-var SearchScope = import_zod10.z.object({
-  type: import_zod10.z.literal("search"),
-  options: import_zod10.z.object({
-    event: import_zod10.z.array(import_zod10.z.string()).length(1),
-    access: import_zod10.z.array(import_zod10.z.enum(["my-jurisdiction", "all"])).length(1)
+var SearchScope = z10.object({
+  type: z10.literal("search"),
+  options: z10.object({
+    event: z10.array(z10.string()).length(1),
+    access: z10.array(z10.enum(["my-jurisdiction", "all"])).length(1)
   })
 });
-var RecordScopeType = import_zod10.z.enum([
+var RecordScopeType = z10.enum([
   "record.create",
   "record.read",
   "record.declare",
   "record.notify",
-  "record.declared.validate",
+  "record.declared.edit",
   "record.declared.reject",
   "record.declared.archive",
   "record.declared.review-duplicates",
@@ -799,27 +827,40 @@ var RecordScopeType = import_zod10.z.enum([
   "record.registered.correct",
   "record.unassign-others"
 ]);
-var RecordScope = import_zod10.z.object({
+var RecordScope = z10.object({
   type: RecordScopeType,
-  options: import_zod10.z.object({
-    event: import_zod10.z.array(import_zod10.z.string()).describe("Event type, e.g. birth, death")
+  options: z10.object({
+    event: z10.array(z10.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_zod10.z.discriminatedUnion("type", [
+var CustomActionScope = z10.object({
+  type: z10.literal("record.custom-action"),
+  options: z10.object({
+    event: z10.array(z10.string()).describe("Allowed event type, e.g. birth, death"),
+    customActionType: z10.array(z10.string()).describe("Allowed custom action types")
+  })
+});
+var ConfigurableRawScopes = z10.discriminatedUnion("type", [
   SearchScope,
   CreateUserScope,
   EditUserScope,
   WorkqueueScope,
-  RecordScope
+  RecordScope,
+  CustomActionScope
+]);
+var ConfigurableActionScopes = z10.discriminatedUnion("type", [
+  // @TODO - Record scope holds non-action scopes as well e.g., `record.read`
+  RecordScope,
+  CustomActionScope
 ]);
 var scopes = Object.values(SCOPES);
-var ActionScopes = import_zod10.z.union([
+var ActionScopes = z10.union([
   DeclareScopes,
   ValidateScopes,
   RegisterScope,
-  import_zod10.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
+  z10.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
   CorrectionScopes
 ]);
 
@@ -953,15 +994,14 @@ var DEFAULT_ROLES_DEFINITION = [
     ]
   }
 ];
-var TokenUserType = import_zod11.z.enum(["user", "system"]);
-var TokenWithBearer = import_zod11.z.string().regex(/^Bearer\s/);
+var TokenUserType = z11.enum(["user", "system"]);
+var TokenWithBearer = z11.string().regex(/^Bearer\s/);
 
 // ../commons/src/events/ActionDocument.ts
-(0, import_zod_openapi4.extendZodWithOpenApi)(import_zod12.z);
-var ActionUpdate = import_zod12.z.record(import_zod12.z.string(), FieldUpdateValue).describe(
+var ActionUpdate = z12.record(z12.string(), FieldUpdateValue).describe(
   "Record of field-level changes made by an action. Supports partial updates and nullable values."
 );
-var EventState = import_zod12.z.record(import_zod12.z.string(), FieldValue).describe(
+var EventState = z12.record(z12.string(), FieldValue).describe(
   "Aggregate representation of event data after all actions have been applied, with all updates consolidated and null values removed."
 );
 var ActionStatus = {
@@ -969,24 +1009,25 @@ var ActionStatus = {
   Accepted: "Accepted",
   Rejected: "Rejected"
 };
-var ActionBase = import_zod12.z.object({
+var ActionBase = z12.object({
   id: UUID.describe("Unique identifier of the action."),
-  transactionId: import_zod12.z.string().describe("Unique identifier of the transaction."),
+  transactionId: z12.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_zod12.z.string().datetime().describe("Timestamp indicating when the action was created."),
-  createdBy: import_zod12.z.string().describe("Identifier of the user who created the action."),
-  createdByRole: import_zod12.z.string().describe("Role of the user who created the action."),
-  createdBySignature: import_zod12.z.string().nullish().describe("Reference to the signature of the user who created the action."),
-  createdAtLocation: CreatedAtLocation.describe(
+  createdAt: z12.string().datetime().describe("Timestamp indicating when the action was created."),
+  createdBy: z12.string().describe("Identifier of the user who created the action."),
+  createdByRole: z12.string().describe("Role of the user who created the action."),
+  createdBySignature: z12.string().nullish().describe("Reference to the signature of the user who created the action."),
+  // @TODO: createdAtLocation should be non-nullable in the future once all actions have this field populated.
+  createdAtLocation: UUID.nullish().describe(
     "Reference to the location of the user who created the action."
   ),
   declaration: ActionUpdate.describe(
     "Declaration data defined by the ActionConfig. Supports partial updates."
   ),
   annotation: ActionUpdate.optional().nullable().describe("Action-specific metadata used to annotate the event."),
-  status: import_zod12.z.enum([
+  status: z12.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
@@ -997,172 +1038,181 @@ var ActionBase = import_zod12.z.object({
     "Reference to the original action asynchronously accepted or rejected by a third-party integration."
   )
 });
-var AssignedAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod12.z.string().describe("Identifier of the user to whom the action is assigned.")
+var AssignedAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.ASSIGN),
+    assignedTo: z12.string().describe("Identifier of the user to whom the action is assigned.")
     // TODO move into 'content' property
-  })
+  }).shape
 );
-var UnassignedAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.UNASSIGN)
-  })
+var UnassignedAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.UNASSIGN)
+  }).shape
 );
-var RegisterAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.REGISTER),
-    registrationNumber: import_zod12.z.string().optional().describe(
+var RegisterAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.REGISTER),
+    registrationNumber: z12.string().optional().describe(
       "Registration number of the event. Always present for accepted registrations."
     )
     // TODO move into 'content' property
-  })
+  }).shape
 );
-var DeclareAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.DECLARE)
-  })
-);
-var ValidateAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.VALIDATE)
-  })
+var DeclareAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.DECLARE)
+  }).shape
 );
-var ReasonContent = import_zod12.z.object({
-  reason: import_zod12.z.string().min(1, { message: "Message cannot be empty" }).describe(
+var ReasonContent = z12.object({
+  reason: z12.string().min(1, { error: "Message cannot be empty" }).describe(
     "Message describing the reason for rejecting or archiving the event."
   )
 });
-var RejectAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.REJECT),
+var RejectAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.REJECT),
     content: ReasonContent
-  })
+  }).shape
 );
-var PotentialDuplicate = import_zod12.z.object({
+var PotentialDuplicate = z12.object({
   id: UUID,
-  trackingId: import_zod12.z.string()
+  trackingId: z12.string()
 });
-var DuplicateDetectedAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.DUPLICATE_DETECTED),
-    content: import_zod12.z.object({
-      duplicates: import_zod12.z.array(PotentialDuplicate)
+var DuplicateDetectedAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.DUPLICATE_DETECTED),
+    content: z12.object({
+      duplicates: z12.array(PotentialDuplicate)
     })
-  })
+  }).shape
 );
-var MarkNotDuplicateAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.MARK_AS_NOT_DUPLICATE)
-  })
+var MarkNotDuplicateAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.MARK_AS_NOT_DUPLICATE)
+  }).shape
 );
-var MarkAsDuplicateAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.MARK_AS_DUPLICATE),
-    content: import_zod12.z.object({
+var MarkAsDuplicateAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.MARK_AS_DUPLICATE),
+    content: z12.object({
       duplicateOf: UUID
     }).optional()
-  })
+  }).shape
 );
-var ArchiveAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.ARCHIVE),
+var ArchiveAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.ARCHIVE),
     content: ReasonContent
-  })
+  }).shape
 );
-var CreatedAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.CREATE)
-  })
+var CreatedAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.CREATE)
+  }).shape
 );
-var NotifiedAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.NOTIFY)
-  })
+var NotifiedAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.NOTIFY)
+  }).shape
+);
+var EditAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.EDIT),
+    content: z12.object({
+      comment: z12.string().describe("Comment for the edit action.").optional()
+    })
+  }).shape
 );
-var PrintContent = import_zod12.z.object({
-  templateId: import_zod12.z.string().optional()
+var PrintContent = z12.object({
+  templateId: z12.string().optional()
 });
-var PrintCertificateAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.PRINT_CERTIFICATE),
+var PrintCertificateAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.PRINT_CERTIFICATE),
     content: PrintContent.optional().nullable()
-  })
+  }).shape
 );
-var RequestedCorrectionAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.REQUEST_CORRECTION)
-  })
+var RequestedCorrectionAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.REQUEST_CORRECTION)
+  }).shape
 );
-var ApprovedCorrectionAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.APPROVE_CORRECTION),
-    requestId: import_zod12.z.string()
+var ApprovedCorrectionAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.APPROVE_CORRECTION),
+    requestId: z12.string()
     // TODO move into 'content' property
-  })
+  }).shape
 );
-var RejectedCorrectionAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.REJECT_CORRECTION),
-    requestId: import_zod12.z.string(),
+var RejectedCorrectionAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.REJECT_CORRECTION),
+    requestId: z12.string(),
     // TODO move into 'content' property
     content: ReasonContent
-  })
+  }).shape
+);
+var ReadAction = ActionBase.extend(
+  z12.object({
+    type: z12.literal(ActionType.READ)
+  }).shape
 );
-var ReadAction = ActionBase.merge(
-  import_zod12.z.object({
-    type: import_zod12.z.literal(ActionType.READ)
+var CustomAction = ActionBase.merge(
+  z12.object({
+    type: z12.literal(ActionType.CUSTOM),
+    customActionType: z12.string()
   })
 );
-var ActionDocument = import_zod12.z.discriminatedUnion("type", [
-  CreatedAction.openapi({ ref: "CreatedAction" }),
-  ValidateAction.openapi({ ref: "ValidateAction" }),
-  RejectAction.openapi({ ref: "RejectAction" }),
-  DuplicateDetectedAction.openapi({ ref: "DuplicateDetectedAction" }),
-  MarkNotDuplicateAction.openapi({ ref: "MarkNotDuplicateAction" }),
-  MarkAsDuplicateAction.openapi({ ref: "MarkAsDuplicateAction" }),
-  ArchiveAction.openapi({ ref: "ArchiveAction" }),
-  NotifiedAction.openapi({ ref: "NotifiedAction" }),
-  RegisterAction.openapi({ ref: "RegisterAction" }),
-  DeclareAction.openapi({ ref: "DeclareAction" }),
-  AssignedAction.openapi({ ref: "AssignedAction" }),
-  RequestedCorrectionAction.openapi({ ref: "RequestedCorrectionAction" }),
-  ApprovedCorrectionAction.openapi({ ref: "ApprovedCorrectionAction" }),
-  RejectedCorrectionAction.openapi({ ref: "RejectedCorrectionAction" }),
-  UnassignedAction.openapi({ ref: "UnassignedAction" }),
-  PrintCertificateAction.openapi({ ref: "PrintCertificateAction" }),
-  ReadAction.openapi({ ref: "ReadAction" })
-]).openapi({
-  ref: "ActionDocument"
+var ActionDocument = z12.discriminatedUnion("type", [
+  CreatedAction.meta({ id: "CreatedAction" }),
+  RejectAction.meta({ id: "RejectAction" }),
+  DuplicateDetectedAction.meta({ id: "DuplicateDetectedAction" }),
+  MarkNotDuplicateAction.meta({ id: "MarkNotDuplicateAction" }),
+  MarkAsDuplicateAction.meta({ id: "MarkAsDuplicateAction" }),
+  ArchiveAction.meta({ id: "ArchiveAction" }),
+  NotifiedAction.meta({ id: "NotifiedAction" }),
+  RegisterAction.meta({ id: "RegisterAction" }),
+  DeclareAction.meta({ id: "DeclareAction" }),
+  AssignedAction.meta({ id: "AssignedAction" }),
+  RequestedCorrectionAction.meta({ id: "RequestedCorrectionAction" }),
+  ApprovedCorrectionAction.meta({ id: "ApprovedCorrectionAction" }),
+  RejectedCorrectionAction.meta({ id: "RejectedCorrectionAction" }),
+  UnassignedAction.meta({ id: "UnassignedAction" }),
+  PrintCertificateAction.meta({ id: "PrintCertificateAction" }),
+  ReadAction.meta({ id: "ReadAction" }),
+  EditAction.meta({ id: "EditAction" }),
+  CustomAction.meta({ id: "CustomAction" })
+]).meta({
+  id: "ActionDocument"
 });
 var AsyncRejectActionDocument = ActionBase.omit({
   declaration: true,
   annotation: true
-}).merge(
-  import_zod12.z.object({
-    type: import_zod12.z.enum(ConfirmableActions),
-    status: import_zod12.z.literal(ActionStatus.Rejected)
-  })
+}).extend(
+  z12.object({
+    type: z12.enum(ConfirmableActions),
+    status: z12.literal(ActionStatus.Rejected)
+  }).shape
 );
-var Action = import_zod12.z.union([ActionDocument, AsyncRejectActionDocument]);
+var Action = z12.union([ActionDocument, AsyncRejectActionDocument]);
 
-// ../commons/src/events/EventMetadata.ts
-var EventStatus = import_zod13.z.enum([
-  "CREATED",
-  "NOTIFIED",
-  "DECLARED",
-  "VALIDATED",
-  "REGISTERED",
-  "ARCHIVED"
-]);
+// ../commons/src/events/Flag.ts
+var z13 = __toESM(require("zod/v4"));
 var InherentFlags = {
-  PENDING_CERTIFICATION: "pending-certification",
   INCOMPLETE: "incomplete",
   REJECTED: "rejected",
   CORRECTION_REQUESTED: "correction-requested",
-  POTENTIAL_DUPLICATE: "potential-duplicate"
+  POTENTIAL_DUPLICATE: "potential-duplicate",
+  /**
+   * This flag is set by the Edit-action and removed after the declaration or registration.
+   * A record should never stay with the EDIT_IN_PROGRESS flag, since it should always be declared or registered right after.
+   *
+   * We only use this flag to determine that a NOTIFY, DECLARE or REGISTER action is allowed next.
+   */
+  EDIT_IN_PROGRESS: "edit-in-progress"
 };
-var ActionFlag = import_zod13.z.string().regex(
+var ActionFlag = z13.string().regex(
   new RegExp(
     `^(${Object.values(ActionType).join("|").toLowerCase()}):(${Object.values(
       ActionStatus
@@ -1170,59 +1220,92 @@ var ActionFlag = import_zod13.z.string().regex(
   ),
   "Flag must be in the format ActionType:ActionStatus (lowerCase)"
 );
-var Flag = ActionFlag.or(import_zod13.z.nativeEnum(InherentFlags));
-var ZodDate = import_zod13.z.string().date();
-var ActionCreationMetadata = import_zod13.z.object({
-  createdAt: import_zod13.z.string().datetime().describe("The timestamp when the action request was created."),
-  createdBy: import_zod13.z.string().describe("ID of the user who created the action request."),
-  createdAtLocation: CreatedAtLocation.describe(
+var CustomFlag = z13.string().refine((val) => !Object.values(InherentFlags).includes(val), {
+  message: `Custom flag cannot be one of the inherent flags: ${Object.values(
+    InherentFlags
+  ).join(", ")}`
+}).refine((val) => !ActionFlag.safeParse(val).success, {
+  message: "Custom flag cannot match the ActionFlag pattern (ActionType:ActionStatus)."
+}).describe("Custom flag identifier defined by the country config.");
+var Flag = ActionFlag.or(z13.enum(InherentFlags)).or(CustomFlag);
+var FlagConfig = z13.object({
+  id: CustomFlag,
+  requiresAction: z13.boolean().describe(
+    "Indicates if this flag expects an action to be performed to be cleared."
+  ),
+  label: TranslationConfig.describe("Human readable label of the flag.")
+});
+var ActionFlagConfig = z13.object({
+  id: Flag,
+  operation: z13.enum(["add", "remove"]).describe("Operation to perform on the flag."),
+  conditional: Conditional.optional().describe(
+    "When conditional is met, the operation is performed on the flag. If not provided, the operation is performed unconditionally."
+  )
+});
+
+// ../commons/src/events/EventMetadata.ts
+var EventStatus = z14.enum([
+  "CREATED",
+  "NOTIFIED",
+  "DECLARED",
+  "REGISTERED",
+  "ARCHIVED"
+]);
+var ZodDate = z14.iso.date();
+var ActionCreationMetadata = z14.object({
+  createdAt: z14.iso.datetime().describe("The timestamp when the action request was created."),
+  createdBy: z14.string().describe("ID of the user who created the action request."),
+  // @TODO: createdAtLocation should be non-nullable in the future once all action requests have this field populated.
+  createdAtLocation: UUID.nullish().describe(
     "Location of the user who created the action request."
   ),
-  createdByUserType: import_zod13.z.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
-  acceptedAt: import_zod13.z.string().datetime().describe("Timestamp when the action request was accepted."),
-  createdByRole: import_zod13.z.string().describe("Role of the user at the time of action request creation."),
-  createdBySignature: import_zod13.z.string().nullish().describe("Signature of the user who created the action request.")
+  createdByUserType: z14.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
+  acceptedAt: z14.iso.datetime().describe("Timestamp when the action request was accepted."),
+  createdByRole: z14.string().describe("Role of the user at the time of action request creation."),
+  createdBySignature: z14.string().nullish().describe("Signature of the user who created the action request.")
 });
 var RegistrationCreationMetadata = ActionCreationMetadata.extend({
-  registrationNumber: import_zod13.z.string().describe(
+  registrationNumber: z14.string().describe(
     "Registration number of the event. Always present for accepted registrations."
   )
 });
-var LegalStatuses = import_zod13.z.object({
+var LegalStatuses = z14.object({
   [EventStatus.enum.DECLARED]: ActionCreationMetadata.nullish(),
   [EventStatus.enum.REGISTERED]: RegistrationCreationMetadata.nullish()
 });
-var EventMetadata = import_zod13.z.object({
+var EventMetadata = z14.object({
   id: UUID,
-  type: import_zod13.z.string().describe("The type of event, such as birth, death, or marriage."),
+  type: z14.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_zod13.z.string().datetime().describe("The timestamp when the event was first created and saved."),
+  createdAt: z14.iso.datetime().describe("The timestamp when the event was first created and saved."),
   dateOfEvent: ZodDate.nullish(),
-  createdBy: import_zod13.z.string().describe("ID of the user who created the event."),
-  createdByUserType: import_zod13.z.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
-  updatedByUserRole: import_zod13.z.string().describe("Role of the user who last changed the status."),
-  createdAtLocation: CreatedAtLocation.describe(
+  placeOfEvent: UUID.nullish(),
+  createdBy: z14.string().describe("ID of the user who created the event."),
+  createdByUserType: z14.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
+  updatedByUserRole: z14.string().describe("Role of the user who last changed the status."),
+  // @TODO: createdAtLocation should be non-nullable in the future once all action requests have this field populated.
+  createdAtLocation: UUID.nullish().describe(
     "Location of the user who created the event."
   ),
-  createdBySignature: import_zod13.z.string().nullish().describe("Signature of the user who created the event."),
+  createdBySignature: z14.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_zod13.z.string().datetime().describe(
+  updatedAt: z14.iso.datetime().describe(
     "Timestamp of the most recent *accepted* status change. Possibly 3rd party update, if action is validation asynchronously."
   ),
-  assignedTo: import_zod13.z.string().nullish().describe("ID of the user currently assigned to the event."),
-  updatedBy: import_zod13.z.string().nullish().describe("ID of the user who last changed the status."),
-  trackingId: import_zod13.z.string().describe(
+  assignedTo: z14.string().nullish().describe("ID of the user currently assigned to the event."),
+  updatedBy: z14.string().nullish().describe("ID of the user who last changed the status."),
+  trackingId: z14.string().describe(
     "System-generated tracking ID used by informants or registrars to look up the event."
   ),
-  potentialDuplicates: import_zod13.z.array(PotentialDuplicate).describe(
+  potentialDuplicates: z14.array(PotentialDuplicate).describe(
     "List of event IDs and their tracking IDs that this event could be a duplicate of."
   ),
-  flags: import_zod13.z.array(Flag)
+  flags: z14.array(Flag)
 });
 var EventMetadataKeysArray = [
   "id",
@@ -1230,6 +1313,7 @@ var EventMetadataKeysArray = [
   "status",
   "createdAt",
   "dateOfEvent",
+  "placeOfEvent",
   "createdBy",
   "createdByUserType",
   "updatedByUserRole",
@@ -1242,130 +1326,124 @@ var EventMetadataKeysArray = [
   "legalStatuses",
   "flags"
 ];
-var EventMetadataKeys = import_zod13.z.enum(EventMetadataKeysArray);
+var EventMetadataKeys = z14.enum(EventMetadataKeysArray);
 
 // ../commons/src/events/EventIndex.ts
-var import_zod_openapi5 = require("zod-openapi");
-(0, import_zod_openapi5.extendZodWithOpenApi)(import_zod14.z);
 var EventIndex = EventMetadata.extend({
   declaration: EventState
-}).openapi({
-  ref: "EventIndex"
+}).meta({
+  id: "EventIndex"
 });
-var EventSearchIndex = import_zod14.z.record(import_zod14.z.string(), import_zod14.z.any()).and(
-  import_zod14.z.object({
-    type: import_zod14.z.string()
+var EventSearchIndex = import_v4.z.record(import_v4.z.string(), import_v4.z.any()).and(
+  import_v4.z.object({
+    type: import_v4.z.string()
     // Ensures "type" (event-id) exists and is a string
   })
-).openapi({
-  ref: "EventSearchIndex"
+).meta({
+  id: "EventSearchIndex"
 });
-var Fuzzy = import_zod14.z.object({ type: import_zod14.z.literal("fuzzy"), term: import_zod14.z.string() }).openapi({
-  ref: "Fuzzy"
+var Fuzzy = import_v4.z.object({ type: import_v4.z.literal("fuzzy"), term: import_v4.z.string() }).meta({
+  id: "Fuzzy"
 });
-var Exact = import_zod14.z.object({ type: import_zod14.z.literal("exact"), term: import_zod14.z.string() }).openapi({
-  ref: "Exact"
+var Exact = import_v4.z.object({ type: import_v4.z.literal("exact"), term: import_v4.z.string() }).meta({
+  id: "Exact"
 });
-var ExactStatus = import_zod14.z.object({
-  type: import_zod14.z.literal("exact"),
+var ExactStatus = import_v4.z.object({
+  type: import_v4.z.literal("exact"),
   term: EventStatus
-}).openapi({
-  ref: "ExactStatus"
+}).meta({
+  id: "ExactStatus"
 });
-var ExactUserType = import_zod14.z.object({
-  type: import_zod14.z.literal("exact"),
+var ExactUserType = import_v4.z.object({
+  type: import_v4.z.literal("exact"),
   term: TokenUserType
-}).openapi({
-  ref: "ExactUserType"
-});
-var AnyOf = import_zod14.z.object({
-  type: import_zod14.z.literal("anyOf"),
-  terms: import_zod14.z.array(import_zod14.z.string())
-}).openapi({
-  ref: "AnyOf"
-});
-var AnyOfStatus = import_zod14.z.object({
-  type: import_zod14.z.literal("anyOf"),
-  terms: import_zod14.z.array(EventStatus)
-}).openapi({
-  ref: "AnyOfStatus"
-});
-var Range = import_zod14.z.object({
-  type: import_zod14.z.literal("range"),
-  gte: import_zod14.z.string(),
-  lte: import_zod14.z.string()
-}).openapi({
-  ref: "Range"
-});
-var ContainsFlags = import_zod14.z.object({
-  anyOf: import_zod14.z.array(Flag).optional(),
-  noneOf: import_zod14.z.array(Flag).optional()
-}).openapi({
-  ref: "ContainsFlags"
-});
-var Within = import_zod14.z.object({ type: import_zod14.z.literal("within"), location: import_zod14.z.string() }).openapi({
-  ref: "Within"
-});
-var RangeDate = import_zod14.z.object({
-  type: import_zod14.z.literal("range"),
-  gte: import_zod14.z.string().date().or(import_zod14.z.string().datetime()),
-  lte: import_zod14.z.string().date().or(import_zod14.z.string().datetime())
-}).openapi({ ref: "RangeDate" });
+}).meta({
+  id: "ExactUserType"
+});
+var AnyOf = import_v4.z.object({
+  type: import_v4.z.literal("anyOf"),
+  terms: import_v4.z.array(import_v4.z.string())
+}).meta({
+  id: "AnyOf"
+});
+var AnyOfStatus = import_v4.z.object({
+  type: import_v4.z.literal("anyOf"),
+  terms: import_v4.z.array(EventStatus)
+}).meta({
+  id: "AnyOfStatus"
+});
+var Range = import_v4.z.object({
+  type: import_v4.z.literal("range"),
+  gte: import_v4.z.string(),
+  lte: import_v4.z.string()
+}).meta({
+  id: "Range"
+});
+var ContainsFlags = import_v4.z.object({
+  anyOf: import_v4.z.array(Flag).optional(),
+  noneOf: import_v4.z.array(Flag).optional()
+}).meta({
+  id: "ContainsFlags"
+});
+var Within = import_v4.z.object({ type: import_v4.z.literal("within"), location: import_v4.z.string() }).meta({
+  id: "Within"
+});
+var RangeDate = import_v4.z.object({
+  type: import_v4.z.literal("range"),
+  gte: import_v4.z.iso.date().or(import_v4.z.iso.datetime()),
+  lte: import_v4.z.iso.date().or(import_v4.z.iso.datetime())
+}).meta({ id: "RangeDate" });
 var ExactDate = Exact.extend({
-  term: import_zod14.z.string().date().or(import_zod14.z.string().datetime())
-}).openapi({
-  ref: "ExactDate"
+  term: import_v4.z.iso.date().or(import_v4.z.iso.datetime())
+}).meta({
+  id: "ExactDate"
 });
-var TimePeriod = import_zod14.z.object({
-  type: import_zod14.z.literal("timePeriod"),
+var TimePeriod = import_v4.z.object({
+  type: import_v4.z.literal("timePeriod"),
   term: SelectDateRangeValue
-}).openapi({
-  ref: "TimePeriod"
+}).meta({
+  id: "TimePeriod"
 });
-var DateCondition = import_zod14.z.union([ExactDate, RangeDate, TimePeriod]).openapi({
-  ref: "DateCondition"
+var DateCondition = import_v4.z.union([ExactDate, RangeDate, TimePeriod]).meta({
+  id: "DateCondition"
 });
-var QueryInput = import_zod14.z.lazy(
-  () => import_zod14.z.union([
-    import_zod14.z.discriminatedUnion("type", [Fuzzy, Exact, Range, Within, AnyOf]),
-    import_zod14.z.record(import_zod14.z.string(), QueryInput)
+var QueryInput = import_v4.z.lazy(
+  () => import_v4.z.union([
+    import_v4.z.discriminatedUnion("type", [Fuzzy, Exact, Range, Within, AnyOf]),
+    import_v4.z.record(import_v4.z.string(), QueryInput)
   ])
-).openapi({
-  ref: "QueryInput"
-});
-var QueryExpression = import_zod14.z.object({
-  id: import_zod14.z.optional(import_zod14.z.string()),
-  eventType: import_zod14.z.string(),
-  status: import_zod14.z.optional(import_zod14.z.union([AnyOfStatus, ExactStatus])),
-  createdAt: import_zod14.z.optional(DateCondition),
-  updatedAt: import_zod14.z.optional(DateCondition),
-  "legalStatuses.REGISTERED.acceptedAt": import_zod14.z.optional(DateCondition),
-  "legalStatuses.DECLARED.createdAtLocation": import_zod14.z.optional(
-    import_zod14.z.union([Within, Exact])
-  ),
-  "legalStatuses.REGISTERED.createdAtLocation": import_zod14.z.optional(
-    import_zod14.z.union([Within, Exact])
-  ),
-  "legalStatuses.REGISTERED.registrationNumber": import_zod14.z.optional(Exact),
-  createdAtLocation: import_zod14.z.optional(import_zod14.z.union([Within, Exact])),
-  updatedAtLocation: import_zod14.z.optional(import_zod14.z.union([Within, Exact])),
-  assignedTo: import_zod14.z.optional(Exact),
-  createdByUserType: import_zod14.z.optional(ExactUserType),
-  createdBy: import_zod14.z.optional(Exact),
-  updatedBy: import_zod14.z.optional(Exact),
-  trackingId: import_zod14.z.optional(Exact),
-  flags: import_zod14.z.optional(ContainsFlags),
+).meta({
+  id: "QueryInput"
+});
+var QueryExpression = import_v4.z.object({
+  id: import_v4.z.optional(import_v4.z.string()),
+  eventType: import_v4.z.string(),
+  status: import_v4.z.optional(import_v4.z.union([AnyOfStatus, ExactStatus])),
+  createdAt: import_v4.z.optional(DateCondition),
+  updatedAt: import_v4.z.optional(DateCondition),
+  "legalStatuses.REGISTERED.acceptedAt": import_v4.z.optional(DateCondition),
+  "legalStatuses.DECLARED.createdAtLocation": import_v4.z.optional(Within).nullable(),
+  "legalStatuses.REGISTERED.createdAtLocation": import_v4.z.optional(Within).nullable(),
+  "legalStatuses.REGISTERED.registrationNumber": import_v4.z.optional(Exact),
+  createdAtLocation: import_v4.z.optional(Within),
+  updatedAtLocation: import_v4.z.optional(Within),
+  assignedTo: import_v4.z.optional(Exact),
+  createdByUserType: import_v4.z.optional(ExactUserType),
+  createdBy: import_v4.z.optional(Exact),
+  updatedBy: import_v4.z.optional(Exact),
+  trackingId: import_v4.z.optional(Exact),
+  flags: import_v4.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), {
-  message: "At least one query field must be specified."
-}).openapi({
-  ref: "QueryExpression"
-});
-var QueryType = import_zod14.z.lazy(
-  () => import_zod14.z.object({
-    type: import_zod14.z.literal("and").or(import_zod14.z.literal("or")).openapi({ default: "and" }),
-    clauses: import_zod14.z.array(import_zod14.z.union([QueryExpression, QueryType])).nonempty("At least one clause is required.").openapi({
+  error: "At least one query field must be specified."
+}).meta({
+  id: "QueryExpression"
+});
+var QueryType = import_v4.z.lazy(
+  () => import_v4.z.object({
+    type: import_v4.z.literal("and").or(import_v4.z.literal("or")).meta({ default: "and" }),
+    clauses: import_v4.z.array(import_v4.z.union([QueryExpression, QueryType])).nonempty("At least one clause is required.").meta({
       default: [
         {
           eventType: TENNIS_CLUB_MEMBERSHIP,
@@ -1383,8 +1461,8 @@ var QueryType = import_zod14.z.lazy(
       ]
     })
   })
-).openapi({
-  ref: "QueryType"
+).meta({
+  id: "QueryType"
 });
 function parseStringifiedQueryField(val) {
   if (typeof val === "string") {
@@ -1392,8 +1470,8 @@ function parseStringifiedQueryField(val) {
   }
   return val;
 }
-var SearchQuery = import_zod14.z.object({
-  query: import_zod14.z.preprocess(parseStringifiedQueryField, QueryType).openapi({
+var SearchQuery = import_v4.z.object({
+  query: import_v4.z.preprocess(parseStringifiedQueryField, QueryType).meta({
     default: {
       type: "and",
       clauses: [
@@ -1413,190 +1491,193 @@ var SearchQuery = import_zod14.z.object({
       ]
     }
   }),
-  limit: import_zod14.z.number().optional().default(100),
-  offset: import_zod14.z.number().optional().default(0),
-  sort: import_zod14.z.preprocess(
+  limit: import_v4.z.number().optional().default(100),
+  offset: import_v4.z.number().optional().default(0),
+  sort: import_v4.z.preprocess(
     parseStringifiedQueryField,
-    import_zod14.z.array(
-      import_zod14.z.object({
-        field: import_zod14.z.string(),
-        direction: import_zod14.z.enum(["asc", "desc"]).default("asc")
+    import_v4.z.array(
+      import_v4.z.object({
+        field: import_v4.z.string(),
+        direction: import_v4.z.enum(["asc", "desc"]).default("asc")
       })
     )
   ).optional()
-}).openapi({
-  ref: "SearchQuery"
+}).meta({
+  id: "SearchQuery"
 });
 
+// ../commons/src/events/serializers/date/serializer.ts
+var import_zod = require("zod");
+var SerializedNowDateTime = import_zod.z.object({
+  $$now: import_zod.z.literal(true)
+});
+function todayDateTimeValueSerializer() {
+  return { $$now: true };
+}
+
 // ../commons/src/events/FieldConfig.ts
-(0, import_zod_openapi6.extendZodWithOpenApi)(import_zod15.z);
-var FieldId = import_zod15.z.string().refine(
-  /*
-   * Disallow underscores '_' in field ids.
-   * Why? Theres two reasons:
-   *   1. We transform dots to underscores as separator in Formik field ids, so this avoids any issues with the Formik transformations.
-   *   2. On Kysely-SQL queries, we use the CamelCasePlugin. This plugin transforms snake_case to camelCase also on nested (jsonb) object keys.
-   *      This could be disabled via 'maintainNestedObjectKeys: true', but this would also affect SQL queries which use e.g. json_agg() or to_jsonb() to aggregate results.
-   */
-  (val) => !val.includes("_"),
-  (val) => ({
-    message: `id: '${val}' must not contain underscores '_'`
-  })
-).describe("Unique identifier for the field");
-var FieldReference = import_zod15.z.object({
+var FieldId = z17.string().superRefine((val, ctx) => {
+  if (val.includes("_")) {
+    ctx.addIssue({
+      code: z17.ZodIssueCode.custom,
+      message: `id: '${val}' must not contain underscores '_'`
+    });
+  }
+}).describe("Unique identifier for the field");
+var FieldReference = z17.object({
   $$field: FieldId,
-  $$subfield: import_zod15.z.array(import_zod15.z.string()).optional().describe(
+  $$subfield: z17.array(z17.string()).optional().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_zod15.z.object({
+var ValidationConfig = z17.object({
   validator: Conditional,
   message: TranslationConfig
 });
-var requiredSchema = import_zod15.z.union([
-  import_zod15.z.boolean(),
-  import_zod15.z.object({
+var requiredSchema = z17.union([
+  z17.boolean(),
+  z17.object({
     message: TranslationConfig.describe("Custom required validation message")
   })
 ]).default(false).optional();
-var BaseField = import_zod15.z.object({
+var BaseField = z17.object({
   id: FieldId.describe("Unique identifier of the field."),
   label: TranslationConfig.describe("Human-readable label of the field."),
-  parent: FieldReference.or(import_zod15.z.array(FieldReference)).optional().describe(
+  parent: FieldReference.or(z17.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_zod15.z.array(FieldConditional).default([]).optional().describe(
+  conditionals: z17.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_zod15.z.boolean().default(false).optional().describe(
+  secured: z17.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_zod15.z.array(ValidationConfig).default([]).optional().describe("Additional validation rules applied to the field."),
+  validation: z17.array(ValidationConfig).default([]).optional().describe("Additional validation rules applied to the field."),
   helperText: TranslationConfig.optional(),
-  hideLabel: import_zod15.z.boolean().default(false).optional(),
-  uncorrectable: import_zod15.z.boolean().default(false).optional().describe(
+  hideLabel: z17.boolean().default(false).optional(),
+  uncorrectable: z17.boolean().default(false).optional().describe(
     "Indicates whether the field can be modified during record correction."
   ),
-  value: FieldReference.or(import_zod15.z.array(FieldReference)).optional().describe(
+  value: FieldReference.or(z17.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_zod15.z.boolean().default(false).optional().describe(
+  analytics: z17.boolean().default(false).optional().describe(
     "Indicates whether the field is included in analytics. When enabled, its value becomes available in the analytics dashboard."
   )
 }).describe("Common properties shared across all field types.");
 var Divider = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.DIVIDER)
+  type: z17.literal(FieldType.DIVIDER)
 });
 var TextField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.TEXT),
-  defaultValue: import_zod15.z.union([NonEmptyTextValue, SerializedUserField]).optional(),
-  configuration: import_zod15.z.object({
-    maxLength: import_zod15.z.number().optional().describe("Maximum length of the text"),
-    type: import_zod15.z.enum(["text", "password"]).optional(),
+  type: z17.literal(FieldType.TEXT),
+  defaultValue: z17.union([NonEmptyTextValue, SerializedUserField]).optional(),
+  configuration: z17.object({
+    maxLength: z17.number().optional().describe("Maximum length of the text"),
+    type: z17.enum(["text", "password"]).optional(),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).default({ type: "text" }).optional()
 }).describe("Text input");
 var NumberField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.NUMBER),
+  type: z17.literal(FieldType.NUMBER),
   defaultValue: NumberFieldValue.optional(),
-  configuration: import_zod15.z.object({
-    min: import_zod15.z.number().optional().describe("Minimum value"),
-    max: import_zod15.z.number().optional().describe("Maximum value"),
+  configuration: z17.object({
+    min: z17.number().optional().describe("Minimum value"),
+    max: z17.number().optional().describe("Maximum value"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).optional()
 }).describe("Number input");
 var TextAreaField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.TEXTAREA),
+  type: z17.literal(FieldType.TEXTAREA),
   defaultValue: NonEmptyTextValue.optional(),
-  configuration: import_zod15.z.object({
-    maxLength: import_zod15.z.number().optional().describe("Maximum length of the text"),
-    rows: import_zod15.z.number().optional().describe("Number of visible text lines"),
-    cols: import_zod15.z.number().optional().describe("Number of visible columns"),
+  configuration: z17.object({
+    maxLength: z17.number().optional().describe("Maximum length of the text"),
+    rows: z17.number().optional().describe("Number of visible text lines"),
+    cols: z17.number().optional().describe("Number of visible columns"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).default({ rows: 4 }).optional()
 }).describe("Multiline text input");
-var ImageMimeType = import_zod15.z.enum([
+var ImageMimeType = z17.enum([
   "image/png",
   "image/jpg",
   "image/jpeg",
   "image/svg+xml"
 ]);
-var DocumentMimeType = import_zod15.z.enum([
+var DocumentMimeType = z17.enum([
   "application/pdf",
   "application/msword",
   "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
   "application/vnd.oasis.opendocument.text"
 ]);
-var MimeType = import_zod15.z.enum([
+var MimeType = z17.enum([
   ...ImageMimeType.options,
   ...DocumentMimeType.options
 ]);
 var DEFAULT_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
 var SignatureField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.SIGNATURE),
+  type: z17.literal(FieldType.SIGNATURE),
   signaturePromptLabel: TranslationConfig.describe(
     "Title of the signature modal"
   ),
   defaultValue: SignatureFieldValue.optional(),
-  configuration: import_zod15.z.object({
-    maxFileSize: import_zod15.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+  configuration: z17.object({
+    maxFileSize: z17.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_zod15.z.literal(FieldType.EMAIL),
-  configuration: import_zod15.z.object({
-    maxLength: import_zod15.z.number().optional().describe("Maximum length of the text")
-  }).default({ maxLength: 10 }).optional(),
+  type: z17.literal(FieldType.EMAIL),
+  configuration: z17.object({
+    maxLength: z17.number().optional().describe("Maximum length of the text")
+  }).default({ maxLength: 255 }).optional(),
   defaultValue: NonEmptyTextValue.optional()
 });
 var DateField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.DATE),
-  defaultValue: DateValue.optional(),
-  configuration: import_zod15.z.object({
+  type: z17.literal(FieldType.DATE),
+  defaultValue: SerializedNowDateTime.or(DateValue).optional().describe("Default date value(yyyy-MM-dd)"),
+  configuration: z17.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_zod15.z.literal(FieldType.AGE),
+  type: z17.literal(FieldType.AGE),
   defaultValue: NumberFieldValue.optional(),
-  configuration: import_zod15.z.object({
+  configuration: z17.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_zod15.z.literal(FieldType.TIME),
-  defaultValue: TimeValue.optional(),
-  configuration: import_zod15.z.object({
-    use12HourFormat: import_zod15.z.boolean().optional().describe("Whether to use 12-hour format"),
+  type: z17.literal(FieldType.TIME),
+  defaultValue: SerializedNowDateTime.or(TimeValue).optional().describe("Default time value (HH-mm)"),
+  configuration: z17.object({
+    use12HourFormat: z17.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_zod15.z.literal(FieldType.DATE_RANGE),
+  type: z17.literal(FieldType.DATE_RANGE),
   defaultValue: DateRangeFieldValue.optional(),
-  configuration: import_zod15.z.object({
+  configuration: z17.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_zod15.z.enum([
+var HtmlFontVariant = z17.enum([
   "reg12",
   "reg14",
   "reg16",
@@ -1606,34 +1687,34 @@ var HtmlFontVariant = import_zod15.z.enum([
   "h2",
   "h1"
 ]);
-var ParagraphConfiguration = import_zod15.z.object({
-  styles: import_zod15.z.object({
+var ParagraphConfiguration = z17.object({
+  styles: z17.object({
     fontVariant: HtmlFontVariant.optional().describe(
       "Font variant to use for the paragraph text"
     ),
-    hint: import_zod15.z.boolean().optional().describe("When true, paragraph is styled as a hint with grey color")
+    hint: z17.boolean().optional().describe("When true, paragraph is styled as a hint with grey color")
   }).optional()
 }).default({});
 var Paragraph = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.PARAGRAPH),
+  type: z17.literal(FieldType.PARAGRAPH),
   defaultValue: NonEmptyTextValue.optional(),
   configuration: ParagraphConfiguration
 }).describe("A read-only HTML <p> paragraph");
 var PageHeader = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.PAGE_HEADER),
+  type: z17.literal(FieldType.PAGE_HEADER),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("A read-only header component for form pages");
 var File = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.FILE),
+  type: z17.literal(FieldType.FILE),
   defaultValue: FileFieldValue.optional(),
-  configuration: import_zod15.z.object({
-    maxFileSize: import_zod15.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+  configuration: z17.object({
+    maxFileSize: z17.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_zod15.z.object({
-      targetSize: import_zod15.z.object({ width: import_zod15.z.number(), height: import_zod15.z.number() })
+    maxImageSize: z17.object({
+      targetSize: z17.object({ width: z17.number(), height: z17.number() })
     }).optional(),
-    style: import_zod15.z.object({
-      width: import_zod15.z.enum(["full", "auto"]).optional().describe(
+    style: z17.object({
+      width: z17.enum(["full", "auto"]).optional().describe(
         "Whether the file upload button should take the full width of the container or not"
       )
     }).optional(),
@@ -1642,46 +1723,46 @@ var File = BaseField.extend({
     maxFileSize: DEFAULT_MAX_FILE_SIZE_BYTES
   })
 }).describe("File upload");
-var SelectOption = import_zod15.z.object({
-  value: import_zod15.z.string().describe("The value of the option"),
-  label: import_zod15.z.union([import_zod15.z.string(), TranslationConfig]).describe("The label of the option")
+var SelectOption = z17.object({
+  value: z17.string().describe("The value of the option"),
+  label: z17.union([z17.string(), TranslationConfig]).describe("The label of the option")
 });
 var NumberWithUnitField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.NUMBER_WITH_UNIT),
+  type: z17.literal(FieldType.NUMBER_WITH_UNIT),
   defaultValue: NumberWithUnitFieldValue.optional(),
-  options: import_zod15.z.array(SelectOption).describe("A list of options for the unit select"),
-  configuration: import_zod15.z.object({
-    min: import_zod15.z.number().optional().describe("Minimum value of the number field"),
-    max: import_zod15.z.number().optional().describe("Maximum value of the number field"),
+  options: z17.array(SelectOption).describe("A list of options for the unit select"),
+  configuration: z17.object({
+    min: z17.number().optional().describe("Minimum value of the number field"),
+    max: z17.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_zod15.z.literal(FieldType.RADIO_GROUP),
+  type: z17.literal(FieldType.RADIO_GROUP),
   defaultValue: TextValue.optional(),
-  options: import_zod15.z.array(SelectOption).describe("A list of options"),
-  configuration: import_zod15.z.object({
-    styles: import_zod15.z.object({
-      size: import_zod15.z.enum(["NORMAL", "LARGE"]).optional()
+  options: z17.array(SelectOption).describe("A list of options"),
+  configuration: z17.object({
+    styles: z17.object({
+      size: z17.enum(["NORMAL", "LARGE"]).optional()
     }).optional()
   }).optional()
 }).describe("Grouped radio options");
 var BulletList = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.BULLET_LIST),
+  type: z17.literal(FieldType.BULLET_LIST),
   defaultValue: TextValue.optional(),
-  items: import_zod15.z.array(TranslationConfig).describe("A list of items"),
-  configuration: import_zod15.z.object({
-    styles: import_zod15.z.object({
+  items: z17.array(TranslationConfig).describe("A list of items"),
+  configuration: z17.object({
+    styles: z17.object({
       fontVariant: HtmlFontVariant.optional()
     }).optional()
   }).default({})
 }).describe("A list of bullet points");
 var Select = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.SELECT),
+  type: z17.literal(FieldType.SELECT),
   defaultValue: TextValue.optional(),
-  options: import_zod15.z.array(SelectOption).describe("A list of options"),
+  options: z17.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.
@@ -1693,34 +1774,34 @@ var Select = BaseField.extend({
   `
   )
 }).describe("Select input");
-var SelectDateRangeOption = import_zod15.z.object({
+var SelectDateRangeOption = z17.object({
   value: SelectDateRangeValue.describe("The value of the option"),
   label: TranslationConfig.describe("The label of the option")
 });
 var SelectDateRangeField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.SELECT_DATE_RANGE),
+  type: z17.literal(FieldType.SELECT_DATE_RANGE),
   defaultValue: SelectDateRangeValue.optional(),
-  options: import_zod15.z.array(SelectDateRangeOption).describe("A list of options")
+  options: z17.array(SelectDateRangeOption).describe("A list of options")
 }).describe("Select input with date range options");
-var NameConfig = import_zod15.z.object({
-  firstname: import_zod15.z.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional(),
-  middlename: import_zod15.z.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional(),
-  surname: import_zod15.z.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional()
+var NameConfig = z17.object({
+  firstname: z17.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional(),
+  middlename: z17.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional(),
+  surname: z17.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional()
 });
 var NameField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.NAME),
-  defaultValue: import_zod15.z.object({
+  type: z17.literal(FieldType.NAME),
+  defaultValue: z17.object({
     firstname: SerializedUserField.or(NonEmptyTextValue).optional(),
     middlename: SerializedUserField.or(NonEmptyTextValue).optional(),
     surname: SerializedUserField.or(NonEmptyTextValue).optional()
   }).optional(),
-  configuration: import_zod15.z.object({
+  configuration: z17.object({
     name: NameConfig.default({
       firstname: { required: true },
       surname: { required: true }
     }).optional(),
-    order: import_zod15.z.array(import_zod15.z.enum(["firstname", "middlename", "surname"])).optional(),
-    maxLength: import_zod15.z.number().optional().describe("Maximum length of the text"),
+    order: z17.array(z17.enum(["firstname", "middlename", "surname"])).optional(),
+    maxLength: z17.number().optional().describe("Maximum length of the text"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).default({
@@ -1732,51 +1813,51 @@ var NameField = BaseField.extend({
 }).describe("Name input field");
 var PhoneField = BaseField.extend({
   defaultValue: NonEmptyTextValue.optional(),
-  type: import_zod15.z.literal(FieldType.PHONE)
+  type: z17.literal(FieldType.PHONE)
 }).describe("Phone input field");
 var IdField = BaseField.extend({
   defaultValue: NonEmptyTextValue.optional(),
-  type: import_zod15.z.literal(FieldType.ID)
+  type: z17.literal(FieldType.ID)
 }).describe("ID input field");
 var Checkbox = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.CHECKBOX),
+  type: z17.literal(FieldType.CHECKBOX),
   defaultValue: CheckboxFieldValue.default(false)
 }).describe("Boolean checkbox field");
 var Country = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.COUNTRY),
+  type: z17.literal(FieldType.COUNTRY),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("Country select field");
-var AdministrativeAreas = import_zod15.z.enum([
+var AdministrativeAreas = z17.enum([
   "ADMIN_STRUCTURE",
   "HEALTH_FACILITY",
   "CRVS_OFFICE"
 ]);
-var AdministrativeAreaConfiguration = import_zod15.z.object({
-  partOf: import_zod15.z.object({
-    $declaration: import_zod15.z.string()
+var AdministrativeAreaConfiguration = z17.object({
+  partOf: z17.object({
+    $declaration: z17.string()
   }).optional().describe("Parent location"),
   type: AdministrativeAreas
 }).describe("Administrative area options");
-var AdministrativeArea = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.ADMINISTRATIVE_AREA),
+var AdministrativeAreaField = BaseField.extend({
+  type: z17.literal(FieldType.ADMINISTRATIVE_AREA),
   defaultValue: NonEmptyTextValue.optional(),
   configuration: AdministrativeAreaConfiguration
 }).describe("Administrative area input field e.g. facility, office");
 var LocationInput = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.LOCATION),
+  type: z17.literal(FieldType.LOCATION),
   defaultValue: NonEmptyTextValue.optional(),
-  configuration: import_zod15.z.object({
-    searchableResource: import_zod15.z.array(import_zod15.z.enum(["locations", "facilities", "offices"]))
+  configuration: z17.object({
+    searchableResource: z17.array(z17.enum(["locations", "facilities", "offices"]))
   })
 }).describe("Input field for a location");
 var FileUploadWithOptions = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.FILE_WITH_OPTIONS),
-  options: import_zod15.z.array(SelectOption).describe("A list of options"),
+  type: z17.literal(FieldType.FILE_WITH_OPTIONS),
+  options: z17.array(SelectOption).describe("A list of options"),
   defaultValue: FileFieldWithOptionValue.optional(),
-  configuration: import_zod15.z.object({
-    maxFileSize: import_zod15.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
-    maxImageSize: import_zod15.z.object({
-      targetSize: import_zod15.z.object({ width: import_zod15.z.number(), height: import_zod15.z.number() })
+  configuration: z17.object({
+    maxFileSize: z17.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+    maxImageSize: z17.object({
+      targetSize: z17.object({ width: z17.number(), height: z17.number() })
     }).optional(),
     acceptedFileTypes: MimeType.array().optional().describe("List of allowed file formats for the signature")
   }).default({
@@ -1784,93 +1865,93 @@ var FileUploadWithOptions = BaseField.extend({
   })
 });
 var Facility = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.FACILITY),
+  type: z17.literal(FieldType.FACILITY),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("Input field for a facility");
 var Office = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.OFFICE),
+  type: z17.literal(FieldType.OFFICE),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("Input field for an office");
 var DefaultAddressFieldValue = DomesticAddressFieldValue.extend({
-  administrativeArea: import_zod15.z.union([UUID, SerializedUserField]).optional()
+  administrativeArea: z17.union([UUID, SerializedUserField]).optional()
 });
 var Address = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.ADDRESS),
-  configuration: import_zod15.z.object({
-    lineSeparator: import_zod15.z.string().optional(),
-    fields: import_zod15.z.array(import_zod15.z.enum(["country", "administrativeArea"])).optional(),
-    administrativeLevels: import_zod15.z.array(import_zod15.z.string()).optional(),
-    streetAddressForm: import_zod15.z.array(
-      import_zod15.z.object({
-        id: import_zod15.z.string(),
+  type: z17.literal(FieldType.ADDRESS),
+  configuration: z17.object({
+    lineSeparator: z17.string().optional(),
+    fields: z17.array(z17.enum(["country", "administrativeArea"])).optional(),
+    administrativeLevels: z17.array(z17.string()).optional(),
+    streetAddressForm: z17.array(
+      z17.object({
+        id: z17.string(),
         required: requiredSchema,
         label: TranslationConfig,
-        type: import_zod15.z.literal(FieldType.TEXT),
-        conditionals: import_zod15.z.array(FieldConditional).default([]).optional(),
+        type: z17.literal(FieldType.TEXT),
+        conditionals: z17.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_zod15.z.object({
-  id: import_zod15.z.string().describe("ID for the data entry."),
+var StaticDataEntry = z17.object({
+  id: z17.string().describe("ID for the data entry."),
   label: TranslationConfig,
-  value: TranslationConfig.or(import_zod15.z.string()).or(FieldReference)
+  value: TranslationConfig.or(z17.string()).or(FieldReference)
 }).describe("Static data entry");
-var DataEntry = import_zod15.z.union([StaticDataEntry, import_zod15.z.object({ fieldId: import_zod15.z.string() })]).describe(
+var DataEntry = z17.union([StaticDataEntry, z17.object({ fieldId: z17.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_zod15.z.literal(FieldType.DATA),
-  configuration: import_zod15.z.object({
+  type: z17.literal(FieldType.DATA),
+  configuration: z17.object({
     subtitle: TranslationConfig.optional(),
-    data: import_zod15.z.array(DataEntry)
+    data: z17.array(DataEntry)
   })
 }).describe("Data field for displaying read-only data");
 var ButtonField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.BUTTON),
+  type: z17.literal(FieldType.BUTTON),
   defaultValue: ButtonFieldValue.optional(),
-  configuration: import_zod15.z.object({
-    icon: import_zod15.z.string().optional().describe(
+  configuration: z17.object({
+    icon: z17.string().optional().describe(
       "Icon for the button. You can find icons from OpenCRVS UI-Kit."
     ),
-    loading: import_zod15.z.boolean().optional().describe("Whether the button is in a loading state and shows a spinner"),
+    loading: z17.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 AlphaPrintButton = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.ALPHA_PRINT_BUTTON),
-  configuration: import_zod15.z.object({
-    template: import_zod15.z.string().describe("Template ID from countryconfig templates to use for printing"),
+  type: z17.literal(FieldType.ALPHA_PRINT_BUTTON),
+  configuration: z17.object({
+    template: z17.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_zod15.z.literal(FieldType.HTTP),
+  type: z17.literal(FieldType.HTTP),
   defaultValue: HttpFieldValue.optional(),
-  configuration: import_zod15.z.object({
+  configuration: z17.object({
     trigger: FieldReference,
-    url: import_zod15.z.string().describe("URL to send the HTTP request to"),
-    method: import_zod15.z.enum(["GET", "POST", "PUT", "DELETE"]),
-    headers: import_zod15.z.record(import_zod15.z.string()).optional(),
-    body: import_zod15.z.record(import_zod15.z.any()).optional(),
-    errorValue: import_zod15.z.any().optional().describe("Value to set if the request fails"),
-    params: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.union([import_zod15.z.string(), FieldReference])).optional(),
-    timeout: import_zod15.z.number().default(15e3).describe("Request timeout in milliseconds")
+    url: z17.string().describe("URL to send the HTTP request to"),
+    method: z17.enum(["GET", "POST", "PUT", "DELETE"]),
+    headers: z17.record(z17.string(), z17.string()).optional(),
+    body: z17.record(z17.string(), z17.any()).optional(),
+    errorValue: z17.any().optional().describe("Value to set if the request fails"),
+    params: z17.record(z17.string(), z17.union([z17.string(), FieldReference])).optional(),
+    timeout: z17.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_zod15.z.literal(FieldType.SEARCH),
+  type: z17.literal(FieldType.SEARCH),
   configuration: SearchQuery.pick({
     query: true,
     limit: true,
     offset: true
   }).extend({
     validation: ValidationConfig,
-    indicators: import_zod15.z.object({
+    indicators: z17.object({
       loading: TranslationConfig.optional().describe(
         "Text to display while the search is in progress"
       ),
@@ -1885,7 +1966,7 @@ var SearchField = HttpField.extend({
       ),
       confirmButton: TranslationConfig.optional(),
       clearButton: TranslationConfig.optional(),
-      clearModal: import_zod15.z.object({
+      clearModal: z17.object({
         title: TranslationConfig.optional(),
         description: TranslationConfig.optional(),
         cancel: TranslationConfig.optional(),
@@ -1896,17 +1977,17 @@ var SearchField = HttpField.extend({
   })
 });
 var LinkButtonField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.LINK_BUTTON),
-  configuration: import_zod15.z.object({
-    url: import_zod15.z.string().describe("URL to open"),
+  type: z17.literal(FieldType.LINK_BUTTON),
+  configuration: z17.object({
+    url: z17.string().describe("URL to open"),
     text: TranslationConfig.describe("Text to display on the button"),
-    icon: import_zod15.z.string().optional().describe("Icon for the button. You can find icons from OpenCRVS UI-Kit.")
+    icon: z17.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_zod15.z.literal(FieldType.VERIFICATION_STATUS),
+  type: z17.literal(FieldType.VERIFICATION_STATUS),
   defaultValue: VerificationStatusValue.optional(),
-  configuration: import_zod15.z.object({
+  configuration: z17.object({
     status: TranslationConfig.describe("Text to display on the status pill."),
     description: TranslationConfig.describe(
       "Explaining text on the banner in form."
@@ -1914,38 +1995,55 @@ var VerificationStatus = BaseField.extend({
   })
 });
 var QueryParamReaderField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.QUERY_PARAM_READER),
-  configuration: import_zod15.z.object({
-    pickParams: import_zod15.z.array(import_zod15.z.string()).describe("List of query parameters to read from the URL")
+  type: z17.literal(FieldType.QUERY_PARAM_READER),
+  configuration: z17.object({
+    pickParams: z17.array(z17.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_zod15.z.literal(FieldType.QR_READER),
+  type: z17.literal(FieldType.QR_READER),
   defaultValue: QrReaderFieldValue.optional(),
-  configuration: import_zod15.z.object({
-    validator: import_zod15.z.custom(
-      (val) => typeof val === "object" && val !== null
-    )
+  configuration: z17.object({
+    validator: z17.any().meta({
+      description: "JSON Schema to validate the scanned QR code data against before populating the form fields.",
+      id: "QrReaderFieldValidator"
+    })
   }).optional()
+}).meta({
+  description: "Configuration for QR code reader field, including optional JSON Schema validator.",
+  id: "QrReaderField"
 });
 var IdReaderField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.ID_READER),
+  type: z17.literal(FieldType.ID_READER),
   defaultValue: IdReaderFieldValue.optional(),
-  methods: import_zod15.z.array(
-    import_zod15.z.union([QrReaderField, LinkButtonField]).describe("Methods for reading an ID")
+  methods: z17.array(
+    z17.union([QrReaderField, LinkButtonField]).describe("Methods for reading an ID")
   )
 });
+var CustomField = BaseField.extend({
+  type: z17.literal(FieldType._EXPERIMENTAL_CUSTOM),
+  defaultValue: CustomFieldValue.optional(),
+  src: z17.string().describe("Module source path for the custom field component"),
+  configuration: z17.unknown().optional()
+});
 var LoaderField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.LOADER),
-  configuration: import_zod15.z.object({
+  type: z17.literal(FieldType.LOADER),
+  configuration: z17.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_zod15.z.discriminatedUnion("type", [
+var HiddenField = BaseField.extend({
+  type: z17.literal(FieldType.ALPHA_HIDDEN),
+  required: z17.boolean().default(false).optional(),
+  defaultValue: TextValue.optional()
+}).describe(
+  "A non-interactive, hidden field that only hold a value in the form"
+);
+var FieldConfig = z17.discriminatedUnion("type", [
   Address,
   TextField,
   NumberField,
@@ -1967,7 +2065,7 @@ var FieldConfig = import_zod15.z.discriminatedUnion("type", [
   Checkbox,
   File,
   Country,
-  AdministrativeArea,
+  AdministrativeAreaField,
   Divider,
   LocationInput,
   Facility,
@@ -1985,83 +2083,81 @@ var FieldConfig = import_zod15.z.discriminatedUnion("type", [
   IdReaderField,
   QueryParamReaderField,
   LoaderField,
-  SearchField
-]).openapi({
+  SearchField,
+  CustomField,
+  HiddenField
+]).meta({
   description: "Form field configuration",
-  ref: "FieldConfig"
+  id: "FieldConfig"
 });
-var AnyFileField = import_zod15.z.discriminatedUnion("type", [
+var AnyFileField = z17.discriminatedUnion("type", [
   SignatureField,
   File,
   FileUploadWithOptions
 ]);
 
 // ../commons/src/events/FormConfig.ts
-var import_zod17 = require("zod");
+var z19 = __toESM(require("zod/v4"));
 
 // ../commons/src/events/PageConfig.ts
-var import_zod16 = require("zod");
-var import_zod_openapi7 = require("zod-openapi");
-(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod16.z);
-var PageTypes = import_zod16.z.enum(["FORM", "VERIFICATION"]);
-var PageConfigBase = import_zod16.z.object({
-  id: import_zod16.z.string().describe("Unique identifier for the page"),
+var z18 = __toESM(require("zod/v4"));
+var PageTypes = z18.enum(["FORM", "VERIFICATION"]);
+var PageConfigBase = z18.object({
+  id: z18.string().describe("Unique identifier for the page"),
   title: TranslationConfig.describe("Header title of the page"),
-  requireCompletionToContinue: import_zod16.z.boolean().default(false).describe(
+  requireCompletionToContinue: z18.boolean().default(false).describe(
     "If true, all required fields must be filled before continuing to the next page"
   ),
-  fields: import_zod16.z.array(FieldConfig).describe("Fields to be rendered on the page"),
+  fields: z18.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."
   )
-}).openapi({
+}).meta({
   description: "Form page configuration",
-  ref: "FormPageConfig"
+  id: "FormPageConfig"
 });
 var FormPageConfig = PageConfigBase.extend({
-  type: import_zod16.z.literal(PageTypes.enum.FORM).default(PageTypes.enum.FORM)
+  type: z18.literal(PageTypes.enum.FORM).default(PageTypes.enum.FORM)
 });
-var VerificationActionConfig = import_zod16.z.object({
-  verify: import_zod16.z.object({ label: TranslationConfig }),
-  cancel: import_zod16.z.object({
+var VerificationActionConfig = z18.object({
+  verify: z18.object({ label: TranslationConfig }),
+  cancel: z18.object({
     label: TranslationConfig,
-    confirmation: import_zod16.z.object({
+    confirmation: z18.object({
       title: TranslationConfig,
       body: TranslationConfig
     })
   })
-}).describe("Actions available on the verification page").openapi({
+}).describe("Actions available on the verification page").meta({
   description: "Verification action configuration",
-  ref: "VerificationActionConfig"
+  id: "VerificationActionConfig"
 });
 var VerificationPageConfig = FormPageConfig.extend({
-  type: import_zod16.z.literal(PageTypes.enum.VERIFICATION),
+  type: z18.literal(PageTypes.enum.VERIFICATION),
   actions: VerificationActionConfig
 });
-var PageConfig = import_zod16.z.discriminatedUnion("type", [
+var PageConfig = z18.discriminatedUnion("type", [
   FormPageConfig,
   VerificationPageConfig
 ]);
 
 // ../commons/src/events/FormConfig.ts
-var DeclarationFormConfig = import_zod17.z.object({
+var DeclarationFormConfig = z19.object({
   label: TranslationConfig.describe("Human readable description of the form"),
-  pages: import_zod17.z.array(FormPageConfig)
+  pages: z19.array(FormPageConfig)
 }).describe("Configuration of the declaration form.");
-var ActionFormConfig = import_zod17.z.object({
+var ActionFormConfig = z19.object({
   label: TranslationConfig.describe("Human readable description of the form"),
-  pages: import_zod17.z.array(PageConfig)
+  pages: z19.array(PageConfig)
 }).describe(
   "Configuration of the form used for system actions beyond declaration, supporting a wider range of page types."
 );
-var FormConfig = import_zod17.z.union([DeclarationFormConfig, ActionFormConfig]);
+var FormConfig = z19.union([DeclarationFormConfig, ActionFormConfig]);
 
 // ../commons/src/events/DeduplicationConfig.ts
-var import_zod18 = require("zod");
-var import_zod_openapi8 = require("zod-openapi");
-(0, import_zod_openapi8.extendZodWithOpenApi)(import_zod18.z);
-var FieldReference2 = import_zod18.z.string();
-var Matcher = import_zod18.z.object({
+var z20 = __toESM(require("zod/v4"));
+var FieldReference2 = z20.string();
+var Matcher = z20.object({
   /**
    * Reference to the field used in matching.
    *
@@ -2069,68 +2165,68 @@ var Matcher = import_zod18.z.object({
    * be used as the origin date to calculate the distance from.
    */
   fieldId: FieldReference2,
-  options: import_zod18.z.object({
-    boost: import_zod18.z.number().optional()
+  options: z20.object({
+    boost: z20.number().optional()
   }).optional().default({
     boost: 1
   })
 });
 var FuzzyMatcher = Matcher.extend({
-  type: import_zod18.z.literal("fuzzy"),
-  options: import_zod18.z.object({
+  type: z20.literal("fuzzy"),
+  options: z20.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_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]).optional().default("AUTO:4,7"),
-    boost: import_zod18.z.number().optional().default(1)
+    fuzziness: z20.union([z20.string(), z20.number()]).optional().default("AUTO:4,7"),
+    boost: z20.number().optional().default(1)
   }).optional().default({
     fuzziness: "AUTO:4,7",
     boost: 1
   })
 });
 var StrictMatcher = Matcher.extend({
-  type: import_zod18.z.literal("strict"),
-  options: import_zod18.z.object({
-    boost: import_zod18.z.number().optional().default(1),
+  type: z20.literal("strict"),
+  options: z20.object({
+    boost: z20.number().optional().default(1),
     /**
      * The constant value to be present in the field for both records
      */
-    value: import_zod18.z.string().optional()
+    value: z20.string().optional()
   }).optional().default({
     boost: 1
   })
 });
 var DateRangeMatcher = Matcher.extend({
-  type: import_zod18.z.literal("dateRange"),
-  options: import_zod18.z.object({
+  type: z20.literal("dateRange"),
+  options: z20.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_zod18.z.number().optional(),
-    days: import_zod18.z.number(),
-    boost: import_zod18.z.number().optional().default(1)
+    pivot: z20.number().optional(),
+    days: z20.number(),
+    boost: z20.number().optional().default(1)
   })
 });
-var Not = import_zod18.z.object({
-  type: import_zod18.z.literal("not"),
+var Not = z20.object({
+  type: z20.literal("not"),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clause: import_zod18.z.lazy(() => Clause)
+  clause: z20.lazy(() => Clause)
 });
-var And = import_zod18.z.object({
-  type: import_zod18.z.literal("and"),
+var And = z20.object({
+  type: z20.literal("and"),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clauses: import_zod18.z.lazy(() => Clause.array())
+  clauses: z20.lazy(() => Clause.array())
 });
-var Or = import_zod18.z.object({
-  type: import_zod18.z.literal("or"),
+var Or = z20.object({
+  type: z20.literal("or"),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clauses: import_zod18.z.lazy(() => Clause.array())
+  clauses: z20.lazy(() => Clause.array())
 });
-var Clause = import_zod18.z.lazy(
-  () => import_zod18.z.discriminatedUnion("type", [
+var Clause = z20.lazy(
+  () => z20.discriminatedUnion("type", [
     Not,
     And,
     Or,
@@ -2138,193 +2234,328 @@ var Clause = import_zod18.z.lazy(
     StrictMatcher,
     DateRangeMatcher
   ])
-).openapi({
-  ref: "Clause"
+).meta({
+  id: "Clause"
 });
-var DeduplicationConfig = import_zod18.z.object({
-  id: import_zod18.z.string(),
+var DeduplicationConfig = z20.object({
+  id: z20.string(),
   label: TranslationConfig,
   query: Clause
 });
 
+// ../commons/src/icons.ts
+var z21 = __toESM(require("zod/v4"));
+var AvailableIcons = z21.enum([
+  "Archived",
+  "Assigned",
+  "Briefcase",
+  "Certified",
+  "Close",
+  "Collapse",
+  "Draft",
+  "DuplicateYellow",
+  "Expand",
+  "ExternalValidate",
+  "FilledCheck",
+  "InReview",
+  "Offline",
+  "Registered",
+  "RequiresUpdates",
+  "Sent",
+  "Validated",
+  "WaitingApproval",
+  "ChartActivity",
+  "Activity",
+  "Archive",
+  "ArchiveTray",
+  "ArrowLeft",
+  "ArrowRight",
+  "Buildings",
+  "Circle",
+  "CaretDown",
+  "CaretLeft",
+  "CaretRight",
+  "ChartBar",
+  "ChartLine",
+  "ChatCircle",
+  "CheckSquare",
+  "Compass",
+  "Check",
+  "Copy",
+  "Database",
+  "DotsThreeVertical",
+  "ArrowCounterClockwise",
+  "MagnifyingGlassMinus",
+  "MagnifyingGlassPlus",
+  "Export",
+  "Eye",
+  "EyeSlash",
+  "Envelope",
+  "File",
+  "FileSearch",
+  "FileMinus",
+  "FilePlus",
+  "FileText",
+  "FileX",
+  "Handshake",
+  "Gear",
+  "GitBranch",
+  "IdentificationCard",
+  "List",
+  "ListBullets",
+  "Lock",
+  "MagnifyingGlass",
+  "MapPin",
+  "Medal",
+  "NotePencil",
+  "Paperclip",
+  "PaperPlaneTilt",
+  "Pen",
+  "PenNib",
+  "Pencil",
+  "PencilSimpleLine",
+  "Phone",
+  "Plus",
+  "Printer",
+  "SignOut",
+  "Stamp",
+  "Star",
+  "Target",
+  "TextT",
+  "Trash",
+  "UploadSimple",
+  "User",
+  "UserPlus",
+  "Users",
+  "WarningCircle",
+  "X",
+  "ChatText",
+  "CircleWavyCheck",
+  "CircleWavyQuestion",
+  "ArchiveBox",
+  "ArrowCircleDown",
+  "FileArrowUp",
+  "FileDotted",
+  "Files",
+  "PencilLine",
+  "PencilCircle",
+  "UserCircle",
+  "Clock",
+  "QrCode",
+  "Webcam",
+  "Sun",
+  "DeviceTabletCamera",
+  "Globe",
+  "Fingerprint",
+  "PushPin",
+  "Timer"
+]);
+
 // ../commons/src/events/ActionConfig.ts
-var import_zod_openapi9 = require("zod-openapi");
-(0, import_zod_openapi9.extendZodWithOpenApi)(import_zod19.z);
-var DeclarationReviewConfig = import_zod19.z.object({
+var DeclarationReviewConfig = z22.object({
   title: TranslationConfig.describe("Title of the review page"),
-  fields: import_zod19.z.array(FieldConfig).describe("Fields displayed on the review page for annotations.")
+  fields: z22.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_zod19.z.object({
-  label: TranslationConfig.describe("Human readable description of the action")
+var ActionConfigBase = z22.object({
+  label: TranslationConfig.describe("Human readable description of the action"),
+  flags: z22.array(ActionFlagConfig).optional().default([]).describe("Flag actions which are executed when the action is performed."),
+  supportingCopy: TranslationConfig.optional().describe(
+    "Text displayed on the confirmation dialog"
+  ),
+  icon: AvailableIcons.describe("Icon representing the action").optional(),
+  conditionals: z22.array(ActionConditional).optional().describe("Conditionals which can disable or hide actions.")
 });
 var DeclarationActionBase = ActionConfigBase.extend({
-  review: DeclarationReviewConfig,
   deduplication: DeduplicationConfig.optional()
 });
-var ReadActionConfig = ActionConfigBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.READ),
+var ReadActionConfig = ActionConfigBase.extend(
+  z22.object({
+    type: z22.literal(ActionType.READ),
     review: DeclarationReviewConfig.describe(
       "Configuration of the review page for read-only view."
-    )
-  })
-);
-var DeclareConfig = DeclarationActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.DECLARE)
-  })
+    ),
+    conditionals: z22.never().optional().describe("Read-action can not be disabled or hidden with conditionals.")
+  }).shape
 );
-var ValidateConfig = DeclarationActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.VALIDATE)
-  })
+var DeclareConfig = DeclarationActionBase.extend(
+  z22.object({
+    type: z22.literal(ActionType.DECLARE),
+    review: DeclarationReviewConfig.describe(
+      "Configuration of the review page fields."
+    ),
+    dialogCopy: z22.object({
+      notify: TranslationConfig.describe(
+        "Confirmation text for the notify action"
+      ),
+      declare: TranslationConfig.describe(
+        "Confirmation text for the declare action"
+      ),
+      register: TranslationConfig.describe(
+        "Confirmation text for the register action"
+      )
+    }).optional()
+  }).shape
 );
-var RegisterConfig = DeclarationActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REGISTER)
-  })
+var ArchiveConfig = ActionConfigBase.extend(
+  z22.object({
+    type: z22.literal(ActionType.ARCHIVE)
+  }).shape
 );
-var RejectDeclarationConfig = ActionConfigBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REJECT)
-  })
+var EditActionConfig = ActionConfigBase.extend(
+  z22.object({
+    type: z22.literal(ActionType.EDIT),
+    dialogCopy: z22.object({
+      notify: TranslationConfig.describe(
+        "Confirmation text for the notify with edits action"
+      ),
+      declare: TranslationConfig.describe(
+        "Confirmation text for the declare with edits action"
+      ),
+      register: TranslationConfig.describe(
+        "Confirmation text for the register with edits action"
+      )
+    })
+  }).shape
 );
-var ArchiveConfig = ActionConfigBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.ARCHIVE)
-  })
+var RejectConfig = ActionConfigBase.extend(
+  z22.object({
+    type: z22.literal(ActionType.REJECT)
+  }).shape
 );
-var DeleteConfig = ActionConfigBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.DELETE)
-  })
+var RegisterConfig = DeclarationActionBase.extend(
+  z22.object({
+    type: z22.literal(ActionType.REGISTER)
+  }).shape
 );
-var PrintCertificateActionConfig = ActionConfigBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.PRINT_CERTIFICATE),
+var PrintCertificateActionConfig = ActionConfigBase.extend(
+  z22.object({
+    type: z22.literal(ActionType.PRINT_CERTIFICATE),
     printForm: ActionFormConfig
-  })
+  }).shape
 );
-var RequestCorrectionConfig = ActionConfigBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REQUEST_CORRECTION),
+var RequestCorrectionConfig = ActionConfigBase.extend(
+  z22.object({
+    type: z22.literal(ActionType.REQUEST_CORRECTION),
     correctionForm: ActionFormConfig
-  })
+  }).shape
 );
-var RejectCorrectionConfig = ActionConfigBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REJECT_CORRECTION)
-  })
-);
-var ApproveCorrectionConfig = ActionConfigBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.APPROVE_CORRECTION)
+var CustomActionConfig = ActionConfigBase.merge(
+  z22.object({
+    type: z22.literal(ActionType.CUSTOM),
+    customActionType: z22.string().describe("Type identifier of the custom action."),
+    /** Custom action form configuration supports a simple array of field configs, which should be rendered on the action modal. In the future, we might add support for pages etc. */
+    form: z22.array(FieldConfig).describe(
+      "Form configuration for the custom action. The form configured here will be used on the custom action confirmation modal."
+    ),
+    auditHistoryLabel: TranslationConfig.describe(
+      'The label to show in audit history for this action. For example "Approved".'
+    )
   })
 );
-var ActionConfig = import_zod19.z.discriminatedUnion("type", [
+var ActionConfig = z22.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.
    */
-  ReadActionConfig.openapi({ ref: "ReadActionConfig" }),
-  DeclareConfig.openapi({ ref: "DeclareActionConfig" }),
-  ValidateConfig.openapi({ ref: "ValidateActionConfig" }),
-  RejectDeclarationConfig.openapi({ ref: "RejectDeclarationActionConfig" }),
-  ArchiveConfig.openapi({ ref: "ArchiveActionConfig" }),
-  RegisterConfig.openapi({ ref: "RegisterActionConfig" }),
-  DeleteConfig.openapi({ ref: "DeleteActionConfig" }),
-  PrintCertificateActionConfig.openapi({
-    ref: "PrintCertificateActionConfig"
+  ReadActionConfig.meta({ id: "ReadActionConfig" }),
+  DeclareConfig.meta({ id: "DeclareActionConfig" }),
+  RejectConfig.meta({ id: "RejectActionConfig" }),
+  RegisterConfig.meta({ id: "RegisterActionConfig" }),
+  PrintCertificateActionConfig.meta({
+    id: "PrintCertificateActionConfig"
   }),
-  RequestCorrectionConfig.openapi({ ref: "RequestCorrectionActionConfig" }),
-  RejectCorrectionConfig.openapi({ ref: "RejectCorrectionActionConfig" }),
-  ApproveCorrectionConfig.openapi({ ref: "ApproveCorrectionActionConfig" })
+  RequestCorrectionConfig.meta({ id: "RequestCorrectionActionConfig" }),
+  EditActionConfig.meta({ id: "EditActionConfig" }),
+  ArchiveConfig.meta({ id: "ArchiveActionConfig" }),
+  CustomActionConfig.meta({ id: "CustomActionConfig" })
 ]).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_zod19.z.discriminatedUnion("type", [
+).meta({ id: "ActionConfig" });
+var actionConfigTypes = new Set(
+  ActionConfig.options.map((opt) => opt.shape.type.value)
+);
+var DeclarationActionConfig = z22.discriminatedUnion("type", [
   DeclareConfig,
-  ValidateConfig,
   RegisterConfig
 ]);
 
 // ../commons/src/events/offline/CertificateConfig.ts
-var import_zod20 = require("zod");
-var FontFamily = import_zod20.z.object({
-  normal: import_zod20.z.string(),
-  bold: import_zod20.z.string(),
-  italics: import_zod20.z.string(),
-  bolditalics: import_zod20.z.string()
-});
-var CertificateConfig = import_zod20.z.object({
-  id: import_zod20.z.string(),
-  event: import_zod20.z.string(),
-  isV2Template: import_zod20.z.boolean().optional(),
+var z23 = __toESM(require("zod/v4"));
+var FontFamily = z23.object({
+  normal: z23.string(),
+  bold: z23.string(),
+  italics: z23.string(),
+  bolditalics: z23.string()
+});
+var CertificateConfig = z23.object({
+  id: z23.string(),
+  event: z23.string(),
+  isV2Template: z23.boolean().optional(),
   label: TranslationConfig,
-  isDefault: import_zod20.z.boolean(),
-  fee: import_zod20.z.object({
-    onTime: import_zod20.z.number(),
-    late: import_zod20.z.number(),
-    delayed: import_zod20.z.number()
+  isDefault: z23.boolean(),
+  fee: z23.object({
+    onTime: z23.number(),
+    late: z23.number(),
+    delayed: z23.number()
   }),
-  svgUrl: import_zod20.z.string(),
-  fonts: import_zod20.z.record(FontFamily).optional(),
-  conditionals: import_zod20.z.array(ShowConditional).optional()
+  svgUrl: z23.string(),
+  fonts: z23.record(z23.string(), FontFamily).optional(),
+  conditionals: z23.array(ShowConditional).optional()
 });
 var CertificateTemplateConfig = CertificateConfig.extend({
-  hash: import_zod20.z.string().optional(),
-  svg: import_zod20.z.string()
+  hash: z23.string().optional(),
+  svg: z23.string()
 });
 
 // ../commons/src/events/offline/LanguageConfig.ts
-var import_zod21 = require("zod");
-var LanguageConfig = import_zod21.z.object({
-  lang: import_zod21.z.string(),
+var z24 = __toESM(require("zod/v4"));
+var LanguageConfig = z24.object({
+  lang: z24.string(),
   /**
    * client.csv contents
    */
-  messages: import_zod21.z.record(import_zod21.z.string())
+  messages: z24.record(z24.string(), z24.string())
 });
 
 // ../commons/src/events/EventConfig.ts
-var import_zod26 = require("zod");
+var z30 = __toESM(require("zod/v4"));
 
 // ../commons/src/events/SummaryConfig.ts
-var import_zod22 = require("zod");
-var BaseField2 = import_zod22.z.object({
+var z25 = __toESM(require("zod/v4"));
+var BaseField2 = z25.object({
   emptyValueMessage: TranslationConfig.optional().describe(
     "Default message displayed when the field value is empty."
   ),
-  conditionals: import_zod22.z.array(ShowConditional).default([]).optional()
+  conditionals: z25.array(ShowConditional).default([]).optional()
 });
 var ReferenceField = BaseField2.extend({
-  fieldId: import_zod22.z.string(),
+  fieldId: z25.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_zod22.z.string().describe("Identifier of the summary field."),
+  id: z25.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_zod22.z.object({
-  fields: import_zod22.z.array(import_zod22.z.union([Field, ReferenceField])).describe("Fields displayed in the event summary view.")
+var SummaryConfig = z25.object({
+  fields: z25.array(z25.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_zod23 = require("zod");
-var MatchType = import_zod23.z.enum(["fuzzy", "exact", "range", "within"]);
-var BaseField3 = import_zod23.z.object({
-  config: import_zod23.z.object({
+var z26 = __toESM(require("zod/v4"));
+var MatchType = z26.enum(["fuzzy", "exact", "range", "within"]);
+var BaseField3 = z26.object({
+  config: z26.object({
     type: MatchType.describe(
       "Determines the search type of field. How to match value."
     ),
-    searchFields: import_zod23.z.array(import_zod23.z.string()).optional().describe(
+    searchFields: z26.array(z26.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.
@@ -2334,7 +2565,7 @@ var BaseField3 = import_zod23.z.object({
       `
     )
   }),
-  type: import_zod23.z.nativeEnum(FieldType).optional().describe(
+  type: z26.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.
@@ -2348,7 +2579,7 @@ var BaseField3 = import_zod23.z.object({
       This is required when searchFields is defined.            
       `
   ),
-  options: import_zod23.z.array(SelectOption).optional(),
+  options: z26.array(SelectOption).optional(),
   searchCriteriaLabelPrefix: TranslationConfig.optional().describe(
     `
     This property determines whether to add a prefix (such as "Child" or "Applicant") before the field label
@@ -2369,7 +2600,7 @@ var BaseField3 = import_zod23.z.object({
     in the country-config > event.advancedSearch configuration. For example: field("child.dob", { searchCriteriaLabelPrefix: TranslationConfig }).
     `
   ),
-  conditionals: import_zod23.z.array(FieldConditional).default([]).optional().describe(
+  conditionals: z26.array(FieldConditional).optional().describe(
     `
        In advanced search, we sometimes need to override the default field visibility conditionals.
 
@@ -2383,20 +2614,20 @@ var BaseField3 = import_zod23.z.object({
        are always rendered in the advanced search form.
       `
   ),
-  validations: import_zod23.z.array(ValidationConfig).default([]).optional().describe(
+  validations: z26.array(ValidationConfig).optional().describe(
     `Option for overriding the field validations specifically for advanced search form.`
   )
 });
-var SearchQueryParams = import_zod23.z.object({
-  eventType: import_zod23.z.string().optional().describe(
+var SearchQueryParams = z26.object({
+  eventType: z26.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_zod23.z.string(),
-  fieldType: import_zod23.z.literal("field")
+  fieldId: z26.string(),
+  fieldType: z26.literal("field")
 });
-var EventFieldIdInput = import_zod23.z.enum([
+var EventFieldIdInput = z26.enum([
   "trackingId",
   "status",
   "legalStatuses.REGISTERED.acceptedAt",
@@ -2405,7 +2636,7 @@ var EventFieldIdInput = import_zod23.z.enum([
   "updatedAt"
 ]);
 var METADATA_FIELD_PREFIX = "event.";
-var EventFieldId = import_zod23.z.enum([
+var EventFieldId = z26.enum([
   `${METADATA_FIELD_PREFIX}trackingId`,
   `${METADATA_FIELD_PREFIX}status`,
   `${METADATA_FIELD_PREFIX}legalStatuses.REGISTERED.acceptedAt`,
@@ -2415,29 +2646,29 @@ var EventFieldId = import_zod23.z.enum([
 ]);
 var EventFieldConfigSchema = BaseField3.extend({
   fieldId: EventFieldId,
-  fieldType: import_zod23.z.literal("event")
+  fieldType: z26.literal("event")
 });
-var AdvancedSearchField = import_zod23.z.discriminatedUnion("fieldType", [FieldConfigSchema, EventFieldConfigSchema]).superRefine((data, ctx) => {
+var AdvancedSearchField = z26.discriminatedUnion("fieldType", [FieldConfigSchema, EventFieldConfigSchema]).superRefine((data, ctx) => {
   if (data.config.searchFields && data.config.searchFields.length > 0) {
     if (!data.label) {
       ctx.addIssue({
-        code: import_zod23.z.ZodIssueCode.custom,
+        code: z26.ZodIssueCode.custom,
         message: "label is required when config.searchFields is defined.",
         path: ["label"]
       });
     }
     if (!data.type) {
       ctx.addIssue({
-        code: import_zod23.z.ZodIssueCode.custom,
+        code: z26.ZodIssueCode.custom,
         message: "type is required when config.searchFields is defined.",
         path: ["type"]
       });
     }
   }
 });
-var AdvancedSearchConfig = import_zod23.z.object({
+var AdvancedSearchConfig = z26.object({
   title: TranslationConfig.describe("Advanced search tab title"),
-  fields: import_zod23.z.array(AdvancedSearchField).describe("Advanced search fields within the tab.")
+  fields: z26.array(AdvancedSearchField).describe("Advanced search fields within the tab.")
 });
 
 // ../commons/src/events/utils.ts
@@ -2446,11 +2677,11 @@ 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_zod25 = require("zod");
+var z28 = __toESM(require("zod/v4"));
 var import_date_fns = require("date-fns");
 
 // ../commons/src/events/DynamicFieldValue.ts
-var import_zod24 = require("zod");
+var z27 = __toESM(require("zod/v4"));
 
 // ../commons/src/conditionals/validate.ts
 var ajv = new import__.default({
@@ -2459,9 +2690,9 @@ var ajv = new import__.default({
   strict: false
   // Allow minContains and other newer features
 });
-var DataContext = import_zod25.z.object({
-  rootData: import_zod25.z.object({
-    $leafAdminStructureLocationIds: import_zod25.z.array(import_zod25.z.object({ id: UUID }))
+var DataContext = z28.object({
+  rootData: z28.object({
+    $leafAdminStructureLocationIds: z28.array(z28.object({ id: UUID }))
   })
 });
 function resolveDataPath(rootData, dataPath, instancePath) {
@@ -2538,12 +2769,12 @@ ajv.addKeyword({
 });
 
 // ../commons/src/utils.ts
-var z26 = __toESM(require("zod"));
-var FullNameV1 = z26.array(
-  z26.object({
-    use: z26.string(),
-    family: z26.string(),
-    given: z26.array(z26.string())
+var z29 = __toESM(require("zod/v4"));
+var FullNameV1 = z29.array(
+  z29.object({
+    use: z29.string(),
+    family: z29.string(),
+    given: z29.array(z29.string())
   })
 );
 function omitKeyDeep(obj, keyToRemove) {
@@ -2564,9 +2795,6 @@ function omitKeyDeep(obj, keyToRemove) {
 
 // ../commons/src/events/utils.ts
 var import_date_fns2 = require("date-fns");
-function isDeclarationActionConfig(action) {
-  return DeclarationActions.safeParse(action.type).success;
-}
 function getDeclarationFields(configuration) {
   return configuration.declaration.pages.flatMap(({ fields }) => fields);
 }
@@ -2577,7 +2805,10 @@ var getActionAnnotationFields = (actionConfig) => {
   if (actionConfig.type === ActionType.PRINT_CERTIFICATE) {
     return actionConfig.printForm.pages.flatMap(({ fields }) => fields);
   }
-  if (isDeclarationActionConfig(actionConfig)) {
+  if (actionConfig.type === ActionType.CUSTOM) {
+    return actionConfig.form;
+  }
+  if ("review" in actionConfig) {
     return actionConfig.review.fields;
   }
   return [];
@@ -2597,38 +2828,8 @@ var EXCLUDED_ACTIONS = [
   ActionType.REJECT_CORRECTION
 ];
 
-// ../commons/src/events/EventConfig.ts
-var import_zod_openapi10 = require("zod-openapi");
-(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod26.z);
-var EventConfig = import_zod26.z.object({
-  id: import_zod26.z.string().describe(
-    'Machine-readable identifier of the event (e.g. "birth", "death").'
-  ),
-  dateOfEvent: FieldReference.optional().describe(
-    "Reference to the field capturing the date of the event (e.g. date of birth). Defaults to the event creation date if unspecified."
-  ),
-  title: TranslationConfig.describe(
-    'Title template for the singular event, supporting variables (e.g. "{applicant.name.firstname} {applicant.name.surname}").'
-  ),
-  fallbackTitle: TranslationConfig.optional().describe(
-    "Fallback title shown when the main title resolves to an empty value."
-  ),
-  summary: SummaryConfig.describe(
-    "Summary information displayed in the event overview."
-  ),
-  label: TranslationConfig.describe(
-    "Human-readable label for the event type."
-  ),
-  actions: import_zod26.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_zod26.z.array(AdvancedSearchConfig).optional().default([]).describe(
-    "Configuration of fields available in the advanced search feature."
-  )
-}).superRefine((event2, ctx) => {
+// ../commons/src/events/eventConfigValidation.ts
+function validateAdvancedSearchConfig(event2, ctx) {
   const allFields = findAllFields(event2);
   const fieldIds = allFields.map((field3) => field3.id);
   const advancedSearchFields = event2.advancedSearch.flatMap(
@@ -2655,10 +2856,12 @@ var EventConfig = import_zod26.z.object({
     ctx.addIssue({
       code: "custom",
       message: `Advanced search id must match a field id of form fields or pre-defined metadata fields.
-    Invalid AdvancedSearch field IDs for event ${event2.id}: ${invalidFields.map((f) => f.fieldId).join(", ")}`,
+  Invalid AdvancedSearch field IDs for event ${event2.id}: ${invalidFields.map((f) => f.fieldId).join(", ")}`,
       path: ["advancedSearch"]
     });
   }
+}
+function validateDateOfEvent(event2, ctx) {
   if (event2.dateOfEvent) {
     const eventDateFieldId = getDeclarationFields(event2).find(
       ({ id }) => id === event2.dateOfEvent?.$$field
@@ -2667,7 +2870,7 @@ var EventConfig = import_zod26.z.object({
       ctx.addIssue({
         code: "custom",
         message: `Date of event field id must match a field id in fields array.
-          Invalid date of event field ID for event ${event2.id}: ${event2.dateOfEvent.$$field}`,
+        Invalid date of event field ID for event ${event2.id}: ${event2.dateOfEvent.$$field}`,
         path: ["dateOfEvent"]
       });
     } else if (eventDateFieldId.type !== FieldType.DATE) {
@@ -2678,8 +2881,105 @@ var EventConfig = import_zod26.z.object({
       });
     }
   }
-}).openapi({
-  ref: "EventConfig"
+}
+function validatePlaceOfEvent(event2, ctx) {
+  if (event2.placeOfEvent) {
+    const eventPlaceFieldId = getDeclarationFields(event2).find(
+      ({ id }) => id === event2.placeOfEvent?.$$field
+    );
+    if (!eventPlaceFieldId) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Place of event field id must match a field id in the event.declaration fields.
+          Invalid place of event field ID for event ${event2.id}: ${event2.placeOfEvent.$$field}`,
+        path: ["placeOfEvent"]
+      });
+    }
+  }
+}
+function validateActionFlags(event2, ctx) {
+  const isInherentFlag = (value) => Object.values(InherentFlags).includes(value);
+  const configuredFlagIds = event2.flags.map((flag) => flag.id);
+  const actionFlagIds = event2.actions.flatMap(
+    (action) => action.flags.map((flag) => flag.id)
+  );
+  for (const actionFlagId of actionFlagIds) {
+    const isConfigured = configuredFlagIds.includes(actionFlagId);
+    const isInherent = isInherentFlag(actionFlagId);
+    if (!isConfigured && !isInherent) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Action flag id must match an inherent flag or a configured flag in the flags array. Invalid action flag ID for event '${event2.id}': '${actionFlagId}'`,
+        path: ["actions"]
+      });
+    }
+  }
+}
+function validateActionOrder(event2, ctx) {
+  if (event2.actionOrder) {
+    const customActionTypes = event2.actions.filter((action) => action.type === ActionType.CUSTOM).map((action) => action.customActionType);
+    const validActionTypes = [
+      ...workqueueActions.options,
+      ...customActionTypes
+    ];
+    for (const actionType of event2.actionOrder) {
+      if (!validActionTypes.includes(actionType)) {
+        ctx.addIssue({
+          code: "custom",
+          message: `Invalid action type in action order: ${actionType}`,
+          path: ["actionOrder"]
+        });
+      }
+    }
+  }
+}
+
+// ../commons/src/events/EventConfig.ts
+var EventConfig = z30.object({
+  id: z30.string().describe(
+    'Machine-readable identifier of the event (e.g. "birth", "death").'
+  ),
+  dateOfEvent: FieldReference.optional().describe(
+    "Reference to the field capturing the date of the event (e.g. date of birth). Defaults to the event creation date if unspecified."
+  ),
+  placeOfEvent: FieldReference.optional().describe(
+    "Reference to the field capturing the place of the event (e.g. place of birth). Defaults to the meta.createdAtLocation if unspecified."
+  ),
+  title: TranslationConfig.describe(
+    'Title template for the singular event, supporting variables (e.g. "{applicant.name.firstname} {applicant.name.surname}").'
+  ),
+  fallbackTitle: TranslationConfig.optional().describe(
+    "Fallback title shown when the main title resolves to an empty value."
+  ),
+  summary: SummaryConfig.describe(
+    "Summary information displayed in the event overview."
+  ),
+  label: TranslationConfig.describe(
+    "Human-readable label for the event type."
+  ),
+  actions: z30.array(ActionConfig).describe(
+    "Configuration of system-defined actions associated with the event."
+  ),
+  actionOrder: z30.array(z30.string()).optional().describe(
+    "Order of actions in the action menu. Use either the action type for core actions or the customActionType for custom actions."
+  ),
+  declaration: DeclarationFormConfig.describe(
+    "Configuration of the form used to gather event data."
+  ),
+  advancedSearch: z30.array(AdvancedSearchConfig).optional().default([]).describe(
+    "Configuration of fields available in the advanced search feature."
+  ),
+  flags: z30.array(FlagConfig).optional().default([]).describe(
+    "Configuration of flags associated with the actions of this event type."
+  )
+}).superRefine((event2, ctx) => {
+  validateAdvancedSearchConfig(event2, ctx);
+  validateDateOfEvent(event2, ctx);
+  validatePlaceOfEvent(event2, ctx);
+  validateActionFlags(event2, ctx);
+  validateActionOrder(event2, ctx);
+}).meta({
+  id: "EventConfig"
 }).describe("Configuration defining an event type.");
 
 // ../commons/src/events/EventConfigInput.ts
@@ -2688,7 +2988,7 @@ var defineActionForm = (actionForm) => ActionFormConfig.parse(actionForm);
 var defineFormPage = (formPage) => FormPageConfig.parse(formPage);
 
 // ../commons/src/events/WorkqueueConfig.ts
-var import_zod30 = require("zod");
+var z33 = __toESM(require("zod/v4"));
 
 // ../commons/src/conditionals/conditionals.ts
 var objectHash = __toESM(require("object-hash"));
@@ -2726,7 +3026,7 @@ function not(condition) {
     required: []
   });
 }
-function never() {
+function never2() {
   return not(alwaysTrue());
 }
 function jsonFieldPath(field3) {
@@ -2757,6 +3057,7 @@ function wrapToPathOptional(condition, path) {
     };
   }, condition);
 }
+var now = Object.assign(todayDateTimeValueSerializer, {});
 var user = Object.assign(userSerializer, {
   hasScope: (scope) => defineConditional({
     type: "object",
@@ -3391,221 +3692,112 @@ var event = Object.assign(eventFn, {
         required: ["$event"]
       });
     };
-    const withMinMax = (additionalFields) => {
-      return {
-        /**
-         * Creates a conditional that checks if the event contains a specific action type
-         * with a minimum count of occurrences.
-         *
-         * @param minCount - The minimum number of actions required.
-         */
-        minCount: (minCount) => createCountConditional("minContains", minCount, additionalFields),
-        /**
-         * Builds a conditional that sets a maximum count for the number of actions.
-         * This is useful for limiting the number of actions of a specific type in a single event.
-         */
-        maxCount: (maxCount) => createCountConditional("maxContains", maxCount, additionalFields)
-      };
-    };
-    const chainableMethods = {
-      /**
-       * Adds additional field constraints to the action matching.
-       *
-       * @param fields - Object containing additional fields to match on the action.
-       */
-      withFields: (fields) => withMinMax(fields),
-      /**
-       * Adds template ID constraint to the action matching.
-       * This is a convenience method that adds content.templateId to the fields.
-       *
-       * @param id - The template ID to match against.
-       */
-      withTemplate: (id) => withMinMax({
-        content: { templateId: id }
-      }),
-      ...withMinMax()
-    };
-    return { ...basicConditional, ...chainableMethods };
-  },
-  field(field3) {
-    return {
-      $event: field3
-    };
-  }
-});
-
-// ../commons/src/events/WorkqueueColumnConfig.ts
-var import_zod27 = require("zod");
-var WorkqueueColumnKeysArray = [
-  ...EventMetadataKeysArray,
-  "title",
-  "outbox"
-];
-var WorkqueueColumnKeys = import_zod27.z.enum(WorkqueueColumnKeysArray);
-var WorkqueueColumnValue = import_zod27.z.object({
-  $event: WorkqueueColumnKeys
-});
-var WorkqueueColumn = import_zod27.z.object({
-  label: TranslationConfig,
-  value: WorkqueueColumnValue
-});
-function defineWorkqueuesColumns(workqueueColumns) {
-  return workqueueColumns.map(
-    (workqueueColumn) => WorkqueueColumn.parse(workqueueColumn)
-  );
-}
-
-// ../commons/src/events/CountryConfigQueryInput.ts
-var import_zod28 = require("zod");
-var SerializableExact = import_zod28.z.object({
-  type: import_zod28.z.literal("exact"),
-  term: import_zod28.z.union([import_zod28.z.string(), SerializedUserField])
-});
-var SerializableWithin = import_zod28.z.object({
-  type: import_zod28.z.literal("within"),
-  location: import_zod28.z.union([import_zod28.z.string(), SerializedUserField])
-});
-var SerializedQueryExpression = import_zod28.z.object({
-  eventType: import_zod28.z.string(),
-  status: import_zod28.z.optional(import_zod28.z.union([AnyOfStatus, ExactStatus])),
-  createdAt: import_zod28.z.optional(DateCondition),
-  updatedAt: import_zod28.z.optional(DateCondition),
-  "legalStatuses.REGISTERED.createdAt": import_zod28.z.optional(DateCondition),
-  "legalStatuses.REGISTERED.createdAtLocation": import_zod28.z.optional(
-    import_zod28.z.union([Within, Exact])
-  ),
-  "legalStatuses.REGISTERED.registrationNumber": import_zod28.z.optional(Exact),
-  createdAtLocation: import_zod28.z.optional(
-    import_zod28.z.union([SerializableWithin, SerializableExact])
-  ),
-  updatedAtLocation: import_zod28.z.optional(
-    import_zod28.z.union([SerializableWithin, SerializableExact])
-  ),
-  assignedTo: import_zod28.z.optional(SerializableExact),
-  createdBy: import_zod28.z.optional(SerializableExact),
-  createdByUserType: ExactUserType,
-  updatedBy: import_zod28.z.optional(SerializableExact),
-  trackingId: import_zod28.z.optional(Exact),
-  flags: import_zod28.z.optional(ContainsFlags),
-  data: QueryInput
-}).partial();
-var Or2 = import_zod28.z.object({
-  type: import_zod28.z.literal("or"),
-  clauses: import_zod28.z.array(SerializedQueryExpression)
-});
-var And2 = import_zod28.z.object({
-  type: import_zod28.z.literal("and"),
-  clauses: import_zod28.z.array(SerializedQueryExpression)
-});
-var CountryConfigQueryType = import_zod28.z.discriminatedUnion("type", [And2, Or2]);
-var CountryConfigQueryInputType = import_zod28.z.union([
-  SerializedQueryExpression,
-  And2,
-  Or2
-]);
-
-// ../commons/src/icons.ts
-var import_zod29 = require("zod");
-var AvailableIcons = import_zod29.z.enum([
-  "Archived",
-  "Assigned",
-  "Certified",
-  "Close",
-  "Collapse",
-  "Draft",
-  "DuplicateYellow",
-  "Expand",
-  "ExternalValidate",
-  "FilledCheck",
-  "InReview",
-  "Offline",
-  "Registered",
-  "RequiresUpdates",
-  "Sent",
-  "Validated",
-  "WaitingApproval",
-  "ChartActivity",
-  "Activity",
-  "Archive",
-  "ArchiveTray",
-  "ArrowLeft",
-  "ArrowRight",
-  "Buildings",
-  "Circle",
-  "CaretDown",
-  "CaretLeft",
-  "CaretRight",
-  "ChartBar",
-  "ChartLine",
-  "ChatCircle",
-  "CheckSquare",
-  "Compass",
-  "Check",
-  "Copy",
-  "Database",
-  "DotsThreeVertical",
-  "ArrowCounterClockwise",
-  "MagnifyingGlassMinus",
-  "MagnifyingGlassPlus",
-  "Export",
-  "Eye",
-  "EyeSlash",
-  "Envelope",
-  "File",
-  "FileSearch",
-  "FileMinus",
-  "FilePlus",
-  "FileText",
-  "FileX",
-  "Handshake",
-  "Gear",
-  "GitBranch",
-  "IdentificationCard",
-  "List",
-  "ListBullets",
-  "Lock",
-  "MagnifyingGlass",
-  "MapPin",
-  "Medal",
-  "NotePencil",
-  "Paperclip",
-  "PaperPlaneTilt",
-  "Pen",
-  "Pencil",
-  "PencilSimpleLine",
-  "Phone",
-  "Plus",
-  "Printer",
-  "SignOut",
-  "Star",
-  "Target",
-  "TextT",
-  "Trash",
-  "UploadSimple",
-  "User",
-  "UserPlus",
-  "Users",
-  "WarningCircle",
-  "X",
-  "CircleWavyCheck",
-  "CircleWavyQuestion",
-  "ArchiveBox",
-  "ArrowCircleDown",
-  "FileArrowUp",
-  "FileDotted",
-  "Files",
-  "PencilLine",
-  "PencilCircle",
-  "UserCircle",
-  "Clock",
-  "QrCode",
-  "Webcam",
-  "Sun",
-  "DeviceTabletCamera",
-  "Globe",
-  "Fingerprint",
-  "PushPin",
-  "Timer"
+    const withMinMax = (additionalFields) => {
+      return {
+        /**
+         * Creates a conditional that checks if the event contains a specific action type
+         * with a minimum count of occurrences.
+         *
+         * @param minCount - The minimum number of actions required.
+         */
+        minCount: (minCount) => createCountConditional("minContains", minCount, additionalFields),
+        /**
+         * Builds a conditional that sets a maximum count for the number of actions.
+         * This is useful for limiting the number of actions of a specific type in a single event.
+         */
+        maxCount: (maxCount) => createCountConditional("maxContains", maxCount, additionalFields)
+      };
+    };
+    const chainableMethods = {
+      /**
+       * Adds additional field constraints to the action matching.
+       *
+       * @param fields - Object containing additional fields to match on the action.
+       */
+      withFields: (fields) => withMinMax(fields),
+      /**
+       * Adds template ID constraint to the action matching.
+       * This is a convenience method that adds content.templateId to the fields.
+       *
+       * @param id - The template ID to match against.
+       */
+      withTemplate: (id) => withMinMax({
+        content: { templateId: id }
+      }),
+      ...withMinMax()
+    };
+    return { ...basicConditional, ...chainableMethods };
+  },
+  field(field3) {
+    return {
+      $event: field3
+    };
+  }
+});
+
+// ../commons/src/events/WorkqueueColumnConfig.ts
+var z31 = __toESM(require("zod/v4"));
+var WorkqueueColumnKeysArray = [
+  ...EventMetadataKeysArray,
+  "title",
+  "outbox"
+];
+var WorkqueueColumnKeys = z31.enum(WorkqueueColumnKeysArray);
+var WorkqueueColumnValue = z31.object({
+  $event: WorkqueueColumnKeys
+});
+var WorkqueueColumn = z31.object({
+  label: TranslationConfig,
+  value: WorkqueueColumnValue
+});
+function defineWorkqueuesColumns(workqueueColumns) {
+  return workqueueColumns.map(
+    (workqueueColumn) => WorkqueueColumn.parse(workqueueColumn)
+  );
+}
+
+// ../commons/src/events/CountryConfigQueryInput.ts
+var z32 = __toESM(require("zod/v4"));
+var SerializableExact = z32.object({
+  type: z32.literal("exact"),
+  term: z32.union([z32.string(), SerializedUserField])
+});
+var SerializableWithin = z32.object({
+  type: z32.literal("within"),
+  location: z32.union([z32.string(), SerializedUserField])
+});
+var SerializedQueryExpression = z32.object({
+  eventType: z32.string(),
+  status: z32.optional(z32.union([AnyOfStatus, ExactStatus])),
+  createdAt: z32.optional(DateCondition),
+  updatedAt: z32.optional(DateCondition),
+  "legalStatuses.REGISTERED.createdAt": z32.optional(DateCondition),
+  "legalStatuses.DECLARED.createdAtLocation": z32.optional(SerializableWithin),
+  "legalStatuses.REGISTERED.createdAtLocation": z32.optional(SerializableWithin),
+  "legalStatuses.REGISTERED.registrationNumber": z32.optional(Exact),
+  createdAtLocation: z32.optional(SerializableWithin),
+  updatedAtLocation: z32.optional(SerializableWithin),
+  assignedTo: z32.optional(SerializableExact),
+  createdBy: z32.optional(SerializableExact),
+  createdByUserType: ExactUserType,
+  updatedBy: z32.optional(SerializableExact),
+  trackingId: z32.optional(Exact),
+  flags: z32.optional(ContainsFlags),
+  data: QueryInput
+}).partial();
+var Or2 = z32.object({
+  type: z32.literal("or"),
+  clauses: z32.array(SerializedQueryExpression)
+});
+var And2 = z32.object({
+  type: z32.literal("and"),
+  clauses: z32.array(SerializedQueryExpression)
+});
+var CountryConfigQueryType = z32.discriminatedUnion("type", [And2, Or2]);
+var CountryConfigQueryInputType = z32.union([
+  SerializedQueryExpression,
+  And2,
+  Or2
 ]);
 
 // ../commons/src/events/WorkqueueConfig.ts
@@ -3627,23 +3819,17 @@ var mandatoryColumns = defineWorkqueuesColumns([
     value: event.field("updatedAt")
   }
 ]);
-var WorkqueueActionsWithDefault = import_zod30.z.enum([
-  ...workqueueActions.options,
-  "DEFAULT"
-]);
-var WorkqueueConfig = import_zod30.z.object({
-  slug: import_zod30.z.string().describe("Determines the url of the workqueue."),
+var CtaActionType = z33.enum([...workqueueActions.options, ActionType.READ]);
+var WorkqueueConfig = z33.object({
+  slug: z33.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_zod30.z.array(
-    import_zod30.z.object({
-      type: WorkqueueActionsWithDefault,
-      conditionals: import_zod30.z.array(Conditional).optional()
-    })
-  ),
-  columns: import_zod30.z.array(WorkqueueColumn).default(mandatoryColumns),
+  /** This action object used to contain a conditionals option, but it was not used anywhere.
+   *  It's also debatable whether it should be an array, or just a single action. */
+  actions: z33.array(z33.object({ type: CtaActionType })).describe("Workqueue call-to-action button configuration."),
+  columns: z33.array(WorkqueueColumn).default(mandatoryColumns),
   icon: AvailableIcons,
   emptyMessage: TranslationConfig.optional()
 }).describe("Configuration for workqueue.");
@@ -3651,26 +3837,21 @@ var WorkqueueConfigWithoutQuery = WorkqueueConfig.omit({
   query: true,
   columns: true
 });
-var WorkqueueConfigInput = import_zod30.z.object({
-  slug: import_zod30.z.string().describe("Determines the url of the workqueue."),
+var WorkqueueConfigInput = z33.object({
+  slug: z33.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_zod30.z.array(
-    import_zod30.z.object({
-      type: WorkqueueActionsWithDefault,
-      conditionals: import_zod30.z.array(Conditional).optional()
-    })
-  ),
-  columns: import_zod30.z.array(WorkqueueColumn).default(mandatoryColumns),
+  actions: z33.array(z33.object({ type: CtaActionType })).describe("Workqueue call-to-action button configuration."),
+  columns: z33.array(WorkqueueColumn).default(mandatoryColumns),
   icon: AvailableIcons,
   emptyMessage: TranslationConfig.optional()
 });
-var WorkqueueCountInput = import_zod30.z.array(
-  import_zod30.z.object({ slug: import_zod30.z.string(), query: QueryType })
+var WorkqueueCountInput = z33.array(
+  z33.object({ slug: z33.string(), query: QueryType })
 );
-var WorkqueueCountOutput = import_zod30.z.record(import_zod30.z.string(), import_zod30.z.number());
+var WorkqueueCountOutput = z33.record(z33.string(), z33.number());
 
 // ../commons/src/events/workqueueDefaultColumns.ts
 var defaultWorkqueueColumns = [
@@ -3693,47 +3874,48 @@ var defaultWorkqueueColumns = [
 ];
 
 // ../commons/src/events/Draft.ts
-var import_zod32 = require("zod");
+var z35 = __toESM(require("zod/v4"));
 
 // ../commons/src/events/ActionInput.ts
-var import_zod31 = require("zod");
-var import_zod_openapi11 = require("zod-openapi");
-(0, import_zod_openapi11.extendZodWithOpenApi)(import_zod31.z);
-var BaseActionInput = import_zod31.z.object({
+var z34 = __toESM(require("zod/v4"));
+var BaseActionInput = z34.object({
   eventId: UUID,
-  transactionId: import_zod31.z.string(),
+  transactionId: z34.string(),
   declaration: ActionUpdate.default({}),
   annotation: ActionUpdate.optional(),
   originalActionId: UUID.optional(),
   // should not be part of base action.
-  keepAssignment: import_zod31.z.boolean().optional(),
+  keepAssignment: z34.boolean().optional(),
   // For normal users, the createdAtLocation is resolved on the backend from the user's primaryOfficeId.
-  createdAtLocation: CreatedAtLocation.describe(
+  // @TODO: createdAtLocation should be limited to actions that system users can perform. For normal users, it should not be part of the base action.
+  createdAtLocation: UUID.nullish().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_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.CREATE).default(ActionType.CREATE),
-    createdAtLocation: CreatedAtLocation
-  })
+var CreateActionInput = BaseActionInput.extend(
+  z34.object({
+    type: z34.literal(ActionType.CREATE).default(ActionType.CREATE),
+    // For normal users, the createdAtLocation is resolved on the backend from the user's primaryOfficeId.
+    createdAtLocation: UUID.nullish().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."
+    )
+  }).shape
 );
-var RegisterActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
-    registrationNumber: import_zod31.z.string().optional()
-  })
-).strict();
-var ValidateActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE)
-  })
+var RegisterActionInput = BaseActionInput.extend(
+  z34.strictObject({
+    type: z34.literal(ActionType.REGISTER).default(ActionType.REGISTER),
+    registrationNumber: z34.string().optional()
+  }).shape
 );
-var NotifyActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
-  })
-).openapi({
+var NotifyActionInput = BaseActionInput.extend(
+  z34.object({
+    type: z34.literal(ActionType.NOTIFY).default(ActionType.NOTIFY),
+    // For normal users, the createdAtLocation is resolved on the backend from the user's primaryOfficeId.
+    createdAtLocation: UUID.nullish().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."
+    )
+  }).shape
+).meta({
   default: {
     eventId: "<event-id-here>",
     transactionId: getUUID(),
@@ -3742,135 +3924,150 @@ var NotifyActionInput = BaseActionInput.merge(
     type: ActionType.NOTIFY
   }
 });
-var DeclareActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
-  })
+var DeclareActionInput = BaseActionInput.extend(
+  z34.object({
+    type: z34.literal(ActionType.DECLARE).default(ActionType.DECLARE)
+  }).shape
+);
+var EditActionInput = BaseActionInput.extend(
+  z34.object({
+    type: z34.literal(ActionType.EDIT).default(ActionType.EDIT),
+    content: z34.object({
+      comment: z34.string().describe("Comment for the edit action.").optional()
+    })
+  }).shape
 );
-var PrintCertificateActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE),
+var PrintCertificateActionInput = BaseActionInput.extend(
+  z34.object({
+    type: z34.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE),
     content: PrintContent.optional()
-  })
+  }).shape
 );
-var RejectDeclarationActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.REJECT).default(ActionType.REJECT),
+var RejectDeclarationActionInput = BaseActionInput.extend(
+  z34.object({
+    type: z34.literal(ActionType.REJECT).default(ActionType.REJECT),
     content: ReasonContent
-  })
+  }).shape
 );
-var DuplicateDetectedActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.DUPLICATE_DETECTED).default(ActionType.DUPLICATE_DETECTED),
-    content: import_zod31.z.object({
-      duplicates: import_zod31.z.array(PotentialDuplicate)
+var DuplicateDetectedActionInput = BaseActionInput.extend(
+  z34.object({
+    type: z34.literal(ActionType.DUPLICATE_DETECTED).default(ActionType.DUPLICATE_DETECTED),
+    content: z34.object({
+      duplicates: z34.array(PotentialDuplicate)
     })
-  })
+  }).shape
 );
-var MarkAsDuplicateActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.MARK_AS_DUPLICATE).default(ActionType.MARK_AS_DUPLICATE),
-    content: import_zod31.z.object({
+var MarkAsDuplicateActionInput = BaseActionInput.extend(
+  z34.object({
+    type: z34.literal(ActionType.MARK_AS_DUPLICATE).default(ActionType.MARK_AS_DUPLICATE),
+    content: z34.object({
       duplicateOf: UUID
     }).optional()
-  })
+  }).shape
 );
-var MarkNotDuplicateActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.MARK_AS_NOT_DUPLICATE).default(ActionType.MARK_AS_NOT_DUPLICATE)
-  })
+var MarkNotDuplicateActionInput = BaseActionInput.extend(
+  z34.object({
+    type: z34.literal(ActionType.MARK_AS_NOT_DUPLICATE).default(ActionType.MARK_AS_NOT_DUPLICATE)
+  }).shape
 );
-var ArchiveActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE),
+var ArchiveActionInput = BaseActionInput.extend(
+  z34.object({
+    type: z34.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE),
     content: ReasonContent
-  })
+  }).shape
 );
-var AssignActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod31.z.string()
-  })
+var AssignActionInput = BaseActionInput.extend(
+  z34.object({
+    type: z34.literal(ActionType.ASSIGN),
+    assignedTo: z34.string()
+  }).shape
 );
-var UnassignActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
-    assignedTo: import_zod31.z.literal(null).default(null)
-  })
+var UnassignActionInput = BaseActionInput.extend(
+  z34.object({
+    type: z34.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
+    assignedTo: z34.literal(null).default(null)
+  }).shape
 );
-var RequestCorrectionActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
-  })
+var RequestCorrectionActionInput = BaseActionInput.extend(
+  z34.object({
+    type: z34.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
+  }).shape
 );
-var RejectCorrectionActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    requestId: import_zod31.z.string(),
-    type: import_zod31.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION),
+var RejectCorrectionActionInput = BaseActionInput.extend(
+  z34.object({
+    requestId: z34.string(),
+    type: z34.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION),
     content: ReasonContent
-  })
+  }).shape
 );
-var ApproveCorrectionActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    requestId: import_zod31.z.string(),
-    type: import_zod31.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
-  })
+var ApproveCorrectionActionInput = BaseActionInput.extend(
+  z34.object({
+    requestId: z34.string(),
+    type: z34.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
+  }).shape
 );
-var ReadActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.READ).default(ActionType.READ)
-  })
+var ReadActionInput = BaseActionInput.extend(
+  z34.object({
+    type: z34.literal(ActionType.READ).default(ActionType.READ)
+  }).shape
+);
+var DeleteActionInput = z34.object({ eventId: UUID });
+var CustomActionInput = BaseActionInput.extend(
+  z34.object({
+    type: z34.literal(ActionType.CUSTOM).default(ActionType.CUSTOM),
+    customActionType: z34.string().describe("Name of the custom action.")
+  }).shape
 );
-var DeleteActionInput = import_zod31.z.object({ eventId: UUID });
-var ActionInput = import_zod31.z.discriminatedUnion("type", [
-  CreateActionInput.openapi({ ref: "CreateActionInput" }),
-  ValidateActionInput.openapi({ ref: "ValidateActionInput" }),
-  RegisterActionInput.openapi({ ref: "RegisterActionInput" }),
-  NotifyActionInput.openapi({ ref: "NotifyActionInput" }),
-  DeclareActionInput.openapi({ ref: "DeclareActionInput" }),
-  RejectDeclarationActionInput.openapi({
-    ref: "RejectDeclarationActionInput"
+var ActionInput = z34.discriminatedUnion("type", [
+  CreateActionInput.meta({ id: "CreateActionInput" }),
+  RegisterActionInput.meta({ id: "RegisterActionInput" }),
+  NotifyActionInput.meta({ id: "NotifyActionInput" }),
+  DeclareActionInput.meta({ id: "DeclareActionInput" }),
+  RejectDeclarationActionInput.meta({
+    id: "RejectDeclarationActionInput"
   }),
-  DuplicateDetectedActionInput.openapi({
-    ref: "DuplicateDetectedActionInput"
+  DuplicateDetectedActionInput.meta({
+    id: "DuplicateDetectedActionInput"
   }),
-  MarkAsDuplicateActionInput.openapi({
-    ref: "MarkAsDuplicateActionInput"
+  MarkAsDuplicateActionInput.meta({
+    id: "MarkAsDuplicateActionInput"
   }),
-  MarkNotDuplicateActionInput.openapi({
-    ref: "MarkNotDuplicateActionInput"
+  MarkNotDuplicateActionInput.meta({
+    id: "MarkNotDuplicateActionInput"
   }),
-  ArchiveActionInput.openapi({ ref: "ArchiveActionInput" }),
-  AssignActionInput.openapi({ ref: "AssignActionInput" }),
-  UnassignActionInput.openapi({ ref: "UnassignActionInput" }),
-  PrintCertificateActionInput.openapi({ ref: "PrintCertificateActionInput" }),
-  RequestCorrectionActionInput.openapi({
-    ref: "RequestCorrectionActionInput"
+  ArchiveActionInput.meta({ id: "ArchiveActionInput" }),
+  AssignActionInput.meta({ id: "AssignActionInput" }),
+  UnassignActionInput.meta({ id: "UnassignActionInput" }),
+  PrintCertificateActionInput.meta({ id: "PrintCertificateActionInput" }),
+  RequestCorrectionActionInput.meta({
+    id: "RequestCorrectionActionInput"
   }),
-  RejectCorrectionActionInput.openapi({ ref: "RejectCorrectionActionInput" }),
-  ApproveCorrectionActionInput.openapi({
-    ref: "ApproveCorrectionActionInput"
+  RejectCorrectionActionInput.meta({ id: "RejectCorrectionActionInput" }),
+  ApproveCorrectionActionInput.meta({
+    id: "ApproveCorrectionActionInput"
   }),
-  ReadActionInput.openapi({ ref: "ReadActionInput" })
-]).openapi({
-  ref: "ActionInput"
+  ReadActionInput.meta({ id: "ReadActionInput" }),
+  CustomActionInput.meta({ id: "CustomActionInput" }),
+  EditActionInput.meta({ id: "EditActionInput" })
+]).meta({
+  id: "ActionInput"
 });
 
 // ../commons/src/events/Draft.ts
-var Draft = import_zod32.z.object({
+var Draft = z35.object({
   id: UUID,
   eventId: UUID,
-  transactionId: import_zod32.z.string(),
-  createdAt: import_zod32.z.string().datetime(),
+  transactionId: z35.string(),
+  createdAt: z35.string().datetime(),
   action: ActionBase.extend({
-    type: ActionTypes.exclude([ActionTypes.Enum.DELETE])
+    type: ActionTypes.exclude([ActionTypes.enum.DELETE])
   }).omit({ id: true, createdAtLocation: true })
 }).describe(
   "A temporary storage for an action. Stored with details of the event, creator and creation time."
 );
 var DraftInput = BaseActionInput.extend({
-  type: ActionTypes.exclude([ActionTypes.Enum.DELETE]),
-  status: import_zod32.z.enum([
+  type: ActionTypes.exclude([ActionTypes.enum.DELETE]),
+  status: z35.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
@@ -3878,32 +4075,33 @@ var DraftInput = BaseActionInput.extend({
 });
 
 // ../commons/src/events/EventInput.ts
-var import_zod33 = require("zod");
-var import_uuid10 = require("uuid");
-var EventInput = import_zod33.z.object({
-  transactionId: import_zod33.z.string(),
-  type: import_zod33.z.string()
-}).openapi({ default: { transactionId: (0, import_uuid10.v4)(), type: "birth" } });
+var z36 = __toESM(require("zod/v4"));
+var import_uuid9 = require("uuid");
+var EventInput = z36.object({
+  transactionId: z36.string(),
+  type: z36.string(),
+  createdAtLocation: UUID.nullish().describe(
+    "Location where the event occurred. Required for system users."
+  )
+}).meta({ default: { transactionId: (0, import_uuid9.v4)(), type: "birth" } });
 
 // ../commons/src/events/EventDocument.ts
-var import_zod34 = require("zod");
-var import_zod_openapi12 = require("zod-openapi");
-(0, import_zod_openapi12.extendZodWithOpenApi)(import_zod34.z);
-var EventDocument = import_zod34.z.object({
+var z37 = __toESM(require("zod/v4"));
+var EventDocument = z37.object({
   id: UUID.describe("Unique identifier of the event."),
-  type: import_zod34.z.string().describe("Type of the event (e.g. birth, death, marriage)."),
-  createdAt: import_zod34.z.string().datetime().describe("Timestamp indicating when the event was created."),
-  updatedAt: import_zod34.z.string().datetime().describe(
+  type: z37.string().describe("Type of the event (e.g. birth, death, marriage)."),
+  createdAt: z37.string().datetime().describe("Timestamp indicating when the event was created."),
+  updatedAt: z37.string().datetime().describe(
     "Timestamp of the last update, excluding changes from actions."
   ),
-  actions: import_zod34.z.array(Action).describe("Ordered list of actions associated with the event."),
-  trackingId: import_zod34.z.string().describe(
+  actions: z37.array(Action).describe("Ordered list of actions associated with the event."),
+  trackingId: z37.string().describe(
     "System-generated tracking identifier used to look up the event."
   )
-}).openapi({ ref: "EventDocument" });
+}).meta({ id: "EventDocument" });
 
 // ../commons/src/events/state/index.ts
-var import_lodash3 = require("lodash");
+var import_lodash4 = require("lodash");
 
 // ../commons/src/events/state/utils.ts
 var import_lodash2 = require("lodash");
@@ -3911,14 +4109,18 @@ var updateActions = ActionTypes.extract([
   ActionType.CREATE,
   ActionType.NOTIFY,
   ActionType.DECLARE,
-  ActionType.VALIDATE,
   ActionType.REGISTER,
   ActionType.REJECT,
   ActionType.ARCHIVE,
   ActionType.PRINT_CERTIFICATE,
-  ActionType.REQUEST_CORRECTION
+  ActionType.REQUEST_CORRECTION,
+  ActionType.CUSTOM
 ]);
 
+// ../commons/src/events/state/flags.ts
+var import_lodash3 = require("lodash");
+var import_date_fns3 = require("date-fns");
+
 // ../commons/src/events/defineConfig.ts
 var defineConfig = (config) => {
   const input = EventConfig.parse(config);
@@ -3926,7 +4128,7 @@ var defineConfig = (config) => {
 };
 
 // ../commons/src/events/test.utils.ts
-var import_lodash4 = require("lodash");
+var import_lodash5 = require("lodash");
 var import_date_fns4 = require("date-fns");
 
 // ../commons/src/field-config/field-configuration.ts
@@ -3948,7 +4150,6 @@ function field(fieldId, options = {}) {
 }
 
 // ../commons/src/fixtures/forms.ts
-var import_date_fns3 = require("date-fns");
 var PRINT_CERTIFICATE_FORM = defineActionForm({
   label: {
     id: "event.tennis-club-membership.action.certificate.form.label",
@@ -4748,7 +4949,7 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
           conditionals: [
             {
               type: ConditionalType.DISPLAY_ON_REVIEW,
-              conditional: never()
+              conditional: never2()
             }
           ]
         },
@@ -5131,119 +5332,16 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
           }
         }
       ],
-      conditional: not(never())
+      conditional: not(never2())
       // Intentional always-true page conditional to exercise interactions between page-level and field-level conditionals in tests
     }
   ]
 });
-var statusOptions = [
-  {
-    value: "ALL",
-    label: {
-      defaultMessage: "Any status",
-      description: "Option for form field: status of record",
-      id: "advancedSearch.form.recordStatusAny"
-    }
-  },
-  {
-    value: EventStatus.enum.CREATED,
-    label: {
-      defaultMessage: "Draft",
-      description: "Option for form field: status of record",
-      id: "advancedSearch.form.recordStatusCreated"
-    }
-  },
-  {
-    value: EventStatus.enum.NOTIFIED,
-    label: {
-      defaultMessage: "Notified",
-      description: "Option for form field: status of record",
-      id: "advancedSearch.form.recordStatusNotified"
-    }
-  },
-  {
-    value: EventStatus.enum.DECLARED,
-    label: {
-      defaultMessage: "Declared",
-      description: "Option for form field: status of record",
-      id: "advancedSearch.form.recordStatusDeclared"
-    }
-  },
-  {
-    value: EventStatus.enum.VALIDATED,
-    label: {
-      defaultMessage: "Validated",
-      description: "Option for form field: status of record",
-      id: "advancedSearch.form.recordStatusValidated"
-    }
-  },
-  {
-    value: EventStatus.enum.REGISTERED,
-    label: {
-      defaultMessage: "Registered",
-      description: "Option for form field: status of record",
-      id: "advancedSearch.form.recordStatusRegistered"
-    }
-  },
-  {
-    value: EventStatus.enum.ARCHIVED,
-    label: {
-      defaultMessage: "Archived",
-      description: "Option for form field: status of record",
-      id: "advancedSearch.form.recordStatusArchived"
-    }
-  }
-];
-var timePeriodOptions = [
-  {
-    label: {
-      defaultMessage: "Last 7 days",
-      description: "Label for option of time period select: last 7 days",
-      id: "form.section.label.timePeriodLast7Days"
-    },
-    value: `${(0, import_date_fns3.format)((0, import_date_fns3.subDays)(/* @__PURE__ */ new Date(), 7), "yyyy-MM-dd")},${(0, import_date_fns3.format)(
-      /* @__PURE__ */ new Date(),
-      "yyyy-MM-dd"
-    )}`
-  },
-  {
-    label: {
-      defaultMessage: "Last 30 days",
-      description: "Label for option of time period select: last 30 days",
-      id: "form.section.label.timePeriodLast30Days"
-    },
-    value: `${(0, import_date_fns3.format)((0, import_date_fns3.subMonths)(/* @__PURE__ */ new Date(), 1), "yyyy-MM-dd")},${(0, import_date_fns3.format)(
-      /* @__PURE__ */ new Date(),
-      "yyyy-MM-dd"
-    )}`
-  },
-  {
-    label: {
-      defaultMessage: "Last 90 days",
-      description: "Label for option of time period select: last 90 days",
-      id: "form.section.label.timePeriodLast90Days"
-    },
-    value: `${(0, import_date_fns3.format)((0, import_date_fns3.subQuarters)(/* @__PURE__ */ new Date(), 1), "yyyy-MM-dd")},${(0, import_date_fns3.format)(
-      /* @__PURE__ */ new Date(),
-      "yyyy-MM-dd"
-    )}`
-  },
-  {
-    label: {
-      defaultMessage: "Last year",
-      description: "Label for option of time period select: last year",
-      id: "form.section.label.timePeriodLastYear"
-    },
-    value: `${(0, import_date_fns3.format)((0, import_date_fns3.subYears)(/* @__PURE__ */ new Date(), 1), "yyyy-MM-dd")},${(0, import_date_fns3.format)(
-      /* @__PURE__ */ new Date(),
-      "yyyy-MM-dd"
-    )}`
-  }
-];
 
 // ../commons/src/fixtures/tennis-club-membership-event.ts
 var tennisClubMembershipEvent = defineConfig({
   id: TENNIS_CLUB_MEMBERSHIP,
+  declaration: TENNIS_CLUB_DECLARATION_FORM,
   label: {
     defaultMessage: "Tennis club membership application",
     description: "This is what this event is referred as in the system",
@@ -5294,13 +5392,12 @@ var tennisClubMembershipEvent = defineConfig({
       review: TENNIS_CLUB_DECLARATION_REVIEW
     },
     {
-      type: ActionType.VALIDATE,
+      type: ActionType.REJECT,
       label: {
-        defaultMessage: "Validate",
+        defaultMessage: "Reject",
         description: "This is shown as the action name anywhere the user can trigger the action from",
-        id: "event.tennis-club-membership.action.validate.label"
-      },
-      review: TENNIS_CLUB_DECLARATION_REVIEW
+        id: "event.tennis-club-membership.action.reject.label"
+      }
     },
     {
       type: ActionType.REGISTER,
@@ -5308,8 +5405,7 @@ var tennisClubMembershipEvent = defineConfig({
         defaultMessage: "Register",
         description: "This is shown as the action name anywhere the user can trigger the action from",
         id: "event.tennis-club-membership.action.register.label"
-      },
-      review: TENNIS_CLUB_DECLARATION_REVIEW
+      }
     },
     {
       type: ActionType.REQUEST_CORRECTION,
@@ -5512,14 +5608,6 @@ var tennisClubMembershipEvent = defineConfig({
         ]
       }
     },
-    {
-      type: ActionType.APPROVE_CORRECTION,
-      label: {
-        defaultMessage: "Approve correction",
-        description: "This is shown as the action name anywhere the user can trigger the action from",
-        id: "event.tennis-club-membership.action.correction.approve.label"
-      }
-    },
     {
       type: ActionType.PRINT_CERTIFICATE,
       label: {
@@ -5528,22 +5616,6 @@ var tennisClubMembershipEvent = defineConfig({
         description: "This is shown as the action name anywhere the user can trigger the action from"
       },
       printForm: PRINT_CERTIFICATE_FORM
-    },
-    {
-      type: ActionType.ARCHIVE,
-      label: {
-        id: "event.tennis-club-membership.action.archive.label",
-        defaultMessage: "Archive",
-        description: "This is shown as the action name anywhere the user can trigger the action from"
-      }
-    },
-    {
-      type: ActionType.REJECT,
-      label: {
-        id: "event.tennis-club-membership.action.reject.label",
-        defaultMessage: "Reject",
-        description: "This is shown as the action name anywhere the user can trigger the action from"
-      }
     }
   ],
   advancedSearch: [
@@ -5580,8 +5652,7 @@ var tennisClubMembershipEvent = defineConfig({
       },
       fields: [field("recommender.name").fuzzy()]
     }
-  ],
-  declaration: TENNIS_CLUB_DECLARATION_FORM
+  ]
 });
 
 // ../commons/src/fixtures/football-club-membership-event.ts
@@ -5649,23 +5720,13 @@ var footballClubMembershipEvent = defineConfig({
       },
       review: TENNIS_CLUB_DECLARATION_REVIEW
     },
-    {
-      type: ActionType.VALIDATE,
-      label: {
-        defaultMessage: "Validate",
-        description: "This is shown as the action name anywhere the user can trigger the action from",
-        id: "event.football-club-membership.action.validate.label"
-      },
-      review: TENNIS_CLUB_DECLARATION_REVIEW
-    },
     {
       type: ActionType.REGISTER,
       label: {
         defaultMessage: "Register",
         description: "This is shown as the action name anywhere the user can trigger the action from",
         id: "event.football-club-membership.action.register.label"
-      },
-      review: TENNIS_CLUB_DECLARATION_REVIEW
+      }
     },
     {
       type: ActionType.REQUEST_CORRECTION,
@@ -5871,14 +5932,6 @@ var footballClubMembershipEvent = defineConfig({
         ]
       }
     },
-    {
-      type: ActionType.APPROVE_CORRECTION,
-      label: {
-        defaultMessage: "Approve correction",
-        description: "This is shown as the action name anywhere the user can trigger the action from",
-        id: "event.football-club-membership.action.correction.approve.label"
-      }
-    },
     {
       type: ActionType.PRINT_CERTIFICATE,
       label: {
@@ -5887,22 +5940,6 @@ var footballClubMembershipEvent = defineConfig({
         description: "This is shown as the action name anywhere the user can trigger the action from"
       },
       printForm: PRINT_CERTIFICATE_FORM
-    },
-    {
-      type: ActionType.ARCHIVE,
-      label: {
-        id: "event.football-club-membership.action.archive.label",
-        defaultMessage: "Archive",
-        description: "This is shown as the action name anywhere the user can trigger the action from"
-      }
-    },
-    {
-      type: ActionType.REJECT,
-      label: {
-        id: "event.football-club-membership.action.reject.label",
-        defaultMessage: "Reject",
-        description: "This is shown as the action name anywhere the user can trigger the action from"
-      }
     }
   ],
   advancedSearch: [
@@ -6002,7 +6039,7 @@ var libraryMembershipEvent = defineConfig({
   declaration: libraryMembershipForm
 });
 
-// ../commons/src/fixtures/v2-birth-event.ts
+// ../commons/src/fixtures/child-onboarding-event.ts
 function generateTranslationConfig(message) {
   return {
     defaultMessage: message,
@@ -6031,6 +6068,61 @@ var child = defineFormPage({
       secured: true,
       validation: [],
       label: generateTranslationConfig("Date of birth")
+    },
+    {
+      id: "child.placeOfBirth",
+      analytics: true,
+      type: FieldType.SELECT,
+      required: true,
+      secured: true,
+      label: {
+        defaultMessage: "Place of delivery",
+        description: "This is the label for the field",
+        id: "event.birth.action.declare.form.section.child.field.placeOfBirth.label"
+      },
+      options: [
+        {
+          value: "child.placeOfBirth-SELECT-2",
+          label: generateTranslationConfig("Health Institution")
+        },
+        {
+          value: "PRIVATE_HOME",
+          label: generateTranslationConfig("Residential address")
+        }
+      ]
+    },
+    {
+      id: "child.birthLocation",
+      analytics: true,
+      type: "FACILITY",
+      required: true,
+      secured: true,
+      label: generateTranslationConfig("Health Institution"),
+      conditionals: [
+        {
+          type: "SHOW",
+          conditional: field("child.placeOfBirth").isEqualTo(
+            "child.placeOfBirth-SELECT-2"
+          )
+        }
+      ]
+    },
+    {
+      id: "child.birthLocation.privateHome",
+      analytics: true,
+      type: FieldType.ADDRESS,
+      secured: true,
+      hideLabel: true,
+      label: generateTranslationConfig("Child's address"),
+      conditionals: [
+        {
+          type: "SHOW",
+          conditional: field("child.placeOfBirth").isEqualTo("PRIVATE_HOME")
+        }
+      ],
+      configuration: {
+        streetAddressForm: []
+      }
     }
   ]
 });
@@ -6107,7 +6199,7 @@ var mother = defineFormPage({
     }
   ]
 });
-var BIRTH_DECLARATION_REVIEW = {
+var CHILD_ONBOARDING_DECLARATION_REVIEW = {
   title: generateTranslationConfig(
     "{child.name.firstname, select, __EMPTY__ {Birth declaration} other {{child.name.surname, select, __EMPTY__ {Birth declaration for {child.name.firstname}} other {Birth declaration for {child.name.firstname} {child.name.surname}}}}}"
   ),
@@ -6127,12 +6219,12 @@ var BIRTH_DECLARATION_REVIEW = {
     }
   ]
 };
-var BIRTH_DECLARATION_FORM = defineDeclarationForm({
+var CHILD_ONBOARDING_DECLARATION_FORM = defineDeclarationForm({
   label: generateTranslationConfig("Birth decalration form"),
   pages: [child, mother]
 });
-var v2BirthEvent = defineConfig({
-  id: BIRTH_EVENT,
+var ChildOnboardingEvent = defineConfig({
+  id: CHILD_ONBOARDING_EVENT,
   title: generateTranslationConfig(
     "{child.name.firstname} {child.name.surname}"
   ),
@@ -6140,27 +6232,21 @@ var v2BirthEvent = defineConfig({
   summary: {
     fields: []
   },
-  declaration: BIRTH_DECLARATION_FORM,
+  declaration: CHILD_ONBOARDING_DECLARATION_FORM,
   actions: [
     {
       type: ActionType.READ,
       label: generateTranslationConfig("Read"),
-      review: BIRTH_DECLARATION_REVIEW
+      review: CHILD_ONBOARDING_DECLARATION_REVIEW
     },
     {
       type: ActionType.DECLARE,
       label: generateTranslationConfig("Declare"),
-      review: BIRTH_DECLARATION_REVIEW
-    },
-    {
-      type: ActionType.VALIDATE,
-      label: generateTranslationConfig("Validate"),
-      review: BIRTH_DECLARATION_REVIEW
+      review: CHILD_ONBOARDING_DECLARATION_REVIEW
     },
     {
       type: ActionType.REGISTER,
-      label: generateTranslationConfig("Register"),
-      review: BIRTH_DECLARATION_REVIEW
+      label: generateTranslationConfig("Register")
     }
   ],
   advancedSearch: []
@@ -6248,7 +6334,7 @@ var PRINT_DIGITAL_ID_CERTIFICATE_FORM = defineActionForm({
           conditionals: [
             {
               type: ConditionalType.ENABLE,
-              conditional: never()
+              conditional: never2()
             },
             {
               type: ConditionalType.SHOW,
@@ -6275,7 +6361,7 @@ var PRINT_DIGITAL_ID_CERTIFICATE_FORM = defineActionForm({
           conditionals: [
             {
               type: ConditionalType.ENABLE,
-              conditional: never()
+              conditional: never2()
             },
             {
               type: ConditionalType.SHOW,
@@ -6303,7 +6389,7 @@ var PRINT_DIGITAL_ID_CERTIFICATE_FORM = defineActionForm({
           conditionals: [
             {
               type: ConditionalType.ENABLE,
-              conditional: never()
+              conditional: never2()
             }
           ],
           value: field("identity.http-fetch").get("data.certificateId")
@@ -6381,8 +6467,8 @@ var digitalIdentityEvent = defineConfig({
 });
 
 // ../commons/src/events/test.utils.ts
-var import_zod35 = require("zod");
-var TestUserRole = import_zod35.z.enum([
+var z38 = __toESM(require("zod/v4"));
+var TestUserRole = z38.enum([
   "FIELD_AGENT",
   "LOCAL_REGISTRAR",
   "LOCAL_SYSTEM_ADMIN",
@@ -6393,18 +6479,14 @@ var TestUserRole = import_zod35.z.enum([
 ]);
 
 // ../commons/src/events/scopes.ts
-var import_lodash5 = require("lodash");
+var import_lodash6 = require("lodash");
 var ACTION_SCOPE_MAP = {
   [ActionType.READ]: ["record.read"],
   [ActionType.CREATE]: ["record.create"],
   [ActionType.NOTIFY]: ["record.notify"],
-  [ActionType.DECLARE]: [
-    "record.declare",
-    "record.declared.validate",
-    "record.register"
-  ],
+  [ActionType.DECLARE]: ["record.declare", "record.register"],
+  [ActionType.EDIT]: ["record.declared.edit"],
   [ActionType.DELETE]: ["record.declare"],
-  [ActionType.VALIDATE]: ["record.declared.validate", "record.register"],
   [ActionType.REGISTER]: ["record.register"],
   [ActionType.PRINT_CERTIFICATE]: ["record.registered.print-certified-copies"],
   [ActionType.REQUEST_CORRECTION]: [
@@ -6422,7 +6504,8 @@ var ACTION_SCOPE_MAP = {
   [ActionType.REJECT]: ["record.declared.reject"],
   [ActionType.ASSIGN]: null,
   [ActionType.UNASSIGN]: null,
-  [ActionType.DUPLICATE_DETECTED]: []
+  [ActionType.DUPLICATE_DETECTED]: [],
+  [ActionType.CUSTOM]: []
 };
 
 // ../commons/src/events/state/availableActions.ts
@@ -6431,28 +6514,25 @@ var AVAILABLE_ACTIONS_BY_EVENT_STATUS = {
     ActionType.READ,
     ActionType.DECLARE,
     ActionType.NOTIFY,
-    ActionType.DELETE
+    ActionType.DELETE,
+    ActionType.CUSTOM
   ],
   [EventStatus.enum.NOTIFIED]: [
     ActionType.READ,
-    ActionType.DECLARE,
+    ActionType.EDIT,
     ActionType.MARK_AS_DUPLICATE,
     ActionType.ARCHIVE,
-    ActionType.REJECT
+    ActionType.REJECT,
+    ActionType.CUSTOM
   ],
   [EventStatus.enum.DECLARED]: [
-    ActionType.READ,
-    ActionType.VALIDATE,
-    ActionType.MARK_AS_DUPLICATE,
-    ActionType.ARCHIVE,
-    ActionType.REJECT
-  ],
-  [EventStatus.enum.VALIDATED]: [
     ActionType.READ,
     ActionType.REGISTER,
     ActionType.MARK_AS_DUPLICATE,
     ActionType.ARCHIVE,
-    ActionType.REJECT
+    ActionType.REJECT,
+    ActionType.CUSTOM,
+    ActionType.EDIT
   ],
   [EventStatus.enum.REGISTERED]: [
     ActionType.READ,
@@ -6460,12 +6540,14 @@ var AVAILABLE_ACTIONS_BY_EVENT_STATUS = {
     ActionType.REQUEST_CORRECTION,
     ActionType.APPROVE_CORRECTION,
     ActionType.REJECT_CORRECTION,
+    ActionType.CUSTOM,
     ClientSpecificAction.REVIEW_CORRECTION_REQUEST
   ],
   [EventStatus.enum.ARCHIVED]: [
     ActionType.READ,
     ActionType.ASSIGN,
-    ActionType.UNASSIGN
+    ActionType.UNASSIGN,
+    ActionType.CUSTOM
   ]
 };
 var ACTION_FILTERS = {
@@ -6475,32 +6557,41 @@ var ACTION_FILTERS = {
   [ActionType.APPROVE_CORRECTION]: (flags) => flags.includes(InherentFlags.CORRECTION_REQUESTED) && !flags.some((flag) => flag.endsWith(":requested")),
   [ActionType.REJECT_CORRECTION]: (flags) => flags.includes(InherentFlags.CORRECTION_REQUESTED) && !flags.some((flag) => flag.endsWith(":requested")),
   [ActionType.MARK_AS_DUPLICATE]: (flags) => flags.includes(InherentFlags.POTENTIAL_DUPLICATE) && !flags.some((flag) => flag.endsWith(":requested")),
-  [ActionType.VALIDATE]: (flags) => !flags.includes(InherentFlags.POTENTIAL_DUPLICATE) && !flags.some((flag) => flag.endsWith(":requested")),
+  [ActionType.EDIT]: (flags) => !flags.includes(InherentFlags.POTENTIAL_DUPLICATE) && !flags.some((flag) => flag.endsWith(":requested")),
   [ActionType.REGISTER]: (flags) => !flags.includes(InherentFlags.POTENTIAL_DUPLICATE) && !flags.some((flag) => flag.endsWith(":requested")),
   [ActionType.REJECT]: (flags) => !flags.includes(InherentFlags.REJECTED) && !flags.some((flag) => flag.endsWith(":requested")),
   [ActionType.ARCHIVE]: (flags) => !flags.some((flag) => flag.endsWith(":requested"))
 };
 
 // ../commons/src/events/FileUtils.ts
-var import_lodash6 = require("lodash");
+var import_lodash7 = require("lodash");
 
 // ../commons/src/events/locations.ts
-var import_zod36 = require("zod");
-var LocationType = import_zod36.z.enum([
+var z39 = __toESM(require("zod/v4"));
+var LocationTypeV1 = z39.enum([
   "ADMIN_STRUCTURE",
   "CRVS_OFFICE",
   "HEALTH_FACILITY"
 ]);
-var Location = import_zod36.z.object({
+var LocationType = z39.enum(["CRVS_OFFICE", "HEALTH_FACILITY"]);
+var AdministrativeArea = z39.object({
   id: UUID,
-  name: import_zod36.z.string(),
+  name: z39.string(),
+  externalId: z39.string().nullish(),
   parentId: UUID.nullable(),
-  validUntil: import_zod36.z.string().datetime().nullable(),
-  locationType: LocationType.nullable()
+  validUntil: z39.iso.datetime().nullable()
+});
+var Location = z39.object({
+  id: UUID,
+  name: z39.string(),
+  externalId: z39.string().nullish(),
+  administrativeAreaId: UUID.nullable(),
+  validUntil: z39.iso.datetime().nullable(),
+  locationType: z39.string().nullable()
 });
 
 // ../commons/src/notification/UserNotifications.ts
-var import_zod37 = require("zod");
+var z40 = __toESM(require("zod/v4"));
 var TriggerEvent = {
   USER_CREATED: "user-created",
   USER_UPDATED: "user-updated",
@@ -6512,50 +6603,50 @@ var TriggerEvent = {
   CHANGE_PHONE_NUMBER: "change-phone-number",
   CHANGE_EMAIL_ADDRESS: "change-email-address"
 };
-var Recipient = import_zod37.z.object({
+var Recipient = z40.object({
   name: NameFieldValue.optional(),
-  mobile: import_zod37.z.string().optional(),
-  email: import_zod37.z.string().optional(),
-  bcc: import_zod37.z.array(import_zod37.z.string()).optional()
+  mobile: z40.string().optional(),
+  email: z40.string().optional(),
+  bcc: z40.array(z40.string()).optional()
 });
-var BasePayload = import_zod37.z.object({
+var BasePayload = z40.object({
   recipient: Recipient
 });
 var TriggerPayload = {
   [TriggerEvent.USER_CREATED]: BasePayload.extend({
-    username: import_zod37.z.string(),
-    temporaryPassword: import_zod37.z.string()
+    username: z40.string(),
+    temporaryPassword: z40.string()
   }),
   [TriggerEvent.USER_UPDATED]: BasePayload.extend({
-    oldUsername: import_zod37.z.string(),
-    newUsername: import_zod37.z.string()
+    oldUsername: z40.string(),
+    newUsername: z40.string()
   }),
   [TriggerEvent.USERNAME_REMINDER]: BasePayload.extend({
-    username: import_zod37.z.string()
+    username: z40.string()
   }),
   [TriggerEvent.RESET_PASSWORD]: BasePayload.extend({
-    code: import_zod37.z.string()
+    code: z40.string()
   }),
   [TriggerEvent.RESET_PASSWORD_BY_ADMIN]: BasePayload.extend({
-    temporaryPassword: import_zod37.z.string(),
-    admin: import_zod37.z.object({
-      id: import_zod37.z.string(),
+    temporaryPassword: z40.string(),
+    admin: z40.object({
+      id: z40.string(),
       name: NameFieldValue,
-      role: import_zod37.z.string()
+      role: z40.string()
     })
   }),
   [TriggerEvent.TWO_FA]: BasePayload.extend({
-    code: import_zod37.z.string()
+    code: z40.string()
   }),
   [TriggerEvent.ALL_USER_NOTIFICATION]: BasePayload.extend({
-    subject: import_zod37.z.string(),
-    body: import_zod37.z.string()
+    subject: z40.string(),
+    body: z40.string()
   }),
   [TriggerEvent.CHANGE_PHONE_NUMBER]: BasePayload.extend({
-    code: import_zod37.z.string()
+    code: z40.string()
   }),
   [TriggerEvent.CHANGE_EMAIL_ADDRESS]: BasePayload.extend({
-    code: import_zod37.z.string()
+    code: z40.string()
   })
 };
 async function triggerUserEventNotification({
@@ -6577,3 +6668,6 @@ function parseUserEventTrigger(event2, body) {
   const schema = TriggerPayload[event2];
   return schema.parse(body);
 }
+
+// src/notification/index.ts
+z41.globalRegistry.clear();