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

package/dist/events/index.js

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/events/index.ts
 var events_exports = {};
 __export(events_exports, {
+  ACTION_ALLOWED_SCOPES: () => ACTION_ALLOWED_SCOPES,
   Action: () => Action,
   ActionBase: () => ActionBase,
   ActionConditional: () => ActionConditional,
@@ -49,8 +50,10 @@ __export(events_exports, {
   AdvancedSearchConfig: () => AdvancedSearchConfig,
   ApproveCorrectionActionInput: () => ApproveCorrectionActionInput,
   ArchiveActionInput: () => ArchiveActionInput,
+  AssignActionInput: () => AssignActionInput,
   AsyncRejectActionDocument: () => AsyncRejectActionDocument,
   BaseActionInput: () => BaseActionInput,
+  CONFIG_GET_ALLOWED_SCOPES: () => CONFIG_GET_ALLOWED_SCOPES,
   CertificateConfig: () => CertificateConfig,
   CertificateTemplateConfig: () => CertificateTemplateConfig,
   CheckboxFieldValue: () => CheckboxFieldValue,
@@ -68,6 +71,8 @@ __export(events_exports, {
   DeclarationUpdateActions: () => DeclarationUpdateActions,
   DeclareActionInput: () => DeclareActionInput,
   DeduplicationConfig: () => DeduplicationConfig,
+  DeleteActionInput: () => DeleteActionInput,
+  DisplayOnReviewConditional: () => DisplayOnReviewConditional,
   Draft: () => Draft,
   DraftInput: () => DraftInput,
   EmailField: () => EmailField,
@@ -81,6 +86,7 @@ __export(events_exports, {
   EventSearchIndex: () => EventSearchIndex,
   EventStatus: () => EventStatus,
   EventStatuses: () => EventStatuses,
+  FieldConditional: () => FieldConditional,
   FieldConfig: () => FieldConfig,
   FieldType: () => FieldType,
   FieldUpdateValue: () => FieldUpdateValue,
@@ -100,7 +106,6 @@ __export(events_exports, {
   NotifyActionInput: () => NotifyActionInput,
   NumberFieldValue: () => NumberFieldValue,
   PageConfig: () => PageConfig,
-  PageConfigBase: () => PageConfigBase,
   PageTypes: () => PageTypes,
   PrintCertificateActionInput: () => PrintCertificateActionInput,
   ReadActionInput: () => ReadActionInput,
@@ -117,6 +122,7 @@ __export(events_exports, {
   SummaryConfig: () => SummaryConfig,
   TextValue: () => TextValue,
   TranslationConfig: () => TranslationConfig,
+  UnassignActionInput: () => UnassignActionInput,
   UrbanAddressUpdateValue: () => UrbanAddressUpdateValue,
   UrbanAddressValue: () => UrbanAddressValue,
   ValidateActionInput: () => ValidateActionInput,
@@ -127,6 +133,7 @@ __export(events_exports, {
   and: () => and,
   annotationActions: () => annotationActions,
   applyDraftsToEventIndex: () => applyDraftsToEventIndex,
+  areConditionsMet: () => areConditionsMet,
   compositeFieldTypes: () => compositeFieldTypes,
   createEmptyDraft: () => createEmptyDraft,
   createValidationSchema: () => createValidationSchema,
@@ -136,8 +143,10 @@ __export(events_exports, {
   defineConditional: () => defineConditional,
   defineConfig: () => defineConfig,
   defineDeclarationForm: () => defineDeclarationForm,
+  defineFormConditional: () => defineFormConditional,
   defineFormPage: () => defineFormPage,
   definePage: () => definePage,
+  defineWorkqueue: () => defineWorkqueue,
   errorMessages: () => errorMessages,
   event: () => event,
   eventMetadataLabelMap: () => eventMetadataLabelMap,
@@ -146,12 +155,14 @@ __export(events_exports, {
   eventStatuses: () => eventStatuses,
   field: () => field,
   fieldTypes: () => fieldTypes,
+  filterUnallowedActions: () => filterUnallowedActions,
   findActiveDrafts: () => findActiveDrafts,
   findAllFields: () => findAllFields,
+  findLastAssignmentAction: () => findLastAssignmentAction,
   findRecordActionPages: () => findRecordActionPages,
+  generateActionAnnotationInput: () => generateActionAnnotationInput,
+  generateActionDeclarationInput: () => generateActionDeclarationInput,
   generateActionDocument: () => generateActionDocument,
-  generateActionInput: () => generateActionInput,
-  generateActionMetadataInput: () => generateActionMetadataInput,
   generateEventDocument: () => generateEventDocument,
   generateEventDraftDocument: () => generateEventDraftDocument,
   generateTransactionId: () => generateTransactionId,
@@ -162,17 +173,19 @@ __export(events_exports, {
   getActionReview: () => getActionReview,
   getActionReviewFields: () => getActionReviewFields,
   getAllAnnotationFields: () => getAllAnnotationFields,
+  getAnnotationFromDrafts: () => getAnnotationFromDrafts,
+  getAssignedUserFromActions: () => getAssignedUserFromActions,
   getCurrentEventState: () => getCurrentEventState,
   getCurrentEventStateWithDrafts: () => getCurrentEventStateWithDrafts,
   getDeclaration: () => getDeclaration,
   getDeclarationFields: () => getDeclarationFields,
   getDeclarationPages: () => getDeclarationPages,
-  getFieldValidationErrors: () => getFieldValidationErrors,
-  getVisiblePagesFormFields: () => getVisiblePagesFormFields,
+  hasAnyOfScopes: () => hasAnyOfScopes,
   isAddressFieldType: () => isAddressFieldType,
   isAdministrativeAreaFieldType: () => isAdministrativeAreaFieldType,
   isBulletListFieldType: () => isBulletListFieldType,
   isCheckboxFieldType: () => isCheckboxFieldType,
+  isConditionMet: () => isConditionMet,
   isCountryFieldType: () => isCountryFieldType,
   isDataFieldType: () => isDataFieldType,
   isDateFieldType: () => isDateFieldType,
@@ -180,6 +193,7 @@ __export(events_exports, {
   isEmailFieldType: () => isEmailFieldType,
   isFacilityFieldType: () => isFacilityFieldType,
   isFieldConfigDefaultValue: () => isFieldConfigDefaultValue,
+  isFieldDisplayedOnReview: () => isFieldDisplayedOnReview,
   isFieldEnabled: () => isFieldEnabled,
   isFieldValue: () => isFieldValue,
   isFieldValueWithoutTemplates: () => isFieldValueWithoutTemplates,
@@ -200,16 +214,20 @@ __export(events_exports, {
   isTextFieldType: () => isTextFieldType,
   isUndeclaredDraft: () => isUndeclaredDraft,
   isVerificationPage: () => isVerificationPage,
+  isWriteAction: () => isWriteAction,
   mapFieldTypeToEmptyValue: () => mapFieldTypeToEmptyValue,
   mapFieldTypeToMockValue: () => mapFieldTypeToMockValue,
   mapFieldTypeToZod: () => mapFieldTypeToZod,
+  never: () => never,
   not: () => not,
+  omitHiddenFields: () => omitHiddenFields,
+  omitHiddenPaginatedFields: () => omitHiddenPaginatedFields,
   or: () => or,
-  stripHiddenFields: () => stripHiddenFields,
+  runFieldValidations: () => runFieldValidations,
   user: () => user,
   validate: () => validate,
   validateFieldInput: () => validateFieldInput,
-  validateWorkqueueConfig: () => validateWorkqueueConfig
+  writeActions: () => writeActions
 });
 module.exports = __toCommonJS(events_exports);
 
@@ -218,29 +236,52 @@ var import_zod9 = require("zod");
 
 // ../commons/src/events/Conditional.ts
 var import_zod = require("zod");
-function Conditional() {
-  return import_zod.z.custom((val) => typeof val === "object" && val !== null);
-}
+var 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 ConditionalType = {
-  /** When 'SHOW' conditional is defined, the action is shown to the user only if the condition is met */
   SHOW: "SHOW",
-  /** If 'ENABLE' conditional is defined, the action is enabled only if the condition is met */
-  ENABLE: "ENABLE"
+  ENABLE: "ENABLE",
+  DISPLAY_ON_REVIEW: "DISPLAY_ON_REVIEW"
 };
 var ShowConditional = import_zod.z.object({
   type: import_zod.z.literal(ConditionalType.SHOW),
-  conditional: Conditional()
-});
+  conditional: Conditional
+}).describe(
+  "If 'SHOW' conditional is defined, the component is shown to the user only if the condition is met"
+);
 var EnableConditional = import_zod.z.object({
   type: import_zod.z.literal(ConditionalType.ENABLE),
-  conditional: Conditional()
-});
+  conditional: Conditional
+}).describe(
+  "If 'ENABLE' conditional is defined, the component is enabled only if the condition is met"
+);
 var ActionConditional = import_zod.z.discriminatedUnion("type", [
   // Action can be shown / hidden
   ShowConditional,
   // Action can be shown to the user in the list but as disabled
   EnableConditional
 ]);
+var DisplayOnReviewConditional = import_zod.z.object({
+  type: import_zod.z.literal(ConditionalType.DISPLAY_ON_REVIEW),
+  conditional: Conditional
+}).describe(
+  "If 'DISPLAY_ON_REVIEW' conditional is defined, the component is shown on the review page only if both the 'DISPLAY_ON_REVIEW' and 'SHOW' conditions are met. This should only be used for fields within declaration forms, as they are the only ones with review pages."
+);
+var FieldConditional = import_zod.z.discriminatedUnion("type", [
+  // Field input can be shown / hidden
+  ShowConditional,
+  // Field input can be shown to the user but as disabled
+  EnableConditional,
+  // Field output can be shown / hidden on the review page
+  DisplayOnReviewConditional
+]).openapi({
+  description: "Field conditional configuration",
+  ref: "FieldConditional"
+});
 
 // ../commons/src/events/PageConfig.ts
 var import_zod6 = require("zod");
@@ -250,6 +291,8 @@ 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"
@@ -258,8 +301,14 @@ 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/FieldConfig.ts
+var import_zod_openapi3 = require("zod-openapi");
+
 // ../commons/src/events/FieldType.ts
 var FieldType = {
   ADDRESS: "ADDRESS",
@@ -410,6 +459,7 @@ var FieldUpdateValue = import_zod4.z.union([
 ]);
 
 // ../commons/src/events/FieldConfig.ts
+(0, import_zod_openapi3.extendZodWithOpenApi)(import_zod5.z);
 var FieldId = import_zod5.z.string();
 var DependencyExpression = import_zod5.z.object({
   dependsOn: import_zod5.z.array(FieldId).default([]),
@@ -428,14 +478,14 @@ var BaseField = import_zod5.z.object({
     ]),
     DependencyExpression
   ]).optional(),
-  conditionals: import_zod5.z.array(ActionConditional).default([]).optional(),
+  conditionals: import_zod5.z.array(FieldConditional).default([]).optional(),
   required: import_zod5.z.boolean().default(false).optional(),
   disabled: import_zod5.z.boolean().default(false).optional(),
   hidden: import_zod5.z.boolean().default(false).optional(),
   placeholder: TranslationConfig.optional(),
   validation: import_zod5.z.array(
     import_zod5.z.object({
-      validator: Conditional(),
+      validator: Conditional,
       message: TranslationConfig
     })
   ).default([]).optional(),
@@ -545,7 +595,8 @@ 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()
+    }).optional(),
+    fileName: TranslationConfig.optional()
   }).default({
     maxFileSize: DEFAULT_MAX_FILE_SIZE_BYTES
   })
@@ -632,7 +683,7 @@ var Address = BaseField.extend({
 var DataEntry = import_zod5.z.union([
   import_zod5.z.object({
     label: TranslationConfig,
-    value: import_zod5.z.string()
+    value: TranslationConfig.or(import_zod5.z.string())
   }),
   import_zod5.z.object({
     fieldId: import_zod5.z.string()
@@ -668,20 +719,28 @@ var FieldConfig = import_zod5.z.discriminatedUnion("type", [
   EmailField,
   FileUploadWithOptions,
   DataField
-]);
+]).openapi({
+  description: "Form field configuration",
+  ref: "FieldConfig"
+});
 
 // ../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"),
   title: TranslationConfig.describe("Header title of the page"),
   fields: import_zod6.z.array(FieldConfig).describe("Fields to be rendered on the page"),
-  conditional: Conditional().optional().describe(
+  conditional: Conditional.optional().describe(
     "Page will be shown if condition is met. If conditional is not defined, the page will be always shown."
   )
 });
 var FormPageConfig = PageConfigBase.extend({
   type: import_zod6.z.literal(PageTypes.enum.FORM).default(PageTypes.enum.FORM)
+}).openapi({
+  description: "Form page configuration",
+  ref: "FormPageConfig"
 });
 var VerificationActionConfig = import_zod6.z.object({
   verify: import_zod6.z.object({ label: TranslationConfig }),
@@ -692,7 +751,10 @@ var VerificationActionConfig = import_zod6.z.object({
       body: TranslationConfig
     })
   })
-}).describe("Actions available on the verification page");
+}).describe("Actions available on the verification page").openapi({
+  description: "Verification action configuration",
+  ref: "VerificationActionConfig"
+});
 var VerificationPageConfig = FormPageConfig.extend({
   type: import_zod6.z.literal(PageTypes.enum.VERIFICATION),
   actions: VerificationActionConfig
@@ -772,6 +834,12 @@ var DeclarationUpdateActions = ActionTypes.extract(
   declarationUpdateActionValues
 );
 var annotationActions = ActionTypes.exclude(declarationActionValues);
+var writeActions = ActionTypes.exclude([
+  ActionType.CREATE,
+  ActionType.READ,
+  ActionType.ASSIGN,
+  ActionType.UNASSIGN
+]);
 
 // ../commons/src/events/FormConfig.ts
 var import_zod8 = require("zod");
@@ -786,6 +854,8 @@ 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,
@@ -863,18 +933,24 @@ var ApproveCorrectionConfig = ActionConfigBase.merge(
   })
 );
 var ActionConfig = import_zod9.z.discriminatedUnion("type", [
-  DeclareConfig,
-  ValidateConfig,
-  RejectDeclarationConfig,
-  MarkedAsDuplicateConfig,
-  ArchiveConfig,
-  RegisterConfig,
-  DeleteConfig,
-  PrintCertificateActionConfig,
-  RequestCorrectionConfig,
-  RejectCorrectionConfig,
-  ApproveCorrectionConfig
-]);
+  /*
+   * 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" });
 var DeclarationActionConfig = import_zod9.z.discriminatedUnion("type", [
   DeclareConfig,
   ValidateConfig,
@@ -918,10 +994,12 @@ var LanguageConfig = import_zod11.z.object({
 });
 
 // ../commons/src/events/EventConfig.ts
-var import_zod20 = require("zod");
+var import_zod16 = 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(),
@@ -965,10 +1043,12 @@ var DateDistanceMatcher = Matcher.extend({
 });
 var And = import_zod12.z.object({
   type: import_zod12.z.literal("and"),
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
   clauses: import_zod12.z.lazy(() => Clause.array())
 });
 var Or = import_zod12.z.object({
   type: import_zod12.z.literal("or"),
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
   clauses: import_zod12.z.lazy(() => Clause.array())
 });
 var Clause = import_zod12.z.lazy(
@@ -980,7 +1060,9 @@ var Clause = import_zod12.z.lazy(
     DateRangeMatcher,
     DateDistanceMatcher
   ])
-);
+).openapi({
+  ref: "Clause"
+});
 var DeduplicationConfig = import_zod12.z.object({
   id: import_zod12.z.string(),
   label: TranslationConfig,
@@ -989,14 +1071,21 @@ var DeduplicationConfig = import_zod12.z.object({
 
 // ../commons/src/events/SummaryConfig.ts
 var import_zod13 = require("zod");
-var Field = import_zod13.z.object({
+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()
+}).describe("Field directly referencing event data with field id");
+var Field = BaseField2.extend({
   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"),
@@ -1004,116 +1093,18 @@ var Title = import_zod13.z.object({
 });
 var SummaryConfig = import_zod13.z.object({
   title: Title.describe("Title of summary view."),
-  fields: import_zod13.z.array(Field).describe("Fields rendered in summary view.")
+  fields: import_zod13.z.array(import_zod13.z.union([Field, ReferenceField])).describe("Fields rendered in summary view.")
 }).describe("Configuration for summary in event.");
 
-// ../commons/src/events/WorkqueueConfig.ts
-var import_zod15 = require("zod");
-
-// ../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"
-  }
-};
-
-// ../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.");
-
 // ../commons/src/events/AdvancedSearchConfig.ts
-var import_zod16 = require("zod");
-var AdvancedSearchConfig = import_zod16.z.object({
+var import_zod14 = require("zod");
+var AdvancedSearchConfig = import_zod14.z.object({
   title: TranslationConfig.describe("Advanced search tab title"),
-  fields: import_zod16.z.array(
-    import_zod16.z.object({
-      fieldId: import_zod16.z.string(),
-      config: import_zod16.z.object({
-        type: import_zod16.z.enum(["FUZZY", "EXACT", "RANGE"]).describe("Determines the type of field")
+  fields: import_zod14.z.array(
+    import_zod14.z.object({
+      fieldId: import_zod14.z.string(),
+      config: import_zod14.z.object({
+        type: import_zod14.z.enum(["FUZZY", "EXACT", "RANGE"]).describe("Determines the type of field")
       }).optional().describe("Configuration options for the field")
     })
   ).optional().default([]).describe("Advanced search fields.")
@@ -1122,139 +1113,13 @@ var AdvancedSearchConfig = import_zod16.z.object({
 // ../commons/src/events/utils.ts
 var import_lodash = require("lodash");
 
-// ../commons/src/workqueues/WorkqueueConfig.ts
-var import_zod18 = require("zod");
-
-// ../commons/src/workqueues/defaultColumns.ts
-var import_zod17 = require("zod");
-var WorkQueueColumnConfig = import_zod17.z.object({
-  id: import_zod17.z.string(),
-  label: TranslationConfig
-});
-var defaultColumns = {
-  event: {
-    id: "event",
-    label: {
-      defaultMessage: "Event",
-      description: "This is the label for the workqueue column",
-      id: "workqueue.default.column.event"
-    }
-  },
-  status: {
-    id: "status",
-    label: {
-      defaultMessage: "Status",
-      description: "This is the label for the workqueue column",
-      id: "workqueue.default.column.status"
-    }
-  },
-  createdAt: {
-    id: "createdAt",
-    label: {
-      defaultMessage: "Created",
-      description: "This is the label for the workqueue column",
-      id: "workqueue.default.column.createdAt"
-    }
-  },
-  modifiedAt: {
-    id: "modifiedAt",
-    label: {
-      defaultMessage: "Modified",
-      description: "This is the label for the workqueue column",
-      id: "workqueue.default.column.modifiedAt"
-    }
-  }
-};
-var DefaultColumnKeys = import_zod17.z.enum(
-  Object.keys(defaultColumns)
-);
-
-// ../commons/src/workqueues/WorkqueueConfig.ts
-var rootWorkqueueConfig = import_zod18.z.object({
-  id: import_zod18.z.string(),
-  title: TranslationConfig,
-  columns: import_zod18.z.array(WorkQueueColumnConfig),
-  defaultColumns: import_zod18.z.array(DefaultColumnKeys)
-});
-var defineWorkqueue = (config) => rootWorkqueueConfig.parse(config);
-
-// ../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_zod19 = require("zod");
+var import_zod15 = require("zod");
 function mapFieldTypeToZod(type, required) {
   let schema;
   switch (type) {
@@ -1307,7 +1172,7 @@ function createValidationSchema(config) {
   for (const field2 of config) {
     shape[field2.id] = mapFieldTypeToZod(field2.type, field2.required);
   }
-  return import_zod19.z.object(shape);
+  return import_zod15.z.object(shape);
 }
 function mapFieldTypeToMockValue(field2, i) {
   switch (field2.type) {
@@ -1481,12 +1346,23 @@ 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
@@ -1508,6 +1384,9 @@ function isFieldVisible(field2, form) {
 function isFieldEnabled(field2, form) {
   return isFieldConditionMet(field2, form, ConditionalType.ENABLE);
 }
+function isFieldDisplayedOnReview(field2, form) {
+  return isFieldVisible(field2, form) && isFieldConditionMet(field2, form, ConditionalType.DISPLAY_ON_REVIEW);
+}
 var errorMessages = {
   hiddenField: {
     id: "v2.error.hidden",
@@ -1535,12 +1414,14 @@ var errorMessages = {
     id: "v2.error.invalid"
   }
 };
-var createIntlError = (message) => ({
-  message: {
-    message
-  }
-});
-var zodToIntlErrorMap = (issue, _ctx) => {
+function createIntlError(message) {
+  return {
+    message: {
+      message
+    }
+  };
+}
+function zodToIntlErrorMap(issue, _ctx) {
   switch (issue.code) {
     case "invalid_string": {
       if (_ctx.data === "") {
@@ -1578,41 +1459,6 @@ var zodToIntlErrorMap = (issue, _ctx) => {
     }
   }
   return createIntlError(errorMessages.invalidInput);
-};
-function getFieldValidationErrors({
-  field: field2,
-  values
-}) {
-  const conditionalParameters = {
-    $form: values,
-    $now: (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" })
-  };
-  if (!isFieldVisible(field2, values) || !isFieldEnabled(field2, values)) {
-    if (values[field2.id]) {
-      return {
-        errors: [
-          {
-            message: errorMessages.hiddenField
-          }
-        ]
-      };
-    }
-    return {
-      errors: []
-    };
-  }
-  const fieldValidationResult = validateFieldInput({
-    field: field2,
-    value: values[field2.id]
-  });
-  const customValidationResults = runCustomFieldValidations({
-    field: field2,
-    conditionalParameters
-  });
-  return {
-    // Assumes that custom validation errors are based on the field type, and extend the validation.
-    errors: [...fieldValidationResult, ...customValidationResults]
-  };
 }
 function runCustomFieldValidations({
   field: field2,
@@ -1635,6 +1481,32 @@ function validateFieldInput({
   );
   return rawError.error?.issues.map((issue) => issue.message) ?? [];
 }
+function runFieldValidations({
+  field: field2,
+  values
+}) {
+  if (!isFieldVisible(field2, values)) {
+    return {
+      errors: []
+    };
+  }
+  const conditionalParameters = {
+    $form: values,
+    $now: (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" })
+  };
+  const fieldValidationResult = validateFieldInput({
+    field: field2,
+    value: values[field2.id]
+  });
+  const customValidationResults = runCustomFieldValidations({
+    field: field2,
+    conditionalParameters
+  });
+  return {
+    // Assumes that custom validation errors are based on the field type, and extend the validation.
+    errors: [...fieldValidationResult, ...customValidationResults]
+  };
+}
 
 // ../commons/src/uuid.ts
 var import_uuid = require("uuid");
@@ -1642,9 +1514,6 @@ 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) {
@@ -1654,15 +1523,18 @@ function getOrThrow(x, message) {
 }
 
 // ../commons/src/events/utils.ts
-var findAllFields = (config) => {
-  return (0, import_lodash.flattenDeep)([
-    ...getDeclarationFields(config),
-    ...getAllAnnotationFields(config)
-  ]);
-};
-var getAllAnnotationFields = (config) => {
-  return (0, import_lodash.flattenDeep)(config.actions.map(getActionAnnotationFields));
-};
+function isDeclarationActionConfig(action) {
+  return DeclarationActions.safeParse(action.type).success;
+}
+function getDeclarationFields(configuration) {
+  return configuration.declaration.pages.flatMap(({ fields }) => fields);
+}
+function getDeclarationPages(configuration) {
+  return configuration.declaration.pages;
+}
+function getDeclaration(configuration) {
+  return configuration.declaration;
+}
 var getActionAnnotationFields = (actionConfig) => {
   if (actionConfig.type === ActionType.REQUEST_CORRECTION) {
     return [
@@ -1671,13 +1543,22 @@ var getActionAnnotationFields = (actionConfig) => {
     ];
   }
   if (actionConfig.type === ActionType.PRINT_CERTIFICATE) {
-    return actionConfig?.printForm.pages.flatMap(({ fields }) => fields) ?? [];
+    return actionConfig.printForm.pages.flatMap(({ fields }) => fields);
   }
   if (isDeclarationActionConfig(actionConfig)) {
-    return actionConfig?.review.fields ?? [];
+    return actionConfig.review.fields;
   }
   return [];
 };
+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) {
@@ -1688,72 +1569,37 @@ var findRecordActionPages = (config, actionType) => {
   }
   return [];
 };
-function isDeclarationActionConfig(action) {
-  return DeclarationActions.safeParse(action.type).success;
-}
-function getDeclarationFields(configuration) {
-  return configuration.declaration.pages.flatMap(({ fields }) => fields);
-}
-function getDeclarationPages(configuration) {
-  return configuration.declaration.pages;
-}
-function getDeclaration(configuration) {
-  return configuration.declaration;
-}
-function getActionReviewFields(configuration, actionType) {
-  return getActionReview(configuration, actionType).fields;
-}
 function getActionReview(configuration, actionType) {
   const [actionConfig] = configuration.actions.filter(
     (a) => a.type === actionType
   );
   return getOrThrow(
-    actionConfig?.review,
+    actionConfig.review,
     `No review config found for ${actionType}`
   );
 }
-function validateWorkqueueConfig(workqueueConfigs) {
-  workqueueConfigs.map((workqueue) => {
-    const rootWorkqueue = Object.values(workqueues).find(
-      (wq) => wq.id === workqueue.id
-    );
-    if (!rootWorkqueue) {
-      throw new Error(
-        `Invalid workqueue configuration: workqueue not found with id: ${workqueue.id}`
-      );
-    }
-  });
+function getActionReviewFields(configuration, actionType) {
+  return getActionReview(configuration, actionType).fields;
 }
 function isPageVisible(page, formValues) {
   if (!page.conditional) {
     return true;
   }
-  return validate(page.conditional, {
-    $form: formValues,
-    $now: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" })
-  });
-}
-var getVisiblePagesFormFields = (formConfig, formData) => {
-  return formConfig.pages.filter((p) => isPageVisible(p, formData)).flatMap((p) => p.fields);
-};
-function isOptionalUncheckedCheckbox(field2, form) {
-  if (field2.type !== FieldType.CHECKBOX || field2.required) {
-    return false;
-  }
-  return !form[field2.id];
+  return isConditionMet(page.conditional, formValues);
 }
-function stripHiddenFields(fields, declaration) {
-  return (0, import_lodash.omitBy)(declaration, (_2, fieldId) => {
+function omitHiddenFields(fields, values) {
+  return (0, import_lodash.omitBy)(values, (_, fieldId) => {
     const field2 = fields.find((f) => f.id === fieldId);
     if (!field2) {
       return true;
     }
-    if (isOptionalUncheckedCheckbox(field2, declaration)) {
-      return true;
-    }
-    return !isFieldVisible(field2, declaration);
+    return !isFieldVisible(field2, values);
   });
 }
+function omitHiddenPaginatedFields(formConfig, declaration) {
+  const visiblePagesFormFields = formConfig.pages.filter((p) => isPageVisible(p, declaration)).flatMap((p) => p.fields);
+  return omitHiddenFields(visiblePagesFormFields, declaration);
+}
 function findActiveDrafts(event2, drafts) {
   const actions = event2.actions.slice().filter(({ type }) => type !== ActionType.READ).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
   const lastAction = actions[actions.length - 1];
@@ -1796,19 +1642,28 @@ function deepMerge(currentDocument, actionDocument) {
     }
   );
 }
+function findLastAssignmentAction(actions) {
+  return actions.filter(
+    ({ type }) => type === ActionType.ASSIGN || type === ActionType.UNASSIGN
+  ).reduce((latestAction, action) => !latestAction || action.createdAt > latestAction.createdAt ? action : latestAction, void 0);
+}
+function isWriteAction(actionType) {
+  return writeActions.safeParse(actionType).success;
+}
 
 // ../commons/src/events/EventConfig.ts
-var EventConfig = import_zod20.z.object({
-  id: import_zod20.z.string().describe(
+var import_zod_openapi7 = require("zod-openapi");
+(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod16.z);
+var EventConfig = import_zod16.z.object({
+  id: import_zod16.z.string().describe(
     'A machine-readable identifier for the event, e.g. "birth" or "death"'
   ),
   summary: SummaryConfig,
   label: TranslationConfig,
-  actions: import_zod20.z.array(ActionConfig),
+  actions: import_zod16.z.array(ActionConfig),
   declaration: DeclarationFormConfig,
-  workqueues: import_zod20.z.array(WorkqueueConfig),
-  deduplication: import_zod20.z.array(DeduplicationConfig).optional().default([]),
-  advancedSearch: import_zod20.z.array(AdvancedSearchConfig).optional().default([])
+  deduplication: import_zod16.z.array(DeduplicationConfig).optional().default([]),
+  advancedSearch: import_zod16.z.array(AdvancedSearchConfig).optional().default([])
 }).superRefine((event2, ctx) => {
   const allFields = findAllFields(event2);
   const fieldIds = allFields.map((field2) => field2.id);
@@ -1834,6 +1689,8 @@ var EventConfig = import_zod20.z.object({
       path: ["advancedSearch"]
     });
   }
+}).openapi({
+  ref: "EventConfig"
 });
 
 // ../commons/src/events/EventConfigInput.ts
@@ -1842,306 +1699,451 @@ var defineActionForm = (actionForm) => ActionFormConfig.parse(actionForm);
 var definePage = (page) => PageConfig.parse(page);
 var defineFormPage = (formPage) => FormPageConfig.parse(formPage);
 
+// ../commons/src/events/WorkqueueConfig.ts
+var import_zod17 = require("zod");
+var WorkqueueConfig = import_zod17.z.object({
+  slug: import_zod17.z.string().describe("Determines the url of the workqueue."),
+  name: TranslationConfig.describe(
+    "Title of the workflow (both in navigation and on the page)"
+  ),
+  /**
+   * Placeholder untill the following gets merged to develop
+   * https://github.com/opencrvs/opencrvs-core/blob/5fbe9854a88504a7a13fcc856b3e82594b70c38c/packages/commons/src/events/EventIndex.ts#L92-L93
+   */
+  query: import_zod17.z.string(),
+  actions: import_zod17.z.array(
+    import_zod17.z.object({
+      type: import_zod17.z.string(),
+      conditionals: import_zod17.z.array(Conditional).optional()
+    })
+  )
+}).describe("Configuration for workqueue.");
+function defineWorkqueue(workqueues) {
+  return workqueues.map((workqueue) => WorkqueueConfig.parse(workqueue));
+}
+
 // ../commons/src/events/Draft.ts
-var import_zod23 = require("zod");
+var import_zod20 = require("zod");
 
 // ../commons/src/events/ActionDocument.ts
-var import_zod21 = require("zod");
-var ActionUpdate = import_zod21.z.record(import_zod21.z.string(), FieldUpdateValue);
+var import_zod18 = require("zod");
+var import_zod_openapi8 = require("zod-openapi");
+(0, import_zod_openapi8.extendZodWithOpenApi)(import_zod18.z);
+var ActionUpdate = import_zod18.z.record(import_zod18.z.string(), FieldUpdateValue);
 var ActionStatus = {
   Requested: "Requested",
   Accepted: "Accepted",
   Rejected: "Rejected"
 };
-var ActionBase = import_zod21.z.object({
-  id: import_zod21.z.string(),
-  createdAt: import_zod21.z.string().datetime(),
-  createdBy: import_zod21.z.string(),
+var ActionBase = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  transactionId: import_zod18.z.string(),
+  createdAt: import_zod18.z.string().datetime(),
+  createdBy: import_zod18.z.string(),
+  createdByRole: import_zod18.z.string(),
   declaration: ActionUpdate,
   annotation: ActionUpdate.optional(),
-  createdAtLocation: import_zod21.z.string(),
-  status: import_zod21.z.enum([
+  createdAtLocation: import_zod18.z.string(),
+  status: import_zod18.z.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
   ]),
   // If the action is an asynchronous confirmation for another action, we will save the original action id here.
-  originalActionId: import_zod21.z.string().optional()
+  originalActionId: import_zod18.z.string().optional()
 });
 var AssignedAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod21.z.string()
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.ASSIGN),
+    assignedTo: import_zod18.z.string()
   })
 );
 var UnassignedAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.UNASSIGN)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.UNASSIGN),
+    assignedTo: import_zod18.z.literal(null)
   })
 );
 var RegisterAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.REGISTER),
-    registrationNumber: import_zod21.z.string().optional()
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.REGISTER),
+    registrationNumber: import_zod18.z.string().optional()
   })
 );
 var DeclareAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.DECLARE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.DECLARE)
   })
 );
 var ValidateAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.VALIDATE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.VALIDATE)
   })
 );
 var RejectAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.REJECT)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.REJECT)
   })
 );
 var MarkAsDuplicateAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.MARKED_AS_DUPLICATE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.ARCHIVE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.ARCHIVE)
   })
 );
 var CreatedAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.CREATE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.CREATE)
   })
 );
 var NotifiedAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.NOTIFY)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.NOTIFY)
   })
 );
 var PrintCertificateAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.PRINT_CERTIFICATE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RequestedCorrectionAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.REQUEST_CORRECTION)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.REQUEST_CORRECTION)
   })
 );
 var ApprovedCorrectionAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.APPROVE_CORRECTION),
