@opencrvs/toolkit 1.9.7-rc.4690c0c → 1.9.7-rc.480775d

package/dist/notification/index.js

@@ -38,7 +38,6 @@ __export(notification_exports, {
   triggerUserEventNotification: () => triggerUserEventNotification
 });
 module.exports = __toCommonJS(notification_exports);
-var z41 = __toESM(require("zod/v4"));
 
 // ../commons/src/url.ts
 function joinUrl(base, path) {
@@ -48,28 +47,30 @@ function joinUrl(base, path) {
 
 // ../commons/src/events/Constants.ts
 var TENNIS_CLUB_MEMBERSHIP = "tennis-club-membership";
-var CHILD_ONBOARDING_EVENT = "child-onboarding";
+var BIRTH_EVENT = "birth";
 
 // ../commons/src/events/ActionConfig.ts
-var z22 = __toESM(require("zod/v4"));
+var import_zod20 = require("zod");
 
 // ../commons/src/events/TranslationConfig.ts
-var z = __toESM(require("zod/v4"));
-var TranslationConfig = z.object({
-  id: z.string().describe(
+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(
     "The identifier of the translation referred in translation CSV files"
   ),
-  defaultMessage: z.string().describe("Default translation message"),
-  description: z.string().describe(
+  defaultMessage: import_zod.z.string().describe("Default translation message"),
+  description: import_zod.z.string().describe(
     "Describe the translation for a translator to be able to identify it."
   )
-}).meta({
+}).openapi({
   description: "Translation configuration",
-  id: "TranslationConfig"
+  ref: "TranslationConfig"
 });
 
 // ../commons/src/events/ActionType.ts
-var z2 = __toESM(require("zod/v4"));
+var import_zod2 = require("zod");
 var ActionType = {
   // Pre-declaration actions
   DELETE: "DELETE",
@@ -77,8 +78,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",
@@ -94,29 +95,26 @@ var ActionType = {
   // General actions
   READ: "READ",
   ASSIGN: "ASSIGN",
-  UNASSIGN: "UNASSIGN",
-  // Custom action
-  CUSTOM: "CUSTOM"
+  UNASSIGN: "UNASSIGN"
 };
 var ConfirmableActions = [
   ActionType.NOTIFY,
   ActionType.DECLARE,
-  ActionType.EDIT,
+  ActionType.VALIDATE,
   ActionType.REGISTER,
   ActionType.REJECT,
   ActionType.ARCHIVE,
   ActionType.PRINT_CERTIFICATE,
   ActionType.REQUEST_CORRECTION,
   ActionType.APPROVE_CORRECTION,
-  ActionType.REJECT_CORRECTION,
-  ActionType.CUSTOM
+  ActionType.REJECT_CORRECTION
 ];
-var ActionTypes = z2.enum([
+var ActionTypes = import_zod2.z.enum([
   "DELETE",
   "CREATE",
   "NOTIFY",
   "DECLARE",
-  "EDIT",
+  "VALIDATE",
   "REGISTER",
   "DUPLICATE_DETECTED",
   "REJECT",
@@ -129,15 +127,14 @@ var ActionTypes = z2.enum([
   "APPROVE_CORRECTION",
   "READ",
   "ASSIGN",
-  "UNASSIGN",
-  "CUSTOM"
+  "UNASSIGN"
 ]);
 var ClientSpecificAction = {
   REVIEW_CORRECTION_REQUEST: "REVIEW_CORRECTION_REQUEST"
 };
 var declarationActionValues = [
   ActionTypes.enum.DECLARE,
-  ActionTypes.enum.EDIT,
+  ActionTypes.enum.VALIDATE,
   ActionTypes.enum.REGISTER,
   ActionTypes.enum.NOTIFY,
   ActionTypes.enum.DUPLICATE_DETECTED
@@ -158,14 +155,13 @@ 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.CUSTOM
+  ActionType.APPROVE_CORRECTION
 ]);
 var META_ACTIONS = [
   ActionType.ASSIGN,
@@ -174,57 +170,59 @@ var META_ACTIONS = [
 ];
 
 // ../commons/src/events/FieldConfig.ts
-var z17 = __toESM(require("zod/v4"));
+var import_zod16 = require("zod");
 
 // ../commons/src/events/Conditional.ts
-var z3 = __toESM(require("zod/v4"));
-var Conditional = z3.any().describe("JSONSchema").meta({
+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({
   description: "JSON schema conditional configuration",
-  id: "Conditional"
+  ref: "Conditional"
 });
 var ConditionalType = {
   SHOW: "SHOW",
   ENABLE: "ENABLE",
   DISPLAY_ON_REVIEW: "DISPLAY_ON_REVIEW"
 };
-var ShowConditional = z3.object({
-  type: z3.literal(ConditionalType.SHOW),
+var ShowConditional = import_zod3.z.object({
+  type: import_zod3.z.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 = z3.object({
-  type: z3.literal(ConditionalType.ENABLE),
+var EnableConditional = import_zod3.z.object({
+  type: import_zod3.z.literal(ConditionalType.ENABLE),
   conditional: Conditional
 }).describe(
   "If 'ENABLE' conditional is defined, the component is enabled only if the condition is met"
 );
-var ActionConditional = z3.discriminatedUnion("type", [
+var ActionConditional = import_zod3.z.discriminatedUnion("type", [
   // Action can be shown / hidden
   ShowConditional,
   // Action can be shown to the user in the list but as disabled
   EnableConditional
 ]);
-var DisplayOnReviewConditional = z3.object({
-  type: z3.literal(ConditionalType.DISPLAY_ON_REVIEW),
+var DisplayOnReviewConditional = import_zod3.z.object({
+  type: import_zod3.z.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 = z3.discriminatedUnion("type", [
+var FieldConditional = import_zod3.z.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
-]).meta({
+]).openapi({
   description: "Field conditional configuration",
-  id: "FieldConditional"
+  ref: "FieldConditional"
 });
 
 // ../commons/src/events/FieldType.ts
-var z4 = __toESM(require("zod/v4"));
+var import_zod4 = require("zod");
 var FieldType = {
   NAME: "NAME",
   PHONE: "PHONE",
@@ -267,21 +265,9 @@ var FieldType = {
   QUERY_PARAM_READER: "QUERY_PARAM_READER",
   QR_READER: "QR_READER",
   ID_READER: "ID_READER",
-  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"
+  LOADER: "LOADER"
 };
-var FileFieldType = z4.enum([
+var FileFieldType = import_zod4.z.enum([
   FieldType.FILE,
   FieldType.FILE_WITH_OPTIONS,
   FieldType.SIGNATURE
@@ -305,155 +291,154 @@ var FieldTypesToHideInReview = [
   FieldType.LOADER,
   FieldType.HTTP,
   FieldType.QUERY_PARAM_READER,
-  FieldType.DATA,
-  FieldType.ALPHA_HIDDEN
+  FieldType.DATA
 ];
 
 // ../commons/src/events/FieldValue.ts
-var z7 = __toESM(require("zod/v4"));
+var import_zod7 = require("zod");
 
 // ../commons/src/documents.ts
-var z5 = __toESM(require("zod/v4"));
-var FullDocumentUrl = z5.string().brand("FullDocumentUrl").describe(
+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(
   "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 = z5.string().overwrite((val) => val.startsWith("/") ? val : `/${val}`).meta({ effectType: "input", type: "string" }).describe(
+var FullDocumentPath = import_zod5.z.string().transform((val) => val.startsWith("/") ? val : `/${val}`).openapi({ 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 = z5.string().brand("DocumentPath").describe(
+var DocumentPath = import_zod5.z.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 z6 = __toESM(require("zod/v4"));
+var import_zod6 = require("zod");
 var AddressType = {
   DOMESTIC: "DOMESTIC",
   INTERNATIONAL: "INTERNATIONAL"
 };
-var FileFieldValue = z6.object({
+var FileFieldValue = import_zod6.z.object({
   path: FullDocumentPath,
-  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(),
+  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(),
   streetLevelDetails: StreetLevelDetailsValue
 });
-var BaseAddressFieldUpdateValue = z6.object({
-  country: z6.string().nullish(),
+var BaseAddressFieldUpdateValue = import_zod6.z.object({
+  country: import_zod6.z.string().nullish(),
   streetLevelDetails: StreetLevelDetailsUpdateValue
 });
 var DomesticAddressFieldValue = BaseAddressFieldValue.extend({
-  addressType: z6.literal(AddressType.DOMESTIC),
-  administrativeArea: z6.string().uuid()
+  addressType: import_zod6.z.literal(AddressType.DOMESTIC),
+  administrativeArea: import_zod6.z.string().uuid()
 });
 var InternationalAddressFieldValue = BaseAddressFieldValue.extend({
-  addressType: z6.literal(AddressType.INTERNATIONAL)
+  addressType: import_zod6.z.literal(AddressType.INTERNATIONAL)
 });
-var AddressFieldValue = z6.discriminatedUnion("addressType", [
+var AddressFieldValue = import_zod6.z.discriminatedUnion("addressType", [
   DomesticAddressFieldValue,
   InternationalAddressFieldValue
 ]);
 var DomesticAddressUpdateFieldValue = BaseAddressFieldUpdateValue.extend({
-  addressType: z6.literal(AddressType.DOMESTIC),
-  administrativeArea: z6.string().uuid().nullish()
+  addressType: import_zod6.z.literal(AddressType.DOMESTIC),
+  administrativeArea: import_zod6.z.string().uuid().nullish()
   /* Leaf level admin structure */
 });
 var InternationalAddressUpdateFieldValue = BaseAddressFieldUpdateValue.extend(
   {
-    addressType: z6.literal(AddressType.INTERNATIONAL)
+    addressType: import_zod6.z.literal(AddressType.INTERNATIONAL)
   }
 );
-var AddressFieldUpdateValue = z6.discriminatedUnion("addressType", [
+var AddressFieldUpdateValue = import_zod6.z.discriminatedUnion("addressType", [
   DomesticAddressUpdateFieldValue,
   InternationalAddressUpdateFieldValue
 ]).nullish();
-var FileFieldValueWithOption = z6.object({
+var FileFieldValueWithOption = import_zod6.z.object({
   path: FullDocumentPath,
-  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())
+  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())
 }).nullish();
-var QueryParamReaderFieldUpdateValue = z6.object({
-  data: z6.record(z6.string(), z6.string())
+var QueryParamReaderFieldUpdateValue = import_zod6.z.object({
+  data: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string())
 });
-var ReadDataValue = z6.object({
-  data: z6.any()
+var ReadDataValue = import_zod6.z.object({
+  data: import_zod6.z.any()
 });
 var QrReaderFieldValue = ReadDataValue;
 var IdReaderFieldValue = ReadDataValue;
-var NumberWithUnitFieldValue = z6.object({
-  numericValue: z6.number(),
-  unit: z6.string()
+var NumberWithUnitFieldValue = import_zod6.z.object({
+  numericValue: import_zod6.z.number(),
+  unit: import_zod6.z.string()
 });
-var NumberWithUnitFieldUpdateValue = z6.object({
-  numericValue: z6.number().optional(),
-  unit: z6.string().optional()
+var NumberWithUnitFieldUpdateValue = import_zod6.z.object({
+  numericValue: import_zod6.z.number().optional(),
+  unit: import_zod6.z.string().optional()
 });
-var CustomFieldValue = z6.unknown().brand("CustomFieldValue");
 
 // ../commons/src/events/FieldValue.ts
-var TextValue = z7.string();
-var HiddenFieldValue = z7.string();
+var TextValue = import_zod7.z.string();
 var NonEmptyTextValue = TextValue.min(1);
-var DateValue = z7.iso.date().describe("Date in the format YYYY-MM-DD");
-var AgeValue = z7.object({
-  age: z7.number(),
-  asOfDateRef: z7.string()
+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 AgeUpdateValue = AgeValue.optional().nullable();
-var TimeValue = z7.string().regex(/^([01][0-9]|2[0-3]):[0-5][0-9]$/);
-var DatetimeValue = z7.iso.datetime();
-var SelectDateRangeValue = z7.enum([
+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([
   "last7Days",
   "last30Days",
   "last90Days",
   "last365Days"
 ]);
-var DateRangeFieldValue = z7.object({
+var DateRangeFieldValue = import_zod7.z.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 = z7.email();
-var CheckboxFieldValue = z7.boolean();
-var NumberFieldValue = z7.number();
-var SignatureFieldValue = z7.string();
-var ButtonFieldValue = z7.number();
-var VerificationStatusValue = z7.enum([
+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([
   "verified",
   "authenticated",
   "failed",
   "pending"
 ]);
-var FieldValuesWithoutDataField = z7.union([
+var FieldValuesWithoutDataField = import_zod7.z.union([
   AddressFieldValue,
   TextValue,
   DateValue,
@@ -474,13 +459,12 @@ var FieldValuesWithoutDataField = z7.union([
   QrReaderFieldValue,
   IdReaderFieldValue,
   NumberWithUnitFieldValue,
-  NumberWithUnitFieldUpdateValue,
-  CustomFieldValue
+  NumberWithUnitFieldUpdateValue
 ]);
-var DataFieldValue = z7.object({
-  data: z7.record(z7.string(), FieldValuesWithoutDataField)
+var DataFieldValue = import_zod7.z.object({
+  data: import_zod7.z.record(import_zod7.z.string(), FieldValuesWithoutDataField)
 }).nullish();
-var FieldValue = z7.union([
+var FieldValue = import_zod7.z.union([
   FieldValuesWithoutDataField,
   DataFieldValue
 ]);
@@ -501,38 +485,22 @@ var PRIORITY_ORDER = [
   "DataFieldValue"
 ];
 function schemaPriority(schema) {
-  const name = schema.description;
-  if (!name) {
-    return 9999;
-  }
+  const name = schema._def?.description;
   const idx = PRIORITY_ORDER.indexOf(name);
   return idx === -1 ? 9999 : idx;
 }
 function safeUnion(schemas) {
-  return z7.any().superRefine((val, ctx) => {
+  return import_zod7.z.custom((val) => {
     const successful = schemas.filter((s) => s.safeParse(val).success);
     if (successful.length === 1) {
-      return;
+      return true;
     }
     if (successful.length === 0) {
-      ctx.addIssue({
-        code: "invalid_type",
-        expected: "custom",
-        message: "Value does not match any schema"
-      });
-      return;
+      return false;
     }
     successful.sort((a, b) => schemaPriority(a) - schemaPriority(b));
     const best = successful[0];
-    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."
+    return best.safeParse(val).success;
   });
 }
 var FieldUpdateValue = safeUnion([
@@ -551,23 +519,24 @@ var FieldUpdateValue = safeUnion([
   DataFieldValue.describe("DataFieldValue"),
   NameFieldUpdateValue.describe("NameFieldUpdateValue"),
   HttpFieldUpdateValue.describe("HttpFieldUpdateValue"),
-  QueryParamReaderFieldUpdateValue.describe("QueryParamReaderFieldUpdateValue"),
-  CustomFieldValue.describe("CustomFieldValue"),
-  HiddenFieldValue.describe("HiddenFieldValue")
+  QueryParamReaderFieldUpdateValue.describe("QueryParamReaderFieldUpdateValue")
 ]);
 
+// ../commons/src/events/FieldConfig.ts
+var import_zod_openapi6 = require("zod-openapi");
+
 // ../commons/src/uuid.ts
 var import_uuid = require("uuid");
-var z8 = __toESM(require("zod/v4"));
-var UUID = z8.uuid().brand("UUID");
+var import_zod8 = require("zod");
+var UUID = import_zod8.z.string().uuid().brand("UUID");
 function getUUID() {
   return (0, import_uuid.v4)();
 }
 
 // ../commons/src/events/serializers/user/serializer.ts
-var z9 = __toESM(require("zod/v4"));
-var SerializedUserField = z9.object({
-  $userField: z9.enum([
+var import_zod9 = require("zod");
+var SerializedUserField = import_zod9.z.object({
+  $userField: import_zod9.z.enum([
     "id",
     "name",
     "role",
@@ -576,12 +545,11 @@ var SerializedUserField = z9.object({
     "firstname",
     "middlename",
     "surname",
-    "signature",
-    "avatar",
-    "primaryOfficeId",
-    "administrativeAreaId"
+    "district",
+    "province",
+    "primaryOfficeId"
   ]),
-  $location: z9.string().optional()
+  $location: import_zod9.z.string().optional()
 });
 function userSerializer(userField) {
   return {
@@ -601,20 +569,24 @@ function userSerializer(userField) {
 }
 
 // ../commons/src/events/EventIndex.ts
-var import_v4 = require("zod/v4");
+var import_zod14 = require("zod");
 
 // ../commons/src/events/EventMetadata.ts
-var z14 = __toESM(require("zod/v4"));
+var import_zod13 = require("zod");
 
 // ../commons/src/events/ActionDocument.ts
-var z12 = __toESM(require("zod/v4"));
+var import_zod12 = require("zod");
+var import_zod_openapi4 = require("zod-openapi");
+
+// ../commons/src/events/CreatedAtLocation.ts
+var CreatedAtLocation = UUID.nullish();
 
 // ../commons/src/authentication.ts
 var import_jwt_decode = __toESM(require("jwt-decode"));
-var z11 = __toESM(require("zod/v4"));
+var import_zod11 = require("zod");
 
 // ../commons/src/scopes.ts
-var z10 = __toESM(require("zod/v4"));
+var import_zod10 = require("zod");
 var SCOPES = {
   // TODO v1.8 legacy scopes
   BYPASSRATELIMIT: "bypassratelimit",
@@ -693,91 +665,91 @@ var SCOPES = {
   // data seeding
   USER_DATA_SEEDING: "user.data-seeding"
 };
-var LegacyScopes = z10.union([
-  z10.literal(SCOPES.BYPASSRATELIMIT),
-  z10.literal(SCOPES.REGISTER),
-  z10.literal(SCOPES.DEMO),
-  z10.literal(SCOPES.CONFIG)
+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 IntegrationScopes = z10.union([
-  z10.literal(SCOPES.WEBHOOK),
-  z10.literal(SCOPES.NATIONALID),
-  z10.literal(SCOPES.NOTIFICATION_API),
-  z10.literal(SCOPES.RECORDSEARCH)
+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 InternalOperationsScopes = z10.union([
-  z10.literal(SCOPES.RECORD_REINDEX),
-  z10.literal(SCOPES.RECORD_IMPORT)
+var InternalOperationsScopes = import_zod10.z.union([
+  import_zod10.z.literal(SCOPES.RECORD_REINDEX),
+  import_zod10.z.literal(SCOPES.RECORD_IMPORT)
 ]);
-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 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 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 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 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 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 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 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 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 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 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 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 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 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 ConfigScope = z10.literal(SCOPES.CONFIG_UPDATE_ALL);
-var DataSeedingScope = z10.literal(SCOPES.USER_DATA_SEEDING);
-var LiteralScopes = z10.union([
+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([
   LegacyScopes,
   IntegrationScopes,
   UnassignScope,
   DeclareScopes,
   ValidateScopes,
   RegisterScope,
-  z10.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
+  import_zod10.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
   CorrectionScopes,
   SearchScopes,
   AuditScopes,
-  z10.literal(SCOPES.PROFILE_ELECTRONIC_SIGNATURE),
+  import_zod10.z.literal(SCOPES.PROFILE_ELECTRONIC_SIGNATURE),
   PerformanceScopes,
   OrganisationScopes,
   UserScopes,
@@ -786,38 +758,38 @@ var LiteralScopes = z10.union([
   InternalOperationsScopes
 ]);
 var rawConfigurableScopeRegex = /^([a-zA-Z][a-zA-Z0-9.-]*(?:\.[a-zA-Z0-9.-]+)*)\[((?:\w+=[\w.-]+(?:\|[\w.-]+)*)(?:,[\w]+=[\w.-]+(?:\|[\w.-]+)*)*)\]$/;
-var rawConfigurableScope = z10.string().regex(rawConfigurableScopeRegex);
-var CreateUserScope = z10.object({
-  type: z10.literal("user.create"),
-  options: z10.object({
-    role: z10.array(z10.string())
+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 EditUserScope = z10.object({
-  type: z10.literal("user.edit"),
-  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 WorkqueueScope = z10.object({
-  type: z10.literal("workqueue"),
-  options: z10.object({
-    id: 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 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 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 RecordScopeType = z10.enum([
+var RecordScopeType = import_zod10.z.enum([
   "record.create",
   "record.read",
   "record.declare",
   "record.notify",
-  "record.declared.edit",
+  "record.declared.validate",
   "record.declared.reject",
   "record.declared.archive",
   "record.declared.review-duplicates",
@@ -827,40 +799,27 @@ var RecordScopeType = z10.enum([
   "record.registered.correct",
   "record.unassign-others"
 ]);
-var RecordScope = z10.object({
+var RecordScope = import_zod10.z.object({
   type: RecordScopeType,
-  options: z10.object({
-    event: z10.array(z10.string()).describe("Event type, e.g. birth, death")
+  options: import_zod10.z.object({
+    event: import_zod10.z.array(import_zod10.z.string()).describe("Event type, e.g. birth, death")
   })
 }).describe(
   "Scopes used to check user's permission to perform actions on a record."
 );
-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", [
+var ConfigurableRawScopes = import_zod10.z.discriminatedUnion("type", [
   SearchScope,
   CreateUserScope,
   EditUserScope,
   WorkqueueScope,
-  RecordScope,
-  CustomActionScope
-]);
-var ConfigurableActionScopes = z10.discriminatedUnion("type", [
-  // @TODO - Record scope holds non-action scopes as well e.g., `record.read`
-  RecordScope,
-  CustomActionScope
+  RecordScope
 ]);
 var scopes = Object.values(SCOPES);
-var ActionScopes = z10.union([
+var ActionScopes = import_zod10.z.union([
   DeclareScopes,
   ValidateScopes,
   RegisterScope,
-  z10.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
+  import_zod10.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
   CorrectionScopes
 ]);
 
@@ -994,14 +953,15 @@ var DEFAULT_ROLES_DEFINITION = [
     ]
   }
 ];
-var TokenUserType = z11.enum(["user", "system"]);
-var TokenWithBearer = z11.string().regex(/^Bearer\s/);
+var TokenUserType = import_zod11.z.enum(["user", "system"]);
+var TokenWithBearer = import_zod11.z.string().regex(/^Bearer\s/);
 
 // ../commons/src/events/ActionDocument.ts
-var ActionUpdate = z12.record(z12.string(), FieldUpdateValue).describe(
+(0, import_zod_openapi4.extendZodWithOpenApi)(import_zod12.z);
+var ActionUpdate = import_zod12.z.record(import_zod12.z.string(), FieldUpdateValue).describe(
   "Record of field-level changes made by an action. Supports partial updates and nullable values."
 );
-var EventState = z12.record(z12.string(), FieldValue).describe(
+var EventState = import_zod12.z.record(import_zod12.z.string(), FieldValue).describe(
   "Aggregate representation of event data after all actions have been applied, with all updates consolidated and null values removed."
 );
 var ActionStatus = {
@@ -1009,25 +969,24 @@ var ActionStatus = {
   Accepted: "Accepted",
   Rejected: "Rejected"
 };
-var ActionBase = z12.object({
+var ActionBase = import_zod12.z.object({
   id: UUID.describe("Unique identifier of the action."),
-  transactionId: z12.string().describe("Unique identifier of the transaction."),
+  transactionId: import_zod12.z.string().describe("Unique identifier of the transaction."),
   createdByUserType: TokenUserType.describe(
     "Indicates whether the action was created by a human-user or by a system-user."
   ),
-  createdAt: 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(
+  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(
     "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: z12.enum([
+  status: import_zod12.z.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
@@ -1038,181 +997,172 @@ var ActionBase = z12.object({
     "Reference to the original action asynchronously accepted or rejected by a third-party integration."
   )
 });
-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.")
+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.")
     // TODO move into 'content' property
-  }).shape
+  })
 );
-var UnassignedAction = ActionBase.extend(
-  z12.object({
-    type: z12.literal(ActionType.UNASSIGN)
-  }).shape
+var UnassignedAction = ActionBase.merge(
+  import_zod12.z.object({
+    type: import_zod12.z.literal(ActionType.UNASSIGN)
+  })
 );
-var RegisterAction = ActionBase.extend(
-  z12.object({
-    type: z12.literal(ActionType.REGISTER),
-    registrationNumber: z12.string().optional().describe(
+var RegisterAction = ActionBase.merge(
+  import_zod12.z.object({
+    type: import_zod12.z.literal(ActionType.REGISTER),
+    registrationNumber: import_zod12.z.string().optional().describe(
       "Registration number of the event. Always present for accepted registrations."
     )
     // TODO move into 'content' property
-  }).shape
+  })
 );
-var DeclareAction = ActionBase.extend(
-  z12.object({
-    type: z12.literal(ActionType.DECLARE)
-  }).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 ReasonContent = z12.object({
-  reason: z12.string().min(1, { error: "Message cannot be empty" }).describe(
+var ReasonContent = import_zod12.z.object({
+  reason: import_zod12.z.string().min(1, { message: "Message cannot be empty" }).describe(
     "Message describing the reason for rejecting or archiving the event."
   )
 });
-var RejectAction = ActionBase.extend(
-  z12.object({
-    type: z12.literal(ActionType.REJECT),
+var RejectAction = ActionBase.merge(
+  import_zod12.z.object({
+    type: import_zod12.z.literal(ActionType.REJECT),
     content: ReasonContent
-  }).shape
+  })
 );
-var PotentialDuplicate = z12.object({
+var PotentialDuplicate = import_zod12.z.object({
   id: UUID,
-  trackingId: z12.string()
+  trackingId: import_zod12.z.string()
 });
-var DuplicateDetectedAction = ActionBase.extend(
-  z12.object({
-    type: z12.literal(ActionType.DUPLICATE_DETECTED),
-    content: z12.object({
-      duplicates: z12.array(PotentialDuplicate)
+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)
     })
-  }).shape
+  })
 );
-var MarkNotDuplicateAction = ActionBase.extend(
-  z12.object({
-    type: z12.literal(ActionType.MARK_AS_NOT_DUPLICATE)
-  }).shape
+var MarkNotDuplicateAction = ActionBase.merge(
+  import_zod12.z.object({
+    type: import_zod12.z.literal(ActionType.MARK_AS_NOT_DUPLICATE)
+  })
 );
-var MarkAsDuplicateAction = ActionBase.extend(
-  z12.object({
-    type: z12.literal(ActionType.MARK_AS_DUPLICATE),
-    content: z12.object({
+var MarkAsDuplicateAction = ActionBase.merge(
+  import_zod12.z.object({
+    type: import_zod12.z.literal(ActionType.MARK_AS_DUPLICATE),
+    content: import_zod12.z.object({
       duplicateOf: UUID
     }).optional()
-  }).shape
+  })
 );
-var ArchiveAction = ActionBase.extend(
-  z12.object({
-    type: z12.literal(ActionType.ARCHIVE),
+var ArchiveAction = ActionBase.merge(
+  import_zod12.z.object({
+    type: import_zod12.z.literal(ActionType.ARCHIVE),
     content: ReasonContent
-  }).shape
-);
-var CreatedAction = ActionBase.extend(
-  z12.object({
-    type: z12.literal(ActionType.CREATE)
-  }).shape
+  })
 );
-var NotifiedAction = ActionBase.extend(
-  z12.object({
-    type: z12.literal(ActionType.NOTIFY)
-  }).shape
+var CreatedAction = ActionBase.merge(
+  import_zod12.z.object({
+    type: import_zod12.z.literal(ActionType.CREATE)
+  })
 );
-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 NotifiedAction = ActionBase.merge(
+  import_zod12.z.object({
+    type: import_zod12.z.literal(ActionType.NOTIFY)
+  })
 );
-var PrintContent = z12.object({
-  templateId: z12.string().optional()
+var PrintContent = import_zod12.z.object({
+  templateId: import_zod12.z.string().optional()
 });
-var PrintCertificateAction = ActionBase.extend(
-  z12.object({
-    type: z12.literal(ActionType.PRINT_CERTIFICATE),
+var PrintCertificateAction = ActionBase.merge(
+  import_zod12.z.object({
+    type: import_zod12.z.literal(ActionType.PRINT_CERTIFICATE),
     content: PrintContent.optional().nullable()
-  }).shape
+  })
 );
-var RequestedCorrectionAction = ActionBase.extend(
-  z12.object({
-    type: z12.literal(ActionType.REQUEST_CORRECTION)
-  }).shape
+var RequestedCorrectionAction = ActionBase.merge(
+  import_zod12.z.object({
+    type: import_zod12.z.literal(ActionType.REQUEST_CORRECTION)
+  })
 );
-var ApprovedCorrectionAction = ActionBase.extend(
-  z12.object({
-    type: z12.literal(ActionType.APPROVE_CORRECTION),
-    requestId: z12.string()
+var ApprovedCorrectionAction = ActionBase.merge(
+  import_zod12.z.object({
+    type: import_zod12.z.literal(ActionType.APPROVE_CORRECTION),
+    requestId: import_zod12.z.string()
     // TODO move into 'content' property
-  }).shape
+  })
 );
-var RejectedCorrectionAction = ActionBase.extend(
-  z12.object({
-    type: z12.literal(ActionType.REJECT_CORRECTION),
-    requestId: z12.string(),
+var RejectedCorrectionAction = ActionBase.merge(
+  import_zod12.z.object({
+    type: import_zod12.z.literal(ActionType.REJECT_CORRECTION),
+    requestId: import_zod12.z.string(),
     // TODO move into 'content' property
     content: ReasonContent
-  }).shape
-);
-var ReadAction = ActionBase.extend(
-  z12.object({
-    type: z12.literal(ActionType.READ)
-  }).shape
+  })
 );
-var CustomAction = ActionBase.merge(
-  z12.object({
-    type: z12.literal(ActionType.CUSTOM),
-    customActionType: z12.string()
+var ReadAction = ActionBase.merge(
+  import_zod12.z.object({
+    type: import_zod12.z.literal(ActionType.READ)
   })
 );
-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 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 AsyncRejectActionDocument = ActionBase.omit({
   declaration: true,
   annotation: true
-}).extend(
-  z12.object({
-    type: z12.enum(ConfirmableActions),
-    status: z12.literal(ActionStatus.Rejected)
-  }).shape
+}).merge(
+  import_zod12.z.object({
+    type: import_zod12.z.enum(ConfirmableActions),
+    status: import_zod12.z.literal(ActionStatus.Rejected)
+  })
 );
-var Action = z12.union([ActionDocument, AsyncRejectActionDocument]);
+var Action = import_zod12.z.union([ActionDocument, AsyncRejectActionDocument]);
 
-// ../commons/src/events/Flag.ts
-var z13 = __toESM(require("zod/v4"));
+// ../commons/src/events/EventMetadata.ts
+var EventStatus = import_zod13.z.enum([
+  "CREATED",
+  "NOTIFIED",
+  "DECLARED",
+  "VALIDATED",
+  "REGISTERED",
+  "ARCHIVED"
+]);
 var InherentFlags = {
+  PENDING_CERTIFICATION: "pending-certification",
   INCOMPLETE: "incomplete",
   REJECTED: "rejected",
   CORRECTION_REQUESTED: "correction-requested",
-  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"
+  POTENTIAL_DUPLICATE: "potential-duplicate"
 };
-var ActionFlag = z13.string().regex(
+var ActionFlag = import_zod13.z.string().regex(
   new RegExp(
     `^(${Object.values(ActionType).join("|").toLowerCase()}):(${Object.values(
       ActionStatus
@@ -1220,92 +1170,59 @@ var ActionFlag = z13.string().regex(
   ),
   "Flag must be in the format ActionType:ActionStatus (lowerCase)"
 );
-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(
+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(
     "Location 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.")
+  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.")
 });
 var RegistrationCreationMetadata = ActionCreationMetadata.extend({
-  registrationNumber: z14.string().describe(
+  registrationNumber: import_zod13.z.string().describe(
     "Registration number of the event. Always present for accepted registrations."
   )
 });
-var LegalStatuses = z14.object({
+var LegalStatuses = import_zod13.z.object({
   [EventStatus.enum.DECLARED]: ActionCreationMetadata.nullish(),
   [EventStatus.enum.REGISTERED]: RegistrationCreationMetadata.nullish()
 });
-var EventMetadata = z14.object({
+var EventMetadata = import_zod13.z.object({
   id: UUID,
-  type: z14.string().describe("The type of event, such as birth, death, or marriage."),
+  type: import_zod13.z.string().describe("The type of event, such as birth, death, or marriage."),
   status: EventStatus,
   legalStatuses: LegalStatuses.describe(
     "Metadata related to the legal registration of the event, such as who registered it and when."
   ),
-  createdAt: z14.iso.datetime().describe("The timestamp when the event was first created and saved."),
+  createdAt: import_zod13.z.string().datetime().describe("The timestamp when the event was first created and saved."),
   dateOfEvent: ZodDate.nullish(),
-  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(
+  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(
     "Location of the user who created the event."
   ),
-  createdBySignature: z14.string().nullish().describe("Signature of the user who created the event."),
+  createdBySignature: import_zod13.z.string().nullish().describe("Signature of the user who created the event."),
   updatedAtLocation: UUID.nullish().describe(
     "Location of the user who last changed the status."
   ),
-  updatedAt: z14.iso.datetime().describe(
+  updatedAt: import_zod13.z.string().datetime().describe(
     "Timestamp of the most recent *accepted* status change. Possibly 3rd party update, if action is validation asynchronously."
   ),
-  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(
+  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(
     "System-generated tracking ID used by informants or registrars to look up the event."
   ),
-  potentialDuplicates: z14.array(PotentialDuplicate).describe(
+  potentialDuplicates: import_zod13.z.array(PotentialDuplicate).describe(
     "List of event IDs and their tracking IDs that this event could be a duplicate of."
   ),
-  flags: z14.array(Flag)
+  flags: import_zod13.z.array(Flag)
 });
 var EventMetadataKeysArray = [
   "id",
@@ -1313,7 +1230,6 @@ var EventMetadataKeysArray = [
   "status",
   "createdAt",
   "dateOfEvent",
-  "placeOfEvent",
   "createdBy",
   "createdByUserType",
   "updatedByUserRole",
@@ -1326,124 +1242,130 @@ var EventMetadataKeysArray = [
   "legalStatuses",
   "flags"
 ];
-var EventMetadataKeys = z14.enum(EventMetadataKeysArray);
+var EventMetadataKeys = import_zod13.z.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
-}).meta({
-  id: "EventIndex"
+}).openapi({
+  ref: "EventIndex"
 });
-var EventSearchIndex = import_v4.z.record(import_v4.z.string(), import_v4.z.any()).and(
-  import_v4.z.object({
-    type: import_v4.z.string()
+var EventSearchIndex = import_zod14.z.record(import_zod14.z.string(), import_zod14.z.any()).and(
+  import_zod14.z.object({
+    type: import_zod14.z.string()
     // Ensures "type" (event-id) exists and is a string
   })
-).meta({
-  id: "EventSearchIndex"
+).openapi({
+  ref: "EventSearchIndex"
 });
-var Fuzzy = import_v4.z.object({ type: import_v4.z.literal("fuzzy"), term: import_v4.z.string() }).meta({
-  id: "Fuzzy"
+var Fuzzy = import_zod14.z.object({ type: import_zod14.z.literal("fuzzy"), term: import_zod14.z.string() }).openapi({
+  ref: "Fuzzy"
 });
-var Exact = import_v4.z.object({ type: import_v4.z.literal("exact"), term: import_v4.z.string() }).meta({
-  id: "Exact"
+var Exact = import_zod14.z.object({ type: import_zod14.z.literal("exact"), term: import_zod14.z.string() }).openapi({
+  ref: "Exact"
 });
-var ExactStatus = import_v4.z.object({
-  type: import_v4.z.literal("exact"),
+var ExactStatus = import_zod14.z.object({
+  type: import_zod14.z.literal("exact"),
   term: EventStatus
-}).meta({
-  id: "ExactStatus"
+}).openapi({
+  ref: "ExactStatus"
 });
-var ExactUserType = import_v4.z.object({
-  type: import_v4.z.literal("exact"),
+var ExactUserType = import_zod14.z.object({
+  type: import_zod14.z.literal("exact"),
   term: TokenUserType
-}).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" });
+}).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" });
 var ExactDate = Exact.extend({
-  term: import_v4.z.iso.date().or(import_v4.z.iso.datetime())
-}).meta({
-  id: "ExactDate"
+  term: import_zod14.z.string().date().or(import_zod14.z.string().datetime())
+}).openapi({
+  ref: "ExactDate"
 });
-var TimePeriod = import_v4.z.object({
-  type: import_v4.z.literal("timePeriod"),
+var TimePeriod = import_zod14.z.object({
+  type: import_zod14.z.literal("timePeriod"),
   term: SelectDateRangeValue
-}).meta({
-  id: "TimePeriod"
+}).openapi({
+  ref: "TimePeriod"
 });
-var DateCondition = import_v4.z.union([ExactDate, RangeDate, TimePeriod]).meta({
-  id: "DateCondition"
+var DateCondition = import_zod14.z.union([ExactDate, RangeDate, TimePeriod]).openapi({
+  ref: "DateCondition"
 });
-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)
+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)
   ])
-).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),
+).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),
   // @todo: The type for this comes out as "any"
   data: QueryInput
 }).partial().refine((obj) => Object.values(obj).some((val) => val !== void 0), {
-  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({
+  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({
       default: [
         {
           eventType: TENNIS_CLUB_MEMBERSHIP,
@@ -1461,8 +1383,8 @@ var QueryType = import_v4.z.lazy(
       ]
     })
   })
-).meta({
-  id: "QueryType"
+).openapi({
+  ref: "QueryType"
 });
 function parseStringifiedQueryField(val) {
   if (typeof val === "string") {
@@ -1470,8 +1392,8 @@ function parseStringifiedQueryField(val) {
   }
   return val;
 }
-var SearchQuery = import_v4.z.object({
-  query: import_v4.z.preprocess(parseStringifiedQueryField, QueryType).meta({
+var SearchQuery = import_zod14.z.object({
+  query: import_zod14.z.preprocess(parseStringifiedQueryField, QueryType).openapi({
     default: {
       type: "and",
       clauses: [
@@ -1491,193 +1413,200 @@ var SearchQuery = import_v4.z.object({
       ]
     }
   }),
-  limit: import_v4.z.number().optional().default(100),
-  offset: import_v4.z.number().optional().default(0),
-  sort: import_v4.z.preprocess(
+  limit: import_zod14.z.number().optional().default(100),
+  offset: import_zod14.z.number().optional().default(0),
+  sort: import_zod14.z.preprocess(
     parseStringifiedQueryField,
-    import_v4.z.array(
-      import_v4.z.object({
-        field: import_v4.z.string(),
-        direction: import_v4.z.enum(["asc", "desc"]).default("asc")
+    import_zod14.z.array(
+      import_zod14.z.object({
+        field: import_zod14.z.string(),
+        direction: import_zod14.z.enum(["asc", "desc"]).default("asc")
       })
     )
   ).optional()
-}).meta({
-  id: "SearchQuery"
+}).openapi({
+  ref: "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)
+var import_zod15 = require("zod");
+var SerializedNowDateTime = import_zod15.z.object({
+  $$now: import_zod15.z.literal(true)
 });
 function todayDateTimeValueSerializer() {
   return { $$now: true };
 }
 
 // ../commons/src/events/FieldConfig.ts
-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({
+(0, import_zod_openapi6.extendZodWithOpenApi)(import_zod16.z);
+var FieldId = import_zod16.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_zod16.z.object({
   $$field: FieldId,
-  $$subfield: z17.array(z17.string()).optional().describe(
+  $$subfield: import_zod16.z.array(import_zod16.z.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 = z17.object({
+var ValidationConfig = import_zod16.z.object({
   validator: Conditional,
   message: TranslationConfig
 });
-var requiredSchema = z17.union([
-  z17.boolean(),
-  z17.object({
+var RequiredSchema = import_zod16.z.union([
+  import_zod16.z.boolean(),
+  import_zod16.z.object({
     message: TranslationConfig.describe("Custom required validation message")
   })
 ]).default(false).optional();
-var BaseField = z17.object({
+var BaseField = import_zod16.z.object({
   id: FieldId.describe("Unique identifier of the field."),
   label: TranslationConfig.describe("Human-readable label of the field."),
-  parent: FieldReference.or(z17.array(FieldReference)).optional().describe(
+  parent: FieldReference.or(import_zod16.z.array(FieldReference)).optional().describe(
     "Reference to the parent field or fields. When a parent field changes, this field is reset."
   ),
-  required: requiredSchema.describe(
+  required: RequiredSchema.describe(
     "Indicates whether the field is mandatory."
   ),
-  conditionals: z17.array(FieldConditional).default([]).optional().describe(
+  conditionals: import_zod16.z.array(FieldConditional).default([]).optional().describe(
     "Conditions determining when the field is shown or enabled. By default, the field is always shown and enabled."
   ),
-  secured: z17.boolean().default(false).optional().describe(
+  secured: import_zod16.z.boolean().default(false).optional().describe(
     "Indicates whether the field is secured. Secured fields are not indexed for search and are only visible when explicitly assigned."
   ),
   placeholder: TranslationConfig.optional(),
-  validation: z17.array(ValidationConfig).default([]).optional().describe("Additional validation rules applied to the field."),
+  validation: import_zod16.z.array(ValidationConfig).default([]).optional().describe("Additional validation rules applied to the field."),
   helperText: TranslationConfig.optional(),
-  hideLabel: z17.boolean().default(false).optional(),
-  uncorrectable: z17.boolean().default(false).optional().describe(
+  hideLabel: import_zod16.z.boolean().default(false).optional(),
+  uncorrectable: import_zod16.z.boolean().default(false).optional().describe(
     "Indicates whether the field can be modified during record correction."
   ),
-  value: FieldReference.or(z17.array(FieldReference)).optional().describe(
+  value: FieldReference.or(import_zod16.z.array(FieldReference)).optional().describe(
     "Reference to the source field or fields. When a value is defined, it is copied from the parent field when changed. If multiple references are provided, the first truthy value is used."
   ),
-  analytics: z17.boolean().default(false).optional().describe(
+  analytics: import_zod16.z.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: z17.literal(FieldType.DIVIDER)
+  type: import_zod16.z.literal(FieldType.DIVIDER)
+});
+var TextFieldConfiguration = import_zod16.z.object({
+  maxLength: import_zod16.z.number().optional().describe("Maximum length of the text"),
+  type: import_zod16.z.enum(["text", "password"]).optional(),
+  prefix: TranslationConfig.optional(),
+  postfix: TranslationConfig.optional()
 });
 var TextField = BaseField.extend({
-  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()
+  type: import_zod16.z.literal(FieldType.TEXT),
+  defaultValue: import_zod16.z.union([NonEmptyTextValue, SerializedUserField]).optional(),
+  configuration: TextFieldConfiguration.default({ type: "text" }).optional()
 }).describe("Text input");
 var NumberField = BaseField.extend({
-  type: z17.literal(FieldType.NUMBER),
+  type: import_zod16.z.literal(FieldType.NUMBER),
   defaultValue: NumberFieldValue.optional(),
-  configuration: z17.object({
-    min: z17.number().optional().describe("Minimum value"),
-    max: z17.number().optional().describe("Maximum value"),
+  configuration: import_zod16.z.object({
+    min: import_zod16.z.number().optional().describe("Minimum value"),
+    max: import_zod16.z.number().optional().describe("Maximum value"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).optional()
 }).describe("Number input");
 var TextAreaField = BaseField.extend({
-  type: z17.literal(FieldType.TEXTAREA),
+  type: import_zod16.z.literal(FieldType.TEXTAREA),
   defaultValue: NonEmptyTextValue.optional(),
-  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"),
+  configuration: import_zod16.z.object({
+    maxLength: import_zod16.z.number().optional().describe("Maximum length of the text"),
+    rows: import_zod16.z.number().optional().describe("Number of visible text lines"),
+    cols: import_zod16.z.number().optional().describe("Number of visible columns"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).default({ rows: 4 }).optional()
 }).describe("Multiline text input");
-var ImageMimeType = z17.enum([
+var ImageMimeType = import_zod16.z.enum([
   "image/png",
   "image/jpg",
   "image/jpeg",
   "image/svg+xml"
 ]);
-var DocumentMimeType = z17.enum([
+var DocumentMimeType = import_zod16.z.enum([
   "application/pdf",
   "application/msword",
   "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
   "application/vnd.oasis.opendocument.text"
 ]);
-var MimeType = z17.enum([
+var MimeType = import_zod16.z.enum([
   ...ImageMimeType.options,
   ...DocumentMimeType.options
 ]);
 var DEFAULT_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
 var SignatureField = BaseField.extend({
-  type: z17.literal(FieldType.SIGNATURE),
+  type: import_zod16.z.literal(FieldType.SIGNATURE),
   signaturePromptLabel: TranslationConfig.describe(
     "Title of the signature modal"
   ),
   defaultValue: SignatureFieldValue.optional(),
-  configuration: z17.object({
-    maxFileSize: z17.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+  configuration: import_zod16.z.object({
+    maxFileSize: import_zod16.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
     acceptedFileTypes: MimeType.array().optional().describe("List of allowed file formats for the signature")
   }).default({
     maxFileSize: DEFAULT_MAX_FILE_SIZE_BYTES
   })
 }).describe("Signature input field");
 var EmailField = BaseField.extend({
-  type: z17.literal(FieldType.EMAIL),
-  configuration: z17.object({
-    maxLength: z17.number().optional().describe("Maximum length of the text")
-  }).default({ maxLength: 255 }).optional(),
+  type: import_zod16.z.literal(FieldType.EMAIL),
+  configuration: import_zod16.z.object({
+    maxLength: import_zod16.z.number().optional().describe("Maximum length of the text")
+  }).default({ maxLength: 10 }).optional(),
   defaultValue: NonEmptyTextValue.optional()
 });
 var DateField = BaseField.extend({
-  type: z17.literal(FieldType.DATE),
-  defaultValue: SerializedNowDateTime.or(DateValue).optional().describe("Default date value(yyyy-MM-dd)"),
-  configuration: z17.object({
+  type: import_zod16.z.literal(FieldType.DATE),
+  defaultValue: SerializedNowDateTime.or(DateValue).optional().openapi({ effectType: "input", type: "string" }).describe("Default date value(yyyy-MM-dd)"),
+  configuration: import_zod16.z.object({
     notice: TranslationConfig.describe(
       "Text to display above the date input"
     ).optional()
   }).optional()
 }).describe("A single date input (yyyy-MM-dd)");
 var AgeField = BaseField.extend({
-  type: z17.literal(FieldType.AGE),
+  type: import_zod16.z.literal(FieldType.AGE),
   defaultValue: NumberFieldValue.optional(),
-  configuration: z17.object({
+  configuration: import_zod16.z.object({
     asOfDate: FieldReference,
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   })
 }).describe("An age input field which uses the current date as the asOfDate");
 var TimeField = BaseField.extend({
-  type: 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"),
+  type: import_zod16.z.literal(FieldType.TIME),
+  defaultValue: SerializedNowDateTime.or(TimeValue).optional().openapi({ effectType: "input", type: "object" }).describe("Default time value (HH-mm)"),
+  configuration: import_zod16.z.object({
+    use12HourFormat: import_zod16.z.boolean().optional().describe("Whether to use 12-hour format"),
     notice: TranslationConfig.describe(
       "Text to display above the time input"
     ).optional()
   }).optional()
 }).describe("A single date input (HH-mm)");
 var DateRangeField = BaseField.extend({
-  type: z17.literal(FieldType.DATE_RANGE),
+  type: import_zod16.z.literal(FieldType.DATE_RANGE),
   defaultValue: DateRangeFieldValue.optional(),
-  configuration: z17.object({
+  configuration: import_zod16.z.object({
     notice: TranslationConfig.describe(
       "Text to display above the date input"
     ).optional()
   }).optional()
 }).describe("A date range input ({ start: yyyy-MM-dd, end: yyyy-MM-dd })");
-var HtmlFontVariant = z17.enum([
+var HtmlFontVariant = import_zod16.z.enum([
   "reg12",
   "reg14",
   "reg16",
@@ -1687,38 +1616,34 @@ var HtmlFontVariant = z17.enum([
   "h2",
   "h1"
 ]);
-var ParagraphTextAlign = z17.enum(["left", "center", "right", "start", "end"]);
-var ParagraphConfiguration = z17.object({
-  styles: z17.object({
+var ParagraphConfiguration = import_zod16.z.object({
+  styles: import_zod16.z.object({
     fontVariant: HtmlFontVariant.optional().describe(
       "Font variant to use for the paragraph text"
     ),
-    hint: z17.boolean().optional().describe("When true, paragraph is styled as a hint with grey color"),
-    textAlign: ParagraphTextAlign.optional().describe(
-      "Text alignment for the paragraph"
-    )
+    hint: import_zod16.z.boolean().optional().describe("When true, paragraph is styled as a hint with grey color")
   }).optional()
 }).default({});
 var Paragraph = BaseField.extend({
-  type: z17.literal(FieldType.PARAGRAPH),
+  type: import_zod16.z.literal(FieldType.PARAGRAPH),
   defaultValue: NonEmptyTextValue.optional(),
   configuration: ParagraphConfiguration
 }).describe("A read-only HTML <p> paragraph");
 var PageHeader = BaseField.extend({
-  type: z17.literal(FieldType.PAGE_HEADER),
+  type: import_zod16.z.literal(FieldType.PAGE_HEADER),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("A read-only header component for form pages");
 var File = BaseField.extend({
-  type: z17.literal(FieldType.FILE),
+  type: import_zod16.z.literal(FieldType.FILE),
   defaultValue: FileFieldValue.optional(),
-  configuration: z17.object({
-    maxFileSize: z17.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+  configuration: import_zod16.z.object({
+    maxFileSize: import_zod16.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
     acceptedFileTypes: MimeType.array().optional().describe("List of allowed file formats for the signature"),
-    maxImageSize: z17.object({
-      targetSize: z17.object({ width: z17.number(), height: z17.number() })
+    maxImageSize: import_zod16.z.object({
+      targetSize: import_zod16.z.object({ width: import_zod16.z.number(), height: import_zod16.z.number() })
     }).optional(),
-    style: z17.object({
-      width: z17.enum(["full", "auto"]).optional().describe(
+    style: import_zod16.z.object({
+      width: import_zod16.z.enum(["full", "auto"]).optional().describe(
         "Whether the file upload button should take the full width of the container or not"
       )
     }).optional(),
@@ -1727,46 +1652,46 @@ var File = BaseField.extend({
     maxFileSize: DEFAULT_MAX_FILE_SIZE_BYTES
   })
 }).describe("File upload");
-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 SelectOption = import_zod16.z.object({
+  value: import_zod16.z.string().describe("The value of the option"),
+  label: import_zod16.z.union([import_zod16.z.string(), TranslationConfig]).describe("The label of the option")
 });
 var NumberWithUnitField = BaseField.extend({
-  type: z17.literal(FieldType.NUMBER_WITH_UNIT),
+  type: import_zod16.z.literal(FieldType.NUMBER_WITH_UNIT),
   defaultValue: NumberWithUnitFieldValue.optional(),
-  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"),
+  options: import_zod16.z.array(SelectOption).describe("A list of options for the unit select"),
+  configuration: import_zod16.z.object({
+    min: import_zod16.z.number().optional().describe("Minimum value of the number field"),
+    max: import_zod16.z.number().optional().describe("Maximum value of the number field"),
     numberFieldPlaceholder: TranslationConfig.optional().describe(
       "Placeholder for the number field"
     )
   }).optional()
 }).describe("Number with unit input");
 var RadioGroup = BaseField.extend({
-  type: z17.literal(FieldType.RADIO_GROUP),
+  type: import_zod16.z.literal(FieldType.RADIO_GROUP),
   defaultValue: TextValue.optional(),
-  options: z17.array(SelectOption).describe("A list of options"),
-  configuration: z17.object({
-    styles: z17.object({
-      size: z17.enum(["NORMAL", "LARGE"]).optional()
+  options: import_zod16.z.array(SelectOption).describe("A list of options"),
+  configuration: import_zod16.z.object({
+    styles: import_zod16.z.object({
+      size: import_zod16.z.enum(["NORMAL", "LARGE"]).optional()
     }).optional()
   }).optional()
 }).describe("Grouped radio options");
 var BulletList = BaseField.extend({
-  type: z17.literal(FieldType.BULLET_LIST),
+  type: import_zod16.z.literal(FieldType.BULLET_LIST),
   defaultValue: TextValue.optional(),
-  items: z17.array(TranslationConfig).describe("A list of items"),
-  configuration: z17.object({
-    styles: z17.object({
+  items: import_zod16.z.array(TranslationConfig).describe("A list of items"),
+  configuration: import_zod16.z.object({
+    styles: import_zod16.z.object({
       fontVariant: HtmlFontVariant.optional()
     }).optional()
   }).default({})
 }).describe("A list of bullet points");
 var Select = BaseField.extend({
-  type: z17.literal(FieldType.SELECT),
+  type: import_zod16.z.literal(FieldType.SELECT),
   defaultValue: TextValue.optional(),
-  options: z17.array(SelectOption).describe("A list of options"),
+  options: import_zod16.z.array(SelectOption).describe("A list of options"),
   noOptionsMessage: TranslationConfig.optional().describe(
     `
     A translation configuration object used to display a message when no options are available.
@@ -1778,34 +1703,48 @@ var Select = BaseField.extend({
   `
   )
 }).describe("Select input");
-var SelectDateRangeOption = z17.object({
+var SelectDateRangeOption = import_zod16.z.object({
   value: SelectDateRangeValue.describe("The value of the option"),
   label: TranslationConfig.describe("The label of the option")
 });
 var SelectDateRangeField = BaseField.extend({
-  type: z17.literal(FieldType.SELECT_DATE_RANGE),
+  type: import_zod16.z.literal(FieldType.SELECT_DATE_RANGE),
   defaultValue: SelectDateRangeValue.optional(),
-  options: z17.array(SelectDateRangeOption).describe("A list of options")
+  options: import_zod16.z.array(SelectDateRangeOption).describe("A list of options")
 }).describe("Select input with date range options");
-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 NameSchema = TextField.pick({
+  label: true,
+  required: true,
+  conditionals: true
+}).extend({
+  id: import_zod16.z.union([
+    import_zod16.z.literal("firstname"),
+    import_zod16.z.literal("middlename"),
+    import_zod16.z.literal("surname")
+  ]),
+  type: import_zod16.z.literal(FieldType.TEXT).default(FieldType.TEXT),
+  configuration: TextFieldConfiguration.omit({ type: true }).default({})
+});
+var NameConfig = import_zod16.z.object({
+  firstname: import_zod16.z.object({ required: RequiredSchema, label: TranslationConfig.optional() }).optional(),
+  middlename: import_zod16.z.object({ required: RequiredSchema, label: TranslationConfig.optional() }).optional(),
+  surname: import_zod16.z.object({ required: RequiredSchema, label: TranslationConfig.optional() }).optional()
 });
 var NameField = BaseField.extend({
-  type: z17.literal(FieldType.NAME),
-  defaultValue: z17.object({
+  type: import_zod16.z.literal(FieldType.NAME),
+  defaultValue: import_zod16.z.object({
     firstname: SerializedUserField.or(NonEmptyTextValue).optional(),
     middlename: SerializedUserField.or(NonEmptyTextValue).optional(),
     surname: SerializedUserField.or(NonEmptyTextValue).optional()
   }).optional(),
-  configuration: z17.object({
+  fields: import_zod16.z.array(NameSchema).optional(),
+  configuration: import_zod16.z.object({
     name: NameConfig.default({
       firstname: { required: true },
       surname: { required: true }
     }).optional(),
-    order: z17.array(z17.enum(["firstname", "middlename", "surname"])).optional(),
-    maxLength: z17.number().optional().describe("Maximum length of the text"),
+    order: import_zod16.z.array(import_zod16.z.enum(["firstname", "middlename", "surname"])).optional(),
+    maxLength: import_zod16.z.number().optional().describe("Maximum length of the text"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).default({
@@ -1817,51 +1756,51 @@ var NameField = BaseField.extend({
 }).describe("Name input field");
 var PhoneField = BaseField.extend({
   defaultValue: NonEmptyTextValue.optional(),
-  type: z17.literal(FieldType.PHONE)
+  type: import_zod16.z.literal(FieldType.PHONE)
 }).describe("Phone input field");
 var IdField = BaseField.extend({
   defaultValue: NonEmptyTextValue.optional(),
-  type: z17.literal(FieldType.ID)
+  type: import_zod16.z.literal(FieldType.ID)
 }).describe("ID input field");
 var Checkbox = BaseField.extend({
-  type: z17.literal(FieldType.CHECKBOX),
+  type: import_zod16.z.literal(FieldType.CHECKBOX),
   defaultValue: CheckboxFieldValue.default(false)
 }).describe("Boolean checkbox field");
 var Country = BaseField.extend({
-  type: z17.literal(FieldType.COUNTRY),
+  type: import_zod16.z.literal(FieldType.COUNTRY),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("Country select field");
-var AdministrativeAreas = z17.enum([
+var AdministrativeAreas = import_zod16.z.enum([
   "ADMIN_STRUCTURE",
   "HEALTH_FACILITY",
   "CRVS_OFFICE"
 ]);
-var AdministrativeAreaConfiguration = z17.object({
-  partOf: z17.object({
-    $declaration: z17.string()
+var AdministrativeAreaConfiguration = import_zod16.z.object({
+  partOf: import_zod16.z.object({
+    $declaration: import_zod16.z.string()
   }).optional().describe("Parent location"),
   type: AdministrativeAreas
 }).describe("Administrative area options");
-var AdministrativeAreaField = BaseField.extend({
-  type: z17.literal(FieldType.ADMINISTRATIVE_AREA),
+var AdministrativeArea = BaseField.extend({
+  type: import_zod16.z.literal(FieldType.ADMINISTRATIVE_AREA),
   defaultValue: NonEmptyTextValue.optional(),
   configuration: AdministrativeAreaConfiguration
 }).describe("Administrative area input field e.g. facility, office");
 var LocationInput = BaseField.extend({
-  type: z17.literal(FieldType.LOCATION),
+  type: import_zod16.z.literal(FieldType.LOCATION),
   defaultValue: NonEmptyTextValue.optional(),
-  configuration: z17.object({
-    searchableResource: z17.array(z17.enum(["locations", "facilities", "offices"]))
+  configuration: import_zod16.z.object({
+    searchableResource: import_zod16.z.array(import_zod16.z.enum(["locations", "facilities", "offices"]))
   })
 }).describe("Input field for a location");
 var FileUploadWithOptions = BaseField.extend({
-  type: z17.literal(FieldType.FILE_WITH_OPTIONS),
-  options: z17.array(SelectOption).describe("A list of options"),
+  type: import_zod16.z.literal(FieldType.FILE_WITH_OPTIONS),
+  options: import_zod16.z.array(SelectOption).describe("A list of options"),
   defaultValue: FileFieldWithOptionValue.optional(),
-  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() })
+  configuration: import_zod16.z.object({
+    maxFileSize: import_zod16.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+    maxImageSize: import_zod16.z.object({
+      targetSize: import_zod16.z.object({ width: import_zod16.z.number(), height: import_zod16.z.number() })
     }).optional(),
     acceptedFileTypes: MimeType.array().optional().describe("List of allowed file formats for the signature")
   }).default({
@@ -1869,93 +1808,115 @@ var FileUploadWithOptions = BaseField.extend({
   })
 });
 var Facility = BaseField.extend({
-  type: z17.literal(FieldType.FACILITY),
+  type: import_zod16.z.literal(FieldType.FACILITY),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("Input field for a facility");
 var Office = BaseField.extend({
-  type: z17.literal(FieldType.OFFICE),
+  type: import_zod16.z.literal(FieldType.OFFICE),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("Input field for an office");
 var DefaultAddressFieldValue = DomesticAddressFieldValue.extend({
-  administrativeArea: z17.union([UUID, SerializedUserField]).optional()
+  administrativeArea: import_zod16.z.union([UUID, SerializedUserField]).optional()
 });
+var DomesticAddressField = import_zod16.z.string().or(
+  BaseField.pick({
+    id: true,
+    required: true,
+    conditionals: true
+  }).extend({
+    type: import_zod16.z.union([
+      import_zod16.z.literal(FieldType.ADMINISTRATIVE_AREA),
+      import_zod16.z.literal(FieldType.COUNTRY)
+    ])
+  })
+).transform((val) => {
+  if (typeof val === "string") {
+    return {
+      id: val,
+      type: val === "country" ? FieldType.COUNTRY : FieldType.ADMINISTRATIVE_AREA,
+      required: true,
+      conditionals: []
+    };
+  }
+  return val;
+}).openapi({ effectType: "input", type: "string" });
 var Address = BaseField.extend({
-  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,
+  type: import_zod16.z.literal(FieldType.ADDRESS),
+  configuration: import_zod16.z.object({
+    lineSeparator: import_zod16.z.string().optional(),
+    fields: import_zod16.z.array(DomesticAddressField).optional(),
+    administrativeLevels: import_zod16.z.array(import_zod16.z.string()).optional(),
+    streetAddressForm: import_zod16.z.array(
+      import_zod16.z.object({
+        id: import_zod16.z.string(),
+        required: RequiredSchema,
         label: TranslationConfig,
-        type: z17.literal(FieldType.TEXT),
-        conditionals: z17.array(FieldConditional).default([]).optional(),
+        type: import_zod16.z.literal(FieldType.TEXT),
+        conditionals: import_zod16.z.array(FieldConditional).default([]).optional(),
         parent: FieldReference.optional()
       })
     ).optional()
   }).optional(),
   defaultValue: DefaultAddressFieldValue.optional()
 }).describe("Address input field \u2013 a combination of location and text fields");
-var StaticDataEntry = z17.object({
-  id: z17.string().describe("ID for the data entry."),
+var StaticDataEntry = import_zod16.z.object({
+  id: import_zod16.z.string().describe("ID for the data entry."),
   label: TranslationConfig,
-  value: TranslationConfig.or(z17.string()).or(FieldReference)
+  value: TranslationConfig.or(import_zod16.z.string()).or(FieldReference)
 }).describe("Static data entry");
-var DataEntry = z17.union([StaticDataEntry, z17.object({ fieldId: z17.string() })]).describe(
+var DataEntry = import_zod16.z.union([StaticDataEntry, import_zod16.z.object({ fieldId: import_zod16.z.string() })]).describe(
   "Data entry can be either a static data entry, or a reference to another field in the current form or the declaration."
 );
 var DataField = BaseField.extend({
-  type: z17.literal(FieldType.DATA),
-  configuration: z17.object({
+  type: import_zod16.z.literal(FieldType.DATA),
+  configuration: import_zod16.z.object({
     subtitle: TranslationConfig.optional(),
-    data: z17.array(DataEntry)
+    data: import_zod16.z.array(DataEntry)
   })
 }).describe("Data field for displaying read-only data");
 var ButtonField = BaseField.extend({
-  type: z17.literal(FieldType.BUTTON),
+  type: import_zod16.z.literal(FieldType.BUTTON),
   defaultValue: ButtonFieldValue.optional(),
-  configuration: z17.object({
-    icon: z17.string().optional().describe(
+  configuration: import_zod16.z.object({
+    icon: import_zod16.z.string().optional().describe(
       "Icon for the button. You can find icons from OpenCRVS UI-Kit."
     ),
-    loading: z17.boolean().optional().describe("Whether the button is in a loading state and shows a spinner"),
+    loading: import_zod16.z.boolean().optional().describe("Whether the button is in a loading state and shows a spinner"),
     text: TranslationConfig.describe("Text to display on the button")
   })
 }).describe("Generic button without any built-in functionality");
 var AlphaPrintButton = BaseField.extend({
-  type: z17.literal(FieldType.ALPHA_PRINT_BUTTON),
-  configuration: z17.object({
-    template: z17.string().describe("Template ID from countryconfig templates to use for printing"),
+  type: import_zod16.z.literal(FieldType.ALPHA_PRINT_BUTTON),
+  configuration: import_zod16.z.object({
+    template: import_zod16.z.string().describe("Template ID from countryconfig templates to use for printing"),
     buttonLabel: TranslationConfig.optional().describe(
       "Label for the print button"
     )
   })
 }).describe("Print button field for printing certificates");
 var HttpField = BaseField.extend({
-  type: z17.literal(FieldType.HTTP),
+  type: import_zod16.z.literal(FieldType.HTTP),
   defaultValue: HttpFieldValue.optional(),
-  configuration: z17.object({
+  configuration: import_zod16.z.object({
     trigger: FieldReference,
-    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")
+    url: import_zod16.z.string().describe("URL to send the HTTP request to"),
+    method: import_zod16.z.enum(["GET", "POST", "PUT", "DELETE"]),
+    headers: import_zod16.z.record(import_zod16.z.string()).optional(),
+    body: import_zod16.z.record(import_zod16.z.any()).optional(),
+    errorValue: import_zod16.z.any().optional().describe("Value to set if the request fails"),
+    params: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.union([import_zod16.z.string(), FieldReference])).optional(),
+    timeout: import_zod16.z.number().default(15e3).describe("Request timeout in milliseconds")
   })
 }).describe("HTTP request function triggered by a button click or other event");
 var SearchField = HttpField.extend({
-  type: z17.literal(FieldType.SEARCH),
+  type: import_zod16.z.literal(FieldType.SEARCH),
   configuration: SearchQuery.pick({
     query: true,
     limit: true,
     offset: true
   }).extend({
     validation: ValidationConfig,
-    indicators: z17.object({
+    indicators: import_zod16.z.object({
       loading: TranslationConfig.optional().describe(
         "Text to display while the search is in progress"
       ),
@@ -1970,7 +1931,7 @@ var SearchField = HttpField.extend({
       ),
       confirmButton: TranslationConfig.optional(),
       clearButton: TranslationConfig.optional(),
-      clearModal: z17.object({
+      clearModal: import_zod16.z.object({
         title: TranslationConfig.optional(),
         description: TranslationConfig.optional(),
         cancel: TranslationConfig.optional(),
@@ -1981,17 +1942,17 @@ var SearchField = HttpField.extend({
   })
 });
 var LinkButtonField = BaseField.extend({
-  type: z17.literal(FieldType.LINK_BUTTON),
-  configuration: z17.object({
-    url: z17.string().describe("URL to open"),
+  type: import_zod16.z.literal(FieldType.LINK_BUTTON),
+  configuration: import_zod16.z.object({
+    url: import_zod16.z.string().describe("URL to open"),
     text: TranslationConfig.describe("Text to display on the button"),
-    icon: z17.string().optional().describe("Icon for the button. You can find icons from OpenCRVS UI-Kit.")
+    icon: import_zod16.z.string().optional().describe("Icon for the button. You can find icons from OpenCRVS UI-Kit.")
   })
 }).describe("Button that opens a link");
 var VerificationStatus = BaseField.extend({
-  type: z17.literal(FieldType.VERIFICATION_STATUS),
+  type: import_zod16.z.literal(FieldType.VERIFICATION_STATUS),
   defaultValue: VerificationStatusValue.optional(),
-  configuration: z17.object({
+  configuration: import_zod16.z.object({
     status: TranslationConfig.describe("Text to display on the status pill."),
     description: TranslationConfig.describe(
       "Explaining text on the banner in form."
@@ -1999,55 +1960,38 @@ var VerificationStatus = BaseField.extend({
   })
 });
 var QueryParamReaderField = BaseField.extend({
-  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")
+  type: import_zod16.z.literal(FieldType.QUERY_PARAM_READER),
+  configuration: import_zod16.z.object({
+    pickParams: import_zod16.z.array(import_zod16.z.string()).describe("List of query parameters to read from the URL")
   })
 }).describe(
   "A field that maps URL query params into form values and clears them afterward"
 );
 var QrReaderField = BaseField.extend({
-  type: z17.literal(FieldType.QR_READER),
+  type: import_zod16.z.literal(FieldType.QR_READER),
   defaultValue: QrReaderFieldValue.optional(),
-  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"
-    })
+  configuration: import_zod16.z.object({
+    validator: import_zod16.z.custom(
+      (val) => typeof val === "object" && val !== null
+    )
   }).optional()
-}).meta({
-  description: "Configuration for QR code reader field, including optional JSON Schema validator.",
-  id: "QrReaderField"
 });
 var IdReaderField = BaseField.extend({
-  type: z17.literal(FieldType.ID_READER),
+  type: import_zod16.z.literal(FieldType.ID_READER),
   defaultValue: IdReaderFieldValue.optional(),
-  methods: z17.array(
-    z17.union([QrReaderField, LinkButtonField]).describe("Methods for reading an ID")
+  methods: import_zod16.z.array(
+    import_zod16.z.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: z17.literal(FieldType.LOADER),
-  configuration: z17.object({
+  type: import_zod16.z.literal(FieldType.LOADER),
+  configuration: import_zod16.z.object({
     text: TranslationConfig.describe("Display text above the loading spinner")
   })
 }).describe(
   "A non-interactive field that indicates an in progress operation in form"
 );
-var 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", [
+var FieldConfig = import_zod16.z.discriminatedUnion("type", [
   Address,
   TextField,
   NumberField,
@@ -2069,7 +2013,7 @@ var FieldConfig = z17.discriminatedUnion("type", [
   Checkbox,
   File,
   Country,
-  AdministrativeAreaField,
+  AdministrativeArea,
   Divider,
   LocationInput,
   Facility,
@@ -2087,81 +2031,83 @@ var FieldConfig = z17.discriminatedUnion("type", [
   IdReaderField,
   QueryParamReaderField,
   LoaderField,
-  SearchField,
-  CustomField,
-  HiddenField
-]).meta({
+  SearchField
+]).openapi({
   description: "Form field configuration",
-  id: "FieldConfig"
+  ref: "FieldConfig"
 });
-var AnyFileField = z17.discriminatedUnion("type", [
+var AnyFileField = import_zod16.z.discriminatedUnion("type", [
   SignatureField,
   File,
   FileUploadWithOptions
 ]);
 
 // ../commons/src/events/FormConfig.ts
-var z19 = __toESM(require("zod/v4"));
+var import_zod18 = require("zod");
 
 // ../commons/src/events/PageConfig.ts
-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"),
+var import_zod17 = require("zod");
+var import_zod_openapi7 = require("zod-openapi");
+(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod17.z);
+var PageTypes = import_zod17.z.enum(["FORM", "VERIFICATION"]);
+var PageConfigBase = import_zod17.z.object({
+  id: import_zod17.z.string().describe("Unique identifier for the page"),
   title: TranslationConfig.describe("Header title of the page"),
-  requireCompletionToContinue: z18.boolean().default(false).describe(
+  requireCompletionToContinue: import_zod17.z.boolean().default(false).describe(
     "If true, all required fields must be filled before continuing to the next page"
   ),
-  fields: z18.array(FieldConfig).describe("Fields to be rendered on the page"),
+  fields: import_zod17.z.array(FieldConfig).describe("Fields to be rendered on the page"),
   conditional: Conditional.optional().describe(
     "Page will be shown if condition is met. If conditional is not defined, the page will be always shown."
   )
-}).meta({
+}).openapi({
   description: "Form page configuration",
-  id: "FormPageConfig"
+  ref: "FormPageConfig"
 });
 var FormPageConfig = PageConfigBase.extend({
-  type: z18.literal(PageTypes.enum.FORM).default(PageTypes.enum.FORM)
+  type: import_zod17.z.literal(PageTypes.enum.FORM).default(PageTypes.enum.FORM)
 });
-var VerificationActionConfig = z18.object({
-  verify: z18.object({ label: TranslationConfig }),
-  cancel: z18.object({
+var VerificationActionConfig = import_zod17.z.object({
+  verify: import_zod17.z.object({ label: TranslationConfig }),
+  cancel: import_zod17.z.object({
     label: TranslationConfig,
-    confirmation: z18.object({
+    confirmation: import_zod17.z.object({
       title: TranslationConfig,
       body: TranslationConfig
     })
   })
-}).describe("Actions available on the verification page").meta({
+}).describe("Actions available on the verification page").openapi({
   description: "Verification action configuration",
-  id: "VerificationActionConfig"
+  ref: "VerificationActionConfig"
 });
 var VerificationPageConfig = FormPageConfig.extend({
-  type: z18.literal(PageTypes.enum.VERIFICATION),
+  type: import_zod17.z.literal(PageTypes.enum.VERIFICATION),
   actions: VerificationActionConfig
 });
-var PageConfig = z18.discriminatedUnion("type", [
+var PageConfig = import_zod17.z.discriminatedUnion("type", [
   FormPageConfig,
   VerificationPageConfig
 ]);
 
 // ../commons/src/events/FormConfig.ts
-var DeclarationFormConfig = z19.object({
+var DeclarationFormConfig = import_zod18.z.object({
   label: TranslationConfig.describe("Human readable description of the form"),
-  pages: z19.array(FormPageConfig)
+  pages: import_zod18.z.array(FormPageConfig)
 }).describe("Configuration of the declaration form.");
-var ActionFormConfig = z19.object({
+var ActionFormConfig = import_zod18.z.object({
   label: TranslationConfig.describe("Human readable description of the form"),
-  pages: z19.array(PageConfig)
+  pages: import_zod18.z.array(PageConfig)
 }).describe(
   "Configuration of the form used for system actions beyond declaration, supporting a wider range of page types."
 );
-var FormConfig = z19.union([DeclarationFormConfig, ActionFormConfig]);
+var FormConfig = import_zod18.z.union([DeclarationFormConfig, ActionFormConfig]);
 
 // ../commons/src/events/DeduplicationConfig.ts
-var z20 = __toESM(require("zod/v4"));
-var FieldReference2 = z20.string();
-var Matcher = z20.object({
+var import_zod19 = require("zod");
+var import_zod_openapi8 = require("zod-openapi");
+(0, import_zod_openapi8.extendZodWithOpenApi)(import_zod19.z);
+var FieldReference2 = import_zod19.z.string();
+var Matcher = import_zod19.z.object({
   /**
    * Reference to the field used in matching.
    *
@@ -2169,23 +2115,23 @@ var Matcher = z20.object({
    * be used as the origin date to calculate the distance from.
    */
   fieldId: FieldReference2,
-  options: z20.object({
-    boost: z20.number().optional(),
+  options: import_zod19.z.object({
+    boost: import_zod19.z.number().optional(),
     matchAgainst: FieldReference2.optional()
   }).optional().default({
     boost: 1
   })
 });
 var FuzzyMatcher = Matcher.extend({
-  type: z20.literal("fuzzy"),
-  options: z20.object({
+  type: import_zod19.z.literal("fuzzy"),
+  options: import_zod19.z.object({
     /**
      * Names of length 3 or less characters = 0 edits allowed
      * Names of length 4 - 6 characters = 1 edit allowed
      * Names of length >7 characters = 2 edits allowed
      */
-    fuzziness: z20.union([z20.string(), z20.number()]).optional().default("AUTO:4,7"),
-    boost: z20.number().optional().default(1),
+    fuzziness: import_zod19.z.union([import_zod19.z.string(), import_zod19.z.number()]).optional().default("AUTO:4,7"),
+    boost: import_zod19.z.number().optional().default(1),
     matchAgainst: FieldReference2.optional()
   }).optional().default({
     fuzziness: "AUTO:4,7",
@@ -2193,48 +2139,48 @@ var FuzzyMatcher = Matcher.extend({
   })
 });
 var StrictMatcher = Matcher.extend({
-  type: z20.literal("strict"),
-  options: z20.object({
-    boost: z20.number().optional().default(1),
+  type: import_zod19.z.literal("strict"),
+  options: import_zod19.z.object({
+    boost: import_zod19.z.number().optional().default(1),
     /**
      * The constant value to be present in the field for both records
      */
-    value: z20.string().optional(),
+    value: import_zod19.z.string().optional(),
     matchAgainst: FieldReference2.optional()
   }).optional().default({
     boost: 1
   })
 });
 var DateRangeMatcher = Matcher.extend({
-  type: z20.literal("dateRange"),
-  options: z20.object({
+  type: import_zod19.z.literal("dateRange"),
+  options: import_zod19.z.object({
     /**
      * The distance pivot in days. Distance from the origin (the value of
      * fieldId) at which relevance scores receive half of the boost value
      */
-    pivot: z20.number().optional(),
-    days: z20.number(),
-    boost: z20.number().optional().default(1),
+    pivot: import_zod19.z.number().optional(),
+    days: import_zod19.z.number(),
+    boost: import_zod19.z.number().optional().default(1),
     matchAgainst: FieldReference2.optional()
   })
 });
-var Not = z20.object({
-  type: z20.literal("not"),
+var Not = import_zod19.z.object({
+  type: import_zod19.z.literal("not"),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clause: z20.lazy(() => Clause)
+  clause: import_zod19.z.lazy(() => Clause)
 });
-var And = z20.object({
-  type: z20.literal("and"),
+var And = import_zod19.z.object({
+  type: import_zod19.z.literal("and"),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clauses: z20.lazy(() => Clause.array())
+  clauses: import_zod19.z.lazy(() => Clause.array())
 });
-var Or = z20.object({
-  type: z20.literal("or"),
+var Or = import_zod19.z.object({
+  type: import_zod19.z.literal("or"),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clauses: z20.lazy(() => Clause.array())
+  clauses: import_zod19.z.lazy(() => Clause.array())
 });
-var Clause = z20.lazy(
-  () => z20.discriminatedUnion("type", [
+var Clause = import_zod19.z.lazy(
+  () => import_zod19.z.discriminatedUnion("type", [
     Not,
     And,
     Or,
@@ -2242,328 +2188,193 @@ var Clause = z20.lazy(
     StrictMatcher,
     DateRangeMatcher
   ])
-).meta({
-  id: "Clause"
+).openapi({
+  ref: "Clause"
 });
-var DeduplicationConfig = z20.object({
-  id: z20.string(),
+var DeduplicationConfig = import_zod19.z.object({
+  id: import_zod19.z.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 DeclarationReviewConfig = z22.object({
+var import_zod_openapi9 = require("zod-openapi");
+(0, import_zod_openapi9.extendZodWithOpenApi)(import_zod20.z);
+var DeclarationReviewConfig = import_zod20.z.object({
   title: TranslationConfig.describe("Title of the review page"),
-  fields: z22.array(FieldConfig).describe("Fields displayed on the review page for annotations.")
+  fields: import_zod20.z.array(FieldConfig).describe("Fields displayed on the review page for annotations.")
 }).describe(
   "Configuration of the declaration review page for collecting event-related metadata."
 );
-var ActionConfigBase = 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 ActionConfigBase = import_zod20.z.object({
+  label: TranslationConfig.describe("Human readable description of the action")
 });
 var DeclarationActionBase = ActionConfigBase.extend({
+  review: DeclarationReviewConfig,
   deduplication: DeduplicationConfig.optional()
 });
-var ReadActionConfig = ActionConfigBase.extend(
-  z22.object({
-    type: z22.literal(ActionType.READ),
+var ReadActionConfig = ActionConfigBase.merge(
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.READ),
     review: DeclarationReviewConfig.describe(
       "Configuration of the review page for read-only view."
-    ),
-    conditionals: z22.never().optional().describe("Read-action can not be disabled or hidden with conditionals.")
-  }).shape
+    )
+  })
 );
-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 DeclareConfig = DeclarationActionBase.merge(
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.DECLARE)
+  })
 );
-var ArchiveConfig = ActionConfigBase.extend(
-  z22.object({
-    type: z22.literal(ActionType.ARCHIVE)
-  }).shape
+var ValidateConfig = DeclarationActionBase.merge(
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.VALIDATE)
+  })
 );
-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 RegisterConfig = DeclarationActionBase.merge(
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.REGISTER)
+  })
 );
-var RejectConfig = ActionConfigBase.extend(
-  z22.object({
-    type: z22.literal(ActionType.REJECT)
-  }).shape
+var RejectDeclarationConfig = ActionConfigBase.merge(
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.REJECT)
+  })
+);
+var ArchiveConfig = ActionConfigBase.merge(
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.ARCHIVE)
+  })
 );
-var RegisterConfig = DeclarationActionBase.extend(
-  z22.object({
-    type: z22.literal(ActionType.REGISTER)
-  }).shape
+var DeleteConfig = ActionConfigBase.merge(
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.DELETE)
+  })
 );
-var PrintCertificateActionConfig = ActionConfigBase.extend(
-  z22.object({
-    type: z22.literal(ActionType.PRINT_CERTIFICATE),
+var PrintCertificateActionConfig = ActionConfigBase.merge(
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.PRINT_CERTIFICATE),
     printForm: ActionFormConfig
-  }).shape
+  })
 );
-var RequestCorrectionConfig = ActionConfigBase.extend(
-  z22.object({
-    type: z22.literal(ActionType.REQUEST_CORRECTION),
+var RequestCorrectionConfig = ActionConfigBase.merge(
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.REQUEST_CORRECTION),
     correctionForm: ActionFormConfig
-  }).shape
+  })
 );
-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 RejectCorrectionConfig = ActionConfigBase.merge(
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.REJECT_CORRECTION)
   })
 );
-var ActionConfig = z22.discriminatedUnion("type", [
+var ApproveCorrectionConfig = ActionConfigBase.merge(
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.APPROVE_CORRECTION)
+  })
+);
+var ActionConfig = import_zod20.z.discriminatedUnion("type", [
   /*
    * OpenAPI references are defined here so our generated OpenAPI spec knows to reuse the models
    * and treat them as "models" instead of duplicating the data structure in each endpoint.
    */
-  ReadActionConfig.meta({ id: "ReadActionConfig" }),
-  DeclareConfig.meta({ id: "DeclareActionConfig" }),
-  RejectConfig.meta({ id: "RejectActionConfig" }),
-  RegisterConfig.meta({ id: "RegisterActionConfig" }),
-  PrintCertificateActionConfig.meta({
-    id: "PrintCertificateActionConfig"
+  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"
   }),
-  RequestCorrectionConfig.meta({ id: "RequestCorrectionActionConfig" }),
-  EditActionConfig.meta({ id: "EditActionConfig" }),
-  ArchiveConfig.meta({ id: "ArchiveActionConfig" }),
-  CustomActionConfig.meta({ id: "CustomActionConfig" })
+  RequestCorrectionConfig.openapi({ ref: "RequestCorrectionActionConfig" }),
+  RejectCorrectionConfig.openapi({ ref: "RejectCorrectionActionConfig" }),
+  ApproveCorrectionConfig.openapi({ ref: "ApproveCorrectionActionConfig" })
 ]).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."
-).meta({ id: "ActionConfig" });
-var actionConfigTypes = new Set(
-  ActionConfig.options.map((opt) => opt.shape.type.value)
-);
-var DeclarationActionConfig = z22.discriminatedUnion("type", [
+).openapi({ ref: "ActionConfig" });
+var DeclarationActionConfig = import_zod20.z.discriminatedUnion("type", [
   DeclareConfig,
+  ValidateConfig,
   RegisterConfig
 ]);
 
 // ../commons/src/events/offline/CertificateConfig.ts
-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(),
+var import_zod21 = require("zod");
+var FontFamily = import_zod21.z.object({
+  normal: import_zod21.z.string(),
+  bold: import_zod21.z.string(),
+  italics: import_zod21.z.string(),
+  bolditalics: import_zod21.z.string()
+});
+var CertificateConfig = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  event: import_zod21.z.string(),
+  isV2Template: import_zod21.z.boolean().optional(),
   label: TranslationConfig,
-  isDefault: z23.boolean(),
-  fee: z23.object({
-    onTime: z23.number(),
-    late: z23.number(),
-    delayed: z23.number()
+  isDefault: import_zod21.z.boolean(),
+  fee: import_zod21.z.object({
+    onTime: import_zod21.z.number(),
+    late: import_zod21.z.number(),
+    delayed: import_zod21.z.number()
   }),
-  svgUrl: z23.string(),
-  fonts: z23.record(z23.string(), FontFamily).optional(),
-  conditionals: z23.array(ShowConditional).optional()
+  svgUrl: import_zod21.z.string(),
+  fonts: import_zod21.z.record(FontFamily).optional(),
+  conditionals: import_zod21.z.array(ShowConditional).optional()
 });
 var CertificateTemplateConfig = CertificateConfig.extend({
-  hash: z23.string().optional(),
-  svg: z23.string()
+  hash: import_zod21.z.string().optional(),
+  svg: import_zod21.z.string()
 });
 
 // ../commons/src/events/offline/LanguageConfig.ts
-var z24 = __toESM(require("zod/v4"));
-var LanguageConfig = z24.object({
-  lang: z24.string(),
+var import_zod22 = require("zod");
+var LanguageConfig = import_zod22.z.object({
+  lang: import_zod22.z.string(),
   /**
    * client.csv contents
    */
-  messages: z24.record(z24.string(), z24.string())
+  messages: import_zod22.z.record(import_zod22.z.string())
 });
 
 // ../commons/src/events/EventConfig.ts
-var z30 = __toESM(require("zod/v4"));
+var import_zod27 = require("zod");
 
 // ../commons/src/events/SummaryConfig.ts
-var z25 = __toESM(require("zod/v4"));
-var BaseField2 = z25.object({
+var import_zod23 = require("zod");
+var BaseField2 = import_zod23.z.object({
   emptyValueMessage: TranslationConfig.optional().describe(
     "Default message displayed when the field value is empty."
   ),
-  conditionals: z25.array(ShowConditional).default([]).optional()
+  conditionals: import_zod23.z.array(ShowConditional).default([]).optional()
 });
 var ReferenceField = BaseField2.extend({
-  fieldId: z25.string(),
+  fieldId: import_zod23.z.string(),
   label: TranslationConfig.optional().describe(
     "Overrides the default label from the referenced field when provided."
   )
 }).describe("Field referencing existing event data by field ID.");
 var Field = BaseField2.extend({
-  id: z25.string().describe("Identifier of the summary field."),
+  id: import_zod23.z.string().describe("Identifier of the summary field."),
   value: TranslationConfig.describe(
     'Field value template supporting variables from configuration and EventMetadata (e.g. "{informant.phoneNo} {informant.email}").'
   ),
   label: TranslationConfig
 }).describe("Custom field defined for the summary view.");
-var SummaryConfig = z25.object({
-  fields: z25.array(z25.union([Field, ReferenceField])).describe("Fields displayed in the event summary view.")
+var SummaryConfig = import_zod23.z.object({
+  fields: import_zod23.z.array(import_zod23.z.union([Field, ReferenceField])).describe("Fields displayed in the event summary view.")
 }).describe("Configuration of the event summary section.");
 
 // ../commons/src/events/AdvancedSearchConfig.ts
-var z26 = __toESM(require("zod/v4"));
-var MatchType = z26.enum(["fuzzy", "exact", "range", "within"]);
-var BaseField3 = z26.object({
-  config: z26.object({
+var import_zod24 = require("zod");
+var MatchType = import_zod24.z.enum(["fuzzy", "exact", "range", "within"]);
+var BaseField3 = import_zod24.z.object({
+  config: import_zod24.z.object({
     type: MatchType.describe(
       "Determines the search type of field. How to match value."
     ),
-    searchFields: z26.array(z26.string()).optional().describe(
+    searchFields: import_zod24.z.array(import_zod24.z.string()).optional().describe(
       `
       Defines multiple form fields that should be searched when this field has a value.
       All specified fields will be combined using OR logic.
@@ -2573,7 +2384,7 @@ var BaseField3 = z26.object({
       `
     )
   }),
-  type: z26.nativeEnum(FieldType).optional().describe(
+  type: import_zod24.z.nativeEnum(FieldType).optional().describe(
     `
       Explicitly specify the field type for searchFields.
       This is required when searchFields is defined, to show the correct control in the UI.
@@ -2587,7 +2398,7 @@ var BaseField3 = z26.object({
       This is required when searchFields is defined.            
       `
   ),
-  options: z26.array(SelectOption).optional(),
+  options: import_zod24.z.array(SelectOption).optional(),
   searchCriteriaLabelPrefix: TranslationConfig.optional().describe(
     `
     This property determines whether to add a prefix (such as "Child" or "Applicant") before the field label
@@ -2608,7 +2419,7 @@ var BaseField3 = z26.object({
     in the country-config > event.advancedSearch configuration. For example: field("child.dob", { searchCriteriaLabelPrefix: TranslationConfig }).
     `
   ),
-  conditionals: z26.array(FieldConditional).optional().describe(
+  conditionals: import_zod24.z.array(FieldConditional).default([]).optional().describe(
     `
        In advanced search, we sometimes need to override the default field visibility conditionals.
 
@@ -2622,20 +2433,20 @@ var BaseField3 = z26.object({
        are always rendered in the advanced search form.
       `
   ),
-  validations: z26.array(ValidationConfig).optional().describe(
+  validations: import_zod24.z.array(ValidationConfig).default([]).optional().describe(
     `Option for overriding the field validations specifically for advanced search form.`
   )
 });
-var SearchQueryParams = z26.object({
-  eventType: z26.string().optional().describe(
+var SearchQueryParams = import_zod24.z.object({
+  eventType: import_zod24.z.string().optional().describe(
     "Defines type of event so that when redirecting to Advanced Search page, appropriate tab can be selected"
   )
 }).catchall(FieldValue);
 var FieldConfigSchema = BaseField3.extend({
-  fieldId: z26.string(),
-  fieldType: z26.literal("field")
+  fieldId: import_zod24.z.string(),
+  fieldType: import_zod24.z.literal("field")
 });
-var EventFieldIdInput = z26.enum([
+var EventFieldIdInput = import_zod24.z.enum([
   "trackingId",
   "status",
   "legalStatuses.REGISTERED.acceptedAt",
@@ -2644,7 +2455,7 @@ var EventFieldIdInput = z26.enum([
   "updatedAt"
 ]);
 var METADATA_FIELD_PREFIX = "event.";
-var EventFieldId = z26.enum([
+var EventFieldId = import_zod24.z.enum([
   `${METADATA_FIELD_PREFIX}trackingId`,
   `${METADATA_FIELD_PREFIX}status`,
   `${METADATA_FIELD_PREFIX}legalStatuses.REGISTERED.acceptedAt`,
@@ -2654,29 +2465,29 @@ var EventFieldId = z26.enum([
 ]);
 var EventFieldConfigSchema = BaseField3.extend({
   fieldId: EventFieldId,
-  fieldType: z26.literal("event")
+  fieldType: import_zod24.z.literal("event")
 });
-var AdvancedSearchField = z26.discriminatedUnion("fieldType", [FieldConfigSchema, EventFieldConfigSchema]).superRefine((data, ctx) => {
+var AdvancedSearchField = import_zod24.z.discriminatedUnion("fieldType", [FieldConfigSchema, EventFieldConfigSchema]).superRefine((data, ctx) => {
   if (data.config.searchFields && data.config.searchFields.length > 0) {
     if (!data.label) {
       ctx.addIssue({
-        code: z26.ZodIssueCode.custom,
+        code: import_zod24.z.ZodIssueCode.custom,
         message: "label is required when config.searchFields is defined.",
         path: ["label"]
       });
     }
     if (!data.type) {
       ctx.addIssue({
-        code: z26.ZodIssueCode.custom,
+        code: import_zod24.z.ZodIssueCode.custom,
         message: "type is required when config.searchFields is defined.",
         path: ["type"]
       });
     }
   }
 });
-var AdvancedSearchConfig = z26.object({
+var AdvancedSearchConfig = import_zod24.z.object({
   title: TranslationConfig.describe("Advanced search tab title"),
-  fields: z26.array(AdvancedSearchField).describe("Advanced search fields within the tab.")
+  fields: import_zod24.z.array(AdvancedSearchField).describe("Advanced search fields within the tab.")
 });
 
 // ../commons/src/events/utils.ts
@@ -2685,11 +2496,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 z28 = __toESM(require("zod/v4"));
+var import_zod26 = require("zod");
 var import_date_fns = require("date-fns");
 
 // ../commons/src/events/DynamicFieldValue.ts
-var z27 = __toESM(require("zod/v4"));
+var import_zod25 = require("zod");
 
 // ../commons/src/conditionals/validate.ts
 var ajv = new import__.default({
@@ -2698,9 +2509,9 @@ var ajv = new import__.default({
   strict: false
   // Allow minContains and other newer features
 });
-var DataContext = z28.object({
-  rootData: z28.object({
-    $leafAdminStructureLocationIds: z28.array(z28.object({ id: UUID }))
+var DataContext = import_zod26.z.object({
+  rootData: import_zod26.z.object({
+    $leafAdminStructureLocationIds: import_zod26.z.array(import_zod26.z.object({ id: UUID }))
   })
 });
 function resolveDataPath(rootData, dataPath, instancePath) {
@@ -2777,12 +2588,12 @@ ajv.addKeyword({
 });
 
 // ../commons/src/utils.ts
-var z29 = __toESM(require("zod/v4"));
-var FullNameV1 = z29.array(
-  z29.object({
-    use: z29.string(),
-    family: z29.string(),
-    given: z29.array(z29.string())
+var z27 = __toESM(require("zod"));
+var FullNameV1 = z27.array(
+  z27.object({
+    use: z27.string(),
+    family: z27.string(),
+    given: z27.array(z27.string())
   })
 );
 function omitKeyDeep(obj, keyToRemove) {
@@ -2803,6 +2614,9 @@ 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);
 }
@@ -2813,10 +2627,7 @@ var getActionAnnotationFields = (actionConfig) => {
   if (actionConfig.type === ActionType.PRINT_CERTIFICATE) {
     return actionConfig.printForm.pages.flatMap(({ fields }) => fields);
   }
-  if (actionConfig.type === ActionType.CUSTOM) {
-    return actionConfig.form;
-  }
-  if ("review" in actionConfig) {
+  if (isDeclarationActionConfig(actionConfig)) {
     return actionConfig.review.fields;
   }
   return [];
@@ -2836,8 +2647,38 @@ var EXCLUDED_ACTIONS = [
   ActionType.REJECT_CORRECTION
 ];
 
-// ../commons/src/events/eventConfigValidation.ts
-function validateAdvancedSearchConfig(event2, ctx) {
+// ../commons/src/events/EventConfig.ts
+var import_zod_openapi10 = require("zod-openapi");
+(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod27.z);
+var EventConfig = import_zod27.z.object({
+  id: import_zod27.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_zod27.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_zod27.z.array(AdvancedSearchConfig).optional().default([]).describe(
+    "Configuration of fields available in the advanced search feature."
+  )
+}).superRefine((event2, ctx) => {
   const allFields = findAllFields(event2);
   const fieldIds = allFields.map((field3) => field3.id);
   const advancedSearchFields = event2.advancedSearch.flatMap(
@@ -2864,12 +2705,10 @@ function validateAdvancedSearchConfig(event2, ctx) {
     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
@@ -2878,7 +2717,7 @@ function validateDateOfEvent(event2, ctx) {
       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) {
@@ -2889,105 +2728,8 @@ function validateDateOfEvent(event2, ctx) {
       });
     }
   }
-}
-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"
+}).openapi({
+  ref: "EventConfig"
 }).describe("Configuration defining an event type.");
 
 // ../commons/src/events/EventConfigInput.ts
@@ -2996,7 +2738,7 @@ var defineActionForm = (actionForm) => ActionFormConfig.parse(actionForm);
 var defineFormPage = (formPage) => FormPageConfig.parse(formPage);
 
 // ../commons/src/events/WorkqueueConfig.ts
-var z33 = __toESM(require("zod/v4"));
+var import_zod31 = require("zod");
 
 // ../commons/src/conditionals/conditionals.ts
 var objectHash = __toESM(require("object-hash"));
@@ -3034,7 +2776,7 @@ function not(condition) {
     required: []
   });
 }
-function never2() {
+function never() {
   return not(alwaysTrue());
 }
 function jsonFieldPath(field3) {
@@ -3744,17 +3486,17 @@ var event = Object.assign(eventFn, {
 });
 
 // ../commons/src/events/WorkqueueColumnConfig.ts
-var z31 = __toESM(require("zod/v4"));
+var import_zod28 = require("zod");
 var WorkqueueColumnKeysArray = [
   ...EventMetadataKeysArray,
   "title",
   "outbox"
 ];
-var WorkqueueColumnKeys = z31.enum(WorkqueueColumnKeysArray);
-var WorkqueueColumnValue = z31.object({
+var WorkqueueColumnKeys = import_zod28.z.enum(WorkqueueColumnKeysArray);
+var WorkqueueColumnValue = import_zod28.z.object({
   $event: WorkqueueColumnKeys
 });
-var WorkqueueColumn = z31.object({
+var WorkqueueColumn = import_zod28.z.object({
   label: TranslationConfig,
   value: WorkqueueColumnValue
 });
@@ -3765,49 +3507,158 @@ function defineWorkqueuesColumns(workqueueColumns) {
 }
 
 // ../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),
+var import_zod29 = require("zod");
+var SerializableExact = import_zod29.z.object({
+  type: import_zod29.z.literal("exact"),
+  term: import_zod29.z.union([import_zod29.z.string(), SerializedUserField])
+});
+var SerializableWithin = import_zod29.z.object({
+  type: import_zod29.z.literal("within"),
+  location: import_zod29.z.union([import_zod29.z.string(), SerializedUserField])
+});
+var SerializedQueryExpression = import_zod29.z.object({
+  eventType: import_zod29.z.string(),
+  status: import_zod29.z.optional(import_zod29.z.union([AnyOfStatus, ExactStatus])),
+  createdAt: import_zod29.z.optional(DateCondition),
+  updatedAt: import_zod29.z.optional(DateCondition),
+  "legalStatuses.REGISTERED.createdAt": import_zod29.z.optional(DateCondition),
+  "legalStatuses.REGISTERED.createdAtLocation": import_zod29.z.optional(
+    import_zod29.z.union([Within, Exact])
+  ),
+  "legalStatuses.REGISTERED.registrationNumber": import_zod29.z.optional(Exact),
+  createdAtLocation: import_zod29.z.optional(
+    import_zod29.z.union([SerializableWithin, SerializableExact])
+  ),
+  updatedAtLocation: import_zod29.z.optional(
+    import_zod29.z.union([SerializableWithin, SerializableExact])
+  ),
+  assignedTo: import_zod29.z.optional(SerializableExact),
+  createdBy: import_zod29.z.optional(SerializableExact),
   createdByUserType: ExactUserType,
-  updatedBy: z32.optional(SerializableExact),
-  trackingId: z32.optional(Exact),
-  flags: z32.optional(ContainsFlags),
+  updatedBy: import_zod29.z.optional(SerializableExact),
+  trackingId: import_zod29.z.optional(Exact),
+  flags: import_zod29.z.optional(ContainsFlags),
   data: QueryInput
 }).partial();
-var Or2 = z32.object({
-  type: z32.literal("or"),
-  clauses: z32.array(SerializedQueryExpression)
+var Or2 = import_zod29.z.object({
+  type: import_zod29.z.literal("or"),
+  clauses: import_zod29.z.array(SerializedQueryExpression)
 });
-var And2 = z32.object({
-  type: z32.literal("and"),
-  clauses: z32.array(SerializedQueryExpression)
+var And2 = import_zod29.z.object({
+  type: import_zod29.z.literal("and"),
+  clauses: import_zod29.z.array(SerializedQueryExpression)
 });
-var CountryConfigQueryType = z32.discriminatedUnion("type", [And2, Or2]);
-var CountryConfigQueryInputType = z32.union([
+var CountryConfigQueryType = import_zod29.z.discriminatedUnion("type", [And2, Or2]);
+var CountryConfigQueryInputType = import_zod29.z.union([
   SerializedQueryExpression,
   And2,
   Or2
 ]);
 
+// ../commons/src/icons.ts
+var import_zod30 = require("zod");
+var AvailableIcons = import_zod30.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"
+]);
+
 // ../commons/src/events/WorkqueueConfig.ts
 var mandatoryColumns = defineWorkqueuesColumns([
   {
@@ -3827,17 +3678,23 @@ var mandatoryColumns = defineWorkqueuesColumns([
     value: event.field("updatedAt")
   }
 ]);
-var CtaActionType = z33.enum([...workqueueActions.options, ActionType.READ]);
-var WorkqueueConfig = z33.object({
-  slug: z33.string().describe("Determines the url of the workqueue."),
+var WorkqueueActionsWithDefault = import_zod31.z.enum([
+  ...workqueueActions.options,
+  "DEFAULT"
+]);
+var WorkqueueConfig = import_zod31.z.object({
+  slug: import_zod31.z.string().describe("Determines the url of the workqueue."),
   name: TranslationConfig.describe(
     "Title of the workflow (both in navigation and on the page)"
   ),
   query: CountryConfigQueryType,
-  /** 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),
+  actions: import_zod31.z.array(
+    import_zod31.z.object({
+      type: WorkqueueActionsWithDefault,
+      conditionals: import_zod31.z.array(Conditional).optional()
+    })
+  ),
+  columns: import_zod31.z.array(WorkqueueColumn).default(mandatoryColumns),
   icon: AvailableIcons,
   emptyMessage: TranslationConfig.optional()
 }).describe("Configuration for workqueue.");
@@ -3845,21 +3702,26 @@ var WorkqueueConfigWithoutQuery = WorkqueueConfig.omit({
   query: true,
   columns: true
 });
-var WorkqueueConfigInput = z33.object({
-  slug: z33.string().describe("Determines the url of the workqueue."),
+var WorkqueueConfigInput = import_zod31.z.object({
+  slug: import_zod31.z.string().describe("Determines the url of the workqueue."),
   name: TranslationConfig.describe(
     "Title of the workflow (both in navigation and on the page)"
   ),
   query: CountryConfigQueryInputType,
-  actions: z33.array(z33.object({ type: CtaActionType })).describe("Workqueue call-to-action button configuration."),
-  columns: z33.array(WorkqueueColumn).default(mandatoryColumns),
+  actions: import_zod31.z.array(
+    import_zod31.z.object({
+      type: WorkqueueActionsWithDefault,
+      conditionals: import_zod31.z.array(Conditional).optional()
+    })
+  ),
+  columns: import_zod31.z.array(WorkqueueColumn).default(mandatoryColumns),
   icon: AvailableIcons,
   emptyMessage: TranslationConfig.optional()
 });
-var WorkqueueCountInput = z33.array(
-  z33.object({ slug: z33.string(), query: QueryType })
+var WorkqueueCountInput = import_zod31.z.array(
+  import_zod31.z.object({ slug: import_zod31.z.string(), query: QueryType })
 );
-var WorkqueueCountOutput = z33.record(z33.string(), z33.number());
+var WorkqueueCountOutput = import_zod31.z.record(import_zod31.z.string(), import_zod31.z.number());
 
 // ../commons/src/events/workqueueDefaultColumns.ts
 var defaultWorkqueueColumns = [
@@ -3882,48 +3744,47 @@ var defaultWorkqueueColumns = [
 ];
 
 // ../commons/src/events/Draft.ts
-var z35 = __toESM(require("zod/v4"));
+var import_zod33 = require("zod");
 
 // ../commons/src/events/ActionInput.ts
-var z34 = __toESM(require("zod/v4"));
-var BaseActionInput = z34.object({
+var import_zod32 = require("zod");
+var import_zod_openapi11 = require("zod-openapi");
+(0, import_zod_openapi11.extendZodWithOpenApi)(import_zod32.z);
+var BaseActionInput = import_zod32.z.object({
   eventId: UUID,
-  transactionId: z34.string(),
+  transactionId: import_zod32.z.string(),
   declaration: ActionUpdate.default({}),
   annotation: ActionUpdate.optional(),
   originalActionId: UUID.optional(),
   // should not be part of base action.
-  keepAssignment: z34.boolean().optional(),
+  keepAssignment: import_zod32.z.boolean().optional(),
   // For normal users, the createdAtLocation is resolved on the backend from the user's primaryOfficeId.
-  // @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(
+  createdAtLocation: CreatedAtLocation.describe(
     "A valid office location ID. This is required for system users performing actions. The provided location must be a leaf-location, i.e. it must not have any children locations."
   )
 });
-var CreateActionInput = BaseActionInput.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 CreateActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.CREATE).default(ActionType.CREATE),
+    createdAtLocation: CreatedAtLocation
+  })
 );
-var RegisterActionInput = BaseActionInput.extend(
-  z34.strictObject({
-    type: z34.literal(ActionType.REGISTER).default(ActionType.REGISTER),
-    registrationNumber: z34.string().optional()
-  }).shape
+var RegisterActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
+    registrationNumber: import_zod32.z.string().optional()
+  })
+).strict();
+var ValidateActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE)
+  })
 );
-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({
+var NotifyActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
+  })
+).openapi({
   default: {
     eventId: "<event-id-here>",
     transactionId: getUUID(),
@@ -3932,150 +3793,135 @@ var NotifyActionInput = BaseActionInput.extend(
     type: ActionType.NOTIFY
   }
 });
-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 DeclareActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
+  })
 );
-var PrintCertificateActionInput = BaseActionInput.extend(
-  z34.object({
-    type: z34.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE),
+var PrintCertificateActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE),
     content: PrintContent.optional()
-  }).shape
+  })
 );
-var RejectDeclarationActionInput = BaseActionInput.extend(
-  z34.object({
-    type: z34.literal(ActionType.REJECT).default(ActionType.REJECT),
+var RejectDeclarationActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.REJECT).default(ActionType.REJECT),
     content: ReasonContent
-  }).shape
+  })
 );
-var DuplicateDetectedActionInput = BaseActionInput.extend(
-  z34.object({
-    type: z34.literal(ActionType.DUPLICATE_DETECTED).default(ActionType.DUPLICATE_DETECTED),
-    content: z34.object({
-      duplicates: z34.array(PotentialDuplicate)
+var DuplicateDetectedActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.DUPLICATE_DETECTED).default(ActionType.DUPLICATE_DETECTED),
+    content: import_zod32.z.object({
+      duplicates: import_zod32.z.array(PotentialDuplicate)
     })
-  }).shape
+  })
 );
-var MarkAsDuplicateActionInput = BaseActionInput.extend(
-  z34.object({
-    type: z34.literal(ActionType.MARK_AS_DUPLICATE).default(ActionType.MARK_AS_DUPLICATE),
-    content: z34.object({
+var MarkAsDuplicateActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.MARK_AS_DUPLICATE).default(ActionType.MARK_AS_DUPLICATE),
+    content: import_zod32.z.object({
       duplicateOf: UUID
     }).optional()
-  }).shape
+  })
 );
-var MarkNotDuplicateActionInput = BaseActionInput.extend(
-  z34.object({
-    type: z34.literal(ActionType.MARK_AS_NOT_DUPLICATE).default(ActionType.MARK_AS_NOT_DUPLICATE)
-  }).shape
+var MarkNotDuplicateActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.MARK_AS_NOT_DUPLICATE).default(ActionType.MARK_AS_NOT_DUPLICATE)
+  })
 );
-var ArchiveActionInput = BaseActionInput.extend(
-  z34.object({
-    type: z34.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE),
+var ArchiveActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE),
     content: ReasonContent
-  }).shape
+  })
 );
-var AssignActionInput = BaseActionInput.extend(
-  z34.object({
-    type: z34.literal(ActionType.ASSIGN),
-    assignedTo: z34.string()
-  }).shape
+var AssignActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.ASSIGN),
+    assignedTo: import_zod32.z.string()
+  })
 );
-var UnassignActionInput = BaseActionInput.extend(
-  z34.object({
-    type: z34.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
-    assignedTo: z34.literal(null).default(null)
-  }).shape
+var UnassignActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
+    assignedTo: import_zod32.z.literal(null).default(null)
+  })
 );
-var RequestCorrectionActionInput = BaseActionInput.extend(
-  z34.object({
-    type: z34.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
-  }).shape
+var RequestCorrectionActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
+  })
 );
-var RejectCorrectionActionInput = BaseActionInput.extend(
-  z34.object({
-    requestId: z34.string(),
-    type: z34.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION),
+var RejectCorrectionActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    requestId: import_zod32.z.string(),
+    type: import_zod32.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION),
     content: ReasonContent
-  }).shape
-);
-var ApproveCorrectionActionInput = BaseActionInput.extend(
-  z34.object({
-    requestId: z34.string(),
-    type: z34.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
-  }).shape
+  })
 );
-var ReadActionInput = BaseActionInput.extend(
-  z34.object({
-    type: z34.literal(ActionType.READ).default(ActionType.READ)
-  }).shape
+var ApproveCorrectionActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    requestId: import_zod32.z.string(),
+    type: import_zod32.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
+  })
 );
-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 ReadActionInput = BaseActionInput.merge(
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.READ).default(ActionType.READ)
+  })
 );
-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"
+var DeleteActionInput = import_zod32.z.object({ eventId: UUID });
+var ActionInput = import_zod32.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"
   }),
-  DuplicateDetectedActionInput.meta({
-    id: "DuplicateDetectedActionInput"
+  DuplicateDetectedActionInput.openapi({
+    ref: "DuplicateDetectedActionInput"
   }),
-  MarkAsDuplicateActionInput.meta({
-    id: "MarkAsDuplicateActionInput"
+  MarkAsDuplicateActionInput.openapi({
+    ref: "MarkAsDuplicateActionInput"
   }),
-  MarkNotDuplicateActionInput.meta({
-    id: "MarkNotDuplicateActionInput"
+  MarkNotDuplicateActionInput.openapi({
+    ref: "MarkNotDuplicateActionInput"
   }),
-  ArchiveActionInput.meta({ id: "ArchiveActionInput" }),
-  AssignActionInput.meta({ id: "AssignActionInput" }),
-  UnassignActionInput.meta({ id: "UnassignActionInput" }),
-  PrintCertificateActionInput.meta({ id: "PrintCertificateActionInput" }),
-  RequestCorrectionActionInput.meta({
-    id: "RequestCorrectionActionInput"
+  ArchiveActionInput.openapi({ ref: "ArchiveActionInput" }),
+  AssignActionInput.openapi({ ref: "AssignActionInput" }),
+  UnassignActionInput.openapi({ ref: "UnassignActionInput" }),
+  PrintCertificateActionInput.openapi({ ref: "PrintCertificateActionInput" }),
+  RequestCorrectionActionInput.openapi({
+    ref: "RequestCorrectionActionInput"
   }),
-  RejectCorrectionActionInput.meta({ id: "RejectCorrectionActionInput" }),
-  ApproveCorrectionActionInput.meta({
-    id: "ApproveCorrectionActionInput"
+  RejectCorrectionActionInput.openapi({ ref: "RejectCorrectionActionInput" }),
+  ApproveCorrectionActionInput.openapi({
+    ref: "ApproveCorrectionActionInput"
   }),
-  ReadActionInput.meta({ id: "ReadActionInput" }),
-  CustomActionInput.meta({ id: "CustomActionInput" }),
-  EditActionInput.meta({ id: "EditActionInput" })
-]).meta({
-  id: "ActionInput"
+  ReadActionInput.openapi({ ref: "ReadActionInput" })
+]).openapi({
+  ref: "ActionInput"
 });
 
 // ../commons/src/events/Draft.ts
-var Draft = z35.object({
+var Draft = import_zod33.z.object({
   id: UUID,
   eventId: UUID,
-  transactionId: z35.string(),
-  createdAt: z35.string().datetime(),
+  transactionId: import_zod33.z.string(),
+  createdAt: import_zod33.z.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: z35.enum([
+  type: ActionTypes.exclude([ActionTypes.Enum.DELETE]),
+  status: import_zod33.z.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
@@ -4083,33 +3929,32 @@ var DraftInput = BaseActionInput.extend({
 });
 
 // ../commons/src/events/EventInput.ts
-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" } });
+var import_zod34 = require("zod");
+var import_uuid10 = require("uuid");
+var EventInput = import_zod34.z.object({
+  transactionId: import_zod34.z.string(),
+  type: import_zod34.z.string()
+}).openapi({ default: { transactionId: (0, import_uuid10.v4)(), type: "birth" } });
 
 // ../commons/src/events/EventDocument.ts
-var z37 = __toESM(require("zod/v4"));
-var EventDocument = z37.object({
+var import_zod35 = require("zod");
+var import_zod_openapi12 = require("zod-openapi");
+(0, import_zod_openapi12.extendZodWithOpenApi)(import_zod35.z);
+var EventDocument = import_zod35.z.object({
   id: UUID.describe("Unique identifier of the event."),
-  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(
+  type: import_zod35.z.string().describe("Type of the event (e.g. birth, death, marriage)."),
+  createdAt: import_zod35.z.string().datetime().describe("Timestamp indicating when the event was created."),
+  updatedAt: import_zod35.z.string().datetime().describe(
     "Timestamp of the last update, excluding changes from actions."
   ),
-  actions: z37.array(Action).describe("Ordered list of actions associated with the event."),
-  trackingId: z37.string().describe(
+  actions: import_zod35.z.array(Action).describe("Ordered list of actions associated with the event."),
+  trackingId: import_zod35.z.string().describe(
     "System-generated tracking identifier used to look up the event."
   )
-}).meta({ id: "EventDocument" });
+}).openapi({ ref: "EventDocument" });
 
 // ../commons/src/events/state/index.ts
-var import_lodash4 = require("lodash");
+var import_lodash3 = require("lodash");
 
 // ../commons/src/events/state/utils.ts
 var import_lodash2 = require("lodash");
@@ -4117,18 +3962,14 @@ 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.CUSTOM
+  ActionType.REQUEST_CORRECTION
 ]);
 
-// ../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);
@@ -4136,7 +3977,7 @@ var defineConfig = (config) => {
 };
 
 // ../commons/src/events/test.utils.ts
-var import_lodash5 = require("lodash");
+var import_lodash4 = require("lodash");
 var import_date_fns4 = require("date-fns");
 
 // ../commons/src/field-config/field-configuration.ts
@@ -4158,6 +3999,7 @@ 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",
@@ -4957,7 +4799,7 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
           conditionals: [
             {
               type: ConditionalType.DISPLAY_ON_REVIEW,
-              conditional: never2()
+              conditional: never()
             }
           ]
         },
@@ -5340,16 +5182,119 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
           }
         }
       ],
-      conditional: not(never2())
+      conditional: not(never())
       // 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",
@@ -5400,12 +5345,13 @@ var tennisClubMembershipEvent = defineConfig({
       review: TENNIS_CLUB_DECLARATION_REVIEW
     },
     {
-      type: ActionType.REJECT,
+      type: ActionType.VALIDATE,
       label: {
-        defaultMessage: "Reject",
+        defaultMessage: "Validate",
         description: "This is shown as the action name anywhere the user can trigger the action from",
-        id: "event.tennis-club-membership.action.reject.label"
-      }
+        id: "event.tennis-club-membership.action.validate.label"
+      },
+      review: TENNIS_CLUB_DECLARATION_REVIEW
     },
     {
       type: ActionType.REGISTER,
@@ -5413,7 +5359,8 @@ 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,
@@ -5616,6 +5563,14 @@ 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: {
@@ -5624,6 +5579,22 @@ 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: [
@@ -5660,7 +5631,8 @@ var tennisClubMembershipEvent = defineConfig({
       },
       fields: [field("recommender.name").fuzzy()]
     }
-  ]
+  ],
+  declaration: TENNIS_CLUB_DECLARATION_FORM
 });
 
 // ../commons/src/fixtures/football-club-membership-event.ts
@@ -5728,13 +5700,23 @@ 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,
@@ -5940,6 +5922,14 @@ 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: {
@@ -5948,6 +5938,22 @@ 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: [
@@ -6047,7 +6053,7 @@ var libraryMembershipEvent = defineConfig({
   declaration: libraryMembershipForm
 });
 
-// ../commons/src/fixtures/child-onboarding-event.ts
+// ../commons/src/fixtures/v2-birth-event.ts
 function generateTranslationConfig(message) {
   return {
     defaultMessage: message,
@@ -6076,61 +6082,6 @@ 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: []
-      }
     }
   ]
 });
@@ -6234,7 +6185,7 @@ var mother = defineFormPage({
     }
   ]
 });
-var CHILD_ONBOARDING_DECLARATION_REVIEW = {
+var BIRTH_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}}}}}"
   ),
@@ -6254,12 +6205,12 @@ var CHILD_ONBOARDING_DECLARATION_REVIEW = {
     }
   ]
 };
-var CHILD_ONBOARDING_DECLARATION_FORM = defineDeclarationForm({
+var BIRTH_DECLARATION_FORM = defineDeclarationForm({
   label: generateTranslationConfig("Birth decalration form"),
   pages: [child, mother]
 });
-var ChildOnboardingEvent = defineConfig({
-  id: CHILD_ONBOARDING_EVENT,
+var v2BirthEvent = defineConfig({
+  id: BIRTH_EVENT,
   title: generateTranslationConfig(
     "{child.name.firstname} {child.name.surname}"
   ),
@@ -6267,21 +6218,27 @@ var ChildOnboardingEvent = defineConfig({
   summary: {
     fields: []
   },
-  declaration: CHILD_ONBOARDING_DECLARATION_FORM,
+  declaration: BIRTH_DECLARATION_FORM,
   actions: [
     {
       type: ActionType.READ,
       label: generateTranslationConfig("Read"),
-      review: CHILD_ONBOARDING_DECLARATION_REVIEW
+      review: BIRTH_DECLARATION_REVIEW
     },
     {
       type: ActionType.DECLARE,
       label: generateTranslationConfig("Declare"),
-      review: CHILD_ONBOARDING_DECLARATION_REVIEW
+      review: BIRTH_DECLARATION_REVIEW
+    },
+    {
+      type: ActionType.VALIDATE,
+      label: generateTranslationConfig("Validate"),
+      review: BIRTH_DECLARATION_REVIEW
     },
     {
       type: ActionType.REGISTER,
-      label: generateTranslationConfig("Register")
+      label: generateTranslationConfig("Register"),
+      review: BIRTH_DECLARATION_REVIEW
     }
   ],
   advancedSearch: []
@@ -6369,7 +6326,7 @@ var PRINT_DIGITAL_ID_CERTIFICATE_FORM = defineActionForm({
           conditionals: [
             {
               type: ConditionalType.ENABLE,
-              conditional: never2()
+              conditional: never()
             },
             {
               type: ConditionalType.SHOW,
@@ -6396,7 +6353,7 @@ var PRINT_DIGITAL_ID_CERTIFICATE_FORM = defineActionForm({
           conditionals: [
             {
               type: ConditionalType.ENABLE,
-              conditional: never2()
+              conditional: never()
             },
             {
               type: ConditionalType.SHOW,
@@ -6424,7 +6381,7 @@ var PRINT_DIGITAL_ID_CERTIFICATE_FORM = defineActionForm({
           conditionals: [
             {
               type: ConditionalType.ENABLE,
-              conditional: never2()
+              conditional: never()
             }
           ],
           value: field("identity.http-fetch").get("data.certificateId")
@@ -6502,8 +6459,8 @@ var digitalIdentityEvent = defineConfig({
 });
 
 // ../commons/src/events/test.utils.ts
-var z38 = __toESM(require("zod/v4"));
-var TestUserRole = z38.enum([
+var import_zod36 = require("zod");
+var TestUserRole = import_zod36.z.enum([
   "FIELD_AGENT",
   "LOCAL_REGISTRAR",
   "LOCAL_SYSTEM_ADMIN",
@@ -6514,14 +6471,18 @@ var TestUserRole = z38.enum([
 ]);
 
 // ../commons/src/events/scopes.ts
-var import_lodash6 = require("lodash");
+var import_lodash5 = require("lodash");
 var ACTION_SCOPE_MAP = {
   [ActionType.READ]: ["record.read"],
   [ActionType.CREATE]: ["record.create"],
   [ActionType.NOTIFY]: ["record.notify"],
-  [ActionType.DECLARE]: ["record.declare", "record.register"],
-  [ActionType.EDIT]: ["record.declared.edit"],
+  [ActionType.DECLARE]: [
+    "record.declare",
+    "record.declared.validate",
+    "record.register"
+  ],
   [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]: [
@@ -6539,8 +6500,7 @@ var ACTION_SCOPE_MAP = {
   [ActionType.REJECT]: ["record.declared.reject"],
   [ActionType.ASSIGN]: null,
   [ActionType.UNASSIGN]: null,
-  [ActionType.DUPLICATE_DETECTED]: [],
-  [ActionType.CUSTOM]: []
+  [ActionType.DUPLICATE_DETECTED]: []
 };
 
 // ../commons/src/events/state/availableActions.ts
@@ -6549,25 +6509,28 @@ var AVAILABLE_ACTIONS_BY_EVENT_STATUS = {
     ActionType.READ,
     ActionType.DECLARE,
     ActionType.NOTIFY,
-    ActionType.DELETE,
-    ActionType.CUSTOM
+    ActionType.DELETE
   ],
   [EventStatus.enum.NOTIFIED]: [
     ActionType.READ,
-    ActionType.EDIT,
+    ActionType.DECLARE,
     ActionType.MARK_AS_DUPLICATE,
     ActionType.ARCHIVE,
-    ActionType.REJECT,
-    ActionType.CUSTOM
+    ActionType.REJECT
   ],
   [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.CUSTOM,
-    ActionType.EDIT
+    ActionType.REJECT
   ],
   [EventStatus.enum.REGISTERED]: [
     ActionType.READ,
@@ -6575,14 +6538,12 @@ 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.CUSTOM
+    ActionType.UNASSIGN
   ]
 };
 var ACTION_FILTERS = {
@@ -6592,41 +6553,32 @@ 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.EDIT]: (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.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_lodash7 = require("lodash");
+var import_lodash6 = require("lodash");
 
 // ../commons/src/events/locations.ts
-var z39 = __toESM(require("zod/v4"));
-var LocationTypeV1 = z39.enum([
+var import_zod37 = require("zod");
+var LocationType = import_zod37.z.enum([
   "ADMIN_STRUCTURE",
   "CRVS_OFFICE",
   "HEALTH_FACILITY"
 ]);
-var LocationType = z39.enum(["CRVS_OFFICE", "HEALTH_FACILITY"]);
-var AdministrativeArea = z39.object({
+var Location = import_zod37.z.object({
   id: UUID,
-  name: z39.string(),
-  externalId: z39.string().nullish(),
+  name: import_zod37.z.string(),
   parentId: UUID.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()
+  validUntil: import_zod37.z.string().datetime().nullable(),
+  locationType: LocationType.nullable()
 });
 
 // ../commons/src/notification/UserNotifications.ts
-var z40 = __toESM(require("zod/v4"));
+var import_zod38 = require("zod");
 var TriggerEvent = {
   USER_CREATED: "user-created",
   USER_UPDATED: "user-updated",
@@ -6638,50 +6590,50 @@ var TriggerEvent = {
   CHANGE_PHONE_NUMBER: "change-phone-number",
   CHANGE_EMAIL_ADDRESS: "change-email-address"
 };
-var Recipient = z40.object({
+var Recipient = import_zod38.z.object({
   name: NameFieldValue.optional(),
-  mobile: z40.string().optional(),
-  email: z40.string().optional(),
-  bcc: z40.array(z40.string()).optional()
+  mobile: import_zod38.z.string().optional(),
+  email: import_zod38.z.string().optional(),
+  bcc: import_zod38.z.array(import_zod38.z.string()).optional()
 });
-var BasePayload = z40.object({
+var BasePayload = import_zod38.z.object({
   recipient: Recipient
 });
 var TriggerPayload = {
   [TriggerEvent.USER_CREATED]: BasePayload.extend({
-    username: z40.string(),
-    temporaryPassword: z40.string()
+    username: import_zod38.z.string(),
+    temporaryPassword: import_zod38.z.string()
   }),
   [TriggerEvent.USER_UPDATED]: BasePayload.extend({
-    oldUsername: z40.string(),
-    newUsername: z40.string()
+    oldUsername: import_zod38.z.string(),
+    newUsername: import_zod38.z.string()
   }),
   [TriggerEvent.USERNAME_REMINDER]: BasePayload.extend({
-    username: z40.string()
+    username: import_zod38.z.string()
   }),
   [TriggerEvent.RESET_PASSWORD]: BasePayload.extend({
-    code: z40.string()
+    code: import_zod38.z.string()
   }),
   [TriggerEvent.RESET_PASSWORD_BY_ADMIN]: BasePayload.extend({
-    temporaryPassword: z40.string(),
-    admin: z40.object({
-      id: z40.string(),
+    temporaryPassword: import_zod38.z.string(),
+    admin: import_zod38.z.object({
+      id: import_zod38.z.string(),
       name: NameFieldValue,
-      role: z40.string()
+      role: import_zod38.z.string()
     })
   }),
   [TriggerEvent.TWO_FA]: BasePayload.extend({
-    code: z40.string()
+    code: import_zod38.z.string()
   }),
   [TriggerEvent.ALL_USER_NOTIFICATION]: BasePayload.extend({
-    subject: z40.string(),
-    body: z40.string()
+    subject: import_zod38.z.string(),
+    body: import_zod38.z.string()
   }),
   [TriggerEvent.CHANGE_PHONE_NUMBER]: BasePayload.extend({
-    code: z40.string()
+    code: import_zod38.z.string()
   }),
   [TriggerEvent.CHANGE_EMAIL_ADDRESS]: BasePayload.extend({
-    code: z40.string()
+    code: import_zod38.z.string()
   })
 };
 async function triggerUserEventNotification({
@@ -6703,6 +6655,3 @@ function parseUserEventTrigger(event2, body) {
   const schema = TriggerPayload[event2];
   return schema.parse(body);
 }
-
-// src/notification/index.ts
-z41.globalRegistry.clear();