@opencrvs/toolkit 1.8.0-rc.f7a451a → 1.8.0-rc.f7bcb31

package/dist/events/index.js

@@ -30,14 +30,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/events/index.ts
 var events_exports = {};
 __export(events_exports, {
-  ACTION_ALLOWED_CONFIGURABLE_SCOPES: () => ACTION_ALLOWED_CONFIGURABLE_SCOPES,
-  ACTION_ALLOWED_SCOPES: () => ACTION_ALLOWED_SCOPES,
   Action: () => Action,
   ActionBase: () => ActionBase,
   ActionConditional: () => ActionConditional,
   ActionConfig: () => ActionConfig,
   ActionConfigBase: () => ActionConfigBase,
-  ActionCreationMetadata: () => ActionCreationMetadata,
   ActionDocument: () => ActionDocument,
   ActionFormConfig: () => ActionFormConfig,
   ActionInput: () => ActionInput,
@@ -55,8 +52,6 @@ __export(events_exports, {
   AssignActionInput: () => AssignActionInput,
   AsyncRejectActionDocument: () => AsyncRejectActionDocument,
   BaseActionInput: () => BaseActionInput,
-  CONFIG_GET_ALLOWED_SCOPES: () => CONFIG_GET_ALLOWED_SCOPES,
-  CONFIG_SEARCH_ALLOWED_SCOPES: () => CONFIG_SEARCH_ALLOWED_SCOPES,
   CertificateConfig: () => CertificateConfig,
   CertificateTemplateConfig: () => CertificateTemplateConfig,
   CheckboxFieldValue: () => CheckboxFieldValue,
@@ -64,13 +59,9 @@ __export(events_exports, {
   Conditional: () => Conditional,
   ConditionalType: () => ConditionalType,
   ConfirmableActions: () => ConfirmableActions,
-  CustomFlags: () => CustomFlags,
-  DEFAULT_DATE_OF_EVENT_PROPERTY: () => DEFAULT_DATE_OF_EVENT_PROPERTY,
   DataEntry: () => DataEntry,
   DataFieldValue: () => DataFieldValue,
-  DateRangeFieldValue: () => DateRangeFieldValue,
   DateValue: () => DateValue,
-  DatetimeValue: () => DatetimeValue,
   DeclarationActionConfig: () => DeclarationActionConfig,
   DeclarationActions: () => DeclarationActions,
   DeclarationFormConfig: () => DeclarationFormConfig,
@@ -78,7 +69,6 @@ __export(events_exports, {
   DeclarationUpdateActions: () => DeclarationUpdateActions,
   DeclareActionInput: () => DeclareActionInput,
   DeduplicationConfig: () => DeduplicationConfig,
-  DeleteActionInput: () => DeleteActionInput,
   DisplayOnReviewConditional: () => DisplayOnReviewConditional,
   Draft: () => Draft,
   DraftInput: () => DraftInput,
@@ -87,28 +77,20 @@ __export(events_exports, {
   EnableConditional: () => EnableConditional,
   EventConfig: () => EventConfig,
   EventDocument: () => EventDocument,
-  EventFieldConfigSchema: () => EventFieldConfigSchema,
-  EventFieldId: () => EventFieldId,
   EventIndex: () => EventIndex,
   EventInput: () => EventInput,
   EventMetadata: () => EventMetadata,
-  EventMetadataKeys: () => EventMetadataKeys,
-  EventMetadataParameter: () => EventMetadataParameter,
   EventSearchIndex: () => EventSearchIndex,
-  EventState: () => EventState,
   EventStatus: () => EventStatus,
-  EventStatusEnum: () => EventStatusEnum,
   EventStatuses: () => EventStatuses,
   FieldConditional: () => FieldConditional,
   FieldConfig: () => FieldConfig,
-  FieldConfigSchema: () => FieldConfigSchema,
   FieldType: () => FieldType,
   FieldUpdateValue: () => FieldUpdateValue,
   FieldValue: () => FieldValue,
   FileFieldValue: () => FileFieldValue,
   FileFieldValueWithOption: () => FileFieldValueWithOption,
   FileFieldWithOptionValue: () => FileFieldWithOptionValue,
-  Flag: () => Flag,
   FormConfig: () => FormConfig,
   FormPageConfig: () => FormPageConfig,
   GenericAddressUpdateValue: () => GenericAddressUpdateValue,
@@ -116,31 +98,23 @@ __export(events_exports, {
   GeographicalArea: () => GeographicalArea,
   ImageMimeType: () => ImageMimeType,
   LanguageConfig: () => LanguageConfig,
-  LegalStatuses: () => LegalStatuses,
   MarkedAsDuplicateActionInput: () => MarkedAsDuplicateActionInput,
   MimeType: () => MimeType,
-  NonEmptyTextValue: () => NonEmptyTextValue,
   NotifyActionInput: () => NotifyActionInput,
   NumberFieldValue: () => NumberFieldValue,
   PageConfig: () => PageConfig,
   PageTypes: () => PageTypes,
   PrintCertificateActionInput: () => PrintCertificateActionInput,
-  QueryExpression: () => QueryExpression,
-  QueryInput: () => QueryInput2,
-  QueryType: () => QueryType,
   ReadActionInput: () => ReadActionInput,
   RegisterAction: () => RegisterAction,
   RegisterActionInput: () => RegisterActionInput,
-  RegistrationCreationMetadata: () => RegistrationCreationMetadata,
   RejectCorrectionActionInput: () => RejectCorrectionActionInput,
   RejectDeclarationActionInput: () => RejectDeclarationActionInput,
   RequestCorrectionActionInput: () => RequestCorrectionActionInput,
+  RequiredTextValue: () => RequiredTextValue,
   ResolvedUser: () => ResolvedUser,
   RuralAddressUpdateValue: () => RuralAddressUpdateValue,
   RuralAddressValue: () => RuralAddressValue,
-  SearchField: () => SearchField,
-  SearchQueryParams: () => SearchQueryParams,
-  SelectOption: () => SelectOption,
   ShowConditional: () => ShowConditional,
   SummaryConfig: () => SummaryConfig,
   TextValue: () => TextValue,
@@ -148,30 +122,19 @@ __export(events_exports, {
   UnassignActionInput: () => UnassignActionInput,
   UrbanAddressUpdateValue: () => UrbanAddressUpdateValue,
   UrbanAddressValue: () => UrbanAddressValue,
-  User: () => User,
   ValidateActionInput: () => ValidateActionInput,
   VerificationActionConfig: () => VerificationActionConfig,
   VerificationPageConfig: () => VerificationPageConfig,
-  WorkqueueColumn: () => WorkqueueColumn,
   WorkqueueConfig: () => WorkqueueConfig,
-  WorkqueueConfigInput: () => WorkqueueConfigInput,
-  WorkqueueCountInput: () => WorkqueueCountInput,
-  WorkqueueCountOutput: () => WorkqueueCountOutput,
-  ZodDate: () => ZodDate,
   alwaysTrue: () => alwaysTrue,
   and: () => and,
   annotationActions: () => annotationActions,
   applyDraftsToEventIndex: () => applyDraftsToEventIndex,
-  areConditionsMet: () => areConditionsMet,
   compositeFieldTypes: () => compositeFieldTypes,
   createEmptyDraft: () => createEmptyDraft,
-  createEventConditionals: () => createEventConditionals,
-  createFieldConditionals: () => createFieldConditionals,
   createValidationSchema: () => createValidationSchema,
   deepDropNulls: () => deepDropNulls,
   deepMerge: () => deepMerge,
-  defaultThirdColumn: () => defaultThirdColumn,
-  defaultWorkqueueColumns: () => defaultWorkqueueColumns,
   defineActionForm: () => defineActionForm,
   defineConditional: () => defineConditional,
   defineConfig: () => defineConfig,
@@ -179,10 +142,6 @@ __export(events_exports, {
   defineFormConditional: () => defineFormConditional,
   defineFormPage: () => defineFormPage,
   definePage: () => definePage,
-  defineWorkqueue: () => defineWorkqueue,
-  defineWorkqueues: () => defineWorkqueues,
-  defineWorkqueuesColumns: () => defineWorkqueuesColumns,
-  deserializeQuery: () => deserializeQuery,
   errorMessages: () => errorMessages,
   event: () => event,
   eventMetadataLabelMap: () => eventMetadataLabelMap,
@@ -191,7 +150,6 @@ __export(events_exports, {
   eventStatuses: () => eventStatuses,
   field: () => field,
   fieldTypes: () => fieldTypes,
-  filterUnallowedActions: () => filterUnallowedActions,
   findActiveDrafts: () => findActiveDrafts,
   findAllFields: () => findAllFields,
   findLastAssignmentAction: () => findLastAssignmentAction,
@@ -203,33 +161,26 @@ __export(events_exports, {
   generateEventDraftDocument: () => generateEventDraftDocument,
   generateTransactionId: () => generateTransactionId,
   generateTranslationConfig: () => generateTranslationConfig,
-  generateWorkqueues: () => generateWorkqueues,
   getAcceptedActions: () => getAcceptedActions,
   getActionAnnotation: () => getActionAnnotation,
   getActionAnnotationFields: () => getActionAnnotationFields,
   getActionReview: () => getActionReview,
   getActionReviewFields: () => getActionReviewFields,
-  getActionVerificationPageIds: () => getActionVerificationPageIds,
+  getAllAnnotationFields: () => getAllAnnotationFields,
   getAnnotationFromDrafts: () => getAnnotationFromDrafts,
-  getAssignedUserFromActions: () => getAssignedUserFromActions,
   getCurrentEventState: () => getCurrentEventState,
   getCurrentEventStateWithDrafts: () => getCurrentEventStateWithDrafts,
   getDeclaration: () => getDeclaration,
   getDeclarationFields: () => getDeclarationFields,
   getDeclarationPages: () => getDeclarationPages,
-  getMixedPath: () => getMixedPath,
-  getStatusFromActions: () => getStatusFromActions,
-  getVisibleVerificationPageIds: () => getVisibleVerificationPageIds,
-  hasAnyOfScopes: () => hasAnyOfScopes,
+  getFieldValidationErrors: () => getFieldValidationErrors,
   isAddressFieldType: () => isAddressFieldType,
   isAdministrativeAreaFieldType: () => isAdministrativeAreaFieldType,
   isBulletListFieldType: () => isBulletListFieldType,
   isCheckboxFieldType: () => isCheckboxFieldType,
-  isConditionMet: () => isConditionMet,
   isCountryFieldType: () => isCountryFieldType,
   isDataFieldType: () => isDataFieldType,
   isDateFieldType: () => isDateFieldType,
-  isDateRangeFieldType: () => isDateRangeFieldType,
   isDividerFieldType: () => isDividerFieldType,
   isEmailFieldType: () => isEmailFieldType,
   isFacilityFieldType: () => isFacilityFieldType,
@@ -261,14 +212,13 @@ __export(events_exports, {
   mapFieldTypeToZod: () => mapFieldTypeToZod,
   never: () => never,
   not: () => not,
-  omitHiddenAnnotationFields: () => omitHiddenAnnotationFields,
   omitHiddenFields: () => omitHiddenFields,
   omitHiddenPaginatedFields: () => omitHiddenPaginatedFields,
   or: () => or,
-  runFieldValidations: () => runFieldValidations,
   user: () => user,
   validate: () => validate,
   validateFieldInput: () => validateFieldInput,
+  validateWorkqueueConfig: () => validateWorkqueueConfig,
   writeActions: () => writeActions
 });
 module.exports = __toCommonJS(events_exports);
@@ -278,12 +228,9 @@ var import_zod9 = require("zod");
 
 // ../commons/src/events/Conditional.ts
 var import_zod = require("zod");
-var import_zod_openapi = require("zod-openapi");
-(0, import_zod_openapi.extendZodWithOpenApi)(import_zod.z);
-var Conditional = import_zod.z.custom((val) => typeof val === "object" && val !== null).openapi({
-  description: "JSON schema conditional configuration",
-  ref: "Conditional"
-});
+var Conditional = import_zod.z.custom(
+  (val) => typeof val === "object" && val !== null
+);
 var ConditionalType = {
   SHOW: "SHOW",
   ENABLE: "ENABLE",
@@ -320,10 +267,7 @@ var FieldConditional = import_zod.z.discriminatedUnion("type", [
   EnableConditional,
   // Field output can be shown / hidden on the review page
   DisplayOnReviewConditional
-]).openapi({
-  description: "Field conditional configuration",
-  ref: "FieldConditional"
-});
+]);
 
 // ../commons/src/events/PageConfig.ts
 var import_zod6 = require("zod");
@@ -333,8 +277,6 @@ var import_zod5 = require("zod");
 
 // ../commons/src/events/TranslationConfig.ts
 var import_zod2 = require("zod");
-var import_zod_openapi2 = require("zod-openapi");
-(0, import_zod_openapi2.extendZodWithOpenApi)(import_zod2.z);
 var TranslationConfig = import_zod2.z.object({
   id: import_zod2.z.string().describe(
     "The identifier of the translation referred in translation CSV files"
@@ -343,9 +285,6 @@ var TranslationConfig = import_zod2.z.object({
   description: import_zod2.z.string().describe(
     "Describe the translation for a translator to be able to identify it."
   )
-}).openapi({
-  description: "Translation configuration",
-  ref: "TranslationConfig"
 });
 
 // ../commons/src/events/FieldType.ts
@@ -356,12 +295,12 @@ var FieldType = {
   TEXTAREA: "TEXTAREA",
   EMAIL: "EMAIL",
   DATE: "DATE",
-  DATE_RANGE: "DATE_RANGE",
   PARAGRAPH: "PARAGRAPH",
   PAGE_HEADER: "PAGE_HEADER",
   RADIO_GROUP: "RADIO_GROUP",
   FILE: "FILE",
   FILE_WITH_OPTIONS: "FILE_WITH_OPTIONS",
+  HIDDEN: "HIDDEN",
   BULLET_LIST: "BULLET_LIST",
   CHECKBOX: "CHECKBOX",
   SELECT: "SELECT",
@@ -376,7 +315,6 @@ var FieldType = {
 };
 var fieldTypes = Object.values(FieldType);
 var compositeFieldTypes = [
-  FieldType.DATE_RANGE,
   FieldType.ADDRESS,
   FieldType.FILE_WITH_OPTIONS,
   FieldType.FILE
@@ -467,10 +405,8 @@ var FileFieldWithOptionValue = import_zod3.z.array(FileFieldValueWithOption);
 
 // ../commons/src/events/FieldValue.ts
 var TextValue = import_zod4.z.string();
-var NonEmptyTextValue = TextValue.min(1);
+var RequiredTextValue = 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();
@@ -478,7 +414,6 @@ var DataFieldValue = import_zod4.z.undefined();
 var FieldValue = import_zod4.z.union([
   TextValue,
   DateValue,
-  DateRangeFieldValue,
   CheckboxFieldValue,
   NumberFieldValue,
   FileFieldValue,
@@ -491,7 +426,6 @@ var FieldValue = import_zod4.z.union([
 var FieldUpdateValue = import_zod4.z.union([
   TextValue,
   DateValue,
-  DateRangeFieldValue,
   CheckboxFieldValue,
   NumberFieldValue,
   FileFieldValue,
@@ -503,24 +437,28 @@ 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();
-var ParentReference = import_zod5.z.object({
-  _fieldId: FieldId.optional()
-}).optional();
+var DependencyExpression = import_zod5.z.object({
+  dependsOn: import_zod5.z.array(FieldId).default([]),
+  expression: import_zod5.z.string()
+});
 var BaseField = import_zod5.z.object({
   id: FieldId,
   defaultValue: import_zod5.z.union([
-    TextValue,
-    NonEmptyTextValue,
-    DateValue,
-    NumberFieldValue,
-    CheckboxFieldValue
+    // These are the currently supported default values types
+    import_zod5.z.union([
+      TextValue,
+      RequiredTextValue,
+      DateValue,
+      NumberFieldValue,
+      CheckboxFieldValue
+    ]),
+    DependencyExpression
   ]).optional(),
-  parent: ParentReference,
   conditionals: import_zod5.z.array(FieldConditional).default([]).optional(),
   required: import_zod5.z.boolean().default(false).optional(),
+  disabled: import_zod5.z.boolean().default(false).optional(),
+  hidden: import_zod5.z.boolean().default(false).optional(),
   placeholder: TranslationConfig.optional(),
   validation: import_zod5.z.array(
     import_zod5.z.object({
@@ -528,8 +466,8 @@ var BaseField = import_zod5.z.object({
       message: TranslationConfig
     })
   ).default([]).optional(),
+  dependsOn: import_zod5.z.array(FieldId).default([]).optional(),
   label: TranslationConfig,
-  helperText: TranslationConfig.optional(),
   hideLabel: import_zod5.z.boolean().default(false).optional()
 });
 var Divider = BaseField.extend({
@@ -537,7 +475,7 @@ var Divider = BaseField.extend({
 });
 var TextField = BaseField.extend({
   type: import_zod5.z.literal(FieldType.TEXT),
-  defaultValue: NonEmptyTextValue.optional(),
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).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(),
@@ -547,7 +485,7 @@ var TextField = BaseField.extend({
 }).describe("Text input");
 var NumberField = BaseField.extend({
   type: import_zod5.z.literal(FieldType.NUMBER),
-  defaultValue: NumberFieldValue.optional(),
+  defaultValue: import_zod5.z.union([NumberFieldValue, DependencyExpression]).optional(),
   configuration: import_zod5.z.object({
     min: import_zod5.z.number().optional().describe("Minimum value"),
     max: import_zod5.z.number().optional().describe("Maximum value"),
@@ -557,7 +495,7 @@ var NumberField = BaseField.extend({
 }).describe("Number input");
 var TextAreaField = BaseField.extend({
   type: import_zod5.z.literal(FieldType.TEXTAREA),
-  defaultValue: NonEmptyTextValue.optional(),
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).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"),
@@ -591,28 +529,17 @@ var EmailField = BaseField.extend({
   configuration: import_zod5.z.object({
     maxLength: import_zod5.z.number().optional().describe("Maximum length of the text")
   }).default({ maxLength: 10 }).optional(),
-  defaultValue: NonEmptyTextValue.optional()
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional()
 });
 var DateField = BaseField.extend({
   type: import_zod5.z.literal(FieldType.DATE),
-  defaultValue: DateValue.optional(),
+  defaultValue: import_zod5.z.union([DateValue, DependencyExpression]).optional(),
   configuration: import_zod5.z.object({
     notice: TranslationConfig.describe(
       "Text to display above the date input"
     ).optional()
   }).optional()
 }).describe("A single date input (dd-mm-YYYY)");
-var DateRangeField = BaseField.extend({
-  type: import_zod5.z.literal(FieldType.DATE_RANGE),
-  defaultValue: DateRangeFieldValue.optional(),
-  configuration: import_zod5.z.object({
-    notice: TranslationConfig.describe(
-      "Text to display above the date input"
-    ).optional()
-  }).optional()
-}).describe(
-  "A date range input ({ rangeStart: dd-mm-YYYY, rangeEnd: dd-mm-YYYY })"
-);
 var HtmlFontVariant = import_zod5.z.enum([
   "reg12",
   "reg14",
@@ -625,7 +552,7 @@ var HtmlFontVariant = import_zod5.z.enum([
 ]);
 var Paragraph = BaseField.extend({
   type: import_zod5.z.literal(FieldType.PARAGRAPH),
-  defaultValue: NonEmptyTextValue.optional(),
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional(),
   configuration: import_zod5.z.object({
     styles: import_zod5.z.object({
       fontVariant: HtmlFontVariant.optional()
@@ -634,7 +561,7 @@ var Paragraph = BaseField.extend({
 }).describe("A read-only HTML <p> paragraph");
 var PageHeader = BaseField.extend({
   type: import_zod5.z.literal(FieldType.PAGE_HEADER),
-  defaultValue: NonEmptyTextValue.optional()
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional()
 }).describe("A read-only header component for form pages");
 var File = BaseField.extend({
   type: import_zod5.z.literal(FieldType.FILE),
@@ -645,8 +572,7 @@ var File = BaseField.extend({
       width: import_zod5.z.enum(["full", "auto"]).optional().describe(
         "Whether the file upload button should take the full width of the container or not"
       )
-    }).optional(),
-    fileName: TranslationConfig.optional()
+    }).optional()
   }).default({
     maxFileSize: DEFAULT_MAX_FILE_SIZE_BYTES
   })
@@ -657,7 +583,7 @@ var SelectOption = import_zod5.z.object({
 });
 var RadioGroup = BaseField.extend({
   type: import_zod5.z.literal(FieldType.RADIO_GROUP),
-  defaultValue: TextValue.optional(),
+  defaultValue: import_zod5.z.union([TextValue, DependencyExpression]).optional(),
   options: import_zod5.z.array(SelectOption).describe("A list of options"),
   configuration: import_zod5.z.object({
     styles: import_zod5.z.object({
@@ -667,7 +593,7 @@ var RadioGroup = BaseField.extend({
 }).describe("Grouped radio options");
 var BulletList = BaseField.extend({
   type: import_zod5.z.literal(FieldType.BULLET_LIST),
-  defaultValue: TextValue.optional(),
+  defaultValue: import_zod5.z.string().optional(),
   items: import_zod5.z.array(TranslationConfig).describe("A list of items"),
   configuration: import_zod5.z.object({
     styles: import_zod5.z.object({
@@ -677,16 +603,16 @@ var BulletList = BaseField.extend({
 }).describe("A list of bullet points");
 var Select = BaseField.extend({
   type: import_zod5.z.literal(FieldType.SELECT),
-  defaultValue: TextValue.optional(),
+  defaultValue: import_zod5.z.union([TextValue, DependencyExpression]).optional(),
   options: import_zod5.z.array(SelectOption).describe("A list of options")
 }).describe("Select input");
 var Checkbox = BaseField.extend({
   type: import_zod5.z.literal(FieldType.CHECKBOX),
-  defaultValue: CheckboxFieldValue.optional()
+  defaultValue: import_zod5.z.union([CheckboxFieldValue, DependencyExpression]).optional()
 }).describe("Boolean checkbox field");
 var Country = BaseField.extend({
   type: import_zod5.z.literal(FieldType.COUNTRY),
-  defaultValue: NonEmptyTextValue.optional()
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional()
 }).describe("Country select field");
 var AdministrativeAreas = import_zod5.z.enum([
   "ADMIN_STRUCTURE",
@@ -701,12 +627,12 @@ var AdministrativeAreaConfiguration = import_zod5.z.object({
 }).describe("Administrative area options");
 var AdministrativeArea = BaseField.extend({
   type: import_zod5.z.literal(FieldType.ADMINISTRATIVE_AREA),
-  defaultValue: NonEmptyTextValue.optional(),
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).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()
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional()
 }).describe("Input field for a location");
 var FileUploadWithOptions = BaseField.extend({
   type: import_zod5.z.literal(FieldType.FILE_WITH_OPTIONS),
@@ -720,11 +646,11 @@ var FileUploadWithOptions = BaseField.extend({
 });
 var Facility = BaseField.extend({
   type: import_zod5.z.literal(FieldType.FACILITY),
-  defaultValue: NonEmptyTextValue.optional()
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional()
 }).describe("Input field for a facility");
 var Office = BaseField.extend({
   type: import_zod5.z.literal(FieldType.OFFICE),
-  defaultValue: NonEmptyTextValue.optional()
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional()
 }).describe("Input field for an office");
 var Address = BaseField.extend({
   type: import_zod5.z.literal(FieldType.ADDRESS),
@@ -733,7 +659,7 @@ var Address = BaseField.extend({
 var DataEntry = import_zod5.z.union([
   import_zod5.z.object({
     label: TranslationConfig,
-    value: TranslationConfig.or(import_zod5.z.string())
+    value: import_zod5.z.string()
   }),
   import_zod5.z.object({
     fieldId: import_zod5.z.string()
@@ -752,7 +678,6 @@ var FieldConfig = import_zod5.z.discriminatedUnion("type", [
   NumberField,
   TextAreaField,
   DateField,
-  DateRangeField,
   Paragraph,
   RadioGroup,
   BulletList,
@@ -770,14 +695,10 @@ var FieldConfig = import_zod5.z.discriminatedUnion("type", [
   EmailField,
   FileUploadWithOptions,
   DataField
-]).openapi({
-  description: "Form field configuration",
-  ref: "FieldConfig"
-});
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+]);
 
 // ../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"),
@@ -786,9 +707,6 @@ var PageConfigBase = import_zod6.z.object({
   conditional: Conditional.optional().describe(
     "Page will be shown if condition is met. If conditional is not defined, the page will be always shown."
   )
-}).openapi({
-  description: "Form page configuration",
-  ref: "FormPageConfig"
 });
 var FormPageConfig = PageConfigBase.extend({
   type: import_zod6.z.literal(PageTypes.enum.FORM).default(PageTypes.enum.FORM)
@@ -802,10 +720,7 @@ var VerificationActionConfig = import_zod6.z.object({
       body: TranslationConfig
     })
   })
-}).describe("Actions available on the verification page").openapi({
-  description: "Verification action configuration",
-  ref: "VerificationActionConfig"
-});
+}).describe("Actions available on the verification page");
 var VerificationPageConfig = FormPageConfig.extend({
   type: import_zod6.z.literal(PageTypes.enum.VERIFICATION),
   actions: VerificationActionConfig
@@ -905,8 +820,6 @@ var ActionFormConfig = import_zod8.z.object({
 var FormConfig = import_zod8.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", [
   /** If conditional is defined, the action is shown to the user only if the condition is met */
   ShowConditional,
@@ -984,24 +897,18 @@ var ApproveCorrectionConfig = ActionConfigBase.merge(
   })
 );
 var ActionConfig = import_zod9.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.
-   */
-  DeclareConfig.openapi({ ref: "DeclareActionConfig" }),
-  ValidateConfig.openapi({ ref: "ValidateActionConfig" }),
-  RejectDeclarationConfig.openapi({ ref: "RejectDeclarationActionConfig" }),
-  MarkedAsDuplicateConfig.openapi({ ref: "MarkedAsDuplicateActionConfig" }),
-  ArchiveConfig.openapi({ ref: "ArchiveActionConfig" }),
-  RegisterConfig.openapi({ ref: "RegisterActionConfig" }),
-  DeleteConfig.openapi({ ref: "DeleteActionConfig" }),
-  PrintCertificateActionConfig.openapi({
-    ref: "PrintCertificateActionConfig"
-  }),
-  RequestCorrectionConfig.openapi({ ref: "RequestCorrectionActionConfig" }),
-  RejectCorrectionConfig.openapi({ ref: "RejectCorrectionActionConfig" }),
-  ApproveCorrectionConfig.openapi({ ref: "ApproveCorrectionActionConfig" })
-]).openapi({ ref: "ActionConfig" });
+  DeclareConfig,
+  ValidateConfig,
+  RejectDeclarationConfig,
+  MarkedAsDuplicateConfig,
+  ArchiveConfig,
+  RegisterConfig,
+  DeleteConfig,
+  PrintCertificateActionConfig,
+  RequestCorrectionConfig,
+  RejectCorrectionConfig,
+  ApproveCorrectionConfig
+]);
 var DeclarationActionConfig = import_zod9.z.discriminatedUnion("type", [
   DeclareConfig,
   ValidateConfig,
@@ -1045,12 +952,10 @@ var LanguageConfig = import_zod11.z.object({
 });
 
 // ../commons/src/events/EventConfig.ts
-var import_zod17 = require("zod");
+var import_zod20 = 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 FieldReference = import_zod12.z.string();
 var Matcher = import_zod12.z.object({
   fieldId: import_zod12.z.string(),
@@ -1111,9 +1016,7 @@ var Clause = import_zod12.z.lazy(
     DateRangeMatcher,
     DateDistanceMatcher
   ])
-).openapi({
-  ref: "Clause"
-});
+);
 var DeduplicationConfig = import_zod12.z.object({
   id: import_zod12.z.string(),
   label: TranslationConfig,
@@ -1122,259 +1025,272 @@ var DeduplicationConfig = import_zod12.z.object({
 
 // ../commons/src/events/SummaryConfig.ts
 var import_zod13 = require("zod");
-var BaseField2 = import_zod13.z.object({
-  emptyValueMessage: TranslationConfig.optional(),
-  conditionals: import_zod13.z.array(ShowConditional).default([]).optional()
-});
-var ReferenceField = BaseField2.extend({
-  fieldId: import_zod13.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({
+var Field = import_zod13.z.object({
   id: import_zod13.z.string().describe("Id of summary field"),
   value: TranslationConfig.describe(
     "Summary field value. Can utilise values defined in configuration and EventMetadata"
   ),
   label: TranslationConfig,
   emptyValueMessage: TranslationConfig.optional()
-}).describe("Custom configured field");
+});
+var Title = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  label: TranslationConfig.describe("Title content"),
+  emptyValueMessage: TranslationConfig.optional()
+});
 var SummaryConfig = import_zod13.z.object({
-  fields: import_zod13.z.array(import_zod13.z.union([Field, ReferenceField])).describe("Fields rendered in summary view.")
+  title: Title.describe("Title of summary view."),
+  fields: import_zod13.z.array(Field).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({
-    type: MatchType.describe("Determines the type of field")
-  }),
-  options: import_zod14.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 
-    when rendering search parameter labels \u2014 for example, in the search results page to indicate which fields were used in the search.
-
-    For example, a field config like { id: "child.firstname", label: { defaultMessage: "First Name(s)" } } would render as "First Name(s)" by default.
-
-    A field config like { id: "mother.firstname", label: { defaultMessage: "First Name(s)" } } would also render as "First Name(s)" by default.
+// ../commons/src/events/WorkqueueConfig.ts
+var import_zod15 = require("zod");
 
-    So, if both child.firstname and mother.firstname are used in a search, the resulting search criteria labels would be "First Name(s)", "First Name(s)", 
-    which is ambiguous.
+// ../commons/src/events/EventMetadata.ts
+var import_zod14 = require("zod");
+var EventStatus = {
+  CREATED: "CREATED",
+  NOTIFIED: "NOTIFIED",
+  DECLARED: "DECLARED",
+  VALIDATED: "VALIDATED",
+  REGISTERED: "REGISTERED",
+  CERTIFIED: "CERTIFIED",
+  REJECTED: "REJECTED",
+  ARCHIVED: "ARCHIVED"
+};
+var eventStatuses = Object.values(EventStatus);
+var EventStatuses = import_zod14.z.nativeEnum(EventStatus);
+var EventMetadata = import_zod14.z.object({
+  id: import_zod14.z.string(),
+  type: import_zod14.z.string(),
+  status: EventStatuses,
+  createdAt: import_zod14.z.string().datetime(),
+  createdBy: import_zod14.z.string(),
+  createdAtLocation: import_zod14.z.string(),
+  modifiedAt: import_zod14.z.string().datetime(),
+  assignedTo: import_zod14.z.string().nullish(),
+  updatedBy: import_zod14.z.string(),
+  trackingId: import_zod14.z.string(),
+  registrationNumber: import_zod14.z.string().nullish()
+});
+var eventMetadataLabelMap = {
+  "event.assignedTo": {
+    id: "event.assignedTo.label",
+    defaultMessage: "Assigned To",
+    description: "Assigned To"
+  },
+  "event.createdAt": {
+    id: "event.createdAt.label",
+    defaultMessage: "Created",
+    description: "Created At"
+  },
+  "event.createdAtLocation": {
+    id: "event.createdAtLocation.label",
+    defaultMessage: "Location",
+    description: "Created At Location"
+  },
+  "event.createdBy": {
+    id: "event.createdBy.label",
+    defaultMessage: "Created By",
+    description: "Created By"
+  },
+  "event.id": {
+    id: "event.id.label",
+    defaultMessage: "ID",
+    description: "ID"
+  },
+  "event.modifiedAt": {
+    id: "event.modifiedAt.label",
+    defaultMessage: "Updated",
+    description: "Modified At"
+  },
+  "event.status": {
+    id: "event.status.label",
+    defaultMessage: "Status",
+    description: "Status"
+  },
+  "event.type": {
+    id: "event.type.label",
+    defaultMessage: "Type",
+    description: "Type"
+  },
+  "event.updatedBy": {
+    id: "event.updatedBy.label",
+    defaultMessage: "Updated By",
+    description: "Updated By"
+  },
+  "event.trackingId": {
+    id: "event.trackingId.label",
+    defaultMessage: "Tracking ID",
+    description: "Tracking ID"
+  },
+  "event.registrationNumber": {
+    id: "event.registrationNumber.label",
+    defaultMessage: "Registration Number",
+    description: "Registration Number"
+  }
+};
 
-    Now, if we treat the field ID prefix as a label (e.g., "applicant.firstname" \u2192 "Applicant"), and the field label is already 
-    descriptive \u2014 like { id: "applicant.firstname", label: { defaultMessage: "Applicant's First Name" } } \u2014 then the resulting 
-    label would be "Applicant Applicant's First Name", which is redundant and awkward.
+// ../commons/src/events/WorkqueueConfig.ts
+var WorkqueueConfig = import_zod15.z.object({
+  id: import_zod15.z.string().describe("Unique identifier for workqueue."),
+  filters: import_zod15.z.array(
+    import_zod15.z.object({
+      status: import_zod15.z.array(EventStatuses).describe("Defines which statusese are included in the workqueue.")
+    })
+  ).describe("Filters to be applied to workqueue.")
+}).describe("Configuration for workqueue.");
 
-    By setting searchCriteriaLabelPrefix to a translation config object, we can explicitly define the desired prefix 
-    in the country-config > event.advancedSearch configuration. For example: field("child.dob", { searchCriteriaLabelPrefix: TranslationConfig }).
-    `
-  ),
-  conditionals: import_zod14.z.array(FieldConditional).default([]).optional().describe(
-    `
-       In advanced search, we sometimes need to override the default field visibility conditionals.
-       
-       For example, Informant fields in the declaration form may have conditional logic 
-       that hides them based on other field values. Since the advanced search form reuses 
-       the declaration form config, those same conditionals would apply by default.
-       
-       However, in advanced search we often want to make all Informant fields searchable,
-       regardless of their original visibility logic. To do this, we explicitly set their 
-       'conditionals' to an empty array ('[]') in the search config. This ensures they 
-       are always rendered in the advanced search form.
-      `
-  )
-});
-var SearchQueryParams = import_zod14.z.object({
-  eventType: import_zod14.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")
-});
-var EventFieldId = import_zod14.z.enum([
-  "trackingId",
-  "status",
-  "legalStatus.REGISTERED.createdAt",
-  "legalStatus.REGISTERED.createdAtLocation",
-  "updatedAt"
-]);
-var EventFieldConfigSchema = BaseField3.extend({
-  fieldId: EventFieldId,
-  fieldType: import_zod14.z.literal("event")
-});
-var SearchField = import_zod14.z.discriminatedUnion("fieldType", [
-  FieldConfigSchema,
-  EventFieldConfigSchema
-]);
-var AdvancedSearchConfig = import_zod14.z.object({
+// ../commons/src/events/AdvancedSearchConfig.ts
+var import_zod16 = require("zod");
+var AdvancedSearchConfig = import_zod16.z.object({
   title: TranslationConfig.describe("Advanced search tab title"),
-  fields: import_zod14.z.array(SearchField).describe("Advanced search fields.")
+  fields: import_zod16.z.array(
+    import_zod16.z.object({
+      fieldId: import_zod16.z.string(),
+      config: import_zod16.z.object({
+        type: import_zod16.z.enum(["FUZZY", "EXACT", "RANGE"]).describe("Determines the type of field")
+      }).optional().describe("Configuration options for the field")
+    })
+  ).optional().default([]).describe("Advanced search fields.")
 });
 
 // ../commons/src/events/utils.ts
 var import_lodash = require("lodash");
 
-// ../commons/src/events/ActionDocument.ts
-var import_zod15 = require("zod");
-var import_zod_openapi7 = require("zod-openapi");
-(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod15.z);
-var ActionUpdate = import_zod15.z.record(import_zod15.z.string(), FieldUpdateValue);
-var EventState = import_zod15.z.record(import_zod15.z.string(), FieldValue);
-var ActionStatus = {
-  Requested: "Requested",
-  Accepted: "Accepted",
-  Rejected: "Rejected"
-};
-var ActionBase = import_zod15.z.object({
-  id: import_zod15.z.string(),
-  transactionId: import_zod15.z.string(),
-  createdAt: import_zod15.z.string().datetime(),
-  createdBy: import_zod15.z.string(),
-  createdByRole: import_zod15.z.string(),
-  declaration: ActionUpdate,
-  annotation: ActionUpdate.optional(),
-  createdAtLocation: import_zod15.z.string(),
-  status: import_zod15.z.enum([
-    ActionStatus.Requested,
-    ActionStatus.Accepted,
-    ActionStatus.Rejected
-  ]),
-  // If the action is an asynchronous confirmation for another action, we will save the original action id here.
-  originalActionId: import_zod15.z.string().optional()
+// ../commons/src/workqueues/WorkqueueConfig.ts
+var import_zod18 = require("zod");
+
+// ../commons/src/workqueues/defaultColumns.ts
+var import_zod17 = require("zod");
+var WorkQueueColumnConfig = import_zod17.z.object({
+  id: import_zod17.z.string(),
+  label: TranslationConfig
 });
-var AssignedAction = ActionBase.merge(
-  import_zod15.z.object({
-    type: import_zod15.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod15.z.string()
-  })
-);
-var UnassignedAction = ActionBase.merge(
-  import_zod15.z.object({
-    type: import_zod15.z.literal(ActionType.UNASSIGN),
-    assignedTo: import_zod15.z.literal(null)
-  })
-);
-var RegisterAction = ActionBase.merge(
-  import_zod15.z.object({
-    type: import_zod15.z.literal(ActionType.REGISTER),
-    registrationNumber: import_zod15.z.string().optional()
-  })
-);
-var DeclareAction = ActionBase.merge(
-  import_zod15.z.object({
-    type: import_zod15.z.literal(ActionType.DECLARE)
-  })
-);
-var ValidateAction = ActionBase.merge(
-  import_zod15.z.object({
-    type: import_zod15.z.literal(ActionType.VALIDATE)
-  })
-);
-var RejectAction = ActionBase.merge(
-  import_zod15.z.object({
-    type: import_zod15.z.literal(ActionType.REJECT)
-  })
-);
-var MarkAsDuplicateAction = ActionBase.merge(
-  import_zod15.z.object({
-    type: import_zod15.z.literal(ActionType.MARKED_AS_DUPLICATE)
-  })
-);
-var ArchiveAction = ActionBase.merge(
-  import_zod15.z.object({
-    type: import_zod15.z.literal(ActionType.ARCHIVE)
-  })
-);
-var CreatedAction = ActionBase.merge(
-  import_zod15.z.object({
-    type: import_zod15.z.literal(ActionType.CREATE)
-  })
-);
-var NotifiedAction = ActionBase.merge(
-  import_zod15.z.object({
-    type: import_zod15.z.literal(ActionType.NOTIFY)
-  })
-);
-var PrintCertificateAction = ActionBase.merge(
-  import_zod15.z.object({
-    type: import_zod15.z.literal(ActionType.PRINT_CERTIFICATE)
-  })
-);
-var RequestedCorrectionAction = ActionBase.merge(
-  import_zod15.z.object({
-    type: import_zod15.z.literal(ActionType.REQUEST_CORRECTION)
-  })
-);
-var ApprovedCorrectionAction = ActionBase.merge(
-  import_zod15.z.object({
-    type: import_zod15.z.literal(ActionType.APPROVE_CORRECTION),
-    requestId: import_zod15.z.string()
-  })
-);
-var RejectedCorrectionAction = ActionBase.merge(
-  import_zod15.z.object({
-    type: import_zod15.z.literal(ActionType.REJECT_CORRECTION),
-    requestId: import_zod15.z.string()
-  })
-);
-var ReadAction = ActionBase.merge(
-  import_zod15.z.object({
-    type: import_zod15.z.literal(ActionType.READ)
-  })
+var defaultColumns = {
+  event: {
+    id: "event",
+    label: {
+      defaultMessage: "Event",
+      description: "This is the label for the workqueue column",
+      id: "workqueue.default.column.event"
+    }
+  },
+  status: {
+    id: "status",
+    label: {
+      defaultMessage: "Status",
+      description: "This is the label for the workqueue column",
+      id: "workqueue.default.column.status"
+    }
+  },
+  createdAt: {
+    id: "createdAt",
+    label: {
+      defaultMessage: "Created",
+      description: "This is the label for the workqueue column",
+      id: "workqueue.default.column.createdAt"
+    }
+  },
+  modifiedAt: {
+    id: "modifiedAt",
+    label: {
+      defaultMessage: "Modified",
+      description: "This is the label for the workqueue column",
+      id: "workqueue.default.column.modifiedAt"
+    }
+  }
+};
+var DefaultColumnKeys = import_zod17.z.enum(
+  Object.keys(defaultColumns)
 );
-var ActionDocument = import_zod15.z.discriminatedUnion("type", [
-  CreatedAction.openapi({ ref: "CreatedAction" }),
-  ValidateAction.openapi({ ref: "ValidateAction" }),
-  RejectAction.openapi({ ref: "RejectAction" }),
-  MarkAsDuplicateAction.openapi({ ref: "MarkAsDuplicateAction" }),
-  ArchiveAction.openapi({ ref: "ArchiveAction" }),
-  NotifiedAction.openapi({ ref: "NotifiedAction" }),
-  RegisterAction.openapi({ ref: "RegisterAction" }),
-  DeclareAction.openapi({ ref: "DeclareAction" }),
-  AssignedAction.openapi({ ref: "AssignedAction" }),
-  RequestedCorrectionAction.openapi({ ref: "RequestedCorrectionAction" }),
-  ApprovedCorrectionAction.openapi({ ref: "ApprovedCorrectionAction" }),
-  RejectedCorrectionAction.openapi({ ref: "RejectedCorrectionAction" }),
-  UnassignedAction.openapi({ ref: "UnassignedAction" }),
-  PrintCertificateAction.openapi({ ref: "PrintCertificateAction" }),
-  ReadAction.openapi({ ref: "ReadAction" })
-]).openapi({
-  ref: "ActionDocument"
+
+// ../commons/src/workqueues/WorkqueueConfig.ts
+var rootWorkqueueConfig = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  title: TranslationConfig,
+  columns: import_zod18.z.array(WorkQueueColumnConfig),
+  defaultColumns: import_zod18.z.array(DefaultColumnKeys)
 });
-var AsyncRejectActionDocument = ActionBase.omit({
-  declaration: true,
-  annotation: true
-}).merge(
-  import_zod15.z.object({
-    type: import_zod15.z.enum(ConfirmableActions),
-    status: import_zod15.z.literal(ActionStatus.Rejected)
-  })
-);
-var Action = import_zod15.z.union([ActionDocument, AsyncRejectActionDocument]);
-var ResolvedUser = import_zod15.z.object({
-  id: import_zod15.z.string(),
-  role: import_zod15.z.string(),
-  name: import_zod15.z.array(
-    import_zod15.z.object({
-      use: import_zod15.z.string(),
-      given: import_zod15.z.array(import_zod15.z.string()),
-      family: import_zod15.z.string()
-    })
-  )
+var defineWorkqueue = (config) => rootWorkqueueConfig.parse(config);
+
+// ../commons/src/workqueues/all.ts
+var allWorkqueue = defineWorkqueue({
+  id: "all",
+  title: {
+    defaultMessage: "All events",
+    description: "This is the label for the workqueue",
+    id: "workqueue.all.label"
+  },
+  columns: [
+    {
+      id: "title",
+      label: {
+        defaultMessage: "Title",
+        description: "This is the label for the workqueue column",
+        id: "workqueue.all.column.title"
+      }
+    }
+  ],
+  defaultColumns: ["event", "status", "createdAt", "modifiedAt"]
+});
+
+// ../commons/src/workqueues/readyForReview.ts
+var inReviewWorkqueue = defineWorkqueue({
+  id: "ready-for-review",
+  title: {
+    defaultMessage: "Ready for review",
+    description: "Label for in review workqueue",
+    id: "event.workqueue.in-review.label"
+  },
+  columns: [
+    {
+      id: "title",
+      label: {
+        defaultMessage: "Title",
+        description: "This is the label for the workqueue column",
+        id: "workqueue.in-reveiw.column.title"
+      }
+    }
+  ],
+  defaultColumns: ["event", "createdAt", "modifiedAt"]
+});
+
+// ../commons/src/workqueues/readyToPrint.ts
+var registeredWorkqueue = defineWorkqueue({
+  id: "registered",
+  title: {
+    defaultMessage: "Ready to print",
+    description: "Label for registered workqueue",
+    id: "event.workqueue.registered.label"
+  },
+  columns: [
+    {
+      id: "title",
+      label: {
+        defaultMessage: "Title",
+        description: "This is the label for the workqueue column",
+        id: "workqueue.registered.column.title"
+      }
+    }
+  ],
+  defaultColumns: ["event", "createdAt", "modifiedAt"]
 });
 
+// ../commons/src/workqueues/index.ts
+var workqueues = {
+  all: allWorkqueue,
+  registered: registeredWorkqueue,
+  inReview: inReviewWorkqueue
+};
+
 // ../commons/src/conditionals/validate.ts
 var import_ajv = __toESM(require("ajv"));
 var import_ajv_formats = __toESM(require("ajv-formats"));
 var import_date_fns = require("date-fns");
 
 // ../commons/src/events/FieldTypeMapping.ts
-var import_zod16 = require("zod");
+var import_zod19 = require("zod");
 function mapFieldTypeToZod(type, required) {
   let schema;
   switch (type) {
@@ -1384,9 +1300,6 @@ function mapFieldTypeToZod(type, required) {
     case FieldType.EMAIL:
       schema = EmailValue;
       break;
-    case FieldType.DATE_RANGE:
-      schema = DateRangeFieldValue;
-      break;
     case FieldType.TEXT:
     case FieldType.TEXTAREA:
     case FieldType.DIVIDER:
@@ -1401,7 +1314,8 @@ function mapFieldTypeToZod(type, required) {
     case FieldType.FACILITY:
     case FieldType.OFFICE:
     case FieldType.SIGNATURE:
-      schema = required ? NonEmptyTextValue : TextValue;
+    case FieldType.HIDDEN:
+      schema = required ? RequiredTextValue : TextValue;
       break;
     case FieldType.NUMBER:
       schema = NumberFieldValue;
@@ -1429,7 +1343,7 @@ function createValidationSchema(config) {
   for (const field2 of config) {
     shape[field2.id] = mapFieldTypeToZod(field2.type, field2.required);
   }
-  return import_zod16.z.object(shape);
+  return import_zod19.z.object(shape);
 }
 function mapFieldTypeToMockValue(field2, i) {
   switch (field2.type) {
@@ -1467,8 +1381,6 @@ function mapFieldTypeToMockValue(field2, i) {
       };
     case FieldType.DATE:
       return "2021-01-01";
-    case FieldType.DATE_RANGE:
-      return ["2021-01-01", "2021-01-02"];
     case FieldType.CHECKBOX:
       return true;
     case FieldType.FILE:
@@ -1503,7 +1415,6 @@ function mapFieldTypeToEmptyValue(field2) {
     case FieldType.EMAIL:
     case FieldType.DATE:
     case FieldType.CHECKBOX:
-    case FieldType.DATE_RANGE:
     case FieldType.DATA:
       return null;
     case FieldType.ADDRESS:
@@ -1536,9 +1447,6 @@ var isParagraphFieldType = (field2) => {
 var isDateFieldType = (field2) => {
   return field2.config.type === FieldType.DATE;
 };
-var isDateRangeFieldType = (field2) => {
-  return field2.config.type === FieldType.DATE_RANGE;
-};
 var isPageHeaderFieldType = (field2) => {
   return field2.config.type === FieldType.PAGE_HEADER;
 };
@@ -1609,23 +1517,12 @@ var ajv = new import_ajv.default({
 function validate(schema, data) {
   return ajv.validate(schema, data);
 }
-function isConditionMet(conditional, values) {
-  return validate(conditional, {
-    $form: values,
-    $now: (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" })
-  });
-}
 function getConditionalActionsForField(field2, values) {
   if (!field2.conditionals) {
     return [];
   }
   return field2.conditionals.filter((conditional) => validate(conditional.conditional, values)).map((conditional) => conditional.type);
 }
-function areConditionsMet(conditions, values) {
-  return conditions.every(
-    (condition) => isConditionMet(condition.conditional, values)
-  );
-}
 function isFieldConditionMet(field2, form, conditionalType) {
   const hasRule = (field2.conditionals ?? []).some(
     (conditional) => conditional.type === conditionalType
@@ -1644,10 +1541,6 @@ function isFieldConditionMet(field2, form, conditionalType) {
 function isFieldVisible(field2, form) {
   return isFieldConditionMet(field2, form, ConditionalType.SHOW);
 }
-function isFieldEmptyAndNotRequired(field2, form) {
-  const fieldValue = form[field2.id];
-  return !field2.required && (fieldValue === void 0 || fieldValue === "");
-}
 function isFieldEnabled(field2, form) {
   return isFieldConditionMet(field2, form, ConditionalType.ENABLE);
 }
@@ -1752,11 +1645,6 @@ function runFieldValidations({
   field: field2,
   values
 }) {
-  if (!isFieldVisible(field2, values) || isFieldEmptyAndNotRequired(field2, values)) {
-    return {
-      errors: []
-    };
-  }
   const conditionalParameters = {
     $form: values,
     $now: (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" })
@@ -1774,13 +1662,39 @@ function runFieldValidations({
     errors: [...fieldValidationResult, ...customValidationResults]
   };
 }
-
-// ../commons/src/uuid.ts
-var import_uuid = require("uuid");
+function getFieldValidationErrors({
+  field: field2,
+  values
+}) {
+  if (!isFieldVisible(field2, values) || !isFieldEnabled(field2, values)) {
+    if (values[field2.id]) {
+      return {
+        errors: [
+          {
+            message: errorMessages.hiddenField
+          }
+        ]
+      };
+    }
+    return {
+      errors: []
+    };
+  }
+  return runFieldValidations({
+    field: field2,
+    values
+  });
+}
+
+// ../commons/src/uuid.ts
+var import_uuid = require("uuid");
 function getUUID() {
   return (0, import_uuid.v4)();
 }
 
+// ../commons/src/events/utils.ts
+var import_date_fns2 = require("date-fns");
+
 // ../commons/src/utils.ts
 function getOrThrow(x, message) {
   if (x === void 0 || x === null) {
@@ -1817,9 +1731,15 @@ var getActionAnnotationFields = (actionConfig) => {
   }
   return [];
 };
-function getAllAnnotationFields(config) {
+var getAllAnnotationFields = (config) => {
   return (0, import_lodash.flattenDeep)(config.actions.map(getActionAnnotationFields));
-}
+};
+var findAllFields = (config) => {
+  return (0, import_lodash.flattenDeep)([
+    ...getDeclarationFields(config),
+    ...getAllAnnotationFields(config)
+  ]);
+};
 var findRecordActionPages = (config, actionType) => {
   const action = config.actions.find((a) => a.type === actionType);
   if (action?.type === ActionType.REQUEST_CORRECTION) {
@@ -1842,22 +1762,34 @@ function getActionReview(configuration, actionType) {
 function getActionReviewFields(configuration, actionType) {
   return getActionReview(configuration, actionType).fields;
 }
+function validateWorkqueueConfig(workqueueConfigs) {
+  workqueueConfigs.map((workqueue) => {
+    const rootWorkqueue = Object.values(workqueues).find(
+      (wq) => wq.id === workqueue.id
+    );
+    if (!rootWorkqueue) {
+      throw new Error(
+        `Invalid workqueue configuration: workqueue not found with id: ${workqueue.id}`
+      );
+    }
+  });
+}
 function isPageVisible(page, formValues) {
   if (!page.conditional) {
     return true;
   }
-  return isConditionMet(page.conditional, formValues);
+  return validate(page.conditional, {
+    $form: formValues,
+    $now: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" })
+  });
 }
-function omitHiddenFields(fields, values, visibleVerificationPageIds = []) {
+function omitHiddenFields(fields, values) {
   return (0, import_lodash.omitBy)(values, (_, fieldId) => {
-    if (visibleVerificationPageIds.includes(fieldId)) {
-      return false;
-    }
-    const fieldConfigs = fields.filter((f) => f.id === fieldId);
-    if (!fieldConfigs.length) {
+    const field2 = fields.find((f) => f.id === fieldId);
+    if (!field2) {
       return true;
     }
-    return fieldConfigs.every((f) => !isFieldVisible(f, values));
+    return !isFieldVisible(field2, values);
   });
 }
 function omitHiddenPaginatedFields(formConfig, declaration) {
@@ -1881,49 +1813,13 @@ function createEmptyDraft(eventId, draftId, actionType) {
       annotation: {},
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       createdBy: "@todo",
-      createdAtLocation: "@todo",
-      status: ActionStatus.Accepted,
-      transactionId: "@todo",
-      createdByRole: "@todo"
+      createdAtLocation: "@todo"
     }
   };
 }
 function isVerificationPage(page) {
   return page.type === PageTypes.enum.VERIFICATION;
 }
-function getVisibleVerificationPageIds(pages, annotation) {
-  return pages.filter((page) => isVerificationPage(page)).filter((page) => isPageVisible(page, annotation)).map((page) => page.id);
-}
-function getActionVerificationPageIds(actionConfig, annotation) {
-  if (actionConfig.type === ActionType.REQUEST_CORRECTION) {
-    return [
-      ...getVisibleVerificationPageIds(actionConfig.onboardingForm, annotation),
-      ...getVisibleVerificationPageIds(
-        actionConfig.additionalDetailsForm,
-        annotation
-      )
-    ];
-  }
-  if (actionConfig.type === ActionType.PRINT_CERTIFICATE) {
-    return getVisibleVerificationPageIds(
-      actionConfig.printForm.pages,
-      annotation
-    );
-  }
-  return [];
-}
-function omitHiddenAnnotationFields(actionConfig, declaration, annotation) {
-  const annotationFields = getActionAnnotationFields(actionConfig);
-  const visibleVerificationPageIds = getActionVerificationPageIds(
-    actionConfig,
-    annotation
-  );
-  return omitHiddenFields(
-    annotationFields,
-    { ...declaration, ...annotation },
-    visibleVerificationPageIds
-  );
-}
 function deepMerge(currentDocument, actionDocument) {
   return (0, import_lodash.mergeWith)(
     currentDocument,
@@ -1950,49 +1846,19 @@ function findLastAssignmentAction(actions) {
 function isWriteAction(actionType) {
   return writeActions.safeParse(actionType).success;
 }
-var findAllFields = (config) => {
-  return (0, import_lodash.flattenDeep)([
-    ...getDeclarationFields(config),
-    ...getAllAnnotationFields(config)
-  ]);
-};
-function getMixedPath(obj, path, defaultValue) {
-  const parts = path.split(".");
-  const resolve = (current, segments) => {
-    if (current == null || segments.length === 0) {
-      return current;
-    }
-    for (let i = segments.length; i > 0; i--) {
-      const compoundKey = segments.slice(0, i).join(".");
-      if ((0, import_lodash.has)(current, compoundKey)) {
-        const next = (0, import_lodash.get)(current, compoundKey);
-        return resolve(next, segments.slice(i));
-      }
-    }
-    return void 0;
-  };
-  const result = resolve(obj, parts);
-  return (0, import_lodash.isNil)(result) ? defaultValue : result;
-}
 
 // ../commons/src/events/EventConfig.ts
-var import_zod_openapi8 = require("zod-openapi");
-(0, import_zod_openapi8.extendZodWithOpenApi)(import_zod17.z);
-var EventConfig = import_zod17.z.object({
-  id: import_zod17.z.string().describe(
+var EventConfig = import_zod20.z.object({
+  id: import_zod20.z.string().describe(
     'A machine-readable identifier for the event, e.g. "birth" or "death"'
   ),
-  dateOfEvent: import_zod17.z.object({ fieldId: import_zod17.z.string() }).optional(),
-  title: TranslationConfig,
-  fallbackTitle: TranslationConfig.optional().describe(
-    "This is a fallback title if actual title resolves to empty string"
-  ),
   summary: SummaryConfig,
   label: TranslationConfig,
-  actions: import_zod17.z.array(ActionConfig),
+  actions: import_zod20.z.array(ActionConfig),
   declaration: DeclarationFormConfig,
-  deduplication: import_zod17.z.array(DeduplicationConfig).optional().default([]),
-  advancedSearch: import_zod17.z.array(AdvancedSearchConfig).optional().default([])
+  workqueues: import_zod20.z.array(WorkqueueConfig),
+  deduplication: import_zod20.z.array(DeduplicationConfig).optional().default([]),
+  advancedSearch: import_zod20.z.array(AdvancedSearchConfig).optional().default([])
 }).superRefine((event2, ctx) => {
   const allFields = findAllFields(event2);
   const fieldIds = allFields.map((field2) => field2.id);
@@ -2008,43 +1874,16 @@ var EventConfig = import_zod17.z.object({
     });
   }
   const invalidFields = event2.advancedSearch.flatMap(
-    (section) => (
-      // Check if the fieldId is not in the fieldIds array
-      // and also not in the metadataFields array
-      section.fields.filter(
-        (field2) => !(fieldIds.includes(field2.fieldId) || EventFieldId.options.includes(field2.fieldId))
-      )
-    )
+    (section) => section.fields.filter((field2) => !fieldIds.includes(field2.fieldId))
   );
   if (invalidFields.length > 0) {
     ctx.addIssue({
       code: "custom",
-      message: `Advanced search id must match a field id of form fields or pre-defined metadata fields.
+      message: `Advanced search id must match a field id in fields array.
     Invalid AdvancedSearch field IDs for event ${event2.id}: ${invalidFields.map((f) => f.fieldId).join(", ")}`,
       path: ["advancedSearch"]
     });
   }
-  if (event2.dateOfEvent) {
-    const eventDateFieldId = getDeclarationFields(event2).find(
-      ({ id }) => id === event2.dateOfEvent?.fieldId
-    );
-    if (!eventDateFieldId) {
-      ctx.addIssue({
-        code: "custom",
-        message: `Date of event field id must match a field id in fields array.
-          Invalid date of event field ID for event ${event2.id}: ${event2.dateOfEvent.fieldId}`,
-        path: ["dateOfEvent"]
-      });
-    } else if (eventDateFieldId.type !== FieldType.DATE) {
-      ctx.addIssue({
-        code: "custom",
-        message: `Field specified for date of event is of type: ${eventDateFieldId.type}, but it needs to be of type: ${FieldType.DATE}`,
-        path: ["dateOfEvent.fieldType"]
-      });
-    }
-  }
-}).openapi({
-  ref: "EventConfig"
 });
 
 // ../commons/src/events/EventConfigInput.ts
@@ -2053,48 +1892,521 @@ var defineActionForm = (actionForm) => ActionFormConfig.parse(actionForm);
 var definePage = (page) => PageConfig.parse(page);
 var defineFormPage = (formPage) => FormPageConfig.parse(formPage);
 
-// ../commons/src/events/WorkqueueConfig.ts
+// ../commons/src/events/Draft.ts
+var import_zod23 = require("zod");
+
+// ../commons/src/events/ActionDocument.ts
+var import_zod21 = require("zod");
+var ActionUpdate = import_zod21.z.record(import_zod21.z.string(), FieldUpdateValue);
+var ActionStatus = {
+  Requested: "Requested",
+  Accepted: "Accepted",
+  Rejected: "Rejected"
+};
+var ActionBase = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  createdAt: import_zod21.z.string().datetime(),
+  createdBy: import_zod21.z.string(),
+  declaration: ActionUpdate,
+  annotation: ActionUpdate.optional(),
+  createdAtLocation: import_zod21.z.string(),
+  status: import_zod21.z.enum([
+    ActionStatus.Requested,
+    ActionStatus.Accepted,
+    ActionStatus.Rejected
+  ]),
+  // If the action is an asynchronous confirmation for another action, we will save the original action id here.
+  originalActionId: import_zod21.z.string().optional()
+});
+var AssignedAction = ActionBase.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.ASSIGN),
+    assignedTo: import_zod21.z.string()
+  })
+);
+var UnassignedAction = ActionBase.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.UNASSIGN),
+    assignedTo: import_zod21.z.literal(null).default(null)
+  })
+);
+var RegisterAction = ActionBase.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.REGISTER),
+    registrationNumber: import_zod21.z.string().optional()
+  })
+);
+var DeclareAction = ActionBase.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.DECLARE)
+  })
+);
+var ValidateAction = ActionBase.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.VALIDATE)
+  })
+);
+var RejectAction = ActionBase.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.REJECT)
+  })
+);
+var MarkAsDuplicateAction = ActionBase.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.MARKED_AS_DUPLICATE)
+  })
+);
+var ArchiveAction = ActionBase.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.ARCHIVE)
+  })
+);
+var CreatedAction = ActionBase.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.CREATE)
+  })
+);
+var NotifiedAction = ActionBase.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.NOTIFY)
+  })
+);
+var PrintCertificateAction = ActionBase.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.PRINT_CERTIFICATE)
+  })
+);
+var RequestedCorrectionAction = ActionBase.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.REQUEST_CORRECTION)
+  })
+);
+var ApprovedCorrectionAction = ActionBase.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.APPROVE_CORRECTION),
+    requestId: import_zod21.z.string()
+  })
+);
+var RejectedCorrectionAction = ActionBase.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.REJECT_CORRECTION),
+    requestId: import_zod21.z.string()
+  })
+);
+var ReadAction = ActionBase.merge(
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.READ)
+  })
+);
+var ActionDocument = import_zod21.z.discriminatedUnion("type", [
+  CreatedAction,
+  ValidateAction,
+  RejectAction,
+  MarkAsDuplicateAction,
+  ArchiveAction,
+  NotifiedAction,
+  RegisterAction,
+  DeclareAction,
+  AssignedAction,
+  RequestedCorrectionAction,
+  ApprovedCorrectionAction,
+  RejectedCorrectionAction,
+  UnassignedAction,
+  PrintCertificateAction,
+  ReadAction
+]);
+var AsyncRejectActionDocument = ActionBase.omit({
+  declaration: true,
+  annotation: true,
+  createdBy: true,
+  createdAtLocation: true
+}).merge(
+  import_zod21.z.object({
+    type: import_zod21.z.enum(ConfirmableActions),
+    status: import_zod21.z.literal(ActionStatus.Rejected)
+  })
+);
+var Action = import_zod21.z.union([ActionDocument, AsyncRejectActionDocument]);
+var ResolvedUser = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  role: import_zod21.z.string(),
+  name: import_zod21.z.array(
+    import_zod21.z.object({
+      use: import_zod21.z.string(),
+      given: import_zod21.z.array(import_zod21.z.string()),
+      family: import_zod21.z.string()
+    })
+  )
+});
+
+// ../commons/src/events/ActionInput.ts
+var import_zod22 = require("zod");
+var BaseActionInput = import_zod22.z.object({
+  eventId: import_zod22.z.string(),
+  transactionId: import_zod22.z.string(),
+  declaration: ActionUpdate.default({}),
+  annotation: ActionUpdate.optional(),
+  originalActionId: import_zod22.z.string().optional(),
+  keepAssignment: import_zod22.z.boolean().optional()
+});
+var CreateActionInput = BaseActionInput.merge(
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.CREATE).default(ActionType.CREATE),
+    createdAtLocation: import_zod22.z.string()
+  })
+);
+var RegisterActionInput = BaseActionInput.merge(
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
+    registrationNumber: import_zod22.z.string().optional()
+  })
+);
+var ValidateActionInput = BaseActionInput.merge(
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
+    duplicates: import_zod22.z.array(import_zod22.z.string())
+  })
+);
+var NotifyActionInput = BaseActionInput.merge(
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
+  })
+);
+var DeclareActionInput = BaseActionInput.merge(
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
+  })
+);
+var PrintCertificateActionInput = BaseActionInput.merge(
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
+  })
+);
+var RejectDeclarationActionInput = BaseActionInput.merge(
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.REJECT).default(ActionType.REJECT)
+  })
+);
+var MarkedAsDuplicateActionInput = BaseActionInput.merge(
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
+  })
+);
+var ArchiveActionInput = BaseActionInput.merge(
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE)
+  })
+);
+var AssignActionInput = BaseActionInput.merge(
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
+    assignedTo: import_zod22.z.string()
+  })
+);
+var UnassignActionInput = BaseActionInput.merge(
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
+    assignedTo: import_zod22.z.literal(null).default(null)
+  })
+);
+var RequestCorrectionActionInput = BaseActionInput.merge(
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
+  })
+);
+var RejectCorrectionActionInput = BaseActionInput.merge(
+  import_zod22.z.object({
+    requestId: import_zod22.z.string(),
+    type: import_zod22.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
+  })
+);
+var ApproveCorrectionActionInput = BaseActionInput.merge(
+  import_zod22.z.object({
+    requestId: import_zod22.z.string(),
+    type: import_zod22.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
+  })
+);
+var ReadActionInput = BaseActionInput.merge(
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.READ).default(ActionType.READ)
+  })
+);
+var ActionInput = import_zod22.z.discriminatedUnion("type", [
+  CreateActionInput,
+  ValidateActionInput,
+  RegisterActionInput,
+  NotifyActionInput,
+  DeclareActionInput,
+  RejectDeclarationActionInput,
+  MarkedAsDuplicateActionInput,
+  ArchiveActionInput,
+  AssignActionInput,
+  UnassignActionInput,
+  PrintCertificateActionInput,
+  RequestCorrectionActionInput,
+  RejectCorrectionActionInput,
+  ApproveCorrectionActionInput,
+  ReadActionInput
+]);
+
+// ../commons/src/events/Draft.ts
+var Draft = import_zod23.z.object({
+  id: import_zod23.z.string(),
+  eventId: import_zod23.z.string(),
+  transactionId: import_zod23.z.string(),
+  createdAt: import_zod23.z.string().datetime(),
+  action: ActionBase.extend({
+    type: ActionTypes
+  }).omit({ id: true })
+});
+var DraftInput = BaseActionInput.extend({
+  type: ActionTypes
+});
+
+// ../commons/src/events/EventInput.ts
 var import_zod24 = require("zod");