-    requestId: import_zod21.z.string()
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.APPROVE_CORRECTION),
+    requestId: import_zod18.z.string()
   })
 );
 var RejectedCorrectionAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.REJECT_CORRECTION),
-    requestId: import_zod21.z.string()
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.REJECT_CORRECTION),
+    requestId: import_zod18.z.string()
   })
 );
 var ReadAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.READ)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.READ)
   })
 );
-var ActionDocument = import_zod21.z.discriminatedUnion("type", [
-  CreatedAction,
-  ValidateAction,
-  RejectAction,
-  MarkAsDuplicateAction,
-  ArchiveAction,
-  NotifiedAction,
-  RegisterAction,
-  DeclareAction,
-  AssignedAction,
-  RequestedCorrectionAction,
-  ApprovedCorrectionAction,
-  RejectedCorrectionAction,
-  UnassignedAction,
-  PrintCertificateAction,
-  ReadAction
-]);
+var ActionDocument = import_zod18.z.discriminatedUnion("type", [
+  CreatedAction.openapi({ ref: "CreatedAction" }),
+  ValidateAction.openapi({ ref: "ValidateAction" }),
+  RejectAction.openapi({ ref: "RejectAction" }),
+  MarkAsDuplicateAction.openapi({ ref: "MarkAsDuplicateAction" }),
+  ArchiveAction.openapi({ ref: "ArchiveAction" }),
+  NotifiedAction.openapi({ ref: "NotifiedAction" }),
+  RegisterAction.openapi({ ref: "RegisterAction" }),
+  DeclareAction.openapi({ ref: "DeclareAction" }),
+  AssignedAction.openapi({ ref: "AssignedAction" }),
+  RequestedCorrectionAction.openapi({ ref: "RequestedCorrectionAction" }),
+  ApprovedCorrectionAction.openapi({ ref: "ApprovedCorrectionAction" }),
+  RejectedCorrectionAction.openapi({ ref: "RejectedCorrectionAction" }),
+  UnassignedAction.openapi({ ref: "UnassignedAction" }),
+  PrintCertificateAction.openapi({ ref: "PrintCertificateAction" }),
+  ReadAction.openapi({ ref: "ReadAction" })
+]).openapi({
+  ref: "ActionDocument"
+});
 var AsyncRejectActionDocument = ActionBase.omit({
   declaration: true,
   annotation: true,
   createdBy: true,
+  createdByRole: true,
   createdAtLocation: true
 }).merge(
-  import_zod21.z.object({
-    type: import_zod21.z.enum(ConfirmableActions),
-    status: import_zod21.z.literal(ActionStatus.Rejected)
+  import_zod18.z.object({
+    type: import_zod18.z.enum(ConfirmableActions),
+    status: import_zod18.z.literal(ActionStatus.Rejected)
   })
 );
-var Action = import_zod21.z.union([ActionDocument, AsyncRejectActionDocument]);
-var ResolvedUser = import_zod21.z.object({
-  id: import_zod21.z.string(),
-  role: import_zod21.z.string(),
-  name: import_zod21.z.array(
-    import_zod21.z.object({
-      use: import_zod21.z.string(),
-      given: import_zod21.z.array(import_zod21.z.string()),
-      family: import_zod21.z.string()
+var Action = import_zod18.z.union([ActionDocument, AsyncRejectActionDocument]);
+var ResolvedUser = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  role: import_zod18.z.string(),
+  name: import_zod18.z.array(
+    import_zod18.z.object({
+      use: import_zod18.z.string(),
+      given: import_zod18.z.array(import_zod18.z.string()),
+      family: import_zod18.z.string()
     })
   )
 });
 
 // ../commons/src/events/ActionInput.ts
-var import_zod22 = require("zod");
-var BaseActionInput = import_zod22.z.object({
-  eventId: import_zod22.z.string(),
-  transactionId: import_zod22.z.string(),
-  declaration: ActionUpdate,
+var import_zod19 = require("zod");
+var import_zod_openapi9 = require("zod-openapi");
+(0, import_zod_openapi9.extendZodWithOpenApi)(import_zod19.z);
+var BaseActionInput = import_zod19.z.object({
+  eventId: import_zod19.z.string(),
+  transactionId: import_zod19.z.string(),
+  declaration: ActionUpdate.default({}),
   annotation: ActionUpdate.optional(),
-  originalActionId: import_zod22.z.string().optional()
+  originalActionId: import_zod19.z.string().optional(),
+  keepAssignment: import_zod19.z.boolean().optional()
 });
 var CreateActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.CREATE).default(ActionType.CREATE),
-    createdAtLocation: import_zod22.z.string()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.CREATE).default(ActionType.CREATE),
+    createdAtLocation: import_zod19.z.string()
   })
 );
 var RegisterActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
-    registrationNumber: import_zod22.z.string().optional()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
+    registrationNumber: import_zod19.z.string().optional()
   })
 );
 var ValidateActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
