@opencrvs/toolkit 1.8.0-rc.f9d33b7 → 1.8.0-rc.f9fb039

package/dist/events/index.js

@@ -36,6 +36,7 @@ __export(events_exports, {
   ActionConditional: () => ActionConditional,
   ActionConfig: () => ActionConfig,
   ActionConfigBase: () => ActionConfigBase,
+  ActionCreationMetadata: () => ActionCreationMetadata,
   ActionDocument: () => ActionDocument,
   ActionFormConfig: () => ActionFormConfig,
   ActionInput: () => ActionInput,
@@ -62,9 +63,13 @@ __export(events_exports, {
   Conditional: () => Conditional,
   ConditionalType: () => ConditionalType,
   ConfirmableActions: () => ConfirmableActions,
+  CustomFlags: () => CustomFlags,
+  DEFAULT_DATE_OF_EVENT_PROPERTY: () => DEFAULT_DATE_OF_EVENT_PROPERTY,
   DataEntry: () => DataEntry,
   DataFieldValue: () => DataFieldValue,
+  DateRangeFieldValue: () => DateRangeFieldValue,
   DateValue: () => DateValue,
+  DatetimeValue: () => DatetimeValue,
   DeclarationActionConfig: () => DeclarationActionConfig,
   DeclarationActions: () => DeclarationActions,
   DeclarationFormConfig: () => DeclarationFormConfig,
@@ -86,7 +91,10 @@ __export(events_exports, {
   EventIndex: () => EventIndex,
   EventInput: () => EventInput,
   EventMetadata: () => EventMetadata,
+  EventMetadataKeys: () => EventMetadataKeys,
+  EventMetadataParameter: () => EventMetadataParameter,
   EventSearchIndex: () => EventSearchIndex,
+  EventState: () => EventState,
   EventStatus: () => EventStatus,
   EventStatuses: () => EventStatuses,
   FieldConditional: () => FieldConditional,
@@ -98,6 +106,7 @@ __export(events_exports, {
   FileFieldValue: () => FileFieldValue,
   FileFieldValueWithOption: () => FileFieldValueWithOption,
   FileFieldWithOptionValue: () => FileFieldWithOptionValue,
+  Flag: () => Flag,
   FormConfig: () => FormConfig,
   FormPageConfig: () => FormPageConfig,
   GenericAddressUpdateValue: () => GenericAddressUpdateValue,
@@ -105,8 +114,8 @@ __export(events_exports, {
   GeographicalArea: () => GeographicalArea,
   ImageMimeType: () => ImageMimeType,
   LanguageConfig: () => LanguageConfig,
+  LegalStatuses: () => LegalStatuses,
   MarkedAsDuplicateActionInput: () => MarkedAsDuplicateActionInput,
-  MatchType: () => MatchType,
   MimeType: () => MimeType,
   NonEmptyTextValue: () => NonEmptyTextValue,
   NotifyActionInput: () => NotifyActionInput,
@@ -119,6 +128,7 @@ __export(events_exports, {
   ReadActionInput: () => ReadActionInput,
   RegisterAction: () => RegisterAction,
   RegisterActionInput: () => RegisterActionInput,
+  RegistrationCreationMetadata: () => RegistrationCreationMetadata,
   RejectCorrectionActionInput: () => RejectCorrectionActionInput,
   RejectDeclarationActionInput: () => RejectDeclarationActionInput,
   RequestCorrectionActionInput: () => RequestCorrectionActionInput,
@@ -192,6 +202,7 @@ __export(events_exports, {
   getDeclaration: () => getDeclaration,
   getDeclarationFields: () => getDeclarationFields,
   getDeclarationPages: () => getDeclarationPages,
+  getMixedPath: () => getMixedPath,
   getVisibleVerificationPageIds: () => getVisibleVerificationPageIds,
   hasAnyOfScopes: () => hasAnyOfScopes,
   isAddressFieldType: () => isAddressFieldType,
@@ -202,6 +213,7 @@ __export(events_exports, {
   isCountryFieldType: () => isCountryFieldType,
   isDataFieldType: () => isDataFieldType,
   isDateFieldType: () => isDateFieldType,
+  isDateRangeFieldType: () => isDateRangeFieldType,
   isDividerFieldType: () => isDividerFieldType,
   isEmailFieldType: () => isEmailFieldType,
   isFacilityFieldType: () => isFacilityFieldType,
@@ -317,6 +329,7 @@ var FieldType = {
   TEXTAREA: "TEXTAREA",
   EMAIL: "EMAIL",
   DATE: "DATE",
+  DATE_RANGE: "DATE_RANGE",
   PARAGRAPH: "PARAGRAPH",
   PAGE_HEADER: "PAGE_HEADER",
   RADIO_GROUP: "RADIO_GROUP",
@@ -336,6 +349,7 @@ var FieldType = {
 };
 var fieldTypes = Object.values(FieldType);
 var compositeFieldTypes = [
+  FieldType.DATE_RANGE,
   FieldType.ADDRESS,
   FieldType.FILE_WITH_OPTIONS,
   FieldType.FILE
@@ -428,6 +442,8 @@ var FileFieldWithOptionValue = import_zod3.z.array(FileFieldValueWithOption);
 var TextValue = import_zod4.z.string();
 var NonEmptyTextValue = TextValue.min(1);
 var DateValue = import_zod4.z.string().date().describe("Date in the format YYYY-MM-DD");
+var DatetimeValue = import_zod4.z.string().datetime();
+var DateRangeFieldValue = DateValue.or(import_zod4.z.tuple([DateValue, DateValue]));
 var EmailValue = import_zod4.z.string().email();
 var CheckboxFieldValue = import_zod4.z.boolean();
 var NumberFieldValue = import_zod4.z.number();
@@ -435,6 +451,7 @@ var DataFieldValue = import_zod4.z.undefined();
 var FieldValue = import_zod4.z.union([
   TextValue,
   DateValue,
+  DateRangeFieldValue,
   CheckboxFieldValue,
   NumberFieldValue,
   FileFieldValue,
@@ -447,6 +464,7 @@ var FieldValue = import_zod4.z.union([
 var FieldUpdateValue = import_zod4.z.union([
   TextValue,
   DateValue,
+  DateRangeFieldValue,
   CheckboxFieldValue,
   NumberFieldValue,
   FileFieldValue,
@@ -482,6 +500,7 @@ var BaseField = import_zod5.z.object({
     })
   ).default([]).optional(),
   label: TranslationConfig,
+  helperText: TranslationConfig.optional(),
   hideLabel: import_zod5.z.boolean().default(false).optional()
 });
 var Divider = BaseField.extend({
@@ -554,6 +573,17 @@ var DateField = BaseField.extend({
     ).optional()
   }).optional()
 }).describe("A single date input (dd-mm-YYYY)");
+var DateRangeField = BaseField.extend({
+  type: import_zod5.z.literal(FieldType.DATE_RANGE),
+  defaultValue: DateRangeFieldValue.optional(),
+  configuration: import_zod5.z.object({
+    notice: TranslationConfig.describe(
+      "Text to display above the date input"
+    ).optional()
+  }).optional()
+}).describe(
+  "A date range input ({ rangeStart: dd-mm-YYYY, rangeEnd: dd-mm-YYYY })"
+);
 var HtmlFontVariant = import_zod5.z.enum([
   "reg12",
   "reg14",
@@ -693,6 +723,7 @@ var FieldConfig = import_zod5.z.discriminatedUnion("type", [
   NumberField,
   TextAreaField,
   DateField,
+  DateRangeField,
   Paragraph,
   RadioGroup,
   BulletList,
@@ -974,7 +1005,7 @@ var LanguageConfig = import_zod11.z.object({
 });
 
 // ../commons/src/events/EventConfig.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 
 // ../commons/src/events/DeduplicationConfig.ts
 var import_zod12 = require("zod");
@@ -1072,18 +1103,26 @@ var SummaryConfig = import_zod13.z.object({
 
 // ../commons/src/events/AdvancedSearchConfig.ts
 var import_zod14 = require("zod");
-var MatchType = import_zod14.z.enum(["FUZZY", "EXACT", "RANGE", "ANY_OF"]);
+var MatchType = import_zod14.z.enum(["fuzzy", "exact", "range"]);
 var BaseField3 = import_zod14.z.object({
   config: import_zod14.z.object({
     type: MatchType.describe("Determines the type of field")
   }),
-  options: import_zod14.z.array(SelectOption).optional()
+  options: import_zod14.z.array(SelectOption).optional(),
+  // If we ever need to override default field conditionals in advanced search
+  conditionals: import_zod14.z.array(FieldConditional).default([]).optional()
 });
 var FieldConfigSchema = BaseField3.extend({
   fieldId: import_zod14.z.string(),
   fieldType: import_zod14.z.literal("field")
 });
-var EventFieldId = import_zod14.z.enum(["trackingId", "status"]);
+var EventFieldId = import_zod14.z.enum([
+  "trackingId",
+  "status",
+  "registeredAt",
+  "registeredAtLocation",
+  "updatedAt"
+]);
 var EventFieldConfigSchema = BaseField3.extend({
   fieldId: EventFieldId,
   fieldType: import_zod14.z.literal("event")
@@ -1100,13 +1139,162 @@ var AdvancedSearchConfig = import_zod14.z.object({
 // ../commons/src/events/utils.ts
 var import_lodash = require("lodash");
 
+// ../commons/src/events/ActionDocument.ts
+var import_zod15 = require("zod");
+var import_zod_openapi3 = require("zod-openapi");
+(0, import_zod_openapi3.extendZodWithOpenApi)(import_zod15.z);
+var ActionUpdate = import_zod15.z.record(import_zod15.z.string(), FieldUpdateValue);
+var EventState = import_zod15.z.record(import_zod15.z.string(), FieldValue);
+var ActionStatus = {
+  Requested: "Requested",
+  Accepted: "Accepted",
+  Rejected: "Rejected"
+};
+var ActionBase = import_zod15.z.object({
+  id: import_zod15.z.string(),
+  transactionId: import_zod15.z.string(),
+  createdAt: import_zod15.z.string().datetime(),
+  createdBy: import_zod15.z.string(),
+  createdByRole: import_zod15.z.string(),
+  declaration: ActionUpdate,
+  annotation: ActionUpdate.optional(),
+  createdAtLocation: import_zod15.z.string(),
+  status: import_zod15.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_zod15.z.string().optional()
+});
+var AssignedAction = ActionBase.merge(
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ActionType.ASSIGN),
+    assignedTo: import_zod15.z.string()
+  })
+);
+var UnassignedAction = ActionBase.merge(
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ActionType.UNASSIGN),
+    assignedTo: import_zod15.z.literal(null)
+  })
+);
+var RegisterAction = ActionBase.merge(
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ActionType.REGISTER),
+    registrationNumber: import_zod15.z.string().optional()
+  })
+);
+var DeclareAction = ActionBase.merge(
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ActionType.DECLARE)
+  })
+);
+var ValidateAction = ActionBase.merge(
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ActionType.VALIDATE)
+  })
+);
+var RejectAction = ActionBase.merge(
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ActionType.REJECT)
+  })
+);
+var MarkAsDuplicateAction = ActionBase.merge(
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ActionType.MARKED_AS_DUPLICATE)
+  })
+);
+var ArchiveAction = ActionBase.merge(
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ActionType.ARCHIVE)
+  })
+);
+var CreatedAction = ActionBase.merge(
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ActionType.CREATE)
+  })
+);
+var NotifiedAction = ActionBase.merge(
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ActionType.NOTIFY)
+  })
+);
+var PrintCertificateAction = ActionBase.merge(
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ActionType.PRINT_CERTIFICATE)
+  })
+);
+var RequestedCorrectionAction = ActionBase.merge(
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ActionType.REQUEST_CORRECTION)
+  })
+);
+var ApprovedCorrectionAction = ActionBase.merge(
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ActionType.APPROVE_CORRECTION),
+    requestId: import_zod15.z.string()
+  })
+);
+var RejectedCorrectionAction = ActionBase.merge(
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ActionType.REJECT_CORRECTION),
+    requestId: import_zod15.z.string()
+  })
+);
+var ReadAction = ActionBase.merge(
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ActionType.READ)
+  })
+);
+var ActionDocument = import_zod15.z.discriminatedUnion("type", [
+  CreatedAction.openapi({ ref: "CreatedAction" }),
+  ValidateAction.openapi({ ref: "ValidateAction" }),
+  RejectAction.openapi({ ref: "RejectAction" }),
+  MarkAsDuplicateAction.openapi({ ref: "MarkAsDuplicateAction" }),
+  ArchiveAction.openapi({ ref: "ArchiveAction" }),
+  NotifiedAction.openapi({ ref: "NotifiedAction" }),
+  RegisterAction.openapi({ ref: "RegisterAction" }),
+  DeclareAction.openapi({ ref: "DeclareAction" }),
+  AssignedAction.openapi({ ref: "AssignedAction" }),
+  RequestedCorrectionAction.openapi({ ref: "RequestedCorrectionAction" }),
+  ApprovedCorrectionAction.openapi({ ref: "ApprovedCorrectionAction" }),
+  RejectedCorrectionAction.openapi({ ref: "RejectedCorrectionAction" }),
+  UnassignedAction.openapi({ ref: "UnassignedAction" }),
+  PrintCertificateAction.openapi({ ref: "PrintCertificateAction" }),
+  ReadAction.openapi({ ref: "ReadAction" })
+]).openapi({
+  ref: "ActionDocument"
+});
+var AsyncRejectActionDocument = ActionBase.omit({
+  declaration: true,
+  annotation: true
+}).merge(
+  import_zod15.z.object({
+    type: import_zod15.z.enum(ConfirmableActions),
+    status: import_zod15.z.literal(ActionStatus.Rejected)
+  })
+);
+var Action = import_zod15.z.union([ActionDocument, AsyncRejectActionDocument]);
+var ResolvedUser = import_zod15.z.object({
+  id: import_zod15.z.string(),
+  role: import_zod15.z.string(),
+  name: import_zod15.z.array(
+    import_zod15.z.object({
+      use: import_zod15.z.string(),
+      given: import_zod15.z.array(import_zod15.z.string()),
+      family: import_zod15.z.string()
+    })
+  )
+});
+
 // ../commons/src/conditionals/validate.ts
 var import_ajv = __toESM(require("ajv"));
 var import_ajv_formats = __toESM(require("ajv-formats"));
 var import_date_fns = require("date-fns");
 
 // ../commons/src/events/FieldTypeMapping.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 function mapFieldTypeToZod(type, required) {
   let schema;
   switch (type) {
@@ -1116,6 +1304,9 @@ function mapFieldTypeToZod(type, required) {
     case FieldType.EMAIL:
       schema = EmailValue;
       break;
+    case FieldType.DATE_RANGE:
+      schema = DateRangeFieldValue;
+      break;
     case FieldType.TEXT:
     case FieldType.TEXTAREA:
     case FieldType.DIVIDER:
@@ -1158,7 +1349,7 @@ function createValidationSchema(config) {
   for (const field2 of config) {
     shape[field2.id] = mapFieldTypeToZod(field2.type, field2.required);
   }
-  return import_zod15.z.object(shape);
+  return import_zod16.z.object(shape);
 }
 function mapFieldTypeToMockValue(field2, i) {
   switch (field2.type) {
@@ -1196,6 +1387,8 @@ function mapFieldTypeToMockValue(field2, i) {
       };
     case FieldType.DATE:
       return "2021-01-01";
+    case FieldType.DATE_RANGE:
+      return ["2021-01-01", "2021-01-02"];
     case FieldType.CHECKBOX:
       return true;
     case FieldType.FILE:
@@ -1230,6 +1423,7 @@ function mapFieldTypeToEmptyValue(field2) {
     case FieldType.EMAIL:
     case FieldType.DATE:
     case FieldType.CHECKBOX:
+    case FieldType.DATE_RANGE:
     case FieldType.DATA:
       return null;
     case FieldType.ADDRESS:
@@ -1262,6 +1456,9 @@ var isParagraphFieldType = (field2) => {
 var isDateFieldType = (field2) => {
   return field2.config.type === FieldType.DATE;
 };
+var isDateRangeFieldType = (field2) => {
+  return field2.config.type === FieldType.DATE_RANGE;
+};
 var isPageHeaderFieldType = (field2) => {
   return field2.config.type === FieldType.PAGE_HEADER;
 };
@@ -1604,7 +1801,10 @@ function createEmptyDraft(eventId, draftId, actionType) {
       annotation: {},
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       createdBy: "@todo",
-      createdAtLocation: "@todo"
+      createdAtLocation: "@todo",
+      status: ActionStatus.Accepted,
+      transactionId: "@todo",
+      createdByRole: "@todo"
     }
   };
 }
@@ -1676,25 +1876,43 @@ var findAllFields = (config) => {
     ...getAllAnnotationFields(config)
   ]);
 };
+function getMixedPath(obj, path, defaultValue) {
+  const parts = path.split(".");
+  const resolve = (current, segments) => {
+    if (current == null || segments.length === 0) {
+      return current;
+    }
+    for (let i = segments.length; i > 0; i--) {
+      const compoundKey = segments.slice(0, i).join(".");
+      if ((0, import_lodash.has)(current, compoundKey)) {
+        const next = (0, import_lodash.get)(current, compoundKey);
+        return resolve(next, segments.slice(i));
+      }
+    }
+    return void 0;
+  };
+  const result = resolve(obj, parts);
+  return (0, import_lodash.isNil)(result) ? defaultValue : result;
+}
 
 // ../commons/src/events/EventConfig.ts
-var import_zod_openapi3 = require("zod-openapi");
-(0, import_zod_openapi3.extendZodWithOpenApi)(import_zod16.z);
-var EventConfig = import_zod16.z.object({
-  id: import_zod16.z.string().describe(
+var import_zod_openapi4 = require("zod-openapi");
+(0, import_zod_openapi4.extendZodWithOpenApi)(import_zod17.z);
+var EventConfig = import_zod17.z.object({
+  id: import_zod17.z.string().describe(
     'A machine-readable identifier for the event, e.g. "birth" or "death"'
   ),
-  dateOfEvent: import_zod16.z.object({ fieldId: import_zod16.z.string() }).optional(),
+  dateOfEvent: import_zod17.z.object({ fieldId: import_zod17.z.string() }).optional(),
   title: TranslationConfig,
   fallbackTitle: TranslationConfig.optional().describe(
     "This is a fallback title if actual title resolves to empty string"
   ),
   summary: SummaryConfig,
   label: TranslationConfig,
-  actions: import_zod16.z.array(ActionConfig),
+  actions: import_zod17.z.array(ActionConfig),
   declaration: DeclarationFormConfig,
-  deduplication: import_zod16.z.array(DeduplicationConfig).optional().default([]),
-  advancedSearch: import_zod16.z.array(AdvancedSearchConfig).optional().default([])
+  deduplication: import_zod17.z.array(DeduplicationConfig).optional().default([]),
+  advancedSearch: import_zod17.z.array(AdvancedSearchConfig).optional().default([])
 }).superRefine((event2, ctx) => {
   const allFields = findAllFields(event2);
   const fieldIds = allFields.map((field2) => field2.id);
@@ -1756,350 +1974,92 @@ var definePage = (page) => PageConfig.parse(page);
 var defineFormPage = (formPage) => FormPageConfig.parse(formPage);
 
 // ../commons/src/events/WorkqueueConfig.ts
-var import_zod17 = require("zod");
-var WorkqueueConfig = import_zod17.z.object({
-  slug: import_zod17.z.string().describe("Determines the url of the workqueue."),
-  name: TranslationConfig.describe(
-    "Title of the workflow (both in navigation and on the page)"
-  ),
-  /**
-   * Placeholder untill the following gets merged to develop
-   * https://github.com/opencrvs/opencrvs-core/blob/5fbe9854a88504a7a13fcc856b3e82594b70c38c/packages/commons/src/events/EventIndex.ts#L92-L93
-   */
-  query: import_zod17.z.string(),
-  actions: import_zod17.z.array(
-    import_zod17.z.object({
-      type: import_zod17.z.string(),
-      conditionals: import_zod17.z.array(Conditional).optional()
-    })
-  )
-}).describe("Configuration for workqueue.");
-function defineWorkqueue(workqueues) {
-  return workqueues.map((workqueue) => WorkqueueConfig.parse(workqueue));
-}
-
-// ../commons/src/events/Draft.ts
 var import_zod20 = require("zod");
 
-// ../commons/src/events/ActionDocument.ts
+// ../commons/src/events/EventIndex.ts
+var import_zod19 = require("zod");
+
+// ../commons/src/events/EventMetadata.ts
 var import_zod18 = require("zod");
-var import_zod_openapi4 = require("zod-openapi");
-(0, import_zod_openapi4.extendZodWithOpenApi)(import_zod18.z);
-var ActionUpdate = import_zod18.z.record(import_zod18.z.string(), FieldUpdateValue);
-var ActionStatus = {
-  Requested: "Requested",
-  Accepted: "Accepted",
-  Rejected: "Rejected"
+var EventStatus = {
+  CREATED: "CREATED",
+  NOTIFIED: "NOTIFIED",
+  DECLARED: "DECLARED",
+  VALIDATED: "VALIDATED",
+  REGISTERED: "REGISTERED",
+  CERTIFIED: "CERTIFIED",
+  REJECTED: "REJECTED",
+  ARCHIVED: "ARCHIVED"
 };
-var ActionBase = import_zod18.z.object({
-  id: import_zod18.z.string(),
-  transactionId: import_zod18.z.string(),
-  createdAt: import_zod18.z.string().datetime(),
-  createdBy: import_zod18.z.string(),
-  createdByRole: import_zod18.z.string(),
-  declaration: ActionUpdate,
-  annotation: ActionUpdate.optional(),
-  createdAtLocation: import_zod18.z.string().optional(),
-  updatedAtLocation: import_zod18.z.string().optional(),
-  status: import_zod18.z.enum([
-    ActionStatus.Requested,
-    ActionStatus.Accepted,
-    ActionStatus.Rejected
-  ]),
-  // If the action is an asynchronous confirmation for another action, we will save the original action id here.
-  originalActionId: import_zod18.z.string().optional()
+var CustomFlags = {
+  CERTIFICATE_PRINTED: "certificate-printed"
+};
+var Flag = import_zod18.z.string().regex(
+  new RegExp(
+    `^(${Object.values(ActionType).join("|").toLowerCase()}):(${Object.values(ActionStatus).join("|").toLowerCase()})$`
+  ),
+  "Flag must be in the format ActionType:ActionStatus (lowerCase)"
+).or(import_zod18.z.nativeEnum(CustomFlags));
+var eventStatuses = Object.values(EventStatus);
+var EventStatuses = import_zod18.z.nativeEnum(EventStatus);
+var ZodDate = import_zod18.z.string().date();
+var ActionCreationMetadata = import_zod18.z.object({
+  createdAt: import_zod18.z.string().datetime().describe("The timestamp when the action request was created."),
+  createdBy: import_zod18.z.string().describe("ID of the user who created the action request."),
+  createdAtLocation: import_zod18.z.string().describe("Location of the user who created the action request."),
+  acceptedAt: import_zod18.z.string().datetime().describe("Timestamp when the action request was accepted."),
+  createdByRole: import_zod18.z.string().describe("Role of the user at the time of action request creation.")
 });
-var AssignedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod18.z.string()
-  })
-);
-var UnassignedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.UNASSIGN),
-    assignedTo: import_zod18.z.literal(null)
-  })
-);
-var RegisterAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.REGISTER),
-    registrationNumber: import_zod18.z.string().optional()
-  })
-);
-var DeclareAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.DECLARE)
-  })
-);
-var ValidateAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.VALIDATE)
-  })
-);
-var RejectAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.REJECT)
-  })
-);
-var MarkAsDuplicateAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.MARKED_AS_DUPLICATE)
-  })
-);
-var ArchiveAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.ARCHIVE)
-  })
-);
-var CreatedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.CREATE)
-  })
-);
-var NotifiedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.NOTIFY)
-  })
-);
-var PrintCertificateAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.PRINT_CERTIFICATE)
-  })
-);
-var RequestedCorrectionAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.REQUEST_CORRECTION)
-  })
-);
-var ApprovedCorrectionAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.APPROVE_CORRECTION),
-    requestId: import_zod18.z.string()
-  })
-);
-var RejectedCorrectionAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.REJECT_CORRECTION),
-    requestId: import_zod18.z.string()
-  })
-);
-var ReadAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.READ)
-  })
-);
-var ActionDocument = import_zod18.z.discriminatedUnion("type", [
-  CreatedAction.openapi({ ref: "CreatedAction" }),
-  ValidateAction.openapi({ ref: "ValidateAction" }),
-  RejectAction.openapi({ ref: "RejectAction" }),
-  MarkAsDuplicateAction.openapi({ ref: "MarkAsDuplicateAction" }),
-  ArchiveAction.openapi({ ref: "ArchiveAction" }),
-  NotifiedAction.openapi({ ref: "NotifiedAction" }),
-  RegisterAction.openapi({ ref: "RegisterAction" }),
-  DeclareAction.openapi({ ref: "DeclareAction" }),
-  AssignedAction.openapi({ ref: "AssignedAction" }),
-  RequestedCorrectionAction.openapi({ ref: "RequestedCorrectionAction" }),
-  ApprovedCorrectionAction.openapi({ ref: "ApprovedCorrectionAction" }),
-  RejectedCorrectionAction.openapi({ ref: "RejectedCorrectionAction" }),
-  UnassignedAction.openapi({ ref: "UnassignedAction" }),
-  PrintCertificateAction.openapi({ ref: "PrintCertificateAction" }),
-  ReadAction.openapi({ ref: "ReadAction" })
-]).openapi({
-  ref: "ActionDocument"
+var RegistrationCreationMetadata = ActionCreationMetadata.extend({
+  registrationNumber: import_zod18.z.string().describe(
+    "Registration number of the event. Always present for accepted registrations."
+  )
 });
-var AsyncRejectActionDocument = ActionBase.omit({
-  declaration: true,
-  annotation: true,
-  createdBy: true,
-  createdByRole: true,
-  createdAtLocation: true
-}).merge(
-  import_zod18.z.object({
-    type: import_zod18.z.enum(ConfirmableActions),
-    status: import_zod18.z.literal(ActionStatus.Rejected)
-  })
-);
-var Action = import_zod18.z.union([ActionDocument, AsyncRejectActionDocument]);
-var ResolvedUser = import_zod18.z.object({
+var LegalStatuses = import_zod18.z.object({
+  [EventStatus.DECLARED]: ActionCreationMetadata.nullish(),
+  [EventStatus.REGISTERED]: RegistrationCreationMetadata.nullish()
+});
+var EventMetadata = import_zod18.z.object({
   id: import_zod18.z.string(),
-  role: import_zod18.z.string(),
-  name: import_zod18.z.array(
-    import_zod18.z.object({
-      use: import_zod18.z.string(),
-      given: import_zod18.z.array(import_zod18.z.string()),
-      family: import_zod18.z.string()
-    })
-  )
+  type: import_zod18.z.string().describe("The type of event, such as birth, death, or marriage."),
+  status: EventStatuses,
+  legalStatuses: LegalStatuses.describe(
+    "Metadata related to the legal registration of the event, such as who registered it and when."
+  ),
+  createdAt: import_zod18.z.string().datetime().describe("The timestamp when the event was first created and saved."),
+  dateOfEvent: ZodDate.nullish(),
+  createdBy: import_zod18.z.string().describe("ID of the user who created the event."),
+  updatedByUserRole: import_zod18.z.string().describe("Role of the user who last updated the declaration."),
+  createdAtLocation: import_zod18.z.string().describe("Location of the user who created the event."),
+  updatedAtLocation: import_zod18.z.string().nullish().describe("Location of the user who last updated the declaration."),
+  updatedAt: import_zod18.z.string().datetime().describe("Timestamp of the most recent declaration update."),
+  assignedTo: import_zod18.z.string().nullish().describe("ID of the user currently assigned to the event."),
+  updatedBy: import_zod18.z.string().nullish().describe("ID of the user who last updated the declaration."),
+  trackingId: import_zod18.z.string().describe(
+    "System-generated tracking ID used by informants or registrars to look up the event."
+  ),
+  flags: import_zod18.z.array(Flag)
 });
-
-// ../commons/src/events/ActionInput.ts
-var import_zod19 = require("zod");
-var import_zod_openapi5 = require("zod-openapi");
-(0, import_zod_openapi5.extendZodWithOpenApi)(import_zod19.z);
-var BaseActionInput = import_zod19.z.object({
-  eventId: import_zod19.z.string(),
-  transactionId: import_zod19.z.string(),
-  declaration: ActionUpdate.default({}),
-  annotation: ActionUpdate.optional(),
-  originalActionId: import_zod19.z.string().optional(),
-  keepAssignment: import_zod19.z.boolean().optional()
-});
-var CreateActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.CREATE).default(ActionType.CREATE),
-    createdAtLocation: import_zod19.z.string()
-  })
-);
-var RegisterActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
-    registrationNumber: import_zod19.z.string().optional()
-  })
-);
-var ValidateActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
-    duplicates: import_zod19.z.array(import_zod19.z.string())
-  })
-);
-var NotifyActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
-  })
-);
-var DeclareActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
-  })
-);
-var PrintCertificateActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
-  })
-);
-var RejectDeclarationActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REJECT).default(ActionType.REJECT)
-  })
-);
-var MarkedAsDuplicateActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
-  })
-);
-var ArchiveActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE)
-  })
-);
-var AssignActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
-    assignedTo: import_zod19.z.string()
-  })
-);
-var UnassignActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
-    assignedTo: import_zod19.z.literal(null).default(null)
-  })
-);
-var RequestCorrectionActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
-  })
-);
-var RejectCorrectionActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    requestId: import_zod19.z.string(),
-    type: import_zod19.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
-  })
-);
-var ApproveCorrectionActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    requestId: import_zod19.z.string(),
-    type: import_zod19.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
-  })
-);
-var ReadActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.READ).default(ActionType.READ)
-  })
-);
-var DeleteActionInput = import_zod19.z.object({ eventId: import_zod19.z.string() });
-var ActionInput = import_zod19.z.discriminatedUnion("type", [
-  CreateActionInput.openapi({ ref: "CreateActionInput" }),
-  ValidateActionInput.openapi({ ref: "ValidateActionInput" }),
-  RegisterActionInput.openapi({ ref: "RegisterActionInput" }),
-  NotifyActionInput.openapi({ ref: "NotifyActionInput" }),
-  DeclareActionInput.openapi({ ref: "DeclareActionInput" }),
-  RejectDeclarationActionInput.openapi({
-    ref: "RejectDeclarationActionInput"
-  }),
-  MarkedAsDuplicateActionInput.openapi({
-    ref: "MarkedAsDuplicateActionInput"
-  }),
-  ArchiveActionInput.openapi({ ref: "ArchiveActionInput" }),
-  AssignActionInput.openapi({ ref: "AssignActionInput" }),
-  UnassignActionInput.openapi({ ref: "UnassignActionInput" }),
-  PrintCertificateActionInput.openapi({ ref: "PrintCertificateActionInput" }),
-  RequestCorrectionActionInput.openapi({
-    ref: "RequestCorrectionActionInput"
-  }),
-  RejectCorrectionActionInput.openapi({ ref: "RejectCorrectionActionInput" }),
-  ApproveCorrectionActionInput.openapi({
-    ref: "ApproveCorrectionActionInput"
-  }),
-  ReadActionInput.openapi({ ref: "ReadActionInput" })
-]).openapi({
-  ref: "ActionInput"
-});
-
-// ../commons/src/events/Draft.ts
-var Draft = import_zod20.z.object({
-  id: import_zod20.z.string(),
-  eventId: import_zod20.z.string(),
-  transactionId: import_zod20.z.string(),
-  createdAt: import_zod20.z.string().datetime(),
-  action: ActionBase.extend({
-    type: ActionTypes
-  }).omit({ id: true })
-});
-var DraftInput = BaseActionInput.extend({
-  type: ActionTypes
-});
-
-// ../commons/src/events/EventMetadata.ts
-var import_zod21 = require("zod");
-var EventStatus = {
-  CREATED: "CREATED",
-  NOTIFIED: "NOTIFIED",
-  DECLARED: "DECLARED",
-  VALIDATED: "VALIDATED",
-  REGISTERED: "REGISTERED",
-  CERTIFIED: "CERTIFIED",
-  REJECTED: "REJECTED",
-  ARCHIVED: "ARCHIVED"
-};
-var eventStatuses = Object.values(EventStatus);
-var EventStatuses = import_zod21.z.nativeEnum(EventStatus);
-var ZodDate = import_zod21.z.string().date();
-var EventMetadata = import_zod21.z.object({
-  id: import_zod21.z.string(),
-  type: import_zod21.z.string(),
-  status: EventStatuses,
-  createdAt: import_zod21.z.string().datetime(),
-  dateOfEvent: ZodDate.nullish(),
-  createdBy: import_zod21.z.string(),
-  updatedByUserRole: import_zod21.z.string(),
-  createdAtLocation: import_zod21.z.string(),
-  updatedAtLocation: import_zod21.z.string(),
-  updatedAt: import_zod21.z.string().datetime(),
-  assignedTo: import_zod21.z.string().nullish(),
-  updatedBy: import_zod21.z.string(),
-  trackingId: import_zod21.z.string(),
-  registrationNumber: import_zod21.z.string().nullish()
+var EventMetadataKeys = import_zod18.z.enum([
+  "id",
+  "type",
+  "status",
+  "createdAt",
+  "dateOfEvent",
+  "createdBy",
+  "updatedByUserRole",
+  "createdAtLocation",
+  "updatedAtLocation",
+  "updatedAt",
+  "assignedTo",
+  "updatedBy",
+  "trackingId",
+  "legalStatuses",
+  "flags"
+]);
+var EventMetadataParameter = import_zod18.z.object({
+  // @TODO: Reconcile with the event metadata definition. How could we derive one from the other?
+  $event: EventMetadataKeys
 });
 var eventMetadataLabelMap = {
   "event.assignedTo": {
@@ -2167,302 +2127,64 @@ var eventMetadataLabelMap = {
     defaultMessage: "Tracking ID",
     description: "Tracking ID"
   },
-  "event.registrationNumber": {
-    id: "event.registrationNumber.label",
-    defaultMessage: "Registration Number",
-    description: "Registration Number"
+  "event.flags": {
+    id: "event.flags.label",
+    defaultMessage: "Flags",
+    description: "Flags"
   }
 };
 
-// ../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(),
-  dateOfEvent: import_zod22.z.object({ fieldId: import_zod22.z.string() }).optional()
-});
-
-// ../commons/src/events/EventDocument.ts
-var import_zod23 = require("zod");
-var import_zod_openapi6 = require("zod-openapi");
-(0, import_zod_openapi6.extendZodWithOpenApi)(import_zod23.z);
-var EventDocument = import_zod23.z.object({
-  id: import_zod23.z.string(),
-  type: import_zod23.z.string(),
-  dateOfEvent: import_zod23.z.object({ fieldId: import_zod23.z.string() }).optional(),
-  createdAt: import_zod23.z.string().datetime(),
-  updatedAt: import_zod23.z.string().datetime(),
-  updatedAtLocation: import_zod23.z.string(),
-  actions: import_zod23.z.array(Action),
-  trackingId: import_zod23.z.string()
-}).openapi({ ref: "EventDocument" });
-
 // ../commons/src/events/EventIndex.ts
-var import_zod24 = require("zod");
 var EventIndex = EventMetadata.extend({
-  declaration: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.any())
+  declaration: EventState
 });
-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_zod19.z.record(import_zod19.z.string(), import_zod19.z.any()).and(
+  import_zod19.z.object({
+    type: import_zod19.z.string()
     // Ensures "type" (event-id) exists and is a string
   })
 );
-var Fuzzy = import_zod24.z.object({ type: import_zod24.z.literal("fuzzy"), term: import_zod24.z.string() });
-var Exact = import_zod24.z.object({ type: import_zod24.z.literal("exact"), term: import_zod24.z.string() });
-var AnyOf = import_zod24.z.object({
-  type: import_zod24.z.literal("anyOf"),
-  terms: import_zod24.z.array(import_zod24.z.string())
+var Fuzzy = import_zod19.z.object({ type: import_zod19.z.literal("fuzzy"), term: import_zod19.z.string() });
+var Exact = import_zod19.z.object({ type: import_zod19.z.literal("exact"), term: import_zod19.z.string() });
+var AnyOf = import_zod19.z.object({
+  type: import_zod19.z.literal("anyOf"),
+  terms: import_zod19.z.array(import_zod19.z.string())
 });
-var Range = import_zod24.z.object({
-  type: import_zod24.z.literal("range"),
-  gte: import_zod24.z.string(),
-  lte: import_zod24.z.string()
+var Range = import_zod19.z.object({
+  type: import_zod19.z.literal("range"),
+  gte: import_zod19.z.string(),
+  lte: import_zod19.z.string()
 });
-var Within = import_zod24.z.object({ type: import_zod24.z.literal("within"), location: import_zod24.z.string() });
-var DateCondition = import_zod24.z.union([Exact, Range]);
-var QueryInput = import_zod24.z.lazy(
-  () => import_zod24.z.union([
-    import_zod24.z.discriminatedUnion("type", [Fuzzy, Exact, Range, Within, AnyOf]),
-    import_zod24.z.record(import_zod24.z.string(), QueryInput)
+var Not = import_zod19.z.object({ type: import_zod19.z.literal("not"), term: import_zod19.z.string() });
+var Within = import_zod19.z.object({ type: import_zod19.z.literal("within"), location: import_zod19.z.string() });
+var DateCondition = import_zod19.z.union([Exact, Range]);
+var QueryInput = import_zod19.z.lazy(
+  () => import_zod19.z.union([
+    import_zod19.z.discriminatedUnion("type", [Fuzzy, Exact, Range, Within, AnyOf, Not]),
+    import_zod19.z.record(import_zod19.z.string(), QueryInput)
   ])
 );
-var QueryExpression = import_zod24.z.object({
-  type: import_zod24.z.literal("and"),
-  eventType: import_zod24.z.string(),
-  status: import_zod24.z.optional(import_zod24.z.union([AnyOf, Exact])),
-  createdAt: import_zod24.z.optional(DateCondition),
-  updatedAt: import_zod24.z.optional(DateCondition),
-  createAtLocation: import_zod24.z.optional(import_zod24.z.union([Within, Exact])),
-  updatedAtLocation: import_zod24.z.optional(import_zod24.z.union([Within, Exact])),
-  createdBy: import_zod24.z.optional(Exact),
-  updatedBy: import_zod24.z.optional(Exact),
-  trackingId: import_zod24.z.optional(Exact),
+var QueryExpression = import_zod19.z.object({
+  type: import_zod19.z.literal("and"),
+  eventType: import_zod19.z.string(),
+  status: import_zod19.z.optional(import_zod19.z.union([AnyOf, Exact])),
+  createdAt: import_zod19.z.optional(DateCondition),
+  updatedAt: import_zod19.z.optional(DateCondition),
+  registeredAt: import_zod19.z.optional(DateCondition),
+  registeredAtLocation: import_zod19.z.optional(import_zod19.z.union([Within, Exact])),
+  createAtLocation: import_zod19.z.optional(import_zod19.z.union([Within, Exact])),
+  updatedAtLocation: import_zod19.z.optional(import_zod19.z.union([Within, Exact])),
+  createdBy: import_zod19.z.optional(Exact),
+  updatedBy: import_zod19.z.optional(Exact),
+  trackingId: import_zod19.z.optional(Exact),
+  flags: import_zod19.z.optional(import_zod19.z.array(import_zod19.z.union([AnyOf, Not]))),
   data: QueryInput
 }).partial();
-var Or2 = import_zod24.z.object({
-  type: import_zod24.z.literal("or"),
-  clauses: import_zod24.z.array(QueryExpression)
+var Or2 = import_zod19.z.object({
+  type: import_zod19.z.literal("or"),
+  clauses: import_zod19.z.array(QueryExpression)
 });
-var QueryType = import_zod24.z.discriminatedUnion("type", [QueryExpression, Or2]);
-
-// ../commons/src/events/state/index.ts
-function getStatusFromActions(actions) {
-  const hasRejectedAction = actions.some(
-    (a) => a.status === ActionStatus.Rejected
-  );
-  if (hasRejectedAction) {
-    return EventStatus.REJECTED;
-  }
-  return actions.reduce((status, action) => {
-    switch (action.type) {
-      case ActionType.CREATE:
-        return EventStatus.CREATED;
-      case ActionType.DECLARE:
-        return EventStatus.DECLARED;
-      case ActionType.VALIDATE:
-        return EventStatus.VALIDATED;
-      case ActionType.REGISTER:
-        return EventStatus.REGISTERED;
-      case ActionType.REJECT:
-        return EventStatus.REJECTED;
-      case ActionType.ARCHIVE:
-        return EventStatus.ARCHIVED;
-      case ActionType.NOTIFY:
-        return EventStatus.NOTIFIED;
-      case ActionType.PRINT_CERTIFICATE:
-        return EventStatus.CERTIFIED;
-      case ActionType.ASSIGN:
-      case ActionType.UNASSIGN:
-      case ActionType.REQUEST_CORRECTION:
-      case ActionType.APPROVE_CORRECTION:
-      case ActionType.MARKED_AS_DUPLICATE:
-      case ActionType.REJECT_CORRECTION:
-      case ActionType.READ:
-      default:
-        return status;
-    }
-  }, EventStatus.CREATED);
-}
-function getLastUpdatedByUserRoleFromActions(actions) {
-  const actionsWithRoles = actions.filter(
-    (action) => !isWriteAction(action.type) && action.status !== ActionStatus.Rejected
-  ).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-  const lastAction = actionsWithRoles.at(-1);
-  if (!lastAction) {
-    throw new Error(
-      "Should never happen, at least CREATE action should be present"
-    );
-  }
-  return ActionDocument.parse(lastAction).createdByRole;
-}
-function getAssignedUserFromActions(actions) {
-  return actions.reduce((user2, action) => {
-    if (action.type === ActionType.ASSIGN) {
-      return action.assignedTo;
-    }
-    if (action.type === ActionType.UNASSIGN) {
-      return null;
-    }
-    return user2;
-  }, null);
-}
-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.declaration);
-    }
-    return deepMerge(status, action.declaration);
-  }, {});
-}
-function deepDropNulls(obj) {
-  if (Array.isArray(obj)) {
-    return obj.map(deepDropNulls);
-  }
-  if (obj !== null && typeof obj === "object") {
-    return Object.entries(obj).reduce((acc, [key, value]) => {
-      const cleanedValue = deepDropNulls(value);
-      if (cleanedValue !== null) {
-        ;
-        acc[key] = cleanedValue;
-      }
-      return acc;
-    }, {});
-  }
-  return obj;
-}
-function isUndeclaredDraft(status) {
-  return status === EventStatus.CREATED;
-}
-function getAcceptedActions(event2) {
-  return event2.actions.filter(
-    (a) => a.status === ActionStatus.Accepted
-  );
-}
-function getCurrentEventState(event2) {
-  const creationAction = event2.actions.find(
-    (action) => action.type === ActionType.CREATE
-  );
-  if (!creationAction) {
-    throw new Error(`Event ${event2.id} has no creation action`);
-  }
-  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;
-  const declaration = aggregateActionDeclarations(activeActions);
-  let dateOfEvent = event2.createdAt.split("T")[0];
-  if (event2.dateOfEvent) {
-    const parsedDate = ZodDate.safeParse(declaration[event2.dateOfEvent.fieldId]);
-    dateOfEvent = parsedDate.success ? parsedDate.data : null;
-  }
-  return deepDropNulls({
-    id: event2.id,
-    type: event2.type,
-    status: getStatusFromActions(event2.actions),
-    createdAt: event2.createdAt,
-    createdBy: creationAction.createdBy,
-    createdAtLocation: creationAction.createdAtLocation ?? "",
-    // @todo remove using empty string
-    updatedAt: latestAction.createdAt,
-    assignedTo: getAssignedUserFromActions(activeActions),
-    updatedBy: latestAction.createdBy,
-    updatedAtLocation: event2.updatedAtLocation,
-    declaration,
-    trackingId: event2.trackingId,
-    registrationNumber,
-    updatedByUserRole: getLastUpdatedByUserRoleFromActions(event2.actions),
-    dateOfEvent
-  });
-}
-function getCurrentEventStateWithDrafts(event2, drafts) {
-  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,
-        {
-          ...action,
-          type: ActionType.APPROVE_CORRECTION
-        }
-      ];
-    }
-    return [action];
-  });
-  const actionWithDrafts = [...actions, ...activeDrafts].sort();
-  const withDrafts = {
-    ...event2,
-    actions: actionWithDrafts
-  };
-  return getCurrentEventState(withDrafts);
-}
-function applyDraftsToEventIndex(eventIndex, drafts) {
-  const indexedAt = eventIndex.updatedAt;
-  const activeDrafts = drafts.filter(({ createdAt }) => new Date(createdAt) > new Date(indexedAt)).map((draft) => draft.action).sort();
-  if (activeDrafts.length === 0) {
-    return eventIndex;
-  }
-  return {
-    ...eventIndex,
-    declaration: {
-      ...eventIndex.declaration,
-      ...activeDrafts[activeDrafts.length - 1].declaration
-    }
-  };
-}
-function getAnnotationFromDrafts(drafts) {
-  const actions = drafts.map((draft) => draft.action);
-  const annotation = actions.reduce((ann, action) => {
-    return deepMerge(ann, action.annotation ?? {});
-  }, {});
-  return deepDropNulls(annotation);
-}
-function getActionAnnotation({
-  event: event2,
-  actionType,
-  drafts = []
-}) {
-  const activeActions = getAcceptedActions(event2);
-  const action = activeActions.find(
-    (activeAction) => actionType === activeAction.type
-  );
-  const eventDrafts = drafts.filter((draft) => draft.eventId === event2.id);
-  const sorted = [
-    ...action ? [action] : [],
-    ...eventDrafts.map((draft) => draft.action)
-  ].sort();
-  const annotation = sorted.reduce((ann, sortedAction) => {
-    return deepMerge(ann, sortedAction.annotation ?? {});
-  }, {});
-  return deepDropNulls(annotation);
-}
-
-// ../commons/src/events/defineConfig.ts
-var defineConfig = (config) => {
-  const input = EventConfig.parse(config);
-  return input;
-};
-
-// ../commons/src/events/transactions.ts
-function generateTransactionId() {
-  return getUUID();
-}
-
-// ../commons/src/events/test.utils.ts
-var import_lodash2 = require("lodash");
+var QueryType = import_zod19.z.discriminatedUnion("type", [QueryExpression, Or2]);
 
 // ../commons/src/conditionals/conditionals.ts
 function defineConditional(schema) {
@@ -2747,81 +2469,619 @@ function createFieldConditionals(fieldId) {
       },
       required: [fieldId]
     }),
-    isBetween: (min, max) => defineFormConditional({
-      type: "object",
-      properties: {
-        [fieldId]: {
-          type: "number",
-          minimum: min,
-          maximum: max
+    isBetween: (min, max) => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "number",
+          minimum: min,
+          maximum: max
+        }
+      },
+      required: [fieldId]
+    }),
+    getId: () => ({ fieldId })
+  };
+}
+
+// ../commons/src/searchConfigs.ts
+function createSearchConfigs(baseField) {
+  return {
+    /**
+     * Creates a range configuration for the specified field.
+     *
+     * @returns An object containing the field ID and a configuration object with a type of 'range'.
+     *
+     * @example event('registeredAt').range()
+     * // {
+     * //   ...
+     * //   config: { type: 'range' }
+     * // }
+     */
+    range: () => ({
+      ...baseField,
+      config: { type: "range" }
+    }),
+    /**
+     * Creates a configuration for exact matching of the specified field.
+     * @returns  An object containing the field ID and a configuration object with a type of 'exact'.
+     * @example field('dob').exact()
+     * // {
+     * //   ...
+     * //   config: { type: 'exact' }
+     * // }
+     */
+    exact: () => ({
+      ...baseField,
+      config: { type: "exact" }
+    }),
+    /**
+     * Creates a configuration for fuzzy matching of the specified field.
+     * @returns  An object containing the field ID and a configuration object with a type of 'exact'.
+     * @example field('name').fuzzy()
+     * // {
+     * //   ...
+     * //   config: { type: 'fuzzy' }
+     * // }
+     */
+    fuzzy: () => ({
+      ...baseField,
+      config: { type: "fuzzy" }
+    })
+  };
+}
+
+// ../commons/src/event-config/event-configuration.ts
+function createEventFieldConfig(fieldId, options) {
+  const baseField = {
+    fieldId,
+    options,
+    fieldType: "event"
+  };
+  return createSearchConfigs(baseField);
+}
+
+// ../commons/src/events/event.ts
+function eventFn(fieldId, options) {
+  return createEventFieldConfig(fieldId, options);
+}
+var event = Object.assign(eventFn, {
+  ...createEventConditionals(),
+  field(field2) {
+    return {
+      $event: field2
+    };
+  }
+});
+
+// ../commons/src/events/WorkqueueConfig.ts
+var WorkqueueConfig = import_zod20.z.object({
+  slug: import_zod20.z.string().describe("Determines the url of the workqueue."),
+  name: TranslationConfig.describe(
+    "Title of the workflow (both in navigation and on the page)"
+  ),
+  query: QueryType,
+  actions: import_zod20.z.array(
+    import_zod20.z.object({
+      type: import_zod20.z.string(),
+      conditionals: import_zod20.z.array(Conditional).optional()
+    })
+  ),
+  columns: import_zod20.z.array(
+    import_zod20.z.object({ label: TranslationConfig, value: EventMetadataParameter })
+  ).default([
+    {
+      label: {
+        id: "workqueues.dateOfEvent",
+        defaultMessage: "Date of Event",
+        description: "Label for workqueue column: dateOfEvent"
+      },
+      value: event.field("dateOfEvent")
+    }
+  ])
+}).describe("Configuration for workqueue.");
+function defineWorkqueue(workqueues) {
+  return workqueues.map((workqueue) => WorkqueueConfig.parse(workqueue));
+}
+
+// ../commons/src/events/Draft.ts
+var import_zod22 = require("zod");
+
+// ../commons/src/events/ActionInput.ts
+var import_zod21 = require("zod");
+var import_zod_openapi5 = require("zod-openapi");
+(0, import_zod_openapi5.extendZodWithOpenApi)(import_zod21.z);
+var BaseActionInput = import_zod21.z.object({
+  eventId: import_zod21.z.string(),
+  transactionId: import_zod21.z.string(),
+  declaration: ActionUpdate.default({}),
+  annotation: ActionUpdate.optional(),
+  originalActionId: import_zod21.z.string().optional(),
+  keepAssignment: import_zod21.z.boolean().optional()
+});
+var CreateActionInput = BaseActionInput.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.CREATE).default(ActionType.CREATE),
+    createdAtLocation: import_zod21.z.string()
+  })
+);
+var RegisterActionInput = BaseActionInput.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
+    registrationNumber: import_zod21.z.string().optional()
+  })
+);
+var ValidateActionInput = BaseActionInput.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
+    duplicates: import_zod21.z.array(import_zod21.z.string())
+  })
+);
+var NotifyActionInput = BaseActionInput.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
+  })
+);
+var DeclareActionInput = BaseActionInput.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
+  })
+);
+var PrintCertificateActionInput = BaseActionInput.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
+  })
+);
+var RejectDeclarationActionInput = BaseActionInput.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.REJECT).default(ActionType.REJECT)
+  })
+);
+var MarkedAsDuplicateActionInput = BaseActionInput.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
+  })
+);
+var ArchiveActionInput = BaseActionInput.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE)
+  })
+);
+var AssignActionInput = BaseActionInput.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
+    assignedTo: import_zod21.z.string()
+  })
+);
+var UnassignActionInput = BaseActionInput.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
+    assignedTo: import_zod21.z.literal(null).default(null)
+  })
+);
+var RequestCorrectionActionInput = BaseActionInput.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
+  })
+);
+var RejectCorrectionActionInput = BaseActionInput.merge(
+  import_zod21.z.object({
+    requestId: import_zod21.z.string(),
+    type: import_zod21.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
+  })
+);
+var ApproveCorrectionActionInput = BaseActionInput.merge(
+  import_zod21.z.object({
+    requestId: import_zod21.z.string(),
+    type: import_zod21.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
+  })
+);
+var ReadActionInput = BaseActionInput.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.READ).default(ActionType.READ)
+  })
+);
+var DeleteActionInput = import_zod21.z.object({ eventId: import_zod21.z.string() });
+var ActionInput = import_zod21.z.discriminatedUnion("type", [
+  CreateActionInput.openapi({ ref: "CreateActionInput" }),
+  ValidateActionInput.openapi({ ref: "ValidateActionInput" }),
+  RegisterActionInput.openapi({ ref: "RegisterActionInput" }),
+  NotifyActionInput.openapi({ ref: "NotifyActionInput" }),
+  DeclareActionInput.openapi({ ref: "DeclareActionInput" }),
+  RejectDeclarationActionInput.openapi({
+    ref: "RejectDeclarationActionInput"
+  }),
+  MarkedAsDuplicateActionInput.openapi({
+    ref: "MarkedAsDuplicateActionInput"
+  }),
+  ArchiveActionInput.openapi({ ref: "ArchiveActionInput" }),
+  AssignActionInput.openapi({ ref: "AssignActionInput" }),
+  UnassignActionInput.openapi({ ref: "UnassignActionInput" }),
+  PrintCertificateActionInput.openapi({ ref: "PrintCertificateActionInput" }),
+  RequestCorrectionActionInput.openapi({
+    ref: "RequestCorrectionActionInput"
+  }),
+  RejectCorrectionActionInput.openapi({ ref: "RejectCorrectionActionInput" }),
+  ApproveCorrectionActionInput.openapi({
+    ref: "ApproveCorrectionActionInput"
+  }),
+  ReadActionInput.openapi({ ref: "ReadActionInput" })
+]).openapi({
+  ref: "ActionInput"
+});
+
+// ../commons/src/events/Draft.ts
+var Draft = import_zod22.z.object({
+  id: import_zod22.z.string(),
+  eventId: import_zod22.z.string(),
+  transactionId: import_zod22.z.string(),
+  createdAt: import_zod22.z.string().datetime(),
+  action: ActionBase.extend({
+    type: ActionTypes
+  }).omit({ id: true })
+});
+var DraftInput = BaseActionInput.extend({
+  type: ActionTypes,
+  status: import_zod22.z.enum([
+    ActionStatus.Requested,
+    ActionStatus.Accepted,
+    ActionStatus.Rejected
+  ])
+});
+
+// ../commons/src/events/EventInput.ts
+var import_zod23 = require("zod");
+var EventInput = import_zod23.z.object({
+  transactionId: import_zod23.z.string(),
+  type: import_zod23.z.string(),
+  dateOfEvent: import_zod23.z.object({ fieldId: import_zod23.z.string() }).optional()
+});
+
+// ../commons/src/events/EventDocument.ts
+var import_zod24 = require("zod");
+var import_zod_openapi6 = require("zod-openapi");
+(0, import_zod_openapi6.extendZodWithOpenApi)(import_zod24.z);
+var EventDocument = import_zod24.z.object({
+  id: import_zod24.z.string(),
+  type: import_zod24.z.string(),
+  dateOfEvent: import_zod24.z.object({ fieldId: import_zod24.z.string() }).optional(),
+  createdAt: import_zod24.z.string().datetime(),
+  updatedAt: import_zod24.z.string().datetime(),
+  registeredAt: import_zod24.z.string().datetime().optional(),
+  // search based on registeration date
+  registeredAtLocation: import_zod24.z.string().optional(),
+  // search based on registeration location
+  actions: import_zod24.z.array(Action),
+  trackingId: import_zod24.z.string()
+}).openapi({ ref: "EventDocument" });
+
+// ../commons/src/events/state/utils.ts
+function getActionRequests(actionType, actions) {
+  const filtered = actions.filter((action) => action.type === actionType);
+  const accept = filtered.find(
+    (action) => action.status === ActionStatus.Accepted
+  );
+  const request = filtered.find(
+    (action) => action.status === ActionStatus.Requested
+  );
+  const reject = filtered.find(
+    (action) => action.status === ActionStatus.Rejected
+  );
+  return {
+    reject,
+    accept,
+    request
+  };
+}
+function getDeclarationActionCreationMetadata(actionType, actions) {
+  const { accept: acceptAction, request: requestAction } = getActionRequests(
+    actionType,
+    actions
+  );
+  if (!acceptAction) {
+    return null;
+  }
+  const registrationNumber = acceptAction.type === ActionType.REGISTER ? acceptAction.registrationNumber : null;
+  return {
+    // When 3rd party API returns 200 OK, we assume that the request was accepted, and persist single 'accepted' action.
+    createdAt: requestAction?.createdAt ?? acceptAction.createdAt,
+    createdBy: requestAction?.createdBy ?? acceptAction.createdBy,
+    createdAtLocation: requestAction?.createdAtLocation ?? acceptAction.createdAtLocation,
+    acceptedAt: acceptAction.createdAt,
+    createdByRole: requestAction?.createdByRole ?? acceptAction.createdByRole,
+    registrationNumber
+  };
+}
+function getDeclarationActionUpdateMetadata(actions) {
+  const createAction = getOrThrow(
+    actions.find((action) => action.type === ActionType.CREATE),
+    `Event has no ${ActionType.CREATE} action`
+  );
+  return [ActionType.DECLARE, ActionType.VALIDATE, ActionType.REGISTER].reduce(
+    (metadata, actionType) => {
+      const { accept, request } = getActionRequests(actionType, actions);
+      return {
+        createdAt: request?.createdAt ?? accept?.createdAt ?? metadata.createdAt,
+        createdBy: request?.createdBy ?? accept?.createdBy ?? metadata.createdBy,
+        createdAtLocation: request?.createdAtLocation ?? accept?.createdAtLocation ?? metadata.createdAtLocation,
+        createdByRole: request?.createdByRole ?? accept?.createdByRole ?? metadata.createdByRole
+      };
+    },
+    {
+      createdAt: createAction.createdAt,
+      createdBy: createAction.createdBy,
+      createdAtLocation: createAction.createdAtLocation,
+      createdByRole: createAction.createdByRole
+    }
+  );
+}
+function getLegalStatuses(actions) {
+  return {
+    [EventStatus.DECLARED]: getDeclarationActionCreationMetadata(
+      ActionType.DECLARE,
+      actions
+    ),
+    [EventStatus.REGISTERED]: getDeclarationActionCreationMetadata(
+      ActionType.REGISTER,
+      actions
+    )
+  };
+}
+
+// ../commons/src/events/state/index.ts
+function getStatusFromActions(actions) {
+  const hasRejectedAction = actions.some(
+    (a) => a.status === ActionStatus.Rejected
+  );
+  if (hasRejectedAction) {
+    return EventStatus.REJECTED;
+  }
+  return actions.reduce((status, action) => {
+    switch (action.type) {
+      case ActionType.CREATE:
+        return EventStatus.CREATED;
+      case ActionType.DECLARE:
+        return EventStatus.DECLARED;
+      case ActionType.VALIDATE:
+        return EventStatus.VALIDATED;
+      case ActionType.REGISTER:
+        return EventStatus.REGISTERED;
+      case ActionType.REJECT:
+        return EventStatus.REJECTED;
+      case ActionType.ARCHIVE:
+        return EventStatus.ARCHIVED;
+      case ActionType.NOTIFY:
+        return EventStatus.NOTIFIED;
+      case ActionType.PRINT_CERTIFICATE:
+        return EventStatus.CERTIFIED;
+      case ActionType.ASSIGN:
+      case ActionType.UNASSIGN:
+      case ActionType.REQUEST_CORRECTION:
+      case ActionType.APPROVE_CORRECTION:
+      case ActionType.MARKED_AS_DUPLICATE:
+      case ActionType.REJECT_CORRECTION:
+      case ActionType.READ:
+      default:
+        return status;
+    }
+  }, EventStatus.CREATED);
+}
+function getFlagsFromActions(actions) {
+  const sortedactions = actions.sort(
+    (a, b) => a.createdAt.localeCompare(b.createdAt)
+  );
+  const actionStatus = sortedactions.reduce(
+    (actionStatuses, { type, status }) => ({
+      ...actionStatuses,
+      [type]: status
+    }),
+    {}
+  );
+  const flags = Object.entries(actionStatus).filter(([, status]) => status !== ActionStatus.Accepted).map(([type, status]) => {
+    const flag = `${type.toLowerCase()}:${status.toLowerCase()}`;
+    return flag;
+  });
+  const isCertificatePrinted = sortedactions.reduce(
+    (prev, { type }) => {
+      if (type === ActionType.PRINT_CERTIFICATE) {
+        return true;
+      }
+      if (type === ActionType.APPROVE_CORRECTION) {
+        return false;
+      }
+      return prev;
+    },
+    false
+  );
+  if (isCertificatePrinted) {
+    flags.push(CustomFlags.CERTIFICATE_PRINTED);
+  }
+  return flags;
+}
+function getAssignedUserFromActions(actions) {
+  return actions.reduce((user2, action) => {
+    if (action.type === ActionType.ASSIGN) {
+      return action.assignedTo;
+    }
+    if (action.type === ActionType.UNASSIGN) {
+      return null;
+    }
+    return user2;
+  }, null);
+}
+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.declaration);
+    }
+    return deepMerge(status, action.declaration);
+  }, {});
+}
+function deepDropNulls(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(deepDropNulls);
+  }
+  if (obj !== null && typeof obj === "object") {
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+      const cleanedValue = deepDropNulls(value);
+      if (cleanedValue !== null) {
+        ;
+        acc[key] = cleanedValue;
+      }
+      return acc;
+    }, {});
+  }
+  return obj;
+}
+function isUndeclaredDraft(status) {
+  return status === EventStatus.CREATED;
+}
+function getAcceptedActions(event2) {
+  return event2.actions.filter(
+    (a) => a.status === ActionStatus.Accepted
+  );
+}
+var DEFAULT_DATE_OF_EVENT_PROPERTY = "createdAt";
+function getCurrentEventState(event2) {
+  const creationAction = event2.actions.find(
+    (action) => action.type === ActionType.CREATE
+  );
+  if (!creationAction) {
+    throw new Error(`Event ${event2.id} has no creation action`);
+  }
+  const acceptedActions = getAcceptedActions(event2);
+  const declarationUpdateMetadata = getDeclarationActionUpdateMetadata(
+    event2.actions
+  );
+  const declaration = aggregateActionDeclarations(acceptedActions);
+  const dateOfEvent = ZodDate.safeParse(
+    event2.dateOfEvent?.fieldId ? declaration[event2.dateOfEvent.fieldId] : event2[DEFAULT_DATE_OF_EVENT_PROPERTY]
+  ).data ?? null;
+  return deepDropNulls({
+    id: event2.id,
+    type: event2.type,
+    status: getStatusFromActions(event2.actions),
+    legalStatuses: getLegalStatuses(event2.actions),
+    createdAt: creationAction.createdAt,
+    createdBy: creationAction.createdBy,
+    createdAtLocation: creationAction.createdAtLocation,
+    updatedAt: declarationUpdateMetadata.createdAt,
+    assignedTo: getAssignedUserFromActions(acceptedActions),
+    updatedBy: declarationUpdateMetadata.createdBy,
+    declaration,
+    trackingId: event2.trackingId,
+    // @TODO: unify this with rest of the code. It will trip us if updatedBy has different rules than updatedByUserRole
+    updatedByUserRole: declarationUpdateMetadata.createdByRole,
+    dateOfEvent,
+    flags: getFlagsFromActions(event2.actions)
+  });
+}
+function getCurrentEventStateWithDrafts(event2, drafts) {
+  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,
+        {
+          ...action,
+          type: ActionType.APPROVE_CORRECTION
         }
-      },
-      required: [fieldId]
-    }),
-    getId: () => ({ fieldId })
+      ];
+    }
+    return [action];
+  });
+  const actionWithDrafts = [...actions, ...activeDrafts].sort();
+  const withDrafts = {
+    ...event2,
+    actions: actionWithDrafts
+  };
+  return getCurrentEventState(withDrafts);
+}
+function applyDraftsToEventIndex(eventIndex, drafts) {
+  const indexedAt = eventIndex.updatedAt;
+  const activeDrafts = drafts.filter(({ createdAt }) => new Date(createdAt) > new Date(indexedAt)).map((draft) => draft.action).sort();
+  if (activeDrafts.length === 0) {
+    return eventIndex;
+  }
+  return {
+    ...eventIndex,
+    declaration: {
+      ...eventIndex.declaration,
+      ...activeDrafts[activeDrafts.length - 1].declaration
+    }
   };
 }
