@opencrvs/toolkit 1.8.0-rc.ffe24c3 → 1.8.1-rc.1e3e9b5

package/dist/events/index.js

@@ -106,6 +106,8 @@ __export(events_exports, {
   Exact: () => Exact,
   ExactDate: () => ExactDate,
   ExactStatus: () => ExactStatus,
+  ExactUserType: () => ExactUserType,
+  ExclusiveActions: () => ExclusiveActions,
   FieldConditional: () => FieldConditional,
   FieldConfig: () => FieldConfig,
   FieldConfigSchema: () => FieldConfigSchema,
@@ -141,7 +143,6 @@ __export(events_exports, {
   QueryInput: () => QueryInput,
   QueryType: () => QueryType,
   Range: () => Range,
-  RangeDate: () => RangeDate,
   ReadActionInput: () => ReadActionInput,
   RegisterAction: () => RegisterAction,
   RegisterActionInput: () => RegisterActionInput,
@@ -155,14 +156,19 @@ __export(events_exports, {
   RuralAddressValue: () => RuralAddressValue,
   SearchField: () => SearchField,
   SearchQueryParams: () => SearchQueryParams,
+  SearchScopeAccessLevels: () => SearchScopeAccessLevels,
+  SelectDateRangeField: () => SelectDateRangeField,
+  SelectDateRangeOption: () => SelectDateRangeOption,
+  SelectDateRangeValue: () => SelectDateRangeValue,
   SelectOption: () => SelectOption,
   ShowConditional: () => ShowConditional,
   SignatureFieldValue: () => SignatureFieldValue,
-  StatusChangingActions: () => StatusChangingActions,
   SummaryConfig: () => SummaryConfig,
   TENNIS_CLUB_MEMBERSHIP: () => TENNIS_CLUB_MEMBERSHIP,
+  TEST_SYSTEM_IANA_TIMEZONE: () => TEST_SYSTEM_IANA_TIMEZONE,
   TestUserRole: () => TestUserRole,
   TextValue: () => TextValue,
+  TimeValue: () => TimeValue,
   TranslationConfig: () => TranslationConfig,
   UnassignActionInput: () => UnassignActionInput,
   UrbanAddressUpdateValue: () => UrbanAddressUpdateValue,
@@ -172,6 +178,7 @@ __export(events_exports, {
   ValidationConfig: () => ValidationConfig,
   VerificationActionConfig: () => VerificationActionConfig,
   VerificationPageConfig: () => VerificationPageConfig,
+  VisibleStatus: () => VisibleStatus,
   WRITE_ACTION_SCOPES: () => WRITE_ACTION_SCOPES,
   Within: () => Within,
   WorkqueueActionsWithDefault: () => WorkqueueActionsWithDefault,
@@ -188,11 +195,11 @@ __export(events_exports, {
   alwaysTrue: () => alwaysTrue,
   and: () => and,
   annotationActions: () => annotationActions,
+  applyDeclarationToEventIndex: () => applyDeclarationToEventIndex,
   applyDraftsToEventIndex: () => applyDraftsToEventIndex,
   areConditionsMet: () => areConditionsMet,
   compositeFieldTypes: () => compositeFieldTypes,
   createEmptyDraft: () => createEmptyDraft,
-  createEventConditionals: () => createEventConditionals,
   createFieldConditionals: () => createFieldConditionals,
   createPrng: () => createPrng,
   createValidationSchema: () => createValidationSchema,
@@ -243,6 +250,7 @@ __export(events_exports, {
   getAnnotationFromDrafts: () => getAnnotationFromDrafts,
   getAssignedUserFromActions: () => getAssignedUserFromActions,
   getAssignedUserSignatureFromActions: () => getAssignedUserSignatureFromActions,
+  getAvailableActionsForEvent: () => getAvailableActionsForEvent,
   getCurrentEventState: () => getCurrentEventState,
   getCurrentEventStateWithDrafts: () => getCurrentEventStateWithDrafts,
   getDeclaration: () => getDeclaration,
@@ -251,6 +259,7 @@ __export(events_exports, {
   getDeclarationPages: () => getDeclarationPages,
   getEventConfigById: () => getEventConfigById,
   getMixedPath: () => getMixedPath,
+  getPrintCertificatePages: () => getPrintCertificatePages,
   getRandomDate: () => getRandomDate,
   getRandomDatetime: () => getRandomDatetime,
   getStatusFromActions: () => getStatusFromActions,
@@ -289,11 +298,13 @@ __export(events_exports, {
   isParagraphFieldType: () => isParagraphFieldType,
   isPhoneFieldType: () => isPhoneFieldType,
   isRadioGroupFieldType: () => isRadioGroupFieldType,
+  isSelectDateRangeFieldType: () => isSelectDateRangeFieldType,
   isSelectFieldType: () => isSelectFieldType,
   isSignatureFieldType: () => isSignatureFieldType,
   isTemplateVariable: () => isTemplateVariable,
   isTextAreaFieldType: () => isTextAreaFieldType,
   isTextFieldType: () => isTextFieldType,
+  isTimeFieldType: () => isTimeFieldType,
   isUndeclaredDraft: () => isUndeclaredDraft,
   isVerificationPage: () => isVerificationPage,
   isWriteAction: () => isWriteAction,
@@ -307,7 +318,9 @@ __export(events_exports, {
   omitHiddenFields: () => omitHiddenFields,
   omitHiddenPaginatedFields: () => omitHiddenPaginatedFields,
   or: () => or,
+  resolveDateOfEvent: () => resolveDateOfEvent,
   runFieldValidations: () => runFieldValidations,
+  timePeriodToDateRange: () => timePeriodToDateRange,
   user: () => user,
   validate: () => validate,
   validateFieldInput: () => validateFieldInput,
@@ -321,7 +334,7 @@ var TENNIS_CLUB_MEMBERSHIP = "tennis-club-membership";
 var BIRTH_EVENT = "v2-birth";
 
 // ../commons/src/events/ActionConfig.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // ../commons/src/events/Conditional.ts
 var import_zod = require("zod");
@@ -372,12 +385,6 @@ var FieldConditional = import_zod.z.discriminatedUnion("type", [
   ref: "FieldConditional"
 });
 
-// ../commons/src/events/PageConfig.ts
-var import_zod6 = require("zod");
-
-// ../commons/src/events/FieldConfig.ts
-var import_zod5 = require("zod");
-
 // ../commons/src/events/TranslationConfig.ts
 var import_zod2 = require("zod");
 var import_zod_openapi2 = require("zod-openapi");
@@ -395,6 +402,110 @@ var TranslationConfig = import_zod2.z.object({
   ref: "TranslationConfig"
 });
 
+// ../commons/src/events/ActionType.ts
+var import_zod3 = require("zod");
+var ActionType = {
+  // Pre-declaration actions
+  DELETE: "DELETE",
+  CREATE: "CREATE",
+  NOTIFY: "NOTIFY",
+  // Declaration actions
+  DECLARE: "DECLARE",
+  VALIDATE: "VALIDATE",
+  REGISTER: "REGISTER",
+  // Declaration system actions. Non-configurable.
+  DETECT_DUPLICATE: "DETECT_DUPLICATE",
+  REJECT: "REJECT",
+  // REJECT_DECLARATION
+  MARKED_AS_DUPLICATE: "MARKED_AS_DUPLICATE",
+  // 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,
+  ActionType.REQUEST_CORRECTION,
+  ActionType.APPROVE_CORRECTION,
+  ActionType.REJECT_CORRECTION
+];
+var ActionTypes = import_zod3.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 ExclusiveActions = {
+  REVIEW_CORRECTION_REQUEST: "REVIEW_CORRECTION_REQUEST"
+};
+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);
+var writeActions = ActionTypes.exclude([
+  ActionType.CREATE,
+  ActionType.READ,
+  ActionType.ASSIGN,
+  ActionType.UNASSIGN
+]);
+var workqueueActions = ActionTypes.exclude([
+  ActionType.CREATE,
+  ActionType.NOTIFY,
+  ActionType.DETECT_DUPLICATE,
+  ActionType.REJECT,
+  ActionType.MARKED_AS_DUPLICATE,
+  ActionType.ARCHIVE,
+  ActionType.REJECT_CORRECTION,
+  ActionType.APPROVE_CORRECTION
+]);
+var META_ACTIONS = [
+  ActionType.ASSIGN,
+  ActionType.UNASSIGN,
+  ActionType.READ
+];
+function isMetaAction(actionType) {
+  return META_ACTIONS.includes(actionType);
+}
+
+// ../commons/src/events/FieldConfig.ts
+var import_zod7 = require("zod");
+
 // ../commons/src/events/FieldType.ts
 var FieldType = {
   NAME: "NAME",
@@ -407,6 +518,10 @@ var FieldType = {
   EMAIL: "EMAIL",
   DATE: "DATE",
   DATE_RANGE: "DATE_RANGE",
+  // // Internal use, only for search functionality
+  SELECT_DATE_RANGE: "SELECT_DATE_RANGE",
+  // Internal use, only for search functionality
+  TIME: "TIME",
   PARAGRAPH: "PARAGRAPH",
   PAGE_HEADER: "PAGE_HEADER",
   RADIO_GROUP: "RADIO_GROUP",
@@ -433,10 +548,24 @@ var compositeFieldTypes = [
 ];
 
 // ../commons/src/events/FieldValue.ts
+var import_zod6 = require("zod");
+
+// ../commons/src/documents.ts
 var import_zod4 = require("zod");
+var import_zod_openapi3 = require("zod-openapi");
+(0, import_zod_openapi3.extendZodWithOpenApi)(import_zod4.z);
+var FullDocumentURL = import_zod4.z.string().brand("FullDocumentURL").describe(
+  "A full url with protocol, host, bucket name, starting from the root of the S3 server, https://minio/bucket-name/document-id.jpg"
+);
+var FullDocumentPath = import_zod4.z.string().transform((val) => val.startsWith("/") ? val : `/${val}`).openapi({ effectType: "input", type: "string" }).describe(
+  "A full absolute path with bucket name, starting from the root of the S3 server, /bucket-name/document-id.jpg"
+);
+var DocumentPath = import_zod4.z.string().brand("DocumentPath").describe(
+  "A full identifier starting from the root of the S3 bucket, e.g. /document-id.jpg or /directory/document-id.jpg but never /bucket-name/document-id.jpg"
+);
 
 // ../commons/src/events/CompositeFieldValue.ts
-var import_zod3 = require("zod");
+var import_zod5 = require("zod");
 var GeographicalArea = {
   URBAN: "URBAN",
   RURAL: "RURAL"
@@ -445,101 +574,115 @@ var AddressType = {
   DOMESTIC: "DOMESTIC",
   INTERNATIONAL: "INTERNATIONAL"
 };
-var FileFieldValue = import_zod3.z.object({
-  filename: import_zod3.z.string(),
-  originalFilename: import_zod3.z.string(),
-  type: import_zod3.z.string()
+var FileFieldValue = import_zod5.z.object({
+  path: FullDocumentPath,
+  originalFilename: import_zod5.z.string(),
+  type: import_zod5.z.string()
 });
-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()
+var AdminStructure = import_zod5.z.object({
+  country: import_zod5.z.string(),
+  addressType: import_zod5.z.literal(AddressType.DOMESTIC),
+  province: import_zod5.z.string(),
+  district: import_zod5.z.string()
 });
 var UrbanAddressValue = AdminStructure.extend({
-  urbanOrRural: import_zod3.z.literal(GeographicalArea.URBAN),
-  town: import_zod3.z.string().optional(),
-  residentialArea: import_zod3.z.string().optional(),
-  street: import_zod3.z.string().optional(),
-  number: import_zod3.z.string().optional(),
-  zipCode: import_zod3.z.string().optional()
+  urbanOrRural: import_zod5.z.literal(GeographicalArea.URBAN),
+  town: import_zod5.z.string().optional(),
+  residentialArea: import_zod5.z.string().optional(),
+  street: import_zod5.z.string().optional(),
+  number: import_zod5.z.string().optional(),
+  zipCode: import_zod5.z.string().optional()
 });
 var RuralAddressValue = AdminStructure.extend({
-  urbanOrRural: import_zod3.z.literal(GeographicalArea.RURAL),
-  village: import_zod3.z.string().optional()
+  urbanOrRural: import_zod5.z.literal(GeographicalArea.RURAL),
+  village: import_zod5.z.string().optional()
 });
 var UrbanAddressUpdateValue = AdminStructure.extend({
-  urbanOrRural: import_zod3.z.literal(GeographicalArea.URBAN),
-  town: import_zod3.z.string().nullish(),
-  residentialArea: import_zod3.z.string().nullish(),
-  street: import_zod3.z.string().nullish(),
-  number: import_zod3.z.string().nullish(),
-  zipCode: import_zod3.z.string().nullish()
+  urbanOrRural: import_zod5.z.literal(GeographicalArea.URBAN),
+  town: import_zod5.z.string().nullish(),
+  residentialArea: import_zod5.z.string().nullish(),
+  street: import_zod5.z.string().nullish(),
+  number: import_zod5.z.string().nullish(),
+  zipCode: import_zod5.z.string().nullish()
 });
-var NameFieldValue = import_zod3.z.object({
-  firstname: import_zod3.z.string(),
-  surname: import_zod3.z.string(),
-  middlename: import_zod3.z.string().optional()
+var NameFieldValue = import_zod5.z.object({
+  firstname: import_zod5.z.string(),
+  surname: import_zod5.z.string(),
+  middlename: import_zod5.z.string().optional()
 });
-var NameFieldUpdateValue = import_zod3.z.object({
-  firstname: import_zod3.z.string(),
-  surname: import_zod3.z.string(),
-  middlename: import_zod3.z.string().nullish()
-}).or(import_zod3.z.null()).or(import_zod3.z.undefined());
+var NameFieldUpdateValue = import_zod5.z.object({
+  firstname: import_zod5.z.string().nullish(),
+  surname: import_zod5.z.string().nullish(),
+  middlename: import_zod5.z.string().nullish()
+}).or(import_zod5.z.null()).or(import_zod5.z.undefined());
 var RuralAddressUpdateValue = AdminStructure.extend({
-  urbanOrRural: import_zod3.z.literal(GeographicalArea.RURAL),
-  village: import_zod3.z.string().nullish()
+  urbanOrRural: import_zod5.z.literal(GeographicalArea.RURAL),
+  village: import_zod5.z.string().nullish()
 });
-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 GenericAddressValue = import_zod5.z.object({
+  country: import_zod5.z.string(),
+  addressType: import_zod5.z.literal(AddressType.INTERNATIONAL),
+  state: import_zod5.z.string(),
+  district2: import_zod5.z.string(),
+  cityOrTown: import_zod5.z.string().optional(),
+  addressLine1: import_zod5.z.string().optional(),
+  addressLine2: import_zod5.z.string().optional(),
+  addressLine3: import_zod5.z.string().optional(),
+  postcodeOrZip: import_zod5.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 AddressFieldValue = import_zod5.z.discriminatedUnion("urbanOrRural", [UrbanAddressValue, RuralAddressValue]).or(GenericAddressValue);
+var GenericAddressUpdateValue = import_zod5.z.object({
+  country: import_zod5.z.string(),
+  addressType: import_zod5.z.literal(AddressType.INTERNATIONAL),
+  state: import_zod5.z.string(),
+  district2: import_zod5.z.string(),
+  cityOrTown: import_zod5.z.string().nullish(),
+  addressLine1: import_zod5.z.string().nullish(),
+  addressLine2: import_zod5.z.string().nullish(),
+  addressLine3: import_zod5.z.string().nullish(),
+  postcodeOrZip: import_zod5.z.string().nullish()
 });
-var AddressFieldUpdateValue = import_zod3.z.discriminatedUnion("urbanOrRural", [
+var AddressFieldUpdateValue = import_zod5.z.discriminatedUnion("urbanOrRural", [
   UrbanAddressUpdateValue,
   RuralAddressUpdateValue
 ]).or(GenericAddressUpdateValue);
-var FileFieldValueWithOption = import_zod3.z.object({
-  filename: import_zod3.z.string(),
-  originalFilename: import_zod3.z.string(),
-  type: import_zod3.z.string(),
-  option: import_zod3.z.string()
+var FileFieldValueWithOption = import_zod5.z.object({
+  path: FullDocumentPath,
+  originalFilename: import_zod5.z.string(),
+  type: import_zod5.z.string(),
+  option: import_zod5.z.string()
 });
-var FileFieldWithOptionValue = import_zod3.z.array(FileFieldValueWithOption);
+var FileFieldWithOptionValue = import_zod5.z.array(FileFieldValueWithOption);
 
 // ../commons/src/events/FieldValue.ts
-var TextValue = import_zod4.z.string();
+var TextValue = import_zod6.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();
-var DataFieldValue = import_zod4.z.undefined();
-var SignatureFieldValue = import_zod4.z.string();
-var FieldValue = import_zod4.z.union([
+var DateValue = import_zod6.z.string().date().describe("Date in the format YYYY-MM-DD");
+var TimeValue = import_zod6.z.string().regex(/^([01][0-9]|2[0-3]):[0-5][0-9]$/);
+var DatetimeValue = import_zod6.z.string().datetime();
+var SelectDateRangeValue = import_zod6.z.enum([
+  "last7Days",
+  "last30Days",
+  "last90Days",
+  "last365Days"
+]);
+var DateRangeFieldValue = import_zod6.z.object({
+  start: DateValue,
+  end: DateValue
+}).or(DateValue).describe(
+  "Date range with start and end dates in the format YYYY-MM-DD. Inclusive start, exclusive end."
+);
+var EmailValue = import_zod6.z.string().email();
+var CheckboxFieldValue = import_zod6.z.boolean();
+var NumberFieldValue = import_zod6.z.number();
+var DataFieldValue = import_zod6.z.undefined();
+var SignatureFieldValue = import_zod6.z.string();
+var FieldValue = import_zod6.z.union([
   TextValue,
   DateValue,
+  TimeValue,
   DateRangeFieldValue,
+  SelectDateRangeValue,
   CheckboxFieldValue,
   NumberFieldValue,
   FileFieldValue,
@@ -551,10 +694,12 @@ var FieldValue = import_zod4.z.union([
   NameFieldValue,
   NameFieldUpdateValue
 ]);
-var FieldUpdateValue = import_zod4.z.union([
+var FieldUpdateValue = import_zod6.z.union([
   TextValue,
   DateValue,
+  TimeValue,
   DateRangeFieldValue,
+  SelectDateRangeValue,
   CheckboxFieldValue,
   NumberFieldValue,
   FileFieldValue,
@@ -567,63 +712,68 @@ var FieldUpdateValue = import_zod4.z.union([
 ]);
 
 // ../commons/src/events/FieldConfig.ts
-var import_zod_openapi3 = require("zod-openapi");
-(0, import_zod_openapi3.extendZodWithOpenApi)(import_zod5.z);
-var FieldId = import_zod5.z.string().describe("Unique identifier for the field");
-var FieldReference = import_zod5.z.object({
+var import_zod_openapi4 = require("zod-openapi");
+(0, import_zod_openapi4.extendZodWithOpenApi)(import_zod7.z);
+var FieldId = import_zod7.z.string().describe("Unique identifier for the field");
+var FieldReference = import_zod7.z.object({
   $$field: FieldId
 }).describe("Reference to a field by its ID");
-var ParentReference = FieldReference.optional();
-var ValidationConfig = import_zod5.z.object({
+var ValidationConfig = import_zod7.z.object({
   validator: Conditional,
   message: TranslationConfig
 });
-var BaseField = import_zod5.z.object({
+var BaseField = import_zod7.z.object({
   id: FieldId,
-  parent: ParentReference,
-  conditionals: import_zod5.z.array(FieldConditional).default([]).optional(),
-  required: import_zod5.z.boolean().default(false).optional(),
-  placeholder: TranslationConfig.optional(),
-  validation: import_zod5.z.array(ValidationConfig).default([]).optional(),
   label: TranslationConfig,
+  parent: FieldReference.optional().describe(
+    "Reference to a parent field. If a field has a parent, it will be reset when the parent field is changed."
+  ),
+  required: import_zod7.z.boolean().default(false).optional(),
+  conditionals: import_zod7.z.array(FieldConditional).default([]).optional(),
+  secured: import_zod7.z.boolean().default(false).optional(),
+  placeholder: TranslationConfig.optional(),
+  validation: import_zod7.z.array(ValidationConfig).default([]).optional(),
   helperText: TranslationConfig.optional(),
-  hideLabel: import_zod5.z.boolean().default(false).optional()
+  hideLabel: import_zod7.z.boolean().default(false).optional(),
+  uncorrectable: import_zod7.z.boolean().default(false).optional().describe(
+    "Indicates if the field can be changed during a record correction."
+  )
 });
 var Divider = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.DIVIDER)
+  type: import_zod7.z.literal(FieldType.DIVIDER)
 });
 var TextField = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.TEXT),
+  type: import_zod7.z.literal(FieldType.TEXT),
   defaultValue: NonEmptyTextValue.optional(),
-  configuration: import_zod5.z.object({
-    maxLength: import_zod5.z.number().optional().describe("Maximum length of the text"),
-    type: import_zod5.z.enum(["text", "password"]).optional(),
+  configuration: import_zod7.z.object({
+    maxLength: import_zod7.z.number().optional().describe("Maximum length of the text"),
+    type: import_zod7.z.enum(["text", "password"]).optional(),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).default({ type: "text" }).optional()
 }).describe("Text input");
 var NumberField = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.NUMBER),
+  type: import_zod7.z.literal(FieldType.NUMBER),
   defaultValue: NumberFieldValue.optional(),
-  configuration: import_zod5.z.object({
-    min: import_zod5.z.number().optional().describe("Minimum value"),
-    max: import_zod5.z.number().optional().describe("Maximum value"),
+  configuration: import_zod7.z.object({
+    min: import_zod7.z.number().optional().describe("Minimum value"),
+    max: import_zod7.z.number().optional().describe("Maximum value"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).optional()
 }).describe("Number input");
 var TextAreaField = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.TEXTAREA),
+  type: import_zod7.z.literal(FieldType.TEXTAREA),
   defaultValue: NonEmptyTextValue.optional(),
-  configuration: import_zod5.z.object({
-    maxLength: import_zod5.z.number().optional().describe("Maximum length of the text"),
-    rows: import_zod5.z.number().optional().describe("Number of visible text lines"),
-    cols: import_zod5.z.number().optional().describe("Number of visible columns"),
+  configuration: import_zod7.z.object({
+    maxLength: import_zod7.z.number().optional().describe("Maximum length of the text"),
+    rows: import_zod7.z.number().optional().describe("Number of visible text lines"),
+    cols: import_zod7.z.number().optional().describe("Number of visible columns"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).default({ rows: 4 }).optional()
 }).describe("Multiline text input");
-var ImageMimeType = import_zod5.z.enum([
+var ImageMimeType = import_zod7.z.enum([
   "image/png",
   "image/jpg",
   "image/jpeg",
@@ -632,46 +782,53 @@ var ImageMimeType = import_zod5.z.enum([
 var MimeType = ImageMimeType;
 var DEFAULT_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
 var SignatureField = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.SIGNATURE),
+  type: import_zod7.z.literal(FieldType.SIGNATURE),
   signaturePromptLabel: TranslationConfig.describe(
     "Title of the signature modal"
   ),
   defaultValue: SignatureFieldValue.optional(),
-  configuration: import_zod5.z.object({
-    maxFileSize: import_zod5.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+  configuration: import_zod7.z.object({
+    maxFileSize: import_zod7.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),
-  configuration: import_zod5.z.object({
-    maxLength: import_zod5.z.number().optional().describe("Maximum length of the text")
+  type: import_zod7.z.literal(FieldType.EMAIL),
+  configuration: import_zod7.z.object({
+    maxLength: import_zod7.z.number().optional().describe("Maximum length of the text")
   }).default({ maxLength: 10 }).optional(),
   defaultValue: NonEmptyTextValue.optional()
 });
 var DateField = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.DATE),
+  type: import_zod7.z.literal(FieldType.DATE),
   defaultValue: DateValue.optional(),
-  configuration: import_zod5.z.object({
+  configuration: import_zod7.z.object({
     notice: TranslationConfig.describe(
       "Text to display above the date input"
     ).optional()
   }).optional()
-}).describe("A single date input (dd-mm-YYYY)");
+}).describe("A single date input (yyyy-MM-dd)");
+var TimeField = BaseField.extend({
+  type: import_zod7.z.literal(FieldType.TIME),
+  defaultValue: TimeValue.optional(),
+  configuration: import_zod7.z.object({
+    notice: TranslationConfig.describe(
+      "Text to display above the time input"
+    ).optional()
+  }).optional()
+}).describe("A single date input (HH-mm)");
 var DateRangeField = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.DATE_RANGE),
+  type: import_zod7.z.literal(FieldType.DATE_RANGE),
   defaultValue: DateRangeFieldValue.optional(),
-  configuration: import_zod5.z.object({
+  configuration: import_zod7.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([
+}).describe("A date range input ({ start: yyyy-MM-dd, end: yyyy-MM-dd })");
+var HtmlFontVariant = import_zod7.z.enum([
   "reg12",
   "reg14",
   "reg16",
@@ -681,27 +838,31 @@ var HtmlFontVariant = import_zod5.z.enum([
   "h2",
   "h1"
 ]);
+var ParagraphConfiguration = import_zod7.z.object({
+  styles: import_zod7.z.object({
+    fontVariant: HtmlFontVariant.optional().describe(
+      "Font variant to use for the paragraph text"
+    ),
+    hint: import_zod7.z.boolean().optional().describe("When true, paragraph is styled as a hint with grey color")
+  }).optional()
+}).default({});
 var Paragraph = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.PARAGRAPH),
+  type: import_zod7.z.literal(FieldType.PARAGRAPH),
   defaultValue: NonEmptyTextValue.optional(),
-  configuration: import_zod5.z.object({
-    styles: import_zod5.z.object({
-      fontVariant: HtmlFontVariant.optional()
-    }).optional()
-  }).default({})
+  configuration: ParagraphConfiguration
 }).describe("A read-only HTML <p> paragraph");
 var PageHeader = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.PAGE_HEADER),
+  type: import_zod7.z.literal(FieldType.PAGE_HEADER),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("A read-only header component for form pages");
 var File = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.FILE),
+  type: import_zod7.z.literal(FieldType.FILE),
   defaultValue: FileFieldValue.optional(),
-  configuration: import_zod5.z.object({
-    maxFileSize: import_zod5.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+  configuration: import_zod7.z.object({
+    maxFileSize: import_zod7.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({
-      width: import_zod5.z.enum(["full", "auto"]).optional().describe(
+    style: import_zod7.z.object({
+      width: import_zod7.z.enum(["full", "auto"]).optional().describe(
         "Whether the file upload button should take the full width of the container or not"
       )
     }).optional(),
@@ -710,129 +871,148 @@ var File = BaseField.extend({
     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"),
+var SelectOption = import_zod7.z.object({
+  value: import_zod7.z.string().describe("The value of the option"),
   label: TranslationConfig.describe("The label of the option")
 });
 var RadioGroup = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.RADIO_GROUP),
+  type: import_zod7.z.literal(FieldType.RADIO_GROUP),
   defaultValue: TextValue.optional(),
-  options: import_zod5.z.array(SelectOption).describe("A list of options"),
-  configuration: import_zod5.z.object({
-    styles: import_zod5.z.object({
-      size: import_zod5.z.enum(["NORMAL", "LARGE"]).optional()
+  options: import_zod7.z.array(SelectOption).describe("A list of options"),
+  configuration: import_zod7.z.object({
+    styles: import_zod7.z.object({
+      size: import_zod7.z.enum(["NORMAL", "LARGE"]).optional()
     }).optional()
   }).optional()
 }).describe("Grouped radio options");
 var BulletList = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.BULLET_LIST),
+  type: import_zod7.z.literal(FieldType.BULLET_LIST),
   defaultValue: TextValue.optional(),
-  items: import_zod5.z.array(TranslationConfig).describe("A list of items"),
-  configuration: import_zod5.z.object({
-    styles: import_zod5.z.object({
+  items: import_zod7.z.array(TranslationConfig).describe("A list of items"),
+  configuration: import_zod7.z.object({
+    styles: import_zod7.z.object({
       fontVariant: HtmlFontVariant.optional()
     }).optional()
   }).default({})
 }).describe("A list of bullet points");
 var Select = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.SELECT),
+  type: import_zod7.z.literal(FieldType.SELECT),
   defaultValue: TextValue.optional(),
-  options: import_zod5.z.array(SelectOption).describe("A list of options")
+  options: import_zod7.z.array(SelectOption).describe("A list of options")
 }).describe("Select input");
+var SelectDateRangeOption = import_zod7.z.object({
+  value: SelectDateRangeValue.describe("The value of the option"),
+  label: TranslationConfig.describe("The label of the option")
+});
+var SelectDateRangeField = BaseField.extend({
+  type: import_zod7.z.literal(FieldType.SELECT_DATE_RANGE),
+  defaultValue: SelectDateRangeValue.optional(),
+  options: import_zod7.z.array(SelectDateRangeOption).describe("A list of options")
+}).describe("Select input with date range options");
 var NameField = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.NAME),
-  defaultValue: import_zod5.z.object({
+  type: import_zod7.z.literal(FieldType.NAME),
+  defaultValue: import_zod7.z.object({
     firstname: NonEmptyTextValue,
     surname: NonEmptyTextValue
   }).optional(),
-  configuration: import_zod5.z.object({
-    maxLength: import_zod5.z.number().optional().describe("Maximum length of the text"),
+  configuration: import_zod7.z.object({
+    maxLength: import_zod7.z.number().optional().describe("Maximum length of the text"),
     prefix: TranslationConfig.optional(),
-    postfix: TranslationConfig.optional()
+    postfix: TranslationConfig.optional(),
+    includeMiddlename: import_zod7.z.boolean().default(false).optional().describe("To make middle name visible in Name form field"),
+    searchMode: import_zod7.z.boolean().optional()
   }).optional()
 }).describe("Name input field");
 var PhoneField = BaseField.extend({
   defaultValue: NonEmptyTextValue.optional(),
-  type: import_zod5.z.literal(FieldType.PHONE)
+  type: import_zod7.z.literal(FieldType.PHONE)
 }).describe("Phone input field");
 var IdField = BaseField.extend({
   defaultValue: NonEmptyTextValue.optional(),
-  type: import_zod5.z.literal(FieldType.ID)
+  type: import_zod7.z.literal(FieldType.ID)
 }).describe("ID input field");
 var Checkbox = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.CHECKBOX),
+  type: import_zod7.z.literal(FieldType.CHECKBOX),
   defaultValue: CheckboxFieldValue.optional()
 }).describe("Boolean checkbox field");
 var Country = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.COUNTRY),
+  type: import_zod7.z.literal(FieldType.COUNTRY),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("Country select field");
-var AdministrativeAreas = import_zod5.z.enum([
+var AdministrativeAreas = import_zod7.z.enum([
   "ADMIN_STRUCTURE",
   "HEALTH_FACILITY",
   "CRVS_OFFICE"
 ]);
-var AdministrativeAreaConfiguration = import_zod5.z.object({
-  partOf: import_zod5.z.object({
-    $declaration: import_zod5.z.string()
+var AdministrativeAreaConfiguration = import_zod7.z.object({
+  partOf: import_zod7.z.object({
+    $declaration: import_zod7.z.string()
   }).optional().describe("Parent location"),
   type: AdministrativeAreas
 }).describe("Administrative area options");
 var AdministrativeArea = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.ADMINISTRATIVE_AREA),
+  type: import_zod7.z.literal(FieldType.ADMINISTRATIVE_AREA),
   defaultValue: NonEmptyTextValue.optional(),
   configuration: AdministrativeAreaConfiguration
 }).describe("Administrative area input field e.g. facility, office");
 var Location = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.LOCATION),
-  defaultValue: NonEmptyTextValue.optional()
+  type: import_zod7.z.literal(FieldType.LOCATION),
+  defaultValue: NonEmptyTextValue.optional(),
+  configuration: import_zod7.z.object({
+    searchableResource: import_zod7.z.array(import_zod7.z.enum(["locations", "facilities", "offices"])).optional()
+  }).optional()
 }).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"),
+  type: import_zod7.z.literal(FieldType.FILE_WITH_OPTIONS),
+  options: import_zod7.z.array(SelectOption).describe("A list of options"),
   defaultValue: FileFieldWithOptionValue.optional(),
-  configuration: import_zod5.z.object({
-    maxFileSize: import_zod5.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+  configuration: import_zod7.z.object({
+    maxFileSize: import_zod7.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),
+  type: import_zod7.z.literal(FieldType.FACILITY),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("Input field for a facility");
 var Office = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.OFFICE),
+  type: import_zod7.z.literal(FieldType.OFFICE),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("Input field for an office");
 var Address = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.ADDRESS),
-  defaultValue: AddressFieldValue.optional()
+  type: import_zod7.z.literal(FieldType.ADDRESS),
+  defaultValue: AddressFieldValue.optional(),
+  configuration: import_zod7.z.object({
+    searchMode: import_zod7.z.boolean().optional()
+  }).optional()
 }).describe("Address input field \u2013 a combination of location and text fields");
-var DataEntry = import_zod5.z.union([
-  import_zod5.z.object({
+var DataEntry = import_zod7.z.union([
+  import_zod7.z.object({
     label: TranslationConfig,
-    value: TranslationConfig.or(import_zod5.z.string())
+    value: TranslationConfig.or(import_zod7.z.string())
   }),
-  import_zod5.z.object({
-    fieldId: import_zod5.z.string()
+  import_zod7.z.object({
+    fieldId: import_zod7.z.string()
   })
 ]);
 var DataField = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.DATA),
-  configuration: import_zod5.z.object({
+  type: import_zod7.z.literal(FieldType.DATA),
+  configuration: import_zod7.z.object({
     subtitle: TranslationConfig.optional(),
-    data: import_zod5.z.array(DataEntry)
+    data: import_zod7.z.array(DataEntry)
   })
 }).describe("Data field for displaying read-only data");
-var FieldConfig = import_zod5.z.discriminatedUnion("type", [
+var FieldConfig = import_zod7.z.discriminatedUnion("type", [
   Address,
   TextField,
   NumberField,
   TextAreaField,
   DateField,
+  TimeField,
   DateRangeField,
+  SelectDateRangeField,
   Paragraph,
   RadioGroup,
   BulletList,
@@ -858,14 +1038,18 @@ var FieldConfig = import_zod5.z.discriminatedUnion("type", [
   ref: "FieldConfig"
 });
 
+// ../commons/src/events/FormConfig.ts
+var import_zod9 = require("zod");
+
 // ../commons/src/events/PageConfig.ts
-var import_zod_openapi4 = require("zod-openapi");
-(0, import_zod_openapi4.extendZodWithOpenApi)(import_zod6.z);
-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"),
+var import_zod8 = require("zod");
+var import_zod_openapi5 = require("zod-openapi");
+(0, import_zod_openapi5.extendZodWithOpenApi)(import_zod8.z);
+var PageTypes = import_zod8.z.enum(["FORM", "VERIFICATION"]);
+var PageConfigBase = import_zod8.z.object({
+  id: import_zod8.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_zod8.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."
   )
@@ -874,13 +1058,13 @@ var PageConfigBase = import_zod6.z.object({
   ref: "FormPageConfig"
 });
 var FormPageConfig = PageConfigBase.extend({
-  type: import_zod6.z.literal(PageTypes.enum.FORM).default(PageTypes.enum.FORM)
+  type: import_zod8.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({
+var VerificationActionConfig = import_zod8.z.object({
+  verify: import_zod8.z.object({ label: TranslationConfig }),
+  cancel: import_zod8.z.object({
     label: TranslationConfig,
-    confirmation: import_zod6.z.object({
+    confirmation: import_zod8.z.object({
       title: TranslationConfig,
       body: TranslationConfig
     })
@@ -890,218 +1074,110 @@ var VerificationActionConfig = import_zod6.z.object({
   ref: "VerificationActionConfig"
 });
 var VerificationPageConfig = FormPageConfig.extend({
-  type: import_zod6.z.literal(PageTypes.enum.VERIFICATION),
+  type: import_zod8.z.literal(PageTypes.enum.VERIFICATION),
   actions: VerificationActionConfig
 });
-var PageConfig = import_zod6.z.discriminatedUnion("type", [
+var PageConfig = import_zod8.z.discriminatedUnion("type", [
   FormPageConfig,
   VerificationPageConfig
 ]);
 
-// ../commons/src/events/ActionType.ts
-var import_zod7 = require("zod");
-var ActionType = {
-  // Pre-declaration actions
-  DELETE: "DELETE",
-  CREATE: "CREATE",
-  NOTIFY: "NOTIFY",
-  // Declaration actions
-  DECLARE: "DECLARE",
-  VALIDATE: "VALIDATE",
-  REGISTER: "REGISTER",
-  // Declaration system actions. Non-configurable.
-  DETECT_DUPLICATE: "DETECT_DUPLICATE",
-  REJECT: "REJECT",
-  // REJECT_DECLARATION
-  MARKED_AS_DUPLICATE: "MARKED_AS_DUPLICATE",
-  // 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);
-var writeActions = ActionTypes.exclude([
-  ActionType.CREATE,
-  ActionType.READ,
-  ActionType.ASSIGN,
-  ActionType.UNASSIGN
-]);
-var StatusChangingActions = ActionTypes.extract([
-  ActionType.CREATE,
-  ActionType.NOTIFY,
-  ActionType.DECLARE,
-  ActionType.VALIDATE,
-  ActionType.REGISTER,
-  ActionType.REJECT,
-  ActionType.ARCHIVE,
-  ActionType.PRINT_CERTIFICATE
-]);
-var workqueueActions = ActionTypes.exclude([
-  ActionType.CREATE,
-  ActionType.NOTIFY,
-  ActionType.DETECT_DUPLICATE,
-  ActionType.REJECT,
-  ActionType.MARKED_AS_DUPLICATE,
-  ActionType.ARCHIVE,
-  ActionType.REQUEST_CORRECTION,
-  ActionType.REJECT_CORRECTION,
-  ActionType.APPROVE_CORRECTION
-]);
-var META_ACTIONS = [
-  ActionType.ASSIGN,
-  ActionType.UNASSIGN,
-  ActionType.READ
-];
-function isMetaAction(actionType) {
-  return META_ACTIONS.includes(actionType);
-}
-
 // ../commons/src/events/FormConfig.ts
-var import_zod8 = require("zod");
-var DeclarationFormConfig = import_zod8.z.object({
+var DeclarationFormConfig = import_zod9.z.object({
   label: TranslationConfig.describe("Human readable description of the form"),
-  pages: import_zod8.z.array(FormPageConfig)
+  pages: import_zod9.z.array(FormPageConfig)
 }).describe("Configuration for a declaration form");
-var ActionFormConfig = import_zod8.z.object({
+var ActionFormConfig = import_zod9.z.object({
   label: TranslationConfig.describe("Human readable description of the form"),
-  pages: import_zod8.z.array(PageConfig)
+  pages: import_zod9.z.array(PageConfig)
 });
-var FormConfig = import_zod8.z.union([DeclarationFormConfig, ActionFormConfig]);
+var FormConfig = import_zod9.z.union([DeclarationFormConfig, ActionFormConfig]);
 
 // ../commons/src/events/ActionConfig.ts
-var import_zod_openapi5 = require("zod-openapi");
-(0, import_zod_openapi5.extendZodWithOpenApi)(import_zod9.z);
-var ActionConditional2 = import_zod9.z.discriminatedUnion("type", [
+var import_zod_openapi6 = require("zod-openapi");
+(0, import_zod_openapi6.extendZodWithOpenApi)(import_zod10.z);
+var ActionConditional2 = import_zod10.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 DeclarationReviewConfig = import_zod9.z.object({
+var DeclarationReviewConfig = import_zod10.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.")
+  fields: import_zod10.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({
+var ActionConfigBase = import_zod10.z.object({
   label: TranslationConfig,
-  conditionals: import_zod9.z.array(ActionConditional2).optional().default([]),
-  draft: import_zod9.z.boolean().optional()
+  conditionals: import_zod10.z.array(ActionConditional2).optional().default([]),
+  draft: import_zod10.z.boolean().optional()
 });
 var ReadActionConfig = ActionConfigBase.merge(
-  import_zod9.z.object({
-    type: import_zod9.z.literal(ActionType.READ),
+  import_zod10.z.object({
+    type: import_zod10.z.literal(ActionType.READ),
     review: DeclarationReviewConfig
   })
 );
 var DeclareConfig = ActionConfigBase.merge(
-  import_zod9.z.object({
-    type: import_zod9.z.literal(ActionType.DECLARE),
+  import_zod10.z.object({
+    type: import_zod10.z.literal(ActionType.DECLARE),
     review: DeclarationReviewConfig
   })
 );
 var ValidateConfig = ActionConfigBase.merge(
-  import_zod9.z.object({
-    type: import_zod9.z.literal(ActionType.VALIDATE),
+  import_zod10.z.object({
+    type: import_zod10.z.literal(ActionType.VALIDATE),
     review: DeclarationReviewConfig
   })
 );
 var RegisterConfig = ActionConfigBase.merge(
-  import_zod9.z.object({
-    type: import_zod9.z.literal(ActionType.REGISTER),
+  import_zod10.z.object({
+    type: import_zod10.z.literal(ActionType.REGISTER),
     review: DeclarationReviewConfig
   })
 );
 var RejectDeclarationConfig = ActionConfigBase.merge(
-  import_zod9.z.object({
-    type: import_zod9.z.literal(ActionType.REJECT)
+  import_zod10.z.object({
+    type: import_zod10.z.literal(ActionType.REJECT)
   })
 );
 var MarkedAsDuplicateConfig = ActionConfigBase.merge(
-  import_zod9.z.object({
-    type: import_zod9.z.literal(ActionType.MARKED_AS_DUPLICATE)
+  import_zod10.z.object({
+    type: import_zod10.z.literal(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveConfig = ActionConfigBase.merge(
-  import_zod9.z.object({
-    type: import_zod9.z.literal(ActionType.ARCHIVE)
+  import_zod10.z.object({
+    type: import_zod10.z.literal(ActionType.ARCHIVE)
   })
 );
 var DeleteConfig = ActionConfigBase.merge(
-  import_zod9.z.object({
-    type: import_zod9.z.literal(ActionType.DELETE)
+  import_zod10.z.object({
+    type: import_zod10.z.literal(ActionType.DELETE)
   })
 );
 var PrintCertificateActionConfig = ActionConfigBase.merge(
-  import_zod9.z.object({
-    type: import_zod9.z.literal(ActionType.PRINT_CERTIFICATE),
+  import_zod10.z.object({
+    type: import_zod10.z.literal(ActionType.PRINT_CERTIFICATE),
     printForm: ActionFormConfig
   })
 );
 var RequestCorrectionConfig = ActionConfigBase.merge(
-  import_zod9.z.object({
-    type: import_zod9.z.literal(ActionType.REQUEST_CORRECTION),
-    onboardingForm: import_zod9.z.array(PageConfig),
-    additionalDetailsForm: import_zod9.z.array(PageConfig)
+  import_zod10.z.object({
+    type: import_zod10.z.literal(ActionType.REQUEST_CORRECTION),
+    correctionForm: ActionFormConfig
   })
 );
 var RejectCorrectionConfig = ActionConfigBase.merge(
-  import_zod9.z.object({
-    type: import_zod9.z.literal(ActionType.REJECT_CORRECTION)
+  import_zod10.z.object({
+    type: import_zod10.z.literal(ActionType.REJECT_CORRECTION)
   })
 );
 var ApproveCorrectionConfig = ActionConfigBase.merge(
-  import_zod9.z.object({
-    type: import_zod9.z.literal(ActionType.APPROVE_CORRECTION)
+  import_zod10.z.object({
+    type: import_zod10.z.literal(ActionType.APPROVE_CORRECTION)
   })
 );
-var ActionConfig = import_zod9.z.discriminatedUnion("type", [
+var ActionConfig = import_zod10.z.discriminatedUnion("type", [
   /*
    * OpenAPI references are defined here so our generated OpenAPI spec knows to reuse the models
    * and treat them as "models" instead of duplicating the data structure in each endpoint.
@@ -1121,108 +1197,108 @@ var ActionConfig = import_zod9.z.discriminatedUnion("type", [
   RejectCorrectionConfig.openapi({ ref: "RejectCorrectionActionConfig" }),
   ApproveCorrectionConfig.openapi({ ref: "ApproveCorrectionActionConfig" })
 ]).openapi({ ref: "ActionConfig" });
-var DeclarationActionConfig = import_zod9.z.discriminatedUnion("type", [
+var DeclarationActionConfig = import_zod10.z.discriminatedUnion("type", [
   DeclareConfig,
   ValidateConfig,
   RegisterConfig
 ]);
 
 // ../commons/src/events/offline/CertificateConfig.ts
-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 import_zod11 = require("zod");
+var FontFamily = import_zod11.z.object({
+  normal: import_zod11.z.string(),
+  bold: import_zod11.z.string(),
+  italics: import_zod11.z.string(),
+  bolditalics: import_zod11.z.string()
 });
-var CertificateConfig = import_zod10.z.object({
-  id: import_zod10.z.string(),
-  event: import_zod10.z.string(),
+var CertificateConfig = import_zod11.z.object({
+  id: import_zod11.z.string(),
+  event: import_zod11.z.string(),
   label: TranslationConfig,
-  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()
+  isDefault: import_zod11.z.boolean(),
+  fee: import_zod11.z.object({
+    onTime: import_zod11.z.number(),
+    late: import_zod11.z.number(),
+    delayed: import_zod11.z.number()
   }),
-  svgUrl: import_zod10.z.string(),
-  fonts: import_zod10.z.record(FontFamily).optional()
+  svgUrl: import_zod11.z.string(),
+  fonts: import_zod11.z.record(FontFamily).optional()
 });
 var CertificateTemplateConfig = CertificateConfig.extend({
-  hash: import_zod10.z.string().optional(),
-  svg: import_zod10.z.string()
+  hash: import_zod11.z.string().optional(),
+  svg: import_zod11.z.string()
 });
 
 // ../commons/src/events/offline/LanguageConfig.ts
-var import_zod11 = require("zod");
-var LanguageConfig = import_zod11.z.object({
-  lang: import_zod11.z.string(),
+var import_zod12 = require("zod");
+var LanguageConfig = import_zod12.z.object({
+  lang: import_zod12.z.string(),
   /**
    * client.csv contents
    */
-  messages: import_zod11.z.record(import_zod11.z.string())
+  messages: import_zod12.z.record(import_zod12.z.string())
 });
 
 // ../commons/src/events/EventConfig.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 
 // ../commons/src/events/DeduplicationConfig.ts
-var import_zod12 = require("zod");
-var import_zod_openapi6 = require("zod-openapi");
-(0, import_zod_openapi6.extendZodWithOpenApi)(import_zod12.z);
-var FieldReference2 = 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()
+var import_zod13 = require("zod");
+var import_zod_openapi7 = require("zod-openapi");
+(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod13.z);
+var FieldReference2 = import_zod13.z.string();
+var Matcher = import_zod13.z.object({
+  fieldId: import_zod13.z.string(),
+  options: import_zod13.z.object({
+    boost: import_zod13.z.number().optional()
   }).optional().default({})
 });
 var FuzzyMatcher = Matcher.extend({
-  type: import_zod12.z.literal("fuzzy"),
-  options: import_zod12.z.object({
+  type: import_zod13.z.literal("fuzzy"),
+  options: import_zod13.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_zod12.z.union([import_zod12.z.string(), import_zod12.z.number()]).optional().default("AUTO:4,7"),
-    boost: import_zod12.z.number().optional().default(1)
+    fuzziness: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).optional().default("AUTO:4,7"),
+    boost: import_zod13.z.number().optional().default(1)
   }).optional().default({})
 });
 var StrictMatcher = Matcher.extend({
-  type: import_zod12.z.literal("strict"),
-  options: import_zod12.z.object({
-    boost: import_zod12.z.number().optional().default(1)
+  type: import_zod13.z.literal("strict"),
+  options: import_zod13.z.object({
+    boost: import_zod13.z.number().optional().default(1)
   }).optional().default({})
 });
 var DateRangeMatcher = Matcher.extend({
-  type: import_zod12.z.literal("dateRange"),
-  options: import_zod12.z.object({
-    days: import_zod12.z.number(),
+  type: import_zod13.z.literal("dateRange"),
+  options: import_zod13.z.object({
+    days: import_zod13.z.number(),
     origin: FieldReference2,
-    boost: import_zod12.z.number().optional().default(1)
+    boost: import_zod13.z.number().optional().default(1)
   })
 });
 var DateDistanceMatcher = Matcher.extend({
-  type: import_zod12.z.literal("dateDistance"),
-  options: import_zod12.z.object({
-    days: import_zod12.z.number(),
+  type: import_zod13.z.literal("dateDistance"),
+  options: import_zod13.z.object({
+    days: import_zod13.z.number(),
     origin: FieldReference2,
-    boost: import_zod12.z.number().optional().default(1)
+    boost: import_zod13.z.number().optional().default(1)
   })
 });
-var And = import_zod12.z.object({
-  type: import_zod12.z.literal("and"),
+var And = import_zod13.z.object({
+  type: import_zod13.z.literal("and"),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clauses: import_zod12.z.lazy(() => Clause.array())
+  clauses: import_zod13.z.lazy(() => Clause.array())
 });
-var Or = import_zod12.z.object({
-  type: import_zod12.z.literal("or"),
+var Or = import_zod13.z.object({
+  type: import_zod13.z.literal("or"),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clauses: import_zod12.z.lazy(() => Clause.array())
+  clauses: import_zod13.z.lazy(() => Clause.array())
 });
-var Clause = import_zod12.z.lazy(
-  () => import_zod12.z.discriminatedUnion("type", [
+var Clause = import_zod13.z.lazy(
+  () => import_zod13.z.discriminatedUnion("type", [
     And,
     Or,
     FuzzyMatcher,
@@ -1233,43 +1309,43 @@ var Clause = import_zod12.z.lazy(
 ).openapi({
   ref: "Clause"
 });
-var DeduplicationConfig = import_zod12.z.object({
-  id: import_zod12.z.string(),
+var DeduplicationConfig = import_zod13.z.object({
+  id: import_zod13.z.string(),
   label: TranslationConfig,
   query: Clause
 });
 
 // ../commons/src/events/SummaryConfig.ts
-var import_zod13 = require("zod");
-var BaseField2 = import_zod13.z.object({
+var import_zod14 = require("zod");
+var BaseField2 = import_zod14.z.object({
   emptyValueMessage: TranslationConfig.optional(),
-  conditionals: import_zod13.z.array(ShowConditional).default([]).optional()
+  conditionals: import_zod14.z.array(ShowConditional).default([]).optional()
 });
 var ReferenceField = BaseField2.extend({
-  fieldId: import_zod13.z.string(),
+  fieldId: import_zod14.z.string(),
   label: TranslationConfig.optional().describe(
     "By default, the configured field's label is used. This can be overridden by providing a custom label."
   )
 }).describe("Field directly referencing event data with field id");
 var Field = BaseField2.extend({
-  id: import_zod13.z.string().describe("Id of summary field"),
+  id: import_zod14.z.string().describe("Id of summary field"),
   value: TranslationConfig.describe(
     "Summary field value. Can utilise values defined in configuration and EventMetadata"
   ),
   label: TranslationConfig
 }).describe("Custom configured field");
-var SummaryConfig = import_zod13.z.object({
-  fields: import_zod13.z.array(import_zod13.z.union([Field, ReferenceField])).describe("Fields rendered in summary view.")
+var SummaryConfig = import_zod14.z.object({
+  fields: import_zod14.z.array(import_zod14.z.union([Field, ReferenceField])).describe("Fields rendered in summary view.")
 }).describe("Configuration for summary in event.");
 
 // ../commons/src/events/AdvancedSearchConfig.ts
-var import_zod14 = require("zod");
-var MatchType = import_zod14.z.enum(["fuzzy", "exact", "range"]);
-var BaseField3 = import_zod14.z.object({
-  config: import_zod14.z.object({
+var import_zod15 = require("zod");
+var MatchType = import_zod15.z.enum(["fuzzy", "exact", "range"]);
+var BaseField3 = import_zod15.z.object({
+  config: import_zod15.z.object({
     type: MatchType.describe("Determines the type of field")
   }),
-  options: import_zod14.z.array(SelectOption).optional(),
+  options: import_zod15.z.array(SelectOption).optional(),
   searchCriteriaLabelPrefix: TranslationConfig.optional().describe(
     `
     This property determines whether to add a prefix (such as "Child" or "Applicant") before the field label
@@ -1290,7 +1366,7 @@ var BaseField3 = import_zod14.z.object({
     in the country-config > event.advancedSearch configuration. For example: field("child.dob", { searchCriteriaLabelPrefix: TranslationConfig }).
     `
   ),
-  conditionals: import_zod14.z.array(FieldConditional).default([]).optional().describe(
+  conditionals: import_zod15.z.array(FieldConditional).default([]).optional().describe(
     `
        In advanced search, we sometimes need to override the default field visibility conditionals.
 
@@ -1304,50 +1380,60 @@ var BaseField3 = import_zod14.z.object({
        are always rendered in the advanced search form.
       `
   ),
-  validations: import_zod14.z.array(ValidationConfig).default([]).optional().describe(
+  validations: import_zod15.z.array(ValidationConfig).default([]).optional().describe(
     `In advanced search, we sometimes need to override the default field validations.`
   )
 });
-var SearchQueryParams = import_zod14.z.object({
-  eventType: import_zod14.z.string().optional().describe(
+var SearchQueryParams = import_zod15.z.object({
+  eventType: import_zod15.z.string().optional().describe(
     "Defines type of event so that when redirecting to Advanced Search page, appropriate tab can be selected"
   )
 }).catchall(FieldValue);
 var FieldConfigSchema = BaseField3.extend({
-  fieldId: import_zod14.z.string(),
-  fieldType: import_zod14.z.literal("field")
+  fieldId: import_zod15.z.string(),
+  fieldType: import_zod15.z.literal("field"),
+  alternateFieldIds: import_zod15.z.array(import_zod15.z.string()).optional().describe(
+    `Sometimes there might be need to search a value against multiple field of same FormField type. For example
+      search Country, Province, District against child.address.private and child.address.other. In such case, we 
+      add a one field as fieldId, and accomodate others in alternateFieldIds`
+  ),
+  excludeInSearchQuery: import_zod15.z.boolean().default(false).optional().describe(`Sometimes there will be search fields which are used to 
+    conditionally display another search field, but its not needed in search query. For example, child.placeOfBirth 
+    is select field, which has 3 options, FACILITY, PRIVATE_HOME, OTHER. Upon selecting any of the option, pops up another field
+    related to the selected option, whose value is required in the search query. But child.placeOfBirth itself is not needed in the query.
+    In such case, populate this field (excludeInSearchQuery) with boolean true`)
 });
-var EventFieldId = import_zod14.z.enum([
+var EventFieldId = import_zod15.z.enum([
   "trackingId",
   "status",
-  "legalStatus.REGISTERED.createdAt",
-  "legalStatus.REGISTERED.createdAtLocation",
+  "legalStatuses.REGISTERED.acceptedAt",
+  "legalStatuses.REGISTERED.createdAtLocation",
   "updatedAt"
 ]);
 var EventFieldConfigSchema = BaseField3.extend({
   fieldId: EventFieldId,
-  fieldType: import_zod14.z.literal("event")
+  fieldType: import_zod15.z.literal("event")
 });
-var SearchField = import_zod14.z.discriminatedUnion("fieldType", [
+var SearchField = import_zod15.z.discriminatedUnion("fieldType", [
   FieldConfigSchema,
   EventFieldConfigSchema
 ]);
-var AdvancedSearchConfig = import_zod14.z.object({
+var AdvancedSearchConfig = import_zod15.z.object({
   title: TranslationConfig.describe("Advanced search tab title"),
-  fields: import_zod14.z.array(SearchField).describe("Advanced search fields.")
+  fields: import_zod15.z.array(SearchField).describe("Advanced search fields.")
 });
 
 // ../commons/src/events/utils.ts
 var import_lodash = require("lodash");
 
 // ../commons/src/events/ActionDocument.ts
-var import_zod18 = require("zod");
-var import_zod_openapi7 = require("zod-openapi");
+var import_zod19 = require("zod");
+var import_zod_openapi8 = require("zod-openapi");
 
 // ../commons/src/uuid.ts
 var import_uuid = require("uuid");
-var import_zod15 = require("zod");
-var UUID = import_zod15.z.string().uuid().brand("UUID");
+var import_zod16 = require("zod");
+var UUID = import_zod16.z.string().uuid().brand("UUID");
 function getUUID() {
   return (0, import_uuid.v4)();
 }
@@ -1357,10 +1443,10 @@ var CreatedAtLocation = UUID.nullish();
 
 // ../commons/src/authentication.ts
 var import_jwt_decode = __toESM(require("jwt-decode"));
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 
 // ../commons/src/scopes.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 var SCOPES = {
   // TODO v1.8 legacy scopes
   NATLSYSADMIN: "natlsysadmin",
@@ -1473,108 +1559,108 @@ var SCOPES = {
   // data seeding
   USER_DATA_SEEDING: "user.data-seeding"
 };
-var LegacyScopes = import_zod16.z.union([
-  import_zod16.z.literal(SCOPES.NATLSYSADMIN),
-  import_zod16.z.literal(SCOPES.BYPASSRATELIMIT),
-  import_zod16.z.literal(SCOPES.DECLARE),
-  import_zod16.z.literal(SCOPES.REGISTER),
-  import_zod16.z.literal(SCOPES.VALIDATE),
-  import_zod16.z.literal(SCOPES.DEMO),
-  import_zod16.z.literal(SCOPES.CERTIFY),
-  import_zod16.z.literal(SCOPES.PERFORMANCE),
-  import_zod16.z.literal(SCOPES.SYSADMIN),
-  import_zod16.z.literal(SCOPES.TEAMS),
-  import_zod16.z.literal(SCOPES.CONFIG)
+var LegacyScopes = import_zod17.z.union([
+  import_zod17.z.literal(SCOPES.NATLSYSADMIN),
+  import_zod17.z.literal(SCOPES.BYPASSRATELIMIT),
+  import_zod17.z.literal(SCOPES.DECLARE),
+  import_zod17.z.literal(SCOPES.REGISTER),
+  import_zod17.z.literal(SCOPES.VALIDATE),
+  import_zod17.z.literal(SCOPES.DEMO),
+  import_zod17.z.literal(SCOPES.CERTIFY),
+  import_zod17.z.literal(SCOPES.PERFORMANCE),
+  import_zod17.z.literal(SCOPES.SYSADMIN),
+  import_zod17.z.literal(SCOPES.TEAMS),
+  import_zod17.z.literal(SCOPES.CONFIG)
 ]);
-var IntegrationScopes = import_zod16.z.union([
-  import_zod16.z.literal(SCOPES.WEBHOOK),
-  import_zod16.z.literal(SCOPES.NATIONALID),
-  import_zod16.z.literal(SCOPES.NOTIFICATION_API),
-  import_zod16.z.literal(SCOPES.RECORDSEARCH)
+var IntegrationScopes = import_zod17.z.union([
+  import_zod17.z.literal(SCOPES.WEBHOOK),
+  import_zod17.z.literal(SCOPES.NATIONALID),
+  import_zod17.z.literal(SCOPES.NOTIFICATION_API),
+  import_zod17.z.literal(SCOPES.RECORDSEARCH)
 ]);
-var DeclareScopes = import_zod16.z.union([
-  import_zod16.z.literal(SCOPES.RECORD_DECLARE),
-  import_zod16.z.literal(SCOPES.RECORD_IMPORT),
-  import_zod16.z.literal(SCOPES.RECORD_DECLARE_BIRTH),
-  import_zod16.z.literal(SCOPES.RECORD_DECLARE_BIRTH_MY_JURISDICTION),
-  import_zod16.z.literal(SCOPES.RECORD_DECLARE_DEATH),
-  import_zod16.z.literal(SCOPES.RECORD_DECLARE_DEATH_MY_JURISDICTION),
-  import_zod16.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE),
-  import_zod16.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE_MY_JURISDICTION),
-  import_zod16.z.literal(SCOPES.RECORD_SUBMIT_INCOMPLETE),
-  import_zod16.z.literal(SCOPES.RECORD_SUBMIT_FOR_REVIEW)
+var DeclareScopes = import_zod17.z.union([
+  import_zod17.z.literal(SCOPES.RECORD_DECLARE),
+  import_zod17.z.literal(SCOPES.RECORD_IMPORT),
+  import_zod17.z.literal(SCOPES.RECORD_DECLARE_BIRTH),
+  import_zod17.z.literal(SCOPES.RECORD_DECLARE_BIRTH_MY_JURISDICTION),
+  import_zod17.z.literal(SCOPES.RECORD_DECLARE_DEATH),
+  import_zod17.z.literal(SCOPES.RECORD_DECLARE_DEATH_MY_JURISDICTION),
+  import_zod17.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE),
+  import_zod17.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE_MY_JURISDICTION),
+  import_zod17.z.literal(SCOPES.RECORD_SUBMIT_INCOMPLETE),
+  import_zod17.z.literal(SCOPES.RECORD_SUBMIT_FOR_REVIEW)
 ]);
-var UnassignScope = import_zod16.z.literal(SCOPES.RECORD_UNASSIGN_OTHERS);
-var ValidateScopes = import_zod16.z.union([
-  import_zod16.z.literal(SCOPES.RECORD_SUBMIT_FOR_APPROVAL),
-  import_zod16.z.literal(SCOPES.RECORD_SUBMIT_FOR_UPDATES),
-  import_zod16.z.literal(SCOPES.RECORD_DECLARATION_EDIT),
-  import_zod16.z.literal(SCOPES.RECORD_REVIEW_DUPLICATES),
-  import_zod16.z.literal(SCOPES.RECORD_DECLARATION_ARCHIVE),
-  import_zod16.z.literal(SCOPES.RECORD_DECLARATION_REINSTATE)
+var UnassignScope = import_zod17.z.literal(SCOPES.RECORD_UNASSIGN_OTHERS);
+var ValidateScopes = import_zod17.z.union([
+  import_zod17.z.literal(SCOPES.RECORD_SUBMIT_FOR_APPROVAL),
+  import_zod17.z.literal(SCOPES.RECORD_SUBMIT_FOR_UPDATES),
+  import_zod17.z.literal(SCOPES.RECORD_DECLARATION_EDIT),
+  import_zod17.z.literal(SCOPES.RECORD_REVIEW_DUPLICATES),
+  import_zod17.z.literal(SCOPES.RECORD_DECLARATION_ARCHIVE),
+  import_zod17.z.literal(SCOPES.RECORD_DECLARATION_REINSTATE)
 ]);
-var RegisterScope = import_zod16.z.literal(SCOPES.RECORD_REGISTER);
-var CertifyScopes = import_zod16.z.union([
-  import_zod16.z.literal(SCOPES.RECORD_EXPORT_RECORDS),
-  import_zod16.z.literal(SCOPES.RECORD_DECLARATION_PRINT),
-  import_zod16.z.literal(SCOPES.RECORD_PRINT_RECORDS_SUPPORTING_DOCUMENTS),
-  import_zod16.z.literal(SCOPES.RECORD_REGISTRATION_PRINT),
-  import_zod16.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
-  import_zod16.z.literal(SCOPES.RECORD_PRINT_CERTIFIED_COPIES),
-  import_zod16.z.literal(SCOPES.RECORD_BULK_PRINT_CERTIFIED_COPIES),
-  import_zod16.z.literal(SCOPES.RECORD_REGISTRATION_VERIFY_CERTIFIED_COPIES)
+var RegisterScope = import_zod17.z.literal(SCOPES.RECORD_REGISTER);
+var CertifyScopes = import_zod17.z.union([
+  import_zod17.z.literal(SCOPES.RECORD_EXPORT_RECORDS),
+  import_zod17.z.literal(SCOPES.RECORD_DECLARATION_PRINT),
+  import_zod17.z.literal(SCOPES.RECORD_PRINT_RECORDS_SUPPORTING_DOCUMENTS),
+  import_zod17.z.literal(SCOPES.RECORD_REGISTRATION_PRINT),
+  import_zod17.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
+  import_zod17.z.literal(SCOPES.RECORD_PRINT_CERTIFIED_COPIES),
+  import_zod17.z.literal(SCOPES.RECORD_BULK_PRINT_CERTIFIED_COPIES),
+  import_zod17.z.literal(SCOPES.RECORD_REGISTRATION_VERIFY_CERTIFIED_COPIES)
 ]);
-var CorrectionScopes = import_zod16.z.union([
-  import_zod16.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_CORRECTION),
-  import_zod16.z.literal(SCOPES.RECORD_REGISTRATION_CORRECT),
-  import_zod16.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_REVOCATION),
-  import_zod16.z.literal(SCOPES.RECORD_REGISTRATION_REVOKE),
-  import_zod16.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_REINSTATEMENT),
-  import_zod16.z.literal(SCOPES.RECORD_REGISTRATION_REINSTATE),
-  import_zod16.z.literal(SCOPES.RECORD_CONFIRM_REGISTRATION),
-  import_zod16.z.literal(SCOPES.RECORD_REJECT_REGISTRATION)
+var CorrectionScopes = import_zod17.z.union([
+  import_zod17.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_CORRECTION),
+  import_zod17.z.literal(SCOPES.RECORD_REGISTRATION_CORRECT),
+  import_zod17.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_REVOCATION),
+  import_zod17.z.literal(SCOPES.RECORD_REGISTRATION_REVOKE),
+  import_zod17.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_REINSTATEMENT),
+  import_zod17.z.literal(SCOPES.RECORD_REGISTRATION_REINSTATE),
+  import_zod17.z.literal(SCOPES.RECORD_CONFIRM_REGISTRATION),
+  import_zod17.z.literal(SCOPES.RECORD_REJECT_REGISTRATION)
 ]);
-var SearchScopes = import_zod16.z.union([
-  import_zod16.z.literal(SCOPES.SEARCH_BIRTH_MY_JURISDICTION),
-  import_zod16.z.literal(SCOPES.SEARCH_BIRTH),
-  import_zod16.z.literal(SCOPES.SEARCH_DEATH_MY_JURISDICTION),
-  import_zod16.z.literal(SCOPES.SEARCH_DEATH),
-  import_zod16.z.literal(SCOPES.SEARCH_MARRIAGE_MY_JURISDICTION),
-  import_zod16.z.literal(SCOPES.SEARCH_MARRIAGE)
+var SearchScopes = import_zod17.z.union([
+  import_zod17.z.literal(SCOPES.SEARCH_BIRTH_MY_JURISDICTION),
+  import_zod17.z.literal(SCOPES.SEARCH_BIRTH),
+  import_zod17.z.literal(SCOPES.SEARCH_DEATH_MY_JURISDICTION),
+  import_zod17.z.literal(SCOPES.SEARCH_DEATH),
+  import_zod17.z.literal(SCOPES.SEARCH_MARRIAGE_MY_JURISDICTION),
+  import_zod17.z.literal(SCOPES.SEARCH_MARRIAGE)
 ]);
-var AuditScopes = import_zod16.z.union([
-  import_zod16.z.literal(SCOPES.RECORD_READ),
-  import_zod16.z.literal(SCOPES.RECORD_READ_AUDIT),
-  import_zod16.z.literal(SCOPES.RECORD_READ_COMMENTS),
-  import_zod16.z.literal(SCOPES.RECORD_CREATE_COMMENTS)
+var AuditScopes = import_zod17.z.union([
+  import_zod17.z.literal(SCOPES.RECORD_READ),
+  import_zod17.z.literal(SCOPES.RECORD_READ_AUDIT),
+  import_zod17.z.literal(SCOPES.RECORD_READ_COMMENTS),
+  import_zod17.z.literal(SCOPES.RECORD_CREATE_COMMENTS)
 ]);
-var ProfileScopes = import_zod16.z.union([
-  import_zod16.z.literal(SCOPES.PROFILE_UPDATE),
-  import_zod16.z.literal(SCOPES.PROFILE_ELECTRONIC_SIGNATURE)
+var ProfileScopes = import_zod17.z.union([
+  import_zod17.z.literal(SCOPES.PROFILE_UPDATE),
+  import_zod17.z.literal(SCOPES.PROFILE_ELECTRONIC_SIGNATURE)
 ]);
-var PerformanceScopes = import_zod16.z.union([
-  import_zod16.z.literal(SCOPES.PERFORMANCE_READ),
-  import_zod16.z.literal(SCOPES.PERFORMANCE_READ_DASHBOARDS),
-  import_zod16.z.literal(SCOPES.PERFORMANCE_EXPORT_VITAL_STATISTICS)
+var PerformanceScopes = import_zod17.z.union([
+  import_zod17.z.literal(SCOPES.PERFORMANCE_READ),
+  import_zod17.z.literal(SCOPES.PERFORMANCE_READ_DASHBOARDS),
+  import_zod17.z.literal(SCOPES.PERFORMANCE_EXPORT_VITAL_STATISTICS)
 ]);
-var OrganisationScopes = import_zod16.z.union([
-  import_zod16.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS),
-  import_zod16.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_OFFICE),
-  import_zod16.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_JURISDICTION)
+var OrganisationScopes = import_zod17.z.union([
+  import_zod17.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS),
+  import_zod17.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_OFFICE),
+  import_zod17.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_JURISDICTION)
 ]);
-var UserScopes = import_zod16.z.union([
-  import_zod16.z.literal(SCOPES.USER_READ),
-  import_zod16.z.literal(SCOPES.USER_READ_MY_OFFICE),
-  import_zod16.z.literal(SCOPES.USER_READ_MY_JURISDICTION),
-  import_zod16.z.literal(SCOPES.USER_READ_ONLY_MY_AUDIT),
-  import_zod16.z.literal(SCOPES.USER_CREATE),
-  import_zod16.z.literal(SCOPES.USER_CREATE_MY_JURISDICTION),
-  import_zod16.z.literal(SCOPES.USER_UPDATE),
-  import_zod16.z.literal(SCOPES.USER_UPDATE_MY_JURISDICTION)
+var UserScopes = import_zod17.z.union([
+  import_zod17.z.literal(SCOPES.USER_READ),
+  import_zod17.z.literal(SCOPES.USER_READ_MY_OFFICE),
+  import_zod17.z.literal(SCOPES.USER_READ_MY_JURISDICTION),
+  import_zod17.z.literal(SCOPES.USER_READ_ONLY_MY_AUDIT),
+  import_zod17.z.literal(SCOPES.USER_CREATE),
+  import_zod17.z.literal(SCOPES.USER_CREATE_MY_JURISDICTION),
+  import_zod17.z.literal(SCOPES.USER_UPDATE),
+  import_zod17.z.literal(SCOPES.USER_UPDATE_MY_JURISDICTION)
 ]);
-var ConfigScope = import_zod16.z.literal(SCOPES.CONFIG_UPDATE_ALL);
-var DataSeedingScope = import_zod16.z.literal(SCOPES.USER_DATA_SEEDING);
-var LiteralScopes = import_zod16.z.union([
+var ConfigScope = import_zod17.z.literal(SCOPES.CONFIG_UPDATE_ALL);
+var DataSeedingScope = import_zod17.z.literal(SCOPES.USER_DATA_SEEDING);
+var LiteralScopes = import_zod17.z.union([
   LegacyScopes,
   IntegrationScopes,
   UnassignScope,
@@ -1593,39 +1679,47 @@ var LiteralScopes = import_zod16.z.union([
   DataSeedingScope
 ]);
 var rawConfigurableScopeRegex = /^([a-zA-Z\.]+)\[((?:\w+=[\w.-]+(?:\|[\w.-]+)*)(?:,[\w]+=[\w.-]+(?:\|[\w.-]+)*)*)\]$/;
-var rawConfigurableScope = import_zod16.z.string().regex(rawConfigurableScopeRegex);
-var CreateUserScope = import_zod16.z.object({
-  type: import_zod16.z.literal("user.create"),
-  options: import_zod16.z.object({
-    role: import_zod16.z.array(import_zod16.z.string())
+var rawConfigurableScope = import_zod17.z.string().regex(rawConfigurableScopeRegex);
+var CreateUserScope = import_zod17.z.object({
+  type: import_zod17.z.literal("user.create"),
+  options: import_zod17.z.object({
+    role: import_zod17.z.array(import_zod17.z.string())
+  })
+});
+var EditUserScope = import_zod17.z.object({
+  type: import_zod17.z.literal("user.edit"),
+  options: import_zod17.z.object({
+    role: import_zod17.z.array(import_zod17.z.string())
   })
 });
-var EditUserScope = import_zod16.z.object({
-  type: import_zod16.z.literal("user.edit"),
-  options: import_zod16.z.object({
-    role: import_zod16.z.array(import_zod16.z.string())
+var WorkqueueScope = import_zod17.z.object({
+  type: import_zod17.z.literal("workqueue"),
+  options: import_zod17.z.object({
+    id: import_zod17.z.array(import_zod17.z.string())
   })
 });
-var WorkqueueScope = import_zod16.z.object({
-  type: import_zod16.z.literal("workqueue"),
-  options: import_zod16.z.object({
-    id: import_zod16.z.array(import_zod16.z.string())
+var NotifyRecordScope = import_zod17.z.object({
+  type: import_zod17.z.literal("record.notify"),
+  options: import_zod17.z.object({
+    event: import_zod17.z.array(import_zod17.z.string())
   })
 });
-var NotifyRecordScope = import_zod16.z.object({
-  type: import_zod16.z.literal("record.notify"),
-  options: import_zod16.z.object({
-    event: import_zod16.z.array(import_zod16.z.string())
+var SearchScope = import_zod17.z.object({
+  type: import_zod17.z.literal("search"),
+  options: import_zod17.z.object({
+    event: import_zod17.z.array(import_zod17.z.string()).length(1),
+    access: import_zod17.z.array(import_zod17.z.enum(["my-jurisdiction", "all"])).length(1)
   })
 });
-var ConfigurableScopes = import_zod16.z.discriminatedUnion("type", [
+var ConfigurableRawScopes = import_zod17.z.discriminatedUnion("type", [
+  SearchScope,
   CreateUserScope,
   EditUserScope,
   WorkqueueScope,
   NotifyRecordScope
 ]);
 var scopes = Object.values(SCOPES);
-var ActionScopes = import_zod16.z.union([
+var ActionScopes = import_zod17.z.union([
   DeclareScopes,
   ValidateScopes,
   RegisterScope,
@@ -1776,30 +1870,30 @@ var DEFAULT_ROLES_DEFINITION = [
     ]
   }
 ];
-var TokenUserType = import_zod17.z.enum(["user", "system"]);
-var TokenWithBearer = import_zod17.z.string().regex(/^Bearer\s/);
+var TokenUserType = import_zod18.z.enum(["user", "system"]);
+var TokenWithBearer = import_zod18.z.string().regex(/^Bearer\s/);
 
 // ../commons/src/events/ActionDocument.ts
-(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod18.z);
-var ActionUpdate = import_zod18.z.record(import_zod18.z.string(), FieldUpdateValue);
-var EventState = import_zod18.z.record(import_zod18.z.string(), FieldValue);
+(0, import_zod_openapi8.extendZodWithOpenApi)(import_zod19.z);
+var ActionUpdate = import_zod19.z.record(import_zod19.z.string(), FieldUpdateValue);
+var EventState = import_zod19.z.record(import_zod19.z.string(), FieldValue);
 var ActionStatus = {
   Requested: "Requested",
   Accepted: "Accepted",
   Rejected: "Rejected"
 };
-var ActionBase = import_zod18.z.object({
+var ActionBase = import_zod19.z.object({
   id: UUID,
-  transactionId: import_zod18.z.string(),
+  transactionId: import_zod19.z.string(),
   createdByUserType: TokenUserType,
-  createdAt: import_zod18.z.string().datetime(),
-  createdBy: import_zod18.z.string(),
-  createdByRole: import_zod18.z.string(),
-  createdBySignature: import_zod18.z.string().nullish().describe("Reference to signature of the user who created the action"),
+  createdAt: import_zod19.z.string().datetime(),
+  createdBy: import_zod19.z.string(),
+  createdByRole: import_zod19.z.string(),
+  createdBySignature: import_zod19.z.string().nullish().describe("Reference to signature of the user who created the action"),
   createdAtLocation: CreatedAtLocation,
   declaration: ActionUpdate,
   annotation: ActionUpdate.optional().nullable(),
-  status: import_zod18.z.enum([
+  status: import_zod19.z.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
@@ -1810,91 +1904,91 @@ var ActionBase = import_zod18.z.object({
   )
 });
 var AssignedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod18.z.string()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.ASSIGN),
+    assignedTo: import_zod19.z.string()
   })
 );
 var UnassignedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.UNASSIGN)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.UNASSIGN)
   })
 );
 var RegisterAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.REGISTER),
-    registrationNumber: import_zod18.z.string().optional()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.REGISTER),
+    registrationNumber: import_zod19.z.string().optional()
   })
 );
 var DeclareAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.DECLARE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.DECLARE)
   })
 );
 var ValidateAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.VALIDATE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.VALIDATE)
   })
 );
-var RejectionReason = import_zod18.z.object({
-  message: import_zod18.z.string().min(1, { message: "Message cannot be empty" }).describe("Message describing reason for rejection or archiving"),
-  isDuplicate: import_zod18.z.boolean().optional().describe("If a declaration is duplicated")
+var RejectionReason = import_zod19.z.object({
+  message: import_zod19.z.string().min(1, { message: "Message cannot be empty" }).describe("Message describing reason for rejection or archiving"),
+  isDuplicate: import_zod19.z.boolean().optional().describe("If a declaration is duplicated")
 });
 var RejectAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.REJECT),
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.REJECT),
     reason: RejectionReason
   })
 );
 var MarkAsDuplicateAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.MARKED_AS_DUPLICATE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.ARCHIVE),
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.ARCHIVE),
     reason: RejectionReason
   })
 );
 var CreatedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.CREATE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.CREATE)
   })
 );
 var NotifiedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.NOTIFY)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.NOTIFY)
   })
 );
 var PrintCertificateAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.PRINT_CERTIFICATE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RequestedCorrectionAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.REQUEST_CORRECTION)
+  import_zod19.z.object({
+    type: import_zod19.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()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.APPROVE_CORRECTION),
+    requestId: import_zod19.z.string()
   })
 );
 var RejectedCorrectionAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.REJECT_CORRECTION),
-    requestId: import_zod18.z.string()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.REJECT_CORRECTION),
+    requestId: import_zod19.z.string()
   })
 );
 var ReadAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.READ)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.READ)
   })
 );
-var ActionDocument = import_zod18.z.discriminatedUnion("type", [
+var ActionDocument = import_zod19.z.discriminatedUnion("type", [
   CreatedAction.openapi({ ref: "CreatedAction" }),
   ValidateAction.openapi({ ref: "ValidateAction" }),
   RejectAction.openapi({ ref: "RejectAction" }),
@@ -1917,20 +2011,20 @@ var AsyncRejectActionDocument = ActionBase.omit({
   declaration: true,
   annotation: true
 }).merge(
-  import_zod18.z.object({
-    type: import_zod18.z.enum(ConfirmableActions),
-    status: import_zod18.z.literal(ActionStatus.Rejected)
+  import_zod19.z.object({
+    type: import_zod19.z.enum(ConfirmableActions),
+    status: import_zod19.z.literal(ActionStatus.Rejected)
   })
 );
-var Action = import_zod18.z.union([ActionDocument, AsyncRejectActionDocument]);
-var ResolvedUser = import_zod18.z.object({
-  id: import_zod18.z.string(),
-  role: import_zod18.z.string(),
-  name: import_zod18.z.array(
-    import_zod18.z.object({
-      use: import_zod18.z.string(),
-      given: import_zod18.z.array(import_zod18.z.string()),
-      family: import_zod18.z.string()
+var Action = import_zod19.z.union([ActionDocument, AsyncRejectActionDocument]);
+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()
     })
   )
 });
@@ -1941,19 +2035,25 @@ var import_ajv_formats = __toESM(require("ajv-formats"));
 var import_date_fns = require("date-fns");
 
 // ../commons/src/events/FieldTypeMapping.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 function mapFieldTypeToZod(type, required) {
   let schema;
   switch (type) {
     case FieldType.DATE:
       schema = DateValue;
       break;
+    case FieldType.TIME:
+      schema = TimeValue;
+      break;
     case FieldType.EMAIL:
       schema = EmailValue;
       break;
     case FieldType.DATE_RANGE:
       schema = DateRangeFieldValue;
       break;
+    case FieldType.SELECT_DATE_RANGE:
+      schema = SelectDateRangeValue;
+      break;
     case FieldType.TEXT:
     case FieldType.TEXTAREA:
     case FieldType.DIVIDER:
@@ -2001,7 +2101,7 @@ function createValidationSchema(config) {
   for (const field2 of config) {
     shape[field2.id] = mapFieldTypeToZod(field2.type, field2.required);
   }
-  return import_zod19.z.object(shape);
+  return import_zod20.z.object(shape);
 }
 function mapFieldTypeToEmptyValue(field2) {
   switch (field2.type) {
@@ -2021,8 +2121,10 @@ function mapFieldTypeToEmptyValue(field2) {
     case FieldType.NUMBER:
     case FieldType.EMAIL:
     case FieldType.DATE:
+    case FieldType.TIME:
     case FieldType.CHECKBOX:
     case FieldType.DATE_RANGE:
+    case FieldType.SELECT_DATE_RANGE:
     case FieldType.DATA:
     case FieldType.NAME:
     case FieldType.PHONE:
@@ -2045,7 +2147,7 @@ function mapFieldTypeToEmptyValue(field2) {
     case FieldType.SIGNATURE:
     case FieldType.FILE:
       return {
-        filename: "",
+        path: "",
         originalFilename: "",
         type: ""
       };
@@ -2059,9 +2161,15 @@ var isParagraphFieldType = (field2) => {
 var isDateFieldType = (field2) => {
   return field2.config.type === FieldType.DATE;
 };
+var isTimeFieldType = (field2) => {
+  return field2.config.type === FieldType.TIME;
+};
 var isDateRangeFieldType = (field2) => {
   return field2.config.type === FieldType.DATE_RANGE;
 };
+var isSelectDateRangeFieldType = (field2) => {
+  return field2.config.type === FieldType.SELECT_DATE_RANGE;
+};
 var isPageHeaderFieldType = (field2) => {
   return field2.config.type === FieldType.PAGE_HEADER;
 };
@@ -2141,6 +2249,29 @@ var ajv = new import_ajv.default({
   allowUnionTypes: true
 });
 (0, import_ajv_formats.default)(ajv);
+ajv.addKeyword({
+  keyword: "daysFromNow",
+  type: "string",
+  schemaType: "object",
+  $data: true,
+  errors: true,
+  validate(schema, data, _, dataContext) {
+    if (!(dataContext && dataContext.rootData && typeof dataContext.rootData === "object" && "$now" in dataContext.rootData && typeof dataContext.rootData.$now === "string")) {
+      throw new Error("Validation context must contain $now");
+    }
+    const { days, clause } = schema;
+    if (typeof data !== "string") {
+      return false;
+    }
+    const date = new Date(data);
+    if (isNaN(date.getTime())) {
+      return false;
+    }
+    const now = new Date(dataContext.rootData.$now);
+    const offsetDate = new Date(now.getTime() + days * 24 * 60 * 60 * 1e3);
+    return clause === "after" ? (0, import_date_fns.isAfter)(date, offsetDate) : (0, import_date_fns.isBefore)(date, offsetDate);
+  }
+});
 function validate(schema, data) {
   return ajv.validate(schema, data);
 }
@@ -2206,7 +2337,7 @@ var errorMessages = {
     id: "v2.error.invalidEmail"
   },
   requiredField: {
-    defaultMessage: "Required for registration",
+    defaultMessage: "Required",
     description: "Error message when required field is missing",
     id: "v2.error.required"
   },
@@ -2219,6 +2350,11 @@ var errorMessages = {
     defaultMessage: "Unexpected field",
     description: "Error message when field is not expected",
     id: "v2.error.unexpectedField"
+  },
+  correctionNotAllowed: {
+    defaultMessage: "Correction not allowed for field",
+    description: "Error message when correction is not allowed for field",
+    id: "v2.error.correctionNotAllowed"
   }
 };
 function createIntlError(message) {
@@ -2279,13 +2415,8 @@ function validateFieldInput({
   field: field2,
   value
 }) {
-  const rawError = mapFieldTypeToZod(field2.type, field2.required).safeParse(
-    value,
-    {
-      // @ts-expect-error
-      errorMap: zodToIntlErrorMap
-    }
-  );
+  const zodType = mapFieldTypeToZod(field2.type, field2.required);
+  const rawError = zodType.safeParse(value, { errorMap: zodToIntlErrorMap });
   return rawError.error?.issues.map((issue) => issue.message) ?? [];
 }
 function runFieldValidations({
@@ -2366,6 +2497,7 @@ function joinValues(values, separator = " ") {
 }
 
 // ../commons/src/events/utils.ts
+var import_date_fns2 = require("date-fns");
 function isDeclarationActionConfig(action) {
   return DeclarationActions.safeParse(action.type).success;
 }
@@ -2378,12 +2510,18 @@ function getDeclarationPages(configuration) {
 function getDeclaration(configuration) {
   return configuration.declaration;
 }
+function getPrintCertificatePages(configuration) {
+  const action = configuration.actions.find(
+    (a) => a.type === ActionType.PRINT_CERTIFICATE
+  );
+  return getOrThrow(
+    action?.printForm.pages,
+    `${ActionType.PRINT_CERTIFICATE} action does not have print form set.`
+  );
+}
 var getActionAnnotationFields = (actionConfig) => {
   if (actionConfig.type === ActionType.REQUEST_CORRECTION) {
-    return [
-      ...actionConfig.onboardingForm.flatMap(({ fields }) => fields),
-      ...actionConfig.additionalDetailsForm.flatMap(({ fields }) => fields)
-    ];
+    return actionConfig.correctionForm.pages.flatMap(({ fields }) => fields);
   }
   if (actionConfig.type === ActionType.PRINT_CERTIFICATE) {
     return actionConfig.printForm.pages.flatMap(({ fields }) => fields);
@@ -2406,7 +2544,7 @@ function getDeclarationFieldById(config, fieldId) {
 var findRecordActionPages = (config, actionType) => {
   const action = config.actions.find((a) => a.type === actionType);
   if (action?.type === ActionType.REQUEST_CORRECTION) {
-    return [...action.onboardingForm, ...action.additionalDetailsForm];
+    return action.correctionForm.pages;
   }
   if (action?.type === ActionType.PRINT_CERTIFICATE) {
     return action.printForm.pages;
@@ -2480,13 +2618,10 @@ function getVisibleVerificationPageIds(pages, annotation) {
 }
 function getActionVerificationPageIds(actionConfig, annotation) {
   if (actionConfig.type === ActionType.REQUEST_CORRECTION) {
-    return [
-      ...getVisibleVerificationPageIds(actionConfig.onboardingForm, annotation),
-      ...getVisibleVerificationPageIds(
-        actionConfig.additionalDetailsForm,
-        annotation
-      )
-    ];
+    return getVisibleVerificationPageIds(
+      actionConfig.correctionForm.pages,
+      annotation
+    );
   }
   if (actionConfig.type === ActionType.PRINT_CERTIFICATE) {
     return getVisibleVerificationPageIds(
@@ -2565,12 +2700,33 @@ function getEventConfigById(eventConfigs, id) {
   );
   return getOrThrow(eventConfig, `Event config for ${id} not found`);
 }
+function timePeriodToDateRange(value) {
+  let startDate;
+  switch (value) {
+    case "last7Days":
+      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 6);
+      break;
+    case "last30Days":
+      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 29);
+      break;
+    case "last90Days":
+      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 89);
+      break;
+    case "last365Days":
+      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 364);
+      break;
+  }
+  return {
+    startDate: startDate.toISOString(),
+    endDate: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
 
 // ../commons/src/events/EventConfig.ts
-var import_zod_openapi8 = require("zod-openapi");
-(0, import_zod_openapi8.extendZodWithOpenApi)(import_zod20.z);
-var EventConfig = import_zod20.z.object({
-  id: import_zod20.z.string().describe(
+var import_zod_openapi9 = require("zod-openapi");
+(0, import_zod_openapi9.extendZodWithOpenApi)(import_zod21.z);
+var EventConfig = import_zod21.z.object({
+  id: import_zod21.z.string().describe(
     'A machine-readable identifier for the event, e.g. "birth" or "death"'
   ),
   dateOfEvent: FieldReference.optional(),
@@ -2580,10 +2736,10 @@ var EventConfig = import_zod20.z.object({
   ),
   summary: SummaryConfig,
   label: TranslationConfig,
-  actions: import_zod20.z.array(ActionConfig),
+  actions: import_zod21.z.array(ActionConfig),
   declaration: DeclarationFormConfig,
-  deduplication: import_zod20.z.array(DeduplicationConfig).optional().default([]),
-  advancedSearch: import_zod20.z.array(AdvancedSearchConfig).optional().default([])
+  deduplication: import_zod21.z.array(DeduplicationConfig).optional().default([]),
+  advancedSearch: import_zod21.z.array(AdvancedSearchConfig).optional().default([])
 }).superRefine((event2, ctx) => {
   const allFields = findAllFields(event2);
   const fieldIds = allFields.map((field2) => field2.id);
@@ -2615,6 +2771,28 @@ var EventConfig = import_zod20.z.object({
       path: ["advancedSearch"]
     });
   }
+  event2.advancedSearch.forEach((section, sectionIndex) => {
+    section.fields.forEach((field2, fieldIndex) => {
+      if ("alternateFieldIds" in field2 && Array.isArray(field2.alternateFieldIds)) {
+        const invalidAltIds = field2.alternateFieldIds.filter(
+          (id) => !fieldIds.includes(id)
+        );
+        if (invalidAltIds.length > 0) {
+          ctx.addIssue({
+            code: "custom",
+            message: `Invalid alternateFieldIds: ${invalidAltIds.join(", ")}`,
+            path: [
+              "advancedSearch",
+              sectionIndex,
+              "fields",
+              fieldIndex,
+              "alternateFieldIds"
+            ]
+          });
+        }
+      }
+    });
+  });
   if (event2.dateOfEvent) {
     const eventDateFieldId = getDeclarationFields(event2).find(
       ({ id }) => id === event2.dateOfEvent?.$$field
@@ -2645,16 +2823,17 @@ var definePage = (page) => PageConfig.parse(page);
 var defineFormPage = (formPage) => FormPageConfig.parse(formPage);
 
 // ../commons/src/events/WorkqueueConfig.ts
-var import_zod27 = require("zod");
+var import_zod28 = require("zod");
 
 // ../commons/src/events/serializers/user/serializer.ts
-var import_zod21 = require("zod");
-var SerializedUserField = import_zod21.z.object({
-  $userField: import_zod21.z.enum([
+var import_zod22 = require("zod");
+var SerializedUserField = import_zod22.z.object({
+  $userField: import_zod22.z.enum([
     "id",
     "name",
     "role",
-    "signatureFilename",
+    "signature",
+    "avatar",
     "primaryOfficeId"
   ])
 });
@@ -2726,41 +2905,6 @@ var user = Object.assign(userSerializer, {
     required: ["$user"]
   })
 });
-function createEventConditionals() {
-  return {
-    /**
-     * Checks if the event contains a specific action type.
-     * @param action - The action type to check for.
-     */
-    hasAction: (action) => defineConditional({
-      type: "object",
-      properties: {
-        $event: {
-          type: "object",
-          properties: {
-            actions: {
-              type: "array",
-              contains: {
-                type: "object",
-                properties: {
-                  type: {
-                    const: action
-                  }
-                },
-                required: ["type"]
-              }
-            }
-          },
-          required: ["actions"]
-        }
-      },
-      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",
@@ -2779,6 +2923,20 @@ function isFieldReference(value) {
   return typeof value === "object" && value !== null && "$$field" in value;
 }
 function createFieldConditionals(fieldId) {
+  const getDayRange = (days, clause) => ({
+    type: "object",
+    properties: {
+      [fieldId]: {
+        type: "string",
+        format: "date",
+        daysFromNow: {
+          days,
+          clause
+        }
+      }
+    },
+    required: [fieldId]
+  });
   const getDateRange = (date, clause) => ({
     type: "object",
     properties: {
@@ -2797,12 +2955,8 @@ function createFieldConditionals(fieldId) {
     $$field: fieldId,
     isAfter: () => ({
       days: (days) => ({
-        inPast: () => defineFormConditional(
-          getDateRange(getDateFromNow(days), "formatMinimum")
-        ),
-        inFuture: () => defineFormConditional(
-          getDateRange(getDateFromNow(-days), "formatMinimum")
-        )
+        inPast: () => defineFormConditional(getDayRange(-days, "after")),
+        inFuture: () => defineFormConditional(getDayRange(days, "after"))
       }),
       date: (date) => {
         if (isFieldReference(date)) {
@@ -2817,16 +2971,12 @@ function createFieldConditionals(fieldId) {
         }
         return defineFormConditional(getDateRange(date, "formatMinimum"));
       },
-      now: () => defineFormConditional(getDateRange(getDateFromNow(0), "formatMinimum"))
+      now: () => defineFormConditional(getDateRange({ $data: "/$now" }, "formatMinimum"))
     }),
     isBefore: () => ({
       days: (days) => ({
-        inPast: () => defineFormConditional(
-          getDateRange(getDateFromNow(days), "formatMaximum")
-        ),
-        inFuture: () => defineFormConditional(
-          getDateRange(getDateFromNow(-days), "formatMaximum")
-        )
+        inPast: () => defineFormConditional(getDayRange(days, "before")),
+        inFuture: () => defineFormConditional(getDayRange(-days, "before"))
       }),
       date: (date) => {
         if (isFieldReference(date)) {
@@ -2841,7 +2991,7 @@ function createFieldConditionals(fieldId) {
         }
         return defineFormConditional(getDateRange(date, "formatMaximum"));
       },
-      now: () => defineFormConditional(getDateRange(getDateFromNow(0), "formatMaximum"))
+      now: () => defineFormConditional(getDateRange({ $data: "/$now" }, "formatMaximum"))
     }),
     isEqualTo: (value) => {
       if (isFieldReference(value)) {
@@ -2933,8 +3083,7 @@ function createFieldConditionals(fieldId) {
           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.
@@ -2990,7 +3139,7 @@ function createSearchConfig(baseField) {
      *
      * @returns An object containing the field ID and a configuration object with a type of 'range'.
      *
-     * @example event('legalStatus.REGISTERED.createdAt').range()
+     * @example event('legalStatuses.REGISTERED.acceptedAt').range()
      * // {
      * //   ...
      * //   config: { type: 'range' }
@@ -3030,21 +3179,47 @@ function createSearchConfig(baseField) {
 }
 
 // ../commons/src/event-config/event-configuration.ts
-function createEventFieldConfig(fieldId, options) {
+function createEventFieldConfig(fieldId) {
   const baseField = {
     fieldId,
-    options,
     fieldType: "event"
   };
   return createSearchConfig(baseField);
 }
 
 // ../commons/src/events/event.ts
-function eventFn(fieldId, options) {
-  return createEventFieldConfig(fieldId, options);
+function eventFn(fieldId) {
+  return createEventFieldConfig(fieldId);
 }
 var event = Object.assign(eventFn, {
-  ...createEventConditionals(),
+  /**
+   * Checks if the event contains a specific action type.
+   * @param action - The action type to check for.
+   */
+  hasAction: (action) => defineConditional({
+    type: "object",
+    properties: {
+      $event: {
+        type: "object",
+        properties: {
+          actions: {
+            type: "array",
+            contains: {
+              type: "object",
+              properties: {
+                type: {
+                  const: action
+                }
+              },
+              required: ["type"]
+            }
+          }
+        },
+        required: ["actions"]
+      }
+    },
+    required: ["$event"]
+  }),
   field(field2) {
     return {
       $event: field2
@@ -3053,83 +3228,83 @@ var event = Object.assign(eventFn, {
 });
 
 // ../commons/src/events/WorkqueueColumnConfig.ts
-var import_zod23 = require("zod");
+var import_zod24 = require("zod");
 
 // ../commons/src/events/EventMetadata.ts
-var import_zod22 = require("zod");
-var EventStatus = import_zod22.z.enum([
+var import_zod23 = require("zod");
+var EventStatus = import_zod23.z.enum([
   "CREATED",
   "NOTIFIED",
   "DECLARED",
   "VALIDATED",
   "REGISTERED",
   "CERTIFIED",
-  "REJECTED",
   "ARCHIVED"
 ]);
+var VisibleStatus = import_zod23.z.enum([...EventStatus.options, "REJECTED"]);
 var InherentFlags = {
   PRINTED: "printed",
   INCOMPLETE: "incomplete",
   REJECTED: "rejected",
   CORRECTION_REQUESTED: "correction-requested"
 };
-var Flag = import_zod22.z.string().regex(
+var Flag = import_zod23.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_zod22.z.nativeEnum(InherentFlags));
-var ZodDate = import_zod22.z.string().date();
-var ActionCreationMetadata = import_zod22.z.object({
-  createdAt: import_zod22.z.string().datetime().describe("The timestamp when the action request was created."),
-  createdBy: import_zod22.z.string().describe("ID of the user who created the action request."),
+).or(import_zod23.z.nativeEnum(InherentFlags));
+var ZodDate = import_zod23.z.string().date();
+var ActionCreationMetadata = import_zod23.z.object({
+  createdAt: import_zod23.z.string().datetime().describe("The timestamp when the action request was created."),
+  createdBy: import_zod23.z.string().describe("ID of the user who created the action request."),
   createdAtLocation: CreatedAtLocation.describe(
     "Location of the user who created the action request."
   ),
-  createdByUserType: import_zod22.z.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
-  acceptedAt: import_zod22.z.string().datetime().describe("Timestamp when the action request was accepted."),
-  createdByRole: import_zod22.z.string().describe("Role of the user at the time of action request creation."),
-  createdBySignature: import_zod22.z.string().nullish().describe("Signature of the user who created the action request.")
+  createdByUserType: import_zod23.z.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
+  acceptedAt: import_zod23.z.string().datetime().describe("Timestamp when the action request was accepted."),
+  createdByRole: import_zod23.z.string().describe("Role of the user at the time of action request creation."),
+  createdBySignature: import_zod23.z.string().nullish().describe("Signature of the user who created the action request.")
 });
 var RegistrationCreationMetadata = ActionCreationMetadata.extend({
-  registrationNumber: import_zod22.z.string().describe(
+  registrationNumber: import_zod23.z.string().describe(
     "Registration number of the event. Always present for accepted registrations."
   )
 });
-var LegalStatuses = import_zod22.z.object({
+var LegalStatuses = import_zod23.z.object({
   [EventStatus.enum.DECLARED]: ActionCreationMetadata.nullish(),
   [EventStatus.enum.REGISTERED]: RegistrationCreationMetadata.nullish()
 });
-var EventMetadata = import_zod22.z.object({
+var EventMetadata = import_zod23.z.object({
   id: UUID,
-  type: import_zod22.z.string().describe("The type of event, such as birth, death, or marriage."),
+  type: import_zod23.z.string().describe("The type of event, such as birth, death, or marriage."),
   status: EventStatus,
   legalStatuses: LegalStatuses.describe(
     "Metadata related to the legal registration of the event, such as who registered it and when."
   ),
-  createdAt: import_zod22.z.string().datetime().describe("The timestamp when the event was first created and saved."),
+  createdAt: import_zod23.z.string().datetime().describe("The timestamp when the event was first created and saved."),
   dateOfEvent: ZodDate.nullish(),
-  createdBy: import_zod22.z.string().describe("ID of the user who created the event."),
-  createdByUserType: import_zod22.z.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
-  updatedByUserRole: import_zod22.z.string().describe("Role of the user who last changed the status."),
+  createdBy: import_zod23.z.string().describe("ID of the user who created the event."),
+  createdByUserType: import_zod23.z.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
+  updatedByUserRole: import_zod23.z.string().describe("Role of the user who last changed the status."),
   createdAtLocation: CreatedAtLocation.describe(
     "Location of the user who created the event."
   ),
-  createdBySignature: import_zod22.z.string().nullish().describe("Signature of the user who created the event."),
+  createdBySignature: import_zod23.z.string().nullish().describe("Signature of the user who created the event."),
   updatedAtLocation: UUID.nullish().describe(
     "Location of the user who last changed the status."
   ),
-  updatedAt: import_zod22.z.string().datetime().describe(
+  updatedAt: import_zod23.z.string().datetime().describe(
     "Timestamp of the most recent *accepted* status change. Possibly 3rd party update, if action is validation asynchronously."
   ),
-  assignedTo: import_zod22.z.string().nullish().describe("ID of the user currently assigned to the event."),
-  updatedBy: import_zod22.z.string().nullish().describe("ID of the user who last changed the status."),
-  trackingId: import_zod22.z.string().describe(
+  assignedTo: import_zod23.z.string().nullish().describe("ID of the user currently assigned to the event."),
+  updatedBy: import_zod23.z.string().nullish().describe("ID of the user who last changed the status."),
+  trackingId: import_zod23.z.string().describe(
     "System-generated tracking ID used by informants or registrars to look up the event."
   ),
-  flags: import_zod22.z.array(Flag)
+  flags: import_zod23.z.array(Flag)
 });
 var EventMetadataKeysArray = [
   "id",
@@ -3149,7 +3324,7 @@ var EventMetadataKeysArray = [
   "legalStatuses",
   "flags"
 ];
-var EventMetadataKeys = import_zod22.z.enum(EventMetadataKeysArray);
+var EventMetadataKeys = import_zod23.z.enum(EventMetadataKeysArray);
 var eventMetadataLabelMap = {
   "event.assignedTo": {
     id: "event.assignedTo.label",
@@ -3234,11 +3409,11 @@ var WorkqueueColumnKeysArray = [
   "title",
   "outbox"
 ];
-var WorkqueueColumnKeys = import_zod23.z.enum(WorkqueueColumnKeysArray);
-var WorkqueueColumnValue = import_zod23.z.object({
+var WorkqueueColumnKeys = import_zod24.z.enum(WorkqueueColumnKeysArray);
+var WorkqueueColumnValue = import_zod24.z.object({
   $event: WorkqueueColumnKeys
 });
-var WorkqueueColumn = import_zod23.z.object({
+var WorkqueueColumn = import_zod24.z.object({
   label: TranslationConfig,
   value: WorkqueueColumnValue
 });
@@ -3249,115 +3424,127 @@ function defineWorkqueuesColumns(workqueueColumns) {
 }
 
 // ../commons/src/events/CountryConfigQueryInput.ts
-var import_zod25 = require("zod");
+var import_zod26 = require("zod");
 
 // ../commons/src/events/EventIndex.ts
-var import_zod24 = require("zod");
-var import_zod_openapi9 = require("zod-openapi");
-(0, import_zod_openapi9.extendZodWithOpenApi)(import_zod24.z);
+var import_zod25 = require("zod");
+var import_zod_openapi10 = require("zod-openapi");
+(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod25.z);
 var EventIndex = EventMetadata.extend({
   declaration: EventState
 }).openapi({
   ref: "EventIndex"
 });
-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_zod25.z.record(import_zod25.z.string(), import_zod25.z.any()).and(
+  import_zod25.z.object({
+    type: import_zod25.z.string()
     // Ensures "type" (event-id) exists and is a string
   })
 ).openapi({
   ref: "EventSearchIndex"
 });
-var Fuzzy = import_zod24.z.object({ type: import_zod24.z.literal("fuzzy"), term: import_zod24.z.string() }).openapi({
+var Fuzzy = import_zod25.z.object({ type: import_zod25.z.literal("fuzzy"), term: import_zod25.z.string() }).openapi({
   ref: "Fuzzy"
 });
-var Exact = import_zod24.z.object({ type: import_zod24.z.literal("exact"), term: import_zod24.z.string() }).openapi({
+var Exact = import_zod25.z.object({ type: import_zod25.z.literal("exact"), term: import_zod25.z.string() }).openapi({
   ref: "Exact"
 });
-var ExactStatus = import_zod24.z.object({
-  type: import_zod24.z.literal("exact"),
+var ExactStatus = import_zod25.z.object({
+  type: import_zod25.z.literal("exact"),
   term: EventStatus
 }).openapi({
   ref: "ExactStatus"
 });
-var AnyOf = import_zod24.z.object({
-  type: import_zod24.z.literal("anyOf"),
-  terms: import_zod24.z.array(import_zod24.z.string())
+var ExactUserType = import_zod25.z.object({
+  type: import_zod25.z.literal("exact"),
+  term: TokenUserType
+}).openapi({
+  ref: "ExactUserType"
+});
+var AnyOf = import_zod25.z.object({
+  type: import_zod25.z.literal("anyOf"),
+  terms: import_zod25.z.array(import_zod25.z.string())
 }).openapi({
   ref: "AnyOf"
 });
-var AnyOfStatus = import_zod24.z.object({
-  type: import_zod24.z.literal("anyOf"),
-  terms: import_zod24.z.array(EventStatus)
+var AnyOfStatus = import_zod25.z.object({
+  type: import_zod25.z.literal("anyOf"),
+  terms: import_zod25.z.array(EventStatus)
 }).openapi({
   ref: "AnyOfStatus"
 });
-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_zod25.z.object({
+  type: import_zod25.z.literal("range"),
+  gte: import_zod25.z.string(),
+  lte: import_zod25.z.string()
 }).openapi({
   ref: "Range"
 });
-var ContainsFlags = import_zod24.z.object({
-  anyOf: import_zod24.z.array(Flag).optional(),
-  noneOf: import_zod24.z.array(Flag).optional()
+var ContainsFlags = import_zod25.z.object({
+  anyOf: import_zod25.z.array(Flag).optional(),
+  noneOf: import_zod25.z.array(Flag).optional()
 }).openapi({
   ref: "ContainsFlags"
 });
-var Within = import_zod24.z.object({ type: import_zod24.z.literal("within"), location: import_zod24.z.string() }).openapi({
+var Within = import_zod25.z.object({ type: import_zod25.z.literal("within"), location: import_zod25.z.string() }).openapi({
   ref: "Within"
 });
-var RangeDate = Range.extend({
-  gte: import_zod24.z.string().date().or(import_zod24.z.string().datetime()),
-  lte: import_zod24.z.string().date().or(import_zod24.z.string().datetime())
-}).openapi({
-  ref: "RangeDate"
-});
+var RangeDate = import_zod25.z.object({
+  type: import_zod25.z.literal("range"),
+  gte: import_zod25.z.string().date().or(import_zod25.z.string().datetime()),
+  lte: import_zod25.z.string().date().or(import_zod25.z.string().datetime())
+}).openapi({ ref: "RangeDate" });
 var ExactDate = Exact.extend({
-  term: import_zod24.z.string().date().or(import_zod24.z.string().datetime())
+  term: import_zod25.z.string().date().or(import_zod25.z.string().datetime())
 }).openapi({
   ref: "ExactDate"
 });
-var DateCondition = import_zod24.z.union([ExactDate, RangeDate]).openapi({
+var TimePeriod = import_zod25.z.object({
+  type: import_zod25.z.literal("timePeriod"),
+  term: SelectDateRangeValue
+}).openapi({
+  ref: "TimePeriod"
+});
+var DateCondition = import_zod25.z.union([ExactDate, RangeDate, TimePeriod]).openapi({
   ref: "DateCondition"
 });
-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 QueryInput = import_zod25.z.lazy(
+  () => import_zod25.z.union([
+    import_zod25.z.discriminatedUnion("type", [Fuzzy, Exact, Range, Within, AnyOf]),
+    import_zod25.z.record(import_zod25.z.string(), QueryInput)
   ])
 ).openapi({
   ref: "QueryInput"
 });
-var QueryExpression = import_zod24.z.object({
-  id: import_zod24.z.optional(import_zod24.z.string()),
-  eventType: import_zod24.z.string(),
-  status: import_zod24.z.optional(import_zod24.z.union([AnyOfStatus, ExactStatus])),
-  createdAt: import_zod24.z.optional(DateCondition),
-  updatedAt: import_zod24.z.optional(DateCondition),
-  "legalStatus.REGISTERED.createdAt": import_zod24.z.optional(DateCondition),
-  "legalStatus.REGISTERED.createdAtLocation": import_zod24.z.optional(
-    import_zod24.z.union([Within, Exact])
+var QueryExpression = import_zod25.z.object({
+  id: import_zod25.z.optional(import_zod25.z.string()),
+  eventType: import_zod25.z.string(),
+  status: import_zod25.z.optional(import_zod25.z.union([AnyOfStatus, ExactStatus])),
+  createdAt: import_zod25.z.optional(DateCondition),
+  updatedAt: import_zod25.z.optional(DateCondition),
+  "legalStatuses.REGISTERED.acceptedAt": import_zod25.z.optional(DateCondition),
+  "legalStatuses.REGISTERED.createdAtLocation": import_zod25.z.optional(
+    import_zod25.z.union([Within, Exact])
   ),
-  "legalStatus.REGISTERED.registrationNumber": import_zod24.z.optional(Exact),
-  createdAtLocation: import_zod24.z.optional(import_zod24.z.union([Within, Exact])),
-  updatedAtLocation: import_zod24.z.optional(import_zod24.z.union([Within, Exact])),
-  assignedTo: import_zod24.z.optional(Exact),
-  createdByUserType: TokenUserType,
-  createdBy: import_zod24.z.optional(Exact),
-  updatedBy: import_zod24.z.optional(Exact),
-  trackingId: import_zod24.z.optional(Exact),
-  flags: import_zod24.z.optional(ContainsFlags),
+  "legalStatuses.REGISTERED.registrationNumber": import_zod25.z.optional(Exact),
+  createdAtLocation: import_zod25.z.optional(import_zod25.z.union([Within, Exact])),
+  updatedAtLocation: import_zod25.z.optional(import_zod25.z.union([Within, Exact])),
+  assignedTo: import_zod25.z.optional(Exact),
+  createdByUserType: import_zod25.z.optional(ExactUserType),
+  createdBy: import_zod25.z.optional(Exact),
+  updatedBy: import_zod25.z.optional(Exact),
+  trackingId: import_zod25.z.optional(Exact),
+  flags: import_zod25.z.optional(ContainsFlags),
+  // @todo: The type for this comes out as "any"
   data: QueryInput
 }).partial().refine((obj) => Object.values(obj).some((val) => val !== void 0), {
   message: "At least one query field must be specified."
 }).openapi({
   ref: "QueryExpression"
 });
-var QueryType = import_zod24.z.object({
-  type: import_zod24.z.literal("and").or(import_zod24.z.literal("or")).openapi({ default: "and" }),
-  clauses: import_zod24.z.preprocess(
+var QueryType = import_zod25.z.object({
+  type: import_zod25.z.literal("and").or(import_zod25.z.literal("or")).openapi({ default: "and" }),
+  clauses: import_zod25.z.preprocess(
     (val) => {
       if (typeof val === "string") {
         return [JSON.parse(val)];
@@ -3367,7 +3554,7 @@ var QueryType = import_zod24.z.object({
       }
       return val;
     },
-    import_zod24.z.array(QueryExpression).nonempty("At least one clause is required.").openapi({
+    import_zod25.z.array(QueryExpression).nonempty("At least one clause is required.").openapi({
       default: [
         {
           eventType: TENNIS_CLUB_MEMBERSHIP,
@@ -3388,58 +3575,62 @@ var QueryType = import_zod24.z.object({
 }).openapi({
   ref: "QueryType"
 });
+var SearchScopeAccessLevels = {
+  MY_JURISDICTION: "my-jurisdiction",
+  ALL: "all"
+};
 
 // ../commons/src/events/CountryConfigQueryInput.ts
-var SerializableExact = import_zod25.z.object({
-  type: import_zod25.z.literal("exact"),
-  term: import_zod25.z.union([import_zod25.z.string(), SerializedUserField])
+var SerializableExact = import_zod26.z.object({
+  type: import_zod26.z.literal("exact"),
+  term: import_zod26.z.union([import_zod26.z.string(), SerializedUserField])
 });
-var SerializableWithin = import_zod25.z.object({
-  type: import_zod25.z.literal("within"),
-  location: import_zod25.z.union([import_zod25.z.string(), SerializedUserField])
+var SerializableWithin = import_zod26.z.object({
+  type: import_zod26.z.literal("within"),
+  location: import_zod26.z.union([import_zod26.z.string(), SerializedUserField])
 });
-var SerializedQueryExpression = import_zod25.z.object({
-  eventType: import_zod25.z.string(),
-  status: import_zod25.z.optional(import_zod25.z.union([AnyOfStatus, ExactStatus])),
-  createdAt: import_zod25.z.optional(DateCondition),
-  updatedAt: import_zod25.z.optional(DateCondition),
-  "legalStatus.REGISTERED.createdAt": import_zod25.z.optional(DateCondition),
-  "legalStatus.REGISTERED.createdAtLocation": import_zod25.z.optional(
-    import_zod25.z.union([Within, Exact])
+var SerializedQueryExpression = import_zod26.z.object({
+  eventType: import_zod26.z.string(),
+  status: import_zod26.z.optional(import_zod26.z.union([AnyOfStatus, ExactStatus])),
+  createdAt: import_zod26.z.optional(DateCondition),
+  updatedAt: import_zod26.z.optional(DateCondition),
+  "legalStatuses.REGISTERED.createdAt": import_zod26.z.optional(DateCondition),
+  "legalStatuses.REGISTERED.createdAtLocation": import_zod26.z.optional(
+    import_zod26.z.union([Within, Exact])
   ),
-  "legalStatus.REGISTERED.registrationNumber": import_zod25.z.optional(Exact),
-  createdAtLocation: import_zod25.z.optional(
-    import_zod25.z.union([SerializableWithin, SerializableExact])
+  "legalStatuses.REGISTERED.registrationNumber": import_zod26.z.optional(Exact),
+  createdAtLocation: import_zod26.z.optional(
+    import_zod26.z.union([SerializableWithin, SerializableExact])
   ),
-  updatedAtLocation: import_zod25.z.optional(
-    import_zod25.z.union([SerializableWithin, SerializableExact])
+  updatedAtLocation: import_zod26.z.optional(
+    import_zod26.z.union([SerializableWithin, SerializableExact])
   ),
-  assignedTo: import_zod25.z.optional(SerializableExact),
-  createdBy: import_zod25.z.optional(SerializableExact),
-  createdByUserType: TokenUserType,
-  updatedBy: import_zod25.z.optional(SerializableExact),
-  trackingId: import_zod25.z.optional(Exact),
-  flags: import_zod25.z.optional(ContainsFlags),
+  assignedTo: import_zod26.z.optional(SerializableExact),
+  createdBy: import_zod26.z.optional(SerializableExact),
+  createdByUserType: ExactUserType,
+  updatedBy: import_zod26.z.optional(SerializableExact),
+  trackingId: import_zod26.z.optional(Exact),
+  flags: import_zod26.z.optional(ContainsFlags),
   data: QueryInput
 }).partial();
-var Or2 = import_zod25.z.object({
-  type: import_zod25.z.literal("or"),
-  clauses: import_zod25.z.array(SerializedQueryExpression)
+var Or2 = import_zod26.z.object({
+  type: import_zod26.z.literal("or"),
+  clauses: import_zod26.z.array(SerializedQueryExpression)
 });
-var And2 = import_zod25.z.object({
-  type: import_zod25.z.literal("and"),
-  clauses: import_zod25.z.array(SerializedQueryExpression)
+var And2 = import_zod26.z.object({
+  type: import_zod26.z.literal("and"),
+  clauses: import_zod26.z.array(SerializedQueryExpression)
 });
-var CountryConfigQueryType = import_zod25.z.discriminatedUnion("type", [And2, Or2]);
-var CountryConfigQueryInputType = import_zod25.z.union([
+var CountryConfigQueryType = import_zod26.z.discriminatedUnion("type", [And2, Or2]);
+var CountryConfigQueryInputType = import_zod26.z.union([
   SerializedQueryExpression,
   And2,
   Or2
 ]);
 
 // ../commons/src/icons.ts
-var import_zod26 = require("zod");
-var AvailableIcons = import_zod26.z.enum([
+var import_zod27 = require("zod");
+var AvailableIcons = import_zod27.z.enum([
   "Archived",
   "Assigned",
   "Certified",
@@ -3477,7 +3668,6 @@ var AvailableIcons = import_zod26.z.enum([
   "Copy",
   "Database",
   "DotsThreeVertical",
-  "DownloadSimple",
   "ArrowCounterClockwise",
   "MagnifyingGlassMinus",
   "MagnifyingGlassPlus",
@@ -3561,42 +3751,42 @@ var mandatoryColumns = defineWorkqueuesColumns([
     value: event.field("updatedAt")
   }
 ]);
-var WorkqueueActionsWithDefault = import_zod27.z.enum([
+var WorkqueueActionsWithDefault = import_zod28.z.enum([
   ...workqueueActions.options,
   "DEFAULT"
 ]);
-var WorkqueueConfig = import_zod27.z.object({
-  slug: import_zod27.z.string().describe("Determines the url of the workqueue."),
+var WorkqueueConfig = import_zod28.z.object({
+  slug: import_zod28.z.string().describe("Determines the url of the workqueue."),
   name: TranslationConfig.describe(
     "Title of the workflow (both in navigation and on the page)"
   ),
   query: CountryConfigQueryType,
-  actions: import_zod27.z.array(
-    import_zod27.z.object({
+  actions: import_zod28.z.array(
+    import_zod28.z.object({
       type: WorkqueueActionsWithDefault,
-      conditionals: import_zod27.z.array(Conditional).optional()
+      conditionals: import_zod28.z.array(Conditional).optional()
     })
   ),
-  columns: import_zod27.z.array(WorkqueueColumn).default(mandatoryColumns),
+  columns: import_zod28.z.array(WorkqueueColumn).default(mandatoryColumns),
   icon: AvailableIcons
 }).describe("Configuration for workqueue.");
 var WorkqueueConfigWithoutQuery = WorkqueueConfig.omit({
   query: true,
   columns: true
 });
-var WorkqueueConfigInput = import_zod27.z.object({
-  slug: import_zod27.z.string().describe("Determines the url of the workqueue."),
+var WorkqueueConfigInput = import_zod28.z.object({
+  slug: import_zod28.z.string().describe("Determines the url of the workqueue."),
   name: TranslationConfig.describe(
     "Title of the workflow (both in navigation and on the page)"
   ),
   query: CountryConfigQueryInputType,
-  actions: import_zod27.z.array(
-    import_zod27.z.object({
+  actions: import_zod28.z.array(
+    import_zod28.z.object({
       type: WorkqueueActionsWithDefault,
-      conditionals: import_zod27.z.array(Conditional).optional()
+      conditionals: import_zod28.z.array(Conditional).optional()
     })
   ),
-  columns: import_zod27.z.array(WorkqueueColumn).default(mandatoryColumns),
+  columns: import_zod28.z.array(WorkqueueColumn).default(mandatoryColumns),
   icon: AvailableIcons
 });
 function defineWorkqueue(workqueueInput) {
@@ -3607,10 +3797,10 @@ function defineWorkqueue(workqueueInput) {
 function defineWorkqueues(workqueues) {
   return workqueues.map((workqueue) => defineWorkqueue(workqueue));
 }
-var WorkqueueCountInput = import_zod27.z.array(
-  import_zod27.z.object({ slug: import_zod27.z.string(), query: QueryType })
+var WorkqueueCountInput = import_zod28.z.array(
+  import_zod28.z.object({ slug: import_zod28.z.string(), query: QueryType })
 );
-var WorkqueueCountOutput = import_zod27.z.record(import_zod27.z.string(), import_zod27.z.number());
+var WorkqueueCountOutput = import_zod28.z.record(import_zod28.z.string(), import_zod28.z.number());
 
 // ../commons/src/events/workqueueDefaultColumns.ts
 var defaultWorkqueueColumns = [
@@ -3633,42 +3823,42 @@ var defaultWorkqueueColumns = [
 ];
 
 // ../commons/src/events/Draft.ts
-var import_zod29 = require("zod");
+var import_zod30 = require("zod");
 
 // ../commons/src/events/ActionInput.ts
-var import_zod28 = require("zod");
-var import_zod_openapi10 = require("zod-openapi");
-(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod28.z);
-var BaseActionInput = import_zod28.z.object({
+var import_zod29 = require("zod");
+var import_zod_openapi11 = require("zod-openapi");
+(0, import_zod_openapi11.extendZodWithOpenApi)(import_zod29.z);
+var BaseActionInput = import_zod29.z.object({
   eventId: UUID,
-  transactionId: import_zod28.z.string(),
+  transactionId: import_zod29.z.string(),
   declaration: ActionUpdate.default({}),
   annotation: ActionUpdate.optional(),
   originalActionId: UUID.optional(),
   // should not be part of base action.
-  keepAssignment: import_zod28.z.boolean().optional()
+  keepAssignment: import_zod29.z.boolean().optional()
 });
 var CreateActionInput = BaseActionInput.merge(
-  import_zod28.z.object({
-    type: import_zod28.z.literal(ActionType.CREATE).default(ActionType.CREATE),
+  import_zod29.z.object({
+    type: import_zod29.z.literal(ActionType.CREATE).default(ActionType.CREATE),
     createdAtLocation: CreatedAtLocation
   })
 );
 var RegisterActionInput = BaseActionInput.merge(
-  import_zod28.z.object({
-    type: import_zod28.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
-    registrationNumber: import_zod28.z.string().optional()
+  import_zod29.z.object({
+    type: import_zod29.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
+    registrationNumber: import_zod29.z.string().optional()
   })
 ).strict();
 var ValidateActionInput = BaseActionInput.merge(
-  import_zod28.z.object({
-    type: import_zod28.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
-    duplicates: import_zod28.z.array(import_zod28.z.string())
+  import_zod29.z.object({
+    type: import_zod29.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
+    duplicates: import_zod29.z.array(import_zod29.z.string())
   })
 );
 var NotifyActionInput = BaseActionInput.merge(
-  import_zod28.z.object({
-    type: import_zod28.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
+  import_zod29.z.object({
+    type: import_zod29.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
   })
 ).openapi({
   default: {
@@ -3680,68 +3870,68 @@ var NotifyActionInput = BaseActionInput.merge(
   }
 });
 var DeclareActionInput = BaseActionInput.merge(
-  import_zod28.z.object({
-    type: import_zod28.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
+  import_zod29.z.object({
+    type: import_zod29.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
   })
 );
 var PrintCertificateActionInput = BaseActionInput.merge(
-  import_zod28.z.object({
-    type: import_zod28.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
+  import_zod29.z.object({
+    type: import_zod29.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RejectDeclarationActionInput = BaseActionInput.merge(
-  import_zod28.z.object({
-    type: import_zod28.z.literal(ActionType.REJECT).default(ActionType.REJECT),
+  import_zod29.z.object({
+    type: import_zod29.z.literal(ActionType.REJECT).default(ActionType.REJECT),
     reason: RejectionReason
   })
 );
 var MarkedAsDuplicateActionInput = BaseActionInput.merge(
-  import_zod28.z.object({
-    type: import_zod28.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
+  import_zod29.z.object({
+    type: import_zod29.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveActionInput = BaseActionInput.merge(
-  import_zod28.z.object({
-    type: import_zod28.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE),
+  import_zod29.z.object({
+    type: import_zod29.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE),
     reason: RejectionReason
   })
 );
 var AssignActionInput = BaseActionInput.merge(
-  import_zod28.z.object({
-    type: import_zod28.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
-    assignedTo: import_zod28.z.string()
+  import_zod29.z.object({
+    type: import_zod29.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
+    assignedTo: import_zod29.z.string()
   })
 );
 var UnassignActionInput = BaseActionInput.merge(
-  import_zod28.z.object({
-    type: import_zod28.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
-    assignedTo: import_zod28.z.literal(null).default(null)
+  import_zod29.z.object({
+    type: import_zod29.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
+    assignedTo: import_zod29.z.literal(null).default(null)
   })
 );
 var RequestCorrectionActionInput = BaseActionInput.merge(
-  import_zod28.z.object({
-    type: import_zod28.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
+  import_zod29.z.object({
+    type: import_zod29.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
   })
 );
 var RejectCorrectionActionInput = BaseActionInput.merge(
-  import_zod28.z.object({
-    requestId: import_zod28.z.string(),
-    type: import_zod28.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
+  import_zod29.z.object({
+    requestId: import_zod29.z.string(),
+    type: import_zod29.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
   })
 );
 var ApproveCorrectionActionInput = BaseActionInput.merge(
-  import_zod28.z.object({
-    requestId: import_zod28.z.string(),
-    type: import_zod28.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
+  import_zod29.z.object({
+    requestId: import_zod29.z.string(),
+    type: import_zod29.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
   })
 );
 var ReadActionInput = BaseActionInput.merge(
-  import_zod28.z.object({
-    type: import_zod28.z.literal(ActionType.READ).default(ActionType.READ)
+  import_zod29.z.object({
+    type: import_zod29.z.literal(ActionType.READ).default(ActionType.READ)
   })
 );
-var DeleteActionInput = import_zod28.z.object({ eventId: UUID });
-var ActionInput = import_zod28.z.discriminatedUnion("type", [
+var DeleteActionInput = import_zod29.z.object({ eventId: UUID });
+var ActionInput = import_zod29.z.discriminatedUnion("type", [
   CreateActionInput.openapi({ ref: "CreateActionInput" }),
   ValidateActionInput.openapi({ ref: "ValidateActionInput" }),
   RegisterActionInput.openapi({ ref: "RegisterActionInput" }),
@@ -3770,18 +3960,18 @@ var ActionInput = import_zod28.z.discriminatedUnion("type", [
 });
 
 // ../commons/src/events/Draft.ts
-var Draft = import_zod29.z.object({
+var Draft = import_zod30.z.object({
   id: UUID,
   eventId: UUID,
-  transactionId: import_zod29.z.string(),
-  createdAt: import_zod29.z.string().datetime(),
+  transactionId: import_zod30.z.string(),
+  createdAt: import_zod30.z.string().datetime(),
   action: ActionBase.extend({
     type: ActionTypes
   }).omit({ id: true })
 });
 var DraftInput = BaseActionInput.extend({
   type: ActionTypes,
-  status: import_zod29.z.enum([
+  status: import_zod30.z.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
@@ -3789,27 +3979,28 @@ var DraftInput = BaseActionInput.extend({
 });
 
 // ../commons/src/events/EventInput.ts
-var import_zod30 = require("zod");
+var import_zod31 = require("zod");
 var import_uuid8 = require("uuid");
-var EventInput = import_zod30.z.object({
-  transactionId: import_zod30.z.string(),
-  type: import_zod30.z.string()
+var EventInput = import_zod31.z.object({
+  transactionId: import_zod31.z.string(),
+  type: import_zod31.z.string()
 }).openapi({ default: { transactionId: (0, import_uuid8.v4)(), type: "v2.birth" } });
 
 // ../commons/src/events/EventDocument.ts
-var import_zod31 = require("zod");
-var import_zod_openapi11 = require("zod-openapi");
-(0, import_zod_openapi11.extendZodWithOpenApi)(import_zod31.z);
-var EventDocument = import_zod31.z.object({
+var import_zod32 = require("zod");
+var import_zod_openapi12 = require("zod-openapi");
+(0, import_zod_openapi12.extendZodWithOpenApi)(import_zod32.z);
+var EventDocument = import_zod32.z.object({
   id: UUID,
-  type: import_zod31.z.string(),
-  createdAt: import_zod31.z.string().datetime(),
-  updatedAt: import_zod31.z.string().datetime(),
-  actions: import_zod31.z.array(Action),
-  trackingId: import_zod31.z.string()
+  type: import_zod32.z.string(),
+  createdAt: import_zod32.z.string().datetime(),
+  updatedAt: import_zod32.z.string().datetime(),
+  actions: import_zod32.z.array(Action),
+  trackingId: import_zod32.z.string()
 }).openapi({ ref: "EventDocument" });
 
 // ../commons/src/events/state/utils.ts
+var import_lodash2 = require("lodash");
 function getActionRequests(actionType, actions) {
   const filtered = actions.filter((action) => action.type === actionType);
   const accept = filtered.find(
@@ -3848,29 +4039,38 @@ function getDeclarationActionCreationMetadata(actionType, actions) {
     registrationNumber
   };
 }
+var updateActions = ActionTypes.extract([
+  ActionType.CREATE,
+  ActionType.NOTIFY,
+  ActionType.DECLARE,
+  ActionType.VALIDATE,
+  ActionType.REGISTER,
+  ActionType.REJECT,
+  ActionType.ARCHIVE,
+  ActionType.PRINT_CERTIFICATE,
+  ActionType.REQUEST_CORRECTION
+]);
 function getActionUpdateMetadata(actions) {
   const createAction = getOrThrow(
     actions.find((action) => action.type === ActionType.CREATE),
     `Event has no ${ActionType.CREATE} action`
   );
-  return StatusChangingActions.options.reduce(
-    (metadata, actionType) => {
-      const { accept, request } = getActionRequests(actionType, actions);
-      return {
-        createdAt: request?.createdAt ?? accept?.createdAt ?? metadata.createdAt,
-        createdBy: request?.createdBy ?? accept?.createdBy ?? metadata.createdBy,
-        createdByUserType: request?.createdByUserType ?? accept?.createdByUserType ?? metadata.createdByUserType,
-        createdAtLocation: request?.createdAtLocation ?? accept?.createdAtLocation ?? metadata.createdAtLocation,
-        createdByRole: request?.createdByRole ?? accept?.createdByRole ?? metadata.createdByRole
-      };
+  const metadataFields = [
+    "createdAt",
+    "createdBy",
+    "createdByUserType",
+    "createdAtLocation",
+    "createdByRole"
+  ];
+  return actions.filter(({ type }) => updateActions.safeParse(type).success).filter(({ status }) => status === ActionStatus.Accepted).reduce(
+    (_, action) => {
+      if (action.originalActionId) {
+        const originalAction = actions.find(({ id }) => id === action.originalActionId) ?? action;
+        return (0, import_lodash2.pick)(originalAction, metadataFields);
+      }
+      return (0, import_lodash2.pick)(action, metadataFields);
     },
-    {
-      createdAt: createAction.createdAt,
-      createdBy: createAction.createdBy,
-      createdByUserType: createAction.createdByUserType,
-      createdAtLocation: createAction.createdAtLocation,
-      createdByRole: createAction.createdByRole
-    }
+    (0, import_lodash2.pick)(createAction, metadataFields)
   );
 }
 function getLegalStatuses(actions) {
@@ -3916,7 +4116,7 @@ function isDeclarationIncomplete(actions) {
   return getStatusFromActions(actions) === EventStatus.enum.NOTIFIED;
 }
 function isRejected(actions) {
-  return getStatusFromActions(actions) === EventStatus.enum.REJECTED;
+  return actions.at(-1)?.type === ActionType.REJECT;
 }
 function getFlagsFromActions(actions) {
   const sortedActions = actions.filter(({ type }) => !isMetaAction(type)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
@@ -3958,8 +4158,6 @@ function getStatusFromActions(actions) {
         return EventStatus.enum.VALIDATED;
       case ActionType.REGISTER:
         return EventStatus.enum.REGISTERED;
-      case ActionType.REJECT:
-        return EventStatus.enum.REJECTED;
       case ActionType.ARCHIVE:
         return EventStatus.enum.ARCHIVED;
       case ActionType.NOTIFY:
@@ -3968,6 +4166,7 @@ function getStatusFromActions(actions) {
         return EventStatus.enum.CERTIFIED;
       case ActionType.ASSIGN:
       case ActionType.UNASSIGN:
+      case ActionType.REJECT:
       case ActionType.REQUEST_CORRECTION:
       case ActionType.APPROVE_CORRECTION:
       case ActionType.MARKED_AS_DUPLICATE:
@@ -4003,7 +4202,8 @@ function getAssignedUserSignatureFromActions(actions) {
 function aggregateActionDeclarations(actions) {
   const excludedActions = [
     ActionType.REQUEST_CORRECTION,
-    ActionType.PRINT_CERTIFICATE
+    ActionType.PRINT_CERTIFICATE,
+    ActionType.REJECT_CORRECTION
   ];
   return actions.reduce((declaration, action) => {
     if (excludedActions.some((excludedAction) => excludedAction === action.type)) {
@@ -4044,6 +4244,13 @@ function getAcceptedActions(event2) {
   );
 }
 var DEFAULT_DATE_OF_EVENT_PROPERTY = "createdAt";
+function resolveDateOfEvent(eventMetadata, declaration, config) {
+  if (!config.dateOfEvent) {
+    return eventMetadata[DEFAULT_DATE_OF_EVENT_PROPERTY].split("T")[0];
+  }
+  const parsedDate = ZodDate.safeParse(declaration[config.dateOfEvent.$$field]);
+  return parsedDate.success ? parsedDate.data : void 0;
+}
 function getCurrentEventState(event2, config) {
   const creationAction = event2.actions.find(
     (action) => action.type === ActionType.CREATE
@@ -4057,17 +4264,6 @@ function getCurrentEventState(event2, config) {
   const requestActionMetadata = getActionUpdateMetadata(event2.actions);
   const acceptedActionMetadata = getActionUpdateMetadata(acceptedActions);
   const declaration = aggregateActionDeclarations(acceptedActions);
-  let dateOfEvent;
-  if (config.dateOfEvent) {
-    const parsedDate = ZodDate.safeParse(
-      declaration[config.dateOfEvent.$$field]
-    );
-    if (parsedDate.success) {
-      dateOfEvent = parsedDate.data;
-    }
-  } else {
-    dateOfEvent = event2[DEFAULT_DATE_OF_EVENT_PROPERTY].split("T")[0];
-  }
   return deepDropNulls({
     id: event2.id,
     type: event2.type,
@@ -4086,7 +4282,7 @@ function getCurrentEventState(event2, config) {
     declaration,
     trackingId: event2.trackingId,
     updatedByUserRole: requestActionMetadata.createdByRole,
-    dateOfEvent,
+    dateOfEvent: resolveDateOfEvent(event2, declaration, config),
     flags: getFlagsFromActions(event2.actions)
   });
 }
@@ -4115,19 +4311,32 @@ function getCurrentEventStateWithDrafts({
   };
   return getCurrentEventState(withDrafts, configuration);
 }
-function applyDraftsToEventIndex(eventIndex, drafts) {
+function applyDeclarationToEventIndex(eventIndex, declaration, eventConfiguration) {
+  const updatedDeclaration = deepMerge(eventIndex.declaration, declaration);
+  return {
+    ...eventIndex,
+    dateOfEvent: resolveDateOfEvent(
+      eventIndex,
+      updatedDeclaration,
+      eventConfiguration
+    ),
+    declaration: updatedDeclaration
+  };
+}
+function applyDraftsToEventIndex(eventIndex, drafts, eventConfiguration) {
   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
-    }
-  };
+  return applyDeclarationToEventIndex(
+    {
+      ...eventIndex,
+      updatedAt: activeDrafts[activeDrafts.length - 1].createdAt
+    },
+    activeDrafts[activeDrafts.length - 1].declaration,
+    eventConfiguration
+  );
 }
 function getAnnotationFromDrafts(drafts) {
   const actions = drafts.map((draft) => draft.action);
@@ -4168,23 +4377,24 @@ function generateTransactionId() {
 }
 
 // ../commons/src/events/User.ts
-var import_zod32 = require("zod");
-var User = import_zod32.z.object({
-  id: import_zod32.z.string(),
-  name: import_zod32.z.array(
-    import_zod32.z.object({
-      use: import_zod32.z.string(),
-      given: import_zod32.z.array(import_zod32.z.string()),
-      family: import_zod32.z.string()
+var import_zod33 = require("zod");
+var User = import_zod33.z.object({
+  id: import_zod33.z.string(),
+  name: import_zod33.z.array(
+    import_zod33.z.object({
+      use: import_zod33.z.string(),
+      given: import_zod33.z.array(import_zod33.z.string()),
+      family: import_zod33.z.string()
     })
   ),
-  role: import_zod32.z.string(),
-  signatureFilename: import_zod32.z.string().optional()
+  role: import_zod33.z.string(),
+  avatar: FullDocumentPath.optional(),
+  signature: FullDocumentPath.optional()
 });
 
 // ../commons/src/events/test.utils.ts
-var import_lodash2 = require("lodash");
-var import_addDays = __toESM(require("date-fns/addDays"));
+var import_lodash3 = require("lodash");
+var import_date_fns4 = require("date-fns");
 
 // ../commons/src/field-config/field-configuration.ts
 function createFieldConfig(fieldId, options) {
@@ -4205,7 +4415,7 @@ function field(fieldId, options = {}) {
 }
 
 // ../commons/src/fixtures/forms.ts
-var import_date_fns2 = require("date-fns");
+var import_date_fns3 = require("date-fns");
 var PRINT_CERTIFICATE_FORM = defineActionForm({
   label: {
     id: "v2.event.tennis-club-membership.action.certificate.form.label",
@@ -4924,6 +5134,7 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
           id: "applicant.email",
           type: "EMAIL",
           required: false,
+          uncorrectable: true,
           conditionals: [],
           label: {
             defaultMessage: "Applicant's email",
@@ -5003,6 +5214,7 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
           id: "applicant.address",
           type: "ADDRESS",
           required: true,
+          secured: true,
           conditionals: [],
           label: {
             defaultMessage: "Applicant's address",
@@ -5147,7 +5359,7 @@ var statusOptions = [
     }
   },
   {
-    value: EventStatus.enum.REJECTED,
+    value: VisibleStatus.enum.REJECTED,
     label: {
       defaultMessage: "Rejected",
       description: "Option for form field: status of record",
@@ -5170,7 +5382,7 @@ var timePeriodOptions = [
       description: "Label for option of time period select: last 7 days",
       id: "form.section.label.timePeriodLast7Days"
     },
-    value: `${(0, import_date_fns2.format)((0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 7), "yyyy-MM-dd")},${(0, import_date_fns2.format)(
+    value: `${(0, import_date_fns3.format)((0, import_date_fns3.subDays)(/* @__PURE__ */ new Date(), 7), "yyyy-MM-dd")},${(0, import_date_fns3.format)(
       /* @__PURE__ */ new Date(),
       "yyyy-MM-dd"
     )}`
@@ -5181,7 +5393,7 @@ var timePeriodOptions = [
       description: "Label for option of time period select: last 30 days",
       id: "form.section.label.timePeriodLast30Days"
     },
-    value: `${(0, import_date_fns2.format)((0, import_date_fns2.subMonths)(/* @__PURE__ */ new Date(), 1), "yyyy-MM-dd")},${(0, import_date_fns2.format)(
+    value: `${(0, import_date_fns3.format)((0, import_date_fns3.subMonths)(/* @__PURE__ */ new Date(), 1), "yyyy-MM-dd")},${(0, import_date_fns3.format)(
       /* @__PURE__ */ new Date(),
       "yyyy-MM-dd"
     )}`
@@ -5192,7 +5404,7 @@ var timePeriodOptions = [
       description: "Label for option of time period select: last 90 days",
       id: "form.section.label.timePeriodLast90Days"
     },
-    value: `${(0, import_date_fns2.format)((0, import_date_fns2.subQuarters)(/* @__PURE__ */ new Date(), 1), "yyyy-MM-dd")},${(0, import_date_fns2.format)(
+    value: `${(0, import_date_fns3.format)((0, import_date_fns3.subQuarters)(/* @__PURE__ */ new Date(), 1), "yyyy-MM-dd")},${(0, import_date_fns3.format)(
       /* @__PURE__ */ new Date(),
       "yyyy-MM-dd"
     )}`
@@ -5203,7 +5415,7 @@ var timePeriodOptions = [
       description: "Label for option of time period select: last year",
       id: "form.section.label.timePeriodLastYear"
     },
-    value: `${(0, import_date_fns2.format)((0, import_date_fns2.subYears)(/* @__PURE__ */ new Date(), 1), "yyyy-MM-dd")},${(0, import_date_fns2.format)(
+    value: `${(0, import_date_fns3.format)((0, import_date_fns3.subYears)(/* @__PURE__ */ new Date(), 1), "yyyy-MM-dd")},${(0, import_date_fns3.format)(
       /* @__PURE__ */ new Date(),
       "yyyy-MM-dd"
     )}`
@@ -5287,197 +5499,202 @@ 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"
       },
-      onboardingForm: [
-        {
-          id: "correction-requester",
-          type: PageTypes.enum.FORM,
-          title: {
-            id: "event.tennis-club-membership.action.requestCorrection.form.section.corrector",
-            defaultMessage: "Correction requester",
-            description: "This is the title of the section"
-          },
-          fields: [
-            {
-              id: "correction.requester.relationshop.intro",
-              type: "PAGE_HEADER",
-              label: {
-                id: "correction.requester.relationshop.intro.label",
-                defaultMessage: "Note: In the case that the child is now of legal age (18) then only they should be able to request a change to their birth record.",
-                description: "The title for the corrector form"
-              }
+      correctionForm: {
+        label: {
+          id: "v2.event.tennis-club-membership.action.request-correction.label",
+          defaultMessage: "Request correction",
+          description: "This is shown as the action name anywhere the user can trigger the action from"
+        },
+        pages: [
+          {
+            id: "correction-requester",
+            type: PageTypes.enum.FORM,
+            title: {
+              id: "event.tennis-club-membership.action.requestCorrection.form.section.corrector",
+              defaultMessage: "Correction requester",
+              description: "This is the title of the section"
             },
-            {
-              id: "correction.requester.relationship",
-              type: "RADIO_GROUP",
-              label: {
-                id: "v2.correction.corrector.title",
-                defaultMessage: "Who is requesting a change to this record?",
-                description: "The title for the corrector form"
+            fields: [
+              {
+                id: "correction.requester.relationshop.intro",
+                type: "PAGE_HEADER",
+                label: {
+                  id: "correction.requester.relationshop.intro.label",
+                  defaultMessage: "Note: In the case that the child is now of legal age (18) then only they should be able to request a change to their birth record.",
+                  description: "The title for the corrector form"
+                }
               },
-              defaultValue: "",
-              options: [
-                {
-                  value: "INFORMANT",
-                  label: {
-                    id: "v2.correction.corrector.informant",
-                    defaultMessage: "Informant",
-                    description: "Label for informant option in certificate correction form"
-                  }
-                },
-                {
-                  value: "ANOTHER_AGENT",
-                  label: {
-                    id: "v2.correction.corrector.anotherAgent",
-                    defaultMessage: "Another registration agent or field agent",
-                    description: "Label for another registration or field agent option in certificate correction form"
-                  }
-                },
-                {
-                  value: "REGISTRAR",
-                  label: {
-                    id: "v2.correction.corrector.me",
-                    defaultMessage: "Me (Registrar)",
-                    description: "Label for registrar option in certificate correction form"
-                  }
+              {
+                id: "correction.requester.relationship",
+                type: "RADIO_GROUP",
+                label: {
+                  id: "v2.correction.corrector.title",
+                  defaultMessage: "Who is requesting a change to this record?",
+                  description: "The title for the corrector form"
                 },
-                {
-                  value: "OTHER",
-                  label: {
-                    id: "v2.correction.corrector.others",
-                    defaultMessage: "Someone else",
-                    description: "Label for someone else option in certificate correction form"
+                defaultValue: "",
+                options: [
+                  {
+                    value: "INFORMANT",
+                    label: {
+                      id: "v2.correction.corrector.informant",
+                      defaultMessage: "Informant",
+                      description: "Label for informant option in certificate correction form"
+                    }
+                  },
+                  {
+                    value: "ANOTHER_AGENT",
+                    label: {
+                      id: "v2.correction.corrector.anotherAgent",
+                      defaultMessage: "Another registration agent or field agent",
+                      description: "Label for another registration or field agent option in certificate correction form"
+                    }
+                  },
+                  {
+                    value: "REGISTRAR",
+                    label: {
+                      id: "v2.correction.corrector.me",
+                      defaultMessage: "Me (Registrar)",
+                      description: "Label for registrar option in certificate correction form"
+                    }
+                  },
+                  {
+                    value: "OTHER",
+                    label: {
+                      id: "v2.correction.corrector.others",
+                      defaultMessage: "Someone else",
+                      description: "Label for someone else option in certificate correction form"
+                    }
                   }
-                }
-              ]
-            }
-          ]
-        },
-        {
-          id: "identity-check",
-          type: PageTypes.enum.FORM,
-          title: {
-            id: "event.tennis-club-membership.action.requestCorrection.form.section.verify",
-            defaultMessage: "Verify their identity",
-            description: "This is the title of the section"
-          },
-          fields: [
-            {
-              id: "correction.identity-check.instructions",
-              type: "PAGE_HEADER",
-              label: {
-                id: "correction.corrector.identity.instruction",
-                defaultMessage: "Please verify the identity of the person making this request",
-                description: "The title for the corrector form"
+                ]
               }
+            ]
+          },
+          {
+            id: "identity-check",
+            type: PageTypes.enum.FORM,
+            title: {
+              id: "event.tennis-club-membership.action.requestCorrection.form.section.verify",
+              defaultMessage: "Verify their identity",
+              description: "This is the title of the section"
             },
-            {
-              id: "correction.identity-check.verified",
-              type: "RADIO_GROUP",
-              label: {
-                id: "correction.corrector.identity.verified.label",
-                defaultMessage: "Identity verified",
-                description: "The title for the corrector form"
+            fields: [
+              {
+                id: "correction.identity-check.instructions",
+                type: "PAGE_HEADER",
+                label: {
+                  id: "correction.corrector.identity.instruction",
+                  defaultMessage: "Please verify the identity of the person making this request",
+                  description: "The title for the corrector form"
+                }
               },
-              defaultValue: "",
-              required: true,
-              options: [
-                {
-                  value: "VERIFIED",
-                  label: {
-                    id: "correction.corrector.identity.verified",
-                    defaultMessage: "I have verified their identity",
-                    description: "Label for verified option in corrector identity check page"
+              {
+                id: "correction.identity-check.verified",
+                type: "RADIO_GROUP",
+                label: {
+                  id: "correction.corrector.identity.verified.label",
+                  defaultMessage: "Identity verified",
+                  description: "The title for the corrector form"
+                },
+                defaultValue: "",
+                required: true,
+                options: [
+                  {
+                    value: "VERIFIED",
+                    label: {
+                      id: "correction.corrector.identity.verified",
+                      defaultMessage: "I have verified their identity",
+                      description: "Label for verified option in corrector identity check page"
+                    }
                   }
-                }
-              ]
-            }
-          ]
-        }
-      ],
-      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",
-            description: "This is the title of the section"
-          },
-          fields: [
-            {
-              id: "correction.supportingDocs.introduction",
-              type: "PAGE_HEADER",
-              label: {
-                id: "correction.corrector.paragraph.title",
-                defaultMessage: "For all record corrections at a minimum an affidavit must be provided. For material errors and omissions eg. in paternity cases, a court order must also be provided.",
-                description: "The title for the corrector form"
-              }
-            },
-            {
-              id: "correction.supportingDocs",
-              type: FieldType.FILE,
-              label: {
-                id: "correction.corrector.title",
-                defaultMessage: "Upload supporting documents",
-                description: "The title for the corrector form"
+                ]
               }
+            ]
+          },
+          {
+            id: "correction-request.supporting-documents",
+            type: PageTypes.enum.FORM,
+            title: {
+              id: "event.tennis-club-membership.action.requestCorrection.form.section.verify",
+              defaultMessage: "Upload supporting documents",
+              description: "This is the title of the section"
             },
-            {
-              id: "correction.request.supportingDocuments",
-              type: "RADIO_GROUP",
-              label: {
-                id: "correction.corrector.title",
-                defaultMessage: "Who is requesting a change to this record?",
-                description: "The title for the corrector form"
+            fields: [
+              {
+                id: "correction.supportingDocs.introduction",
+                type: "PAGE_HEADER",
+                label: {
+                  id: "correction.corrector.paragraph.title",
+                  defaultMessage: "For all record corrections at a minimum an affidavit must be provided. For material errors and omissions eg. in paternity cases, a court order must also be provided.",
+                  description: "The title for the corrector form"
+                }
               },
-              defaultValue: "",
-              configuration: {
-                styles: {
-                  size: "NORMAL"
+              {
+                id: "correction.supportingDocs",
+                type: FieldType.FILE,
+                label: {
+                  id: "correction.corrector.title",
+                  defaultMessage: "Upload supporting documents",
+                  description: "The title for the corrector form"
                 }
               },
-              options: [
-                {
-                  value: "ATTEST",
-                  label: {
-                    id: "correction.supportingDocuments.attest.label",
-                    defaultMessage: "I attest to seeing supporting documentation and have a copy filed at my office",
-                    description: ""
+              {
+                id: "correction.request.supportingDocuments",
+                type: "RADIO_GROUP",
+                label: {
+                  id: "correction.corrector.title",
+                  defaultMessage: "Who is requesting a change to this record?",
+                  description: "The title for the corrector form"
+                },
+                defaultValue: "",
+                configuration: {
+                  styles: {
+                    size: "NORMAL"
                   }
                 },
-                {
-                  value: "NOT_NEEDED",
-                  label: {
-                    id: "correction.supportingDocuments.notNeeded.label",
-                    defaultMessage: "No supporting documents required",
-                    description: ""
+                options: [
+                  {
+                    value: "ATTEST",
+                    label: {
+                      id: "correction.supportingDocuments.attest.label",
+                      defaultMessage: "I attest to seeing supporting documentation and have a copy filed at my office",
+                      description: ""
+                    }
+                  },
+                  {
+                    value: "NOT_NEEDED",
+                    label: {
+                      id: "correction.supportingDocuments.notNeeded.label",
+                      defaultMessage: "No supporting documents required",
+                      description: ""
+                    }
                   }
-                }
-              ]
-            }
-          ]
-        },
-        {
-          id: "correction-request.additional-details",
-          type: PageTypes.enum.FORM,
-          title: {
-            id: "event.tennis-club-membership.action.requestCorrection.form.section.corrector",
-            defaultMessage: "Reason for correction",
-            description: "This is the title of the section"
+                ]
+              }
+            ]
           },
-          fields: [
-            {
-              id: "correction.request.reason",
-              type: FieldType.TEXT,
-              label: {
-                id: "correction.reason.title",
-                defaultMessage: "Reason for correction?",
-                description: "The title for the corrector form"
+          {
+            id: "correction-request.additional-details",
+            type: PageTypes.enum.FORM,
+            title: {
+              id: "event.tennis-club-membership.action.requestCorrection.form.section.corrector",
+              defaultMessage: "Reason for correction",
+              description: "This is the title of the section"
+            },
+            fields: [
+              {
+                id: "correction.request.reason",
+                type: FieldType.TEXT,
+                label: {
+                  id: "correction.reason.title",
+                  defaultMessage: "Reason for correction?",
+                  description: "The title for the corrector form"
+                }
               }
-            }
-          ]
-        }
-      ]
+            ]
+          }
+        ]
+      }
     },
     {
       type: ActionType.APPROVE_CORRECTION,
@@ -5560,10 +5777,10 @@ var tennisClubMembershipEvent = defineConfig({
         id: "v2.advancedSearch.form.registrationDetails"
       },
       fields: [
-        event("legalStatus.REGISTERED.createdAtLocation").exact(),
-        event("legalStatus.REGISTERED.createdAt").range(),
-        event("status", statusOptions).exact(),
-        event("updatedAt", timePeriodOptions).range()
+        event("legalStatuses.REGISTERED.createdAtLocation").exact(),
+        event("legalStatuses.REGISTERED.acceptedAt").range(),
+        event("status").exact(),
+        event("updatedAt").range()
       ]
     },
     {
@@ -5680,197 +5897,202 @@ var footballClubMembershipEvent = defineConfig({
         description: "This is shown as the action name anywhere the user can trigger the action from",
         id: "event.football-club-membership.action.correction.request.label"
       },
-      onboardingForm: [
-        {
-          id: "correction-requester",
-          type: PageTypes.enum.FORM,
-          title: {
-            id: "event.football-club-membership.action.requestCorrection.form.section.corrector",
-            defaultMessage: "Correction requester",
-            description: "This is the title of the section"
-          },
-          fields: [
-            {
-              id: "correction.requester.relationshop.intro",
-              type: "PAGE_HEADER",
-              label: {
-                id: "correction.requester.relationshop.intro.label",
-                defaultMessage: "Note: In the case that the child is now of legal age (18) then only they should be able to request a change to their birth record.",
-                description: "The title for the corrector form"
-              }
+      correctionForm: {
+        label: {
+          id: "event.football-club-membership.action.correction.request.label",
+          defaultMessage: "Request correction",
+          description: "This is shown as the action name anywhere the user can trigger the action from"
+        },
+        pages: [
+          {
+            id: "correction-requester",
+            type: PageTypes.enum.FORM,
+            title: {
+              id: "event.football-club-membership.action.requestCorrection.form.section.corrector",
+              defaultMessage: "Correction requester",
+              description: "This is the title of the section"
             },
-            {
-              id: "correction.requester.relationship",
-              type: "RADIO_GROUP",
-              label: {
-                id: "v2.correction.corrector.title",
-                defaultMessage: "Who is requesting a change to this record?",
-                description: "The title for the corrector form"
+            fields: [
+              {
+                id: "correction.requester.relationshop.intro",
+                type: "PAGE_HEADER",
+                label: {
+                  id: "correction.requester.relationshop.intro.label",
+                  defaultMessage: "Note: In the case that the child is now of legal age (18) then only they should be able to request a change to their birth record.",
+                  description: "The title for the corrector form"
+                }
               },
-              defaultValue: "",
-              options: [
-                {
-                  value: "INFORMANT",
-                  label: {
-                    id: "v2.correction.corrector.informant",
-                    defaultMessage: "Informant",
-                    description: "Label for informant option in certificate correction form"
-                  }
-                },
-                {
-                  value: "ANOTHER_AGENT",
-                  label: {
-                    id: "v2.correction.corrector.anotherAgent",
-                    defaultMessage: "Another registration agent or field agent",
-                    description: "Label for another registration or field agent option in certificate correction form"
-                  }
-                },
-                {
-                  value: "REGISTRAR",
-                  label: {
-                    id: "v2.correction.corrector.me",
-                    defaultMessage: "Me (Registrar)",
-                    description: "Label for registrar option in certificate correction form"
-                  }
+              {
+                id: "correction.requester.relationship",
+                type: "RADIO_GROUP",
+                label: {
+                  id: "v2.correction.corrector.title",
+                  defaultMessage: "Who is requesting a change to this record?",
+                  description: "The title for the corrector form"
                 },
-                {
-                  value: "OTHER",
-                  label: {
-                    id: "v2.correction.corrector.others",
-                    defaultMessage: "Someone else",
-                    description: "Label for someone else option in certificate correction form"
+                defaultValue: "",
+                options: [
+                  {
+                    value: "INFORMANT",
+                    label: {
+                      id: "v2.correction.corrector.informant",
+                      defaultMessage: "Informant",
+                      description: "Label for informant option in certificate correction form"
+                    }
+                  },
+                  {
+                    value: "ANOTHER_AGENT",
+                    label: {
+                      id: "v2.correction.corrector.anotherAgent",
+                      defaultMessage: "Another registration agent or field agent",
+                      description: "Label for another registration or field agent option in certificate correction form"
+                    }
+                  },
+                  {
+                    value: "REGISTRAR",
+                    label: {
+                      id: "v2.correction.corrector.me",
+                      defaultMessage: "Me (Registrar)",
+                      description: "Label for registrar option in certificate correction form"
+                    }
+                  },
+                  {
+                    value: "OTHER",
+                    label: {
+                      id: "v2.correction.corrector.others",
+                      defaultMessage: "Someone else",
+                      description: "Label for someone else option in certificate correction form"
+                    }
                   }
-                }
-              ]
-            }
-          ]
-        },
-        {
-          id: "identity-check",
-          type: PageTypes.enum.FORM,
-          title: {
-            id: "event.football-club-membership.action.requestCorrection.form.section.verify",
-            defaultMessage: "Verify their identity",
-            description: "This is the title of the section"
-          },
-          fields: [
-            {
-              id: "correction.identity-check.instructions",
-              type: "PAGE_HEADER",
-              label: {
-                id: "correction.corrector.identity.instruction",
-                defaultMessage: "Please verify the identity of the person making this request",
-                description: "The title for the corrector form"
+                ]
               }
+            ]
+          },
+          {
+            id: "identity-check",
+            type: PageTypes.enum.FORM,
+            title: {
+              id: "event.football-club-membership.action.requestCorrection.form.section.verify",
+              defaultMessage: "Verify their identity",
+              description: "This is the title of the section"
             },
-            {
-              id: "correction.identity-check.verified",
-              type: "RADIO_GROUP",
-              label: {
-                id: "correction.corrector.identity.verified.label",
-                defaultMessage: "Identity verified",
-                description: "The title for the corrector form"
+            fields: [
+              {
+                id: "correction.identity-check.instructions",
+                type: "PAGE_HEADER",
+                label: {
+                  id: "correction.corrector.identity.instruction",
+                  defaultMessage: "Please verify the identity of the person making this request",
+                  description: "The title for the corrector form"
+                }
               },
-              defaultValue: "",
-              required: true,
-              options: [
-                {
-                  value: "VERIFIED",
-                  label: {
-                    id: "correction.corrector.identity.verified",
-                    defaultMessage: "I have verified their identity",
-                    description: "Label for verified option in corrector identity check page"
+              {
+                id: "correction.identity-check.verified",
+                type: "RADIO_GROUP",
+                label: {
+                  id: "correction.corrector.identity.verified.label",
+                  defaultMessage: "Identity verified",
+                  description: "The title for the corrector form"
+                },
+                defaultValue: "",
+                required: true,
+                options: [
+                  {
+                    value: "VERIFIED",
+                    label: {
+                      id: "correction.corrector.identity.verified",
+                      defaultMessage: "I have verified their identity",
+                      description: "Label for verified option in corrector identity check page"
+                    }
                   }
-                }
-              ]
-            }
-          ]
-        }
-      ],
-      additionalDetailsForm: [
-        {
-          id: "correction-request.supporting-documents",
-          type: PageTypes.enum.FORM,
-          title: {
-            id: "event.football-club-membership.action.requestCorrection.form.section.verify",
-            defaultMessage: "Upload supporting documents",
-            description: "This is the title of the section"
-          },
-          fields: [
-            {
-              id: "correction.supportingDocs.introduction",
-              type: "PAGE_HEADER",
-              label: {
-                id: "correction.corrector.paragraph.title",
-                defaultMessage: "For all record corrections at a minimum an affidavit must be provided. For material errors and omissions eg. in paternity cases, a court order must also be provided.",
-                description: "The title for the corrector form"
-              }
-            },
-            {
-              id: "correction.supportingDocs",
-              type: FieldType.FILE,
-              label: {
-                id: "correction.corrector.title",
-                defaultMessage: "Upload supporting documents",
-                description: "The title for the corrector form"
+                ]
               }
+            ]
+          },
+          {
+            id: "correction-request.supporting-documents",
+            type: PageTypes.enum.FORM,
+            title: {
+              id: "event.football-club-membership.action.requestCorrection.form.section.verify",
+              defaultMessage: "Upload supporting documents",
+              description: "This is the title of the section"
             },
-            {
-              id: "correction.request.supportingDocuments",
-              type: "RADIO_GROUP",
-              label: {
-                id: "correction.corrector.title",
-                defaultMessage: "Who is requesting a change to this record?",
-                description: "The title for the corrector form"
+            fields: [
+              {
+                id: "correction.supportingDocs.introduction",
+                type: "PAGE_HEADER",
+                label: {
+                  id: "correction.corrector.paragraph.title",
+                  defaultMessage: "For all record corrections at a minimum an affidavit must be provided. For material errors and omissions eg. in paternity cases, a court order must also be provided.",
+                  description: "The title for the corrector form"
+                }
               },
-              defaultValue: "",
-              configuration: {
-                styles: {
-                  size: "NORMAL"
+              {
+                id: "correction.supportingDocs",
+                type: FieldType.FILE,
+                label: {
+                  id: "correction.corrector.title",
+                  defaultMessage: "Upload supporting documents",
+                  description: "The title for the corrector form"
                 }
               },
-              options: [
-                {
-                  value: "ATTEST",
-                  label: {
-                    id: "correction.supportingDocuments.attest.label",
-                    defaultMessage: "I attest to seeing supporting documentation and have a copy filed at my office",
-                    description: ""
+              {
+                id: "correction.request.supportingDocuments",
+                type: "RADIO_GROUP",
+                label: {
+                  id: "correction.corrector.title",
+                  defaultMessage: "Who is requesting a change to this record?",
+                  description: "The title for the corrector form"
+                },
+                defaultValue: "",
+                configuration: {
+                  styles: {
+                    size: "NORMAL"
                   }
                 },
-                {
-                  value: "NOT_NEEDED",
-                  label: {
-                    id: "correction.supportingDocuments.notNeeded.label",
-                    defaultMessage: "No supporting documents required",
-                    description: ""
+                options: [
+                  {
+                    value: "ATTEST",
+                    label: {
+                      id: "correction.supportingDocuments.attest.label",
+                      defaultMessage: "I attest to seeing supporting documentation and have a copy filed at my office",
+                      description: ""
+                    }
+                  },
+                  {
+                    value: "NOT_NEEDED",
+                    label: {
+                      id: "correction.supportingDocuments.notNeeded.label",
+                      defaultMessage: "No supporting documents required",
+                      description: ""
+                    }
                   }
-                }
-              ]
-            }
-          ]
-        },
-        {
-          id: "correction-request.additional-details",
-          type: PageTypes.enum.FORM,
-          title: {
-            id: "event.football-club-membership.action.requestCorrection.form.section.corrector",
-            defaultMessage: "Reason for correction",
-            description: "This is the title of the section"
+                ]
+              }
+            ]
           },
-          fields: [
-            {
-              id: "correction.request.reason",
-              type: FieldType.TEXT,
-              label: {
-                id: "correction.reason.title",
-                defaultMessage: "Reason for correction?",
-                description: "The title for the corrector form"
+          {
+            id: "correction-request.additional-details",
+            type: PageTypes.enum.FORM,
+            title: {
+              id: "event.football-club-membership.action.requestCorrection.form.section.corrector",
+              defaultMessage: "Reason for correction",
+              description: "This is the title of the section"
+            },
+            fields: [
+              {
+                id: "correction.request.reason",
+                type: FieldType.TEXT,
+                label: {
+                  id: "correction.reason.title",
+                  defaultMessage: "Reason for correction?",
+                  description: "The title for the corrector form"
+                }
               }
-            }
-          ]
-        }
-      ]
+            ]
+          }
+        ]
+      }
     },
     {
       type: ActionType.APPROVE_CORRECTION,
@@ -5953,10 +6175,10 @@ var footballClubMembershipEvent = defineConfig({
         id: "v2.advancedSearch.form.registrationDetails"
       },
       fields: [
-        event("legalStatus.REGISTERED.createdAtLocation").exact(),
-        event("legalStatus.REGISTERED.createdAt").range(),
-        event("status", statusOptions).exact(),
-        event("updatedAt", timePeriodOptions).range()
+        event("legalStatuses.REGISTERED.createdAtLocation").exact(),
+        event("legalStatuses.REGISTERED.acceptedAt").range(),
+        event("status").exact(),
+        event("updatedAt").range()
       ]
     },
     {
@@ -6169,8 +6391,9 @@ var v2BirthEvent = defineConfig({
 });
 
 // ../commons/src/events/test.utils.ts
-var import_zod33 = require("zod");
-var TestUserRole = import_zod33.z.enum([
+var import_zod34 = require("zod");
+var TEST_SYSTEM_IANA_TIMEZONE = "Asia/Dhaka";
+var TestUserRole = import_zod34.z.enum([
   "FIELD_AGENT",
   "LOCAL_REGISTRAR",
   "LOCAL_SYSTEM_ADMIN",
@@ -6225,6 +6448,7 @@ function mapFieldTypeToMockValue(field2, i, rng) {
     case FieldType.PAGE_HEADER:
     case FieldType.LOCATION:
     case FieldType.SELECT:
+    case FieldType.SELECT_DATE_RANGE:
     case FieldType.COUNTRY:
     case FieldType.RADIO_GROUP:
     case FieldType.PARAGRAPH:
@@ -6255,14 +6479,19 @@ function mapFieldTypeToMockValue(field2, i, rng) {
       };
     case FieldType.DATE:
       return "2021-01-01";
+    case FieldType.TIME:
+      return "09:33";
     case FieldType.DATE_RANGE:
-      return ["2021-01-01", "2021-01-02"];
+      return {
+        start: "2021-01-01",
+        end: "2021-01-31"
+      };
     case FieldType.CHECKBOX:
       return true;
     case FieldType.SIGNATURE:
     case FieldType.FILE:
       return {
-        filename: "4f095fc4-4312-4de2-aa38-86dcc0f71044.png",
+        path: "/ocrvs/4f095fc4-4312-4de2-aa38-86dcc0f71044.png",
         originalFilename: "abcd.png",
         type: "image/png"
       };
@@ -6325,7 +6554,11 @@ function eventPayloadGenerator(rng) {
       type: input.type ?? TENNIS_CLUB_MEMBERSHIP,
       id
     }),
-    draft: ({ eventId, actionType }, input = {}) => (0, import_lodash2.merge)(
+    draft: ({
+      eventId,
+      actionType,
+      annotation
+    }, input = {}) => (0, import_lodash3.merge)(
       {
         id: getUUID(),
         eventId,
@@ -6341,11 +6574,16 @@ function eventPayloadGenerator(rng) {
               surname: "McLaren"
             },
             "applicant.dob": "2020-01-02",
-            "recommender.none": true
+            "applicant.image": {
+              path: "/ocrvs/e56d1dd3-2cd4-452a-b54e-bf3e2d830605.png",
+              originalFilename: "Screenshot.png",
+              type: "image/png"
+            }
           },
           annotation: {
             "correction.requester.relationship": "ANOTHER_AGENT",
-            "correction.request.reason": "Child's name was incorrect"
+            "correction.request.reason": "Child's name was incorrect",
+            ...annotation
           },
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           createdBy: "@todo",
@@ -6379,13 +6617,13 @@ function eventPayloadGenerator(rng) {
       notify: (eventId, input = {}) => {
         let declaration = input.declaration;
         if (!declaration) {
-          const partialDeclaration = (0, import_lodash2.omitBy)(
+          const partialDeclaration = (0, import_lodash3.omitBy)(
             generateActionDeclarationInput(
               tennisClubMembershipEvent,
               ActionType.DECLARE,
               rng
             ),
-            import_lodash2.isString
+            import_lodash3.isString
           );
           declaration = partialDeclaration;
         }
@@ -6488,10 +6726,13 @@ function eventPayloadGenerator(rng) {
         request: (eventId, input = {}) => ({
           type: ActionType.REQUEST_CORRECTION,
           transactionId: input.transactionId ?? getUUID(),
-          declaration: input.declaration ?? generateActionDeclarationInput(
-            tennisClubMembershipEvent,
-            ActionType.REQUEST_CORRECTION,
-            rng
+          declaration: input.declaration ?? (0, import_lodash3.omit)(
+            generateActionDeclarationInput(
+              tennisClubMembershipEvent,
+              ActionType.REQUEST_CORRECTION,
+              rng
+            ),
+            ["applicant.email"]
           ),
           annotation: input.annotation ?? generateActionAnnotationInput(
             tennisClubMembershipEvent,
@@ -6712,7 +6953,7 @@ var eventQueryDataGenerator = (overrides = {}, seed = 1) => {
     createdAtLocation: overrides.createdAtLocation ?? generateUuid(rng),
     updatedAtLocation: overrides.updatedAtLocation ?? generateUuid(rng),
     createdBySignature: overrides.createdBySignature ?? generateRandomSignature(rng),
-    updatedAt: overrides.updatedAt ?? (0, import_addDays.default)(new Date(createdAt), 1).toISOString(),
+    updatedAt: overrides.updatedAt ?? (0, import_date_fns4.addDays)(new Date(createdAt), 1).toISOString(),
     assignedTo: overrides.assignedTo ?? null,
     updatedBy: overrides.updatedBy ?? generateUuid(rng),
     updatedByUserRole: overrides.updatedByUserRole ?? "FIELD_AGENT",
@@ -6784,7 +7025,7 @@ function isFieldConfigDefaultValue(value) {
 }
 
 // ../commons/src/events/scopes.ts
-var import_lodash3 = require("lodash");
+var import_lodash4 = require("lodash");
 var CONFIG_GET_ALLOWED_SCOPES = [
   SCOPES.RECORD_DECLARE,
   SCOPES.RECORD_READ,
@@ -6831,7 +7072,11 @@ var ACTION_ALLOWED_SCOPES = {
   [ActionType.REGISTER]: [SCOPES.RECORD_REGISTER],
   [ActionType.PRINT_CERTIFICATE]: [SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES],
   [ActionType.REQUEST_CORRECTION]: [
-    SCOPES.RECORD_REGISTRATION_REQUEST_CORRECTION
+    SCOPES.RECORD_REGISTRATION_REQUEST_CORRECTION,
+    SCOPES.RECORD_REGISTRATION_CORRECT
+  ],
+  [ExclusiveActions.REVIEW_CORRECTION_REQUEST]: [
+    SCOPES.RECORD_REGISTRATION_CORRECT
   ],
   [ActionType.REJECT_CORRECTION]: [SCOPES.RECORD_REGISTRATION_CORRECT],
   [ActionType.APPROVE_CORRECTION]: [SCOPES.RECORD_REGISTRATION_CORRECT],
@@ -6868,19 +7113,19 @@ var WRITE_ACTION_SCOPES = [
   ...ACTION_ALLOWED_SCOPES[ActionType.PRINT_CERTIFICATE]
 ];
 function hasAnyOfScopes(a, b) {
-  return (0, import_lodash3.intersection)(a, b).length > 0;
+  return (0, import_lodash4.intersection)(a, b).length > 0;
 }
 
 // ../commons/src/events/serializers/user/deserializer.ts
-var import_zod34 = require("zod");
+var import_zod35 = require("zod");
 var UserWithPrimaryOffice = User.extend({
-  primaryOfficeId: import_zod34.z.string()
+  primaryOfficeId: import_zod35.z.string()
 });
 function userDeserializer(serializedUserField, user2) {
   if (typeof serializedUserField === "string") {
     return serializedUserField;
   }
-  if (serializedUserField.$userField === "name" || serializedUserField.$userField === "signatureFilename") {
+  if (serializedUserField.$userField === "name" || serializedUserField.$userField === "signature" || serializedUserField.$userField === "avatar") {
     throw new Error(
       `Deserializer for ${serializedUserField.$userField} is not implemented yet`
     );
@@ -6962,20 +7207,21 @@ var AVAILABLE_ACTIONS_BY_EVENT_STATUS = {
     ActionType.ARCHIVE,
     ActionType.REJECT
   ],
-  [EventStatus.enum.REJECTED]: [
-    ActionType.READ,
-    ActionType.DECLARE,
-    ActionType.VALIDATE
-  ],
   [EventStatus.enum.REGISTERED]: [
     ActionType.READ,
     ActionType.PRINT_CERTIFICATE,
-    ActionType.REQUEST_CORRECTION
+    ActionType.REQUEST_CORRECTION,
+    ActionType.APPROVE_CORRECTION,
+    ActionType.REJECT_CORRECTION,
+    ExclusiveActions.REVIEW_CORRECTION_REQUEST
   ],
   [EventStatus.enum.CERTIFIED]: [
     ActionType.READ,
     ActionType.PRINT_CERTIFICATE,
-    ActionType.REQUEST_CORRECTION
+    ActionType.REQUEST_CORRECTION,
+    ActionType.APPROVE_CORRECTION,
+    ActionType.REJECT_CORRECTION,
+    ExclusiveActions.REVIEW_CORRECTION_REQUEST
   ],
   [EventStatus.enum.ARCHIVED]: [
     ActionType.READ,
@@ -6983,3 +7229,10 @@ var AVAILABLE_ACTIONS_BY_EVENT_STATUS = {
     ActionType.UNASSIGN
   ]
 };
+var getAvailableActionsForEvent = (event2) => {
+  return event2.flags.includes(InherentFlags.REJECTED) ? [
+    ActionType.READ,
+    event2.status === EventStatus.Enum.VALIDATED ? ActionType.VALIDATE : ActionType.DECLARE,
+    ActionType.ARCHIVE
+  ] : AVAILABLE_ACTIONS_BY_EVENT_STATUS[event2.status];
+};