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

package/dist/events/index.js

@@ -30,7 +30,6 @@ 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,
@@ -53,7 +52,6 @@ __export(events_exports, {
   AssignActionInput: () => AssignActionInput,
   AsyncRejectActionDocument: () => AsyncRejectActionDocument,
   BaseActionInput: () => BaseActionInput,
-  CONFIG_GET_ALLOWED_SCOPES: () => CONFIG_GET_ALLOWED_SCOPES,
   CertificateConfig: () => CertificateConfig,
   CertificateTemplateConfig: () => CertificateTemplateConfig,
   CheckboxFieldValue: () => CheckboxFieldValue,
@@ -71,7 +69,6 @@ __export(events_exports, {
   DeclarationUpdateActions: () => DeclarationUpdateActions,
   DeclareActionInput: () => DeclareActionInput,
   DeduplicationConfig: () => DeduplicationConfig,
-  DeleteActionInput: () => DeleteActionInput,
   DisplayOnReviewConditional: () => DisplayOnReviewConditional,
   Draft: () => Draft,
   DraftInput: () => DraftInput,
@@ -133,7 +130,6 @@ __export(events_exports, {
   and: () => and,
   annotationActions: () => annotationActions,
   applyDraftsToEventIndex: () => applyDraftsToEventIndex,
-  areConditionsMet: () => areConditionsMet,
   compositeFieldTypes: () => compositeFieldTypes,
   createEmptyDraft: () => createEmptyDraft,
   createValidationSchema: () => createValidationSchema,
@@ -146,7 +142,6 @@ __export(events_exports, {
   defineFormConditional: () => defineFormConditional,
   defineFormPage: () => defineFormPage,
   definePage: () => definePage,
-  defineWorkqueue: () => defineWorkqueue,
   errorMessages: () => errorMessages,
   event: () => event,
   eventMetadataLabelMap: () => eventMetadataLabelMap,
@@ -155,7 +150,6 @@ __export(events_exports, {
   eventStatuses: () => eventStatuses,
   field: () => field,
   fieldTypes: () => fieldTypes,
-  filterUnallowedActions: () => filterUnallowedActions,
   findActiveDrafts: () => findActiveDrafts,
   findAllFields: () => findAllFields,
   findLastAssignmentAction: () => findLastAssignmentAction,
@@ -174,18 +168,16 @@ __export(events_exports, {
   getActionReviewFields: () => getActionReviewFields,
   getAllAnnotationFields: () => getAllAnnotationFields,
   getAnnotationFromDrafts: () => getAnnotationFromDrafts,
-  getAssignedUserFromActions: () => getAssignedUserFromActions,
   getCurrentEventState: () => getCurrentEventState,
   getCurrentEventStateWithDrafts: () => getCurrentEventStateWithDrafts,
   getDeclaration: () => getDeclaration,
   getDeclarationFields: () => getDeclarationFields,
   getDeclarationPages: () => getDeclarationPages,
-  hasAnyOfScopes: () => hasAnyOfScopes,
+  getFieldValidationErrors: () => getFieldValidationErrors,
   isAddressFieldType: () => isAddressFieldType,
   isAdministrativeAreaFieldType: () => isAdministrativeAreaFieldType,
   isBulletListFieldType: () => isBulletListFieldType,
   isCheckboxFieldType: () => isCheckboxFieldType,
-  isConditionMet: () => isConditionMet,
   isCountryFieldType: () => isCountryFieldType,
   isDataFieldType: () => isDataFieldType,
   isDateFieldType: () => isDateFieldType,
@@ -223,10 +215,10 @@ __export(events_exports, {
   omitHiddenFields: () => omitHiddenFields,
   omitHiddenPaginatedFields: () => omitHiddenPaginatedFields,
   or: () => or,
-  runFieldValidations: () => runFieldValidations,
   user: () => user,
   validate: () => validate,
   validateFieldInput: () => validateFieldInput,
+  validateWorkqueueConfig: () => validateWorkqueueConfig,
   writeActions: () => writeActions
 });
 module.exports = __toCommonJS(events_exports);
@@ -236,12 +228,9 @@ var import_zod9 = require("zod");
 
 // ../commons/src/events/Conditional.ts
 var import_zod = require("zod");
-var import_zod_openapi = require("zod-openapi");
-(0, import_zod_openapi.extendZodWithOpenApi)(import_zod.z);
-var Conditional = import_zod.z.custom((val) => typeof val === "object" && val !== null).openapi({
-  description: "JSON schema conditional configuration",
-  ref: "Conditional"
-});
+var Conditional = import_zod.z.custom(
+  (val) => typeof val === "object" && val !== null
+);
 var ConditionalType = {
   SHOW: "SHOW",
   ENABLE: "ENABLE",
@@ -278,10 +267,7 @@ var FieldConditional = import_zod.z.discriminatedUnion("type", [
   EnableConditional,
   // Field output can be shown / hidden on the review page
   DisplayOnReviewConditional
-]).openapi({
-  description: "Field conditional configuration",
-  ref: "FieldConditional"
-});
+]);
 
 // ../commons/src/events/PageConfig.ts
 var import_zod6 = require("zod");
@@ -291,8 +277,6 @@ var import_zod5 = require("zod");
 
 // ../commons/src/events/TranslationConfig.ts
 var import_zod2 = require("zod");
-var import_zod_openapi2 = require("zod-openapi");
-(0, import_zod_openapi2.extendZodWithOpenApi)(import_zod2.z);
 var TranslationConfig = import_zod2.z.object({
   id: import_zod2.z.string().describe(
     "The identifier of the translation referred in translation CSV files"
@@ -301,14 +285,8 @@ 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",
@@ -459,7 +437,6 @@ 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([]),
@@ -595,8 +572,7 @@ var File = BaseField.extend({
       width: import_zod5.z.enum(["full", "auto"]).optional().describe(
         "Whether the file upload button should take the full width of the container or not"
       )
-    }).optional(),
-    fileName: TranslationConfig.optional()
+    }).optional()
   }).default({
     maxFileSize: DEFAULT_MAX_FILE_SIZE_BYTES
   })
@@ -683,7 +659,7 @@ var Address = BaseField.extend({
 var DataEntry = import_zod5.z.union([
   import_zod5.z.object({
     label: TranslationConfig,
-    value: TranslationConfig.or(import_zod5.z.string())
+    value: import_zod5.z.string()
   }),
   import_zod5.z.object({
     fieldId: import_zod5.z.string()
@@ -719,14 +695,10 @@ var FieldConfig = import_zod5.z.discriminatedUnion("type", [
   EmailField,
   FileUploadWithOptions,
   DataField
-]).openapi({
-  description: "Form field configuration",
-  ref: "FieldConfig"
-});
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+]);
 
 // ../commons/src/events/PageConfig.ts
-var import_zod_openapi4 = require("zod-openapi");
-(0, import_zod_openapi4.extendZodWithOpenApi)(import_zod6.z);
 var PageTypes = import_zod6.z.enum(["FORM", "VERIFICATION"]);
 var PageConfigBase = import_zod6.z.object({
   id: import_zod6.z.string().describe("Unique identifier for the page"),
@@ -738,9 +710,6 @@ var PageConfigBase = import_zod6.z.object({
 });
 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 }),
@@ -751,10 +720,7 @@ var VerificationActionConfig = import_zod6.z.object({
       body: TranslationConfig
     })
   })
-}).describe("Actions available on the verification page").openapi({
-  description: "Verification action configuration",
-  ref: "VerificationActionConfig"
-});
+}).describe("Actions available on the verification page");
 var VerificationPageConfig = FormPageConfig.extend({
   type: import_zod6.z.literal(PageTypes.enum.VERIFICATION),
   actions: VerificationActionConfig
@@ -854,8 +820,6 @@ var ActionFormConfig = import_zod8.z.object({
 var FormConfig = import_zod8.z.union([DeclarationFormConfig, ActionFormConfig]);
 
 // ../commons/src/events/ActionConfig.ts
-var import_zod_openapi5 = require("zod-openapi");
-(0, import_zod_openapi5.extendZodWithOpenApi)(import_zod9.z);
 var ActionConditional2 = import_zod9.z.discriminatedUnion("type", [
   /** If conditional is defined, the action is shown to the user only if the condition is met */
   ShowConditional,
@@ -933,24 +897,18 @@ var ApproveCorrectionConfig = ActionConfigBase.merge(
   })
 );
 var ActionConfig = import_zod9.z.discriminatedUnion("type", [
-  /*
-   * OpenAPI references are defined here so our generated OpenAPI spec knows to reuse the models
-   * and treat them as "models" instead of duplicating the data structure in each endpoint.
-   */
-  DeclareConfig.openapi({ ref: "DeclareActionConfig" }),
-  ValidateConfig.openapi({ ref: "ValidateActionConfig" }),
-  RejectDeclarationConfig.openapi({ ref: "RejectDeclarationActionConfig" }),
-  MarkedAsDuplicateConfig.openapi({ ref: "MarkedAsDuplicateActionConfig" }),
-  ArchiveConfig.openapi({ ref: "ArchiveActionConfig" }),
-  RegisterConfig.openapi({ ref: "RegisterActionConfig" }),
-  DeleteConfig.openapi({ ref: "DeleteActionConfig" }),
-  PrintCertificateActionConfig.openapi({
-    ref: "PrintCertificateActionConfig"
-  }),
-  RequestCorrectionConfig.openapi({ ref: "RequestCorrectionActionConfig" }),
-  RejectCorrectionConfig.openapi({ ref: "RejectCorrectionActionConfig" }),
-  ApproveCorrectionConfig.openapi({ ref: "ApproveCorrectionActionConfig" })
-]).openapi({ ref: "ActionConfig" });
+  DeclareConfig,
+  ValidateConfig,
+  RejectDeclarationConfig,
+  MarkedAsDuplicateConfig,
+  ArchiveConfig,
+  RegisterConfig,
+  DeleteConfig,
+  PrintCertificateActionConfig,
+  RequestCorrectionConfig,
+  RejectCorrectionConfig,
+  ApproveCorrectionConfig
+]);
 var DeclarationActionConfig = import_zod9.z.discriminatedUnion("type", [
   DeclareConfig,
   ValidateConfig,
@@ -994,12 +952,10 @@ var LanguageConfig = import_zod11.z.object({
 });
 
 // ../commons/src/events/EventConfig.ts
-var import_zod16 = require("zod");
+var import_zod20 = require("zod");
 
 // ../commons/src/events/DeduplicationConfig.ts
 var import_zod12 = require("zod");
-var import_zod_openapi6 = require("zod-openapi");
-(0, import_zod_openapi6.extendZodWithOpenApi)(import_zod12.z);
 var FieldReference = import_zod12.z.string();
 var Matcher = import_zod12.z.object({
   fieldId: import_zod12.z.string(),
@@ -1060,9 +1016,7 @@ var Clause = import_zod12.z.lazy(
     DateRangeMatcher,
     DateDistanceMatcher
   ])
-).openapi({
-  ref: "Clause"
-});
+);
 var DeduplicationConfig = import_zod12.z.object({
   id: import_zod12.z.string(),
   label: TranslationConfig,
@@ -1071,21 +1025,14 @@ var DeduplicationConfig = import_zod12.z.object({
 
 // ../commons/src/events/SummaryConfig.ts
 var import_zod13 = require("zod");
-var BaseField2 = import_zod13.z.object({
-  emptyValueMessage: TranslationConfig.optional(),
-  conditionals: import_zod13.z.array(ShowConditional).default([]).optional()
-});
-var ReferenceField = BaseField2.extend({
-  fieldId: import_zod13.z.string()
-}).describe("Field directly referencing event data with field id");
-var Field = BaseField2.extend({
+var Field = import_zod13.z.object({
   id: import_zod13.z.string().describe("Id of summary field"),
   value: TranslationConfig.describe(
     "Summary field value. Can utilise values defined in configuration and EventMetadata"
   ),
   label: TranslationConfig,
   emptyValueMessage: TranslationConfig.optional()
-}).describe("Custom configured field");
+});
 var Title = import_zod13.z.object({
   id: import_zod13.z.string(),
   label: TranslationConfig.describe("Title content"),
@@ -1093,18 +1040,116 @@ var Title = import_zod13.z.object({
 });
 var SummaryConfig = import_zod13.z.object({
   title: Title.describe("Title of summary view."),
-  fields: import_zod13.z.array(import_zod13.z.union([Field, ReferenceField])).describe("Fields rendered in summary view.")
+  fields: import_zod13.z.array(Field).describe("Fields rendered in summary view.")
 }).describe("Configuration for summary in event.");
 
-// ../commons/src/events/AdvancedSearchConfig.ts
+// ../commons/src/events/WorkqueueConfig.ts
+var import_zod15 = require("zod");
+
+// ../commons/src/events/EventMetadata.ts
 var import_zod14 = require("zod");
-var AdvancedSearchConfig = import_zod14.z.object({
+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({
   title: TranslationConfig.describe("Advanced search tab title"),
-  fields: import_zod14.z.array(
-    import_zod14.z.object({
-      fieldId: import_zod14.z.string(),
-      config: import_zod14.z.object({
-        type: import_zod14.z.enum(["FUZZY", "EXACT", "RANGE"]).describe("Determines the type of field")
+  fields: import_zod16.z.array(
+    import_zod16.z.object({
+      fieldId: import_zod16.z.string(),
+      config: import_zod16.z.object({
+        type: import_zod16.z.enum(["FUZZY", "EXACT", "RANGE"]).describe("Determines the type of field")
       }).optional().describe("Configuration options for the field")
     })
   ).optional().default([]).describe("Advanced search fields.")
@@ -1113,13 +1158,139 @@ var AdvancedSearchConfig = import_zod14.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_zod15 = require("zod");
+var import_zod19 = require("zod");
 function mapFieldTypeToZod(type, required) {
   let schema;
   switch (type) {
@@ -1172,7 +1343,7 @@ function createValidationSchema(config) {
   for (const field2 of config) {
     shape[field2.id] = mapFieldTypeToZod(field2.type, field2.required);
   }
-  return import_zod15.z.object(shape);
+  return import_zod19.z.object(shape);
 }
 function mapFieldTypeToMockValue(field2, i) {
   switch (field2.type) {
@@ -1346,23 +1517,12 @@ var ajv = new import_ajv.default({
 function validate(schema, data) {
   return ajv.validate(schema, data);
 }
-function isConditionMet(conditional, values) {
-  return validate(conditional, {
-    $form: values,
-    $now: (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" })
-  });
-}
 function getConditionalActionsForField(field2, values) {
   if (!field2.conditionals) {
     return [];
   }
   return field2.conditionals.filter((conditional) => validate(conditional.conditional, values)).map((conditional) => conditional.type);
 }
-function areConditionsMet(conditions, values) {
-  return conditions.every(
-    (condition) => isConditionMet(condition.conditional, values)
-  );
-}
 function isFieldConditionMet(field2, form, conditionalType) {
   const hasRule = (field2.conditionals ?? []).some(
     (conditional) => conditional.type === conditionalType
@@ -1485,11 +1645,6 @@ 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" })
@@ -1507,6 +1662,29 @@ function runFieldValidations({
     errors: [...fieldValidationResult, ...customValidationResults]
   };
 }
+function getFieldValidationErrors({
+  field: field2,
+  values
+}) {
+  if (!isFieldVisible(field2, values) || !isFieldEnabled(field2, values)) {
+    if (values[field2.id]) {
+      return {
+        errors: [
+          {
+            message: errorMessages.hiddenField
+          }
+        ]
+      };
+    }
+    return {
+      errors: []
+    };
+  }
+  return runFieldValidations({
+    field: field2,
+    values
+  });
+}
 
 // ../commons/src/uuid.ts
 var import_uuid = require("uuid");
@@ -1514,6 +1692,9 @@ 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) {
@@ -1581,11 +1762,26 @@ function getActionReview(configuration, actionType) {
 function getActionReviewFields(configuration, actionType) {
   return getActionReview(configuration, actionType).fields;
 }
+function validateWorkqueueConfig(workqueueConfigs) {
+  workqueueConfigs.map((workqueue) => {
+    const rootWorkqueue = Object.values(workqueues).find(
+      (wq) => wq.id === workqueue.id
+    );
+    if (!rootWorkqueue) {
+      throw new Error(
+        `Invalid workqueue configuration: workqueue not found with id: ${workqueue.id}`
+      );
+    }
+  });
+}
 function isPageVisible(page, formValues) {
   if (!page.conditional) {
     return true;
   }
-  return isConditionMet(page.conditional, formValues);
+  return validate(page.conditional, {
+    $form: formValues,
+    $now: (0, import_date_fns2.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" })
+  });
 }
 function omitHiddenFields(fields, values) {
   return (0, import_lodash.omitBy)(values, (_, fieldId) => {
@@ -1652,18 +1848,17 @@ function isWriteAction(actionType) {
 }
 
 // ../commons/src/events/EventConfig.ts
-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(
+var EventConfig = import_zod20.z.object({
+  id: import_zod20.z.string().describe(
     'A machine-readable identifier for the event, e.g. "birth" or "death"'
   ),
   summary: SummaryConfig,
   label: TranslationConfig,
-  actions: import_zod16.z.array(ActionConfig),
+  actions: import_zod20.z.array(ActionConfig),
   declaration: DeclarationFormConfig,
-  deduplication: import_zod16.z.array(DeduplicationConfig).optional().default([]),
-  advancedSearch: import_zod16.z.array(AdvancedSearchConfig).optional().default([])
+  workqueues: import_zod20.z.array(WorkqueueConfig),
+  deduplication: import_zod20.z.array(DeduplicationConfig).optional().default([]),
+  advancedSearch: import_zod20.z.array(AdvancedSearchConfig).optional().default([])
 }).superRefine((event2, ctx) => {
   const allFields = findAllFields(event2);
   const fieldIds = allFields.map((field2) => field2.id);
@@ -1689,8 +1884,6 @@ var EventConfig = import_zod16.z.object({
       path: ["advancedSearch"]
     });
   }
-}).openapi({
-  ref: "EventConfig"
 });
 
 // ../commons/src/events/EventConfigInput.ts
@@ -1699,312 +1892,269 @@ 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_zod20 = require("zod");
+var import_zod23 = require("zod");
 
 // ../commons/src/events/ActionDocument.ts
-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 import_zod21 = require("zod");
+var ActionUpdate = import_zod21.z.record(import_zod21.z.string(), FieldUpdateValue);
 var ActionStatus = {
   Requested: "Requested",
   Accepted: "Accepted",
   Rejected: "Rejected"
 };
-var ActionBase = import_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(),
+var ActionBase = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  createdAt: import_zod21.z.string().datetime(),
+  createdBy: import_zod21.z.string(),
   declaration: ActionUpdate,
   annotation: ActionUpdate.optional(),
-  createdAtLocation: import_zod18.z.string(),
-  status: import_zod18.z.enum([
+  createdAtLocation: import_zod21.z.string(),
+  status: import_zod21.z.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
   ]),
   // If the action is an asynchronous confirmation for another action, we will save the original action id here.
-  originalActionId: import_zod18.z.string().optional()
+  originalActionId: import_zod21.z.string().optional()
 });
 var AssignedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod18.z.string()
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.ASSIGN),
+    assignedTo: import_zod21.z.string()
   })
 );
 var UnassignedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.UNASSIGN),
-    assignedTo: import_zod18.z.literal(null)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.UNASSIGN),
+    assignedTo: import_zod21.z.literal(null).default(null)
   })
 );
 var RegisterAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.REGISTER),
-    registrationNumber: import_zod18.z.string().optional()
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.REGISTER),
+    registrationNumber: import_zod21.z.string().optional()
   })
 );
 var DeclareAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.DECLARE)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.DECLARE)
   })
 );
 var ValidateAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.VALIDATE)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.VALIDATE)
   })
 );
 var RejectAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.REJECT)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.REJECT)
   })
 );
 var MarkAsDuplicateAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.MARKED_AS_DUPLICATE)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.ARCHIVE)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.ARCHIVE)
   })
 );
 var CreatedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.CREATE)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.CREATE)
   })
 );
 var NotifiedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.NOTIFY)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.NOTIFY)
   })
 );
 var PrintCertificateAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.PRINT_CERTIFICATE)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RequestedCorrectionAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.REQUEST_CORRECTION)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.REQUEST_CORRECTION)
   })
 );
 var ApprovedCorrectionAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.APPROVE_CORRECTION),