-    duplicates: import_zod22.z.array(import_zod22.z.string())
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
+    duplicates: import_zod19.z.array(import_zod19.z.string())
   })
 );
 var NotifyActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
   })
 );
 var DeclareActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
   })
 );
 var PrintCertificateActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RejectDeclarationActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.REJECT).default(ActionType.REJECT)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.REJECT).default(ActionType.REJECT)
   })
 );
 var MarkedAsDuplicateActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE)
   })
 );
 var AssignActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
-    assignedTo: import_zod22.z.string()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
+    assignedTo: import_zod19.z.string()
   })
 );
 var UnassignActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
+    assignedTo: import_zod19.z.literal(null).default(null)
   })
 );
 var RequestCorrectionActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
   })
 );
 var RejectCorrectionActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    requestId: import_zod22.z.string(),
-    type: import_zod22.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
+  import_zod19.z.object({
+    requestId: import_zod19.z.string(),
+    type: import_zod19.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
   })
 );
 var ApproveCorrectionActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    requestId: import_zod22.z.string(),
-    type: import_zod22.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
+  import_zod19.z.object({
+    requestId: import_zod19.z.string(),
+    type: import_zod19.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
   })
 );
 var ReadActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.READ).default(ActionType.READ)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.READ).default(ActionType.READ)
   })
 );