+var EventInput = import_zod24.z.object({
+  transactionId: import_zod24.z.string(),
+  type: import_zod24.z.string()
+});
 
-// ../commons/src/events/serializers/user/serializer.ts
-var import_zod18 = require("zod");
-var SerializedUserField = import_zod18.z.object({
-  $userField: import_zod18.z.enum([
-    "id",
-    "name",
-    "role",
-    "signatureFilename",
-    "primaryOfficeId"
-  ])
+// ../commons/src/events/EventDocument.ts
+var import_zod25 = require("zod");
+var EventDocument = import_zod25.z.object({
+  id: import_zod25.z.string(),
+  type: import_zod25.z.string(),
+  createdAt: import_zod25.z.string().datetime(),
+  updatedAt: import_zod25.z.string().datetime(),
+  actions: import_zod25.z.array(Action),
+  trackingId: import_zod25.z.string()
 });
-function userSerializer(userField) {
-  return {
-    $userField: userField
-  };
-}
 
-// ../commons/src/conditionals/conditionals.ts
-function defineConditional(schema) {
-  return schema;
-}
-function defineFormConditional(schema) {
-  const schemaWithForm = {
-    type: "object",
-    properties: {
-      $form: schema
-    },
-    required: ["$form"]
-  };
-  return defineConditional(schemaWithForm);
-}
-function alwaysTrue() {
-  return {};
+// ../commons/src/events/EventIndex.ts
+var import_zod26 = require("zod");
+var EventIndex = EventMetadata.extend({
+  declaration: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any())
+});
+var EventSearchIndex = import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any()).and(
+  import_zod26.z.object({
+    type: import_zod26.z.string()
+    // Ensures "type" (event-id) exists and is a string
+  })
+);
+
+// ../commons/src/events/state/index.ts
+function getStatusFromActions(actions) {
+  const hasRejectedAction = actions.some(
+    (a) => a.status === ActionStatus.Rejected
+  );
+  if (hasRejectedAction) {
+    return EventStatus.REJECTED;
+  }
+  return actions.reduce((status, action) => {
+    if (action.type === ActionType.CREATE) {
+      return EventStatus.CREATED;
+    }
+    if (action.type === ActionType.DECLARE) {
+      return EventStatus.DECLARED;
+    }
+    if (action.type === ActionType.VALIDATE) {
+      return EventStatus.VALIDATED;
+    }
+    if (action.type === ActionType.REGISTER) {
+      return EventStatus.REGISTERED;
+    }
+    if (action.type === ActionType.REJECT) {
+      return EventStatus.REJECTED;
+    }
+    if (action.type === ActionType.ARCHIVE) {
+      return EventStatus.ARCHIVED;
+    }
+    if (action.type === ActionType.NOTIFY) {
+      return EventStatus.NOTIFIED;
+    }
+    return status;
+  }, EventStatus.CREATED);
 }
-function and(...conditions) {
-  return defineConditional({
-    type: "object",
-    allOf: conditions,
-    required: []
+function getAssignedUserFromActions(actions) {
+  return actions.reduce((user2, action) => {
+    if (action.type === ActionType.ASSIGN) {
+      return action.assignedTo;
+    }
+    if (action.type === ActionType.UNASSIGN) {
+      return null;
+    }
+    return user2;
+  }, null);
+}
+function aggregateActionDeclarations(actions) {
+  const excludedActions = [
+    ActionType.REQUEST_CORRECTION,
+    ActionType.PRINT_CERTIFICATE
+  ];
+  return actions.reduce((status, action) => {
+    if (excludedActions.some((excludedAction) => excludedAction === action.type)) {
+      return status;
+    }
+    if (action.type === ActionType.APPROVE_CORRECTION) {
+      const requestAction = actions.find(({ id }) => id === action.requestId);
+      if (!requestAction) {
+        return status;
+      }
+      return deepMerge(status, requestAction.declaration);
+    }
+    return deepMerge(status, action.declaration);
+  }, {});
+}
+function deepDropNulls(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(deepDropNulls);
+  }
+  if (obj !== null && typeof obj === "object") {
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+      const cleanedValue = deepDropNulls(value);
+      if (cleanedValue !== null) {
+        ;
+        acc[key] = cleanedValue;
+      }
+      return acc;
+    }, {});
+  }
+  return obj;
+}
+function isUndeclaredDraft(status) {
+  return status === EventStatus.CREATED;
+}
+function getAcceptedActions(event2) {
+  return event2.actions.filter(
+    (a) => a.status === ActionStatus.Accepted
+  );
+}
+function getCurrentEventState(event2) {
+  const creationAction = event2.actions.find(
+    (action) => action.type === ActionType.CREATE
+  );
+  if (!creationAction) {
+    throw new Error(`Event ${event2.id} has no creation action`);
+  }
+  const activeActions = getAcceptedActions(event2);
+  const latestAction = activeActions[activeActions.length - 1];
+  const registrationAction = activeActions.find(
+    (a) => a.type === ActionType.REGISTER && a.status === ActionStatus.Accepted
+  );
+  const registrationNumber = registrationAction?.registrationNumber ?? null;
+  return deepDropNulls({
+    id: event2.id,
+    type: event2.type,
+    status: getStatusFromActions(event2.actions),
+    createdAt: event2.createdAt,
+    createdBy: creationAction.createdBy,
+    createdAtLocation: creationAction.createdAtLocation,
+    modifiedAt: latestAction.createdAt,
+    assignedTo: getAssignedUserFromActions(activeActions),
+    updatedBy: latestAction.createdBy,
+    declaration: aggregateActionDeclarations(activeActions),
+    trackingId: event2.trackingId,
+    registrationNumber
+  });
+}
+function getCurrentEventStateWithDrafts(event2, drafts) {
+  const actions = event2.actions.slice().sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const activeDrafts = findActiveDrafts(event2, drafts).map((draft) => draft.action).flatMap((action) => {
+    if (action.type === ActionType.REQUEST_CORRECTION) {
+      return [
+        action,
+        {
+          ...action,
+          type: ActionType.APPROVE_CORRECTION
+        }
+      ];
+    }
+    return [action];
+  });
+  const actionWithDrafts = [...actions, ...activeDrafts].sort();
+  const withDrafts = {
+    ...event2,
+    actions: actionWithDrafts
+  };
+  return getCurrentEventState(withDrafts);
+}
+function applyDraftsToEventIndex(eventIndex, drafts) {
+  const indexedAt = eventIndex.modifiedAt;
+  const activeDrafts = drafts.filter(({ createdAt }) => new Date(createdAt) > new Date(indexedAt)).map((draft) => draft.action).sort();
+  if (activeDrafts.length === 0) {
+    return eventIndex;
+  }
+  return {
+    ...eventIndex,
+    declaration: {
+      ...eventIndex.declaration,
+      ...activeDrafts[activeDrafts.length - 1].declaration
+    }
+  };
+}
+function getAnnotationFromDrafts(drafts) {
+  const actions = drafts.map((draft) => draft.action);
+  const annotation = actions.reduce((ann, action) => {
+    return deepMerge(ann, action.annotation ?? {});
+  }, {});
+  return deepDropNulls(annotation);
+}
+function getActionAnnotation({
+  event: event2,
+  actionType,
+  drafts
+}) {
+  const activeActions = getAcceptedActions(event2);
+  const action = activeActions.find(
+    (activeAction) => actionType === activeAction.type
+  );
+  const eventDrafts = drafts.filter((draft) => draft.eventId === event2.id);
+  const sorted = [
+    ...action ? [action] : [],
+    ...eventDrafts.map((draft) => draft.action)
+  ].sort();
+  const annotation = sorted.reduce((ann, sortedAction) => {
+    return deepMerge(ann, sortedAction.annotation ?? {});
+  }, {});
+  return deepDropNulls(annotation);
+}
+
+// ../commons/src/events/defineConfig.ts
+var defineConfig = (config) => {
+  validateWorkqueueConfig(config.workqueues);
+  const input = EventConfig.parse(config);
+  return input;
+};
+
+// ../commons/src/events/transactions.ts
+function generateTransactionId() {
+  return getUUID();
+}
+
+// ../commons/src/events/test.utils.ts
+var import_lodash2 = require("lodash");
+
+// ../commons/src/conditionals/conditionals.ts
+function defineConditional(schema) {
+  return schema;
+}
+function defineFormConditional(schema) {
+  const schemaWithForm = {
+    type: "object",
+    properties: {
+      $form: schema
+    },
+    required: ["$form"]
+  };
+  return defineConditional(schemaWithForm);
+}
+function alwaysTrue() {
+  return {};
+}
+function and(...conditions) {
+  return defineConditional({
+    type: "object",
+    allOf: conditions,
+    required: []
   });
 }
 function or(...conditions) {
@@ -2114,7 +2426,7 @@ function not(condition) {
 function never() {
   return not(alwaysTrue());
 }
-var user = Object.assign(userSerializer, {
+var user = {
   hasScope: (scope) => defineConditional({
     type: "object",
     properties: {
@@ -2134,39 +2446,33 @@ 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"]
-              }
+};
+var event = {
+  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"]
-    })
-  };
-}
+          }
+        },
+        required: ["actions"]
+      }
+    },
+    required: ["$event"]
+  })
+};
 function getDateFromNow(days) {
   return new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString().split("T")[0];
 }