-    requestId: import_zod18.z.string()
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.APPROVE_CORRECTION),
+    requestId: import_zod21.z.string()
   })
 );
 var RejectedCorrectionAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.REJECT_CORRECTION),
-    requestId: import_zod18.z.string()
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.REJECT_CORRECTION),
+    requestId: import_zod21.z.string()
   })
 );
 var ReadAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.READ)
+  import_zod21.z.object({
+    type: import_zod21.z.literal(ActionType.READ)
   })
 );
-var ActionDocument = import_zod18.z.discriminatedUnion("type", [
-  CreatedAction.openapi({ ref: "CreatedAction" }),
-  ValidateAction.openapi({ ref: "ValidateAction" }),
-  RejectAction.openapi({ ref: "RejectAction" }),
-  MarkAsDuplicateAction.openapi({ ref: "MarkAsDuplicateAction" }),
-  ArchiveAction.openapi({ ref: "ArchiveAction" }),
-  NotifiedAction.openapi({ ref: "NotifiedAction" }),
-  RegisterAction.openapi({ ref: "RegisterAction" }),
-  DeclareAction.openapi({ ref: "DeclareAction" }),
-  AssignedAction.openapi({ ref: "AssignedAction" }),
-  RequestedCorrectionAction.openapi({ ref: "RequestedCorrectionAction" }),
-  ApprovedCorrectionAction.openapi({ ref: "ApprovedCorrectionAction" }),
-  RejectedCorrectionAction.openapi({ ref: "RejectedCorrectionAction" }),
-  UnassignedAction.openapi({ ref: "UnassignedAction" }),
-  PrintCertificateAction.openapi({ ref: "PrintCertificateAction" }),
-  ReadAction.openapi({ ref: "ReadAction" })
-]).openapi({
-  ref: "ActionDocument"
-});
+var ActionDocument = import_zod21.z.discriminatedUnion("type", [
+  CreatedAction,
+  ValidateAction,
+  RejectAction,
+  MarkAsDuplicateAction,
+  ArchiveAction,
+  NotifiedAction,
+  RegisterAction,
+  DeclareAction,
+  AssignedAction,
+  RequestedCorrectionAction,
+  ApprovedCorrectionAction,
+  RejectedCorrectionAction,
+  UnassignedAction,
+  PrintCertificateAction,
+  ReadAction
+]);
 var AsyncRejectActionDocument = ActionBase.omit({
   declaration: true,
   annotation: true,
   createdBy: true,
-  createdByRole: true,
   createdAtLocation: true
 }).merge(
-  import_zod18.z.object({
-    type: import_zod18.z.enum(ConfirmableActions),
-    status: import_zod18.z.literal(ActionStatus.Rejected)
+  import_zod21.z.object({
+    type: import_zod21.z.enum(ConfirmableActions),
+    status: import_zod21.z.literal(ActionStatus.Rejected)
   })
 );
-var Action = import_zod18.z.union([ActionDocument, AsyncRejectActionDocument]);
-var ResolvedUser = import_zod18.z.object({
-  id: import_zod18.z.string(),
-  role: import_zod18.z.string(),
-  name: import_zod18.z.array(
-    import_zod18.z.object({
-      use: import_zod18.z.string(),
-      given: import_zod18.z.array(import_zod18.z.string()),
-      family: import_zod18.z.string()
+var Action = import_zod21.z.union([ActionDocument, AsyncRejectActionDocument]);
+var ResolvedUser = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  role: import_zod21.z.string(),
+  name: import_zod21.z.array(
+    import_zod21.z.object({
+      use: import_zod21.z.string(),
+      given: import_zod21.z.array(import_zod21.z.string()),
+      family: import_zod21.z.string()
     })
   )
 });
 
 // ../commons/src/events/ActionInput.ts
-var import_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(),
+var import_zod22 = require("zod");
+var BaseActionInput = import_zod22.z.object({
+  eventId: import_zod22.z.string(),
+  transactionId: import_zod22.z.string(),
   declaration: ActionUpdate.default({}),
   annotation: ActionUpdate.optional(),
-  originalActionId: import_zod19.z.string().optional(),
-  keepAssignment: import_zod19.z.boolean().optional()
+  originalActionId: import_zod22.z.string().optional(),
+  keepAssignment: import_zod22.z.boolean().optional()
 });
 var CreateActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.CREATE).default(ActionType.CREATE),
-    createdAtLocation: import_zod19.z.string()
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.CREATE).default(ActionType.CREATE),
+    createdAtLocation: import_zod22.z.string()
   })
 );
 var RegisterActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