-var ActionInput = import_zod22.z.discriminatedUnion("type", [
-  CreateActionInput,
-  ValidateActionInput,
-  RegisterActionInput,
-  NotifyActionInput,
-  DeclareActionInput,
-  RejectDeclarationActionInput,
-  MarkedAsDuplicateActionInput,
-  ArchiveActionInput,
-  AssignActionInput,
-  UnassignActionInput,
-  PrintCertificateActionInput,
-  RequestCorrectionActionInput,
-  RejectCorrectionActionInput,
-  ApproveCorrectionActionInput,
-  ReadActionInput
-]);
+var DeleteActionInput = import_zod19.z.object({ eventId: import_zod19.z.string() });
+var ActionInput = import_zod19.z.discriminatedUnion("type", [
+  CreateActionInput.openapi({ ref: "CreateActionInput" }),
+  ValidateActionInput.openapi({ ref: "ValidateActionInput" }),
+  RegisterActionInput.openapi({ ref: "RegisterActionInput" }),
+  NotifyActionInput.openapi({ ref: "NotifyActionInput" }),
+  DeclareActionInput.openapi({ ref: "DeclareActionInput" }),
+  RejectDeclarationActionInput.openapi({
+    ref: "RejectDeclarationActionInput"
+  }),
+  MarkedAsDuplicateActionInput.openapi({
+    ref: "MarkedAsDuplicateActionInput"
+  }),
+  ArchiveActionInput.openapi({ ref: "ArchiveActionInput" }),
+  AssignActionInput.openapi({ ref: "AssignActionInput" }),
+  UnassignActionInput.openapi({ ref: "UnassignActionInput" }),
+  PrintCertificateActionInput.openapi({ ref: "PrintCertificateActionInput" }),
+  RequestCorrectionActionInput.openapi({
+    ref: "RequestCorrectionActionInput"
+  }),
+  RejectCorrectionActionInput.openapi({ ref: "RejectCorrectionActionInput" }),
+  ApproveCorrectionActionInput.openapi({
+    ref: "ApproveCorrectionActionInput"
+  }),
+  ReadActionInput.openapi({ ref: "ReadActionInput" })
+]).openapi({
+  ref: "ActionInput"
+});
 
 // ../commons/src/events/Draft.ts