@@ -2187,7 +2493,7 @@ function getDateRangeToFieldReference(fieldId, comparedFieldId, clause) {
 function isFieldReference(value) {
   return typeof value === "object" && value !== null && "_fieldId" in value;
 }
-function createFieldConditionals(fieldId) {
+function field(fieldId) {
   const getDateRange = (date, clause) => ({
     type: "object",
     properties: {
@@ -2200,6 +2506,10 @@ function createFieldConditionals(fieldId) {
     required: [fieldId]
   });
   return {
+    /**
+     * @private Internal property used for field reference tracking.
+     */
+    _fieldId: fieldId,
     isAfter: () => ({
       days: (days) => ({
         inPast: () => defineFormConditional(
@@ -2272,1215 +2582,105 @@ function createFieldConditionals(fieldId) {
               { type: "boolean", const: value }
             ],
             const: value
-          }
-        },
-        required: [fieldId]
-      });
-    },
-    /**
-     * Use case: Some fields are rendered when selection is not made, or boolean false is explicitly selected.
-     * @example field('recommender.none').isFalsy() vs not(field('recommender.none').isEqualTo(true))
-     * @returns whether the field is falsy (undefined, false, null, empty string)
-     *
-     * NOTE: For now, this only works with string, boolean, and null types. 0 is still allowed.
-     *
-     */
-    isFalsy: () => defineFormConditional({
-      type: "object",
-      properties: {
-        [fieldId]: {
-          anyOf: [
-            { const: "undefined" },
-            { const: false },
-            { const: null },
-            { const: "" }
-          ]
-        }
-      },
-      anyOf: [
-        {
-          required: [fieldId]
-        },
-        {
-          not: {
-            required: [fieldId]
-          }
-        }
-      ]
-    }),
-    isUndefined: () => defineFormConditional({
-      type: "object",
-      properties: {
-        [fieldId]: {
-          type: "string",
-          enum: ["undefined"]
-        }
-      },
-      not: {
-        required: [fieldId]
-      }
-    }),
-    inArray: (values) => defineFormConditional({
-      type: "object",
-      properties: {
-        [fieldId]: {
-          type: "string",
-          enum: values
-        }
-      },
-      required: [fieldId]
-    }),
-    isValidEnglishName: () => defineFormConditional({
-      type: "object",
-      properties: {
-        [fieldId]: {
-          type: "string",
-          pattern: "^[\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*( [\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*)*$",
-          description: "Name must contain only letters, numbers, and allowed special characters ('._-). No double spaces."
-        }
-      },
-      required: [fieldId]
-    }),
-    /**
-     * Checks if the field value matches a given regular expression pattern.
-     * @param pattern - The regular expression pattern to match the field value against.
-     * @returns A JSONSchema conditional that validates the field value against the pattern.
-     */
-    matches: (pattern) => defineFormConditional({
-      type: "object",
-      properties: {
-        [fieldId]: {
-          type: "string",
-          pattern
-        }
-      },
-      required: [fieldId]
-    }),
-    isBetween: (min, max) => defineFormConditional({
-      type: "object",
-      properties: {
-        [fieldId]: {
-          type: "number",
-          minimum: min,
-          maximum: max
-        }
-      },
-      required: [fieldId]
-    }),
-    getId: () => ({ fieldId })
-  };
-}
-
-// ../commons/src/searchConfigs.ts
-function createSearchConfig(baseField) {
-  return {
-    /**
-     * Creates a range configuration for the specified field.
-     *
-     * @returns An object containing the field ID and a configuration object with a type of 'range'.
-     *
-     * @example event('legalStatus.REGISTERED.createdAt').range()
-     * // {
-     * //   ...
-     * //   config: { type: 'range' }
-     * // }
-     */
-    range: () => ({
-      ...baseField,
-      config: { type: "range" }
-    }),
-    /**
-     * Creates a configuration for exact matching of the specified field.
-     * @returns  An object containing the field ID and a configuration object with a type of 'exact'.
-     * @example field('dob').exact()
-     * // {
-     * //   ...
-     * //   config: { type: 'exact' }
-     * // }
-     */
-    exact: () => ({
-      ...baseField,
-      config: { type: "exact" }
-    }),
-    /**
-     * Creates a configuration for fuzzy matching of the specified field.
-     * @returns  An object containing the field ID and a configuration object with a type of 'exact'.
-     * @example field('name').fuzzy()
-     * // {
-     * //   ...
-     * //   config: { type: 'fuzzy' }
-     * // }
-     */
-    fuzzy: () => ({
-      ...baseField,
-      config: { type: "fuzzy" }
-    })
-  };
-}
-
-// ../commons/src/event-config/event-configuration.ts
-function createEventFieldConfig(fieldId, options) {
-  const baseField = {
-    fieldId,
-    options,
-    fieldType: "event"
-  };
-  return createSearchConfig(baseField);
-}
-
-// ../commons/src/events/event.ts
-function eventFn(fieldId, options) {
-  return createEventFieldConfig(fieldId, options);
-}
-var event = Object.assign(eventFn, {
-  ...createEventConditionals(),
-  field(field2) {
-    return {
-      $event: field2
-    };
-  }
-});
-
-// ../commons/src/events/WorkqueueColumnConfig.ts
-var import_zod20 = require("zod");
-
-// ../commons/src/events/EventMetadata.ts
-var import_zod19 = require("zod");
-var EventStatus = {
-  CREATED: "CREATED",
-  NOTIFIED: "NOTIFIED",
-  DECLARED: "DECLARED",
-  VALIDATED: "VALIDATED",
-  REGISTERED: "REGISTERED",
-  CERTIFIED: "CERTIFIED",
-  REJECTED: "REJECTED",
-  ARCHIVED: "ARCHIVED"
-};
-var eventStatusValues = [
-  EventStatus.CREATED,
-  EventStatus.NOTIFIED,
-  EventStatus.DECLARED,
-  EventStatus.VALIDATED,
-  EventStatus.REGISTERED,
-  EventStatus.CERTIFIED,
-  EventStatus.REJECTED,
-  EventStatus.ARCHIVED
-];
-var EventStatusEnum = import_zod19.z.enum(eventStatusValues);
-var CustomFlags = {
-  CERTIFICATE_PRINTED: "certificate-printed"
-};
-var Flag = import_zod19.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_zod19.z.nativeEnum(CustomFlags));
-var eventStatuses = Object.values(EventStatus);
-var EventStatuses = import_zod19.z.nativeEnum(EventStatus);
-var ZodDate = import_zod19.z.string().date();
-var ActionCreationMetadata = import_zod19.z.object({
-  createdAt: import_zod19.z.string().datetime().describe("The timestamp when the action request was created."),
-  createdBy: import_zod19.z.string().describe("ID of the user who created the action request."),
-  createdAtLocation: import_zod19.z.string().describe("Location of the user who created the action request."),
-  acceptedAt: import_zod19.z.string().datetime().describe("Timestamp when the action request was accepted."),
-  createdByRole: import_zod19.z.string().describe("Role of the user at the time of action request creation.")
-});
-var RegistrationCreationMetadata = ActionCreationMetadata.extend({
-  registrationNumber: import_zod19.z.string().describe(
-    "Registration number of the event. Always present for accepted registrations."
-  )
-});
-var LegalStatuses = import_zod19.z.object({
-  [EventStatus.DECLARED]: ActionCreationMetadata.nullish(),
-  [EventStatus.REGISTERED]: RegistrationCreationMetadata.nullish()
-});
-var EventMetadata = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  title: import_zod19.z.string(),
-  type: import_zod19.z.string().describe("The type of event, such as birth, death, or marriage."),
-  status: EventStatuses,
-  legalStatuses: LegalStatuses.describe(
-    "Metadata related to the legal registration of the event, such as who registered it and when."
-  ),
-  createdAt: import_zod19.z.string().datetime().describe("The timestamp when the event was first created and saved."),
-  dateOfEvent: ZodDate.nullish(),
-  createdBy: import_zod19.z.string().describe("ID of the user who created the event."),
-  updatedByUserRole: import_zod19.z.string().describe("Role of the user who last updated the declaration."),
-  createdAtLocation: import_zod19.z.string().describe("Location of the user who created the event."),
-  updatedAtLocation: import_zod19.z.string().nullish().describe("Location of the user who last updated the declaration."),
-  updatedAt: import_zod19.z.string().datetime().describe("Timestamp of the most recent declaration update."),
-  assignedTo: import_zod19.z.string().nullish().describe("ID of the user currently assigned to the event."),
-  updatedBy: import_zod19.z.string().nullish().describe("ID of the user who last updated the declaration."),
-  trackingId: import_zod19.z.string().describe(
-    "System-generated tracking ID used by informants or registrars to look up the event."
-  ),
-  flags: import_zod19.z.array(Flag)
-});
-var EventMetadataKeys = import_zod19.z.enum([
-  "id",
-  "title",
-  "type",
-  "status",
-  "createdAt",
-  "dateOfEvent",
-  "createdBy",
-  "updatedByUserRole",
-  "createdAtLocation",
-  "updatedAtLocation",
-  "updatedAt",
-  "assignedTo",
-  "updatedBy",
-  "trackingId",
-  "legalStatuses",
-  "flags"
-]);
-var EventMetadataParameter = import_zod19.z.object({
-  // @TODO: Reconcile with the event metadata definition. How could we derive one from the other?
-  $event: EventMetadataKeys
-});
-var eventMetadataLabelMap = {
-  "event.assignedTo": {
-    id: "event.assignedTo.label",
-    defaultMessage: "Assigned To",
-    description: "Assigned To"
-  },
-  "event.title": {
-    id: "event.title.label",
-    defaultMessage: "Title",
-    description: "Title"
-  },
-  "event.createdAt": {
-    id: "event.createdAt.label",
-    defaultMessage: "Created",
-    description: "Created At"
-  },
-  "event.dateOfEvent": {
-    id: "event.dateOfEvent.label",
-    defaultMessage: "Date of Event",
-    description: "Date of Event"
-  },
-  "event.createdAtLocation": {
-    id: "event.createdAtLocation.label",
-    defaultMessage: "Location",
-    description: "Created At Location"
-  },
-  "event.updatedAtLocation": {
-    id: "event.updatedAtLocation.label",
-    defaultMessage: "Location",
-    description: "Updated At Location"
-  },
-  "event.createdBy": {
-    id: "event.createdBy.label",
-    defaultMessage: "Created By",
-    description: "Created By"
-  },
-  "event.updatedByUserRole": {
-    id: "event.updatedByUserRole.label",
-    defaultMessage: "Updated By Role",
-    description: "Updated By Role"
-  },
-  "event.id": {
-    id: "event.id.label",
-    defaultMessage: "ID",
-    description: "ID"
-  },
-  "event.updatedAt": {
-    id: "event.modifiedAt.label",
-    defaultMessage: "Updated",
-    description: "Modified At"
-  },
-  "event.status": {
-    id: "event.status.label",
-    defaultMessage: "Status",
-    description: "Status"
-  },
-  "event.type": {
-    id: "event.type.label",
-    defaultMessage: "Type",
-    description: "Type"
-  },
-  "event.updatedBy": {
-    id: "event.updatedBy.label",
-    defaultMessage: "Updated By",
-    description: "Updated By"
-  },
-  "event.trackingId": {
-    id: "event.trackingId.label",
-    defaultMessage: "Tracking ID",
-    description: "Tracking ID"
-  },
-  "event.flags": {
-    id: "event.flags.label",
-    defaultMessage: "Flags",
-    description: "Flags"
-  }
-};
-
-// ../commons/src/events/WorkqueueColumnConfig.ts
-var WorkqueueColumn = import_zod20.z.object({
-  label: TranslationConfig,
-  value: EventMetadataParameter
-});
-function defineWorkqueuesColumns(workqueueColumns) {
-  return workqueueColumns.map(
-    (workqueueColumn) => WorkqueueColumn.parse(workqueueColumn)
-  );
-}
-
-// ../commons/src/events/CountryConfigQueryInput.ts
-var import_zod21 = require("zod");
-var Fuzzy = import_zod21.z.object({ type: import_zod21.z.literal("fuzzy"), term: import_zod21.z.string() });
-var Exact = import_zod21.z.object({ type: import_zod21.z.literal("exact"), term: import_zod21.z.string() });
-var AnyOf = import_zod21.z.object({
-  type: import_zod21.z.literal("anyOf"),
-  terms: import_zod21.z.array(import_zod21.z.string())
-});
-var AnyOfStatus = import_zod21.z.object({
-  type: import_zod21.z.literal("anyOf"),
-  terms: import_zod21.z.array(EventStatusEnum)
-});
-var SerializableExact = import_zod21.z.object({
-  type: import_zod21.z.literal("exact"),
-  term: import_zod21.z.union([import_zod21.z.string(), SerializedUserField])
-});
-var ExactStatus = import_zod21.z.object({
-  type: import_zod21.z.literal("exact"),
-  term: EventStatusEnum
-});
-var Range = import_zod21.z.object({
-  type: import_zod21.z.literal("range"),
-  gte: import_zod21.z.string(),
-  lte: import_zod21.z.string()
-});
-var Not = import_zod21.z.object({ type: import_zod21.z.literal("not"), term: import_zod21.z.string() });
-var Within = import_zod21.z.object({ type: import_zod21.z.literal("within"), location: import_zod21.z.string() });
-var SerializableWithin = import_zod21.z.object({
-  type: import_zod21.z.literal("within"),
-  location: import_zod21.z.union([import_zod21.z.string(), SerializedUserField])
-});
-var DateCondition = import_zod21.z.union([Exact, Range]);
-var QueryInput = import_zod21.z.lazy(
-  () => import_zod21.z.union([
-    import_zod21.z.discriminatedUnion("type", [Fuzzy, Exact, Range, Within, AnyOf, Not]),
-    import_zod21.z.record(import_zod21.z.string(), QueryInput)
-  ])
-);
-var SerializedQueryExpression = import_zod21.z.object({
-  title: import_zod21.z.string(),
-  eventType: import_zod21.z.string(),
-  status: import_zod21.z.optional(import_zod21.z.union([AnyOfStatus, ExactStatus])),
-  createdAt: import_zod21.z.optional(DateCondition),
-  updatedAt: import_zod21.z.optional(DateCondition),
-  createdAtLocation: import_zod21.z.optional(
-    import_zod21.z.union([SerializableWithin, SerializableExact])
-  ),
-  updatedAtLocation: import_zod21.z.optional(
-    import_zod21.z.union([SerializableWithin, SerializableExact])
-  ),
-  assignedTo: import_zod21.z.optional(SerializableExact),
-  createdBy: import_zod21.z.optional(SerializableExact),
-  updatedBy: import_zod21.z.optional(SerializableExact),
-  trackingId: import_zod21.z.optional(Exact),
-  flags: import_zod21.z.optional(import_zod21.z.array(import_zod21.z.union([AnyOf, Not]))),
-  data: QueryInput
-}).partial();
-var Or2 = import_zod21.z.object({
-  type: import_zod21.z.literal("or"),
-  clauses: import_zod21.z.array(SerializedQueryExpression)
-});
-var And2 = import_zod21.z.object({
-  type: import_zod21.z.literal("and"),
-  clauses: import_zod21.z.array(SerializedQueryExpression)
-});
-var CountryConfigQueryType = import_zod21.z.discriminatedUnion("type", [And2, Or2]);
-var CountryConfigQueryInputType = import_zod21.z.union([
-  SerializedQueryExpression,
-  And2,
-  Or2
-]);
-
-// ../commons/src/icons.ts
-var import_zod22 = require("zod");
-var AvailableIcons = import_zod22.z.enum([
-  "Archived",
-  "Assigned",
-  "Certified",
-  "Close",
-  "Collapse",
-  "Draft",
-  "DuplicateYellow",
-  "Expand",
-  "ExternalValidate",
-  "FilledCheck",
-  "InReview",
-  "Offline",
-  "Registered",
-  "RequiresUpdates",
-  "Sent",
-  "Validated",
-  "WaitingApproval",
-  "ChartActivity",
-  "Activity",
-  "Archive",
-  "ArchiveTray",
-  "ArrowLeft",
-  "ArrowRight",
-  "Buildings",
-  "Circle",
-  "CaretDown",
-  "CaretLeft",
-  "CaretRight",
-  "ChartBar",
-  "ChartLine",
-  "ChatCircle",
-  "CheckSquare",
-  "Compass",
-  "Check",
-  "Copy",
-  "Database",
-  "DotsThreeVertical",
-  "DownloadSimple",
-  "ArrowCounterClockwise",
-  "MagnifyingGlassMinus",
-  "MagnifyingGlassPlus",
-  "Export",
-  "Eye",
-  "EyeSlash",
-  "Envelope",
-  "File",
-  "FileSearch",
-  "FileMinus",
-  "FilePlus",
-  "FileText",
-  "FileX",
-  "Handshake",
-  "Gear",
-  "GitBranch",
-  "IdentificationCard",
-  "List",
-  "ListBullets",
-  "Lock",
-  "MagnifyingGlass",
-  "MapPin",
-  "Medal",
-  "NotePencil",
-  "Paperclip",
-  "PaperPlaneTilt",
-  "Pen",
-  "Pencil",
-  "PencilSimpleLine",
-  "Phone",
-  "Plus",
-  "Printer",
-  "SignOut",
-  "Star",
-  "Target",
-  "TextT",
-  "Trash",
-  "UploadSimple",
-  "User",
-  "UserPlus",
-  "Users",
-  "WarningCircle",
-  "X",
-  "CircleWavyCheck",
-  "CircleWavyQuestion",
-  "ArchiveBox",
-  "ArrowCircleDown",
-  "FileArrowUp",
-  "FileDotted",
-  "Files",
-  "PencilLine",
-  "PencilCircle",
-  "UserCircle",
-  "Clock",
-  "QrCode",
-  "Webcam",
-  "Sun",
-  "DeviceTabletCamera",
-  "Globe",
-  "Fingerprint",
-  "PushPin",
-  "Timer"
-]);
-
-// ../commons/src/events/EventIndex.ts
-var import_zod23 = require("zod");
-var EventIndex = EventMetadata.extend({
-  declaration: EventState
-});
-var EventSearchIndex = import_zod23.z.record(import_zod23.z.string(), import_zod23.z.any()).and(
-  import_zod23.z.object({
-    type: import_zod23.z.string()
-    // Ensures "type" (event-id) exists and is a string
-  })
-);
-var Fuzzy2 = import_zod23.z.object({ type: import_zod23.z.literal("fuzzy"), term: import_zod23.z.string() });
-var Exact2 = import_zod23.z.object({ type: import_zod23.z.literal("exact"), term: import_zod23.z.string() });
-var AnyOf2 = import_zod23.z.object({
-  type: import_zod23.z.literal("anyOf"),
-  terms: import_zod23.z.array(import_zod23.z.string())
-});
-var ExactStatus2 = import_zod23.z.object({
-  type: import_zod23.z.literal("exact"),
-  term: EventStatusEnum
-});
-var AnyOfStatus2 = import_zod23.z.object({
-  type: import_zod23.z.literal("anyOf"),
-  terms: import_zod23.z.array(EventStatusEnum)
-});
-var Range2 = import_zod23.z.object({
-  type: import_zod23.z.literal("range"),
-  gte: import_zod23.z.string(),
-  lte: import_zod23.z.string()
-});
-var Not2 = import_zod23.z.object({ type: import_zod23.z.literal("not"), term: import_zod23.z.string() });
-var Within2 = import_zod23.z.object({ type: import_zod23.z.literal("within"), location: import_zod23.z.string() });
-var DateCondition2 = import_zod23.z.union([Exact2, Range2]);
-var QueryInput2 = import_zod23.z.lazy(
-  () => import_zod23.z.union([
-    import_zod23.z.discriminatedUnion("type", [Fuzzy2, Exact2, Range2, Within2, AnyOf2, Not2]),
-    import_zod23.z.record(import_zod23.z.string(), QueryInput2)
-  ])
-);
-var QueryExpression = import_zod23.z.object({
-  title: import_zod23.z.string(),
-  eventType: import_zod23.z.string(),
-  status: import_zod23.z.optional(import_zod23.z.union([AnyOfStatus2, ExactStatus2])),
-  createdAt: import_zod23.z.optional(DateCondition2),
-  updatedAt: import_zod23.z.optional(DateCondition2),
-  "legalStatus.REGISTERED.createdAt": import_zod23.z.optional(DateCondition2),
-  "legalStatus.REGISTERED.createdAtLocation": import_zod23.z.optional(
-    import_zod23.z.union([Within2, Exact2])
-  ),
-  createdAtLocation: import_zod23.z.optional(import_zod23.z.union([Within2, Exact2])),
-  updatedAtLocation: import_zod23.z.optional(import_zod23.z.union([Within2, Exact2])),
-  assignedTo: import_zod23.z.optional(Exact2),
-  createdBy: import_zod23.z.optional(Exact2),
-  updatedBy: import_zod23.z.optional(Exact2),
-  trackingId: import_zod23.z.optional(Exact2),
-  flags: import_zod23.z.optional(import_zod23.z.array(import_zod23.z.union([AnyOf2, Not2]))),
-  data: QueryInput2
-}).partial();
-var Or3 = import_zod23.z.object({
-  type: import_zod23.z.literal("or"),
-  clauses: import_zod23.z.array(QueryExpression)
-});
-var And3 = import_zod23.z.object({
-  type: import_zod23.z.literal("and"),
-  clauses: import_zod23.z.array(QueryExpression)
-});
-var QueryType = import_zod23.z.discriminatedUnion("type", [Or3, And3]);
-
-// ../commons/src/events/WorkqueueConfig.ts
-var defaultThirdColumn = defineWorkqueuesColumns([
-  {
-    label: {
-      id: "workqueues.dateOfEvent",
-      defaultMessage: "Date of Event",
-      description: "Label for workqueue column: dateOfEvent"
-    },
-    value: event.field("dateOfEvent")
-  }
-]);
-var WorkqueueConfig = import_zod24.z.object({
-  slug: import_zod24.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_zod24.z.array(
-    import_zod24.z.object({
-      type: import_zod24.z.string(),
-      conditionals: import_zod24.z.array(Conditional).optional()
-    })
-  ),
-  columns: import_zod24.z.array(WorkqueueColumn).default(defaultThirdColumn),
-  icon: AvailableIcons
-}).describe("Configuration for workqueue.");
-var WorkqueueConfigInput = import_zod24.z.object({
-  slug: import_zod24.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_zod24.z.array(
-    import_zod24.z.object({
-      type: import_zod24.z.string(),
-      conditionals: import_zod24.z.array(Conditional).optional()
-    })
-  ),
-  columns: import_zod24.z.array(WorkqueueColumn).default(defaultThirdColumn),
-  icon: AvailableIcons
-});
-function defineWorkqueue(workqueueInput) {
-  const queryInput = workqueueInput.query;
-  const query = "type" in queryInput ? queryInput : { type: "and", clauses: [queryInput] };
-  return WorkqueueConfig.parse({ ...workqueueInput, query });
-}
-function defineWorkqueues(workqueues) {
-  return workqueues.map((workqueue) => defineWorkqueue(workqueue));
-}
-var WorkqueueCountInput = import_zod24.z.array(
-  import_zod24.z.object({ slug: import_zod24.z.string(), query: QueryType })
-);
-var WorkqueueCountOutput = import_zod24.z.record(import_zod24.z.string(), import_zod24.z.number());
-
-// ../commons/src/events/workqueueDefaultColumns.ts
-var defaultWorkqueueColumns = [
-  {
-    label: {
-      defaultMessage: "Title",
-      description: "This is the label for the workqueue column",
-      id: "workqueue.in-reveiw.column.title"
-    },
-    value: event.field("title")
-  },
-  {
-    label: {
-      defaultMessage: "Event",
-      description: "This is the label for the workqueue column",
-      id: "workqueue.default.column.event"
-    },
-    value: event.field("type")
-  },
-  {
-    label: {
-      defaultMessage: "Last updated",
-      description: "This is the label for the workqueue column",
-      id: "workqueue.default.column.modifiedAt"
-    },
-    value: event.field("updatedAt")
-  }
-];
-
-// ../commons/src/events/Draft.ts
-var import_zod26 = require("zod");
-
-// ../commons/src/events/ActionInput.ts
-var import_zod25 = require("zod");
-var import_zod_openapi9 = require("zod-openapi");
-(0, import_zod_openapi9.extendZodWithOpenApi)(import_zod25.z);
-var BaseActionInput = import_zod25.z.object({
-  eventId: import_zod25.z.string(),
-  transactionId: import_zod25.z.string(),
-  declaration: ActionUpdate.default({}),
-  annotation: ActionUpdate.optional(),
-  originalActionId: import_zod25.z.string().optional(),
-  keepAssignment: import_zod25.z.boolean().optional()
-});
-var CreateActionInput = BaseActionInput.merge(
-  import_zod25.z.object({
-    type: import_zod25.z.literal(ActionType.CREATE).default(ActionType.CREATE),
-    createdAtLocation: import_zod25.z.string()
-  })
-);
-var RegisterActionInput = BaseActionInput.merge(
-  import_zod25.z.object({
-    type: import_zod25.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
-    registrationNumber: import_zod25.z.string().optional()
-  })
-);
-var ValidateActionInput = BaseActionInput.merge(
-  import_zod25.z.object({
-    type: import_zod25.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
-    duplicates: import_zod25.z.array(import_zod25.z.string())
-  })
-);
-var NotifyActionInput = BaseActionInput.merge(
-  import_zod25.z.object({
-    type: import_zod25.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
-  })
-);
-var DeclareActionInput = BaseActionInput.merge(
-  import_zod25.z.object({
-    type: import_zod25.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
-  })
-);
-var PrintCertificateActionInput = BaseActionInput.merge(
-  import_zod25.z.object({
-    type: import_zod25.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
-  })
-);
-var RejectDeclarationActionInput = BaseActionInput.merge(
-  import_zod25.z.object({
-    type: import_zod25.z.literal(ActionType.REJECT).default(ActionType.REJECT)
-  })
-);
-var MarkedAsDuplicateActionInput = BaseActionInput.merge(
-  import_zod25.z.object({
-    type: import_zod25.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
-  })
-);
-var ArchiveActionInput = BaseActionInput.merge(
-  import_zod25.z.object({
-    type: import_zod25.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE)
-  })
-);
-var AssignActionInput = BaseActionInput.merge(
-  import_zod25.z.object({
-    type: import_zod25.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
-    assignedTo: import_zod25.z.string()
-  })
-);
-var UnassignActionInput = BaseActionInput.merge(
-  import_zod25.z.object({
-    type: import_zod25.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
-    assignedTo: import_zod25.z.literal(null).default(null)
-  })
-);
-var RequestCorrectionActionInput = BaseActionInput.merge(
-  import_zod25.z.object({
-    type: import_zod25.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
-  })
-);
-var RejectCorrectionActionInput = BaseActionInput.merge(
-  import_zod25.z.object({
-    requestId: import_zod25.z.string(),
-    type: import_zod25.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
-  })
-);
-var ApproveCorrectionActionInput = BaseActionInput.merge(
-  import_zod25.z.object({
-    requestId: import_zod25.z.string(),
-    type: import_zod25.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
-  })
-);
-var ReadActionInput = BaseActionInput.merge(
-  import_zod25.z.object({
-    type: import_zod25.z.literal(ActionType.READ).default(ActionType.READ)
-  })
-);
-var DeleteActionInput = import_zod25.z.object({ eventId: import_zod25.z.string() });
-var ActionInput = import_zod25.z.discriminatedUnion("type", [
-  CreateActionInput.openapi({ ref: "CreateActionInput" }),
-  ValidateActionInput.openapi({ ref: "ValidateActionInput" }),
-  RegisterActionInput.openapi({ ref: "RegisterActionInput" }),
-  NotifyActionInput.openapi({ ref: "NotifyActionInput" }),
-  DeclareActionInput.openapi({ ref: "DeclareActionInput" }),
-  RejectDeclarationActionInput.openapi({
-    ref: "RejectDeclarationActionInput"
-  }),
-  MarkedAsDuplicateActionInput.openapi({
-    ref: "MarkedAsDuplicateActionInput"
-  }),
-  ArchiveActionInput.openapi({ ref: "ArchiveActionInput" }),
-  AssignActionInput.openapi({ ref: "AssignActionInput" }),
-  UnassignActionInput.openapi({ ref: "UnassignActionInput" }),
-  PrintCertificateActionInput.openapi({ ref: "PrintCertificateActionInput" }),
-  RequestCorrectionActionInput.openapi({
-    ref: "RequestCorrectionActionInput"
-  }),
-  RejectCorrectionActionInput.openapi({ ref: "RejectCorrectionActionInput" }),
-  ApproveCorrectionActionInput.openapi({
-    ref: "ApproveCorrectionActionInput"
-  }),
-  ReadActionInput.openapi({ ref: "ReadActionInput" })
-]).openapi({
-  ref: "ActionInput"
-});
-
-// ../commons/src/events/Draft.ts
-var Draft = import_zod26.z.object({
-  id: import_zod26.z.string(),
-  eventId: import_zod26.z.string(),
-  transactionId: import_zod26.z.string(),
-  createdAt: import_zod26.z.string().datetime(),
-  action: ActionBase.extend({
-    type: ActionTypes
-  }).omit({ id: true })
-});
-var DraftInput = BaseActionInput.extend({
-  type: ActionTypes,
-  status: import_zod26.z.enum([
-    ActionStatus.Requested,
-    ActionStatus.Accepted,
-    ActionStatus.Rejected
-  ])
-});
-
-// ../commons/src/events/EventInput.ts
-var import_zod27 = require("zod");
-var EventInput = import_zod27.z.object({
-  transactionId: import_zod27.z.string(),
-  type: import_zod27.z.string()
-});
-
-// ../commons/src/events/EventDocument.ts
-var import_zod28 = require("zod");
-var import_zod_openapi10 = require("zod-openapi");
-(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod28.z);
-var EventDocument = import_zod28.z.object({
-  id: import_zod28.z.string(),
-  type: import_zod28.z.string(),
-  createdAt: import_zod28.z.string().datetime(),
-  updatedAt: import_zod28.z.string().datetime(),
-  actions: import_zod28.z.array(Action),
-  trackingId: import_zod28.z.string()
-}).openapi({ ref: "EventDocument" });
-
-// ../commons/src/events/state/utils.ts
-function getActionRequests(actionType, actions) {
-  const filtered = actions.filter((action) => action.type === actionType);
-  const accept = filtered.find(
-    (action) => action.status === ActionStatus.Accepted
-  );
-  const request = filtered.find(
-    (action) => action.status === ActionStatus.Requested
-  );
-  const reject = filtered.find(
-    (action) => action.status === ActionStatus.Rejected
-  );
-  return {
-    reject,
-    accept,
-    request
-  };
-}
-function getDeclarationActionCreationMetadata(actionType, actions) {
-  const { accept: acceptAction, request: requestAction } = getActionRequests(
-    actionType,
-    actions
-  );
-  if (!acceptAction) {
-    return null;
-  }
-  const registrationNumber = acceptAction.type === ActionType.REGISTER ? acceptAction.registrationNumber : null;
-  return {
-    // When 3rd party API returns 200 OK, we assume that the request was accepted, and persist single 'accepted' action.
-    createdAt: requestAction?.createdAt ?? acceptAction.createdAt,
-    createdBy: requestAction?.createdBy ?? acceptAction.createdBy,
-    createdAtLocation: requestAction?.createdAtLocation ?? acceptAction.createdAtLocation,
-    acceptedAt: acceptAction.createdAt,
-    createdByRole: requestAction?.createdByRole ?? acceptAction.createdByRole,
-    registrationNumber
-  };
-}
-function getDeclarationActionUpdateMetadata(actions) {
-  const createAction = getOrThrow(
-    actions.find((action) => action.type === ActionType.CREATE),
-    `Event has no ${ActionType.CREATE} action`
-  );
-  return [ActionType.DECLARE, ActionType.VALIDATE, ActionType.REGISTER].reduce(
-    (metadata, actionType) => {
-      const { accept, request } = getActionRequests(actionType, actions);
-      return {
-        createdAt: request?.createdAt ?? accept?.createdAt ?? metadata.createdAt,
-        createdBy: request?.createdBy ?? accept?.createdBy ?? metadata.createdBy,
-        createdAtLocation: request?.createdAtLocation ?? accept?.createdAtLocation ?? metadata.createdAtLocation,
-        createdByRole: request?.createdByRole ?? accept?.createdByRole ?? metadata.createdByRole
-      };
-    },
-    {
-      createdAt: createAction.createdAt,
-      createdBy: createAction.createdBy,
-      createdAtLocation: createAction.createdAtLocation,
-      createdByRole: createAction.createdByRole
-    }
-  );
-}
-function getLegalStatuses(actions) {
-  return {
-    [EventStatus.DECLARED]: getDeclarationActionCreationMetadata(
-      ActionType.DECLARE,
-      actions
-    ),
-    [EventStatus.REGISTERED]: getDeclarationActionCreationMetadata(
-      ActionType.REGISTER,
-      actions
-    )
-  };
-}
-
-// ../commons/src/events/state/index.ts
-function getStatusFromActions(actions) {
-  const hasRejectedAction = actions.some(
-    (a) => a.status === ActionStatus.Rejected
-  );
-  if (hasRejectedAction) {
-    return EventStatus.REJECTED;
-  }
-  return actions.reduce((status, action) => {
-    switch (action.type) {
-      case ActionType.CREATE:
-        return EventStatus.CREATED;
-      case ActionType.DECLARE:
-        return EventStatus.DECLARED;
-      case ActionType.VALIDATE:
-        return EventStatus.VALIDATED;
-      case ActionType.REGISTER:
-        return EventStatus.REGISTERED;
-      case ActionType.REJECT:
-        return EventStatus.REJECTED;
-      case ActionType.ARCHIVE:
-        return EventStatus.ARCHIVED;
-      case ActionType.NOTIFY:
-        return EventStatus.NOTIFIED;
-      case ActionType.PRINT_CERTIFICATE:
-        return EventStatus.CERTIFIED;
-      case ActionType.ASSIGN:
-      case ActionType.UNASSIGN:
-      case ActionType.REQUEST_CORRECTION:
-      case ActionType.APPROVE_CORRECTION:
-      case ActionType.MARKED_AS_DUPLICATE:
-      case ActionType.REJECT_CORRECTION:
-      case ActionType.READ:
-      default:
-        return status;
-    }
-  }, EventStatus.CREATED);
-}
-function getFlagsFromActions(actions) {
-  const sortedactions = actions.sort(
-    (a, b) => a.createdAt.localeCompare(b.createdAt)
-  );
-  const actionStatus = sortedactions.reduce(
-    (actionStatuses, { type, status }) => ({
-      ...actionStatuses,
-      [type]: status
-    }),
-    {}
-  );
-  const flags = Object.entries(actionStatus).filter(([, status]) => status !== ActionStatus.Accepted).map(([type, status]) => {
-    const flag = `${type.toLowerCase()}:${status.toLowerCase()}`;
-    return flag;
-  });
-  const isCertificatePrinted = sortedactions.reduce(
-    (prev, { type }) => {
-      if (type === ActionType.PRINT_CERTIFICATE) {
-        return true;
-      }
-      if (type === ActionType.APPROVE_CORRECTION) {
-        return false;
-      }
-      return prev;
-    },
-    false
-  );
-  if (isCertificatePrinted) {
-    flags.push(CustomFlags.CERTIFICATE_PRINTED);
-  }
-  return flags;
-}
-function getAssignedUserFromActions(actions) {
-  return actions.reduce((user2, action) => {
-    if (action.type === ActionType.ASSIGN) {
-      return action.assignedTo;
-    }
-    if (action.type === ActionType.UNASSIGN) {
-      return null;
-    }
-    return user2;
-  }, null);
-}
-function aggregateActionDeclarations(actions) {
-  const excludedActions = [
-    ActionType.REQUEST_CORRECTION,
-    ActionType.PRINT_CERTIFICATE
-  ];
-  return actions.reduce((declaration, action) => {
-    if (excludedActions.some((excludedAction) => excludedAction === action.type)) {
-      return declaration;
-    }
-    if (action.type === ActionType.APPROVE_CORRECTION) {
-      const requestAction = actions.find(({ id }) => id === action.requestId);
-      if (!requestAction) {
-        return declaration;
-      }
-      return deepMerge(declaration, requestAction.declaration);
-    }
-    return deepMerge(declaration, action.declaration);
-  }, {});
-}
-function deepDropNulls(obj) {
-  if (Array.isArray(obj)) {
-    return obj.map(deepDropNulls);
-  }
-  if (obj !== null && typeof obj === "object") {
-    return Object.entries(obj).reduce((acc, [key, value]) => {
-      const cleanedValue = deepDropNulls(value);
-      if (cleanedValue !== null) {
-        ;
-        acc[key] = cleanedValue;
-      }
-      return acc;
-    }, {});
-  }
-  return obj;
-}
-function isUndeclaredDraft(status) {
-  return status === EventStatus.CREATED;
-}
-function getAcceptedActions(event2) {
-  return event2.actions.filter(
-    (a) => a.status === ActionStatus.Accepted
-  );
-}
-var DEFAULT_DATE_OF_EVENT_PROPERTY = "createdAt";
-function getCurrentEventState(event2, config) {
-  const creationAction = event2.actions.find(
-    (action) => action.type === ActionType.CREATE
-  );
-  if (!creationAction) {
-    throw new Error(`Event ${event2.id} has no creation action`);
-  }
-  const acceptedActions = getAcceptedActions(event2);
-  const declarationUpdateMetadata = getDeclarationActionUpdateMetadata(
-    event2.actions
-  );
-  const declaration = aggregateActionDeclarations(acceptedActions);
-  let dateOfEvent;
-  if (config && config.dateOfEvent) {
-    const parsedDate = ZodDate.safeParse(
-      declaration[config.dateOfEvent.fieldId]
-    );
-    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,
-    title: "ToDo",
-    status: getStatusFromActions(event2.actions),
-    legalStatuses: getLegalStatuses(event2.actions),
-    createdAt: creationAction.createdAt,
-    createdBy: creationAction.createdBy,
-    createdAtLocation: creationAction.createdAtLocation,
-    updatedAt: declarationUpdateMetadata.createdAt,
-    assignedTo: getAssignedUserFromActions(acceptedActions),
-    updatedBy: declarationUpdateMetadata.createdBy,
-    updatedAtLocation: declarationUpdateMetadata.createdAtLocation,
-    declaration,
-    trackingId: event2.trackingId,
-    // @TODO: unify this with rest of the code. It will trip us if updatedBy has different rules than updatedByUserRole
-    updatedByUserRole: declarationUpdateMetadata.createdByRole,
-    dateOfEvent,
-    flags: getFlagsFromActions(event2.actions)
-  });
-}
-function getCurrentEventStateWithDrafts({
-  event: event2,
-  drafts,
-  configuration
-}) {
-  const actions = event2.actions.slice().sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-  const activeDrafts = findActiveDrafts(event2, drafts).map((draft) => draft.action).flatMap((action) => {
-    if (action.type === ActionType.REQUEST_CORRECTION) {
-      return [
-        action,
-        {
-          ...action,
-          type: ActionType.APPROVE_CORRECTION
-        }
-      ];
-    }
-    return [action];
-  });
-  const actionWithDrafts = [...actions, ...activeDrafts].sort();
-  const withDrafts = {
-    ...event2,
-    actions: actionWithDrafts
-  };
-  return getCurrentEventState(withDrafts, configuration);
-}
-function applyDraftsToEventIndex(eventIndex, drafts) {
-  const indexedAt = eventIndex.updatedAt;
-  const activeDrafts = drafts.filter(({ createdAt }) => new Date(createdAt) > new Date(indexedAt)).map((draft) => draft.action).sort();
-  if (activeDrafts.length === 0) {
-    return eventIndex;
-  }
-  return {
-    ...eventIndex,
-    declaration: {
-      ...eventIndex.declaration,
-      ...activeDrafts[activeDrafts.length - 1].declaration
-    }
-  };
-}
-function getAnnotationFromDrafts(drafts) {
-  const actions = drafts.map((draft) => draft.action);
-  const annotation = actions.reduce((ann, action) => {
-    return deepMerge(ann, action.annotation ?? {});
-  }, {});
-  return deepDropNulls(annotation);
-}
-function getActionAnnotation({
-  event: event2,
-  actionType,
-  drafts = []
-}) {
-  const activeActions = getAcceptedActions(event2);
-  const action = activeActions.find(
-    (activeAction) => actionType === activeAction.type
-  );
-  const eventDrafts = drafts.filter((draft) => draft.eventId === event2.id);
-  const sorted = [
-    ...action ? [action] : [],
-    ...eventDrafts.map((draft) => draft.action)
-  ].sort();
-  const annotation = sorted.reduce((ann, sortedAction) => {
-    return deepMerge(ann, sortedAction.annotation ?? {});
-  }, {});
-  return deepDropNulls(annotation);
-}
-
-// ../commons/src/events/defineConfig.ts
-var defineConfig = (config) => {
-  const input = EventConfig.parse(config);
-  return input;
-};
-
-// ../commons/src/events/transactions.ts
-function generateTransactionId() {
-  return getUUID();
-}
-
-// ../commons/src/events/User.ts
-var import_zod29 = require("zod");
-var User = import_zod29.z.object({
-  id: import_zod29.z.string(),
-  name: import_zod29.z.array(
-    import_zod29.z.object({
-      use: import_zod29.z.string(),
-      given: import_zod29.z.array(import_zod29.z.string()),
-      family: import_zod29.z.string()
-    })
-  ),
-  role: import_zod29.z.string(),
-  signatureFilename: import_zod29.z.string().optional()
-});
-
-// ../commons/src/events/test.utils.ts
-var import_lodash2 = require("lodash");
-
-// ../commons/src/field-config/field-configuration.ts
-function createFieldConfig(fieldId, options) {
-  const baseField = {
-    fieldId,
-    fieldType: "field",
-    ...options
-  };
-  return createSearchConfig(baseField);
-}
-
-// ../commons/src/events/field.ts
-function field(fieldId, options = {}) {
-  return {
+          }
+        },
+        required: [fieldId]
+      });
+    },
     /**
-     * @private Internal property used for field reference tracking.
+     * Use case: Some fields are rendered when selection is not made, or boolean false is explicitly selected.
+     * @example field('recommender.none').isFalsy() vs not(field('recommender.none').isEqualTo(true))
+     * @returns whether the field is falsy (undefined, false, null, empty string)
+     *
+     * NOTE: For now, this only works with string, boolean, and null types. 0 is still allowed.
+     *
      */