+function getAnnotationFromDrafts(drafts) {
+  const actions = drafts.map((draft) => draft.action);
+  const annotation = actions.reduce((ann, action) => {
+    return deepMerge(ann, action.annotation ?? {});
+  }, {});
+  return deepDropNulls(annotation);
+}
+function getActionAnnotation({
+  event: event2,
+  actionType,
+  drafts = []
+}) {
+  const activeActions = getAcceptedActions(event2);
+  const action = activeActions.find(
+    (activeAction) => actionType === activeAction.type
+  );
+  const eventDrafts = drafts.filter((draft) => draft.eventId === event2.id);
+  const sorted = [
+    ...action ? [action] : [],
+    ...eventDrafts.map((draft) => draft.action)
+  ].sort();
+  const annotation = sorted.reduce((ann, sortedAction) => {
+    return deepMerge(ann, sortedAction.annotation ?? {});
+  }, {});
+  return deepDropNulls(annotation);
+}
+
+// ../commons/src/events/defineConfig.ts
+var defineConfig = (config) => {
+  const input = EventConfig.parse(config);
+  return input;
+};
+
+// ../commons/src/events/transactions.ts
+function generateTransactionId() {
+  return getUUID();
+}
+
+// ../commons/src/events/test.utils.ts
+var import_lodash2 = require("lodash");
 
 // ../commons/src/field-config/field-configuration.ts