-var Draft = import_zod23.z.object({
-  id: import_zod23.z.string(),
-  eventId: import_zod23.z.string(),
-  transactionId: import_zod23.z.string(),
-  createdAt: import_zod23.z.string().datetime(),
+var Draft = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  eventId: import_zod20.z.string(),
+  transactionId: import_zod20.z.string(),
+  createdAt: import_zod20.z.string().datetime(),
   action: ActionBase.extend({
     type: ActionTypes
-  }).omit({ id: true, status: true })
+  }).omit({ id: true })
 });
 var DraftInput = BaseActionInput.extend({
   type: ActionTypes
 });
 
+// ../commons/src/events/EventMetadata.ts
+var import_zod21 = require("zod");
+var EventStatus = {
+  CREATED: "CREATED",
+  NOTIFIED: "NOTIFIED",
+  DECLARED: "DECLARED",
+  VALIDATED: "VALIDATED",
+  REGISTERED: "REGISTERED",
+  CERTIFIED: "CERTIFIED",
+  REJECTED: "REJECTED",
+  ARCHIVED: "ARCHIVED"
+};
+var eventStatuses = Object.values(EventStatus);
+var EventStatuses = import_zod21.z.nativeEnum(EventStatus);
+var EventMetadata = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  type: import_zod21.z.string(),
+  status: EventStatuses,
+  createdAt: import_zod21.z.string().datetime(),
+  createdBy: import_zod21.z.string(),
+  updatedByUserRole: import_zod21.z.string(),
+  createdAtLocation: import_zod21.z.string(),
+  updatedAtLocation: import_zod21.z.string(),
+  modifiedAt: import_zod21.z.string().datetime(),
+  assignedTo: import_zod21.z.string().nullish(),
+  updatedBy: import_zod21.z.string(),
+  trackingId: import_zod21.z.string(),
+  registrationNumber: import_zod21.z.string().nullish()
+});
+var 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.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.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"
+  }
+};
+
 // ../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()
+var import_zod22 = require("zod");
+var EventInput = import_zod22.z.object({
+  transactionId: import_zod22.z.string(),
+  type: import_zod22.z.string()
 });
 
 // ../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()
-});
+var import_zod23 = require("zod");
+var import_zod_openapi10 = require("zod-openapi");
+(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod23.z);
+var EventDocument = import_zod23.z.object({
+  id: import_zod23.z.string(),
+  type: import_zod23.z.string(),
+  createdAt: import_zod23.z.string().datetime(),
+  updatedAt: import_zod23.z.string().datetime(),
+  updatedAtLocation: import_zod23.z.string(),
+  actions: import_zod23.z.array(Action),
+  trackingId: import_zod23.z.string()
+}).openapi({ ref: "EventDocument" });
 
 // ../commons/src/events/EventIndex.ts