-    _fieldId: fieldId,
-    ...createFieldConditionals(fieldId),
-    ...createFieldConfig(fieldId, options)
+    isFalsy: () => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          anyOf: [
+            { const: "undefined" },
+            { const: false },
+            { const: null },
+            { const: "" }
+          ]
+        }
+      },
+      anyOf: [
+        {
+          required: [fieldId]
+        },
+        {
+          not: {
+            required: [fieldId]
+          }
+        }
+      ]
+    }),
+    isUndefined: () => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "string",
+          enum: ["undefined"]
+        }
+      },
+      not: {
+        required: [fieldId]
+      }
+    }),
+    inArray: (values) => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "string",
+          enum: values
+        }
+      },
+      required: [fieldId]
+    }),
+    isValidEnglishName: () => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "string",
+          pattern: "^[\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*( [\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*)*$",
+          description: "Name must contain only letters, numbers, and allowed special characters ('._-). No double spaces."
+        }
+      },
+      required: [fieldId]
+    }),
+    /**
+     * Checks if the field value matches a given regular expression pattern.
+     * @param pattern - The regular expression pattern to match the field value against.
+     * @returns A JSONSchema conditional that validates the field value against the pattern.
+     */
+    matches: (pattern) => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "string",
+          pattern
+        }
+      },
+      required: [fieldId]
+    }),
+    isBetween: (min, max) => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "number",
+          minimum: min,
+          maximum: max
+        }
+      },
+      required: [fieldId]
+    })
   };
 }
 
 // ../commons/src/fixtures/tennis-club-membership-event.ts