-function createFieldConfigs(fieldId) {
+function createFieldConfigs(fieldId, options) {
   const baseField = {
     fieldId,
-    fieldType: "field"
-  };
-  return {
-    /**
-     * Creates a range configuration for the specified field.
-     *
-     * @returns An object containing the field ID and a configuration object with a type of 'RANGE'.
-     *
-     * @example field('age').range()
-     * // {
-     * //   fieldId: 'age',
-     * //   config: { type: 'RANGE' }
-     * // }
-     */
-    range: () => ({
-      ...baseField,
-      config: { type: "RANGE" }
-    }),
-    /**
-     * Creates a configuration for exact matching of the specified field.
-     * @returns  An object containing the field ID and a configuration object with a type of 'EXACT'.
-     * @example field('dob').exact()
-     * // {
-     * //   fieldId: 'dob',
-     * //   config: { type: 'EXACT' }
-     * // }
-     */
-    exact: () => ({
-      ...baseField,
-      config: { type: "EXACT" }
-    }),
-    /**
-     * Creates a configuration for fuzzy matching of the specified field.
-     * @returns  An object containing the field ID and a configuration object with a type of 'EXACT'.
-     * @example field('name').fuzzy()
-     * // {
-     * //   fieldId: 'name',
-     * //   config: { type: 'FUZZY' }
-     * // }
-     */
-    fuzzy: () => ({
-      ...baseField,
-      config: { type: "FUZZY" }
-    })
+    fieldType: "field",
+    ...options
   };
+  return createSearchConfigs(baseField);
 }
 
 // ../commons/src/events/field.ts
-function field(fieldId) {
+function field(fieldId, options = {}) {
   return {
     /**
      * @private Internal property used for field reference tracking.
      */
     _fieldId: fieldId,
     ...createFieldConditionals(fieldId),
-    ...createFieldConfigs(fieldId)
+    ...createFieldConfigs(fieldId, options)
   };
 }
 
@@ -4093,7 +4353,7 @@ var tennisClubMembershipEvent = defineConfig({
         description: "This is what this event is referred as in the system",
         id: "v2.event.tennis-club-membership.search"
       },
-      fields: [field("applicant.dob").exact()]
+      fields: [field("applicant.dob").exact(), event("registeredAt").exact()]
     }
   ],
   declaration: TENNIS_CLUB_DECLARATION_FORM
@@ -4176,8 +4436,7 @@ var eventPayloadGenerator = {
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         createdBy: "@todo",
         createdByRole: "@todo",
-        createdAtLocation: "@todo",
-        updatedAtLocation: "@todo"
+        createdAtLocation: "@todo"
       }
     },
     input