-var import_zod26 = require("zod");
+var import_zod24 = require("zod");
 var EventIndex = EventMetadata.extend({
-  declaration: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any())
+  declaration: import_zod24.z.record(import_zod24.z.string(), import_zod24.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()
+var EventSearchIndex = import_zod24.z.record(import_zod24.z.string(), import_zod24.z.any()).and(
+  import_zod24.z.object({
+    type: import_zod24.z.string()
     // Ensures "type" (event-id) exists and is a string
   })
 );
 
 // ../commons/src/events/state/index.ts
-var _ = __toESM(require("lodash"));
 function getStatusFromActions(actions) {
   const hasRejectedAction = actions.some(
     (a) => a.status === ActionStatus.Rejected
@@ -2150,30 +2152,46 @@ function getStatusFromActions(actions) {
     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;
+    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:
+      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;
     }
-    return status;
   }, EventStatus.CREATED);
 }
+function getLastUpdatedByUserRoleFromActions(actions) {
+  const actionsWithRoles = actions.filter(
+    (action) => !isWriteAction(action.type) && action.status !== ActionStatus.Rejected
+  ).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const lastAction = actionsWithRoles.at(-1);
+  if (!lastAction) {
+    throw new Error(
+      "Should never happen, at least CREATE action should be present"
+    );
+  }
+  return ActionDocument.parse(lastAction).createdByRole;
+}
 function getAssignedUserFromActions(actions) {
   return actions.reduce((user2, action) => {
     if (action.type === ActionType.ASSIGN) {
@@ -2205,26 +2223,27 @@ function aggregateActionDeclarations(actions) {
   }, {});
 }
 function deepDropNulls(obj) {
-  if (!_.isObject(obj)) return obj;
-  return Object.entries(obj).reduce((acc, [key, value]) => {
-    if (_.isObject(value)) {
-      value = deepDropNulls(value);
-    }
-    if (value !== null) {
-      return {
-        ...acc,
-        [key]: value
-      };
-    }
-    return acc;
-  }, {});
+  if (Array.isArray(obj)) {
+    return obj.map(deepDropNulls);
+  }
+  if (obj !== null && typeof obj === "object") {
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+      const cleanedValue = deepDropNulls(value);
+      if (cleanedValue !== null) {
+        ;
+        acc[key] = cleanedValue;
+      }
+      return acc;
+    }, {});
+  }
+  return obj;
 }
 function isUndeclaredDraft(status) {
   return status === EventStatus.CREATED;
 }
 function getAcceptedActions(event2) {
   return event2.actions.filter(
-    (a) => !a.status || a.status === ActionStatus.Accepted
+    (a) => a.status === ActionStatus.Accepted
   );
 }
 function getCurrentEventState(event2) {
@@ -2250,9 +2269,11 @@ function getCurrentEventState(event2) {
     modifiedAt: latestAction.createdAt,
     assignedTo: getAssignedUserFromActions(activeActions),
     updatedBy: latestAction.createdBy,
+    updatedAtLocation: event2.updatedAtLocation,
     declaration: aggregateActionDeclarations(activeActions),
     trackingId: event2.trackingId,
-    registrationNumber
+    registrationNumber,
+    updatedByUserRole: getLastUpdatedByUserRoleFromActions(event2.actions)
   });
 }
 function getCurrentEventStateWithDrafts(event2, drafts) {
@@ -2290,27 +2311,35 @@ function applyDraftsToEventIndex(eventIndex, drafts) {
     }
   };
 }
+function getAnnotationFromDrafts(drafts) {
+  const actions = drafts.map((draft) => draft.action);
+  const annotation = actions.reduce((ann, action) => {
+    return deepMerge(ann, action.annotation ?? {});
+  }, {});
+  return deepDropNulls(annotation);
+}
 function getActionAnnotation({
   event: event2,
   actionType,
-  drafts
+  drafts = []
 }) {
   const activeActions = getAcceptedActions(event2);
-  const action = activeActions.find((action2) => actionType === action2.type);
+  const action = activeActions.find(
+    (activeAction) => actionType === activeAction.type
+  );
   const eventDrafts = drafts.filter((draft) => draft.eventId === event2.id);
   const sorted = [
     ...action ? [action] : [],
     ...eventDrafts.map((draft) => draft.action)
   ].sort();
-  const annotation = sorted.reduce((annotation2, action2) => {
-    return deepMerge(annotation2, action2.annotation ?? {});
+  const annotation = sorted.reduce((ann, sortedAction) => {
+    return deepMerge(ann, sortedAction.annotation ?? {});
   }, {});
   return deepDropNulls(annotation);
 }
 
 // ../commons/src/events/defineConfig.ts
 var defineConfig = (config) => {
-  validateWorkqueueConfig(config.workqueues);
   const input = EventConfig.parse(config);
   return input;
 };
@@ -2327,6 +2356,16 @@ var import_lodash2 = require("lodash");
 function defineConditional(schema) {
   return schema;
 }
+function defineFormConditional(schema) {
+  const schemaWithForm = {
+    type: "object",
+    properties: {
+      $form: schema
+    },
+    required: ["$form"]
+  };
+  return defineConditional(schemaWithForm);
+}
 function alwaysTrue() {
   return {};
 }
@@ -2351,6 +2390,9 @@ function not(condition) {
     required: []
   });
 }
+function never() {
+  return not(alwaysTrue());
+}
 var user = {
   hasScope: (scope) => defineConditional({
     type: "object",
@@ -2398,100 +2440,118 @@ var event = {
     required: ["$event"]
   })
 };
+function getDateFromNow(days) {
+  return new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString().split("T")[0];
+}
+function getDateRangeToFieldReference(fieldId, comparedFieldId, clause) {
+  return {
+    type: "object",
+    properties: {
+      [fieldId]: {
+        type: "string",
+        format: "date",
+        [clause]: { $data: `1/${comparedFieldId}` }
+      },
+      [comparedFieldId]: { type: "string", format: "date" }
+    },
+    required: [fieldId]
+  };
+}
+function isFieldReference(value) {
+  return typeof value === "object" && value !== null && "_fieldId" in value;
+}
 function field(fieldId) {
-  const getDateFromNow = (days) => new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString().split("T")[0];
   const getDateRange = (date, clause) => ({
     type: "object",
     properties: {
-      $form: {
-        type: "object",
-        properties: {
-          [fieldId]: {
-            type: "string",
-            format: "date",
-            [clause]: date
-          }
-        },
-        required: [fieldId]
+      [fieldId]: {
+        type: "string",
+        format: "date",
+        [clause]: date
       }
     },
-    required: ["$form"]
+    required: [fieldId]
   });
   return {
     /**
      * @private Internal property used for field reference tracking.
      */
-    _returning: fieldId,
+    _fieldId: fieldId,
     isAfter: () => ({
       days: (days) => ({
-        inPast: () => defineConditional(
+        inPast: () => defineFormConditional(
           getDateRange(getDateFromNow(days), "formatMinimum")
         ),
-        inFuture: () => defineConditional(
+        inFuture: () => defineFormConditional(
           getDateRange(getDateFromNow(-days), "formatMinimum")
         )
       }),
-      date: (date) => defineConditional(getDateRange(date, "formatMinimum")),
-      now: () => defineConditional(getDateRange(getDateFromNow(0), "formatMinimum"))
+      date: (date) => {
+        if (isFieldReference(date)) {
+          const comparedFieldId = date._fieldId;
+          return defineFormConditional(
+            getDateRangeToFieldReference(
+              fieldId,
+              comparedFieldId,
+              "formatMinimum"
+            )
+          );
+        }
+        return defineFormConditional(getDateRange(date, "formatMinimum"));
+      },
+      now: () => defineFormConditional(getDateRange(getDateFromNow(0), "formatMinimum"))
     }),
     isBefore: () => ({
       days: (days) => ({
-        inPast: () => defineConditional(
+        inPast: () => defineFormConditional(
           getDateRange(getDateFromNow(days), "formatMaximum")
         ),
-        inFuture: () => defineConditional(
+        inFuture: () => defineFormConditional(
           getDateRange(getDateFromNow(-days), "formatMaximum")
         )
       }),
-      date: (date) => defineConditional(getDateRange(date, "formatMaximum")),
-      now: () => defineConditional(getDateRange(getDateFromNow(0), "formatMaximum"))
+      date: (date) => {
+        if (isFieldReference(date)) {
+          const comparedFieldId = date._fieldId;
+          return defineFormConditional(
+            getDateRangeToFieldReference(
+              fieldId,
+              comparedFieldId,
+              "formatMaximum"
+            )
+          );
+        }
+        return defineFormConditional(getDateRange(date, "formatMaximum"));
+      },
+      now: () => defineFormConditional(getDateRange(getDateFromNow(0), "formatMaximum"))
     }),
-    // TODO CIHAN: typing
     isEqualTo: (value) => {
-      if (typeof value === "object" && value._returning) {
-        const comparedFieldId = value._returning;
-        return defineConditional({
+      if (isFieldReference(value)) {
+        const comparedFieldId = value._fieldId;
+        return defineFormConditional({
           type: "object",
           properties: {
-            $form: {
-              type: "object",
-              properties: {
-                [fieldId]: { type: ["string", "boolean"] },
-                [comparedFieldId]: { type: ["string", "boolean"] }
-              },
-              required: [fieldId, comparedFieldId],
-              allOf: [
-                {
-                  properties: {
-                    [fieldId]: {
-                      const: { $data: `1/${comparedFieldId}` }
-                    }
-                  }
-                }
-              ]
-            }
+            [fieldId]: {
+              type: ["string", "boolean"],
+              const: { $data: `1/${comparedFieldId}` }
+            },
+            [comparedFieldId]: { type: ["string", "boolean"] }
           },
-          required: ["$form"]
+          required: [fieldId, comparedFieldId]
         });
       }
-      return defineConditional({
+      return defineFormConditional({
         type: "object",
         properties: {
-          $form: {
-            type: "object",
-            properties: {
-              [fieldId]: {
-                oneOf: [
-                  { type: "string", const: value },
-                  { type: "boolean", const: value }
-                ],
-                const: value
-              }
-            },
-            required: [fieldId]
+          [fieldId]: {
+            oneOf: [
+              { type: "string", const: value },
+              { type: "boolean", const: value }
+            ],
+            const: value
           }
         },
-        required: ["$form"]
+        required: [fieldId]
       });
     },
     /**
@@ -2502,140 +2562,87 @@ function field(fieldId) {
      * NOTE: For now, this only works with string, boolean, and null types. 0 is still allowed.
      *
      */
-    isFalsy: () => defineConditional({
+    isFalsy: () => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              anyOf: [
-                { const: "undefined" },
-                { const: false },
-                { const: null },
-                { const: "" }
-              ]
-            }
-          },
+        [fieldId]: {
           anyOf: [
-            {
-              required: [fieldId]
-            },
-            {
-              not: {
-                required: [fieldId]
-              }
-            }
+            { const: "undefined" },
+            { const: false },
+            { const: null },
+            { const: "" }
           ]
         }
       },
-      required: ["$form"]
-    }),
-    isUndefined: () => defineConditional({
-      type: "object",
-      properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              enum: ["undefined"]
-            }
-          },
+      anyOf: [
+        {
+          required: [fieldId]
+        },
+        {
           not: {
             required: [fieldId]
           }
         }
-      },
-      required: ["$form"]
+      ]
     }),
-    inArray: (values) => defineConditional({
+    isUndefined: () => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              enum: values
-            }
-          },
-          required: [fieldId]
+        [fieldId]: {
+          type: "string",
+          enum: ["undefined"]
         }
       },
-      required: ["$form"]
+      not: {
+        required: [fieldId]
+      }
     }),
-    isValidEnglishName: () => defineConditional({
+    inArray: (values) => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              pattern: "^[\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*( [\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*)*$",
-              description: "Name must contain only letters, numbers, and allowed special characters ('._-). No double spaces."
-            }
-          },
-          required: [fieldId]
+        [fieldId]: {
+          type: "string",
+          enum: values
         }
       },
-      required: ["$form"]
+      required: [fieldId]
     }),
-    isValidNationalId: () => defineConditional({
+    isValidEnglishName: () => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              pattern: "^[0-9]{9}$",
-              description: "The National ID can only be numeric and must be 9 digits long."
-            }
-          },
-          required: [fieldId]
+        [fieldId]: {
+          type: "string",
+          pattern: "^[\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*( [\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*)*$",
+          description: "Name must contain only letters, numbers, and allowed special characters ('._-). No double spaces."
         }
       },
-      required: ["$form"]
+      required: [fieldId]
     }),
     /**
      * Checks if the field value matches a given regular expression pattern.
      * @param pattern - The regular expression pattern to match the field value against.
      * @returns A JSONSchema conditional that validates the field value against the pattern.
      */
