@opencrvs/toolkit 1.8.0-rc.f876361 → 1.8.0-rc.f8e4107

package/dist/events/index.js

@@ -49,6 +49,7 @@ __export(events_exports, {
   AdvancedSearchConfig: () => AdvancedSearchConfig,
   ApproveCorrectionActionInput: () => ApproveCorrectionActionInput,
   ArchiveActionInput: () => ArchiveActionInput,
+  AssignActionInput: () => AssignActionInput,
   AsyncRejectActionDocument: () => AsyncRejectActionDocument,
   BaseActionInput: () => BaseActionInput,
   CertificateConfig: () => CertificateConfig,
@@ -68,12 +69,13 @@ __export(events_exports, {
   DeclarationUpdateActions: () => DeclarationUpdateActions,
   DeclareActionInput: () => DeclareActionInput,
   DeduplicationConfig: () => DeduplicationConfig,
+  DisplayOnReviewConditional: () => DisplayOnReviewConditional,
   Draft: () => Draft,
   DraftInput: () => DraftInput,
   EmailField: () => EmailField,
   EmailValue: () => EmailValue,
   EnableConditional: () => EnableConditional,
-  EventConfig: () => EventConfig,
+  EventConfig: () => EventConfig2,
   EventDocument: () => EventDocument,
   EventIndex: () => EventIndex,
   EventInput: () => EventInput,
@@ -81,7 +83,9 @@ __export(events_exports, {
   EventSearchIndex: () => EventSearchIndex,
   EventStatus: () => EventStatus,
   EventStatuses: () => EventStatuses,
+  FieldConditional: () => FieldConditional,
   FieldConfig: () => FieldConfig,
+  FieldConfigSchema: () => FieldConfigSchema,
   FieldType: () => FieldType,
   FieldUpdateValue: () => FieldUpdateValue,
   FieldValue: () => FieldValue,
@@ -100,9 +104,10 @@ __export(events_exports, {
   NotifyActionInput: () => NotifyActionInput,
   NumberFieldValue: () => NumberFieldValue,
   PageConfig: () => PageConfig,
-  PageConfigBase: () => PageConfigBase,
   PageTypes: () => PageTypes,
   PrintCertificateActionInput: () => PrintCertificateActionInput,
+  QueryInput: () => QueryInput,
+  QueryType: () => QueryType,
   ReadActionInput: () => ReadActionInput,
   RegisterAction: () => RegisterAction,
   RegisterActionInput: () => RegisterActionInput,
@@ -113,10 +118,12 @@ __export(events_exports, {
   ResolvedUser: () => ResolvedUser,
   RuralAddressUpdateValue: () => RuralAddressUpdateValue,
   RuralAddressValue: () => RuralAddressValue,
+  SelectOption: () => SelectOption,
   ShowConditional: () => ShowConditional,
   SummaryConfig: () => SummaryConfig,
   TextValue: () => TextValue,
   TranslationConfig: () => TranslationConfig,
+  UnassignActionInput: () => UnassignActionInput,
   UrbanAddressUpdateValue: () => UrbanAddressUpdateValue,
   UrbanAddressValue: () => UrbanAddressValue,
   ValidateActionInput: () => ValidateActionInput,
@@ -136,10 +143,12 @@ __export(events_exports, {
   defineConditional: () => defineConditional,
   defineConfig: () => defineConfig,
   defineDeclarationForm: () => defineDeclarationForm,
+  defineFormConditional: () => defineFormConditional,
   defineFormPage: () => defineFormPage,
   definePage: () => definePage,
   errorMessages: () => errorMessages,
   event: () => event,
+  eventField: () => eventField,
   eventMetadataLabelMap: () => eventMetadataLabelMap,
   eventPayloadGenerator: () => eventPayloadGenerator,
   eventQueryDataGenerator: () => eventQueryDataGenerator,
@@ -147,11 +156,11 @@ __export(events_exports, {
   field: () => field,
   fieldTypes: () => fieldTypes,
   findActiveDrafts: () => findActiveDrafts,
-  findAllFields: () => findAllFields,
+  findLastAssignmentAction: () => findLastAssignmentAction,
   findRecordActionPages: () => findRecordActionPages,
+  generateActionAnnotationInput: () => generateActionAnnotationInput,
+  generateActionDeclarationInput: () => generateActionDeclarationInput,
   generateActionDocument: () => generateActionDocument,
-  generateActionInput: () => generateActionInput,
-  generateActionMetadataInput: () => generateActionMetadataInput,
   generateEventDocument: () => generateEventDocument,
   generateEventDraftDocument: () => generateEventDraftDocument,
   generateTransactionId: () => generateTransactionId,
@@ -162,13 +171,13 @@ __export(events_exports, {
   getActionReview: () => getActionReview,
   getActionReviewFields: () => getActionReviewFields,
   getAllAnnotationFields: () => getAllAnnotationFields,
+  getAnnotationFromDrafts: () => getAnnotationFromDrafts,
   getCurrentEventState: () => getCurrentEventState,
   getCurrentEventStateWithDrafts: () => getCurrentEventStateWithDrafts,
   getDeclaration: () => getDeclaration,
   getDeclarationFields: () => getDeclarationFields,
   getDeclarationPages: () => getDeclarationPages,
   getFieldValidationErrors: () => getFieldValidationErrors,
-  getVisiblePagesFormFields: () => getVisiblePagesFormFields,
   isAddressFieldType: () => isAddressFieldType,
   isAdministrativeAreaFieldType: () => isAdministrativeAreaFieldType,
   isBulletListFieldType: () => isBulletListFieldType,
@@ -180,6 +189,7 @@ __export(events_exports, {
   isEmailFieldType: () => isEmailFieldType,
   isFacilityFieldType: () => isFacilityFieldType,
   isFieldConfigDefaultValue: () => isFieldConfigDefaultValue,
+  isFieldDisplayedOnReview: () => isFieldDisplayedOnReview,
   isFieldEnabled: () => isFieldEnabled,
   isFieldValue: () => isFieldValue,
   isFieldValueWithoutTemplates: () => isFieldValueWithoutTemplates,
@@ -200,16 +210,20 @@ __export(events_exports, {
   isTextFieldType: () => isTextFieldType,
   isUndeclaredDraft: () => isUndeclaredDraft,
   isVerificationPage: () => isVerificationPage,
+  isWriteAction: () => isWriteAction,
   mapFieldTypeToEmptyValue: () => mapFieldTypeToEmptyValue,
   mapFieldTypeToMockValue: () => mapFieldTypeToMockValue,
   mapFieldTypeToZod: () => mapFieldTypeToZod,
+  never: () => never,
   not: () => not,
+  omitHiddenFields: () => omitHiddenFields,
+  omitHiddenPaginatedFields: () => omitHiddenPaginatedFields,
   or: () => or,
-  stripHiddenFields: () => stripHiddenFields,
   user: () => user,
   validate: () => validate,
   validateFieldInput: () => validateFieldInput,
-  validateWorkqueueConfig: () => validateWorkqueueConfig
+  validateWorkqueueConfig: () => validateWorkqueueConfig,
+  writeActions: () => writeActions
 });
 module.exports = __toCommonJS(events_exports);
 
@@ -218,29 +232,46 @@ var import_zod9 = require("zod");
 
 // ../commons/src/events/Conditional.ts
 var import_zod = require("zod");
-function Conditional() {
-  return import_zod.z.custom((val) => typeof val === "object" && val !== null);
-}
+var Conditional = import_zod.z.custom(
+  (val) => typeof val === "object" && val !== null
+);
 var ConditionalType = {
-  /** When 'SHOW' conditional is defined, the action is shown to the user only if the condition is met */
   SHOW: "SHOW",
-  /** If 'ENABLE' conditional is defined, the action is enabled only if the condition is met */
-  ENABLE: "ENABLE"
+  ENABLE: "ENABLE",
+  DISPLAY_ON_REVIEW: "DISPLAY_ON_REVIEW"
 };
 var ShowConditional = import_zod.z.object({
   type: import_zod.z.literal(ConditionalType.SHOW),
-  conditional: Conditional()
-});
+  conditional: Conditional
+}).describe(
+  "If 'SHOW' conditional is defined, the component is shown to the user only if the condition is met"
+);
 var EnableConditional = import_zod.z.object({
   type: import_zod.z.literal(ConditionalType.ENABLE),
-  conditional: Conditional()
-});
+  conditional: Conditional
+}).describe(
+  "If 'ENABLE' conditional is defined, the component is enabled only if the condition is met"
+);
 var ActionConditional = import_zod.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 = import_zod.z.object({
+  type: import_zod.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 = import_zod.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
+]);
 
 // ../commons/src/events/PageConfig.ts
 var import_zod6 = require("zod");
@@ -428,14 +459,14 @@ var BaseField = import_zod5.z.object({
     ]),
     DependencyExpression
   ]).optional(),
-  conditionals: import_zod5.z.array(ActionConditional).default([]).optional(),
+  conditionals: import_zod5.z.array(FieldConditional).default([]).optional(),
   required: import_zod5.z.boolean().default(false).optional(),
   disabled: import_zod5.z.boolean().default(false).optional(),
   hidden: import_zod5.z.boolean().default(false).optional(),
   placeholder: TranslationConfig.optional(),
   validation: import_zod5.z.array(
     import_zod5.z.object({
-      validator: Conditional(),
+      validator: Conditional,
       message: TranslationConfig
     })
   ).default([]).optional(),
@@ -668,6 +699,7 @@ var FieldConfig = import_zod5.z.discriminatedUnion("type", [
   EmailField,
   FileUploadWithOptions,
   DataField
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ]);
 
 // ../commons/src/events/PageConfig.ts
@@ -676,7 +708,7 @@ var PageConfigBase = import_zod6.z.object({
   id: import_zod6.z.string().describe("Unique identifier for the page"),
   title: TranslationConfig.describe("Header title of the page"),
   fields: import_zod6.z.array(FieldConfig).describe("Fields to be rendered on the page"),
-  conditional: Conditional().optional().describe(
+  conditional: Conditional.optional().describe(
     "Page will be shown if condition is met. If conditional is not defined, the page will be always shown."
   )
 });
@@ -772,6 +804,12 @@ var DeclarationUpdateActions = ActionTypes.extract(
   declarationUpdateActionValues
 );
 var annotationActions = ActionTypes.exclude(declarationActionValues);
+var writeActions = ActionTypes.exclude([
+  ActionType.CREATE,
+  ActionType.READ,
+  ActionType.ASSIGN,
+  ActionType.UNASSIGN
+]);
 
 // ../commons/src/events/FormConfig.ts
 var import_zod8 = require("zod");
@@ -918,7 +956,7 @@ var LanguageConfig = import_zod11.z.object({
 });
 
 // ../commons/src/events/EventConfig.ts
-var import_zod20 = require("zod");
+var import_zod17 = require("zod");
 
 // ../commons/src/events/DeduplicationConfig.ts
 var import_zod12 = require("zod");
@@ -965,10 +1003,12 @@ var DateDistanceMatcher = Matcher.extend({
 });
 var And = import_zod12.z.object({
   type: import_zod12.z.literal("and"),
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
   clauses: import_zod12.z.lazy(() => Clause.array())
 });
 var Or = import_zod12.z.object({
   type: import_zod12.z.literal("or"),
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
   clauses: import_zod12.z.lazy(() => Clause.array())
 });
 var Clause = import_zod12.z.lazy(
@@ -1031,7 +1071,8 @@ var EventMetadata = import_zod14.z.object({
   createdAt: import_zod14.z.string().datetime(),
   createdBy: import_zod14.z.string(),
   createdAtLocation: import_zod14.z.string(),
-  modifiedAt: import_zod14.z.string().datetime(),
+  updatedAtLocation: import_zod14.z.string(),
+  updatedAt: import_zod14.z.string().datetime(),
   assignedTo: import_zod14.z.string().nullish(),
   updatedBy: import_zod14.z.string(),
   trackingId: import_zod14.z.string(),
@@ -1053,6 +1094,11 @@ var eventMetadataLabelMap = {
     defaultMessage: "Location",
     description: "Created At Location"
   },
+  "event.updatedAtLocation": {
+    id: "event.updatedAtLocation.label",
+    defaultMessage: "Location",
+    description: "Updated At"
+  },
   "event.createdBy": {
     id: "event.createdBy.label",
     defaultMessage: "Created By",
@@ -1063,7 +1109,7 @@ var eventMetadataLabelMap = {
     defaultMessage: "ID",
     description: "ID"
   },
-  "event.modifiedAt": {
+  "event.updatedAt": {
     id: "event.modifiedAt.label",
     defaultMessage: "Updated",
     description: "Modified At"
@@ -1107,847 +1153,194 @@ var WorkqueueConfig = import_zod15.z.object({
 
 // ../commons/src/events/AdvancedSearchConfig.ts
 var import_zod16 = require("zod");
+var FieldType2 = import_zod16.z.enum(["FUZZY", "EXACT", "RANGE"]);
+var FieldConfigSchema = import_zod16.z.object({
+  fieldId: import_zod16.z.string(),
+  config: import_zod16.z.object({
+    type: FieldType2.describe("Determines the type of field")
+  }),
+  options: import_zod16.z.array(SelectOption).optional()
+});
 var AdvancedSearchConfig = import_zod16.z.object({
   title: TranslationConfig.describe("Advanced search tab title"),
-  fields: import_zod16.z.array(
-    import_zod16.z.object({
-      fieldId: import_zod16.z.string(),
-      config: import_zod16.z.object({
-        type: import_zod16.z.enum(["FUZZY", "EXACT", "RANGE"]).describe("Determines the type of field")
-      }).optional().describe("Configuration options for the field")
-    })
-  ).optional().default([]).describe("Advanced search fields.")
+  fields: import_zod16.z.array(FieldConfigSchema).optional().default([]).describe("Advanced search fields.")
 });
 
-// ../commons/src/events/utils.ts
+// ../commons/src/utils.ts
 var import_lodash = require("lodash");
-
-// ../commons/src/workqueues/WorkqueueConfig.ts
-var import_zod18 = require("zod");
-
-// ../commons/src/workqueues/defaultColumns.ts
-var import_zod17 = require("zod");
-var WorkQueueColumnConfig = import_zod17.z.object({
-  id: import_zod17.z.string(),
-  label: TranslationConfig
-});
-var defaultColumns = {
-  event: {
-    id: "event",
-    label: {
-      defaultMessage: "Event",
-      description: "This is the label for the workqueue column",
-      id: "workqueue.default.column.event"
-    }
-  },
-  status: {
-    id: "status",
-    label: {
-      defaultMessage: "Status",
-      description: "This is the label for the workqueue column",
-      id: "workqueue.default.column.status"
-    }
-  },
-  createdAt: {
-    id: "createdAt",
-    label: {
-      defaultMessage: "Created",
-      description: "This is the label for the workqueue column",
-      id: "workqueue.default.column.createdAt"
-    }
-  },
-  modifiedAt: {
-    id: "modifiedAt",
-    label: {
-      defaultMessage: "Modified",
-      description: "This is the label for the workqueue column",
-      id: "workqueue.default.column.modifiedAt"
-    }
+function getOrThrow(x, message) {
+  if (x === void 0 || x === null) {
+    throw new Error(message);
   }
+  return x;
+}
+var findAllFields = (config) => {
+  return (0, import_lodash.flattenDeep)([
+    ...getDeclarationFields(config),
+    ...getAllAnnotationFields(config)
+  ]);
 };
-var DefaultColumnKeys = import_zod17.z.enum(
-  Object.keys(defaultColumns)
-);
-
-// ../commons/src/workqueues/WorkqueueConfig.ts
-var rootWorkqueueConfig = import_zod18.z.object({
-  id: import_zod18.z.string(),
-  title: TranslationConfig,
-  columns: import_zod18.z.array(WorkQueueColumnConfig),
-  defaultColumns: import_zod18.z.array(DefaultColumnKeys)
-});
-var defineWorkqueue = (config) => rootWorkqueueConfig.parse(config);
+var metadataFields = ["trackingId", "status"];
 
-// ../commons/src/workqueues/all.ts
-var allWorkqueue = defineWorkqueue({
-  id: "all",
-  title: {
-    defaultMessage: "All events",
-    description: "This is the label for the workqueue",
-    id: "workqueue.all.label"
-  },
-  columns: [
-    {
-      id: "title",
-      label: {
-        defaultMessage: "Title",
-        description: "This is the label for the workqueue column",
-        id: "workqueue.all.column.title"
-      }
-    }
-  ],
-  defaultColumns: ["event", "status", "createdAt", "modifiedAt"]
+// ../commons/src/events/EventConfig.ts
+var EventConfig2 = import_zod17.z.object({
+  id: import_zod17.z.string().describe(
+    'A machine-readable identifier for the event, e.g. "birth" or "death"'
+  ),
+  summary: SummaryConfig,
+  label: TranslationConfig,
+  actions: import_zod17.z.array(ActionConfig),
+  declaration: DeclarationFormConfig,
+  workqueues: import_zod17.z.array(WorkqueueConfig),
+  deduplication: import_zod17.z.array(DeduplicationConfig).optional().default([]),
+  advancedSearch: import_zod17.z.array(AdvancedSearchConfig).optional().default([])
+}).superRefine((event2, ctx) => {
+  const allFields = findAllFields(event2);
+  const fieldIds = allFields.map((field2) => field2.id);
+  const advancedSearchFields = event2.advancedSearch.flatMap(
+    (section) => section.fields.flatMap((field2) => field2.fieldId)
+  );
+  const advancedSearchFieldsSet = new Set(advancedSearchFields);
+  if (advancedSearchFieldsSet.size !== advancedSearchFields.length) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Advanced search field ids must be unique",
+      path: ["advancedSearch"]
+    });
+  }
+  const invalidFields = event2.advancedSearch.flatMap(
+    (section) => (
+      // Check if the fieldId is not in the fieldIds array
+      // and also not in the metadataFields array
+      section.fields.filter(
+        (field2) => !(fieldIds.includes(field2.fieldId) || Boolean(metadataFields.find((f) => f === field2.fieldId)))
+      )
+    )
+  );
+  if (invalidFields.length > 0) {
+    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(", ")}`,
+      path: ["advancedSearch"]
+    });
+  }
 });
 
-// ../commons/src/workqueues/readyForReview.ts
-var inReviewWorkqueue = defineWorkqueue({
-  id: "ready-for-review",
-  title: {
-    defaultMessage: "Ready for review",
-    description: "Label for in review workqueue",
-    id: "event.workqueue.in-review.label"
-  },
-  columns: [
-    {
-      id: "title",
-      label: {
-        defaultMessage: "Title",
-        description: "This is the label for the workqueue column",
-        id: "workqueue.in-reveiw.column.title"
-      }
-    }
-  ],
-  defaultColumns: ["event", "createdAt", "modifiedAt"]
-});
+// ../commons/src/events/EventConfigInput.ts
+var defineDeclarationForm = (form) => DeclarationFormConfig.parse(form);
+var defineActionForm = (actionForm) => ActionFormConfig.parse(actionForm);
+var definePage = (page) => PageConfig.parse(page);
+var defineFormPage = (formPage) => FormPageConfig.parse(formPage);
 
-// ../commons/src/workqueues/readyToPrint.ts
-var registeredWorkqueue = defineWorkqueue({
-  id: "registered",
-  title: {
-    defaultMessage: "Ready to print",
-    description: "Label for registered workqueue",
-    id: "event.workqueue.registered.label"
-  },
-  columns: [
-    {
-      id: "title",
-      label: {
-        defaultMessage: "Title",
-        description: "This is the label for the workqueue column",
-        id: "workqueue.registered.column.title"
-      }
-    }
-  ],
-  defaultColumns: ["event", "createdAt", "modifiedAt"]
-});
+// ../commons/src/events/Draft.ts
+var import_zod20 = require("zod");
 
-// ../commons/src/workqueues/index.ts
-var workqueues = {
-  all: allWorkqueue,
-  registered: registeredWorkqueue,
-  inReview: inReviewWorkqueue
+// ../commons/src/events/ActionDocument.ts
+var import_zod18 = require("zod");
+var ActionUpdate = import_zod18.z.record(import_zod18.z.string(), FieldUpdateValue);
+var ActionStatus = {
+  Requested: "Requested",
+  Accepted: "Accepted",
+  Rejected: "Rejected"
 };
-
-// ../commons/src/conditionals/validate.ts
-var import_ajv = __toESM(require("ajv"));
-var import_ajv_formats = __toESM(require("ajv-formats"));
-var import_date_fns = require("date-fns");
-
-// ../commons/src/events/FieldTypeMapping.ts
-var import_zod19 = require("zod");
-function mapFieldTypeToZod(type, required) {
-  let schema;
-  switch (type) {
-    case FieldType.DATE:
-      schema = DateValue;
-      break;
-    case FieldType.EMAIL:
-      schema = EmailValue;
-      break;
-    case FieldType.TEXT:
-    case FieldType.TEXTAREA:
-    case FieldType.DIVIDER:
-    case FieldType.BULLET_LIST:
-    case FieldType.PAGE_HEADER:
-    case FieldType.LOCATION:
-    case FieldType.SELECT:
-    case FieldType.COUNTRY:
-    case FieldType.RADIO_GROUP:
-    case FieldType.PARAGRAPH:
-    case FieldType.ADMINISTRATIVE_AREA:
-    case FieldType.FACILITY:
-    case FieldType.OFFICE:
-    case FieldType.SIGNATURE:
-    case FieldType.HIDDEN:
-      schema = required ? RequiredTextValue : TextValue;
-      break;
-    case FieldType.NUMBER:
-      schema = NumberFieldValue;
-      break;
-    case FieldType.CHECKBOX:
-      schema = CheckboxFieldValue;
-      break;
-    case FieldType.FILE:
-      schema = FileFieldValue;
-      break;
-    case FieldType.FILE_WITH_OPTIONS:
-      schema = FileFieldWithOptionValue;
-      break;
-    case FieldType.ADDRESS:
-      schema = AddressFieldUpdateValue;
-      break;
-    case FieldType.DATA:
-      schema = DataFieldValue;
-      break;
-  }
-  return required ? schema : schema.nullish();
-}
-function createValidationSchema(config) {
-  const shape = {};
-  for (const field2 of config) {
-    shape[field2.id] = mapFieldTypeToZod(field2.type, field2.required);
-  }
-  return import_zod19.z.object(shape);
-}
-function mapFieldTypeToMockValue(field2, i) {
-  switch (field2.type) {
-    case FieldType.DIVIDER:
-    case FieldType.TEXT:
-    case FieldType.TEXTAREA:
-    case FieldType.BULLET_LIST:
-    case FieldType.PAGE_HEADER:
-    case FieldType.LOCATION:
-    case FieldType.SELECT:
-    case FieldType.COUNTRY:
-    case FieldType.RADIO_GROUP:
-    case FieldType.SIGNATURE:
-    case FieldType.PARAGRAPH:
-    case FieldType.ADMINISTRATIVE_AREA:
-    case FieldType.FACILITY:
-    case FieldType.OFFICE:
-      return `${field2.id}-${field2.type}-${i}`;
-    case FieldType.NUMBER:
-      return 19;
-    case FieldType.EMAIL:
-      return "test@opencrvs.org";
-    case FieldType.ADDRESS:
-      return {
-        country: "FAR",
-        addressType: AddressType.DOMESTIC,
-        province: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
-        district: "5ef450bc-712d-48ad-93f3-8da0fa453baa",
-        urbanOrRural: "URBAN",
-        town: "Example Town",
-        residentialArea: "Example Residential Area",
-        street: "Example Street",
-        number: "55",
-        zipCode: "123456"
-      };
-    case FieldType.DATE:
-      return "2021-01-01";
-    case FieldType.CHECKBOX:
-      return true;
-    case FieldType.FILE:
-      return {
-        filename: "4f095fc4-4312-4de2-aa38-86dcc0f71044.png",
-        originalFilename: "abcd.png",
-        type: "image/png"
-      };
-    case FieldType.FILE_WITH_OPTIONS:
-      return null;
-    case FieldType.DATA:
-      return {};
-  }
-}
-function mapFieldTypeToEmptyValue(field2) {
-  switch (field2.type) {
-    case FieldType.DIVIDER:
-    case FieldType.TEXT:
-    case FieldType.TEXTAREA:
-    case FieldType.BULLET_LIST:
-    case FieldType.PAGE_HEADER:
-    case FieldType.LOCATION:
-    case FieldType.SELECT:
-    case FieldType.COUNTRY:
-    case FieldType.RADIO_GROUP:
-    case FieldType.SIGNATURE:
-    case FieldType.PARAGRAPH:
-    case FieldType.ADMINISTRATIVE_AREA:
-    case FieldType.FACILITY:
-    case FieldType.OFFICE:
-    case FieldType.NUMBER:
-    case FieldType.EMAIL:
-    case FieldType.DATE:
-    case FieldType.CHECKBOX:
-    case FieldType.DATA:
-      return null;
-    case FieldType.ADDRESS:
-      return {
-        country: null,
-        addressType: AddressType.DOMESTIC,
-        province: null,
-        district: null,
-        urbanOrRural: "URBAN",
-        // Default to urban needed for validation
-        town: null,
-        residentialArea: null,
-        street: null,
-        number: null,
-        zipCode: null
-      };
-    case FieldType.FILE:
-      return {
-        filename: "",
-        originalFilename: "",
-        type: ""
-      };
-    case FieldType.FILE_WITH_OPTIONS:
-      return [];
-  }
-}
-var isParagraphFieldType = (field2) => {
-  return field2.config.type === FieldType.PARAGRAPH;
-};
-var isDateFieldType = (field2) => {
-  return field2.config.type === FieldType.DATE;
-};
-var isPageHeaderFieldType = (field2) => {
-  return field2.config.type === FieldType.PAGE_HEADER;
-};
-var isTextFieldType = (field2) => {
-  return field2.config.type === FieldType.TEXT;
-};
-var isNumberFieldType = (field2) => {
-  return field2.config.type === FieldType.NUMBER;
-};
-var isTextAreaFieldType = (field2) => {
-  return field2.config.type === FieldType.TEXTAREA;
-};
-var isSignatureFieldType = (field2) => {
-  return field2.config.type === FieldType.SIGNATURE;
-};
-var isEmailFieldType = (field2) => {
-  return field2.config.type === FieldType.EMAIL;
-};
-var isFileFieldType = (field2) => {
-  return field2.config.type === FieldType.FILE;
-};
-var isFileFieldWithOptionType = (field2) => {
-  return field2.config.type === FieldType.FILE_WITH_OPTIONS;
-};
-var isBulletListFieldType = (field2) => {
-  return field2.config.type === FieldType.BULLET_LIST;
-};
-var isSelectFieldType = (field2) => {
-  return field2.config.type === FieldType.SELECT;
-};
-var isAddressFieldType = (field2) => {
-  return field2.config.type === FieldType.ADDRESS;
-};
-var isCountryFieldType = (field2) => {
-  return field2.config.type === FieldType.COUNTRY;
-};
-var isCheckboxFieldType = (field2) => {
-  return field2.config.type === FieldType.CHECKBOX;
-};
-var isRadioGroupFieldType = (field2) => {
-  return field2.config.type === FieldType.RADIO_GROUP;
-};
-var isLocationFieldType = (field2) => {
-  return field2.config.type === FieldType.LOCATION;
-};
-var isDividerFieldType = (field2) => {
-  return field2.config.type === FieldType.DIVIDER;
-};
-var isAdministrativeAreaFieldType = (field2) => {
-  return field2.config.type === FieldType.ADMINISTRATIVE_AREA;
-};
-var isFacilityFieldType = (field2) => {
-  return field2.config.type === FieldType.FACILITY;
-};
-var isOfficeFieldType = (field2) => {
-  return field2.config.type === FieldType.OFFICE;
-};
-var isDataFieldType = (field2) => {
-  return field2.config.type === FieldType.DATA;
-};
-
-// ../commons/src/conditionals/validate.ts
-var ajv = new import_ajv.default({
-  $data: true,
-  allowUnionTypes: true
-});
-(0, import_ajv_formats.default)(ajv);
-function validate(schema, data) {
-  return ajv.validate(schema, data);
-}
-function getConditionalActionsForField(field2, values) {
-  if (!field2.conditionals) {
-    return [];
-  }
-  return field2.conditionals.filter((conditional) => validate(conditional.conditional, values)).map((conditional) => conditional.type);
-}
-function isFieldConditionMet(field2, form, conditionalType) {
-  const hasRule = (field2.conditionals ?? []).some(
-    (conditional) => conditional.type === conditionalType
-  );
-  if (!hasRule) {
-    return true;
-  }
-  const validConditionals = getConditionalActionsForField(field2, {
-    $form: form,
-    $now: (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), {
-      representation: "date"
-    })
-  });
-  return validConditionals.includes(conditionalType);
-}
-function isFieldVisible(field2, form) {
-  return isFieldConditionMet(field2, form, ConditionalType.SHOW);
-}
-function isFieldEnabled(field2, form) {
-  return isFieldConditionMet(field2, form, ConditionalType.ENABLE);
-}
-var errorMessages = {
-  hiddenField: {
-    id: "v2.error.hidden",
-    defaultMessage: "Hidden or disabled field should not receive a value",
-    description: "Error message when field is hidden or disabled, but a value was received"
-  },
-  invalidDate: {
-    defaultMessage: "Invalid date field",
-    description: "Error message when date field is invalid",
-    id: "v2.error.invalidDate"
-  },
-  invalidEmail: {
-    defaultMessage: "Invalid email address",
-    description: "Error message when email address is invalid",
-    id: "v2.error.invalidEmail"
-  },
-  requiredField: {
-    defaultMessage: "Required for registration",
-    description: "Error message when required field is missing",
-    id: "v2.error.required"
-  },
-  invalidInput: {
-    defaultMessage: "Invalid input",
-    description: "Error message when generic field is invalid",
-    id: "v2.error.invalid"
-  }
-};
-var createIntlError = (message) => ({
-  message: {
-    message
-  }
-});
-var zodToIntlErrorMap = (issue, _ctx) => {
-  switch (issue.code) {
-    case "invalid_string": {
-      if (_ctx.data === "") {
-        return createIntlError(errorMessages.requiredField);
-      }
-      if (issue.validation === "date") {
-        return createIntlError(errorMessages.invalidDate);
-      }
-      if (issue.validation === "email") {
-        return createIntlError(errorMessages.invalidEmail);
-      }
-      break;
-    }
-    case "invalid_type": {
-      if (issue.expected !== issue.received && issue.received === "undefined") {
-        return createIntlError(errorMessages.requiredField);
-      }
-      break;
-    }
-    case "too_small": {
-      if (issue.message === void 0) {
-        return createIntlError(errorMessages.requiredField);
-      }
-      break;
-    }
-    case "invalid_union": {
-      for (const { issues } of issue.unionErrors) {
-        for (const e of issues) {
-          if (zodToIntlErrorMap(e, _ctx).message.message.id !== "v2.error.required") {
-            return createIntlError(errorMessages.invalidInput);
-          }
-        }
-      }
-      return createIntlError(errorMessages.requiredField);
-    }
-  }
-  return createIntlError(errorMessages.invalidInput);
-};
-function getFieldValidationErrors({
-  field: field2,
-  values
-}) {
-  const conditionalParameters = {
-    $form: values,
-    $now: (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" })
-  };
-  if (!isFieldVisible(field2, values) || !isFieldEnabled(field2, values)) {
-    if (values[field2.id]) {
-      return {
-        errors: [
-          {
-            message: errorMessages.hiddenField
-          }
-        ]
-      };
-    }
-    return {
-      errors: []
-    };
-  }
-  const fieldValidationResult = validateFieldInput({
-    field: field2,
-    value: values[field2.id]
-  });
-  const customValidationResults = runCustomFieldValidations({
-    field: field2,
-    conditionalParameters
-  });
-  return {
-    // Assumes that custom validation errors are based on the field type, and extend the validation.
-    errors: [...fieldValidationResult, ...customValidationResults]
-  };
-}
-function runCustomFieldValidations({
-  field: field2,
-  conditionalParameters
-}) {
-  return (field2.validation ?? []).filter((validation) => {
-    return !validate(validation.validator, conditionalParameters);
-  }).map((validation) => ({ message: validation.message }));
-}
-function validateFieldInput({
-  field: field2,
-  value
-}) {
-  const rawError = mapFieldTypeToZod(field2.type, field2.required).safeParse(
-    value,
-    {
-      // @ts-expect-error
-      errorMap: zodToIntlErrorMap
-    }
-  );
-  return rawError.error?.issues.map((issue) => issue.message) ?? [];
-}
-
-// ../commons/src/uuid.ts
-var import_uuid = require("uuid");
-function getUUID() {
-  return (0, import_uuid.v4)();
-}
-
-// ../commons/src/events/utils.ts
-var import_date_fns2 = require("date-fns");
-
-// ../commons/src/utils.ts
-function getOrThrow(x, message) {
-  if (x === void 0 || x === null) {
-    throw new Error(message);
-  }
-  return x;
-}
-
-// ../commons/src/events/utils.ts
-var findAllFields = (config) => {
-  return (0, import_lodash.flattenDeep)([
-    ...getDeclarationFields(config),
-    ...getAllAnnotationFields(config)
-  ]);
-};
-var getAllAnnotationFields = (config) => {
-  return (0, import_lodash.flattenDeep)(config.actions.map(getActionAnnotationFields));
-};
-var getActionAnnotationFields = (actionConfig) => {
-  if (actionConfig.type === ActionType.REQUEST_CORRECTION) {
-    return [
-      ...actionConfig.onboardingForm.flatMap(({ fields }) => fields),
-      ...actionConfig.additionalDetailsForm.flatMap(({ fields }) => fields)
-    ];
-  }
-  if (actionConfig.type === ActionType.PRINT_CERTIFICATE) {
-    return actionConfig?.printForm.pages.flatMap(({ fields }) => fields) ?? [];
-  }
-  if (isDeclarationActionConfig(actionConfig)) {
-    return actionConfig?.review.fields ?? [];
-  }
-  return [];
-};
-var findRecordActionPages = (config, actionType) => {
-  const action = config.actions.find((a) => a.type === actionType);
-  if (action?.type === ActionType.REQUEST_CORRECTION) {
-    return [...action.onboardingForm, ...action.additionalDetailsForm];
-  }
-  if (action?.type === ActionType.PRINT_CERTIFICATE) {
-    return action.printForm.pages;
-  }
-  return [];
-};
-function isDeclarationActionConfig(action) {
-  return DeclarationActions.safeParse(action.type).success;
-}
-function getDeclarationFields(configuration) {
-  return configuration.declaration.pages.flatMap(({ fields }) => fields);
-}
-function getDeclarationPages(configuration) {
-  return configuration.declaration.pages;
-}
-function getDeclaration(configuration) {
-  return configuration.declaration;
-}
-function getActionReviewFields(configuration, actionType) {
-  return getActionReview(configuration, actionType).fields;
-}
-function getActionReview(configuration, actionType) {
-  const [actionConfig] = configuration.actions.filter(
-    (a) => a.type === actionType
-  );
-  return getOrThrow(
-    actionConfig?.review,
-    `No review config found for ${actionType}`
-  );
-}
-function validateWorkqueueConfig(workqueueConfigs) {
-  workqueueConfigs.map((workqueue) => {
-    const rootWorkqueue = Object.values(workqueues).find(
-      (wq) => wq.id === workqueue.id
-    );
-    if (!rootWorkqueue) {
-      throw new Error(
-        `Invalid workqueue configuration: workqueue not found with id: ${workqueue.id}`
-      );
-    }
-  });
-}
-function isPageVisible(page, formValues) {
-  if (!page.conditional) {
-    return true;
-  }
-  return validate(page.conditional, {
-    $form: formValues,
-    $now: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" })
-  });
-}
-var getVisiblePagesFormFields = (formConfig, formData) => {
-  return formConfig.pages.filter((p) => isPageVisible(p, formData)).flatMap((p) => p.fields);
-};
-function isOptionalUncheckedCheckbox(field2, form) {
-  if (field2.type !== FieldType.CHECKBOX || field2.required) {
-    return false;
-  }
-  return !form[field2.id];
-}
-function stripHiddenFields(fields, declaration) {
-  return (0, import_lodash.omitBy)(declaration, (_2, fieldId) => {
-    const field2 = fields.find((f) => f.id === fieldId);
-    if (!field2) {
-      return true;
-    }
-    if (isOptionalUncheckedCheckbox(field2, declaration)) {
-      return true;
-    }
-    return !isFieldVisible(field2, declaration);
-  });
-}
-function findActiveDrafts(event2, drafts) {
-  const actions = event2.actions.slice().filter(({ type }) => type !== ActionType.READ).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-  const lastAction = actions[actions.length - 1];
-  return drafts.filter(({ createdAt }) => createdAt >= lastAction.createdAt).filter(({ eventId }) => eventId === event2.id);
-}
-function createEmptyDraft(eventId, draftId, actionType) {
-  return {
-    id: draftId,
-    eventId,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    transactionId: getUUID(),
-    action: {
-      type: actionType,
-      declaration: {},
-      annotation: {},
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      createdBy: "@todo",
-      createdAtLocation: "@todo"
-    }
-  };
-}
-function isVerificationPage(page) {
-  return page.type === PageTypes.enum.VERIFICATION;
-}
-function deepMerge(currentDocument, actionDocument) {
-  return (0, import_lodash.mergeWith)(
-    currentDocument,
-    actionDocument,
-    (previousValue, incomingValue) => {
-      if (incomingValue === void 0) {
-        return previousValue;
-      }
-      if ((0, import_lodash.isArray)(incomingValue)) {
-        return incomingValue;
-      }
-      if ((0, import_lodash.isObject)(previousValue) && (0, import_lodash.isObject)(incomingValue)) {
-        return void 0;
-      }
-      return incomingValue;
-    }
-  );
-}
-
-// ../commons/src/events/EventConfig.ts
-var EventConfig = import_zod20.z.object({
-  id: import_zod20.z.string().describe(
-    'A machine-readable identifier for the event, e.g. "birth" or "death"'
-  ),
-  summary: SummaryConfig,
-  label: TranslationConfig,
-  actions: import_zod20.z.array(ActionConfig),
-  declaration: DeclarationFormConfig,
-  workqueues: import_zod20.z.array(WorkqueueConfig),
-  deduplication: import_zod20.z.array(DeduplicationConfig).optional().default([]),
-  advancedSearch: import_zod20.z.array(AdvancedSearchConfig).optional().default([])
-}).superRefine((event2, ctx) => {
-  const allFields = findAllFields(event2);
-  const fieldIds = allFields.map((field2) => field2.id);
-  const advancedSearchFields = event2.advancedSearch.flatMap(
-    (section) => section.fields.flatMap((field2) => field2.fieldId)
-  );
-  const advancedSearchFieldsSet = new Set(advancedSearchFields);
-  if (advancedSearchFieldsSet.size !== advancedSearchFields.length) {
-    ctx.addIssue({
-      code: "custom",
-      message: "Advanced search field ids must be unique",
-      path: ["advancedSearch"]
-    });
-  }
-  const invalidFields = event2.advancedSearch.flatMap(
-    (section) => section.fields.filter((field2) => !fieldIds.includes(field2.fieldId))
-  );
-  if (invalidFields.length > 0) {
-    ctx.addIssue({
-      code: "custom",
-      message: `Advanced search id must match a field id in fields array.
-    Invalid AdvancedSearch field IDs for event ${event2.id}: ${invalidFields.map((f) => f.fieldId).join(", ")}`,
-      path: ["advancedSearch"]
-    });
-  }
-});
-
-// ../commons/src/events/EventConfigInput.ts
-var defineDeclarationForm = (form) => DeclarationFormConfig.parse(form);
-var defineActionForm = (actionForm) => ActionFormConfig.parse(actionForm);
-var definePage = (page) => PageConfig.parse(page);
-var defineFormPage = (formPage) => FormPageConfig.parse(formPage);
-
-// ../commons/src/events/Draft.ts
-var import_zod23 = require("zod");
-
-// ../commons/src/events/ActionDocument.ts
-var import_zod21 = require("zod");
-var ActionUpdate = import_zod21.z.record(import_zod21.z.string(), FieldUpdateValue);
-var ActionStatus = {
-  Requested: "Requested",
-  Accepted: "Accepted",
-  Rejected: "Rejected"
-};
-var ActionBase = import_zod21.z.object({
-  id: import_zod21.z.string(),
-  createdAt: import_zod21.z.string().datetime(),
-  createdBy: import_zod21.z.string(),
+var ActionBase = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  createdAt: import_zod18.z.string().datetime(),
+  createdBy: import_zod18.z.string(),
   declaration: ActionUpdate,
   annotation: ActionUpdate.optional(),
-  createdAtLocation: import_zod21.z.string(),
-  status: import_zod21.z.enum([
+  createdAtLocation: import_zod18.z.string().optional(),
+  updatedAtLocation: import_zod18.z.string().optional(),
+  status: import_zod18.z.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
   ]),
   // If the action is an asynchronous confirmation for another action, we will save the original action id here.
-  originalActionId: import_zod21.z.string().optional()
+  originalActionId: import_zod18.z.string().optional()
 });
 var AssignedAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod21.z.string()
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.ASSIGN),
+    assignedTo: import_zod18.z.string()
   })
 );
 var UnassignedAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.UNASSIGN)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.UNASSIGN),
+    assignedTo: import_zod18.z.literal(null).default(null)
   })
 );
 var RegisterAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.REGISTER),
-    registrationNumber: import_zod21.z.string().optional()
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.REGISTER),
+    registrationNumber: import_zod18.z.string().optional()
   })
 );
 var DeclareAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.DECLARE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.DECLARE)
   })
 );
 var ValidateAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.VALIDATE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.VALIDATE)
   })
 );
 var RejectAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.REJECT)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.REJECT)
   })
 );
 var MarkAsDuplicateAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.MARKED_AS_DUPLICATE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.ARCHIVE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.ARCHIVE)
   })
 );
 var CreatedAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.CREATE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.CREATE)
   })
 );
 var NotifiedAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.NOTIFY)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.NOTIFY)
   })
 );
 var PrintCertificateAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.PRINT_CERTIFICATE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RequestedCorrectionAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.REQUEST_CORRECTION)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.REQUEST_CORRECTION)
   })
 );
 var ApprovedCorrectionAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.APPROVE_CORRECTION),
-    requestId: import_zod21.z.string()
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.APPROVE_CORRECTION),
+    requestId: import_zod18.z.string()
   })
 );
 var RejectedCorrectionAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.REJECT_CORRECTION),
-    requestId: import_zod21.z.string()
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.REJECT_CORRECTION),
+    requestId: import_zod18.z.string()
   })
 );
 var ReadAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.READ)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.READ)
   })
 );
-var ActionDocument = import_zod21.z.discriminatedUnion("type", [
+var ActionDocument = import_zod18.z.discriminatedUnion("type", [
   CreatedAction,
   ValidateAction,
   RejectAction,
@@ -1970,115 +1363,117 @@ var AsyncRejectActionDocument = ActionBase.omit({
   createdBy: true,
   createdAtLocation: true
 }).merge(
-  import_zod21.z.object({
-    type: import_zod21.z.enum(ConfirmableActions),
-    status: import_zod21.z.literal(ActionStatus.Rejected)
+  import_zod18.z.object({
+    type: import_zod18.z.enum(ConfirmableActions),
+    status: import_zod18.z.literal(ActionStatus.Rejected)
   })
 );
-var Action = import_zod21.z.union([ActionDocument, AsyncRejectActionDocument]);
-var ResolvedUser = import_zod21.z.object({
-  id: import_zod21.z.string(),
-  role: import_zod21.z.string(),
-  name: import_zod21.z.array(
-    import_zod21.z.object({
-      use: import_zod21.z.string(),
-      given: import_zod21.z.array(import_zod21.z.string()),
-      family: import_zod21.z.string()
+var Action = import_zod18.z.union([ActionDocument, AsyncRejectActionDocument]);
+var ResolvedUser = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  role: import_zod18.z.string(),
+  name: import_zod18.z.array(
+    import_zod18.z.object({
+      use: import_zod18.z.string(),
+      given: import_zod18.z.array(import_zod18.z.string()),
+      family: import_zod18.z.string()
     })
   )
 });
 
 // ../commons/src/events/ActionInput.ts
-var import_zod22 = require("zod");
-var BaseActionInput = import_zod22.z.object({
-  eventId: import_zod22.z.string(),
-  transactionId: import_zod22.z.string(),
-  declaration: ActionUpdate,
+var import_zod19 = require("zod");
+var BaseActionInput = import_zod19.z.object({
+  eventId: import_zod19.z.string(),
+  transactionId: import_zod19.z.string(),
+  declaration: ActionUpdate.default({}),
   annotation: ActionUpdate.optional(),
-  originalActionId: import_zod22.z.string().optional()
+  originalActionId: import_zod19.z.string().optional(),
+  keepAssignment: import_zod19.z.boolean().optional()
 });
 var CreateActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.CREATE).default(ActionType.CREATE),
-    createdAtLocation: import_zod22.z.string()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.CREATE).default(ActionType.CREATE),
+    createdAtLocation: import_zod19.z.string()
   })
 );
 var RegisterActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
-    registrationNumber: import_zod22.z.string().optional()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
+    registrationNumber: import_zod19.z.string().optional()
   })
 );
 var ValidateActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
-    duplicates: import_zod22.z.array(import_zod22.z.string())
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
+    duplicates: import_zod19.z.array(import_zod19.z.string())
   })
 );
 var NotifyActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
   })
 );
 var DeclareActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
   })
 );
 var PrintCertificateActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RejectDeclarationActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.REJECT).default(ActionType.REJECT)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.REJECT).default(ActionType.REJECT)
   })
 );
 var MarkedAsDuplicateActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE)
   })
 );
 var AssignActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
-    assignedTo: import_zod22.z.string()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
+    assignedTo: import_zod19.z.string()
   })
 );
 var UnassignActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
+    assignedTo: import_zod19.z.literal(null).default(null)
   })
 );
 var RequestCorrectionActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
   })
 );
 var RejectCorrectionActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    requestId: import_zod22.z.string(),
-    type: import_zod22.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
+  import_zod19.z.object({
+    requestId: import_zod19.z.string(),
+    type: import_zod19.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
   })
 );
 var ApproveCorrectionActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    requestId: import_zod22.z.string(),
-    type: import_zod22.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
+  import_zod19.z.object({
+    requestId: import_zod19.z.string(),
+    type: import_zod19.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
   })
 );
 var ReadActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.READ).default(ActionType.READ)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.READ).default(ActionType.READ)
   })
 );
-var ActionInput = import_zod22.z.discriminatedUnion("type", [
+var ActionInput = import_zod19.z.discriminatedUnion("type", [
   CreateActionInput,
   ValidateActionInput,
   RegisterActionInput,
@@ -2096,52 +1491,765 @@ var ActionInput = import_zod22.z.discriminatedUnion("type", [
   ReadActionInput
 ]);
 
-// ../commons/src/events/Draft.ts
-var Draft = import_zod23.z.object({
-  id: import_zod23.z.string(),
-  eventId: import_zod23.z.string(),
-  transactionId: import_zod23.z.string(),
-  createdAt: import_zod23.z.string().datetime(),
-  action: ActionBase.extend({
-    type: ActionTypes
-  }).omit({ id: true, status: true })
+// ../commons/src/events/Draft.ts
+var Draft = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  eventId: import_zod20.z.string(),
+  transactionId: import_zod20.z.string(),
+  createdAt: import_zod20.z.string().datetime(),
+  action: ActionBase.extend({
+    type: ActionTypes
+  }).omit({ id: true })
+});
+var DraftInput = BaseActionInput.extend({
+  type: ActionTypes
+});
+
+// ../commons/src/events/EventInput.ts
+var import_zod21 = require("zod");
+var EventInput = import_zod21.z.object({
+  transactionId: import_zod21.z.string(),
+  type: import_zod21.z.string()
+});
+
+// ../commons/src/events/EventDocument.ts
+var import_zod22 = require("zod");
+var EventDocument = import_zod22.z.object({
+  id: import_zod22.z.string(),
+  type: import_zod22.z.string(),
+  createdAt: import_zod22.z.string().datetime(),
+  updatedAt: import_zod22.z.string().datetime(),
+  actions: import_zod22.z.array(Action),
+  trackingId: import_zod22.z.string()
+});
+
+// ../commons/src/events/EventIndex.ts
+var import_zod23 = require("zod");
+var EventIndex = EventMetadata.extend({
+  declaration: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.any())
+});
+var EventSearchIndex = import_zod23.z.record(import_zod23.z.string(), import_zod23.z.any()).and(
+  import_zod23.z.object({
+    type: import_zod23.z.string()
+    // Ensures "type" (event-id) exists and is a string
+  })
+);
+var Fuzzy = import_zod23.z.object({ type: import_zod23.z.literal("fuzzy"), term: import_zod23.z.string() });
+var Exact = import_zod23.z.object({ type: import_zod23.z.literal("exact"), term: import_zod23.z.string() });
+var AnyOf = import_zod23.z.object({
+  type: import_zod23.z.literal("anyOf"),
+  terms: import_zod23.z.array(import_zod23.z.string())
+});
+var Range = import_zod23.z.object({
+  type: import_zod23.z.literal("range"),
+  gte: import_zod23.z.string(),
+  lte: import_zod23.z.string()
+});
+var Within = import_zod23.z.object({ type: import_zod23.z.literal("within"), location: import_zod23.z.string() });
+var DateCondition = import_zod23.z.union([Exact, Range]);
+var QueryInput = import_zod23.z.lazy(
+  () => import_zod23.z.union([
+    import_zod23.z.discriminatedUnion("type", [Fuzzy, Exact, Range, Within, AnyOf]),
+    import_zod23.z.record(import_zod23.z.string(), QueryInput)
+  ])
+);
+var QueryExpression = import_zod23.z.object({
+  type: import_zod23.z.literal("and"),
+  eventType: import_zod23.z.string(),
+  searchType: import_zod23.z.optional(import_zod23.z.union([AnyOf, Exact])),
+  status: import_zod23.z.optional(import_zod23.z.union([AnyOf, Exact])),
+  createdAt: import_zod23.z.optional(DateCondition),
+  updatedAt: import_zod23.z.optional(DateCondition),
+  createAtLocation: import_zod23.z.optional(import_zod23.z.union([Within, Exact])),
+  updatedAtLocation: import_zod23.z.optional(import_zod23.z.union([Within, Exact])),
+  createdBy: import_zod23.z.optional(Exact),
+  updatedBy: import_zod23.z.optional(Exact),
+  trackingId: import_zod23.z.optional(Exact),
+  data: QueryInput
+}).partial();
+var Or2 = import_zod23.z.object({
+  type: import_zod23.z.literal("or"),
+  clauses: import_zod23.z.array(QueryExpression)
+});
+var QueryType = import_zod23.z.discriminatedUnion("type", [QueryExpression, Or2]);
+
+// ../commons/src/events/utils.ts
+var import_lodash2 = require("lodash");
+
+// ../commons/src/workqueues/WorkqueueConfig.ts
+var import_zod25 = require("zod");
+
+// ../commons/src/workqueues/defaultColumns.ts
+var import_zod24 = require("zod");
+var WorkQueueColumnConfig = import_zod24.z.object({
+  id: import_zod24.z.string(),
+  label: TranslationConfig
+});
+var defaultColumns = {
+  event: {
+    id: "event",
+    label: {
+      defaultMessage: "Event",
+      description: "This is the label for the workqueue column",
+      id: "workqueue.default.column.event"
+    }
+  },
+  status: {
+    id: "status",
+    label: {
+      defaultMessage: "Status",
+      description: "This is the label for the workqueue column",
+      id: "workqueue.default.column.status"
+    }
+  },
+  createdAt: {
+    id: "createdAt",
+    label: {
+      defaultMessage: "Created",
+      description: "This is the label for the workqueue column",
+      id: "workqueue.default.column.createdAt"
+    }
+  },
+  modifiedAt: {
+    id: "modifiedAt",
+    label: {
+      defaultMessage: "Modified",
+      description: "This is the label for the workqueue column",
+      id: "workqueue.default.column.modifiedAt"
+    }
+  }
+};
+var DefaultColumnKeys = import_zod24.z.enum(
+  Object.keys(defaultColumns)
+);
+
+// ../commons/src/workqueues/WorkqueueConfig.ts
+var rootWorkqueueConfig = import_zod25.z.object({
+  id: import_zod25.z.string(),
+  title: TranslationConfig,
+  columns: import_zod25.z.array(WorkQueueColumnConfig),
+  defaultColumns: import_zod25.z.array(DefaultColumnKeys)
+});
+var defineWorkqueue = (config) => rootWorkqueueConfig.parse(config);
+
+// ../commons/src/workqueues/all.ts
+var allWorkqueue = defineWorkqueue({
+  id: "all",
+  title: {
+    defaultMessage: "All events",
+    description: "This is the label for the workqueue",
+    id: "workqueue.all.label"
+  },
+  columns: [
+    {
+      id: "title",
+      label: {
+        defaultMessage: "Title",
+        description: "This is the label for the workqueue column",
+        id: "workqueue.all.column.title"
+      }
+    }
+  ],
+  defaultColumns: ["event", "status", "createdAt", "modifiedAt"]
+});
+
+// ../commons/src/workqueues/readyForReview.ts
+var inReviewWorkqueue = defineWorkqueue({
+  id: "ready-for-review",
+  title: {
+    defaultMessage: "Ready for review",
+    description: "Label for in review workqueue",
+    id: "event.workqueue.in-review.label"
+  },
+  columns: [
+    {
+      id: "title",
+      label: {
+        defaultMessage: "Title",
+        description: "This is the label for the workqueue column",
+        id: "workqueue.in-reveiw.column.title"
+      }
+    }
+  ],
+  defaultColumns: ["event", "createdAt", "modifiedAt"]
 });
-var DraftInput = BaseActionInput.extend({
-  type: ActionTypes
+
+// ../commons/src/workqueues/readyToPrint.ts
+var registeredWorkqueue = defineWorkqueue({
+  id: "registered",
+  title: {
+    defaultMessage: "Ready to print",
+    description: "Label for registered workqueue",
+    id: "event.workqueue.registered.label"
+  },
+  columns: [
+    {
+      id: "title",
+      label: {
+        defaultMessage: "Title",
+        description: "This is the label for the workqueue column",
+        id: "workqueue.registered.column.title"
+      }
+    }
+  ],
+  defaultColumns: ["event", "createdAt", "modifiedAt"]
 });
 
-// ../commons/src/events/EventInput.ts
-var import_zod24 = require("zod");
-var EventInput = import_zod24.z.object({
-  transactionId: import_zod24.z.string(),
-  type: import_zod24.z.string()
+// ../commons/src/workqueues/index.ts
+var workqueues = {
+  all: allWorkqueue,
+  registered: registeredWorkqueue,
+  inReview: inReviewWorkqueue
+};
+
+// ../commons/src/conditionals/validate.ts
+var import_ajv = __toESM(require("ajv"));
+var import_ajv_formats = __toESM(require("ajv-formats"));
+var import_date_fns = require("date-fns");
+
+// ../commons/src/events/FieldTypeMapping.ts
+var import_zod26 = require("zod");
+function mapFieldTypeToZod(type, required) {
+  let schema;
+  switch (type) {
+    case FieldType.DATE:
+      schema = DateValue;
+      break;
+    case FieldType.EMAIL:
+      schema = EmailValue;
+      break;
+    case FieldType.TEXT:
+    case FieldType.TEXTAREA:
+    case FieldType.DIVIDER:
+    case FieldType.BULLET_LIST:
+    case FieldType.PAGE_HEADER:
+    case FieldType.LOCATION:
+    case FieldType.SELECT:
+    case FieldType.COUNTRY:
+    case FieldType.RADIO_GROUP:
+    case FieldType.PARAGRAPH:
+    case FieldType.ADMINISTRATIVE_AREA:
+    case FieldType.FACILITY:
+    case FieldType.OFFICE:
+    case FieldType.SIGNATURE:
+    case FieldType.HIDDEN:
+      schema = required ? RequiredTextValue : TextValue;
+      break;
+    case FieldType.NUMBER:
+      schema = NumberFieldValue;
+      break;
+    case FieldType.CHECKBOX:
+      schema = CheckboxFieldValue;
+      break;
+    case FieldType.FILE:
+      schema = FileFieldValue;
+      break;
+    case FieldType.FILE_WITH_OPTIONS:
+      schema = FileFieldWithOptionValue;
+      break;
+    case FieldType.ADDRESS:
+      schema = AddressFieldUpdateValue;
+      break;
+    case FieldType.DATA:
+      schema = DataFieldValue;
+      break;
+  }
+  return required ? schema : schema.nullish();
+}
+function createValidationSchema(config) {
+  const shape = {};
+  for (const field2 of config) {
+    shape[field2.id] = mapFieldTypeToZod(field2.type, field2.required);
+  }
+  return import_zod26.z.object(shape);
+}
+function mapFieldTypeToMockValue(field2, i) {
+  switch (field2.type) {
+    case FieldType.DIVIDER:
+    case FieldType.TEXT:
+    case FieldType.TEXTAREA:
+    case FieldType.BULLET_LIST:
+    case FieldType.PAGE_HEADER:
+    case FieldType.LOCATION:
+    case FieldType.SELECT:
+    case FieldType.COUNTRY:
+    case FieldType.RADIO_GROUP:
+    case FieldType.SIGNATURE:
+    case FieldType.PARAGRAPH:
+    case FieldType.ADMINISTRATIVE_AREA:
+    case FieldType.FACILITY:
+    case FieldType.OFFICE:
+      return `${field2.id}-${field2.type}-${i}`;
+    case FieldType.NUMBER:
+      return 19;
+    case FieldType.EMAIL:
+      return "test@opencrvs.org";
+    case FieldType.ADDRESS:
+      return {
+        country: "FAR",
+        addressType: AddressType.DOMESTIC,
+        province: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
+        district: "5ef450bc-712d-48ad-93f3-8da0fa453baa",
+        urbanOrRural: "URBAN",
+        town: "Example Town",
+        residentialArea: "Example Residential Area",
+        street: "Example Street",
+        number: "55",
+        zipCode: "123456"
+      };
+    case FieldType.DATE:
+      return "2021-01-01";
+    case FieldType.CHECKBOX:
+      return true;
+    case FieldType.FILE:
+      return {
+        filename: "4f095fc4-4312-4de2-aa38-86dcc0f71044.png",
+        originalFilename: "abcd.png",
+        type: "image/png"
+      };
+    case FieldType.FILE_WITH_OPTIONS:
+      return null;
+    case FieldType.DATA:
+      return {};
+  }
+}
+function mapFieldTypeToEmptyValue(field2) {
+  switch (field2.type) {
+    case FieldType.DIVIDER:
+    case FieldType.TEXT:
+    case FieldType.TEXTAREA:
+    case FieldType.BULLET_LIST:
+    case FieldType.PAGE_HEADER:
+    case FieldType.LOCATION:
+    case FieldType.SELECT:
+    case FieldType.COUNTRY:
+    case FieldType.RADIO_GROUP:
+    case FieldType.SIGNATURE:
+    case FieldType.PARAGRAPH:
+    case FieldType.ADMINISTRATIVE_AREA:
+    case FieldType.FACILITY:
+    case FieldType.OFFICE:
+    case FieldType.NUMBER:
+    case FieldType.EMAIL:
+    case FieldType.DATE:
+    case FieldType.CHECKBOX:
+    case FieldType.DATA:
+      return null;
+    case FieldType.ADDRESS:
+      return {
+        country: null,
+        addressType: AddressType.DOMESTIC,
+        province: null,
+        district: null,
+        urbanOrRural: "URBAN",
+        // Default to urban needed for validation
+        town: null,
+        residentialArea: null,
+        street: null,
+        number: null,
+        zipCode: null
+      };
+    case FieldType.FILE:
+      return {
+        filename: "",
+        originalFilename: "",
+        type: ""
+      };
+    case FieldType.FILE_WITH_OPTIONS:
+      return [];
+  }
+}
+var isParagraphFieldType = (field2) => {
+  return field2.config.type === FieldType.PARAGRAPH;
+};
+var isDateFieldType = (field2) => {
+  return field2.config.type === FieldType.DATE;
+};
+var isPageHeaderFieldType = (field2) => {
+  return field2.config.type === FieldType.PAGE_HEADER;
+};
+var isTextFieldType = (field2) => {
+  return field2.config.type === FieldType.TEXT;
+};
+var isNumberFieldType = (field2) => {
+  return field2.config.type === FieldType.NUMBER;
+};
+var isTextAreaFieldType = (field2) => {
+  return field2.config.type === FieldType.TEXTAREA;
+};
+var isSignatureFieldType = (field2) => {
+  return field2.config.type === FieldType.SIGNATURE;
+};
+var isEmailFieldType = (field2) => {
+  return field2.config.type === FieldType.EMAIL;
+};
+var isFileFieldType = (field2) => {
+  return field2.config.type === FieldType.FILE;
+};
+var isFileFieldWithOptionType = (field2) => {
+  return field2.config.type === FieldType.FILE_WITH_OPTIONS;
+};
+var isBulletListFieldType = (field2) => {
+  return field2.config.type === FieldType.BULLET_LIST;
+};
+var isSelectFieldType = (field2) => {
+  return field2.config.type === FieldType.SELECT;
+};
+var isAddressFieldType = (field2) => {
+  return field2.config.type === FieldType.ADDRESS;
+};
+var isCountryFieldType = (field2) => {
+  return field2.config.type === FieldType.COUNTRY;
+};
+var isCheckboxFieldType = (field2) => {
+  return field2.config.type === FieldType.CHECKBOX;
+};
+var isRadioGroupFieldType = (field2) => {
+  return field2.config.type === FieldType.RADIO_GROUP;
+};
+var isLocationFieldType = (field2) => {
+  return field2.config.type === FieldType.LOCATION;
+};
+var isDividerFieldType = (field2) => {
+  return field2.config.type === FieldType.DIVIDER;
+};
+var isAdministrativeAreaFieldType = (field2) => {
+  return field2.config.type === FieldType.ADMINISTRATIVE_AREA;
+};
+var isFacilityFieldType = (field2) => {
+  return field2.config.type === FieldType.FACILITY;
+};
+var isOfficeFieldType = (field2) => {
+  return field2.config.type === FieldType.OFFICE;
+};
+var isDataFieldType = (field2) => {
+  return field2.config.type === FieldType.DATA;
+};
+
+// ../commons/src/conditionals/validate.ts
+var ajv = new import_ajv.default({
+  $data: true,
+  allowUnionTypes: true
 });
+(0, import_ajv_formats.default)(ajv);
+function validate(schema, data) {
+  return ajv.validate(schema, data);
+}
+function getConditionalActionsForField(field2, values) {
+  if (!field2.conditionals) {
+    return [];
+  }
+  return field2.conditionals.filter((conditional) => validate(conditional.conditional, values)).map((conditional) => conditional.type);
+}
+function isFieldConditionMet(field2, form, conditionalType) {
+  const hasRule = (field2.conditionals ?? []).some(
+    (conditional) => conditional.type === conditionalType
+  );
+  if (!hasRule) {
+    return true;
+  }
+  const validConditionals = getConditionalActionsForField(field2, {
+    $form: form,
+    $now: (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), {
+      representation: "date"
+    })
+  });
+  return validConditionals.includes(conditionalType);
+}
+function isFieldVisible(field2, form) {
+  return isFieldConditionMet(field2, form, ConditionalType.SHOW);
+}
+function isFieldEnabled(field2, form) {
+  return isFieldConditionMet(field2, form, ConditionalType.ENABLE);
+}
+function isFieldDisplayedOnReview(field2, form) {
+  return isFieldVisible(field2, form) && isFieldConditionMet(field2, form, ConditionalType.DISPLAY_ON_REVIEW);
+}
+var errorMessages = {
+  hiddenField: {
+    id: "v2.error.hidden",
+    defaultMessage: "Hidden or disabled field should not receive a value",
+    description: "Error message when field is hidden or disabled, but a value was received"
+  },
+  invalidDate: {
+    defaultMessage: "Invalid date field",
+    description: "Error message when date field is invalid",
+    id: "v2.error.invalidDate"
+  },
+  invalidEmail: {
+    defaultMessage: "Invalid email address",
+    description: "Error message when email address is invalid",
+    id: "v2.error.invalidEmail"
+  },
+  requiredField: {
+    defaultMessage: "Required for registration",
+    description: "Error message when required field is missing",
+    id: "v2.error.required"
+  },
+  invalidInput: {
+    defaultMessage: "Invalid input",
+    description: "Error message when generic field is invalid",
+    id: "v2.error.invalid"
+  }
+};
+function createIntlError(message) {
+  return {
+    message: {
+      message
+    }
+  };
+}
+function zodToIntlErrorMap(issue, _ctx) {
+  switch (issue.code) {
+    case "invalid_string": {
+      if (_ctx.data === "") {
+        return createIntlError(errorMessages.requiredField);
+      }
+      if (issue.validation === "date") {
+        return createIntlError(errorMessages.invalidDate);
+      }
+      if (issue.validation === "email") {
+        return createIntlError(errorMessages.invalidEmail);
+      }
+      break;
+    }
+    case "invalid_type": {
+      if (issue.expected !== issue.received && issue.received === "undefined") {
+        return createIntlError(errorMessages.requiredField);
+      }
+      break;
+    }
+    case "too_small": {
+      if (issue.message === void 0) {
+        return createIntlError(errorMessages.requiredField);
+      }
+      break;
+    }
+    case "invalid_union": {
+      for (const { issues } of issue.unionErrors) {
+        for (const e of issues) {
+          if (zodToIntlErrorMap(e, _ctx).message.message.id !== "v2.error.required") {
+            return createIntlError(errorMessages.invalidInput);
+          }
+        }
+      }
+      return createIntlError(errorMessages.requiredField);
+    }
+  }
+  return createIntlError(errorMessages.invalidInput);
+}
+function runCustomFieldValidations({
+  field: field2,
+  conditionalParameters
+}) {
+  return (field2.validation ?? []).filter((validation) => {
+    return !validate(validation.validator, conditionalParameters);
+  }).map((validation) => ({ message: validation.message }));
+}
+function validateFieldInput({
+  field: field2,
+  value
+}) {
+  const rawError = mapFieldTypeToZod(field2.type, field2.required).safeParse(
+    value,
+    {
+      // @ts-expect-error
+      errorMap: zodToIntlErrorMap
+    }
+  );
+  return rawError.error?.issues.map((issue) => issue.message) ?? [];
+}
+function runFieldValidations({
+  field: field2,
+  values
+}) {
+  const conditionalParameters = {
+    $form: values,
+    $now: (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" })
+  };
+  const fieldValidationResult = validateFieldInput({
+    field: field2,
+    value: values[field2.id]
+  });
+  const customValidationResults = runCustomFieldValidations({
+    field: field2,
+    conditionalParameters
+  });
+  return {
+    // Assumes that custom validation errors are based on the field type, and extend the validation.
+    errors: [...fieldValidationResult, ...customValidationResults]
+  };
+}
+function getFieldValidationErrors({
+  field: field2,
+  values
+}) {
+  if (!isFieldVisible(field2, values) || !isFieldEnabled(field2, values)) {
+    if (values[field2.id]) {
+      return {
+        errors: [
+          {
+            message: errorMessages.hiddenField
+          }
+        ]
+      };
+    }
+    return {
+      errors: []
+    };
+  }
+  return runFieldValidations({
+    field: field2,
+    values
+  });
+}
 
-// ../commons/src/events/EventDocument.ts
-var import_zod25 = require("zod");
-var EventDocument = import_zod25.z.object({
-  id: import_zod25.z.string(),
-  type: import_zod25.z.string(),
-  createdAt: import_zod25.z.string().datetime(),
-  updatedAt: import_zod25.z.string().datetime(),
-  actions: import_zod25.z.array(Action),
-  trackingId: import_zod25.z.string()
-});
+// ../commons/src/uuid.ts
+var import_uuid = require("uuid");
+function getUUID() {
+  return (0, import_uuid.v4)();
+}
 
-// ../commons/src/events/EventIndex.ts
-var import_zod26 = require("zod");
-var EventIndex = EventMetadata.extend({
-  declaration: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any())
-});
-var EventSearchIndex = import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any()).and(
-  import_zod26.z.object({
-    type: import_zod26.z.string()
-    // Ensures "type" (event-id) exists and is a string
-  })
-);
+// ../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);
+}
+function getDeclarationPages(configuration) {
+  return configuration.declaration.pages;
+}
+function getDeclaration(configuration) {
+  return configuration.declaration;
+}
+var getActionAnnotationFields = (actionConfig) => {
+  if (actionConfig.type === ActionType.REQUEST_CORRECTION) {
+    return [
+      ...actionConfig.onboardingForm.flatMap(({ fields }) => fields),
+      ...actionConfig.additionalDetailsForm.flatMap(({ fields }) => fields)
+    ];
+  }
+  if (actionConfig.type === ActionType.PRINT_CERTIFICATE) {
+    return actionConfig.printForm.pages.flatMap(({ fields }) => fields);
+  }
+  if (isDeclarationActionConfig(actionConfig)) {
+    return actionConfig.review.fields;
+  }
+  return [];
+};
+var getAllAnnotationFields = (config) => {
+  return (0, import_lodash2.flattenDeep)(config.actions.map(getActionAnnotationFields));
+};
+var findRecordActionPages = (config, actionType) => {
+  const action = config.actions.find((a) => a.type === actionType);
+  if (action?.type === ActionType.REQUEST_CORRECTION) {
+    return [...action.onboardingForm, ...action.additionalDetailsForm];
+  }
+  if (action?.type === ActionType.PRINT_CERTIFICATE) {
+    return action.printForm.pages;
+  }
+  return [];
+};
+function getActionReview(configuration, actionType) {
+  const [actionConfig] = configuration.actions.filter(
+    (a) => a.type === actionType
+  );
+  return getOrThrow(
+    actionConfig.review,
+    `No review config found for ${actionType}`
+  );
+}
+function getActionReviewFields(configuration, actionType) {
+  return getActionReview(configuration, actionType).fields;
+}
+function validateWorkqueueConfig(workqueueConfigs) {
+  workqueueConfigs.map((workqueue) => {
+    const rootWorkqueue = Object.values(workqueues).find(
+      (wq) => wq.id === workqueue.id
+    );
+    if (!rootWorkqueue) {
+      throw new Error(
+        `Invalid workqueue configuration: workqueue not found with id: ${workqueue.id}`
+      );
+    }
+  });
+}
+function isPageVisible(page, formValues) {
+  if (!page.conditional) {
+    return true;
+  }
+  return validate(page.conditional, {
+    $form: formValues,
+    $now: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" })
+  });
+}
+function omitHiddenFields(fields, values) {
+  return (0, import_lodash2.omitBy)(values, (_, fieldId) => {
+    const field2 = fields.find((f) => f.id === fieldId);
+    if (!field2) {
+      return true;
+    }
+    return !isFieldVisible(field2, values);
+  });
+}
+function omitHiddenPaginatedFields(formConfig, declaration) {
+  const visiblePagesFormFields = formConfig.pages.filter((p) => isPageVisible(p, declaration)).flatMap((p) => p.fields);
+  return omitHiddenFields(visiblePagesFormFields, declaration);
+}
+function findActiveDrafts(event2, drafts) {
+  const actions = event2.actions.slice().filter(({ type }) => type !== ActionType.READ).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const lastAction = actions[actions.length - 1];
+  return drafts.filter(({ createdAt }) => createdAt >= lastAction.createdAt).filter(({ eventId }) => eventId === event2.id);
+}
+function createEmptyDraft(eventId, draftId, actionType) {
+  return {
+    id: draftId,
+    eventId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    transactionId: getUUID(),
+    action: {
+      type: actionType,
+      declaration: {},
+      annotation: {},
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      createdBy: "@todo",
+      createdAtLocation: "@todo"
+    }
+  };
+}
+function isVerificationPage(page) {
+  return page.type === PageTypes.enum.VERIFICATION;
+}
+function deepMerge(currentDocument, actionDocument) {
+  return (0, import_lodash2.mergeWith)(
+    currentDocument,
+    actionDocument,
+    (previousValue, incomingValue) => {
+      if (incomingValue === void 0) {
+        return previousValue;
+      }
+      if ((0, import_lodash2.isArray)(incomingValue)) {
+        return incomingValue;
+      }
+      if ((0, import_lodash2.isObject)(previousValue) && (0, import_lodash2.isObject)(incomingValue)) {
+        return void 0;
+      }
+      return incomingValue;
+    }
+  );
+}
+function findLastAssignmentAction(actions) {
+  return actions.filter(
+    ({ type }) => type === ActionType.ASSIGN || type === ActionType.UNASSIGN
+  ).reduce((latestAction, action) => !latestAction || action.createdAt > latestAction.createdAt ? action : latestAction, void 0);
+}
+function isWriteAction(actionType) {
+  return writeActions.safeParse(actionType).success;
+}
 
 // ../commons/src/events/state/index.ts
-var _ = __toESM(require("lodash"));
 function getStatusFromActions(actions) {
   const hasRejectedAction = actions.some(
     (a) => a.status === ActionStatus.Rejected
@@ -2205,26 +2313,27 @@ function aggregateActionDeclarations(actions) {
   }, {});
 }
 function deepDropNulls(obj) {
-  if (!_.isObject(obj)) return obj;
-  return Object.entries(obj).reduce((acc, [key, value]) => {
-    if (_.isObject(value)) {
-      value = deepDropNulls(value);
-    }
-    if (value !== null) {
-      return {
-        ...acc,
-        [key]: value
-      };
-    }
-    return acc;
-  }, {});
+  if (Array.isArray(obj)) {
+    return obj.map(deepDropNulls);
+  }
+  if (obj !== null && typeof obj === "object") {
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+      const cleanedValue = deepDropNulls(value);
+      if (cleanedValue !== null) {
+        ;
+        acc[key] = cleanedValue;
+      }
+      return acc;
+    }, {});
+  }
+  return obj;
 }
 function isUndeclaredDraft(status) {
   return status === EventStatus.CREATED;
 }
 function getAcceptedActions(event2) {
   return event2.actions.filter(
-    (a) => !a.status || a.status === ActionStatus.Accepted
+    (a) => a.status === ActionStatus.Accepted
   );
 }
 function getCurrentEventState(event2) {
@@ -2246,8 +2355,11 @@ function getCurrentEventState(event2) {
     status: getStatusFromActions(event2.actions),
     createdAt: event2.createdAt,
     createdBy: creationAction.createdBy,
-    createdAtLocation: creationAction.createdAtLocation,
-    modifiedAt: latestAction.createdAt,
+    createdAtLocation: creationAction.createdAtLocation ?? "",
+    // @todo remove using empty string
+    updatedAtLocation: creationAction.updatedAtLocation ?? "",
+    // @todo remove using empty string
+    updatedAt: latestAction.createdAt,
     assignedTo: getAssignedUserFromActions(activeActions),
     updatedBy: latestAction.createdBy,
     declaration: aggregateActionDeclarations(activeActions),
@@ -2277,7 +2389,7 @@ function getCurrentEventStateWithDrafts(event2, drafts) {
   return getCurrentEventState(withDrafts);
 }
 function applyDraftsToEventIndex(eventIndex, drafts) {
-  const indexedAt = eventIndex.modifiedAt;
+  const indexedAt = eventIndex.updatedAt;
   const activeDrafts = drafts.filter(({ createdAt }) => new Date(createdAt) > new Date(indexedAt)).map((draft) => draft.action).sort();
   if (activeDrafts.length === 0) {
     return eventIndex;
@@ -2290,20 +2402,29 @@ function applyDraftsToEventIndex(eventIndex, drafts) {
     }
   };
 }
+function getAnnotationFromDrafts(drafts) {
+  const actions = drafts.map((draft) => draft.action);
+  const annotation = actions.reduce((ann, action) => {
+    return deepMerge(ann, action.annotation ?? {});
+  }, {});
+  return deepDropNulls(annotation);
+}
 function getActionAnnotation({
   event: event2,
   actionType,
   drafts
 }) {
   const activeActions = getAcceptedActions(event2);
-  const action = activeActions.find((action2) => actionType === action2.type);
+  const action = activeActions.find(
+    (activeAction) => actionType === activeAction.type
+  );
   const eventDrafts = drafts.filter((draft) => draft.eventId === event2.id);
   const sorted = [
     ...action ? [action] : [],
     ...eventDrafts.map((draft) => draft.action)
   ].sort();
-  const annotation = sorted.reduce((annotation2, action2) => {
-    return deepMerge(annotation2, action2.annotation ?? {});
+  const annotation = sorted.reduce((ann, sortedAction) => {
+    return deepMerge(ann, sortedAction.annotation ?? {});
   }, {});
   return deepDropNulls(annotation);
 }
@@ -2311,7 +2432,7 @@ function getActionAnnotation({
 // ../commons/src/events/defineConfig.ts
 var defineConfig = (config) => {
   validateWorkqueueConfig(config.workqueues);
-  const input = EventConfig.parse(config);
+  const input = EventConfig2.parse(config);
   return input;
 };
 
@@ -2321,12 +2442,22 @@ function generateTransactionId() {
 }
 
 // ../commons/src/events/test.utils.ts
-var import_lodash2 = require("lodash");
+var import_lodash3 = require("lodash");
 
 // ../commons/src/conditionals/conditionals.ts
 function defineConditional(schema) {
   return schema;
 }
+function defineFormConditional(schema) {
+  const schemaWithForm = {
+    type: "object",
+    properties: {
+      $form: schema
+    },
+    required: ["$form"]
+  };
+  return defineConditional(schemaWithForm);
+}
 function alwaysTrue() {
   return {};
 }
@@ -2351,6 +2482,9 @@ function not(condition) {
     required: []
   });
 }
+function never() {
+  return not(alwaysTrue());
+}
 var user = {
   hasScope: (scope) => defineConditional({
     type: "object",
@@ -2398,100 +2532,118 @@ var event = {
     required: ["$event"]
   })
 };
+function getDateFromNow(days) {
+  return new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString().split("T")[0];
+}
+function getDateRangeToFieldReference(fieldId, comparedFieldId, clause) {
+  return {
+    type: "object",
+    properties: {
+      [fieldId]: {
+        type: "string",
+        format: "date",
+        [clause]: { $data: `1/${comparedFieldId}` }
+      },
+      [comparedFieldId]: { type: "string", format: "date" }
+    },
+    required: [fieldId]
+  };
+}
+function isFieldReference(value) {
+  return typeof value === "object" && value !== null && "_fieldId" in value;
+}
 function field(fieldId) {
-  const getDateFromNow = (days) => new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString().split("T")[0];
   const getDateRange = (date, clause) => ({
     type: "object",
     properties: {
-      $form: {
-        type: "object",
-        properties: {
-          [fieldId]: {
-            type: "string",
-            format: "date",
-            [clause]: date
-          }
-        },
-        required: [fieldId]
+      [fieldId]: {
+        type: "string",
+        format: "date",
+        [clause]: date
       }
     },
-    required: ["$form"]
+    required: [fieldId]
   });
   return {
     /**
      * @private Internal property used for field reference tracking.
      */
-    _returning: fieldId,
+    _fieldId: fieldId,
     isAfter: () => ({
       days: (days) => ({
-        inPast: () => defineConditional(
+        inPast: () => defineFormConditional(
           getDateRange(getDateFromNow(days), "formatMinimum")
         ),
-        inFuture: () => defineConditional(
+        inFuture: () => defineFormConditional(
           getDateRange(getDateFromNow(-days), "formatMinimum")
         )
       }),
-      date: (date) => defineConditional(getDateRange(date, "formatMinimum")),
-      now: () => defineConditional(getDateRange(getDateFromNow(0), "formatMinimum"))
+      date: (date) => {
+        if (isFieldReference(date)) {
+          const comparedFieldId = date._fieldId;
+          return defineFormConditional(
+            getDateRangeToFieldReference(
+              fieldId,
+              comparedFieldId,
+              "formatMinimum"
+            )
+          );
+        }
+        return defineFormConditional(getDateRange(date, "formatMinimum"));
+      },
+      now: () => defineFormConditional(getDateRange(getDateFromNow(0), "formatMinimum"))
     }),
     isBefore: () => ({
       days: (days) => ({
-        inPast: () => defineConditional(
+        inPast: () => defineFormConditional(
           getDateRange(getDateFromNow(days), "formatMaximum")
         ),
-        inFuture: () => defineConditional(
+        inFuture: () => defineFormConditional(
           getDateRange(getDateFromNow(-days), "formatMaximum")
         )
       }),
-      date: (date) => defineConditional(getDateRange(date, "formatMaximum")),
-      now: () => defineConditional(getDateRange(getDateFromNow(0), "formatMaximum"))
+      date: (date) => {
+        if (isFieldReference(date)) {
+          const comparedFieldId = date._fieldId;
+          return defineFormConditional(
+            getDateRangeToFieldReference(
+              fieldId,
+              comparedFieldId,
+              "formatMaximum"
+            )
+          );
+        }
+        return defineFormConditional(getDateRange(date, "formatMaximum"));
+      },
+      now: () => defineFormConditional(getDateRange(getDateFromNow(0), "formatMaximum"))
     }),
-    // TODO CIHAN: typing
     isEqualTo: (value) => {
-      if (typeof value === "object" && value._returning) {
-        const comparedFieldId = value._returning;
-        return defineConditional({
+      if (isFieldReference(value)) {
+        const comparedFieldId = value._fieldId;
+        return defineFormConditional({
           type: "object",
           properties: {
-            $form: {
-              type: "object",
-              properties: {
-                [fieldId]: { type: ["string", "boolean"] },
-                [comparedFieldId]: { type: ["string", "boolean"] }
-              },
-              required: [fieldId, comparedFieldId],
-              allOf: [
-                {
-                  properties: {
-                    [fieldId]: {
-                      const: { $data: `1/${comparedFieldId}` }
-                    }
-                  }
-                }
-              ]
-            }
+            [fieldId]: {
+              type: ["string", "boolean"],
+              const: { $data: `1/${comparedFieldId}` }
+            },
+            [comparedFieldId]: { type: ["string", "boolean"] }
           },
-          required: ["$form"]
+          required: [fieldId, comparedFieldId]
         });
       }
-      return defineConditional({
+      return defineFormConditional({
         type: "object",
         properties: {
-          $form: {
-            type: "object",
-            properties: {
-              [fieldId]: {
-                oneOf: [
-                  { type: "string", const: value },
-                  { type: "boolean", const: value }
-                ],
-                const: value
-              }
-            },
-            required: [fieldId]
+          [fieldId]: {
+            oneOf: [
+              { type: "string", const: value },
+              { type: "boolean", const: value }
+            ],
+            const: value
           }
         },
-        required: ["$form"]
+        required: [fieldId]
       });
     },
     /**
@@ -2502,143 +2654,138 @@ function field(fieldId) {
      * NOTE: For now, this only works with string, boolean, and null types. 0 is still allowed.
      *
      */
-    isFalsy: () => defineConditional({
+    isFalsy: () => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              anyOf: [
-                { const: "undefined" },
-                { const: false },
-                { const: null },
-                { const: "" }
-              ]
-            }
-          },
+        [fieldId]: {
           anyOf: [
-            {
-              required: [fieldId]
-            },
-            {
-              not: {
-                required: [fieldId]
-              }
-            }
+            { const: "undefined" },
+            { const: false },
+            { const: null },
+            { const: "" }
           ]
         }
       },
-      required: ["$form"]
-    }),
-    isUndefined: () => defineConditional({
-      type: "object",
-      properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              enum: ["undefined"]
-            }
-          },
+      anyOf: [
+        {
+          required: [fieldId]
+        },
+        {
           not: {
             required: [fieldId]
           }
         }
-      },
-      required: ["$form"]
+      ]
     }),
-    inArray: (values) => defineConditional({
+    isUndefined: () => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              enum: values
-            }
-          },
-          required: [fieldId]
+        [fieldId]: {
+          type: "string",
+          enum: ["undefined"]
         }
       },
-      required: ["$form"]
+      not: {
+        required: [fieldId]
+      }
     }),
-    isValidEnglishName: () => defineConditional({
+    inArray: (values) => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              pattern: "^[\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*( [\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*)*$",
-              description: "Name must contain only letters, numbers, and allowed special characters ('._-). No double spaces."
-            }
-          },
-          required: [fieldId]
+        [fieldId]: {
+          type: "string",
+          enum: values
         }
       },
-      required: ["$form"]
+      required: [fieldId]
     }),
-    isValidNationalId: () => defineConditional({
+    isValidEnglishName: () => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              pattern: "^[0-9]{9}$",
-              description: "The National ID can only be numeric and must be 9 digits long."
-            }
-          },
-          required: [fieldId]
+        [fieldId]: {
+          type: "string",
+          pattern: "^[\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*( [\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*)*$",
+          description: "Name must contain only letters, numbers, and allowed special characters ('._-). No double spaces."
         }
       },
-      required: ["$form"]
+      required: [fieldId]
     }),
     /**
      * Checks if the field value matches a given regular expression pattern.
      * @param pattern - The regular expression pattern to match the field value against.
      * @returns A JSONSchema conditional that validates the field value against the pattern.
      */
-    matches: (pattern) => defineConditional({
+    matches: (pattern) => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              pattern
-            }
-          },
-          required: [fieldId]
+        [fieldId]: {
+          type: "string",
+          pattern
         }
       },
-      required: ["$form"]
+      required: [fieldId]
     }),
-    isBetween: (min, max) => defineConditional({
+    isBetween: (min, max) => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "number",
-              minimum: min,
-              maximum: max
-            }
-          },
-          required: [fieldId]
+        [fieldId]: {
+          type: "number",
+          minimum: min,
+          maximum: max
         }
       },
-      required: ["$form"]
+      required: [fieldId]
+    }),
+    /**
+     * Creates a range configuration for the specified field.
+     *
+     * @returns An object containing the field ID and a configuration object with a type of 'RANGE'.
+     *
+     * @example field('age').range()
+     * // {
+     * //   fieldId: 'age',
+     * //   config: { type: 'RANGE' }
+     * // }
+     */
+    range: () => ({
+      fieldId,
+      config: { type: "RANGE" }
+    }),
+    /**
+     * Creates a configuration for exact matching of the specified field.
+     * @returns  An object containing the field ID and a configuration object with a type of 'EXACT'.
+     * @example field('dob').exact()
+     * // {
+     * //   fieldId: 'dob',
+     * //   config: { type: 'EXACT' }
+     * // }
+     */
+    exact: () => ({
+      fieldId,
+      config: { type: "EXACT" }
+    }),
+    /**
+     * Creates a configuration for fuzzy matching of the specified field.
+     * @returns  An object containing the field ID and a configuration object with a type of 'EXACT'.
+     * @example field('name').fuzzy()
+     * // {
+     * //   fieldId: 'name',
+     * //   config: { type: 'FUZZY' }
+     * // }
+     */
+    fuzzy: () => ({
+      fieldId,
+      config: { type: "FUZZY" }
     })
   };
 }
+function eventField(fieldId, options) {
+  return {
+    fieldId,
+    options,
+    config: { type: "EXACT" }
+  };
+}
 
 // ../commons/src/fixtures/tennis-club-membership-event.ts
 var PRINT_CERTIFICATE_FORM = defineActionForm({
@@ -3378,9 +3525,8 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
         },
         {
           id: "applicant.dob",
-          type: "DATE",
+          type: FieldType.DATE,
           required: true,
-          conditionals: [],
           validation: [
             {
               message: {
@@ -3391,12 +3537,50 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
               validator: field("applicant.dob").isBefore().now()
             }
           ],
+          conditionals: [
+            {
+              type: ConditionalType.SHOW,
+              conditional: field("applicant.dobUnknown").isFalsy()
+            }
+          ],
           label: {
             defaultMessage: "Applicant's date of birth",
             description: "This is the label for the field",
             id: "v2.event.tennis-club-membership.action.declare.form.section.who.field.dob.label"
           }
         },
+        {
+          id: "applicant.dobUnknown",
+          type: FieldType.CHECKBOX,
+          required: false,
+          label: {
+            defaultMessage: "Exact date of birth unknown",
+            description: "This is the label for the field",
+            id: "v2.event.tennis-club-membership.action.declare.form.section.who.field.dobUnknown.label"
+          },
+          conditionals: [
+            {
+              type: ConditionalType.DISPLAY_ON_REVIEW,
+              conditional: never()
+            }
+          ]
+        },
+        {
+          id: "applicant.age",
+          type: FieldType.NUMBER,
+          required: true,
+          label: {
+            defaultMessage: "Age of tennis-member",
+            description: "This is the label for the field",
+            id: "v2.event.tennis-club-membership.action.declare.form.section.who.field.age.label"
+          },
+          conditionals: [
+            {
+              type: ConditionalType.SHOW,
+              conditional: field("applicant.dobUnknown").isEqualTo(true)
+            }
+          ]
+        },
         {
           id: "applicant.image",
           type: FieldType.FILE,
@@ -3901,18 +4085,14 @@ var tennisClubMembershipEvent = defineConfig({
         description: "This is what this event is referred as in the system",
         id: "v2.event.tennis-club-membership.search"
       },
-      fields: [
-        {
-          fieldId: "applicant.dob"
-        }
-      ]
+      fields: [field("applicant.dob").exact()]
     }
   ],
   declaration: TENNIS_CLUB_DECLARATION_FORM
 });
 
 // ../commons/src/events/test.utils.ts
-function fieldConfigsToActionAnnotation(fields) {
+function fieldConfigsToActionPayload(fields) {
   return fields.reduce(
     (acc, field2, i) => ({
       ...acc,
@@ -3921,23 +4101,27 @@ function fieldConfigsToActionAnnotation(fields) {
     {}
   );
 }
-function generateActionInput(configuration, action) {
+function generateActionDeclarationInput(configuration, action) {
   const parsed = DeclarationUpdateActions.safeParse(action);
   if (parsed.success) {
     const fields = getDeclarationFields(configuration);
-    const annotation = fieldConfigsToActionAnnotation(fields);
-    return stripHiddenFields(fields, annotation);
+    const declarationConfig = getDeclaration(configuration);
+    const declaration = fieldConfigsToActionPayload(fields);
+    return omitHiddenPaginatedFields(declarationConfig, declaration);
   }
   console.warn(`${action} is not a declaration action. Setting data as {}.`);
   return {};
 }
-function generateActionMetadataInput(configuration, action) {
+function generateActionAnnotationInput(configuration, action) {
   const actionConfig = configuration.actions.find(
-    (actionConfig2) => actionConfig2.type === action
+    (ac) => ac.type === action
   );
   const annotationFields = actionConfig ? getActionAnnotationFields(actionConfig) : [];
-  const annotation = fieldConfigsToActionAnnotation(annotationFields);
-  const visibleVerificationPageIds = (findRecordActionPages(configuration, action) ?? []).filter((page) => isVerificationPage(page)).filter((page) => isPageVisible(page, annotation)).map((page) => page.id) ?? [];
+  const annotation = fieldConfigsToActionPayload(annotationFields);
+  const visibleVerificationPageIds = findRecordActionPages(
+    configuration,
+    action
+  ).filter((page) => isVerificationPage(page)).filter((page) => isPageVisible(page, annotation)).map((page) => page.id);
   const visiblePageVerificationMap = visibleVerificationPageIds.reduce(
     (acc, pageId) => ({
       ...acc,
@@ -3945,7 +4129,7 @@ function generateActionMetadataInput(configuration, action) {
     }),
     {}
   );
-  const fieldBasedPayload = stripHiddenFields(annotationFields, annotation);
+  const fieldBasedPayload = omitHiddenFields(annotationFields, annotation);
   return {
     ...fieldBasedPayload,
     ...visiblePageVerificationMap
@@ -3961,14 +4145,15 @@ var eventPayloadGenerator = {
     type: input.type ?? "TENNIS_CLUB_MEMBERSHIP",
     id
   }),
-  draft: (eventId, input = {}) => (0, import_lodash2.merge)(
+  draft: ({ eventId, actionType }, input = {}) => (0, import_lodash3.merge)(
     {
       id: getUUID(),
       eventId,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       transactionId: getUUID(),
       action: {
-        type: ActionType.REQUEST_CORRECTION,
+        type: actionType,
+        status: ActionStatus.Accepted,
         declaration: {
           "applicant.firstname": "Max",
           "applicant.surname": "McLaren",
@@ -3981,7 +4166,8 @@ var eventPayloadGenerator = {
         },
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         createdBy: "@todo",
-        createdAtLocation: "@todo"
+        createdAtLocation: "@todo",
+        updatedAtLocation: "@todo"
       }
     },
     input
@@ -3990,8 +4176,11 @@ var eventPayloadGenerator = {
     declare: (eventId, input = {}) => ({
       type: ActionType.DECLARE,
       transactionId: input.transactionId ?? getUUID(),
-      declaration: input.declaration ?? generateActionInput(tennisClubMembershipEvent, ActionType.DECLARE),
-      annotation: input.annotation ?? generateActionMetadataInput(
+      declaration: input.declaration ?? generateActionDeclarationInput(
+        tennisClubMembershipEvent,
+        ActionType.DECLARE
+      ),
+      annotation: input.annotation ?? generateActionAnnotationInput(
         tennisClubMembershipEvent,
         ActionType.DECLARE
       ),
@@ -4003,9 +4192,12 @@ var eventPayloadGenerator = {
     notify: (eventId, input = {}) => {
       let declaration = input.declaration;
       if (!declaration) {
-        const partialDeclaration = (0, import_lodash2.omitBy)(
-          generateActionInput(tennisClubMembershipEvent, ActionType.DECLARE),
-          import_lodash2.isString
+        const partialDeclaration = (0, import_lodash3.omitBy)(
+          generateActionDeclarationInput(
+            tennisClubMembershipEvent,
+            ActionType.DECLARE
+          ),
+          import_lodash3.isString
         );
         declaration = partialDeclaration;
       }
@@ -4019,14 +4211,31 @@ var eventPayloadGenerator = {
     validate: (eventId, input = {}) => ({
       type: ActionType.VALIDATE,
       transactionId: input.transactionId ?? getUUID(),
-      declaration: input.declaration ?? generateActionInput(tennisClubMembershipEvent, ActionType.VALIDATE),
-      annotation: input.annotation ?? generateActionMetadataInput(
+      declaration: input.declaration ?? generateActionDeclarationInput(
+        tennisClubMembershipEvent,
+        ActionType.VALIDATE
+      ),
+      annotation: input.annotation ?? generateActionAnnotationInput(
         tennisClubMembershipEvent,
         ActionType.VALIDATE
       ),
       duplicates: [],
       eventId
     }),
+    assign: (eventId, input = {}) => ({
+      type: ActionType.ASSIGN,
+      transactionId: input.transactionId ?? getUUID(),
+      declaration: {},
+      assignedTo: input.assignedTo ?? getUUID(),
+      eventId
+    }),
+    unassign: (eventId, input = {}) => ({
+      type: ActionType.UNASSIGN,
+      transactionId: input.transactionId ?? getUUID(),
+      declaration: {},
+      assignedTo: null,
+      eventId
+    }),
     archive: (eventId, input = {}, isDuplicate) => ({
       type: ActionType.ARCHIVE,
       transactionId: input.transactionId ?? getUUID(),
@@ -4040,7 +4249,7 @@ var eventPayloadGenerator = {
       type: ActionType.REJECT,
       transactionId: input.transactionId ?? getUUID(),
       declaration: {},
-      annotation: input.annotation ?? generateActionMetadataInput(
+      annotation: input.annotation ?? generateActionAnnotationInput(
         tennisClubMembershipEvent,
         ActionType.REJECT
       ),
@@ -4050,8 +4259,11 @@ var eventPayloadGenerator = {
     register: (eventId, input = {}) => ({
       type: ActionType.REGISTER,
       transactionId: input.transactionId ?? getUUID(),
-      declaration: input.declaration ?? generateActionInput(tennisClubMembershipEvent, ActionType.REGISTER),
-      annotation: input.annotation ?? generateActionMetadataInput(
+      declaration: input.declaration ?? generateActionDeclarationInput(
+        tennisClubMembershipEvent,
+        ActionType.REGISTER
+      ),
+      annotation: input.annotation ?? generateActionAnnotationInput(
         tennisClubMembershipEvent,
         ActionType.REGISTER
       ),
@@ -4061,7 +4273,7 @@ var eventPayloadGenerator = {
       type: ActionType.PRINT_CERTIFICATE,
       transactionId: input.transactionId ?? getUUID(),
       declaration: {},
-      annotation: input.annotation ?? generateActionMetadataInput(
+      annotation: input.annotation ?? generateActionAnnotationInput(
         tennisClubMembershipEvent,
         ActionType.PRINT_CERTIFICATE
       ),
@@ -4071,11 +4283,11 @@ var eventPayloadGenerator = {
       request: (eventId, input = {}) => ({
         type: ActionType.REQUEST_CORRECTION,
         transactionId: input.transactionId ?? getUUID(),
-        declaration: input.declaration ?? generateActionInput(
+        declaration: input.declaration ?? generateActionDeclarationInput(
           tennisClubMembershipEvent,
           ActionType.REQUEST_CORRECTION
         ),
-        annotation: input.annotation ?? generateActionMetadataInput(
+        annotation: input.annotation ?? generateActionAnnotationInput(
           tennisClubMembershipEvent,
           ActionType.REQUEST_CORRECTION
         ),
@@ -4085,7 +4297,7 @@ var eventPayloadGenerator = {
         type: ActionType.APPROVE_CORRECTION,
         transactionId: input.transactionId ?? getUUID(),
         declaration: {},
-        annotation: input.annotation ?? generateActionMetadataInput(
+        annotation: input.annotation ?? generateActionAnnotationInput(
           tennisClubMembershipEvent,
           ActionType.APPROVE_CORRECTION
         ),
@@ -4096,7 +4308,7 @@ var eventPayloadGenerator = {
         type: ActionType.REJECT_CORRECTION,
         transactionId: input.transactionId ?? getUUID(),
         declaration: {},
-        annotation: input.annotation ?? generateActionMetadataInput(
+        annotation: input.annotation ?? generateActionAnnotationInput(
           tennisClubMembershipEvent,
           ActionType.REJECT_CORRECTION
         ),
@@ -4118,16 +4330,21 @@ function generateActionDocument({
     createdBy: getUUID(),
     id: getUUID(),
     createdAtLocation: "TODO",
-    declaration: generateActionInput(configuration, action),
+    updatedAtLocation: "TODO",
+    declaration: generateActionDeclarationInput(configuration, action),
     annotation: {},
     ...defaults,
     status: ActionStatus.Accepted
   };
   switch (action) {
+    case ActionType.READ:
+      return { ...actionBase, type: action };
+    case ActionType.MARKED_AS_DUPLICATE:
+      return { ...actionBase, type: action };
     case ActionType.DECLARE:
       return { ...actionBase, type: action };
     case ActionType.UNASSIGN:
-      return { ...actionBase, type: action };
+      return { ...actionBase, type: action, assignedTo: null };
     case ActionType.ASSIGN:
       return { ...actionBase, assignedTo: getUUID(), type: action };
     case ActionType.VALIDATE:
@@ -4153,6 +4370,8 @@ function generateActionDocument({
         ...actionBase,
         type: action
       };
+    case ActionType.DELETE:
+    case ActionType.DETECT_DUPLICATE:
     default:
       throw new Error(`Unsupported action type: ${action}`);
   }
@@ -4202,7 +4421,8 @@ var eventQueryDataGenerator = (overrides = {}) => ({
   createdAt: overrides.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
   createdBy: overrides.createdBy ?? getUUID(),
   createdAtLocation: overrides.createdAtLocation ?? getUUID(),
-  modifiedAt: overrides.modifiedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+  updatedAtLocation: overrides.updatedAtLocation ?? getUUID(),
+  updatedAt: overrides.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
   assignedTo: overrides.assignedTo ?? null,
   updatedBy: overrides.updatedBy ?? getUUID(),
   declaration: overrides.declaration ?? {
@@ -4236,7 +4456,9 @@ function isFieldValueWithoutTemplates(value) {
   return true;
 }
 function isFieldConfigDefaultValue(value) {
-  if (!value) return false;
+  if (!value) {
+    return false;
+  }
   if (isFieldValue(value)) {
     return true;
   }