-    registrationNumber: import_zod19.z.string().optional()
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
+    registrationNumber: import_zod22.z.string().optional()
   })
 );
 var ValidateActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
-    duplicates: import_zod19.z.array(import_zod19.z.string())
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
+    duplicates: import_zod22.z.array(import_zod22.z.string())
   })
 );
 var NotifyActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
   })
 );
 var DeclareActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
   })
 );
 var PrintCertificateActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RejectDeclarationActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REJECT).default(ActionType.REJECT)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.REJECT).default(ActionType.REJECT)
   })
 );
 var MarkedAsDuplicateActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE)
   })
 );
 var AssignActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
-    assignedTo: import_zod19.z.string()
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
+    assignedTo: import_zod22.z.string()
   })
 );
 var UnassignActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
-    assignedTo: import_zod19.z.literal(null).default(null)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
+    assignedTo: import_zod22.z.literal(null).default(null)
   })
 );
 var RequestCorrectionActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
   })
 );
 var RejectCorrectionActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    requestId: import_zod19.z.string(),
-    type: import_zod19.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
+  import_zod22.z.object({
+    requestId: import_zod22.z.string(),
+    type: import_zod22.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
   })
 );
 var ApproveCorrectionActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    requestId: import_zod19.z.string(),