-    matches: (pattern) => defineConditional({
+    matches: (pattern) => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "string",
-              pattern
-            }
-          },
-          required: [fieldId]
+        [fieldId]: {
+          type: "string",
+          pattern
         }
       },
-      required: ["$form"]
+      required: [fieldId]
     }),
-    isBetween: (min, max) => defineConditional({
+    isBetween: (min, max) => defineFormConditional({
       type: "object",
       properties: {
-        $form: {
-          type: "object",
-          properties: {
-            [fieldId]: {
-              type: "number",
-              minimum: min,
-              maximum: max
-            }
-          },
-          required: [fieldId]
+        [fieldId]: {
+          type: "number",
+          minimum: min,
+          maximum: max
         }
       },
-      required: ["$form"]
+      required: [fieldId]
     })
   };
 }
@@ -3378,9 +3385,8 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
         },
         {
           id: "applicant.dob",
-          type: "DATE",
+          type: FieldType.DATE,
           required: true,
-          conditionals: [],
           validation: [
             {
               message: {
@@ -3391,12 +3397,50 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
               validator: field("applicant.dob").isBefore().now()
             }
           ],
+          conditionals: [
+            {
+              type: ConditionalType.SHOW,
+              conditional: field("applicant.dobUnknown").isFalsy()
+            }
+          ],
           label: {
             defaultMessage: "Applicant's date of birth",
             description: "This is the label for the field",
             id: "v2.event.tennis-club-membership.action.declare.form.section.who.field.dob.label"
           }
         },
+        {
+          id: "applicant.dobUnknown",
+          type: FieldType.CHECKBOX,
+          required: false,
+          label: {
+            defaultMessage: "Exact date of birth unknown",
+            description: "This is the label for the field",
+            id: "v2.event.tennis-club-membership.action.declare.form.section.who.field.dobUnknown.label"
+          },
+          conditionals: [
+            {
+              type: ConditionalType.DISPLAY_ON_REVIEW,
+              conditional: never()
+            }
+          ]
+        },
+        {
+          id: "applicant.age",
+          type: FieldType.NUMBER,
+          required: true,
+          label: {
+            defaultMessage: "Age of tennis-member",
+            description: "This is the label for the field",
+            id: "v2.event.tennis-club-membership.action.declare.form.section.who.field.age.label"
+          },
+          conditionals: [
+            {
+              type: ConditionalType.SHOW,
+              conditional: field("applicant.dobUnknown").isEqualTo(true)
+            }
+          ]
+        },
         {
           id: "applicant.image",
           type: FieldType.FILE,
@@ -3572,28 +3616,6 @@ var tennisClubMembershipEvent = defineConfig({
       }
     ]
   },
-  workqueues: [
-    {
-      id: "all",
-      filters: []
-    },
-    {
-      id: "ready-for-review",
-      filters: [
-        {
-          status: ["DECLARED"]
-        }
-      ]
-    },
-    {
-      id: "registered",
-      filters: [
-        {
-          status: ["REGISTERED"]
-        }
-      ]
-    }
-  ],
   actions: [
     {
       type: ActionType.DECLARE,
@@ -3912,7 +3934,7 @@ var tennisClubMembershipEvent = defineConfig({
 });
 
 // ../commons/src/events/test.utils.ts
-function fieldConfigsToActionAnnotation(fields) {
+function fieldConfigsToActionPayload(fields) {
   return fields.reduce(
     (acc, field2, i) => ({
       ...acc,
@@ -3921,23 +3943,27 @@ function fieldConfigsToActionAnnotation(fields) {
     {}
   );
 }
-function generateActionInput(configuration, action) {
+function generateActionDeclarationInput(configuration, action) {
   const parsed = DeclarationUpdateActions.safeParse(action);
   if (parsed.success) {
     const fields = getDeclarationFields(configuration);
-    const annotation = fieldConfigsToActionAnnotation(fields);
-    return stripHiddenFields(fields, annotation);
+    const declarationConfig = getDeclaration(configuration);
+    const declaration = fieldConfigsToActionPayload(fields);
+    return omitHiddenPaginatedFields(declarationConfig, declaration);
   }
   console.warn(`${action} is not a declaration action. Setting data as {}.`);
   return {};
 }
-function generateActionMetadataInput(configuration, action) {
+function generateActionAnnotationInput(configuration, action) {
   const actionConfig = configuration.actions.find(
-    (actionConfig2) => actionConfig2.type === action
+    (ac) => ac.type === action
   );
   const annotationFields = actionConfig ? getActionAnnotationFields(actionConfig) : [];
-  const annotation = fieldConfigsToActionAnnotation(annotationFields);
-  const visibleVerificationPageIds = (findRecordActionPages(configuration, action) ?? []).filter((page) => isVerificationPage(page)).filter((page) => isPageVisible(page, annotation)).map((page) => page.id) ?? [];
+  const annotation = fieldConfigsToActionPayload(annotationFields);
+  const visibleVerificationPageIds = findRecordActionPages(
+    configuration,
+    action
+  ).filter((page) => isVerificationPage(page)).filter((page) => isPageVisible(page, annotation)).map((page) => page.id);
   const visiblePageVerificationMap = visibleVerificationPageIds.reduce(
     (acc, pageId) => ({
       ...acc,
@@ -3945,7 +3971,7 @@ function generateActionMetadataInput(configuration, action) {
     }),
     {}
   );
-  const fieldBasedPayload = stripHiddenFields(annotationFields, annotation);
+  const fieldBasedPayload = omitHiddenFields(annotationFields, annotation);
   return {
     ...fieldBasedPayload,
     ...visiblePageVerificationMap
@@ -3961,14 +3987,16 @@ var eventPayloadGenerator = {
     type: input.type ?? "TENNIS_CLUB_MEMBERSHIP",
     id
   }),
-  draft: (eventId, input = {}) => (0, import_lodash2.merge)(
+  draft: ({ eventId, actionType }, input = {}) => (0, import_lodash2.merge)(
     {
       id: getUUID(),
       eventId,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       transactionId: getUUID(),
       action: {
-        type: ActionType.REQUEST_CORRECTION,
+        transactionId: getUUID(),
+        type: actionType,
+        status: ActionStatus.Accepted,
         declaration: {
           "applicant.firstname": "Max",
           "applicant.surname": "McLaren",
@@ -3981,6 +4009,7 @@ var eventPayloadGenerator = {
         },
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         createdBy: "@todo",
+        createdByRole: "@todo",
         createdAtLocation: "@todo"
       }
     },
@@ -3990,8 +4019,11 @@ var eventPayloadGenerator = {
     declare: (eventId, input = {}) => ({
       type: ActionType.DECLARE,
       transactionId: input.transactionId ?? getUUID(),
-      declaration: input.declaration ?? generateActionInput(tennisClubMembershipEvent, ActionType.DECLARE),
-      annotation: input.annotation ?? generateActionMetadataInput(
+      declaration: input.declaration ?? generateActionDeclarationInput(
+        tennisClubMembershipEvent,
+        ActionType.DECLARE
+      ),
+      annotation: input.annotation ?? generateActionAnnotationInput(
         tennisClubMembershipEvent,
         ActionType.DECLARE
       ),
@@ -4004,7 +4036,10 @@ var eventPayloadGenerator = {
       let declaration = input.declaration;
       if (!declaration) {
         const partialDeclaration = (0, import_lodash2.omitBy)(
-          generateActionInput(tennisClubMembershipEvent, ActionType.DECLARE),
+          generateActionDeclarationInput(
+            tennisClubMembershipEvent,
+            ActionType.DECLARE
+          ),
           import_lodash2.isString
         );
         declaration = partialDeclaration;
@@ -4019,14 +4054,31 @@ var eventPayloadGenerator = {
     validate: (eventId, input = {}) => ({
       type: ActionType.VALIDATE,
       transactionId: input.transactionId ?? getUUID(),
-      declaration: input.declaration ?? generateActionInput(tennisClubMembershipEvent, ActionType.VALIDATE),
-      annotation: input.annotation ?? generateActionMetadataInput(
+      declaration: input.declaration ?? generateActionDeclarationInput(
+        tennisClubMembershipEvent,
+        ActionType.VALIDATE
+      ),
+      annotation: input.annotation ?? generateActionAnnotationInput(
         tennisClubMembershipEvent,
         ActionType.VALIDATE
       ),
       duplicates: [],
       eventId
     }),
+    assign: (eventId, input = {}) => ({
+      type: ActionType.ASSIGN,
+      transactionId: input.transactionId ?? getUUID(),
+      declaration: {},
+      assignedTo: input.assignedTo ?? getUUID(),
+      eventId
+    }),
+    unassign: (eventId, input = {}) => ({
+      type: ActionType.UNASSIGN,
+      transactionId: input.transactionId ?? getUUID(),
+      declaration: {},
+      assignedTo: null,
+      eventId
+    }),
     archive: (eventId, input = {}, isDuplicate) => ({
       type: ActionType.ARCHIVE,
       transactionId: input.transactionId ?? getUUID(),
@@ -4040,7 +4092,7 @@ var eventPayloadGenerator = {
       type: ActionType.REJECT,
       transactionId: input.transactionId ?? getUUID(),
       declaration: {},
-      annotation: input.annotation ?? generateActionMetadataInput(
+      annotation: input.annotation ?? generateActionAnnotationInput(
         tennisClubMembershipEvent,
         ActionType.REJECT
       ),
@@ -4050,8 +4102,11 @@ var eventPayloadGenerator = {
     register: (eventId, input = {}) => ({
       type: ActionType.REGISTER,
       transactionId: input.transactionId ?? getUUID(),
-      declaration: input.declaration ?? generateActionInput(tennisClubMembershipEvent, ActionType.REGISTER),
-      annotation: input.annotation ?? generateActionMetadataInput(
+      declaration: input.declaration ?? generateActionDeclarationInput(
+        tennisClubMembershipEvent,
+        ActionType.REGISTER
+      ),
+      annotation: input.annotation ?? generateActionAnnotationInput(
         tennisClubMembershipEvent,
         ActionType.REGISTER
       ),
@@ -4061,7 +4116,7 @@ var eventPayloadGenerator = {
       type: ActionType.PRINT_CERTIFICATE,
       transactionId: input.transactionId ?? getUUID(),
       declaration: {},
-      annotation: input.annotation ?? generateActionMetadataInput(
+      annotation: input.annotation ?? generateActionAnnotationInput(
         tennisClubMembershipEvent,
         ActionType.PRINT_CERTIFICATE
       ),
@@ -4071,11 +4126,11 @@ var eventPayloadGenerator = {
       request: (eventId, input = {}) => ({
         type: ActionType.REQUEST_CORRECTION,
         transactionId: input.transactionId ?? getUUID(),
-        declaration: input.declaration ?? generateActionInput(
+        declaration: input.declaration ?? generateActionDeclarationInput(
           tennisClubMembershipEvent,
           ActionType.REQUEST_CORRECTION
         ),
-        annotation: input.annotation ?? generateActionMetadataInput(
+        annotation: input.annotation ?? generateActionAnnotationInput(
           tennisClubMembershipEvent,
           ActionType.REQUEST_CORRECTION
         ),
@@ -4085,7 +4140,7 @@ var eventPayloadGenerator = {
         type: ActionType.APPROVE_CORRECTION,
         transactionId: input.transactionId ?? getUUID(),
         declaration: {},
-        annotation: input.annotation ?? generateActionMetadataInput(
+        annotation: input.annotation ?? generateActionAnnotationInput(
           tennisClubMembershipEvent,
           ActionType.APPROVE_CORRECTION
         ),
@@ -4096,7 +4151,7 @@ var eventPayloadGenerator = {
         type: ActionType.REJECT_CORRECTION,
         transactionId: input.transactionId ?? getUUID(),
         declaration: {},
-        annotation: input.annotation ?? generateActionMetadataInput(
+        annotation: input.annotation ?? generateActionAnnotationInput(
           tennisClubMembershipEvent,
           ActionType.REJECT_CORRECTION
         ),
@@ -4116,18 +4171,24 @@ 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: "TODO",
-    declaration: generateActionInput(configuration, action),
+    declaration: generateActionDeclarationInput(configuration, action),
     annotation: {},
     ...defaults,
-    status: ActionStatus.Accepted
+    status: ActionStatus.Accepted,
+    transactionId: getUUID()
   };
   switch (action) {
+    case ActionType.READ:
+      return { ...actionBase, type: action };
+    case ActionType.MARKED_AS_DUPLICATE:
+      return { ...actionBase, type: action };
     case ActionType.DECLARE:
       return { ...actionBase, type: action };
     case ActionType.UNASSIGN:
-      return { ...actionBase, type: action };
+      return { ...actionBase, type: action, assignedTo: null };
     case ActionType.ASSIGN:
       return { ...actionBase, assignedTo: getUUID(), type: action };
     case ActionType.VALIDATE:
@@ -4153,6 +4214,8 @@ function generateActionDocument({
         ...actionBase,
         type: action
       };
+    case ActionType.DELETE:
+    case ActionType.DETECT_DUPLICATE:
     default:
       throw new Error(`Unsupported action type: ${action}`);
   }
@@ -4173,7 +4236,8 @@ function generateEventDocument({
     id: getUUID(),
     // Offset is needed so the createdAt timestamps for events, actions and drafts make logical sense in storybook tests.
     // @TODO: This should be fixed in the future.
-    updatedAt: new Date(Date.now() - 1e3).toISOString()
+    updatedAt: new Date(Date.now() - 1e3).toISOString(),
+    updatedAtLocation: "TODO"
   };
 }
 function generateEventDraftDocument(eventId, actionType = ActionType.DECLARE, declaration = {}) {
@@ -4202,9 +4266,11 @@ var eventQueryDataGenerator = (overrides = {}) => ({
   createdAt: overrides.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
   createdBy: overrides.createdBy ?? getUUID(),
   createdAtLocation: overrides.createdAtLocation ?? getUUID(),
+  updatedAtLocation: overrides.updatedAtLocation ?? getUUID(),
   modifiedAt: overrides.modifiedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
   assignedTo: overrides.assignedTo ?? null,
   updatedBy: overrides.updatedBy ?? getUUID(),
+  updatedByUserRole: overrides.updatedByUserRole ?? "FIELD_AGENT",
   declaration: overrides.declaration ?? {
     "recommender.none": true,
     "applicant.firstname": "Danny",
@@ -4236,7 +4302,9 @@ function isFieldValueWithoutTemplates(value) {
   return true;
 }
 function isFieldConfigDefaultValue(value) {
-  if (!value) return false;
+  if (!value) {
+    return false;
+  }
   if (isFieldValue(value)) {
     return true;
   }
@@ -4248,3 +4316,189 @@ function isFieldConfigDefaultValue(value) {
   }
   return false;
 }
+
+// ../commons/src/events/scopes.ts
+var import_lodash3 = require("lodash");
+
+// ../commons/src/scopes.ts
+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 scopes = Object.values(SCOPES);
+
+// ../commons/src/events/scopes.ts
+function hasAnyOfScopes(a, b) {
+  return (0, import_lodash3.intersection)(a, b).length > 0;
+}
+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 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]: []
+};
+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];
+}