-var import_date_fns2 = require("date-fns");
 var PRINT_CERTIFICATE_FORM = defineActionForm({
   label: {
     id: "v2.event.tennis-club-membership.action.certificate.form.label",
@@ -4389,139 +3589,27 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
     }
   ]
 });
-var statusOptions = [
-  {
-    value: "ALL",
-    label: {
-      defaultMessage: "Any status",
-      description: "Option for form field: status of record",
-      id: "v2.advancedSearch.form.recordStatusAny"
-    }
-  },
-  {
-    value: EventStatus.CREATED,
-    label: {
-      defaultMessage: "Draft",
-      description: "Option for form field: status of record",
-      id: "v2.advancedSearch.form.recordStatusCreated"
-    }
-  },
-  {
-    value: EventStatus.NOTIFIED,
-    label: {
-      defaultMessage: "Notified",
-      description: "Option for form field: status of record",
-      id: "v2.advancedSearch.form.recordStatusNotified"
-    }
-  },
-  {
-    value: EventStatus.DECLARED,
-    label: {
-      defaultMessage: "Declared",
-      description: "Option for form field: status of record",
-      id: "v2.advancedSearch.form.recordStatusDeclared"
-    }
-  },
-  {
-    value: EventStatus.VALIDATED,
-    label: {
-      defaultMessage: "Validated",
-      description: "Option for form field: status of record",
-      id: "v2.advancedSearch.form.recordStatusValidated"
-    }
-  },
-  {
-    value: EventStatus.REGISTERED,
-    label: {
-      defaultMessage: "Registered",
-      description: "Option for form field: status of record",
-      id: "v2.advancedSearch.form.recordStatusRegistered"
-    }
-  },
-  {
-    value: EventStatus.CERTIFIED,
-    label: {
-      defaultMessage: "Certified",
-      description: "Option for form field: status of record",
-      id: "v2.advancedSearch.form.recordStatusCertified"
-    }
-  },
-  {
-    value: EventStatus.REJECTED,
-    label: {
-      defaultMessage: "Rejected",
-      description: "Option for form field: status of record",
-      id: "v2.advancedSearch.form.recordStatusRejected"
-    }
-  },
-  {
-    value: EventStatus.ARCHIVED,
-    label: {
-      defaultMessage: "Archived",
-      description: "Option for form field: status of record",
-      id: "v2.advancedSearch.form.recordStatusArchived"
-    }
-  }
-];
-var timePeriodOptions = [
-  {
-    label: {
-      defaultMessage: "Last 7 days",
-      description: "Label for option of time period select: last 7 days",
-      id: "form.section.label.timePeriodLast7Days"
-    },
-    value: `${(0, import_date_fns2.format)((0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 7), "yyyy-MM-dd")},${(0, import_date_fns2.format)(
-      /* @__PURE__ */ new Date(),
-      "yyyy-MM-dd"
-    )}`
-  },
-  {
-    label: {
-      defaultMessage: "Last 30 days",
-      description: "Label for option of time period select: last 30 days",
-      id: "form.section.label.timePeriodLast30Days"
-    },
-    value: `${(0, import_date_fns2.format)((0, import_date_fns2.subMonths)(/* @__PURE__ */ new Date(), 1), "yyyy-MM-dd")},${(0, import_date_fns2.format)(
-      /* @__PURE__ */ new Date(),
-      "yyyy-MM-dd"
-    )}`
-  },
-  {
-    label: {
-      defaultMessage: "Last 90 days",
-      description: "Label for option of time period select: last 90 days",
-      id: "form.section.label.timePeriodLast90Days"
-    },
-    value: `${(0, import_date_fns2.format)((0, import_date_fns2.subQuarters)(/* @__PURE__ */ new Date(), 1), "yyyy-MM-dd")},${(0, import_date_fns2.format)(
-      /* @__PURE__ */ new Date(),
-      "yyyy-MM-dd"
-    )}`
-  },
-  {
-    label: {
-      defaultMessage: "Last year",
-      description: "Label for option of time period select: last year",
-      id: "form.section.label.timePeriodLastYear"
-    },
-    value: `${(0, import_date_fns2.format)((0, import_date_fns2.subYears)(/* @__PURE__ */ new Date(), 1), "yyyy-MM-dd")},${(0, import_date_fns2.format)(
-      /* @__PURE__ */ new Date(),
-      "yyyy-MM-dd"
-    )}`
-  }
-];
 var tennisClubMembershipEvent = defineConfig({
-  id: "tennis-club-membership",
+  id: "TENNIS_CLUB_MEMBERSHIP",
   label: {
     defaultMessage: "Tennis club membership application",
     description: "This is what this event is referred as in the system",
     id: "event.tennis-club-membership.label"
   },
-  title: {
-    defaultMessage: "{applicant.firstname} {applicant.surname}",
-    description: "This is the title of the summary",
-    id: "v2.event.tennis-club-membership.title"
-  },
   summary: {
+    title: {
+      id: "event.tennis-club-membership.summary.title",
+      label: {
+        defaultMessage: "{applicant.firstname} {applicant.surname}",
+        description: "This is the title of the summary",
+        id: "v2.event.tennis-club-membership.summary.title"
+      },
+      emptyValueMessage: {
+        defaultMessage: "Membership application",
+        description: "This is the message shown when the applicant name is missing",
+        id: "event.tennis-club-membership.summary.title.empty"
+      }
+    },
     fields: [
       {
         id: "applicant.firstname",
@@ -4542,18 +3630,47 @@ var tennisClubMembershipEvent = defineConfig({
         }
       },
       {
-        fieldId: "applicant.surname",
+        id: "applicant.surname",
         label: {
           defaultMessage: "Applicant's last name",
-          description: "Label for surname",
-          id: "v2.event.tennis-club-membership.summary.field.surname.label"
+          description: "This is the label for the field",
+          id: "event.tennis-club-membership.summary.field.surname.label"
+        },
+        value: {
+          defaultMessage: "{applicant.surname}",
+          description: "This is the value to show in the summary",
+          id: "event.tennis-club-membership.summary.field.surname"
+        },
+        emptyValueMessage: {
+          defaultMessage: "Last name is not provided",
+          description: "This is the message to show when the field is empty",
+          id: "event.tennis-club-membership.summary.field.surname.empty"
         }
-      },
-      {
-        fieldId: "applicant.email"
       }
     ]
   },
+  workqueues: [
+    {
+      id: "all",
+      filters: []
+    },
+    {
+      id: "ready-for-review",
+      filters: [
+        {
+          status: ["DECLARED"]
+        }
+      ]
+    },
+    {
+      id: "registered",
+      filters: [
+        {
+          status: ["REGISTERED"]
+        }
+      ]
+    }
+  ],
   actions: [
     {
       type: ActionType.DECLARE,
@@ -4857,61 +3974,19 @@ var tennisClubMembershipEvent = defineConfig({
   advancedSearch: [
     {
       title: {
-        defaultMessage: "Registration details",
-        description: "The title of Registration details accordion",
-        id: "v2.advancedSearch.form.registrationDetails"
-      },
-      fields: [
-        event("legalStatus.REGISTERED.createdAtLocation").exact(),
-        event("legalStatus.REGISTERED.createdAt").range(),
-        event("status", statusOptions).exact(),
-        event("updatedAt", timePeriodOptions).range()
-      ]
-    },
-    {
-      title: {
-        defaultMessage: "Applicant's details",
-        description: "Applicant details search field section title",
-        id: "v2.event.tennis-club-membership.search.applicants"
-      },
-      fields: [
-        field("applicant.firstname").fuzzy(),
-        field("applicant.surname").fuzzy(),
-        field("applicant.dob").range(),
-        field("applicant.email").exact()
-      ]
-    },
-    {
-      title: {
-        defaultMessage: "Recommender's details",
-        description: "Recommender details search field section title",
-        id: "v2.event.tennis-club-membership.search.recommender"
+        defaultMessage: "Tennis club registration search",
+        description: "This is what this event is referred as in the system",
+        id: "v2.event.tennis-club-membership.search"
       },
       fields: [
-        field("recommender.firstname").fuzzy(),
-        field("recommender.surname").fuzzy()
+        {
+          fieldId: "applicant.dob"
+        }
       ]
     }
   ],
   declaration: TENNIS_CLUB_DECLARATION_FORM
 });
-var WorkqueueFixture = defineWorkqueues([
-  {
-    columns: [],
-    slug: "in-progress",
-    name: {
-      id: "workqueues.inProgress.title",
-      defaultMessage: "In progress",
-      description: "Title of in progress workqueue"
-    },
-    query: {
-      type: "and",
-      clauses: [{ eventType: tennisClubMembershipEvent.id }]
-    },
-    actions: [],
-    icon: "Draft"
-  }
-]);
 
 // ../commons/src/events/test.utils.ts
 function fieldConfigsToActionPayload(fields) {
@@ -4940,10 +4015,10 @@ function generateActionAnnotationInput(configuration, action) {
   );
   const annotationFields = actionConfig ? getActionAnnotationFields(actionConfig) : [];
   const annotation = fieldConfigsToActionPayload(annotationFields);
-  const visibleVerificationPageIds = getVisibleVerificationPageIds(
-    findRecordActionPages(configuration, action),
-    annotation
-  );
+  const visibleVerificationPageIds = findRecordActionPages(
+    configuration,
+    action
+  ).filter((page) => isVerificationPage(page)).filter((page) => isPageVisible(page, annotation)).map((page) => page.id);
   const visiblePageVerificationMap = visibleVerificationPageIds.reduce(
     (acc, pageId) => ({
       ...acc,
@@ -4960,11 +4035,11 @@ function generateActionAnnotationInput(configuration, action) {
 var eventPayloadGenerator = {
   create: (input = {}) => ({
     transactionId: input.transactionId ?? getUUID(),
-    type: input.type ?? "tennis-club-membership"
+    type: input.type ?? "TENNIS_CLUB_MEMBERSHIP"
   }),
   patch: (id, input = {}) => ({
     transactionId: input.transactionId ?? getUUID(),
-    type: input.type ?? "tennis-club-membership",
+    type: input.type ?? "TENNIS_CLUB_MEMBERSHIP",
     id
   }),
   draft: ({ eventId, actionType }, input = {}) => (0, import_lodash2.merge)(
@@ -4974,7 +4049,6 @@ var eventPayloadGenerator = {
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       transactionId: getUUID(),
       action: {
-        transactionId: getUUID(),
         type: actionType,
         status: ActionStatus.Accepted,
         declaration: {
@@ -4989,7 +4063,6 @@ var eventPayloadGenerator = {
         },
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         createdBy: "@todo",
-        createdByRole: "@todo",
         createdAtLocation: "@todo"
       }
     },
@@ -5151,14 +4224,12 @@ function generateActionDocument({
     // @TODO: This should be fixed in the future.
     createdAt: new Date(Date.now() - 500).toISOString(),
     createdBy: getUUID(),
-    createdByRole: "FIELD_AGENT",
     id: getUUID(),
-    createdAtLocation: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
+    createdAtLocation: "TODO",
     declaration: generateActionDeclarationInput(configuration, action),
     annotation: {},
-    status: ActionStatus.Accepted,
-    transactionId: getUUID(),
-    ...defaults
+    ...defaults,
+    status: ActionStatus.Accepted
   };
   switch (action) {
     case ActionType.READ:
@@ -5238,100 +4309,29 @@ function generateEventDraftDocument(eventId, actionType = ActionType.DECLARE, de
     eventId
   };
 }
-function getEventStatus() {
-  const statuses = [
-    EventStatus.CREATED,
-    EventStatus.REGISTERED,
-    EventStatus.DECLARED
-  ];
-  const randomIndex = Math.floor(Math.random() * 3);
-  return statuses[randomIndex];
-}
-function getTrackingId() {
-  const uuid = getUUID().replace(/-/g, "");
-  const trackingId = uuid.slice(0, 6).toUpperCase();
-  return trackingId;
-}
-function getRandomApplicant() {
-  const firstNames = [
-    "Danny",
-    "John",
-    "Jane",
-    "Emily",
-    "Michael",
-    "Sarah",
-    "Chris",
-    "Jessica"
-  ];
-  const surnames = [
-    "Doe",
-    "Smith",
-    "Johnson",
-    "Brown",
-    "Williams",
-    "Jones",
-    "Garcia",
-    "Miller"
-  ];
-  function getRandomDate(start, end) {
-    const randomDate = new Date(
-      start.getTime() + Math.random() * (end.getTime() - start.getTime())
-    );
-    return randomDate.toISOString().split("T")[0];
-  }
-  const randomFirstName = firstNames[Math.floor(Math.random() * firstNames.length)];
-  const randomSurname = surnames[Math.floor(Math.random() * surnames.length)];
-  const randomDob = getRandomDate(
-    /* @__PURE__ */ new Date("1990-01-01"),
-    /* @__PURE__ */ new Date("2010-12-31")
-  );
-  return {
-    "recommender.none": true,
-    "applicant.firstname": randomFirstName,
-    "applicant.surname": randomSurname,
-    "applicant.dob": randomDob
-  };
-}
 var eventQueryDataGenerator = (overrides = {}) => ({
   id: overrides.id ?? getUUID(),
-  title: overrides.title ?? "Danny Doe",
   type: overrides.type ?? "tennis-club-membership",
-  status: overrides.status ?? getEventStatus(),
+  status: overrides.status ?? "REGISTERED",
   createdAt: overrides.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
   createdBy: overrides.createdBy ?? getUUID(),
   createdAtLocation: overrides.createdAtLocation ?? getUUID(),
-  updatedAtLocation: overrides.updatedAtLocation ?? getUUID(),
-  updatedAt: overrides.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+  modifiedAt: overrides.modifiedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
   assignedTo: overrides.assignedTo ?? null,
   updatedBy: overrides.updatedBy ?? getUUID(),
-  updatedByUserRole: overrides.updatedByUserRole ?? "FIELD_AGENT",
-  flags: [],
-  legalStatuses: overrides.legalStatuses ?? {},
-  declaration: overrides.declaration ?? getRandomApplicant(),
-  trackingId: overrides.trackingId ?? getTrackingId()
+  declaration: overrides.declaration ?? {
+    "recommender.none": true,
+    "applicant.firstname": "Danny",
+    "applicant.surname": "Doe",
+    "applicant.dob": "1999-11-11"
+  },
+  trackingId: overrides.trackingId ?? "M3F8YQ"
 });
 var generateTranslationConfig = (message) => ({
   defaultMessage: message,
   description: "Description for ${message}",
   id: message
 });
-var generateWorkqueues = (slug = "all-events") => defineWorkqueues([
-  {
-    slug,
-    name: {
-      id: "workqueues.inProgress.title",
-      defaultMessage: slug.charAt(0).toUpperCase() + slug.slice(1).split("-").join(" "),
-      description: "Title of in progress workqueue"
-    },
-    query: {
-      type: "and",
-      clauses: [{ eventType: tennisClubMembershipEvent.id }]
-    },
-    actions: [],
-    icon: "Draft",
-    columns: []
-  }
-]);
 
 // ../commons/src/events/TemplateConfig.ts
 function isTemplateVariable(value) {
@@ -5364,389 +4364,3 @@ function isFieldConfigDefaultValue(value) {
   }
   return false;
 }
-
-// ../commons/src/events/scopes.ts
-var import_lodash3 = require("lodash");
-
-// ../commons/src/scopes.ts
-var import_zod30 = require("zod");
-var SCOPES = {
-  // TODO v1.8 legacy scopes
-  NATLSYSADMIN: "natlsysadmin",
-  BYPASSRATELIMIT: "bypassratelimit",
-  DECLARE: "declare",
-  REGISTER: "register",
-  VALIDATE: "validate",
-  DEMO: "demo",
-  CERTIFY: "certify",
-  PERFORMANCE: "performance",
-  SYSADMIN: "sysadmin",
-  TEAMS: "teams",
-  CONFIG: "config",
-  // systems / integrations
-  WEBHOOK: "webhook",
-  NATIONALID: "nationalId",
-  NOTIFICATION_API: "notification-api",
-  RECORDSEARCH: "recordsearch",
-  /**
-   * @TODO This is a temporary scope to be used for V2 Events custom events declaration
-   */
-  RECORD_DECLARE: "record.declare-birth",
-  // declare
-  RECORD_DECLARE_BIRTH: "record.declare-birth",
-  RECORD_DECLARE_BIRTH_MY_JURISDICTION: "record.declare-birth:my-jurisdiction",
-  RECORD_DECLARE_DEATH: "record.declare-death",
-  RECORD_DECLARE_DEATH_MY_JURISDICTION: "record.declare-death:my-jurisdiction",
-  RECORD_DECLARE_MARRIAGE: "record.declare-marriage",
-  RECORD_DECLARE_MARRIAGE_MY_JURISDICTION: "record.declare-marriage:my-jurisdiction",
-  RECORD_SUBMIT_INCOMPLETE: "record.declaration-submit-incomplete",
-  RECORD_SUBMIT_FOR_REVIEW: "record.declaration-submit-for-review",
-  RECORD_UNASSIGN_OTHERS: "record.unassign-others",
-  // validate
-  RECORD_SUBMIT_FOR_APPROVAL: "record.declaration-submit-for-approval",
-  RECORD_SUBMIT_FOR_UPDATES: "record.declaration-submit-for-updates",
-  RECORD_DECLARATION_EDIT: "record.declaration-edit",
-  RECORD_REVIEW_DUPLICATES: "record.review-duplicates",
-  RECORD_DECLARATION_ARCHIVE: "record.declaration-archive",
-  RECORD_DECLARATION_REINSTATE: "record.declaration-reinstate",
-  // register
-  RECORD_REGISTER: "record.register",
-  // certify
-  RECORD_EXPORT_RECORDS: "record.export-records",
-  RECORD_DECLARATION_PRINT: "record.declaration-print",
-  RECORD_PRINT_RECORDS_SUPPORTING_DOCUMENTS: "record.declaration-print-supporting-documents",
-  RECORD_REGISTRATION_PRINT: "record.registration-print",
-  // v1.8
-  /**
-   * This scope is used to **print and **issue certified copies of a record
-   * after it has been registered. Previously Registrars had this permission.
-   */
-  RECORD_PRINT_ISSUE_CERTIFIED_COPIES: "record.registration-print&issue-certified-copies",
-  RECORD_PRINT_CERTIFIED_COPIES: "record.registration-print-certified-copies",
-  // v1.8
-  RECORD_BULK_PRINT_CERTIFIED_COPIES: "record.registration-bulk-print-certified-copies",
-  // v1.8
-  RECORD_REGISTRATION_VERIFY_CERTIFIED_COPIES: "record.registration-verify-certified-copies",
-  // v1.8
-  // correct
-  RECORD_REGISTRATION_REQUEST_CORRECTION: "record.registration-request-correction",
-  RECORD_REGISTRATION_CORRECT: "record.registration-correct",
-  RECORD_REGISTRATION_REQUEST_REVOCATION: "record.registration-request-revocation",
-  // v1.8
-  RECORD_REGISTRATION_REVOKE: "record.registration-revoke",
-  // v1.8
-  RECORD_REGISTRATION_REQUEST_REINSTATEMENT: "record.registration-request-reinstatement",
-  // v1.8
-  RECORD_REGISTRATION_REINSTATE: "record.registration-reinstate",
-  // v1.8
-  RECORD_CONFIRM_REGISTRATION: "record.confirm-registration",
-  RECORD_REJECT_REGISTRATION: "record.reject-registration",
-  // search
-  SEARCH_BIRTH_MY_JURISDICTION: "search.birth:my-jurisdiction",
-  SEARCH_BIRTH: "search.birth",
-  SEARCH_DEATH_MY_JURISDICTION: "search.death:my-jurisdiction",
-  SEARCH_DEATH: "search.death",
-  SEARCH_MARRIAGE_MY_JURISDICTION: "search.marriage:my-jurisdiction",
-  SEARCH_MARRIAGE: "search.marriage",
-  // audit v1.8
-  RECORD_READ: "record.read",
-  RECORD_READ_AUDIT: "record.read-audit",
-  RECORD_READ_COMMENTS: "record.read-comments",
-  RECORD_CREATE_COMMENTS: "record.create-comments",
-  // profile
-  PROFILE_UPDATE: "profile.update",
-  //v1.8
-  PROFILE_ELECTRONIC_SIGNATURE: "profile.electronic-signature",
-  // performance
-  PERFORMANCE_READ: "performance.read",
-  PERFORMANCE_READ_DASHBOARDS: "performance.read-dashboards",
-  PERFORMANCE_EXPORT_VITAL_STATISTICS: "performance.vital-statistics-export",
-  // organisation
-  ORGANISATION_READ_LOCATIONS: "organisation.read-locations:all",
-  ORGANISATION_READ_LOCATIONS_MY_OFFICE: "organisation.read-locations:my-office",
-  ORGANISATION_READ_LOCATIONS_MY_JURISDICTION: "organisation.read-locations:my-jurisdiction",
-  // user
-  USER_READ: "user.read:all",
-  USER_READ_MY_OFFICE: "user.read:my-office",
-  USER_READ_MY_JURISDICTION: "user.read:my-jurisdiction",
-  USER_READ_ONLY_MY_AUDIT: "user.read:only-my-audit",
-  //v1.8
-  USER_CREATE: "user.create:all",
-  USER_CREATE_MY_JURISDICTION: "user.create:my-jurisdiction",
-  USER_UPDATE: "user.update:all",
-  USER_UPDATE_MY_JURISDICTION: "user.update:my-jurisdiction",
-  // config
-  CONFIG_UPDATE_ALL: "config.update:all",
-  // data seeding
-  USER_DATA_SEEDING: "user.data-seeding"
-};
-var LiteralScopes = import_zod30.z.union([
-  import_zod30.z.literal(SCOPES.NATLSYSADMIN),
-  import_zod30.z.literal(SCOPES.BYPASSRATELIMIT),
-  import_zod30.z.literal(SCOPES.DECLARE),
-  import_zod30.z.literal(SCOPES.REGISTER),
-  import_zod30.z.literal(SCOPES.VALIDATE),
-  import_zod30.z.literal(SCOPES.DEMO),
-  import_zod30.z.literal(SCOPES.CERTIFY),
-  import_zod30.z.literal(SCOPES.PERFORMANCE),
-  import_zod30.z.literal(SCOPES.SYSADMIN),
-  import_zod30.z.literal(SCOPES.TEAMS),
-  import_zod30.z.literal(SCOPES.CONFIG),
-  import_zod30.z.literal(SCOPES.WEBHOOK),
-  import_zod30.z.literal(SCOPES.NATIONALID),
-  import_zod30.z.literal(SCOPES.NOTIFICATION_API),
-  import_zod30.z.literal(SCOPES.RECORDSEARCH),
-  import_zod30.z.literal(SCOPES.RECORD_DECLARE_BIRTH),
-  import_zod30.z.literal(SCOPES.RECORD_DECLARE_BIRTH_MY_JURISDICTION),
-  import_zod30.z.literal(SCOPES.RECORD_DECLARE_DEATH),
-  import_zod30.z.literal(SCOPES.RECORD_DECLARE_DEATH_MY_JURISDICTION),
-  import_zod30.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE),
-  import_zod30.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE_MY_JURISDICTION),
-  import_zod30.z.literal(SCOPES.RECORD_SUBMIT_INCOMPLETE),
-  import_zod30.z.literal(SCOPES.RECORD_SUBMIT_FOR_REVIEW),
-  import_zod30.z.literal(SCOPES.RECORD_UNASSIGN_OTHERS),
-  import_zod30.z.literal(SCOPES.RECORD_SUBMIT_FOR_APPROVAL),
-  import_zod30.z.literal(SCOPES.RECORD_SUBMIT_FOR_UPDATES),
-  import_zod30.z.literal(SCOPES.RECORD_DECLARATION_EDIT),
-  import_zod30.z.literal(SCOPES.RECORD_REVIEW_DUPLICATES),
-  import_zod30.z.literal(SCOPES.RECORD_DECLARATION_ARCHIVE),
-  import_zod30.z.literal(SCOPES.RECORD_DECLARATION_REINSTATE),
-  import_zod30.z.literal(SCOPES.RECORD_REGISTER),
-  import_zod30.z.literal(SCOPES.RECORD_EXPORT_RECORDS),
-  import_zod30.z.literal(SCOPES.RECORD_DECLARATION_PRINT),
-  import_zod30.z.literal(SCOPES.RECORD_PRINT_RECORDS_SUPPORTING_DOCUMENTS),
-  import_zod30.z.literal(SCOPES.RECORD_REGISTRATION_PRINT),
-  import_zod30.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
-  import_zod30.z.literal(SCOPES.RECORD_PRINT_CERTIFIED_COPIES),
-  import_zod30.z.literal(SCOPES.RECORD_BULK_PRINT_CERTIFIED_COPIES),
-  import_zod30.z.literal(SCOPES.RECORD_REGISTRATION_VERIFY_CERTIFIED_COPIES),
-  import_zod30.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_CORRECTION),
-  import_zod30.z.literal(SCOPES.RECORD_REGISTRATION_CORRECT),
-  import_zod30.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_REVOCATION),
-  import_zod30.z.literal(SCOPES.RECORD_REGISTRATION_REVOKE),
-  import_zod30.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_REINSTATEMENT),
-  import_zod30.z.literal(SCOPES.RECORD_REGISTRATION_REINSTATE),
-  import_zod30.z.literal(SCOPES.RECORD_CONFIRM_REGISTRATION),
-  import_zod30.z.literal(SCOPES.RECORD_REJECT_REGISTRATION),
-  import_zod30.z.literal(SCOPES.SEARCH_BIRTH_MY_JURISDICTION),
-  import_zod30.z.literal(SCOPES.SEARCH_BIRTH),
-  import_zod30.z.literal(SCOPES.SEARCH_DEATH_MY_JURISDICTION),
-  import_zod30.z.literal(SCOPES.SEARCH_DEATH),
-  import_zod30.z.literal(SCOPES.SEARCH_MARRIAGE_MY_JURISDICTION),
-  import_zod30.z.literal(SCOPES.SEARCH_MARRIAGE),
-  import_zod30.z.literal(SCOPES.RECORD_READ),
-  import_zod30.z.literal(SCOPES.RECORD_READ_AUDIT),
-  import_zod30.z.literal(SCOPES.RECORD_READ_COMMENTS),
-  import_zod30.z.literal(SCOPES.RECORD_CREATE_COMMENTS),
-  import_zod30.z.literal(SCOPES.PROFILE_UPDATE),
-  import_zod30.z.literal(SCOPES.PROFILE_ELECTRONIC_SIGNATURE),
-  import_zod30.z.literal(SCOPES.PERFORMANCE_READ),
-  import_zod30.z.literal(SCOPES.PERFORMANCE_READ_DASHBOARDS),
-  import_zod30.z.literal(SCOPES.PERFORMANCE_EXPORT_VITAL_STATISTICS),
-  import_zod30.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS),
-  import_zod30.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_OFFICE),
-  import_zod30.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_JURISDICTION),
-  import_zod30.z.literal(SCOPES.USER_READ),
-  import_zod30.z.literal(SCOPES.USER_READ_MY_OFFICE),
-  import_zod30.z.literal(SCOPES.USER_READ_MY_JURISDICTION),
-  import_zod30.z.literal(SCOPES.USER_READ_ONLY_MY_AUDIT),
-  import_zod30.z.literal(SCOPES.USER_CREATE),
-  import_zod30.z.literal(SCOPES.USER_CREATE_MY_JURISDICTION),
-  import_zod30.z.literal(SCOPES.USER_UPDATE),
-  import_zod30.z.literal(SCOPES.USER_UPDATE_MY_JURISDICTION),
-  import_zod30.z.literal(SCOPES.CONFIG_UPDATE_ALL),
-  import_zod30.z.literal(SCOPES.USER_DATA_SEEDING)
-]);
-var rawConfigurableScopeRegex = /^([a-zA-Z\.]+)\[((?:\w+=[\w.-]+(?:\|[\w.-]+)*)(?:,[\w]+=[\w.-]+(?:\|[\w.-]+)*)*)\]$/;
-var rawConfigurableScope = import_zod30.z.string().regex(rawConfigurableScopeRegex);
-var CreateUserScope = import_zod30.z.object({
-  type: import_zod30.z.literal("user.create"),
-  options: import_zod30.z.object({
-    role: import_zod30.z.array(import_zod30.z.string())
-  })
-});
-var EditUserScope = import_zod30.z.object({
-  type: import_zod30.z.literal("user.edit"),
-  options: import_zod30.z.object({
-    role: import_zod30.z.array(import_zod30.z.string())
-  })
-});
-var WorkqueueScope = import_zod30.z.object({
-  type: import_zod30.z.literal("workqueue"),
-  options: import_zod30.z.object({
-    id: import_zod30.z.array(import_zod30.z.string())
-  })
-});
-var NotifyRecordScope = import_zod30.z.object({
-  type: import_zod30.z.literal("record.notify"),
-  options: import_zod30.z.object({
-    event: import_zod30.z.array(import_zod30.z.string())
-  })
-});
-var ConfigurableScopes = import_zod30.z.discriminatedUnion("type", [
-  CreateUserScope,
-  EditUserScope,
-  WorkqueueScope,
-  NotifyRecordScope
-]);
-var scopes = Object.values(SCOPES);
-
-// ../commons/src/events/scopes.ts
-var CONFIG_GET_ALLOWED_SCOPES = [
-  SCOPES.RECORD_DECLARE,
-  SCOPES.RECORD_READ,
-  SCOPES.RECORD_SUBMIT_INCOMPLETE,
-  SCOPES.RECORD_SUBMIT_FOR_REVIEW,
-  SCOPES.RECORD_REGISTER,
-  SCOPES.RECORD_EXPORT_RECORDS,
-  SCOPES.CONFIG,
-  SCOPES.CONFIG_UPDATE_ALL
-];
-var CONFIG_SEARCH_ALLOWED_SCOPES = [
-  SCOPES.SEARCH_BIRTH,
-  SCOPES.SEARCH_DEATH,
-  SCOPES.SEARCH_MARRIAGE,
-  SCOPES.SEARCH_BIRTH_MY_JURISDICTION,
-  SCOPES.SEARCH_DEATH_MY_JURISDICTION,
-  SCOPES.SEARCH_MARRIAGE_MY_JURISDICTION
-];
-var ACTION_ALLOWED_SCOPES = {
-  [ActionType.READ]: [
-    SCOPES.RECORD_DECLARE,
-    SCOPES.RECORD_READ,
-    SCOPES.RECORD_SUBMIT_INCOMPLETE,
-    SCOPES.RECORD_SUBMIT_FOR_REVIEW,
-    SCOPES.RECORD_REGISTER,
-    SCOPES.RECORD_EXPORT_RECORDS
-  ],
-  [ActionType.CREATE]: [
-    SCOPES.RECORD_DECLARE,
-    SCOPES.RECORD_SUBMIT_INCOMPLETE,
-    SCOPES.RECORD_SUBMIT_FOR_REVIEW
-  ],
-  [ActionType.NOTIFY]: [SCOPES.RECORD_SUBMIT_INCOMPLETE],
-  [ActionType.DECLARE]: [
-    SCOPES.RECORD_DECLARE,
-    SCOPES.RECORD_SUBMIT_FOR_APPROVAL,
-    SCOPES.RECORD_REGISTER
-  ],
-  [ActionType.DELETE]: [SCOPES.RECORD_DECLARE],
-  [ActionType.VALIDATE]: [
-    SCOPES.RECORD_SUBMIT_FOR_APPROVAL,
-    SCOPES.RECORD_REGISTER
-  ],
-  [ActionType.REGISTER]: [SCOPES.RECORD_REGISTER],
-  [ActionType.PRINT_CERTIFICATE]: [SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES],
-  [ActionType.REQUEST_CORRECTION]: [
-    SCOPES.RECORD_REGISTRATION_REQUEST_CORRECTION
-  ],
-  [ActionType.REJECT_CORRECTION]: [SCOPES.RECORD_REGISTRATION_CORRECT],
-  [ActionType.APPROVE_CORRECTION]: [SCOPES.RECORD_REGISTRATION_CORRECT],
-  [ActionType.MARKED_AS_DUPLICATE]: [SCOPES.RECORD_DECLARATION_ARCHIVE],
-  [ActionType.ARCHIVE]: [SCOPES.RECORD_DECLARATION_ARCHIVE],
-  [ActionType.REJECT]: [SCOPES.RECORD_SUBMIT_FOR_UPDATES],
-  [ActionType.ASSIGN]: null,
-  [ActionType.UNASSIGN]: null,
-  [ActionType.DETECT_DUPLICATE]: []
-};
-var ACTION_ALLOWED_CONFIGURABLE_SCOPES = {
-  [ActionType.READ]: [],
-  [ActionType.CREATE]: ["record.notify"],
-  [ActionType.NOTIFY]: ["record.notify"],
-  [ActionType.DECLARE]: [],
-  [ActionType.DELETE]: [],
-  [ActionType.VALIDATE]: [],
-  [ActionType.REGISTER]: [],
-  [ActionType.PRINT_CERTIFICATE]: [],
-  [ActionType.REQUEST_CORRECTION]: [],
-  [ActionType.REJECT_CORRECTION]: [],
-  [ActionType.APPROVE_CORRECTION]: [],
-  [ActionType.MARKED_AS_DUPLICATE]: [],
-  [ActionType.ARCHIVE]: [],
-  [ActionType.REJECT]: [],
-  [ActionType.ASSIGN]: [],
-  [ActionType.UNASSIGN]: [],
-  [ActionType.DETECT_DUPLICATE]: []
-};
-function hasAnyOfScopes(a, b) {
-  return (0, import_lodash3.intersection)(a, b).length > 0;
-}
-function filterUnallowedActions(actions, userScopes) {
-  const allowedActions = actions.filter((action) => {
-    const requiredScopes = ACTION_ALLOWED_SCOPES[action];
-    if (requiredScopes === null) {
-      return true;
-    }
-    return hasAnyOfScopes(userScopes, requiredScopes);
-  });
-  const hasOtherAllowedActions = allowedActions.some(
-    (action) => action !== ActionType.READ && action !== ActionType.ASSIGN && action !== ActionType.UNASSIGN
-  );
-  if (hasOtherAllowedActions) {
-    return allowedActions;
-  }
-  return [ActionType.READ];
-}
-
-// ../commons/src/events/serializers/user/deserializer.ts
-var import_zod31 = require("zod");
-var UserWithPrimaryOffice = User.extend({
-  primaryOfficeId: import_zod31.z.string()
-});
-function userDeserializer(serializedUserField, user2) {
-  if (typeof serializedUserField === "string") {
-    return serializedUserField;
-  }
-  if (serializedUserField.$userField === "id") {
-    return user2[serializedUserField.$userField];
-  }
-  if (serializedUserField.$userField === "primaryOfficeId") {
-    return user2[serializedUserField.$userField];
-  }
-  return "ToDo";
-}
-function deserializeQueryExpression(expression, user2) {
-  return {
-    ...expression,
-    assignedTo: expression.assignedTo && {
-      ...expression.assignedTo,
-      term: userDeserializer(expression.assignedTo.term, user2)
-    },
-    createdBy: expression.createdBy && {
-      ...expression.createdBy,
-      term: userDeserializer(expression.createdBy.term, user2)
-    },
-    updatedBy: expression.updatedBy && {
-      ...expression.updatedBy,
-      term: userDeserializer(expression.updatedBy.term, user2)
-    },
-    createdAtLocation: expression.createdAtLocation && (expression.createdAtLocation.type === "within" ? {
-      ...expression.createdAtLocation,
-      location: userDeserializer(
-        expression.createdAtLocation.location,
-        user2
-      )
-    } : {
-      ...expression.createdAtLocation,
-      term: userDeserializer(expression.createdAtLocation.term, user2)
-    }),
-    updatedAtLocation: expression.updatedAtLocation && (expression.updatedAtLocation.type === "within" ? {
-      ...expression.updatedAtLocation,
-      location: userDeserializer(
-        expression.updatedAtLocation.location,
-        user2
-      )
-    } : {
-      ...expression.updatedAtLocation,
-      term: userDeserializer(expression.updatedAtLocation.term, user2)
-    })
-  };
-}
-function deserializeQuery(query, user2) {
-  return {
-    ...query,
-    clauses: query.clauses.map(
-      (clause) => deserializeQueryExpression(clause, user2)
-    )
-  };
-}