-    type: import_zod19.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
+  import_zod22.z.object({
+    requestId: import_zod22.z.string(),
+    type: import_zod22.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
   })
 );
 var ReadActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.READ).default(ActionType.READ)
+  import_zod22.z.object({
+    type: import_zod22.z.literal(ActionType.READ).default(ActionType.READ)
   })
 );
-var DeleteActionInput = import_zod19.z.object({ eventId: import_zod19.z.string() });
-var ActionInput = import_zod19.z.discriminatedUnion("type", [
-  CreateActionInput.openapi({ ref: "CreateActionInput" }),
-  ValidateActionInput.openapi({ ref: "ValidateActionInput" }),
-  RegisterActionInput.openapi({ ref: "RegisterActionInput" }),
-  NotifyActionInput.openapi({ ref: "NotifyActionInput" }),
-  DeclareActionInput.openapi({ ref: "DeclareActionInput" }),
-  RejectDeclarationActionInput.openapi({
-    ref: "RejectDeclarationActionInput"
-  }),
-  MarkedAsDuplicateActionInput.openapi({
-    ref: "MarkedAsDuplicateActionInput"
-  }),
-  ArchiveActionInput.openapi({ ref: "ArchiveActionInput" }),
-  AssignActionInput.openapi({ ref: "AssignActionInput" }),
-  UnassignActionInput.openapi({ ref: "UnassignActionInput" }),
-  PrintCertificateActionInput.openapi({ ref: "PrintCertificateActionInput" }),
-  RequestCorrectionActionInput.openapi({
-    ref: "RequestCorrectionActionInput"
-  }),
-  RejectCorrectionActionInput.openapi({ ref: "RejectCorrectionActionInput" }),
-  ApproveCorrectionActionInput.openapi({
-    ref: "ApproveCorrectionActionInput"
-  }),
-  ReadActionInput.openapi({ ref: "ReadActionInput" })
-]).openapi({
-  ref: "ActionInput"
-});
+var ActionInput = import_zod22.z.discriminatedUnion("type", [
+  CreateActionInput,
+  ValidateActionInput,
+  RegisterActionInput,
+  NotifyActionInput,
+  DeclareActionInput,
+  RejectDeclarationActionInput,
+  MarkedAsDuplicateActionInput,
+  ArchiveActionInput,
+  AssignActionInput,
+  UnassignActionInput,
+  PrintCertificateActionInput,
+  RequestCorrectionActionInput,
+  RejectCorrectionActionInput,
+  ApproveCorrectionActionInput,
+  ReadActionInput
+]);
 
 // ../commons/src/events/Draft.ts
