@opencrvs/toolkit 1.8.0-rc.ff73871 → 1.8.0-rc.ffbb9d7

package/dist/events/index.js

@@ -30,20 +30,27 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/events/index.ts
 var events_exports = {};
 __export(events_exports, {
+  Action: () => Action,
   ActionBase: () => ActionBase,
   ActionConditional: () => ActionConditional,
   ActionConfig: () => ActionConfig,
   ActionConfigBase: () => ActionConfigBase,
   ActionDocument: () => ActionDocument,
+  ActionFormConfig: () => ActionFormConfig,
   ActionInput: () => ActionInput,
+  ActionStatus: () => ActionStatus,
   ActionType: () => ActionType,
+  ActionTypes: () => ActionTypes,
   ActionUpdate: () => ActionUpdate,
   AddressFieldUpdateValue: () => AddressFieldUpdateValue,
   AddressFieldValue: () => AddressFieldValue,
+  AddressType: () => AddressType,
   AdministrativeAreas: () => AdministrativeAreas,
   AdvancedSearchConfig: () => AdvancedSearchConfig,
   ApproveCorrectionActionInput: () => ApproveCorrectionActionInput,
   ArchiveActionInput: () => ArchiveActionInput,
+  AssignActionInput: () => AssignActionInput,
+  AsyncRejectActionDocument: () => AsyncRejectActionDocument,
   BaseActionInput: () => BaseActionInput,
   CertificateConfig: () => CertificateConfig,
   CertificateTemplateConfig: () => CertificateTemplateConfig,
@@ -51,9 +58,18 @@ __export(events_exports, {
   Clause: () => Clause,
   Conditional: () => Conditional,
   ConditionalType: () => ConditionalType,
+  ConfirmableActions: () => ConfirmableActions,
+  DataEntry: () => DataEntry,
+  DataFieldValue: () => DataFieldValue,
   DateValue: () => DateValue,
+  DeclarationActionConfig: () => DeclarationActionConfig,
+  DeclarationActions: () => DeclarationActions,
+  DeclarationFormConfig: () => DeclarationFormConfig,
+  DeclarationReviewConfig: () => DeclarationReviewConfig,
+  DeclarationUpdateActions: () => DeclarationUpdateActions,
   DeclareActionInput: () => DeclareActionInput,
   DeduplicationConfig: () => DeduplicationConfig,
+  DisplayOnReviewConditional: () => DisplayOnReviewConditional,
   Draft: () => Draft,
   DraftInput: () => DraftInput,
   EmailField: () => EmailField,
@@ -67,6 +83,7 @@ __export(events_exports, {
   EventSearchIndex: () => EventSearchIndex,
   EventStatus: () => EventStatus,
   EventStatuses: () => EventStatuses,
+  FieldConditional: () => FieldConditional,
   FieldConfig: () => FieldConfig,
   FieldType: () => FieldType,
   FieldUpdateValue: () => FieldUpdateValue,
@@ -75,13 +92,21 @@ __export(events_exports, {
   FileFieldValueWithOption: () => FileFieldValueWithOption,
   FileFieldWithOptionValue: () => FileFieldWithOptionValue,
   FormConfig: () => FormConfig,
-  FormPage: () => FormPage,
+  FormPageConfig: () => FormPageConfig,
+  GenericAddressUpdateValue: () => GenericAddressUpdateValue,
+  GenericAddressValue: () => GenericAddressValue,
   GeographicalArea: () => GeographicalArea,
+  ImageMimeType: () => ImageMimeType,
   LanguageConfig: () => LanguageConfig,
   MarkedAsDuplicateActionInput: () => MarkedAsDuplicateActionInput,
+  MimeType: () => MimeType,
   NotifyActionInput: () => NotifyActionInput,
   NumberFieldValue: () => NumberFieldValue,
+  PageConfig: () => PageConfig,
+  PageTypes: () => PageTypes,
   PrintCertificateActionInput: () => PrintCertificateActionInput,
+  ReadActionInput: () => ReadActionInput,
+  RegisterAction: () => RegisterAction,
   RegisterActionInput: () => RegisterActionInput,
   RejectCorrectionActionInput: () => RejectCorrectionActionInput,
   RejectDeclarationActionInput: () => RejectDeclarationActionInput,
@@ -94,20 +119,30 @@ __export(events_exports, {
   SummaryConfig: () => SummaryConfig,
   TextValue: () => TextValue,
   TranslationConfig: () => TranslationConfig,
+  UnassignActionInput: () => UnassignActionInput,
   UrbanAddressUpdateValue: () => UrbanAddressUpdateValue,
   UrbanAddressValue: () => UrbanAddressValue,
   ValidateActionInput: () => ValidateActionInput,
+  VerificationActionConfig: () => VerificationActionConfig,
+  VerificationPageConfig: () => VerificationPageConfig,
   WorkqueueConfig: () => WorkqueueConfig,
   alwaysTrue: () => alwaysTrue,
   and: () => and,
+  annotationActions: () => annotationActions,
   applyDraftsToEventIndex: () => applyDraftsToEventIndex,
   compositeFieldTypes: () => compositeFieldTypes,
+  createEmptyDraft: () => createEmptyDraft,
   createValidationSchema: () => createValidationSchema,
   deepDropNulls: () => deepDropNulls,
+  deepMerge: () => deepMerge,
+  defineActionForm: () => defineActionForm,
   defineConditional: () => defineConditional,
   defineConfig: () => defineConfig,
-  defineForm: () => defineForm,
+  defineDeclarationForm: () => defineDeclarationForm,
+  defineFormConditional: () => defineFormConditional,
   defineFormPage: () => defineFormPage,
+  definePage: () => definePage,
+  errorMessages: () => errorMessages,
   event: () => event,
   eventMetadataLabelMap: () => eventMetadataLabelMap,
   eventPayloadGenerator: () => eventPayloadGenerator,
@@ -115,37 +150,42 @@ __export(events_exports, {
   eventStatuses: () => eventStatuses,
   field: () => field,
   fieldTypes: () => fieldTypes,
-  findActiveActionFields: () => findActiveActionFields,
-  findActiveActionForm: () => findActiveActionForm,
-  findActiveActionFormFields: () => findActiveActionFormFields,
-  findActiveActionFormPages: () => findActiveActionFormPages,
-  findInputPageFields: () => findInputPageFields,
-  findPageFields: () => findPageFields,
+  findActiveDrafts: () => findActiveDrafts,
+  findAllFields: () => findAllFields,
+  findRecordActionPages: () => findRecordActionPages,
   generateActionDocument: () => generateActionDocument,
   generateActionInput: () => generateActionInput,
+  generateActionMetadataInput: () => generateActionMetadataInput,
   generateEventDocument: () => generateEventDocument,
   generateEventDraftDocument: () => generateEventDraftDocument,
   generateTransactionId: () => generateTransactionId,
-  getActiveActionFields: () => getActiveActionFields,
-  getActiveActionFormPages: () => getActiveActionFormPages,
-  getAllFields: () => getAllFields,
-  getAllPages: () => getAllPages,
+  generateTranslationConfig: () => generateTranslationConfig,
+  getAcceptedActions: () => getAcceptedActions,
+  getActionAnnotation: () => getActionAnnotation,
+  getActionAnnotationFields: () => getActionAnnotationFields,
+  getActionReview: () => getActionReview,
+  getActionReviewFields: () => getActionReviewFields,
+  getAllAnnotationFields: () => getAllAnnotationFields,
+  getAnnotationFromDrafts: () => getAnnotationFromDrafts,
   getCurrentEventState: () => getCurrentEventState,
   getCurrentEventStateWithDrafts: () => getCurrentEventStateWithDrafts,
-  getEventConfiguration: () => getEventConfiguration,
+  getDeclaration: () => getDeclaration,
+  getDeclarationFields: () => getDeclarationFields,
+  getDeclarationPages: () => getDeclarationPages,
   getFieldValidationErrors: () => getFieldValidationErrors,
-  getFormFields: () => getFormFields,
-  getMetadataForAction: () => getMetadataForAction,
+  getVisiblePagesFormFields: () => getVisiblePagesFormFields,
   isAddressFieldType: () => isAddressFieldType,
   isAdministrativeAreaFieldType: () => isAdministrativeAreaFieldType,
   isBulletListFieldType: () => isBulletListFieldType,
   isCheckboxFieldType: () => isCheckboxFieldType,
   isCountryFieldType: () => isCountryFieldType,
+  isDataFieldType: () => isDataFieldType,
   isDateFieldType: () => isDateFieldType,
   isDividerFieldType: () => isDividerFieldType,
   isEmailFieldType: () => isEmailFieldType,
   isFacilityFieldType: () => isFacilityFieldType,
   isFieldConfigDefaultValue: () => isFieldConfigDefaultValue,
+  isFieldDisplayedOnReview: () => isFieldDisplayedOnReview,
   isFieldEnabled: () => isFieldEnabled,
   isFieldValue: () => isFieldValue,
   isFieldValueWithoutTemplates: () => isFieldValueWithoutTemplates,
@@ -156,6 +196,7 @@ __export(events_exports, {
   isNumberFieldType: () => isNumberFieldType,
   isOfficeFieldType: () => isOfficeFieldType,
   isPageHeaderFieldType: () => isPageHeaderFieldType,
+  isPageVisible: () => isPageVisible,
   isParagraphFieldType: () => isParagraphFieldType,
   isRadioGroupFieldType: () => isRadioGroupFieldType,
   isSelectFieldType: () => isSelectFieldType,
@@ -164,12 +205,13 @@ __export(events_exports, {
   isTextAreaFieldType: () => isTextAreaFieldType,
   isTextFieldType: () => isTextFieldType,
   isUndeclaredDraft: () => isUndeclaredDraft,
+  isVerificationPage: () => isVerificationPage,
   mapFieldTypeToEmptyValue: () => mapFieldTypeToEmptyValue,
   mapFieldTypeToMockValue: () => mapFieldTypeToMockValue,
   mapFieldTypeToZod: () => mapFieldTypeToZod,
+  never: () => never,
   not: () => not,
   or: () => or,
-  resolveLabelsFromKnownFields: () => resolveLabelsFromKnownFields,
   stripHiddenFields: () => stripHiddenFields,
   user: () => user,
   validate: () => validate,
@@ -179,35 +221,52 @@ __export(events_exports, {
 module.exports = __toCommonJS(events_exports);
 
 // ../commons/src/events/ActionConfig.ts
-var import_zod7 = require("zod");
+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/FormConfig.ts
+// ../commons/src/events/PageConfig.ts
 var import_zod6 = require("zod");
 
 // ../commons/src/events/FieldConfig.ts
@@ -248,7 +307,8 @@ var FieldType = {
   ADMINISTRATIVE_AREA: "ADMINISTRATIVE_AREA",
   FACILITY: "FACILITY",
   OFFICE: "OFFICE",
-  SIGNATURE: "SIGNATURE"
+  SIGNATURE: "SIGNATURE",
+  DATA: "DATA"
 };
 var fieldTypes = Object.values(FieldType);
 var compositeFieldTypes = [
@@ -266,6 +326,10 @@ var GeographicalArea = {
   URBAN: "URBAN",
   RURAL: "RURAL"
 };
+var AddressType = {
+  DOMESTIC: "DOMESTIC",
+  INTERNATIONAL: "INTERNATIONAL"
+};
 var FileFieldValue = import_zod3.z.object({
   filename: import_zod3.z.string(),
   originalFilename: import_zod3.z.string(),
@@ -273,6 +337,7 @@ var FileFieldValue = import_zod3.z.object({
 });
 var AdminStructure = import_zod3.z.object({
   country: import_zod3.z.string(),
+  addressType: import_zod3.z.literal(AddressType.DOMESTIC),
   province: import_zod3.z.string(),
   district: import_zod3.z.string()
 });
@@ -300,14 +365,33 @@ var RuralAddressUpdateValue = AdminStructure.extend({
   urbanOrRural: import_zod3.z.literal(GeographicalArea.RURAL),
   village: import_zod3.z.string().nullish()
 });
-var AddressFieldValue = import_zod3.z.discriminatedUnion("urbanOrRural", [
-  UrbanAddressValue,
-  RuralAddressValue
-]);
+var GenericAddressValue = import_zod3.z.object({
+  country: import_zod3.z.string(),
+  addressType: import_zod3.z.literal(AddressType.INTERNATIONAL),
+  state: import_zod3.z.string(),
+  district2: import_zod3.z.string(),
+  cityOrTown: import_zod3.z.string().optional(),
+  addressLine1: import_zod3.z.string().optional(),
+  addressLine2: import_zod3.z.string().optional(),
+  addressLine3: import_zod3.z.string().optional(),
+  postcodeOrZip: import_zod3.z.string().optional()
+});
+var AddressFieldValue = import_zod3.z.discriminatedUnion("urbanOrRural", [UrbanAddressValue, RuralAddressValue]).or(GenericAddressValue);
+var GenericAddressUpdateValue = import_zod3.z.object({
+  country: import_zod3.z.string(),
+  addressType: import_zod3.z.literal(AddressType.INTERNATIONAL),
+  state: import_zod3.z.string(),
+  district2: import_zod3.z.string(),
+  cityOrTown: import_zod3.z.string().nullish(),
+  addressLine1: import_zod3.z.string().nullish(),
+  addressLine2: import_zod3.z.string().nullish(),
+  addressLine3: import_zod3.z.string().nullish(),
+  postcodeOrZip: import_zod3.z.string().nullish()
+});
 var AddressFieldUpdateValue = import_zod3.z.discriminatedUnion("urbanOrRural", [
   UrbanAddressUpdateValue,
   RuralAddressUpdateValue
-]);
+]).or(GenericAddressUpdateValue);
 var FileFieldValueWithOption = import_zod3.z.object({
   filename: import_zod3.z.string(),
   originalFilename: import_zod3.z.string(),
@@ -323,6 +407,7 @@ var DateValue = import_zod4.z.string().date().describe("Date in the format YYYY-
 var EmailValue = import_zod4.z.string().email();
 var CheckboxFieldValue = import_zod4.z.boolean();
 var NumberFieldValue = import_zod4.z.number();
+var DataFieldValue = import_zod4.z.undefined();
 var FieldValue = import_zod4.z.union([
   TextValue,
   DateValue,
@@ -331,7 +416,9 @@ var FieldValue = import_zod4.z.union([
   FileFieldValue,
   FileFieldWithOptionValue,
   UrbanAddressValue,
-  RuralAddressValue
+  RuralAddressValue,
+  DataFieldValue,
+  GenericAddressValue
 ]);
 var FieldUpdateValue = import_zod4.z.union([
   TextValue,
@@ -341,7 +428,9 @@ var FieldUpdateValue = import_zod4.z.union([
   FileFieldValue,
   FileFieldWithOptionValue,
   UrbanAddressUpdateValue,
-  RuralAddressUpdateValue
+  RuralAddressUpdateValue,
+  DataFieldValue,
+  GenericAddressUpdateValue
 ]);
 
 // ../commons/src/events/FieldConfig.ts
@@ -363,14 +452,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(),
@@ -412,15 +501,25 @@ var TextAreaField = BaseField.extend({
     postfix: TranslationConfig.optional()
   }).default({ rows: 4 }).optional()
 }).describe("Multiline text input");
+var ImageMimeType = import_zod5.z.enum([
+  "image/png",
+  "image/jpg",
+  "image/jpeg",
+  "image/svg+xml"
+]);
+var MimeType = ImageMimeType;
+var DEFAULT_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
 var SignatureField = BaseField.extend({
   type: import_zod5.z.literal(FieldType.SIGNATURE),
   signaturePromptLabel: TranslationConfig.describe(
     "Title of the signature modal"
   ),
   configuration: import_zod5.z.object({
-    maxSizeMb: import_zod5.z.number().optional().describe("Maximum file size in MB"),
-    allowedFileFormats: import_zod5.z.array(import_zod5.z.string()).optional().describe("List of allowed file formats for the signature")
-  }).default({}).optional()
+    maxFileSize: import_zod5.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+    acceptedFileTypes: MimeType.array().optional().describe("List of allowed file formats for the signature")
+  }).default({
+    maxFileSize: DEFAULT_MAX_FILE_SIZE_BYTES
+  })
 }).describe("Signature input field");
 var EmailField = BaseField.extend({
   type: import_zod5.z.literal(FieldType.EMAIL),
@@ -463,13 +562,17 @@ var PageHeader = BaseField.extend({
 }).describe("A read-only header component for form pages");
 var File = BaseField.extend({
   type: import_zod5.z.literal(FieldType.FILE),
-  options: import_zod5.z.object({
+  configuration: import_zod5.z.object({
+    maxFileSize: import_zod5.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+    acceptedFileTypes: MimeType.array().optional().describe("List of allowed file formats for the signature"),
     style: import_zod5.z.object({
-      fullWidth: import_zod5.z.boolean().describe(
+      width: import_zod5.z.enum(["full", "auto"]).optional().describe(
         "Whether the file upload button should take the full width of the container or not"
       )
-    })
-  }).optional()
+    }).optional()
+  }).default({
+    maxFileSize: DEFAULT_MAX_FILE_SIZE_BYTES
+  })
 }).describe("File upload");
 var SelectOption = import_zod5.z.object({
   value: import_zod5.z.string().describe("The value of the option"),
@@ -515,7 +618,7 @@ var AdministrativeAreas = import_zod5.z.enum([
 ]);
 var AdministrativeAreaConfiguration = import_zod5.z.object({
   partOf: import_zod5.z.object({
-    $data: import_zod5.z.string()
+    $declaration: import_zod5.z.string()
   }).optional().describe("Parent location"),
   type: AdministrativeAreas
 }).describe("Administrative area options");
@@ -530,8 +633,14 @@ var Location = BaseField.extend({
 }).describe("Input field for a location");
 var FileUploadWithOptions = BaseField.extend({
   type: import_zod5.z.literal(FieldType.FILE_WITH_OPTIONS),
-  options: import_zod5.z.array(SelectOption).describe("A list of options")
-}).describe("Select input");
+  options: import_zod5.z.array(SelectOption).describe("A list of options"),
+  configuration: import_zod5.z.object({
+    maxFileSize: import_zod5.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+    acceptedFileTypes: MimeType.array().optional().describe("List of allowed file formats for the signature")
+  }).default({
+    maxFileSize: DEFAULT_MAX_FILE_SIZE_BYTES
+  })
+});
 var Facility = BaseField.extend({
   type: import_zod5.z.literal(FieldType.FACILITY),
   defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional()
@@ -544,6 +653,22 @@ var Address = BaseField.extend({
   type: import_zod5.z.literal(FieldType.ADDRESS),
   defaultValue: AddressFieldValue.optional()
 }).describe("Address input field \u2013 a combination of location and text fields");
+var DataEntry = import_zod5.z.union([
+  import_zod5.z.object({
+    label: TranslationConfig,
+    value: import_zod5.z.string()
+  }),
+  import_zod5.z.object({
+    fieldId: import_zod5.z.string()
+  })
+]);
+var DataField = BaseField.extend({
+  type: import_zod5.z.literal(FieldType.DATA),
+  configuration: import_zod5.z.object({
+    subtitle: TranslationConfig.optional(),
+    data: import_zod5.z.array(DataEntry)
+  })
+}).describe("Data field for displaying read-only data");
 var FieldConfig = import_zod5.z.discriminatedUnion("type", [
   Address,
   TextField,
@@ -565,138 +690,204 @@ var FieldConfig = import_zod5.z.discriminatedUnion("type", [
   Office,
   SignatureField,
   EmailField,
-  FileUploadWithOptions
+  FileUploadWithOptions,
+  DataField
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ]);
 
-// ../commons/src/events/FormConfig.ts
-var FormPage = import_zod6.z.object({
+// ../commons/src/events/PageConfig.ts
+var PageTypes = import_zod6.z.enum(["FORM", "VERIFICATION"]);
+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")
+  fields: import_zod6.z.array(FieldConfig).describe("Fields to be rendered on the page"),
+  conditional: Conditional.optional().describe(
+    "Page will be shown if condition is met. If conditional is not defined, the page will be always shown."
+  )
 });
-var FormConfig = import_zod6.z.object({
-  label: TranslationConfig.describe("Human readable description of the form"),
-  version: import_zod6.z.object({
-    id: import_zod6.z.string().describe(
-      "Form version. Semantic versioning recommended. Example: 0.0.1"
-    ),
-    label: TranslationConfig.describe(
-      "Human readable description of the version"
-    )
-  }),
-  active: import_zod6.z.boolean().default(false).describe("Whether the form is active"),
-  pages: import_zod6.z.array(FormPage),
-  review: import_zod6.z.object({
-    title: TranslationConfig.describe(
-      "Title of the form to show in review page"
-    ),
-    fields: import_zod6.z.array(FieldConfig).describe("Fields to be rendered on the review page for metadata")
+var FormPageConfig = PageConfigBase.extend({
+  type: import_zod6.z.literal(PageTypes.enum.FORM).default(PageTypes.enum.FORM)
+});
+var VerificationActionConfig = import_zod6.z.object({
+  verify: import_zod6.z.object({ label: TranslationConfig }),
+  cancel: import_zod6.z.object({
+    label: TranslationConfig,
+    confirmation: import_zod6.z.object({
+      title: TranslationConfig,
+      body: TranslationConfig
+    })
   })
+}).describe("Actions available on the verification page");
+var VerificationPageConfig = FormPageConfig.extend({
+  type: import_zod6.z.literal(PageTypes.enum.VERIFICATION),
+  actions: VerificationActionConfig
 });
+var PageConfig = import_zod6.z.discriminatedUnion("type", [
+  FormPageConfig,
+  VerificationPageConfig
+]);
 
 // ../commons/src/events/ActionType.ts
+var import_zod7 = require("zod");
 var ActionType = {
+  // Pre-declaration actions
+  DELETE: "DELETE",
   CREATE: "CREATE",
-  ASSIGN: "ASSIGN",
-  UNASSIGN: "UNASSIGN",
-  REGISTER: "REGISTER",
-  VALIDATE: "VALIDATE",
-  REQUEST_CORRECTION: "REQUEST_CORRECTION",
-  REJECT_CORRECTION: "REJECT_CORRECTION",
-  APPROVE_CORRECTION: "APPROVE_CORRECTION",
-  DETECT_DUPLICATE: "DETECT_DUPLICATE",
   NOTIFY: "NOTIFY",
+  // Declaration actions
   DECLARE: "DECLARE",
-  DELETE: "DELETE",
-  PRINT_CERTIFICATE: "PRINT_CERTIFICATE",
-  CUSTOM: "CUSTOM",
+  VALIDATE: "VALIDATE",
+  REGISTER: "REGISTER",
+  // Declaration system actions. Non-configurable.
+  DETECT_DUPLICATE: "DETECT_DUPLICATE",
   REJECT: "REJECT",
+  // REJECT_DECLARATION
   MARKED_AS_DUPLICATE: "MARKED_AS_DUPLICATE",
-  ARCHIVE: "ARCHIVE"
+  // MARK_AS_DUPLICATE
+  ARCHIVE: "ARCHIVE",
+  // Record actions
+  PRINT_CERTIFICATE: "PRINT_CERTIFICATE",
+  REQUEST_CORRECTION: "REQUEST_CORRECTION",
+  REJECT_CORRECTION: "REJECT_CORRECTION",
+  APPROVE_CORRECTION: "APPROVE_CORRECTION",
+  // General actions
+  READ: "READ",
+  ASSIGN: "ASSIGN",
+  UNASSIGN: "UNASSIGN"
 };
+var ConfirmableActions = [
+  ActionType.NOTIFY,
+  ActionType.DECLARE,
+  ActionType.VALIDATE,
+  ActionType.REGISTER,
+  ActionType.REJECT,
+  ActionType.ARCHIVE,
+  ActionType.PRINT_CERTIFICATE
+];
+var ActionTypes = import_zod7.z.enum([
+  "DELETE",
+  "CREATE",
+  "NOTIFY",
+  "DECLARE",
+  "VALIDATE",
+  "REGISTER",
+  "DETECT_DUPLICATE",
+  "REJECT",
+  "MARKED_AS_DUPLICATE",
+  "ARCHIVE",
+  "PRINT_CERTIFICATE",
+  "REQUEST_CORRECTION",
+  "REJECT_CORRECTION",
+  "APPROVE_CORRECTION",
+  "READ",
+  "ASSIGN",
+  "UNASSIGN"
+]);
+var declarationActionValues = [
+  ActionTypes.enum.DECLARE,
+  ActionTypes.enum.VALIDATE,
+  ActionTypes.enum.REGISTER
+];
+var DeclarationActions = ActionTypes.extract(declarationActionValues);
+var declarationUpdateActionValues = [
+  ...declarationActionValues,
+  ActionTypes.enum.REQUEST_CORRECTION
+];
+var DeclarationUpdateActions = ActionTypes.extract(
+  declarationUpdateActionValues
+);
+var annotationActions = ActionTypes.exclude(declarationActionValues);
+
+// ../commons/src/events/FormConfig.ts
+var import_zod8 = require("zod");
+var DeclarationFormConfig = import_zod8.z.object({
+  label: TranslationConfig.describe("Human readable description of the form"),
+  pages: import_zod8.z.array(FormPageConfig)
+}).describe("Configuration for a declaration form");
+var ActionFormConfig = import_zod8.z.object({
+  label: TranslationConfig.describe("Human readable description of the form"),
+  pages: import_zod8.z.array(PageConfig)
+});
+var FormConfig = import_zod8.z.union([DeclarationFormConfig, ActionFormConfig]);
 
 // ../commons/src/events/ActionConfig.ts
-var ActionConditional2 = import_zod7.z.discriminatedUnion("type", [
+var ActionConditional2 = import_zod9.z.discriminatedUnion("type", [
   /** If conditional is defined, the action is shown to the user only if the condition is met */
   ShowConditional,
   /** If conditional is defined, the action is enabled only if the condition is met */
   EnableConditional
 ]);
-var ActionConfigBase = import_zod7.z.object({
+var DeclarationReviewConfig = import_zod9.z.object({
+  title: TranslationConfig.describe("Title of the review page"),
+  fields: import_zod9.z.array(FieldConfig).describe("Fields to be rendered on the review page for annotations.")
+}).describe("Configuration for **declaration** review page.");
+var ActionConfigBase = import_zod9.z.object({
   label: TranslationConfig,
-  conditionals: import_zod7.z.array(ActionConditional2).optional().default([]),
-  draft: import_zod7.z.boolean().optional(),
-  forms: import_zod7.z.array(FormConfig)
+  conditionals: import_zod9.z.array(ActionConditional2).optional().default([]),
+  draft: import_zod9.z.boolean().optional()
 });
 var DeclareConfig = ActionConfigBase.merge(
-  import_zod7.z.object({
-    type: import_zod7.z.literal(ActionType.DECLARE)
+  import_zod9.z.object({
+    type: import_zod9.z.literal(ActionType.DECLARE),
+    review: DeclarationReviewConfig
   })
 );
 var ValidateConfig = ActionConfigBase.merge(
-  import_zod7.z.object({
-    type: import_zod7.z.literal(ActionType.VALIDATE)
+  import_zod9.z.object({
+    type: import_zod9.z.literal(ActionType.VALIDATE),
+    review: DeclarationReviewConfig
+  })
+);
+var RegisterConfig = ActionConfigBase.merge(
+  import_zod9.z.object({
+    type: import_zod9.z.literal(ActionType.REGISTER),
+    review: DeclarationReviewConfig
   })
 );
 var RejectDeclarationConfig = ActionConfigBase.merge(
-  import_zod7.z.object({
-    type: import_zod7.z.literal(ActionType.REJECT),
-    comment: import_zod7.z.string(),
-    isDuplicate: import_zod7.z.boolean()
+  import_zod9.z.object({
+    type: import_zod9.z.literal(ActionType.REJECT)
   })
 );
 var MarkedAsDuplicateConfig = ActionConfigBase.merge(
-  import_zod7.z.object({
-    type: import_zod7.z.literal(ActionType.MARKED_AS_DUPLICATE),
-    comment: import_zod7.z.string(),
-    duplicates: import_zod7.z.array(import_zod7.z.string()).describe("UUIDs of duplicate records")
+  import_zod9.z.object({
+    type: import_zod9.z.literal(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveConfig = ActionConfigBase.merge(
-  import_zod7.z.object({
-    type: import_zod7.z.literal(ActionType.ARCHIVE),
-    comment: import_zod7.z.string(),
-    isDuplicate: import_zod7.z.boolean()
-  })
-);
-var RegisterConfig = ActionConfigBase.merge(
-  import_zod7.z.object({
-    type: import_zod7.z.literal(ActionType.REGISTER)
+  import_zod9.z.object({
+    type: import_zod9.z.literal(ActionType.ARCHIVE)
   })
 );
 var DeleteConfig = ActionConfigBase.merge(
-  import_zod7.z.object({
-    type: import_zod7.z.literal(ActionType.DELETE)
+  import_zod9.z.object({
+    type: import_zod9.z.literal(ActionType.DELETE)
   })
 );
 var PrintCertificateActionConfig = ActionConfigBase.merge(
-  import_zod7.z.object({
-    type: import_zod7.z.literal(ActionType.PRINT_CERTIFICATE)
+  import_zod9.z.object({
+    type: import_zod9.z.literal(ActionType.PRINT_CERTIFICATE),
+    printForm: ActionFormConfig
   })
 );
 var RequestCorrectionConfig = ActionConfigBase.merge(
-  import_zod7.z.object({
-    type: import_zod7.z.literal(ActionType.REQUEST_CORRECTION),
-    onboardingForm: import_zod7.z.array(FormPage),
-    additionalDetailsForm: import_zod7.z.array(FormPage)
+  import_zod9.z.object({
+    type: import_zod9.z.literal(ActionType.REQUEST_CORRECTION),
+    onboardingForm: import_zod9.z.array(PageConfig),
+    additionalDetailsForm: import_zod9.z.array(PageConfig)
   })
 );
 var RejectCorrectionConfig = ActionConfigBase.merge(
-  import_zod7.z.object({
-    type: import_zod7.z.literal(ActionType.REJECT_CORRECTION)
+  import_zod9.z.object({
+    type: import_zod9.z.literal(ActionType.REJECT_CORRECTION)
   })
 );
 var ApproveCorrectionConfig = ActionConfigBase.merge(
-  import_zod7.z.object({
-    type: import_zod7.z.literal(ActionType.APPROVE_CORRECTION)
-  })
-);
-var CustomConfig = ActionConfigBase.merge(
-  import_zod7.z.object({
-    type: import_zod7.z.literal(ActionType.CUSTOM)
+  import_zod9.z.object({
+    type: import_zod9.z.literal(ActionType.APPROVE_CORRECTION)
   })
 );
-var ActionConfig = import_zod7.z.discriminatedUnion("type", [
+var ActionConfig = import_zod9.z.discriminatedUnion("type", [
   DeclareConfig,
   ValidateConfig,
   RejectDeclarationConfig,
@@ -707,102 +898,108 @@ var ActionConfig = import_zod7.z.discriminatedUnion("type", [
   PrintCertificateActionConfig,
   RequestCorrectionConfig,
   RejectCorrectionConfig,
-  ApproveCorrectionConfig,
-  CustomConfig
+  ApproveCorrectionConfig
+]);
+var DeclarationActionConfig = import_zod9.z.discriminatedUnion("type", [
+  DeclareConfig,
+  ValidateConfig,
+  RegisterConfig
 ]);
 
 // ../commons/src/events/offline/CertificateConfig.ts
-var import_zod8 = require("zod");
-var FontFamily = import_zod8.z.object({
-  normal: import_zod8.z.string(),
-  bold: import_zod8.z.string(),
-  italics: import_zod8.z.string(),
-  bolditalics: import_zod8.z.string()
+var import_zod10 = require("zod");
+var FontFamily = import_zod10.z.object({
+  normal: import_zod10.z.string(),
+  bold: import_zod10.z.string(),
+  italics: import_zod10.z.string(),
+  bolditalics: import_zod10.z.string()
 });
-var CertificateConfig = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  event: import_zod8.z.string(),
+var CertificateConfig = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  event: import_zod10.z.string(),
   label: TranslationConfig,
-  isDefault: import_zod8.z.boolean(),
-  fee: import_zod8.z.object({
-    onTime: import_zod8.z.number(),
-    late: import_zod8.z.number(),
-    delayed: import_zod8.z.number()
+  isDefault: import_zod10.z.boolean(),
+  fee: import_zod10.z.object({
+    onTime: import_zod10.z.number(),
+    late: import_zod10.z.number(),
+    delayed: import_zod10.z.number()
   }),
-  svgUrl: import_zod8.z.string(),
-  fonts: import_zod8.z.record(FontFamily).optional()
+  svgUrl: import_zod10.z.string(),
+  fonts: import_zod10.z.record(FontFamily).optional()
 });
 var CertificateTemplateConfig = CertificateConfig.extend({
-  hash: import_zod8.z.string().optional(),
-  svg: import_zod8.z.string()
+  hash: import_zod10.z.string().optional(),
+  svg: import_zod10.z.string()
 });
 
 // ../commons/src/events/offline/LanguageConfig.ts
-var import_zod9 = require("zod");
-var LanguageConfig = import_zod9.z.object({
-  lang: import_zod9.z.string(),
+var import_zod11 = require("zod");
+var LanguageConfig = import_zod11.z.object({
+  lang: import_zod11.z.string(),
   /**
    * client.csv contents
    */
-  messages: import_zod9.z.record(import_zod9.z.string())
+  messages: import_zod11.z.record(import_zod11.z.string())
 });
 
 // ../commons/src/events/EventConfig.ts
-var import_zod18 = require("zod");
+var import_zod20 = require("zod");
 
 // ../commons/src/events/DeduplicationConfig.ts
-var import_zod10 = require("zod");
-var FieldReference = import_zod10.z.string();
-var Matcher = import_zod10.z.object({
-  fieldId: import_zod10.z.string(),
-  options: import_zod10.z.object({
-    boost: import_zod10.z.number().optional()
+var import_zod12 = require("zod");
+var FieldReference = import_zod12.z.string();
+var Matcher = import_zod12.z.object({
+  fieldId: import_zod12.z.string(),
+  options: import_zod12.z.object({
+    boost: import_zod12.z.number().optional()
   }).optional().default({})
 });
 var FuzzyMatcher = Matcher.extend({
-  type: import_zod10.z.literal("fuzzy"),
-  options: import_zod10.z.object({
+  type: import_zod12.z.literal("fuzzy"),
+  options: import_zod12.z.object({
     /**
      * Names of length 3 or less characters = 0 edits allowed
      * Names of length 4 - 6 characters = 1 edit allowed
      * Names of length >7 characters = 2 edits allowed
      */
-    fuzziness: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.number()]).optional().default("AUTO:4,7"),
-    boost: import_zod10.z.number().optional().default(1)
+    fuzziness: import_zod12.z.union([import_zod12.z.string(), import_zod12.z.number()]).optional().default("AUTO:4,7"),
+    boost: import_zod12.z.number().optional().default(1)
   }).optional().default({})
 });
 var StrictMatcher = Matcher.extend({
-  type: import_zod10.z.literal("strict"),
-  options: import_zod10.z.object({
-    boost: import_zod10.z.number().optional().default(1)
+  type: import_zod12.z.literal("strict"),
+  options: import_zod12.z.object({
+    boost: import_zod12.z.number().optional().default(1)
   }).optional().default({})
 });
 var DateRangeMatcher = Matcher.extend({
-  type: import_zod10.z.literal("dateRange"),
-  options: import_zod10.z.object({
-    days: import_zod10.z.number(),
+  type: import_zod12.z.literal("dateRange"),
+  options: import_zod12.z.object({
+    days: import_zod12.z.number(),
     origin: FieldReference,
-    boost: import_zod10.z.number().optional().default(1)
+    boost: import_zod12.z.number().optional().default(1)
   })
 });
 var DateDistanceMatcher = Matcher.extend({
-  type: import_zod10.z.literal("dateDistance"),
-  options: import_zod10.z.object({
-    days: import_zod10.z.number(),
+  type: import_zod12.z.literal("dateDistance"),
+  options: import_zod12.z.object({
+    days: import_zod12.z.number(),
     origin: FieldReference,
-    boost: import_zod10.z.number().optional().default(1)
+    boost: import_zod12.z.number().optional().default(1)
   })
 });
-var And = import_zod10.z.object({
-  type: import_zod10.z.literal("and"),
-  clauses: import_zod10.z.lazy(() => Clause.array())
+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_zod10.z.object({
-  type: import_zod10.z.literal("or"),
-  clauses: import_zod10.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_zod10.z.lazy(
-  () => import_zod10.z.discriminatedUnion("type", [
+var Clause = import_zod12.z.lazy(
+  () => import_zod12.z.discriminatedUnion("type", [
     And,
     Or,
     FuzzyMatcher,
@@ -811,37 +1008,37 @@ var Clause = import_zod10.z.lazy(
     DateDistanceMatcher
   ])
 );
-var DeduplicationConfig = import_zod10.z.object({
-  id: import_zod10.z.string(),
+var DeduplicationConfig = import_zod12.z.object({
+  id: import_zod12.z.string(),
   label: TranslationConfig,
   query: Clause
 });
 
 // ../commons/src/events/SummaryConfig.ts
-var import_zod11 = require("zod");
-var Field = import_zod11.z.object({
-  id: import_zod11.z.string().describe("Id of summary field"),
+var import_zod13 = require("zod");
+var Field = import_zod13.z.object({
+  id: import_zod13.z.string().describe("Id of summary field"),
   value: TranslationConfig.describe(
     "Summary field value. Can utilise values defined in configuration and EventMetadata"
   ),
   label: TranslationConfig,
   emptyValueMessage: TranslationConfig.optional()
 });
-var Title = import_zod11.z.object({
-  id: import_zod11.z.string(),
+var Title = import_zod13.z.object({
+  id: import_zod13.z.string(),
   label: TranslationConfig.describe("Title content"),
   emptyValueMessage: TranslationConfig.optional()
 });
-var SummaryConfig = import_zod11.z.object({
+var SummaryConfig = import_zod13.z.object({
   title: Title.describe("Title of summary view."),
-  fields: import_zod11.z.array(Field).describe("Fields rendered in summary view.")
+  fields: import_zod13.z.array(Field).describe("Fields rendered in summary view.")
 }).describe("Configuration for summary in event.");
 
 // ../commons/src/events/WorkqueueConfig.ts
-var import_zod13 = require("zod");
+var import_zod15 = require("zod");
 
 // ../commons/src/events/EventMetadata.ts
-var import_zod12 = require("zod");
+var import_zod14 = require("zod");
 var EventStatus = {
   CREATED: "CREATED",
   NOTIFIED: "NOTIFIED",
@@ -853,18 +1050,19 @@ var EventStatus = {
   ARCHIVED: "ARCHIVED"
 };
 var eventStatuses = Object.values(EventStatus);
-var EventStatuses = import_zod12.z.nativeEnum(EventStatus);
-var EventMetadata = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  type: import_zod12.z.string(),
+var EventStatuses = import_zod14.z.nativeEnum(EventStatus);
+var EventMetadata = import_zod14.z.object({
+  id: import_zod14.z.string(),
+  type: import_zod14.z.string(),
   status: EventStatuses,
-  createdAt: import_zod12.z.string().datetime(),
-  createdBy: import_zod12.z.string(),
-  createdAtLocation: import_zod12.z.string(),
-  modifiedAt: import_zod12.z.string().datetime(),
-  assignedTo: import_zod12.z.string().nullish(),
-  updatedBy: import_zod12.z.string(),
-  trackingId: import_zod12.z.string()
+  createdAt: import_zod14.z.string().datetime(),
+  createdBy: import_zod14.z.string(),
+  createdAtLocation: import_zod14.z.string(),
+  modifiedAt: import_zod14.z.string().datetime(),
+  assignedTo: import_zod14.z.string().nullish(),
+  updatedBy: import_zod14.z.string(),
+  trackingId: import_zod14.z.string(),
+  registrationNumber: import_zod14.z.string().nullish()
 });
 var eventMetadataLabelMap = {
   "event.assignedTo": {
@@ -916,28 +1114,33 @@ var eventMetadataLabelMap = {
     id: "event.trackingId.label",
     defaultMessage: "Tracking ID",
     description: "Tracking ID"
+  },
+  "event.registrationNumber": {
+    id: "event.registrationNumber.label",
+    defaultMessage: "Registration Number",
+    description: "Registration Number"
   }
 };
 
 // ../commons/src/events/WorkqueueConfig.ts
-var WorkqueueConfig = import_zod13.z.object({
-  id: import_zod13.z.string().describe("Unique identifier for workqueue."),
-  filters: import_zod13.z.array(
-    import_zod13.z.object({
-      status: import_zod13.z.array(EventStatuses).describe("Defines which statusese are included in the workqueue.")
+var WorkqueueConfig = import_zod15.z.object({
+  id: import_zod15.z.string().describe("Unique identifier for workqueue."),
+  filters: import_zod15.z.array(
+    import_zod15.z.object({
+      status: import_zod15.z.array(EventStatuses).describe("Defines which statusese are included in the workqueue.")
     })
   ).describe("Filters to be applied to workqueue.")
 }).describe("Configuration for workqueue.");
 
 // ../commons/src/events/AdvancedSearchConfig.ts
-var import_zod14 = require("zod");
-var AdvancedSearchConfig = import_zod14.z.object({
+var import_zod16 = require("zod");
+var AdvancedSearchConfig = import_zod16.z.object({
   title: TranslationConfig.describe("Advanced search tab title"),
-  fields: import_zod14.z.array(
-    import_zod14.z.object({
-      fieldId: import_zod14.z.string(),
-      config: import_zod14.z.object({
-        type: import_zod14.z.enum(["FUZZY", "EXACT", "RANGE"]).describe("Determines the type of field")
+  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.")
@@ -947,12 +1150,12 @@ var AdvancedSearchConfig = import_zod14.z.object({
 var import_lodash = require("lodash");
 
 // ../commons/src/workqueues/WorkqueueConfig.ts
-var import_zod16 = require("zod");
+var import_zod18 = require("zod");
 
 // ../commons/src/workqueues/defaultColumns.ts
-var import_zod15 = require("zod");
-var WorkQueueColumnConfig = import_zod15.z.object({
-  id: import_zod15.z.string(),
+var import_zod17 = require("zod");
+var WorkQueueColumnConfig = import_zod17.z.object({
+  id: import_zod17.z.string(),
   label: TranslationConfig
 });
 var defaultColumns = {
@@ -989,16 +1192,16 @@ var defaultColumns = {
     }
   }
 };
-var DefaultColumnKeys = import_zod15.z.enum(
+var DefaultColumnKeys = import_zod17.z.enum(
   Object.keys(defaultColumns)
 );
 
 // ../commons/src/workqueues/WorkqueueConfig.ts
-var rootWorkqueueConfig = import_zod16.z.object({
-  id: import_zod16.z.string(),
+var rootWorkqueueConfig = import_zod18.z.object({
+  id: import_zod18.z.string(),
   title: TranslationConfig,
-  columns: import_zod16.z.array(WorkQueueColumnConfig),
-  defaultColumns: import_zod16.z.array(DefaultColumnKeys)
+  columns: import_zod18.z.array(WorkQueueColumnConfig),
+  defaultColumns: import_zod18.z.array(DefaultColumnKeys)
 });
 var defineWorkqueue = (config) => rootWorkqueueConfig.parse(config);
 
@@ -1078,7 +1281,7 @@ var import_ajv_formats = __toESM(require("ajv-formats"));
 var import_date_fns = require("date-fns");
 
 // ../commons/src/events/FieldTypeMapping.ts
-var import_zod17 = require("zod");
+var import_zod19 = require("zod");
 function mapFieldTypeToZod(type, required) {
   let schema;
   switch (type) {
@@ -1120,6 +1323,9 @@ function mapFieldTypeToZod(type, required) {
     case FieldType.ADDRESS:
       schema = AddressFieldUpdateValue;
       break;
+    case FieldType.DATA:
+      schema = DataFieldValue;
+      break;
   }
   return required ? schema : schema.nullish();
 }
@@ -1128,7 +1334,7 @@ function createValidationSchema(config) {
   for (const field2 of config) {
     shape[field2.id] = mapFieldTypeToZod(field2.type, field2.required);
   }
-  return import_zod17.z.object(shape);
+  return import_zod19.z.object(shape);
 }
 function mapFieldTypeToMockValue(field2, i) {
   switch (field2.type) {
@@ -1154,6 +1360,7 @@ function mapFieldTypeToMockValue(field2, i) {
     case FieldType.ADDRESS:
       return {
         country: "FAR",
+        addressType: AddressType.DOMESTIC,
         province: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
         district: "5ef450bc-712d-48ad-93f3-8da0fa453baa",
         urbanOrRural: "URBAN",
@@ -1175,6 +1382,8 @@ function mapFieldTypeToMockValue(field2, i) {
       };
     case FieldType.FILE_WITH_OPTIONS:
       return null;
+    case FieldType.DATA:
+      return {};
   }
 }
 function mapFieldTypeToEmptyValue(field2) {
@@ -1197,10 +1406,12 @@ function mapFieldTypeToEmptyValue(field2) {
     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",
@@ -1284,10 +1495,14 @@ var isFacilityFieldType = (field2) => {
 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
+  $data: true,
+  allowUnionTypes: true
 });
 (0, import_ajv_formats.default)(ajv);
 function validate(schema, data) {
@@ -1320,50 +1535,103 @@ function isFieldVisible(field2, form) {
 function isFieldEnabled(field2, form) {
   return isFieldConditionMet(field2, form, ConditionalType.ENABLE);
 }
-var zodToIntlErrorMap = (issue, _ctx) => {
-  if (issue.code === "invalid_string" && issue.validation === "date") {
-    return {
-      message: {
-        message: {
-          defaultMessage: "Invalid date. Please use the format YYYY-MM-DD",
-          description: "This is the error message for invalid date fields",
-          id: "v2.error.invalidDate"
-        }
-      }
-    };
+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"
   }
-  if (issue.code === "invalid_string" && issue.validation === "email") {
-    return {
-      message: {
-        message: {
-          defaultMessage: "Invalid email address",
-          description: "This is the error message for invalid email fields",
-          id: "v2.error.invalidEmail"
-        }
+};
+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.code === "invalid_type" && issue.expected !== issue.received && issue.received === "undefined" || issue.code === "too_small" && issue.message === void 0) {
-    return {
-      message: {
-        message: {
-          defaultMessage: "Required for registration",
-          description: "This is the error message for required fields",
-          id: "v2.error.required"
+      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 {
-    message: {
-      message: {
-        defaultMessage: "Invalid input",
-        description: "This is the error message for invalid field value",
-        id: "v2.error.invalid"
-      }
+  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 getFieldValidationErrors({
   field: field2,
   values
@@ -1377,11 +1645,7 @@ function getFieldValidationErrors({
       return {
         errors: [
           {
-            message: {
-              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"
-            }
+            message: errorMessages.hiddenField
           }
         ]
       };
@@ -1399,32 +1663,20 @@ function getFieldValidationErrors({
     conditionalParameters
   });
   return {
-    // Assumes that custom validation errors are more important than field validation errors
-    errors: [...customValidationResults, ...fieldValidationResult]
+    // 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) {
@@ -1434,66 +1686,63 @@ function getOrThrow(x, message) {
 }
 
 // ../commons/src/events/utils.ts
-function isMetadataField(field2) {
-  return field2 in eventMetadataLabelMap;
-}
-var findInputPageFields = (config) => {
-  return (0, import_lodash.flattenDeep)(
-    config.actions.map(
-      ({ forms }) => forms.map(
-        ({ pages }) => pages.map(
-          ({ fields }) => fields.map(({ id, label }) => ({ id, label }))
-        )
-      )
-    )
-  );
+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 findPageFields = (config) => {
-  return (0, import_lodash.flattenDeep)(
-    config.actions.map((action) => {
-      if (action.type === ActionType.REQUEST_CORRECTION) {
-        return [
-          ...action.forms.map(({ pages }) => pages.map(({ fields }) => fields)),
-          ...action.onboardingForm.flatMap(({ fields }) => fields),
-          ...action.additionalDetailsForm.flatMap(({ fields }) => fields)
-        ];
-      }
-      return action.forms.map(({ pages }) => pages.map(({ fields }) => fields));
-    })
-  );
+var getAllAnnotationFields = (config) => {
+  return (0, import_lodash.flattenDeep)(config.actions.map(getActionAnnotationFields));
 };
-var resolveLabelsFromKnownFields = ({
-  pageFields,
-  refFields
-}) => {
-  return refFields.map((field2) => {
-    if (field2.label) {
-      return field2;
-    }
-    if (isMetadataField(field2.id)) {
-      return {
-        ...field2,
-        label: eventMetadataLabelMap[field2.id]
-      };
-    }
-    const pageLabel = pageFields.find((pageField) => pageField.id === field2.id);
-    if (!pageLabel) {
-      throw new Error(`Referenced field ${field2.id} does not have a label`);
-    }
-    return {
-      ...field2,
-      label: pageLabel.label
-    };
-  });
-};
-function getAllFields(configuration) {
-  return configuration.actions.flatMap((action) => action.forms.filter((form) => form.active)).flatMap((form) => [
-    ...form.review.fields,
-    ...form.pages.flatMap((page) => page.fields)
+var findAllFields = (config) => {
+  return (0, import_lodash.flattenDeep)([
+    ...getDeclarationFields(config),
+    ...getAllAnnotationFields(config)
   ]);
+};
+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 getAllPages(configuration) {
-  return configuration.actions.flatMap((action) => action.forms.filter((form) => form.active)).flatMap((form) => form.pages);
+function getActionReviewFields(configuration, actionType) {
+  return getActionReview(configuration, actionType).fields;
 }
 function validateWorkqueueConfig(workqueueConfigs) {
   workqueueConfigs.map((workqueue) => {
@@ -1502,85 +1751,98 @@ function validateWorkqueueConfig(workqueueConfigs) {
     );
     if (!rootWorkqueue) {
       throw new Error(
-        `Invalid workqueue configuration: workqueue not found with id:  ${workqueue.id}`
+        `Invalid workqueue configuration: workqueue not found with id: ${workqueue.id}`
       );
     }
   });
 }
-var findActiveActionForm = (configuration, action) => {
-  const actionConfig = configuration.actions.find((a) => a.type === action);
-  const form = actionConfig?.forms.find((f) => f.active);
-  return form;
-};
-var findActiveActionFormPages = (configuration, action) => {
-  return findActiveActionForm(configuration, action)?.pages;
-};
-var getFormFields = (formConfig) => {
-  return formConfig.pages.flatMap((p) => p.fields);
-};
-var findActiveActionFormFields = (configuration, action) => {
-  const form = findActiveActionForm(configuration, action);
-  return form ? getFormFields(form) : void 0;
-};
-var findActiveActionFields = (configuration, action) => {
-  const form = findActiveActionForm(configuration, action);
-  const reviewFields = form?.review.fields;
-  const formFields = form ? getFormFields(form) : void 0;
-  const allFields = formFields ? formFields.concat(reviewFields ?? []) : reviewFields;
-  return allFields;
-};
-var getActiveActionFormPages = (configuration, action) => {
-  return getOrThrow(
-    findActiveActionForm(configuration, action)?.pages,
-    "Form configuration not found for type: " + configuration.id
-  );
-};
-function getActiveActionFields(configuration, action) {
-  const fields = findActiveActionFields(configuration, action);
-  if (!fields) {
-    throw new Error(`No active field config found for action type ${action}`);
-  }
-  return fields;
-}
-function getEventConfiguration(eventConfigurations, type) {
-  const config = eventConfigurations.find((config2) => config2.id === type);
-  if (!config) {
-    throw new Error(`Event configuration not found for type: ${type}`);
+function isPageVisible(page, formValues) {
+  if (!page.conditional) {
+    return true;
   }
-  return config;
+  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, data) {
-  return (0, import_lodash.omitBy)(data, (_2, fieldId) => {
+function stripHiddenFields(fields, declaration) {
+  return (0, import_lodash.omitBy)(declaration, (_, fieldId) => {
     const field2 = fields.find((f) => f.id === fieldId);
     if (!field2) {
       return true;
     }
-    if (isOptionalUncheckedCheckbox(field2, data)) {
+    if (isOptionalUncheckedCheckbox(field2, declaration)) {
       return true;
     }
-    return !isFieldVisible(field2, data);
+    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_zod18.z.object({
-  id: import_zod18.z.string().describe(
+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_zod18.z.array(ActionConfig),
-  workqueues: import_zod18.z.array(WorkqueueConfig),
-  deduplication: import_zod18.z.array(DeduplicationConfig).optional().default([]),
-  advancedSearch: import_zod18.z.array(AdvancedSearchConfig).optional().default([])
+  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 = findPageFields(event2);
+  const allFields = findAllFields(event2);
   const fieldIds = allFields.map((field2) => field2.id);
   const advancedSearchFields = event2.advancedSearch.flatMap(
     (section) => section.fields.flatMap((field2) => field2.fieldId)
@@ -1607,106 +1869,117 @@ var EventConfig = import_zod18.z.object({
 });
 
 // ../commons/src/events/EventConfigInput.ts
-var defineForm = (form) => FormConfig.parse(form);
-var defineFormPage = (formPage) => FormPage.parse(formPage);
+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_zod21 = require("zod");
+var import_zod23 = require("zod");
 
 // ../commons/src/events/ActionDocument.ts
-var import_zod19 = require("zod");
-var ActionUpdate = import_zod19.z.record(import_zod19.z.string(), FieldUpdateValue);
-var ActionBase = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  createdAt: import_zod19.z.string().datetime(),
-  createdBy: import_zod19.z.string(),
-  data: ActionUpdate,
-  metadata: ActionUpdate.optional(),
-  createdAtLocation: import_zod19.z.string()
+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(),
+  declaration: ActionUpdate,
+  annotation: ActionUpdate.optional(),
+  createdAtLocation: import_zod21.z.string(),
+  status: import_zod21.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()
 });
 var AssignedAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod19.z.string()
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.ASSIGN),
+    assignedTo: import_zod21.z.string()
   })
 );
 var UnassignedAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.UNASSIGN)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.UNASSIGN)
   })
 );
 var RegisterAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REGISTER),
-    identifiers: import_zod19.z.object({
-      trackingId: import_zod19.z.string(),
-      registrationNumber: import_zod19.z.string()
-    })
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.REGISTER),
+    registrationNumber: import_zod21.z.string().optional()
   })
 );
 var DeclareAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.DECLARE)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.DECLARE)
   })
 );
 var ValidateAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.VALIDATE)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.VALIDATE)
   })
 );
 var RejectAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REJECT)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.REJECT)
   })
 );
 var MarkAsDuplicateAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.MARKED_AS_DUPLICATE)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.ARCHIVE)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.ARCHIVE)
   })
 );
 var CreatedAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.CREATE)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.CREATE)
   })
 );
 var NotifiedAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.NOTIFY)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.NOTIFY)
   })
 );
 var PrintCertificateAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.PRINT_CERTIFICATE)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RequestedCorrectionAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REQUEST_CORRECTION)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.REQUEST_CORRECTION)
   })
 );
 var ApprovedCorrectionAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.APPROVE_CORRECTION),
-    requestId: import_zod19.z.string()
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.APPROVE_CORRECTION),
+    requestId: import_zod21.z.string()
   })
 );
 var RejectedCorrectionAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REJECT_CORRECTION),
-    requestId: import_zod19.z.string()
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.REJECT_CORRECTION),
+    requestId: import_zod21.z.string()
   })
 );
-var CustomAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.CUSTOM)
+var ReadAction = ActionBase.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.READ)
   })
 );
-var ActionDocument = import_zod19.z.discriminatedUnion("type", [
+var ActionDocument = import_zod21.z.discriminatedUnion("type", [
   CreatedAction,
   ValidateAction,
   RejectAction,
@@ -1721,108 +1994,124 @@ var ActionDocument = import_zod19.z.discriminatedUnion("type", [
   RejectedCorrectionAction,
   UnassignedAction,
   PrintCertificateAction,
-  CustomAction
+  ReadAction
 ]);
-var ResolvedUser = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  role: import_zod19.z.string(),
-  name: import_zod19.z.array(
-    import_zod19.z.object({
-      use: import_zod19.z.string(),
-      given: import_zod19.z.array(import_zod19.z.string()),
-      family: import_zod19.z.string()
+var AsyncRejectActionDocument = ActionBase.omit({
+  declaration: true,
+  annotation: true,
+  createdBy: true,
+  createdAtLocation: true
+}).merge(
+  import_zod21.z.object({
+    type: import_zod21.z.enum(ConfirmableActions),
+    status: import_zod21.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()
     })
   )
 });
 
 // ../commons/src/events/ActionInput.ts
-var import_zod20 = require("zod");
-var BaseActionInput = import_zod20.z.object({
-  eventId: import_zod20.z.string(),
-  transactionId: import_zod20.z.string(),
-  data: ActionUpdate,
-  metadata: ActionUpdate.optional()
+var import_zod22 = require("zod");
+var BaseActionInput = import_zod22.z.object({
+  eventId: import_zod22.z.string(),
+  transactionId: import_zod22.z.string(),
+  declaration: ActionUpdate.default({}),
+  annotation: ActionUpdate.optional(),
+  originalActionId: import_zod22.z.string().optional()
 });
 var CreateActionInput = BaseActionInput.merge(
-  import_zod20.z.object({
-    type: import_zod20.z.literal(ActionType.CREATE).default(ActionType.CREATE),
-    createdAtLocation: import_zod20.z.string()
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.CREATE).default(ActionType.CREATE),
+    createdAtLocation: import_zod22.z.string()
   })
 );
 var RegisterActionInput = BaseActionInput.merge(
-  import_zod20.z.object({
-    type: import_zod20.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
-    identifiers: import_zod20.z.object({
-      trackingId: import_zod20.z.string(),
-      registrationNumber: import_zod20.z.string()
-    })
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
+    registrationNumber: import_zod22.z.string().optional()
   })
 );
 var ValidateActionInput = BaseActionInput.merge(
-  import_zod20.z.object({
-    type: import_zod20.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
-    duplicates: import_zod20.z.array(import_zod20.z.string())
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
+    duplicates: import_zod22.z.array(import_zod22.z.string())
   })
 );
 var NotifyActionInput = BaseActionInput.merge(
-  import_zod20.z.object({
-    type: import_zod20.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
   })
 );
 var DeclareActionInput = BaseActionInput.merge(
-  import_zod20.z.object({
-    type: import_zod20.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
   })
 );
 var PrintCertificateActionInput = BaseActionInput.merge(
-  import_zod20.z.object({
-    type: import_zod20.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RejectDeclarationActionInput = BaseActionInput.merge(
-  import_zod20.z.object({
-    type: import_zod20.z.literal(ActionType.REJECT).default(ActionType.REJECT)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.REJECT).default(ActionType.REJECT)
   })
 );
 var MarkedAsDuplicateActionInput = BaseActionInput.merge(
-  import_zod20.z.object({
-    type: import_zod20.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveActionInput = BaseActionInput.merge(
-  import_zod20.z.object({
-    type: import_zod20.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE)
   })
 );
 var AssignActionInput = BaseActionInput.merge(
-  import_zod20.z.object({
-    type: import_zod20.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
-    assignedTo: import_zod20.z.string()
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
+    assignedTo: import_zod22.z.string()
   })
 );
 var UnassignActionInput = BaseActionInput.merge(
-  import_zod20.z.object({
-    type: import_zod20.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
+    assignedTo: import_zod22.z.literal(null).default(null)
   })
 );
 var RequestCorrectionActionInput = BaseActionInput.merge(
-  import_zod20.z.object({
-    type: import_zod20.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
   })
 );
 var RejectCorrectionActionInput = BaseActionInput.merge(
-  import_zod20.z.object({
-    requestId: import_zod20.z.string(),
-    type: import_zod20.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
+  import_zod22.z.object({
+    requestId: import_zod22.z.string(),
+    type: import_zod22.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
   })
 );
 var ApproveCorrectionActionInput = BaseActionInput.merge(
-  import_zod20.z.object({
-    requestId: import_zod20.z.string(),
-    type: import_zod20.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
+  import_zod22.z.object({
+    requestId: import_zod22.z.string(),
+    type: import_zod22.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)
   })
 );
-var ActionInput = import_zod20.z.discriminatedUnion("type", [
+var ActionInput = import_zod22.z.discriminatedUnion("type", [
   CreateActionInput,
   ValidateActionInput,
   RegisterActionInput,
@@ -1836,56 +2125,62 @@ var ActionInput = import_zod20.z.discriminatedUnion("type", [
   PrintCertificateActionInput,
   RequestCorrectionActionInput,
   RejectCorrectionActionInput,
-  ApproveCorrectionActionInput
+  ApproveCorrectionActionInput,
+  ReadActionInput
 ]);
 
 // ../commons/src/events/Draft.ts
-var Draft = import_zod21.z.object({
-  id: import_zod21.z.string(),
-  eventId: import_zod21.z.string(),
-  transactionId: import_zod21.z.string(),
-  createdAt: import_zod21.z.string().datetime(),
+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: import_zod21.z.enum(Object.values(ActionType))
+    type: ActionTypes
   }).omit({ id: true })
 });
 var DraftInput = BaseActionInput.extend({
-  type: import_zod21.z.enum(Object.values(ActionType))
+  type: ActionTypes
 });
 
 // ../commons/src/events/EventInput.ts
-var import_zod22 = require("zod");
-var EventInput = import_zod22.z.object({
-  transactionId: import_zod22.z.string(),
-  type: import_zod22.z.string()
+var import_zod24 = require("zod");
+var EventInput = import_zod24.z.object({
+  transactionId: import_zod24.z.string(),
+  type: import_zod24.z.string()
 });
 
 // ../commons/src/events/EventDocument.ts
-var import_zod23 = require("zod");
-var EventDocument = import_zod23.z.object({
-  id: import_zod23.z.string(),
-  type: import_zod23.z.string(),
-  createdAt: import_zod23.z.string().datetime(),
-  updatedAt: import_zod23.z.string().datetime(),
-  actions: import_zod23.z.array(ActionDocument),
-  trackingId: import_zod23.z.string()
+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/events/EventIndex.ts
-var import_zod24 = require("zod");
+var import_zod26 = require("zod");
 var EventIndex = EventMetadata.extend({
-  data: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.any())
+  declaration: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any())
 });
-var EventSearchIndex = import_zod24.z.record(import_zod24.z.string(), import_zod24.z.any()).and(
-  import_zod24.z.object({
-    type: import_zod24.z.string()
+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/state/index.ts
-var _ = __toESM(require("lodash"));
 function getStatusFromActions(actions) {
+  const hasRejectedAction = actions.some(
+    (a) => a.status === ActionStatus.Rejected
+  );
+  if (hasRejectedAction) {
+    return EventStatus.REJECTED;
+  }
   return actions.reduce((status, action) => {
     if (action.type === ActionType.CREATE) {
       return EventStatus.CREATED;
@@ -1922,61 +2217,49 @@ function getAssignedUserFromActions(actions) {
     return user2;
   }, null);
 }
-function getData(actions) {
+function aggregateActionDeclarations(actions) {
   const excludedActions = [
     ActionType.REQUEST_CORRECTION,
     ActionType.PRINT_CERTIFICATE
   ];
   return actions.reduce((status, action) => {
-    if (excludedActions.some((excludedAction) => excludedAction === action.type)) {
-      return status;
-    }
-    if (action.type === ActionType.APPROVE_CORRECTION) {
-      const requestAction = actions.find(({ id }) => id === action.requestId);
-      if (!requestAction) {
-        return status;
-      }
-      return deepMerge(status, requestAction.data);
-    }
-    return deepMerge(status, action.data);
-  }, {});
-}
-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;
-  }, {});
-}
-function deepMerge(currentDocument, actionDocument) {
-  return _.mergeWith(
-    currentDocument,
-    actionDocument,
-    (previousValue, incomingValue) => {
-      if (incomingValue === void 0) {
-        return previousValue;
-      }
-      if (_.isArray(incomingValue)) {
-        return incomingValue;
-      }
-      if (_.isObject(previousValue) && _.isObject(incomingValue)) {
-        return void 0;
+    if (excludedActions.some((excludedAction) => excludedAction === action.type)) {
+      return status;
+    }
+    if (action.type === ActionType.APPROVE_CORRECTION) {
+      const requestAction = actions.find(({ id }) => id === action.requestId);
+      if (!requestAction) {
+        return status;
       }
-      return incomingValue;
+      return deepMerge(status, requestAction.declaration);
     }
-  );
+    return deepMerge(status, action.declaration);
+  }, {});
+}
+function deepDropNulls(obj) {
+  if (Array.isArray(obj)) {
+    return obj;
+  }
+  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 === ActionStatus.Accepted
+  );
+}
 function getCurrentEventState(event2) {
   const creationAction = event2.actions.find(
     (action) => action.type === ActionType.CREATE
@@ -1984,7 +2267,12 @@ function getCurrentEventState(event2) {
   if (!creationAction) {
     throw new Error(`Event ${event2.id} has no creation action`);
   }
-  const latestAction = event2.actions[event2.actions.length - 1];
+  const activeActions = getAcceptedActions(event2);
+  const latestAction = activeActions[activeActions.length - 1];
+  const registrationAction = activeActions.find(
+    (a) => a.type === ActionType.REGISTER && a.status === ActionStatus.Accepted
+  );
+  const registrationNumber = registrationAction?.registrationNumber ?? null;
   return deepDropNulls({
     id: event2.id,
     type: event2.type,
@@ -1993,16 +2281,16 @@ function getCurrentEventState(event2) {
     createdBy: creationAction.createdBy,
     createdAtLocation: creationAction.createdAtLocation,
     modifiedAt: latestAction.createdAt,
-    assignedTo: getAssignedUserFromActions(event2.actions),
+    assignedTo: getAssignedUserFromActions(activeActions),
     updatedBy: latestAction.createdBy,
-    data: getData(event2.actions),
-    trackingId: event2.trackingId
+    declaration: aggregateActionDeclarations(activeActions),
+    trackingId: event2.trackingId,
+    registrationNumber
   });
 }
 function getCurrentEventStateWithDrafts(event2, drafts) {
-  const actions = event2.actions.slice().sort();
-  const lastAction = actions[actions.length - 1];
-  const activeDrafts = drafts.filter(({ eventId }) => eventId === event2.id).filter(({ createdAt }) => createdAt > lastAction.createdAt).map((draft) => draft.action).flatMap((action) => {
+  const actions = event2.actions.slice().sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const activeDrafts = findActiveDrafts(event2, drafts).map((draft) => draft.action).flatMap((action) => {
     if (action.type === ActionType.REQUEST_CORRECTION) {
       return [
         action,
@@ -2029,46 +2317,46 @@ function applyDraftsToEventIndex(eventIndex, drafts) {
   }
   return {
     ...eventIndex,
-    data: {
-      ...eventIndex.data,
-      ...activeDrafts[activeDrafts.length - 1].data
+    declaration: {
+      ...eventIndex.declaration,
+      ...activeDrafts[activeDrafts.length - 1].declaration
     }
   };
 }
-function getMetadataForAction({
+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 action = event2.actions.find((action2) => actionType === action2.type);
+  const activeActions = getAcceptedActions(event2);
+  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 metadata = sorted.reduce((metadata2, action2) => {
-    return deepMerge(metadata2, action2.metadata ?? {});
+  const annotation = sorted.reduce((ann, sortedAction) => {
+    return deepMerge(ann, sortedAction.annotation ?? {});
   }, {});
-  return deepDropNulls(metadata);
+  return deepDropNulls(annotation);
 }
 
 // ../commons/src/events/defineConfig.ts
 var defineConfig = (config) => {
   validateWorkqueueConfig(config.workqueues);
   const input = EventConfig.parse(config);
-  const pageFields = findInputPageFields(input);
-  return EventConfig.parse({
-    ...input,
-    pageFields
-  });
+  return input;
 };
 
-// ../commons/src/uuid.ts
-var import_uuid = require("uuid");
-function getUUID() {
-  return (0, import_uuid.v4)();
-}
-
 // ../commons/src/events/transactions.ts
 function generateTransactionId() {
   return getUUID();
@@ -2081,6 +2369,16 @@ var import_lodash2 = require("lodash");
 function defineConditional(schema) {
   return schema;
 }
+function defineFormConditional(schema) {
+  const schemaWithForm = {
+    type: "object",
+    properties: {
+      $form: schema
+    },
+    required: ["$form"]
+  };
+  return defineConditional(schemaWithForm);
+}
 function alwaysTrue() {
   return {};
 }
@@ -2105,6 +2403,9 @@ function not(condition) {
     required: []
   });
 }
+function never() {
+  return not(alwaysTrue());
+}
 var user = {
   hasScope: (scope) => defineConditional({
     type: "object",
@@ -2152,69 +2453,120 @@ 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.
+     */
+    _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"))
     }),
-    isEqualTo: (value) => defineConditional({
-      type: "object",
-      properties: {
-        $form: {
+    isEqualTo: (value) => {
+      if (isFieldReference(value)) {
+        const comparedFieldId = value._fieldId;
+        return defineFormConditional({
           type: "object",
           properties: {
             [fieldId]: {
-              oneOf: [
-                { type: "string", const: value },
-                { type: "boolean", const: value }
-              ],
-              const: value
-            }
+              type: ["string", "boolean"],
+              const: { $data: `1/${comparedFieldId}` }
+            },
+            [comparedFieldId]: { type: ["string", "boolean"] }
           },
-          required: [fieldId]
-        }
-      },
-      required: ["$form"]
-    }),
+          required: [fieldId, comparedFieldId]
+        });
+      }
+      return defineFormConditional({
+        type: "object",
+        properties: {
+          [fieldId]: {
+            oneOf: [
+              { type: "string", const: value },
+              { type: "boolean", const: value }
+            ],
+            const: value
+          }
+        },
+        required: [fieldId]
+      });
+    },
     /**
      * Use case: Some fields are rendered when selection is not made, or boolean false is explicitly selected.
      * @example field('recommender.none').isFalsy() vs not(field('recommender.none').isEqualTo(true))
@@ -2223,91 +2575,102 @@ 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]
           }
         }
+      ]
+    }),
+    isUndefined: () => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "string",
+          enum: ["undefined"]
+        }
       },
-      required: ["$form"]
+      not: {
+        required: [fieldId]
+      }
     }),
-    inArray: (values) => defineConditional({
+    inArray: (values) => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              enum: values
-            }
-          },
-          required: [fieldId]
+        [fieldId]: {
+          type: "string",
+          enum: values
+        }
+      },
+      required: [fieldId]
+    }),
+    isValidEnglishName: () => defineFormConditional({
+      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]
+    }),
+    /**
+     * 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) => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "string",
+          pattern
+        }
+      },
+      required: [fieldId]
+    }),
+    isBetween: (min, max) => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "number",
+          minimum: min,
+          maximum: max
         }
       },
-      required: ["$form"]
+      required: [fieldId]
     })
   };
 }
 
 // ../commons/src/fixtures/tennis-club-membership-event.ts
-var PRINT_CERTIFICATE_FORM = defineForm({
+var PRINT_CERTIFICATE_FORM = defineActionForm({
   label: {
     id: "v2.event.tennis-club-membership.action.certificate.form.label",
     defaultMessage: "Tennis club membership certificate collector",
     description: "This is what this form is referred as in the system"
   },
-  version: {
-    id: "1.0.0",
-    label: {
-      id: "v2.event.tennis-club-membership.action.certificate.form.version.1",
-      defaultMessage: "Version 1",
-      description: "This is the first version of the form"
-    }
-  },
-  active: true,
   pages: [
     {
       id: "collector",
+      type: PageTypes.enum.FORM,
       title: {
         id: "v2.event.tennis-club-membership.action.certificate.form.section.who.title",
         defaultMessage: "Print certified copy",
@@ -2322,7 +2685,7 @@ var PRINT_CERTIFICATE_FORM = defineForm({
             defaultMessage: "Requester",
             description: "This is the label for the field"
           },
-          type: "SELECT",
+          type: FieldType.SELECT,
           options: [
             {
               value: "INFORMANT",
@@ -2399,7 +2762,7 @@ var PRINT_CERTIFICATE_FORM = defineForm({
             defaultMessage: "Select Type of ID",
             description: "This is the label for selecting the type of ID"
           },
-          type: "SELECT",
+          type: FieldType.SELECT,
           options: [
             {
               value: "PASSPORT",
@@ -2500,7 +2863,7 @@ var PRINT_CERTIFICATE_FORM = defineForm({
             defaultMessage: "Passport Details",
             description: "Field for entering Passport details"
           },
-          type: "TEXT"
+          type: FieldType.TEXT
         },
         {
           id: "collector.DRIVING_LICENSE.details",
@@ -2551,7 +2914,7 @@ var PRINT_CERTIFICATE_FORM = defineForm({
             defaultMessage: "Driving License Details",
             description: "Field for entering Driving License details"
           },
-          type: "TEXT"
+          type: FieldType.TEXT
         },
         {
           id: "collector.REFUGEE_NUMBER.details",
@@ -2602,7 +2965,7 @@ var PRINT_CERTIFICATE_FORM = defineForm({
             defaultMessage: "Refugee Number Details",
             description: "Field for entering Refugee Number details"
           },
-          type: "TEXT"
+          type: FieldType.TEXT
         },
         {
           id: "collector.ALIEN_NUMBER.details",
@@ -2653,7 +3016,7 @@ var PRINT_CERTIFICATE_FORM = defineForm({
             defaultMessage: "Alien Number Details",
             description: "Field for entering Alien Number details"
           },
-          type: "TEXT"
+          type: FieldType.TEXT
         },
         {
           id: "collector.OTHER.idTypeOther",
@@ -2704,7 +3067,7 @@ var PRINT_CERTIFICATE_FORM = defineForm({
             defaultMessage: "Other ID Type (if applicable)",
             description: 'Field for entering ID type if "Other" is selected'
           },
-          type: "TEXT"
+          type: FieldType.TEXT
         },
         {
           id: "collector.OTHER.firstName",
@@ -2755,7 +3118,7 @@ var PRINT_CERTIFICATE_FORM = defineForm({
             defaultMessage: "First Name",
             description: "This is the label for the first name field"
           },
-          type: "TEXT"
+          type: FieldType.TEXT
         },
         {
           id: "collector.OTHER.lastName",
@@ -2806,7 +3169,7 @@ var PRINT_CERTIFICATE_FORM = defineForm({
             defaultMessage: "Last Name",
             description: "This is the label for the last name field"
           },
-          type: "TEXT"
+          type: FieldType.TEXT
         },
         {
           id: "collector.OTHER.relationshipToMember",
@@ -2857,7 +3220,7 @@ var PRINT_CERTIFICATE_FORM = defineForm({
             defaultMessage: "Relationship to Member",
             description: "This is the label for the relationship to member field"
           },
-          type: "TEXT"
+          type: FieldType.TEXT
         },
         {
           id: "collector.OTHER.signedAffidavit",
@@ -2908,66 +3271,88 @@ var PRINT_CERTIFICATE_FORM = defineForm({
             defaultMessage: "Signed Affidavit (Optional)",
             description: "This is the label for uploading a signed affidavit"
           },
-          type: "FILE"
+          type: FieldType.FILE
         }
       ]
-    }
-  ],
-  review: {
-    title: {
-      id: "v2.event.tennis-club-membership.action.certificate.form.review.title",
-      defaultMessage: "Member certificate collector for {firstname} {surname}",
-      description: "Title of the form to show in review page"
     },
-    fields: []
-  }
-});
-var TENNIS_CLUB_FORM = defineForm({
-  label: {
-    id: "v2.event.tennis-club-membership.action.declare.form.label",
-    defaultMessage: "Tennis club membership application",
-    description: "This is what this form is referred as in the system"
-  },
-  active: true,
-  version: {
-    id: "1.0.0",
-    label: {
-      id: "v2.event.tennis-club-membership.action.declare.form.version.1",
-      defaultMessage: "Version 1",
-      description: "This is the first version of the form"
+    {
+      id: "collector.identity.verify",
+      type: PageTypes.enum.VERIFICATION,
+      conditional: field("collector.requesterId").isEqualTo("INFORMANT"),
+      title: {
+        id: "event.tennis-club-membership.action.print.verifyIdentity",
+        defaultMessage: "Verify their identity",
+        description: "This is the title of the section"
+      },
+      fields: [],
+      actions: {
+        verify: {
+          label: {
+            defaultMessage: "Verified",
+            description: "This is the label for the verification button",
+            id: "v2.event.tennis-club-membership.action.certificate.form.verify"
+          }
+        },
+        cancel: {
+          label: {
+            defaultMessage: "Identity does not match",
+            description: "This is the label for the verification cancellation button",
+            id: "v2.event.tennis-club-membership.action.certificate.form.cancel"
+          },
+          confirmation: {
+            title: {
+              defaultMessage: "Print without proof of ID?",
+              description: "This is the title for the verification cancellation modal",
+              id: "v2.event.tennis-club-membership.action.certificate.form.cancel.confirmation.title"
+            },
+            body: {
+              defaultMessage: "Please be aware that if you proceed, you will be responsible for issuing a certificate without the necessary proof of ID from the collector",
+              description: "This is the body for the verification cancellation modal",
+              id: "v2.event.tennis-club-membership.action.certificate.form.cancel.confirmation.body"
+            }
+          }
+        }
+      }
     }
+  ]
+});
+var TENNIS_CLUB_DECLARATION_REVIEW = {
+  title: {
+    id: "v2.event.tennis-club-membership.action.declare.form.review.title",
+    defaultMessage: "{applicant.firstname, select, __EMPTY__ {Member declaration} other {{applicant.surname, select, __EMPTY__ {Member declaration} other {Member declaration for {applicant.firstname} {applicant.surname}}}}}",
+    description: "Title of the review page"
   },
-  review: {
-    title: {
-      id: "v2.event.tennis-club-membership.action.declare.form.review.title",
-      defaultMessage: "{applicant.firstname, select, __EMPTY__ {Member declaration} other {{applicant.surname, select, __EMPTY__ {Member declaration} other {Member declaration for {applicant.firstname} {applicant.surname}}}}}",
-      description: "Title of the form to show in review page"
+  fields: [
+    {
+      id: "review.comment",
+      type: FieldType.TEXTAREA,
+      label: {
+        defaultMessage: "Comment",
+        id: "v2.event.birth.action.declare.form.review.comment.label",
+        description: "Label for the comment field in the review section"
+      }
     },
-    fields: [
-      {
-        id: "review.comment",
-        type: "TEXTAREA",
-        label: {
-          defaultMessage: "Comment",
-          id: "v2.event.birth.action.declare.form.review.comment.label",
-          description: "Label for the comment field in the review section"
-        }
+    {
+      type: FieldType.SIGNATURE,
+      id: "review.signature",
+      label: {
+        defaultMessage: "Signature of informant",
+        id: "v2.event.birth.action.declare.form.review.signature.label",
+        description: "Label for the signature field in the review section"
       },
-      {
-        type: "SIGNATURE",
-        id: "review.signature",
-        label: {
-          defaultMessage: "Signature of informant",
-          id: "v2.event.birth.action.declare.form.review.signature.label",
-          description: "Label for the signature field in the review section"
-        },
-        signaturePromptLabel: {
-          id: "v2.signature.upload.modal.title",
-          defaultMessage: "Draw signature",
-          description: "Title for the modal to draw signature"
-        }
+      signaturePromptLabel: {
+        id: "v2.signature.upload.modal.title",
+        defaultMessage: "Draw signature",
+        description: "Title for the modal to draw signature"
       }
-    ]
+    }
+  ]
+};
+var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
+  label: {
+    id: "v2.event.tennis-club-membership.action.declare.form.label",
+    defaultMessage: "Tennis club membership application",
+    description: "This is what this form is referred as in the system"
   },
   pages: [
     {
@@ -2980,7 +3365,7 @@ var TENNIS_CLUB_FORM = defineForm({
       fields: [
         {
           id: "applicant.firstname",
-          type: "TEXT",
+          type: FieldType.TEXT,
           required: true,
           conditionals: [],
           label: {
@@ -2991,7 +3376,7 @@ var TENNIS_CLUB_FORM = defineForm({
         },
         {
           id: "applicant.surname",
-          type: "TEXT",
+          type: FieldType.TEXT,
           required: true,
           conditionals: [],
           label: {
@@ -3034,7 +3419,7 @@ var TENNIS_CLUB_FORM = defineForm({
         },
         {
           id: "applicant.image",
-          type: "FILE",
+          type: FieldType.FILE,
           required: false,
           label: {
             defaultMessage: "Applicant's profile picture",
@@ -3055,6 +3440,27 @@ var TENNIS_CLUB_FORM = defineForm({
         }
       ]
     },
+    {
+      id: "senior-pass",
+      conditional: field("applicant.dob").isBefore().date("1950-01-01"),
+      title: {
+        id: "v2.event.tennis-club-membership.action.declare.form.section.senior-pass.title",
+        defaultMessage: "Assign senior pass for applicant",
+        description: "This is the title of the section"
+      },
+      fields: [
+        {
+          id: "senior-pass.id",
+          type: FieldType.TEXT,
+          required: true,
+          label: {
+            defaultMessage: "Senior pass ID",
+            description: "This is the label for the field",
+            id: "v2.event.tennis-club-membership.action.declare.form.section.senior-pass.field.id.label"
+          }
+        }
+      ]
+    },
     {
       id: "recommender",
       title: {
@@ -3076,7 +3482,7 @@ var TENNIS_CLUB_FORM = defineForm({
         },
         {
           id: "recommender.firstname",
-          type: "TEXT",
+          type: FieldType.TEXT,
           required: true,
           conditionals: [
             {
@@ -3092,7 +3498,7 @@ var TENNIS_CLUB_FORM = defineForm({
         },
         {
           id: "recommender.surname",
-          type: "TEXT",
+          type: FieldType.TEXT,
           required: true,
           conditionals: [
             {
@@ -3108,7 +3514,7 @@ var TENNIS_CLUB_FORM = defineForm({
         },
         {
           id: "recommender.id",
-          type: "TEXT",
+          type: FieldType.TEXT,
           required: true,
           conditionals: [
             {
@@ -3216,7 +3622,7 @@ var tennisClubMembershipEvent = defineConfig({
         description: "This is shown as the action name anywhere the user can trigger the action from",
         id: "event.tennis-club-membership.action.declare.label"
       },
-      forms: [TENNIS_CLUB_FORM]
+      review: TENNIS_CLUB_DECLARATION_REVIEW
     },
     {
       type: ActionType.VALIDATE,
@@ -3225,7 +3631,7 @@ var tennisClubMembershipEvent = defineConfig({
         description: "This is shown as the action name anywhere the user can trigger the action from",
         id: "event.tennis-club-membership.action.validate.label"
       },
-      forms: [TENNIS_CLUB_FORM]
+      review: TENNIS_CLUB_DECLARATION_REVIEW
     },
     {
       type: ActionType.REGISTER,
@@ -3234,7 +3640,7 @@ var tennisClubMembershipEvent = defineConfig({
         description: "This is shown as the action name anywhere the user can trigger the action from",
         id: "event.tennis-club-membership.action.register.label"
       },
-      forms: [TENNIS_CLUB_FORM]
+      review: TENNIS_CLUB_DECLARATION_REVIEW
     },
     {
       type: ActionType.REQUEST_CORRECTION,
@@ -3243,10 +3649,10 @@ var tennisClubMembershipEvent = defineConfig({
         description: "This is shown as the action name anywhere the user can trigger the action from",
         id: "event.tennis-club-membership.action.correction.request.label"
       },
-      forms: [TENNIS_CLUB_FORM],
       onboardingForm: [
         {
           id: "correction-requester",
+          type: PageTypes.enum.FORM,
           title: {
             id: "event.tennis-club-membership.action.requestCorrection.form.section.corrector",
             defaultMessage: "Correction requester",
@@ -3310,6 +3716,7 @@ var tennisClubMembershipEvent = defineConfig({
         },
         {
           id: "identity-check",
+          type: PageTypes.enum.FORM,
           title: {
             id: "event.tennis-club-membership.action.requestCorrection.form.section.verify",
             defaultMessage: "Verify their identity",
@@ -3352,6 +3759,7 @@ var tennisClubMembershipEvent = defineConfig({
       additionalDetailsForm: [
         {
           id: "correction-request.supporting-documents",
+          type: PageTypes.enum.FORM,
           title: {
             id: "event.tennis-club-membership.action.requestCorrection.form.section.verify",
             defaultMessage: "Upload supporting documents",
@@ -3369,7 +3777,7 @@ var tennisClubMembershipEvent = defineConfig({
             },
             {
               id: "correction.supportingDocs",
-              type: "FILE",
+              type: FieldType.FILE,
               label: {
                 id: "correction.corrector.title",
                 defaultMessage: "Upload supporting documents",
@@ -3413,6 +3821,7 @@ var tennisClubMembershipEvent = defineConfig({
         },
         {
           id: "correction-request.additional-details",
+          type: PageTypes.enum.FORM,
           title: {
             id: "event.tennis-club-membership.action.requestCorrection.form.section.corrector",
             defaultMessage: "Reason for correction",
@@ -3421,7 +3830,7 @@ var tennisClubMembershipEvent = defineConfig({
           fields: [
             {
               id: "correction.request.reason",
-              type: "TEXT",
+              type: FieldType.TEXT,
               label: {
                 id: "correction.reason.title",
                 defaultMessage: "Reason for correction?",
@@ -3434,7 +3843,6 @@ var tennisClubMembershipEvent = defineConfig({
     },
     {
       type: ActionType.APPROVE_CORRECTION,
-      forms: [TENNIS_CLUB_FORM],
       label: {
         defaultMessage: "Approve correction",
         description: "This is shown as the action name anywhere the user can trigger the action from",
@@ -3448,7 +3856,7 @@ var tennisClubMembershipEvent = defineConfig({
         defaultMessage: "Print certificate",
         description: "This is shown as the action name anywhere the user can trigger the action from"
       },
-      forms: [PRINT_CERTIFICATE_FORM],
+      printForm: PRINT_CERTIFICATE_FORM,
       conditionals: [
         {
           type: "SHOW",
@@ -3488,6 +3896,22 @@ var tennisClubMembershipEvent = defineConfig({
           })
         }
       ]
+    },
+    {
+      type: ActionType.ARCHIVE,
+      label: {
+        id: "v2.event.tennis-club-membership.action.archive.label",
+        defaultMessage: "Archive",
+        description: "This is shown as the action name anywhere the user can trigger the action from"
+      }
+    },
+    {
+      type: ActionType.REJECT,
+      label: {
+        id: "v2.event.tennis-club-membership.action.reject.label",
+        defaultMessage: "Reject",
+        description: "This is shown as the action name anywhere the user can trigger the action from"
+      }
     }
   ],
   advancedSearch: [
@@ -3503,20 +3927,52 @@ var tennisClubMembershipEvent = defineConfig({
         }
       ]
     }
-  ]
+  ],
+  declaration: TENNIS_CLUB_DECLARATION_FORM
 });
 
 // ../commons/src/events/test.utils.ts
-function generateActionInput(configuration, action) {
-  const fields = findActiveActionFormFields(configuration, action) ?? [];
-  const data = fields.reduce(
+function fieldConfigsToActionAnnotation(fields) {
+  return fields.reduce(
     (acc, field2, i) => ({
       ...acc,
       [field2.id]: mapFieldTypeToMockValue(field2, i)
     }),
     {}
   );
-  return stripHiddenFields(fields, data);
+}
+function generateActionInput(configuration, action) {
+  const parsed = DeclarationUpdateActions.safeParse(action);
+  if (parsed.success) {
+    const fields = getDeclarationFields(configuration);
+    const annotation = fieldConfigsToActionAnnotation(fields);
+    return stripHiddenFields(fields, annotation);
+  }
+  console.warn(`${action} is not a declaration action. Setting data as {}.`);
+  return {};
+}
+function generateActionMetadataInput(configuration, action) {
+  const actionConfig = configuration.actions.find(
+    (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 visiblePageVerificationMap = visibleVerificationPageIds.reduce(
+    (acc, pageId) => ({
+      ...acc,
+      [pageId]: true
+    }),
+    {}
+  );
+  const fieldBasedPayload = stripHiddenFields(annotationFields, annotation);
+  return {
+    ...fieldBasedPayload,
+    ...visiblePageVerificationMap
+  };
 }
 var eventPayloadGenerator = {
   create: (input = {}) => ({
@@ -3528,21 +3984,22 @@ var eventPayloadGenerator = {
     type: input.type ?? "TENNIS_CLUB_MEMBERSHIP",
     id
   }),
-  draft: (eventId, input = {}) => (0, import_lodash2.merge)(
+  draft: ({ eventId, actionType }, input = {}) => (0, import_lodash2.merge)(
     {
       id: getUUID(),
       eventId,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       transactionId: getUUID(),
       action: {
-        type: ActionType.REQUEST_CORRECTION,
-        data: {
+        type: actionType,
+        status: ActionStatus.Accepted,
+        declaration: {
           "applicant.firstname": "Max",
           "applicant.surname": "McLaren",
           "applicant.dob": "2020-01-02",
           "recommender.none": true
         },
-        metadata: {
+        annotation: {
           "correction.requester.relationship": "ANOTHER_AGENT",
           "correction.request.reason": "Child's name was incorrect"
         },
@@ -3557,41 +4014,92 @@ var eventPayloadGenerator = {
     declare: (eventId, input = {}) => ({
       type: ActionType.DECLARE,
       transactionId: input.transactionId ?? getUUID(),
-      data: input.data ?? generateActionInput(tennisClubMembershipEvent, ActionType.DECLARE),
+      declaration: input.declaration ?? generateActionInput(tennisClubMembershipEvent, ActionType.DECLARE),
+      annotation: input.annotation ?? generateActionMetadataInput(
+        tennisClubMembershipEvent,
+        ActionType.DECLARE
+      ),
       eventId
     }),
+    /**
+     * Notify allows sending incomplete data. Think it as 'partial declare' for now.
+     */
+    notify: (eventId, input = {}) => {
+      let declaration = input.declaration;
+      if (!declaration) {
+        const partialDeclaration = (0, import_lodash2.omitBy)(
+          generateActionInput(tennisClubMembershipEvent, ActionType.DECLARE),
+          import_lodash2.isString
+        );
+        declaration = partialDeclaration;
+      }
+      return {
+        type: ActionType.NOTIFY,
+        transactionId: input.transactionId ?? getUUID(),
+        declaration,
+        eventId
+      };
+    },
     validate: (eventId, input = {}) => ({
       type: ActionType.VALIDATE,
       transactionId: input.transactionId ?? getUUID(),
-      data: input.data ?? generateActionInput(tennisClubMembershipEvent, ActionType.VALIDATE),
+      declaration: input.declaration ?? generateActionInput(tennisClubMembershipEvent, ActionType.VALIDATE),
+      annotation: input.annotation ?? generateActionMetadataInput(
+        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(),
-      data: input.data ?? {},
-      metadata: { isDuplicate: isDuplicate ?? false },
+      declaration: {},
+      // @TODO: Check whether generator is needed?
+      annotation: { isDuplicate: isDuplicate ?? false },
       duplicates: [],
       eventId
     }),
     reject: (eventId, input = {}) => ({
       type: ActionType.REJECT,
       transactionId: input.transactionId ?? getUUID(),
-      data: input.data ?? {},
+      declaration: {},
+      annotation: input.annotation ?? generateActionMetadataInput(
+        tennisClubMembershipEvent,
+        ActionType.REJECT
+      ),
       duplicates: [],
       eventId
     }),
     register: (eventId, input = {}) => ({
       type: ActionType.REGISTER,
       transactionId: input.transactionId ?? getUUID(),
-      data: input.data ?? generateActionInput(tennisClubMembershipEvent, ActionType.REGISTER),
+      declaration: input.declaration ?? generateActionInput(tennisClubMembershipEvent, ActionType.REGISTER),
+      annotation: input.annotation ?? generateActionMetadataInput(
+        tennisClubMembershipEvent,
+        ActionType.REGISTER
+      ),
       eventId
     }),
     printCertificate: (eventId, input = {}) => ({
       type: ActionType.PRINT_CERTIFICATE,
       transactionId: input.transactionId ?? getUUID(),
-      data: input.data ?? generateActionInput(
+      declaration: {},
+      annotation: input.annotation ?? generateActionMetadataInput(
         tennisClubMembershipEvent,
         ActionType.PRINT_CERTIFICATE
       ),
@@ -3601,17 +4109,21 @@ var eventPayloadGenerator = {
       request: (eventId, input = {}) => ({
         type: ActionType.REQUEST_CORRECTION,
         transactionId: input.transactionId ?? getUUID(),
-        data: input.data ?? generateActionInput(
+        declaration: input.declaration ?? generateActionInput(
+          tennisClubMembershipEvent,
+          ActionType.REQUEST_CORRECTION
+        ),
+        annotation: input.annotation ?? generateActionMetadataInput(
           tennisClubMembershipEvent,
           ActionType.REQUEST_CORRECTION
         ),
-        metadata: {},
         eventId
       }),
       approve: (eventId, requestId, input = {}) => ({
         type: ActionType.APPROVE_CORRECTION,
         transactionId: input.transactionId ?? getUUID(),
-        data: input.data ?? generateActionInput(
+        declaration: {},
+        annotation: input.annotation ?? generateActionMetadataInput(
           tennisClubMembershipEvent,
           ActionType.APPROVE_CORRECTION
         ),
@@ -3621,7 +4133,8 @@ var eventPayloadGenerator = {
       reject: (eventId, requestId, input = {}) => ({
         type: ActionType.REJECT_CORRECTION,
         transactionId: input.transactionId ?? getUUID(),
-        data: input.data ?? generateActionInput(
+        declaration: {},
+        annotation: input.annotation ?? generateActionMetadataInput(
           tennisClubMembershipEvent,
           ActionType.REJECT_CORRECTION
         ),
@@ -3637,15 +4150,22 @@ function generateActionDocument({
   defaults = {}
 }) {
   const actionBase = {
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    // Offset is needed so the createdAt timestamps for events, actions and drafts make logical sense in storybook tests.
+    // @TODO: This should be fixed in the future.
+    createdAt: new Date(Date.now() - 500).toISOString(),
     createdBy: getUUID(),
     id: getUUID(),
     createdAtLocation: "TODO",
-    data: generateActionInput(configuration, action),
-    metadata: {},
-    ...defaults
+    declaration: generateActionInput(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:
@@ -3670,14 +4190,13 @@ function generateActionDocument({
       return { ...actionBase, requestId: getUUID(), type: action };
     case ActionType.REJECT_CORRECTION:
       return { ...actionBase, requestId: getUUID(), type: action };
-    case ActionType.CUSTOM:
-      return { ...actionBase, type: action };
     case ActionType.REGISTER:
       return {
         ...actionBase,
-        type: action,
-        identifiers: { trackingId: getUUID(), registrationNumber: getUUID() }
+        type: action
       };
+    case ActionType.DELETE:
+    case ActionType.DETECT_DUPLICATE:
     default:
       throw new Error(`Unsupported action type: ${action}`);
   }
@@ -3692,12 +4211,16 @@ function generateEventDocument({
     actions: actions.map(
       (action) => generateActionDocument({ configuration, action })
     ),
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    // Offset is needed so the createdAt timestamps for events, actions and drafts make logical sense in storybook tests.
+    // @TODO: This should be fixed in the future.
+    createdAt: new Date(Date.now() - 1e3).toISOString(),
     id: getUUID(),
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    // Offset is needed so the createdAt timestamps for events, actions and drafts make logical sense in storybook tests.
+    // @TODO: This should be fixed in the future.
+    updatedAt: new Date(Date.now() - 1e3).toISOString()
   };
 }
-function generateEventDraftDocument(eventId, actionType = ActionType.DECLARE, data = {}) {
+function generateEventDraftDocument(eventId, actionType = ActionType.DECLARE, declaration = {}) {
   const action = generateActionDocument({
     configuration: tennisClubMembershipEvent,
     action: actionType
@@ -3707,9 +4230,9 @@ function generateEventDraftDocument(eventId, actionType = ActionType.DECLARE, da
     transactionId: getUUID(),
     action: {
       ...action,
-      data: {
-        ...action.data,
-        ...data
+      declaration: {
+        ...action.declaration,
+        ...declaration
       }
     },
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3726,7 +4249,7 @@ var eventQueryDataGenerator = (overrides = {}) => ({
   modifiedAt: overrides.modifiedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
   assignedTo: overrides.assignedTo ?? null,
   updatedBy: overrides.updatedBy ?? getUUID(),
-  data: overrides.data ?? {
+  declaration: overrides.declaration ?? {
     "recommender.none": true,
     "applicant.firstname": "Danny",
     "applicant.surname": "Doe",
@@ -3734,6 +4257,11 @@ var eventQueryDataGenerator = (overrides = {}) => ({
   },
   trackingId: overrides.trackingId ?? "M3F8YQ"
 });
+var generateTranslationConfig = (message) => ({
+  defaultMessage: message,
+  description: "Description for ${message}",
+  id: message
+});
 
 // ../commons/src/events/TemplateConfig.ts
 function isTemplateVariable(value) {
@@ -3752,7 +4280,9 @@ function isFieldValueWithoutTemplates(value) {
   return true;
 }
 function isFieldConfigDefaultValue(value) {
-  if (!value) return false;
+  if (!value) {
+    return false;
+  }
   if (isFieldValue(value)) {
     return true;
   }