@@ -4340,13 +4599,12 @@ function generateActionDocument({
     createdBy: getUUID(),
     createdByRole: "FIELD_AGENT",
     id: getUUID(),
-    createdAtLocation: "TODO",
-    updatedAtLocation: "TODO",
+    createdAtLocation: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
     declaration: generateActionDeclarationInput(configuration, action),
     annotation: {},
-    ...defaults,
     status: ActionStatus.Accepted,
-    transactionId: getUUID()
+    transactionId: getUUID(),
+    ...defaults
   };
   switch (action) {
     case ActionType.READ:
@@ -4405,8 +4663,7 @@ function generateEventDocument({
     // 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(),
-    dateOfEvent: configuration.dateOfEvent,
-    updatedAtLocation: getUUID()
+    dateOfEvent: configuration.dateOfEvent
   };
 }
 function generateEventDraftDocument(eventId, actionType = ActionType.DECLARE, declaration = {}) {
@@ -4428,10 +4685,64 @@ function generateEventDraftDocument(eventId, actionType = ActionType.DECLARE, de
     eventId
   };
 }
+function getEventStatus() {
+  const statuses = [
+    EventStatus.CREATED,
+    EventStatus.REGISTERED,
+    EventStatus.DECLARED
+  ];
+  const randomIndex = Math.floor(Math.random() * 3);
+  return statuses[randomIndex];
+}
+function getTrackingId() {
+  const uuid = getUUID().replace(/-/g, "");
+  const trackingId = uuid.slice(0, 6).toUpperCase();
+  return trackingId;
+}
+function getRandomApplicant() {
+  const firstNames = [
+    "Danny",
+    "John",
+    "Jane",
+    "Emily",
+    "Michael",
+    "Sarah",
+    "Chris",
+    "Jessica"
+  ];
+  const surnames = [
+    "Doe",
+    "Smith",
+    "Johnson",
+    "Brown",
+    "Williams",
+    "Jones",
+    "Garcia",
+    "Miller"
+  ];
+  function getRandomDate(start, end) {
+    const randomDate = new Date(
+      start.getTime() + Math.random() * (end.getTime() - start.getTime())
+    );
+    return randomDate.toISOString().split("T")[0];
+  }
+  const randomFirstName = firstNames[Math.floor(Math.random() * firstNames.length)];
+  const randomSurname = surnames[Math.floor(Math.random() * surnames.length)];
+  const randomDob = getRandomDate(
+    /* @__PURE__ */ new Date("1990-01-01"),
+    /* @__PURE__ */ new Date("2010-12-31")
+  );
+  return {
+    "recommender.none": true,
+    "applicant.firstname": randomFirstName,
+    "applicant.surname": randomSurname,
+    "applicant.dob": randomDob
+  };
+}
 var eventQueryDataGenerator = (overrides = {}) => ({
   id: overrides.id ?? getUUID(),
-  type: overrides.type ?? "tennis-club-membership",
-  status: overrides.status ?? "REGISTERED",
+  type: overrides.type ?? "TENNIS_CLUB_MEMBERSHIP",
+  status: overrides.status ?? getEventStatus(),
   createdAt: overrides.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
   createdBy: overrides.createdBy ?? getUUID(),
   createdAtLocation: overrides.createdAtLocation ?? getUUID(),
@@ -4440,13 +4751,10 @@ var eventQueryDataGenerator = (overrides = {}) => ({
   assignedTo: overrides.assignedTo ?? null,
   updatedBy: overrides.updatedBy ?? getUUID(),
   updatedByUserRole: overrides.updatedByUserRole ?? "FIELD_AGENT",
-  declaration: overrides.declaration ?? {
-    "recommender.none": true,
-    "applicant.firstname": "Danny",
-    "applicant.surname": "Doe",
-    "applicant.dob": "1999-11-11"
-  },
-  trackingId: overrides.trackingId ?? "M3F8YQ"
+  flags: [],
+  legalStatuses: overrides.legalStatuses ?? {},
+  declaration: overrides.declaration ?? getRandomApplicant(),
+  trackingId: overrides.trackingId ?? getTrackingId()
 });
 var generateTranslationConfig = (message) => ({
   defaultMessage: message,
@@ -4679,19 +4987,3 @@ function filterUnallowedActions(actions, userScopes) {
   }
   return [ActionType.READ];
 }
-
-// ../commons/src/event-config/event-configuration.ts
-function createEventFieldConfig(fieldId, options) {
-  return {
-    fieldId,
-    options,
-    config: { type: "EXACT" },
-    fieldType: "event"
-  };
-}
-
-// ../commons/src/events/event.ts
-function eventFn(fieldId, options) {
-  return createEventFieldConfig(fieldId, options);
-}
-var event = Object.assign(eventFn, createEventConditionals());