-var Draft = import_zod20.z.object({
-  id: import_zod20.z.string(),
-  eventId: import_zod20.z.string(),
-  transactionId: import_zod20.z.string(),
-  createdAt: import_zod20.z.string().datetime(),
+var Draft = import_zod23.z.object({
+  id: import_zod23.z.string(),
+  eventId: import_zod23.z.string(),
+  transactionId: import_zod23.z.string(),
+  createdAt: import_zod23.z.string().datetime(),
   action: ActionBase.extend({
     type: ActionTypes
   }).omit({ id: true })
@@ -2013,132 +2163,32 @@ 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_zod22 = require("zod");
-var EventInput = import_zod22.z.object({
-  transactionId: import_zod22.z.string(),
-  type: import_zod22.z.string()
+var import_zod24 = require("zod");
+var EventInput = import_zod24.z.object({
+  transactionId: import_zod24.z.string(),
+  type: import_zod24.z.string()
 });
 
 // ../commons/src/events/EventDocument.ts
-var import_zod23 = require("zod");
-var 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" });
+var import_zod25 = require("zod");
+var EventDocument = import_zod25.z.object({
+  id: import_zod25.z.string(),
+  type: import_zod25.z.string(),
+  createdAt: import_zod25.z.string().datetime(),
+  updatedAt: import_zod25.z.string().datetime(),
+  actions: import_zod25.z.array(Action),
+  trackingId: import_zod25.z.string()
+});
 
 // ../commons/src/events/EventIndex.ts
-var import_zod24 = require("zod");
+var import_zod26 = require("zod");
 var EventIndex = EventMetadata.extend({
-  declaration: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.any())
+  declaration: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any())
 });
-var EventSearchIndex = import_zod24.z.record(import_zod24.z.string(), import_zod24.z.any()).and(
-  import_zod24.z.object({
-    type: import_zod24.z.string()
+var EventSearchIndex = import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any()).and(
+  import_zod26.z.object({
+    type: import_zod26.z.string()
     // Ensures "type" (event-id) exists and is a string
   })
 );
@@ -2152,46 +2202,30 @@ function getStatusFromActions(actions) {
     return EventStatus.REJECTED;
   }
   return actions.reduce((status, action) => {
-    switch (action.type) {
-      case ActionType.CREATE:
-        return EventStatus.CREATED;
-      case ActionType.DECLARE:
-        return EventStatus.DECLARED;
-      case ActionType.VALIDATE:
-        return EventStatus.VALIDATED;
-      case ActionType.REGISTER:
-        return EventStatus.REGISTERED;
-      case ActionType.REJECT:
-        return EventStatus.REJECTED;
-      case ActionType.ARCHIVE:
-        return EventStatus.ARCHIVED;
-      case ActionType.NOTIFY:
-        return EventStatus.NOTIFIED;
-      case ActionType.PRINT_CERTIFICATE:
-      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;
+    if (action.type === ActionType.CREATE) {
+      return EventStatus.CREATED;
+    }
+    if (action.type === ActionType.DECLARE) {
+      return EventStatus.DECLARED;
     }
+    if (action.type === ActionType.VALIDATE) {
+      return EventStatus.VALIDATED;
+    }
+    if (action.type === ActionType.REGISTER) {
+      return EventStatus.REGISTERED;
+    }
+    if (action.type === ActionType.REJECT) {
+      return EventStatus.REJECTED;
+    }
+    if (action.type === ActionType.ARCHIVE) {
+      return EventStatus.ARCHIVED;
+    }
+    if (action.type === ActionType.NOTIFY) {
+      return EventStatus.NOTIFIED;
+    }
+    return status;
   }, EventStatus.CREATED);
 }
-function 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) {
@@ -2269,11 +2303,9 @@ function getCurrentEventState(event2) {
     modifiedAt: latestAction.createdAt,
     assignedTo: getAssignedUserFromActions(activeActions),
     updatedBy: latestAction.createdBy,
-    updatedAtLocation: event2.updatedAtLocation,
     declaration: aggregateActionDeclarations(activeActions),
     trackingId: event2.trackingId,
-    registrationNumber,
-    updatedByUserRole: getLastUpdatedByUserRoleFromActions(event2.actions)
+    registrationNumber
   });
 }
 function getCurrentEventStateWithDrafts(event2, drafts) {
@@ -2321,7 +2353,7 @@ function getAnnotationFromDrafts(drafts) {
 function getActionAnnotation({
   event: event2,
   actionType,
-  drafts = []
+  drafts
 }) {
   const activeActions = getAcceptedActions(event2);
   const action = activeActions.find(
@@ -2340,6 +2372,7 @@ function getActionAnnotation({
 
 // ../commons/src/events/defineConfig.ts
 var defineConfig = (config) => {
+  validateWorkqueueConfig(config.workqueues);
   const input = EventConfig.parse(config);
   return input;
 };
@@ -3616,6 +3649,28 @@ var tennisClubMembershipEvent = defineConfig({
       }
     ]
   },
+  workqueues: [
+    {
+      id: "all",
+      filters: []
+    },
+    {
+      id: "ready-for-review",
+      filters: [
+        {
+          status: ["DECLARED"]
+        }
+      ]
+    },
+    {
+      id: "registered",
+      filters: [
+        {
+          status: ["REGISTERED"]
+        }
+      ]
+    }
+  ],
   actions: [
     {
       type: ActionType.DECLARE,
@@ -3994,7 +4049,6 @@ var eventPayloadGenerator = {
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       transactionId: getUUID(),
       action: {
-        transactionId: getUUID(),
         type: actionType,
         status: ActionStatus.Accepted,
         declaration: {
@@ -4009,7 +4063,6 @@ var eventPayloadGenerator = {
         },
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         createdBy: "@todo",
-        createdByRole: "@todo",
         createdAtLocation: "@todo"
       }
     },
@@ -4171,14 +4224,12 @@ function generateActionDocument({
     // @TODO: This should be fixed in the future.
     createdAt: new Date(Date.now() - 500).toISOString(),
     createdBy: getUUID(),
-    createdByRole: "FIELD_AGENT",
     id: getUUID(),
     createdAtLocation: "TODO",
     declaration: generateActionDeclarationInput(configuration, action),
     annotation: {},
     ...defaults,
-    status: ActionStatus.Accepted,
-    transactionId: getUUID()
+    status: ActionStatus.Accepted
   };
   switch (action) {
     case ActionType.READ:
@@ -4236,8 +4287,7 @@ 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(),
-    updatedAtLocation: "TODO"
+    updatedAt: new Date(Date.now() - 1e3).toISOString()
   };
 }
 function generateEventDraftDocument(eventId, actionType = ActionType.DECLARE, declaration = {}) {
@@ -4266,11 +4316,9 @@ 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",
@@ -4316,189 +4364,3 @@ 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];
-}