@opencrvs/toolkit 1.8.0-rc.fa564ca → 1.8.0-rc.fa82472

package/dist/events/index.js

@@ -56,6 +56,7 @@ __export(events_exports, {
   ArchiveActionInput: () => ArchiveActionInput,
   AssignActionInput: () => AssignActionInput,
   AsyncRejectActionDocument: () => AsyncRejectActionDocument,
+  BIRTH_EVENT: () => BIRTH_EVENT,
   BaseActionInput: () => BaseActionInput,
   BearerTokenByUserType: () => BearerTokenByUserType,
   CONFIG_GET_ALLOWED_SCOPES: () => CONFIG_GET_ALLOWED_SCOPES,
@@ -101,9 +102,8 @@ __export(events_exports, {
   EventSearchIndex: () => EventSearchIndex,
   EventState: () => EventState,
   EventStatus: () => EventStatus,
-  EventStatusEnum: () => EventStatusEnum,
-  EventStatuses: () => EventStatuses,
   Exact: () => Exact,
+  ExactDate: () => ExactDate,
   ExactStatus: () => ExactStatus,
   FieldConditional: () => FieldConditional,
   FieldConfig: () => FieldConfig,
@@ -127,6 +127,8 @@ __export(events_exports, {
   LegalStatuses: () => LegalStatuses,
   MarkedAsDuplicateActionInput: () => MarkedAsDuplicateActionInput,
   MimeType: () => MimeType,
+  NameFieldUpdateValue: () => NameFieldUpdateValue,
+  NameFieldValue: () => NameFieldValue,
   NonEmptyTextValue: () => NonEmptyTextValue,
   Not: () => Not,
   NotifyActionInput: () => NotifyActionInput,
@@ -138,6 +140,7 @@ __export(events_exports, {
   QueryInput: () => QueryInput,
   QueryType: () => QueryType,
   Range: () => Range,
+  RangeDate: () => RangeDate,
   ReadActionInput: () => ReadActionInput,
   RegisterAction: () => RegisterAction,
   RegisterActionInput: () => RegisterActionInput,
@@ -154,8 +157,10 @@ __export(events_exports, {
   SelectOption: () => SelectOption,
   ShowConditional: () => ShowConditional,
   SignatureFieldValue: () => SignatureFieldValue,
+  StatusChangingActions: () => StatusChangingActions,
   SummaryConfig: () => SummaryConfig,
   TENNIS_CLUB_MEMBERSHIP: () => TENNIS_CLUB_MEMBERSHIP,
+  TestUserRole: () => TestUserRole,
   TextValue: () => TextValue,
   TranslationConfig: () => TranslationConfig,
   UnassignActionInput: () => UnassignActionInput,
@@ -165,6 +170,7 @@ __export(events_exports, {
   ValidateActionInput: () => ValidateActionInput,
   VerificationActionConfig: () => VerificationActionConfig,
   VerificationPageConfig: () => VerificationPageConfig,
+  WRITE_ACTION_SCOPES: () => WRITE_ACTION_SCOPES,
   Within: () => Within,
   WorkqueueActionsWithDefault: () => WorkqueueActionsWithDefault,
   WorkqueueColumn: () => WorkqueueColumn,
@@ -173,6 +179,7 @@ __export(events_exports, {
   WorkqueueColumnValue: () => WorkqueueColumnValue,
   WorkqueueConfig: () => WorkqueueConfig,
   WorkqueueConfigInput: () => WorkqueueConfigInput,
+  WorkqueueConfigWithoutQuery: () => WorkqueueConfigWithoutQuery,
   WorkqueueCountInput: () => WorkqueueCountInput,
   WorkqueueCountOutput: () => WorkqueueCountOutput,
   ZodDate: () => ZodDate,
@@ -185,9 +192,8 @@ __export(events_exports, {
   createEmptyDraft: () => createEmptyDraft,
   createEventConditionals: () => createEventConditionals,
   createFieldConditionals: () => createFieldConditionals,
-  createPseudoRandomNumberGenerator: () => createPseudoRandomNumberGenerator,
+  createPrng: () => createPrng,
   createValidationSchema: () => createValidationSchema,
-  dateOfEventColumn: () => dateOfEventColumn,
   deepDropNulls: () => deepDropNulls,
   deepMerge: () => deepMerge,
   defaultWorkqueueColumns: () => defaultWorkqueueColumns,
@@ -207,7 +213,6 @@ __export(events_exports, {
   eventMetadataLabelMap: () => eventMetadataLabelMap,
   eventPayloadGenerator: () => eventPayloadGenerator,
   eventQueryDataGenerator: () => eventQueryDataGenerator,
-  eventStatuses: () => eventStatuses,
   field: () => field,
   fieldTypes: () => fieldTypes,
   filterUnallowedActions: () => filterUnallowedActions,
@@ -220,6 +225,7 @@ __export(events_exports, {
   generateActionDocument: () => generateActionDocument,
   generateEventDocument: () => generateEventDocument,
   generateEventDraftDocument: () => generateEventDraftDocument,
+  generateRandomName: () => generateRandomName,
   generateRandomSignature: () => generateRandomSignature,
   generateTransactionId: () => generateTransactionId,
   generateTranslationConfig: () => generateTranslationConfig,
@@ -230,17 +236,23 @@ __export(events_exports, {
   getActionReview: () => getActionReview,
   getActionReviewFields: () => getActionReviewFields,
   getActionVerificationPageIds: () => getActionVerificationPageIds,
+  getAllUniqueFields: () => getAllUniqueFields,
   getAnnotationFromDrafts: () => getAnnotationFromDrafts,
   getAssignedUserFromActions: () => getAssignedUserFromActions,
   getAssignedUserSignatureFromActions: () => getAssignedUserSignatureFromActions,
   getCurrentEventState: () => getCurrentEventState,
   getCurrentEventStateWithDrafts: () => getCurrentEventStateWithDrafts,
   getDeclaration: () => getDeclaration,
+  getDeclarationFieldById: () => getDeclarationFieldById,
   getDeclarationFields: () => getDeclarationFields,
   getDeclarationPages: () => getDeclarationPages,
+  getEventConfigById: () => getEventConfigById,
   getMixedPath: () => getMixedPath,
+  getRandomDate: () => getRandomDate,
   getRandomDatetime: () => getRandomDatetime,
   getStatusFromActions: () => getStatusFromActions,
+  getUserActionsByStatus: () => getUserActionsByStatus,
+  getValidatorsForField: () => getValidatorsForField,
   getVisibleVerificationPageIds: () => getVisibleVerificationPageIds,
   hasAnyOfScopes: () => hasAnyOfScopes,
   isAddressFieldType: () => isAddressFieldType,
@@ -263,14 +275,17 @@ __export(events_exports, {
   isFieldVisible: () => isFieldVisible,
   isFileFieldType: () => isFileFieldType,
   isFileFieldWithOptionType: () => isFileFieldWithOptionType,
+  isIdFieldType: () => isIdFieldType,
   isLocationFieldType: () => isLocationFieldType,
   isMetaAction: () => isMetaAction,
+  isNameFieldType: () => isNameFieldType,
   isNonInteractiveFieldType: () => isNonInteractiveFieldType,
   isNumberFieldType: () => isNumberFieldType,
   isOfficeFieldType: () => isOfficeFieldType,
   isPageHeaderFieldType: () => isPageHeaderFieldType,
   isPageVisible: () => isPageVisible,
   isParagraphFieldType: () => isParagraphFieldType,
+  isPhoneFieldType: () => isPhoneFieldType,
   isRadioGroupFieldType: () => isRadioGroupFieldType,
   isSelectFieldType: () => isSelectFieldType,
   isSignatureFieldType: () => isSignatureFieldType,
@@ -280,6 +295,7 @@ __export(events_exports, {
   isUndeclaredDraft: () => isUndeclaredDraft,
   isVerificationPage: () => isVerificationPage,
   isWriteAction: () => isWriteAction,
+  mandatoryColumns: () => mandatoryColumns,
   mapFieldTypeToEmptyValue: () => mapFieldTypeToEmptyValue,
   mapFieldTypeToMockValue: () => mapFieldTypeToMockValue,
   mapFieldTypeToZod: () => mapFieldTypeToZod,
@@ -300,6 +316,7 @@ module.exports = __toCommonJS(events_exports);
 
 // ../commons/src/events/Constants.ts
 var TENNIS_CLUB_MEMBERSHIP = "tennis-club-membership";
+var BIRTH_EVENT = "v2-birth";
 
 // ../commons/src/events/ActionConfig.ts
 var import_zod9 = require("zod");
@@ -378,6 +395,9 @@ var TranslationConfig = import_zod2.z.object({
 
 // ../commons/src/events/FieldType.ts
 var FieldType = {
+  NAME: "NAME",
+  PHONE: "PHONE",
+  ID: "ID",
   ADDRESS: "ADDRESS",
   TEXT: "TEXT",
   NUMBER: "NUMBER",
@@ -454,6 +474,16 @@ var UrbanAddressUpdateValue = AdminStructure.extend({
   number: import_zod3.z.string().nullish(),
   zipCode: import_zod3.z.string().nullish()
 });
+var NameFieldValue = import_zod3.z.object({
+  firstname: import_zod3.z.string(),
+  surname: import_zod3.z.string(),
+  middlename: import_zod3.z.string().optional()
+});
+var NameFieldUpdateValue = import_zod3.z.object({
+  firstname: import_zod3.z.string(),
+  surname: import_zod3.z.string(),
+  middlename: import_zod3.z.string().nullish()
+}).or(import_zod3.z.null()).or(import_zod3.z.undefined());
 var RuralAddressUpdateValue = AdminStructure.extend({
   urbanOrRural: import_zod3.z.literal(GeographicalArea.RURAL),
   village: import_zod3.z.string().nullish()
@@ -515,7 +545,9 @@ var FieldValue = import_zod4.z.union([
   UrbanAddressValue,
   RuralAddressValue,
   DataFieldValue,
-  GenericAddressValue
+  GenericAddressValue,
+  NameFieldValue,
+  NameFieldUpdateValue
 ]);
 var FieldUpdateValue = import_zod4.z.union([
   TextValue,
@@ -528,7 +560,8 @@ var FieldUpdateValue = import_zod4.z.union([
   UrbanAddressUpdateValue,
   RuralAddressUpdateValue,
   DataFieldValue,
-  GenericAddressUpdateValue
+  GenericAddressUpdateValue,
+  NameFieldUpdateValue
 ]);
 
 // ../commons/src/events/FieldConfig.ts
@@ -705,6 +738,26 @@ var Select = BaseField.extend({
   defaultValue: TextValue.optional(),
   options: import_zod5.z.array(SelectOption).describe("A list of options")
 }).describe("Select input");
+var NameField = BaseField.extend({
+  type: import_zod5.z.literal(FieldType.NAME),
+  defaultValue: import_zod5.z.object({
+    firstname: NonEmptyTextValue,
+    surname: NonEmptyTextValue
+  }).optional(),
+  configuration: import_zod5.z.object({
+    maxLength: import_zod5.z.number().optional().describe("Maximum length of the text"),
+    prefix: TranslationConfig.optional(),
+    postfix: TranslationConfig.optional()
+  }).optional()
+}).describe("Name input field");
+var PhoneField = BaseField.extend({
+  defaultValue: NonEmptyTextValue.optional(),
+  type: import_zod5.z.literal(FieldType.PHONE)
+}).describe("Phone input field");
+var IdField = BaseField.extend({
+  defaultValue: NonEmptyTextValue.optional(),
+  type: import_zod5.z.literal(FieldType.ID)
+}).describe("ID input field");
 var Checkbox = BaseField.extend({
   type: import_zod5.z.literal(FieldType.CHECKBOX),
   defaultValue: CheckboxFieldValue.optional()
@@ -784,6 +837,9 @@ var FieldConfig = import_zod5.z.discriminatedUnion("type", [
   BulletList,
   PageHeader,
   Select,
+  NameField,
+  PhoneField,
+  IdField,
   Checkbox,
   File,
   Country,
@@ -917,6 +973,16 @@ var writeActions = ActionTypes.exclude([
   ActionType.ASSIGN,
   ActionType.UNASSIGN
 ]);
+var StatusChangingActions = ActionTypes.extract([
+  ActionType.CREATE,
+  ActionType.NOTIFY,
+  ActionType.DECLARE,
+  ActionType.VALIDATE,
+  ActionType.REGISTER,
+  ActionType.REJECT,
+  ActionType.ARCHIVE,
+  ActionType.PRINT_CERTIFICATE
+]);
 var workqueueActions = ActionTypes.exclude([
   ActionType.CREATE,
   ActionType.NOTIFY,
@@ -1097,7 +1163,7 @@ var LanguageConfig = import_zod11.z.object({
 });
 
 // ../commons/src/events/EventConfig.ts
-var import_zod18 = require("zod");
+var import_zod20 = require("zod");
 
 // ../commons/src/events/DeduplicationConfig.ts
 var import_zod12 = require("zod");
@@ -1189,8 +1255,7 @@ var Field = BaseField2.extend({
   value: TranslationConfig.describe(
     "Summary field value. Can utilise values defined in configuration and EventMetadata"
   ),
-  label: TranslationConfig,
-  emptyValueMessage: TranslationConfig.optional()
+  label: TranslationConfig
 }).describe("Custom configured field");
 var SummaryConfig = import_zod13.z.object({
   fields: import_zod13.z.array(import_zod13.z.union([Field, ReferenceField])).describe("Fields rendered in summary view.")
@@ -1206,35 +1271,35 @@ var BaseField3 = import_zod14.z.object({
   options: import_zod14.z.array(SelectOption).optional(),
   searchCriteriaLabelPrefix: TranslationConfig.optional().describe(
     `
-    This property determines whether to add a prefix (such as "Child" or "Applicant") before the field label 
+    This property determines whether to add a prefix (such as "Child" or "Applicant") before the field label
     when rendering search parameter labels \u2014 for example, in the search results page to indicate which fields were used in the search.
 
-    For example, a field config like { id: "child.firstname", label: { defaultMessage: "First Name(s)" } } would render as "First Name(s)" by default.
+    For example, a field config like { id: "child.name.firstname", label: { defaultMessage: "First Name(s)" } } would render as "First Name(s)" by default.
 
     A field config like { id: "mother.firstname", label: { defaultMessage: "First Name(s)" } } would also render as "First Name(s)" by default.
 
-    So, if both child.firstname and mother.firstname are used in a search, the resulting search criteria labels would be "First Name(s)", "First Name(s)", 
+    So, if both child.name.firstname and mother.firstname are used in a search, the resulting search criteria labels would be "First Name(s)", "First Name(s)",
     which is ambiguous.
 
-    Now, if we treat the field ID prefix as a label (e.g., "applicant.firstname" \u2192 "Applicant"), and the field label is already 
-    descriptive \u2014 like { id: "applicant.firstname", label: { defaultMessage: "Applicant's First Name" } } \u2014 then the resulting 
+    Now, if we treat the field ID prefix as a label (e.g., "applicant.firstname" \u2192 "Applicant"), and the field label is already
+    descriptive \u2014 like { id: "applicant.firstname", label: { defaultMessage: "Applicant's First Name" } } \u2014 then the resulting
     label would be "Applicant Applicant's First Name", which is redundant and awkward.
 
-    By setting searchCriteriaLabelPrefix to a translation config object, we can explicitly define the desired prefix 
+    By setting searchCriteriaLabelPrefix to a translation config object, we can explicitly define the desired prefix
     in the country-config > event.advancedSearch configuration. For example: field("child.dob", { searchCriteriaLabelPrefix: TranslationConfig }).
     `
   ),
   conditionals: import_zod14.z.array(FieldConditional).default([]).optional().describe(
     `
        In advanced search, we sometimes need to override the default field visibility conditionals.
-       
-       For example, Informant fields in the declaration form may have conditional logic 
-       that hides them based on other field values. Since the advanced search form reuses 
+
+       For example, Informant fields in the declaration form may have conditional logic
+       that hides them based on other field values. Since the advanced search form reuses
        the declaration form config, those same conditionals would apply by default.
-       
+
        However, in advanced search we often want to make all Informant fields searchable,
-       regardless of their original visibility logic. To do this, we explicitly set their 
-       'conditionals' to an empty array ('[]') in the search config. This ensures they 
+       regardless of their original visibility logic. To do this, we explicitly set their
+       'conditionals' to an empty array ('[]') in the search config. This ensures they
        are always rendered in the advanced search form.
       `
   )
@@ -1272,127 +1337,552 @@ var AdvancedSearchConfig = import_zod14.z.object({
 var import_lodash = require("lodash");
 
 // ../commons/src/events/ActionDocument.ts
-var import_zod16 = require("zod");
+var import_zod18 = require("zod");
 var import_zod_openapi7 = require("zod-openapi");
 
 // ../commons/src/events/CreatedAtLocation.ts
 var import_zod15 = require("zod");
 var CreatedAtLocation = import_zod15.z.string().nullish();
 
+// ../commons/src/authentication.ts
+var import_jwt_decode = __toESM(require("jwt-decode"));
+var import_zod17 = require("zod");
+
+// ../commons/src/scopes.ts
+var import_zod16 = require("zod");
+var SCOPES = {
+  // TODO v1.8 legacy scopes
+  NATLSYSADMIN: "natlsysadmin",
+  BYPASSRATELIMIT: "bypassratelimit",
+  DECLARE: "declare",
+  REGISTER: "register",
+  VALIDATE: "validate",
+  DEMO: "demo",
+  CERTIFY: "certify",
+  PERFORMANCE: "performance",
+  SYSADMIN: "sysadmin",
+  TEAMS: "teams",
+  CONFIG: "config",
+  // systems / integrations
+  WEBHOOK: "webhook",
+  NATIONALID: "nationalId",
+  NOTIFICATION_API: "notification-api",
+  RECORDSEARCH: "recordsearch",
+  /**
+   * @TODO This is a temporary scope to be used for V2 Events custom events declaration
+   */
+  RECORD_DECLARE: "record.declare-birth",
+  // declare
+  RECORD_IMPORT: "record.import",
+  // 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 LegacyScopes = import_zod16.z.union([
+  import_zod16.z.literal(SCOPES.NATLSYSADMIN),
+  import_zod16.z.literal(SCOPES.BYPASSRATELIMIT),
+  import_zod16.z.literal(SCOPES.DECLARE),
+  import_zod16.z.literal(SCOPES.REGISTER),
+  import_zod16.z.literal(SCOPES.VALIDATE),
+  import_zod16.z.literal(SCOPES.DEMO),
+  import_zod16.z.literal(SCOPES.CERTIFY),
+  import_zod16.z.literal(SCOPES.PERFORMANCE),
+  import_zod16.z.literal(SCOPES.SYSADMIN),
+  import_zod16.z.literal(SCOPES.TEAMS),
+  import_zod16.z.literal(SCOPES.CONFIG)
+]);
+var IntegrationScopes = import_zod16.z.union([
+  import_zod16.z.literal(SCOPES.WEBHOOK),
+  import_zod16.z.literal(SCOPES.NATIONALID),
+  import_zod16.z.literal(SCOPES.NOTIFICATION_API),
+  import_zod16.z.literal(SCOPES.RECORDSEARCH)
+]);
+var DeclareScopes = import_zod16.z.union([
+  import_zod16.z.literal(SCOPES.RECORD_DECLARE),
+  import_zod16.z.literal(SCOPES.RECORD_IMPORT),
+  import_zod16.z.literal(SCOPES.RECORD_DECLARE_BIRTH),
+  import_zod16.z.literal(SCOPES.RECORD_DECLARE_BIRTH_MY_JURISDICTION),
+  import_zod16.z.literal(SCOPES.RECORD_DECLARE_DEATH),
+  import_zod16.z.literal(SCOPES.RECORD_DECLARE_DEATH_MY_JURISDICTION),
+  import_zod16.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE),
+  import_zod16.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE_MY_JURISDICTION),
+  import_zod16.z.literal(SCOPES.RECORD_SUBMIT_INCOMPLETE),
+  import_zod16.z.literal(SCOPES.RECORD_SUBMIT_FOR_REVIEW)
+]);
+var UnassignScope = import_zod16.z.literal(SCOPES.RECORD_UNASSIGN_OTHERS);
+var ValidateScopes = import_zod16.z.union([
+  import_zod16.z.literal(SCOPES.RECORD_SUBMIT_FOR_APPROVAL),
+  import_zod16.z.literal(SCOPES.RECORD_SUBMIT_FOR_UPDATES),
+  import_zod16.z.literal(SCOPES.RECORD_DECLARATION_EDIT),
+  import_zod16.z.literal(SCOPES.RECORD_REVIEW_DUPLICATES),
+  import_zod16.z.literal(SCOPES.RECORD_DECLARATION_ARCHIVE),
+  import_zod16.z.literal(SCOPES.RECORD_DECLARATION_REINSTATE)
+]);
+var RegisterScope = import_zod16.z.literal(SCOPES.RECORD_REGISTER);
+var CertifyScopes = import_zod16.z.union([
+  import_zod16.z.literal(SCOPES.RECORD_EXPORT_RECORDS),
+  import_zod16.z.literal(SCOPES.RECORD_DECLARATION_PRINT),
+  import_zod16.z.literal(SCOPES.RECORD_PRINT_RECORDS_SUPPORTING_DOCUMENTS),
+  import_zod16.z.literal(SCOPES.RECORD_REGISTRATION_PRINT),
+  import_zod16.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
+  import_zod16.z.literal(SCOPES.RECORD_PRINT_CERTIFIED_COPIES),
+  import_zod16.z.literal(SCOPES.RECORD_BULK_PRINT_CERTIFIED_COPIES),
+  import_zod16.z.literal(SCOPES.RECORD_REGISTRATION_VERIFY_CERTIFIED_COPIES)
+]);
+var CorrectionScopes = import_zod16.z.union([
+  import_zod16.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_CORRECTION),
+  import_zod16.z.literal(SCOPES.RECORD_REGISTRATION_CORRECT),
+  import_zod16.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_REVOCATION),
+  import_zod16.z.literal(SCOPES.RECORD_REGISTRATION_REVOKE),
+  import_zod16.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_REINSTATEMENT),
+  import_zod16.z.literal(SCOPES.RECORD_REGISTRATION_REINSTATE),
+  import_zod16.z.literal(SCOPES.RECORD_CONFIRM_REGISTRATION),
+  import_zod16.z.literal(SCOPES.RECORD_REJECT_REGISTRATION)
+]);
+var SearchScopes = import_zod16.z.union([
+  import_zod16.z.literal(SCOPES.SEARCH_BIRTH_MY_JURISDICTION),
+  import_zod16.z.literal(SCOPES.SEARCH_BIRTH),
+  import_zod16.z.literal(SCOPES.SEARCH_DEATH_MY_JURISDICTION),
+  import_zod16.z.literal(SCOPES.SEARCH_DEATH),
+  import_zod16.z.literal(SCOPES.SEARCH_MARRIAGE_MY_JURISDICTION),
+  import_zod16.z.literal(SCOPES.SEARCH_MARRIAGE)
+]);
+var AuditScopes = import_zod16.z.union([
+  import_zod16.z.literal(SCOPES.RECORD_READ),
+  import_zod16.z.literal(SCOPES.RECORD_READ_AUDIT),
+  import_zod16.z.literal(SCOPES.RECORD_READ_COMMENTS),
+  import_zod16.z.literal(SCOPES.RECORD_CREATE_COMMENTS)
+]);
+var ProfileScopes = import_zod16.z.union([
+  import_zod16.z.literal(SCOPES.PROFILE_UPDATE),
+  import_zod16.z.literal(SCOPES.PROFILE_ELECTRONIC_SIGNATURE)
+]);
+var PerformanceScopes = import_zod16.z.union([
+  import_zod16.z.literal(SCOPES.PERFORMANCE_READ),
+  import_zod16.z.literal(SCOPES.PERFORMANCE_READ_DASHBOARDS),
+  import_zod16.z.literal(SCOPES.PERFORMANCE_EXPORT_VITAL_STATISTICS)
+]);
+var OrganisationScopes = import_zod16.z.union([
+  import_zod16.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS),
+  import_zod16.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_OFFICE),
+  import_zod16.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_JURISDICTION)
+]);
+var UserScopes = import_zod16.z.union([
+  import_zod16.z.literal(SCOPES.USER_READ),
+  import_zod16.z.literal(SCOPES.USER_READ_MY_OFFICE),
+  import_zod16.z.literal(SCOPES.USER_READ_MY_JURISDICTION),
+  import_zod16.z.literal(SCOPES.USER_READ_ONLY_MY_AUDIT),
+  import_zod16.z.literal(SCOPES.USER_CREATE),
+  import_zod16.z.literal(SCOPES.USER_CREATE_MY_JURISDICTION),
+  import_zod16.z.literal(SCOPES.USER_UPDATE),
+  import_zod16.z.literal(SCOPES.USER_UPDATE_MY_JURISDICTION)
+]);
+var ConfigScope = import_zod16.z.literal(SCOPES.CONFIG_UPDATE_ALL);
+var DataSeedingScope = import_zod16.z.literal(SCOPES.USER_DATA_SEEDING);
+var LiteralScopes = import_zod16.z.union([
+  LegacyScopes,
+  IntegrationScopes,
+  UnassignScope,
+  DeclareScopes,
+  ValidateScopes,
+  RegisterScope,
+  CertifyScopes,
+  CorrectionScopes,
+  SearchScopes,
+  AuditScopes,
+  ProfileScopes,
+  PerformanceScopes,
+  OrganisationScopes,
+  UserScopes,
+  ConfigScope,
+  DataSeedingScope
+]);
+var rawConfigurableScopeRegex = /^([a-zA-Z\.]+)\[((?:\w+=[\w.-]+(?:\|[\w.-]+)*)(?:,[\w]+=[\w.-]+(?:\|[\w.-]+)*)*)\]$/;
+var rawConfigurableScope = import_zod16.z.string().regex(rawConfigurableScopeRegex);
+var CreateUserScope = import_zod16.z.object({
+  type: import_zod16.z.literal("user.create"),
+  options: import_zod16.z.object({
+    role: import_zod16.z.array(import_zod16.z.string())
+  })
+});
+var EditUserScope = import_zod16.z.object({
+  type: import_zod16.z.literal("user.edit"),
+  options: import_zod16.z.object({
+    role: import_zod16.z.array(import_zod16.z.string())
+  })
+});
+var WorkqueueScope = import_zod16.z.object({
+  type: import_zod16.z.literal("workqueue"),
+  options: import_zod16.z.object({
+    id: import_zod16.z.array(import_zod16.z.string())
+  })
+});
+var NotifyRecordScope = import_zod16.z.object({
+  type: import_zod16.z.literal("record.notify"),
+  options: import_zod16.z.object({
+    event: import_zod16.z.array(import_zod16.z.string())
+  })
+});
+var ConfigurableScopes = import_zod16.z.discriminatedUnion("type", [
+  CreateUserScope,
+  EditUserScope,
+  WorkqueueScope,
+  NotifyRecordScope
+]);
+var scopes = Object.values(SCOPES);
+var ActionScopes = import_zod16.z.union([
+  DeclareScopes,
+  ValidateScopes,
+  RegisterScope,
+  CertifyScopes,
+  CorrectionScopes
+]);
+
+// ../commons/src/authentication.ts
+var DEFAULT_ROLES_DEFINITION = [
+  {
+    id: "FIELD_AGENT",
+    label: {
+      defaultMessage: "Field Agent",
+      description: "Name for user role Field Agent",
+      id: "userRole.fieldAgent"
+    },
+    scopes: [
+      // new scopes
+      SCOPES.RECORD_DECLARE_BIRTH,
+      SCOPES.RECORD_DECLARE_DEATH,
+      SCOPES.RECORD_DECLARE_MARRIAGE,
+      SCOPES.RECORD_SUBMIT_INCOMPLETE,
+      SCOPES.RECORD_SUBMIT_FOR_REVIEW,
+      SCOPES.SEARCH_BIRTH,
+      SCOPES.SEARCH_DEATH,
+      SCOPES.SEARCH_MARRIAGE
+    ]
+  },
+  {
+    id: "REGISTRATION_AGENT",
+    label: {
+      defaultMessage: "Registration Agent",
+      description: "Name for user role Registration Agent",
+      id: "userRole.registrationAgent"
+    },
+    scopes: [
+      SCOPES.PERFORMANCE,
+      SCOPES.CERTIFY,
+      SCOPES.RECORD_DECLARE_BIRTH,
+      SCOPES.RECORD_DECLARE_DEATH,
+      SCOPES.RECORD_DECLARE_MARRIAGE,
+      SCOPES.RECORD_SUBMIT_FOR_APPROVAL,
+      SCOPES.RECORD_SUBMIT_FOR_UPDATES,
+      SCOPES.RECORD_DECLARATION_ARCHIVE,
+      SCOPES.RECORD_DECLARATION_REINSTATE,
+      SCOPES.RECORD_REGISTRATION_REQUEST_CORRECTION,
+      SCOPES.RECORD_REGISTRATION_PRINT,
+      SCOPES.RECORD_PRINT_RECORDS_SUPPORTING_DOCUMENTS,
+      SCOPES.RECORD_EXPORT_RECORDS,
+      SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES,
+      SCOPES.RECORD_REGISTRATION_VERIFY_CERTIFIED_COPIES,
+      SCOPES.RECORD_CREATE_COMMENTS,
+      SCOPES.PERFORMANCE_READ,
+      SCOPES.PERFORMANCE_READ_DASHBOARDS,
+      SCOPES.ORGANISATION_READ_LOCATIONS,
+      SCOPES.ORGANISATION_READ_LOCATIONS_MY_OFFICE,
+      SCOPES.SEARCH_BIRTH,
+      SCOPES.SEARCH_DEATH,
+      SCOPES.SEARCH_MARRIAGE
+    ]
+  },
+  {
+    id: "LOCAL_REGISTRAR",
+    label: {
+      defaultMessage: "Local Registrar",
+      description: "Name for user role Local Registrar",
+      id: "userRole.localRegistrar"
+    },
+    scopes: [
+      SCOPES.PERFORMANCE,
+      SCOPES.CERTIFY,
+      SCOPES.RECORD_DECLARE_BIRTH,
+      SCOPES.RECORD_DECLARE_DEATH,
+      SCOPES.RECORD_DECLARE_MARRIAGE,
+      SCOPES.RECORD_SUBMIT_FOR_UPDATES,
+      SCOPES.RECORD_REVIEW_DUPLICATES,
+      SCOPES.RECORD_DECLARATION_ARCHIVE,
+      SCOPES.RECORD_DECLARATION_REINSTATE,
+      SCOPES.RECORD_REGISTER,
+      SCOPES.RECORD_REGISTRATION_CORRECT,
+      SCOPES.RECORD_REGISTRATION_PRINT,
+      SCOPES.RECORD_PRINT_RECORDS_SUPPORTING_DOCUMENTS,
+      SCOPES.RECORD_EXPORT_RECORDS,
+      SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES,
+      SCOPES.RECORD_REGISTRATION_VERIFY_CERTIFIED_COPIES,
+      SCOPES.RECORD_CREATE_COMMENTS,
+      SCOPES.PERFORMANCE_READ,
+      SCOPES.PERFORMANCE_READ_DASHBOARDS,
+      SCOPES.ORGANISATION_READ_LOCATIONS,
+      SCOPES.PROFILE_ELECTRONIC_SIGNATURE,
+      SCOPES.ORGANISATION_READ_LOCATIONS_MY_OFFICE,
+      SCOPES.SEARCH_BIRTH,
+      SCOPES.SEARCH_DEATH,
+      SCOPES.SEARCH_MARRIAGE
+    ]
+  },
+  {
+    id: "LOCAL_SYSTEM_ADMIN",
+    label: {
+      defaultMessage: "Local System Admin",
+      description: "Name for user role Local System Admin",
+      id: "userRole.localSystemAdmin"
+    },
+    scopes: [
+      SCOPES.SYSADMIN,
+      SCOPES.USER_READ_MY_OFFICE,
+      SCOPES.USER_CREATE_MY_JURISDICTION,
+      SCOPES.USER_UPDATE_MY_JURISDICTION,
+      SCOPES.ORGANISATION_READ_LOCATIONS,
+      SCOPES.PERFORMANCE_READ,
+      SCOPES.PERFORMANCE_READ_DASHBOARDS,
+      SCOPES.PERFORMANCE_EXPORT_VITAL_STATISTICS
+      // 'organisation.read-users' ?
+    ]
+  },
+  {
+    id: "NATIONAL_SYSTEM_ADMIN",
+    label: {
+      defaultMessage: "National System Admin",
+      description: "Name for user role National System Admin",
+      id: "userRole.nationalSystemAdmin"
+    },
+    scopes: [
+      SCOPES.SYSADMIN,
+      SCOPES.NATLSYSADMIN,
+      SCOPES.USER_CREATE,
+      SCOPES.USER_READ,
+      SCOPES.USER_UPDATE,
+      SCOPES.ORGANISATION_READ_LOCATIONS,
+      SCOPES.PERFORMANCE_READ,
+      SCOPES.PERFORMANCE_READ_DASHBOARDS,
+      SCOPES.PERFORMANCE_EXPORT_VITAL_STATISTICS
+      // 'organisation.read-users' ?
+    ]
+  },
+  {
+    id: "PERFORMANCE_MANAGER",
+    label: {
+      defaultMessage: "Performance Manager",
+      description: "Name for user role Performance Manager",
+      id: "userRole.performanceManager"
+    },
+    scopes: [
+      SCOPES.PERFORMANCE,
+      SCOPES.PERFORMANCE_READ,
+      SCOPES.PERFORMANCE_READ_DASHBOARDS,
+      SCOPES.PERFORMANCE_EXPORT_VITAL_STATISTICS
+    ]
+  }
+];
+var TokenUserType = import_zod17.z.enum(["user", "system"]);
+var TokenWithBearer = import_zod17.z.string().regex(/^Bearer\s/);
+
 // ../commons/src/events/ActionDocument.ts
-(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod16.z);
-var ActionUpdate = import_zod16.z.record(import_zod16.z.string(), FieldUpdateValue);
-var EventState = import_zod16.z.record(import_zod16.z.string(), FieldValue);
+(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod18.z);
+var ActionUpdate = import_zod18.z.record(import_zod18.z.string(), FieldUpdateValue);
+var EventState = import_zod18.z.record(import_zod18.z.string(), FieldValue);
 var ActionStatus = {
   Requested: "Requested",
   Accepted: "Accepted",
   Rejected: "Rejected"
 };
-var ActionBase = import_zod16.z.object({
-  id: import_zod16.z.string(),
-  transactionId: import_zod16.z.string(),
-  createdAt: import_zod16.z.string().datetime(),
-  createdBy: import_zod16.z.string(),
-  createdByRole: import_zod16.z.string(),
-  createdBySignature: import_zod16.z.string().nullish().describe("Reference to signature of the user who created the action"),
+var ActionBase = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  transactionId: import_zod18.z.string(),
+  createdByUserType: TokenUserType,
+  createdAt: import_zod18.z.string().datetime(),
+  createdBy: import_zod18.z.string(),
+  createdByRole: import_zod18.z.string(),
+  createdBySignature: import_zod18.z.string().nullish().describe("Reference to signature of the user who created the action"),
   createdAtLocation: CreatedAtLocation,
   declaration: ActionUpdate,
   annotation: ActionUpdate.optional(),
-  status: import_zod16.z.enum([
+  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_zod16.z.string().optional()
+  originalActionId: import_zod18.z.string().optional()
 });
 var AssignedAction = ActionBase.merge(
-  import_zod16.z.object({
-    type: import_zod16.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod16.z.string()
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.ASSIGN),
+    assignedTo: import_zod18.z.string()
   })
 );
 var UnassignedAction = ActionBase.merge(
-  import_zod16.z.object({
-    type: import_zod16.z.literal(ActionType.UNASSIGN),
-    assignedTo: import_zod16.z.literal(null)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.UNASSIGN),
+    assignedTo: import_zod18.z.literal(null)
   })
 );
 var RegisterAction = ActionBase.merge(
-  import_zod16.z.object({
-    type: import_zod16.z.literal(ActionType.REGISTER),
-    registrationNumber: import_zod16.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_zod16.z.object({
-    type: import_zod16.z.literal(ActionType.DECLARE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.DECLARE)
   })
 );
 var ValidateAction = ActionBase.merge(
-  import_zod16.z.object({
-    type: import_zod16.z.literal(ActionType.VALIDATE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.VALIDATE)
   })
 );
-var RejectionReason = import_zod16.z.object({
-  message: import_zod16.z.string().min(1, { message: "Message cannot be empty" }).describe("Message describing reason for rejection or archiving"),
-  isDuplicate: import_zod16.z.boolean().optional().describe("If a declaration is duplicated")
+var RejectionReason = import_zod18.z.object({
+  message: import_zod18.z.string().min(1, { message: "Message cannot be empty" }).describe("Message describing reason for rejection or archiving"),
+  isDuplicate: import_zod18.z.boolean().optional().describe("If a declaration is duplicated")
 });
 var RejectAction = ActionBase.merge(
-  import_zod16.z.object({
-    type: import_zod16.z.literal(ActionType.REJECT),
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.REJECT),
     reason: RejectionReason
   })
 );
 var MarkAsDuplicateAction = ActionBase.merge(
-  import_zod16.z.object({
-    type: import_zod16.z.literal(ActionType.MARKED_AS_DUPLICATE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveAction = ActionBase.merge(
-  import_zod16.z.object({
-    type: import_zod16.z.literal(ActionType.ARCHIVE),
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.ARCHIVE),
     reason: RejectionReason
   })
 );
 var CreatedAction = ActionBase.merge(
-  import_zod16.z.object({
-    type: import_zod16.z.literal(ActionType.CREATE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.CREATE)
   })
 );
 var NotifiedAction = ActionBase.merge(
-  import_zod16.z.object({
-    type: import_zod16.z.literal(ActionType.NOTIFY)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.NOTIFY)
   })
 );
 var PrintCertificateAction = ActionBase.merge(
-  import_zod16.z.object({
-    type: import_zod16.z.literal(ActionType.PRINT_CERTIFICATE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RequestedCorrectionAction = ActionBase.merge(
-  import_zod16.z.object({
-    type: import_zod16.z.literal(ActionType.REQUEST_CORRECTION)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.REQUEST_CORRECTION)
   })
 );
 var ApprovedCorrectionAction = ActionBase.merge(
-  import_zod16.z.object({
-    type: import_zod16.z.literal(ActionType.APPROVE_CORRECTION),
-    requestId: import_zod16.z.string()
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.APPROVE_CORRECTION),
+    requestId: import_zod18.z.string()
   })
 );
 var RejectedCorrectionAction = ActionBase.merge(
-  import_zod16.z.object({
-    type: import_zod16.z.literal(ActionType.REJECT_CORRECTION),
-    requestId: import_zod16.z.string()
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.REJECT_CORRECTION),
+    requestId: import_zod18.z.string()
   })
 );
 var ReadAction = ActionBase.merge(
-  import_zod16.z.object({
-    type: import_zod16.z.literal(ActionType.READ)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.READ)
   })
 );
-var ActionDocument = import_zod16.z.discriminatedUnion("type", [
+var ActionDocument = import_zod18.z.discriminatedUnion("type", [
   CreatedAction.openapi({ ref: "CreatedAction" }),
   ValidateAction.openapi({ ref: "ValidateAction" }),
   RejectAction.openapi({ ref: "RejectAction" }),
@@ -1415,20 +1905,20 @@ var AsyncRejectActionDocument = ActionBase.omit({
   declaration: true,
   annotation: true
 }).merge(
-  import_zod16.z.object({
-    type: import_zod16.z.enum(ConfirmableActions),
-    status: import_zod16.z.literal(ActionStatus.Rejected)
+  import_zod18.z.object({
+    type: import_zod18.z.enum(ConfirmableActions),
+    status: import_zod18.z.literal(ActionStatus.Rejected)
   })
 );
-var Action = import_zod16.z.union([ActionDocument, AsyncRejectActionDocument]);
-var ResolvedUser = import_zod16.z.object({
-  id: import_zod16.z.string(),
-  role: import_zod16.z.string(),
-  name: import_zod16.z.array(
-    import_zod16.z.object({
-      use: import_zod16.z.string(),
-      given: import_zod16.z.array(import_zod16.z.string()),
-      family: import_zod16.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()
     })
   )
 });
@@ -1439,7 +1929,7 @@ var import_ajv_formats = __toESM(require("ajv-formats"));
 var import_date_fns = require("date-fns");
 
 // ../commons/src/events/FieldTypeMapping.ts
-var import_zod17 = require("zod");
+var import_zod19 = require("zod");
 function mapFieldTypeToZod(type, required) {
   let schema;
   switch (type) {
@@ -1465,6 +1955,8 @@ function mapFieldTypeToZod(type, required) {
     case FieldType.ADMINISTRATIVE_AREA:
     case FieldType.FACILITY:
     case FieldType.OFFICE:
+    case FieldType.PHONE:
+    case FieldType.ID:
       schema = required ? NonEmptyTextValue : TextValue;
       break;
     case FieldType.NUMBER:
@@ -1486,6 +1978,9 @@ function mapFieldTypeToZod(type, required) {
     case FieldType.DATA:
       schema = DataFieldValue;
       break;
+    case FieldType.NAME:
+      schema = required ? NameFieldValue : NameFieldUpdateValue;
+      break;
   }
   return required ? schema : schema.nullish();
 }
@@ -1494,59 +1989,7 @@ function createValidationSchema(config) {
   for (const field2 of config) {
     shape[field2.id] = mapFieldTypeToZod(field2.type, field2.required);
   }
-  return import_zod17.z.object(shape);
-}
-function mapFieldTypeToMockValue(field2, i) {
-  switch (field2.type) {
-    case FieldType.DIVIDER:
-    case FieldType.TEXT:
-    case FieldType.TEXTAREA:
-    case FieldType.BULLET_LIST:
-    case FieldType.PAGE_HEADER:
-    case FieldType.LOCATION:
-    case FieldType.SELECT:
-    case FieldType.COUNTRY:
-    case FieldType.RADIO_GROUP:
-    case FieldType.PARAGRAPH:
-    case FieldType.ADMINISTRATIVE_AREA:
-    case FieldType.FACILITY:
-    case FieldType.OFFICE:
-      return `${field2.id}-${field2.type}-${i}`;
-    case FieldType.NUMBER:
-      return 19;
-    case FieldType.EMAIL:
-      return "test@opencrvs.org";
-    case FieldType.ADDRESS:
-      return {
-        country: "FAR",
-        addressType: AddressType.DOMESTIC,
-        province: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
-        district: "5ef450bc-712d-48ad-93f3-8da0fa453baa",
-        urbanOrRural: "URBAN",
-        town: "Example Town",
-        residentialArea: "Example Residential Area",
-        street: "Example Street",
-        number: "55",
-        zipCode: "123456"
-      };
-    case FieldType.DATE:
-      return "2021-01-01";
-    case FieldType.DATE_RANGE:
-      return ["2021-01-01", "2021-01-02"];
-    case FieldType.CHECKBOX:
-      return true;
-    case FieldType.SIGNATURE:
-    case FieldType.FILE:
-      return {
-        filename: "4f095fc4-4312-4de2-aa38-86dcc0f71044.png",
-        originalFilename: "abcd.png",
-        type: "image/png"
-      };
-    case FieldType.FILE_WITH_OPTIONS:
-      return null;
-    case FieldType.DATA:
-      return {};
-  }
+  return import_zod19.z.object(shape);
 }
 function mapFieldTypeToEmptyValue(field2) {
   switch (field2.type) {
@@ -1569,6 +2012,9 @@ function mapFieldTypeToEmptyValue(field2) {
     case FieldType.CHECKBOX:
     case FieldType.DATE_RANGE:
     case FieldType.DATA:
+    case FieldType.NAME:
+    case FieldType.PHONE:
+    case FieldType.ID:
       return null;
     case FieldType.ADDRESS:
       return {
@@ -1613,7 +2059,16 @@ var isTextFieldType = (field2) => {
 var isNumberFieldType = (field2) => {
   return field2.config.type === FieldType.NUMBER;
 };
-var isTextAreaFieldType = (field2) => {
+var isNameFieldType = (field2) => {
+  return field2.config.type === FieldType.NAME;
+};
+var isPhoneFieldType = (field2) => {
+  return field2.config.type === FieldType.PHONE;
+};
+var isIdFieldType = (field2) => {
+  return field2.config.type === FieldType.ID;
+};
+var isTextAreaFieldType = (field2) => {
   return field2.config.type === FieldType.TEXTAREA;
 };
 var isSignatureFieldType = (field2) => {
@@ -1747,6 +2202,11 @@ var errorMessages = {
     defaultMessage: "Invalid input",
     description: "Error message when generic field is invalid",
     id: "v2.error.invalid"
+  },
+  unexpectedField: {
+    defaultMessage: "Unexpected field",
+    description: "Error message when field is not expected",
+    id: "v2.error.unexpectedField"
   }
 };
 function createIntlError(message) {
@@ -1842,6 +2302,45 @@ function runFieldValidations({
     errors: [...fieldValidationResult, ...customValidationResults]
   };
 }
+function getValidatorsForField(fieldId, validations) {
+  return validations.map(({ validator, message }) => {
+    const jsonSchema = validator;
+    const $form = jsonSchema.properties.$form;
+    if ($form.properties?.[fieldId]?.type === "object") {
+      return {
+        message,
+        validator: {
+          ...jsonSchema,
+          properties: {
+            $form: {
+              type: "object",
+              properties: $form.properties?.[fieldId]?.properties || {},
+              required: $form.properties?.[fieldId]?.required || []
+            }
+          }
+        }
+      };
+    }
+    if (!$form.properties?.[fieldId]) {
+      return null;
+    }
+    return {
+      message,
+      validator: {
+        ...jsonSchema,
+        properties: {
+          $form: {
+            type: "object",
+            properties: {
+              [fieldId]: $form.properties?.[fieldId]
+            },
+            required: $form.required?.includes(fieldId) ? [fieldId] : []
+          }
+        }
+      }
+    };
+  }).filter((x) => x !== null);
+}
 
 // ../commons/src/uuid.ts
 var import_uuid = require("uuid");
@@ -1888,6 +2387,13 @@ var getActionAnnotationFields = (actionConfig) => {
 function getAllAnnotationFields(config) {
   return (0, import_lodash.flattenDeep)(config.actions.map(getActionAnnotationFields));
 }
+function getAllUniqueFields(eventConfig) {
+  return (0, import_lodash.uniqBy)(getDeclarationFields(eventConfig), (field2) => field2.id);
+}
+function getDeclarationFieldById(config, fieldId) {
+  const field2 = getAllUniqueFields(config).find((f) => f.id === fieldId);
+  return getOrThrow(field2, `Field with id ${fieldId} not found in event config`);
+}
 var findRecordActionPages = (config, actionType) => {
   const action = config.actions.find((a) => a.type === actionType);
   if (action?.type === ActionType.REQUEST_CORRECTION) {
@@ -1948,6 +2454,7 @@ function createEmptyDraft(eventId, draftId, actionType) {
       declaration: {},
       annotation: {},
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      createdByUserType: TokenUserType.Enum.user,
       createdBy: "@todo",
       createdAtLocation: "@todo",
       status: ActionStatus.Accepted,
@@ -1993,8 +2500,9 @@ function omitHiddenAnnotationFields(actionConfig, declaration, annotation) {
   );
 }
 function deepMerge(currentDocument, actionDocument) {
+  const currentDocumentClone = (0, import_lodash.cloneDeep)(currentDocument);
   return (0, import_lodash.mergeWith)(
-    currentDocument,
+    (0, import_lodash.cloneDeep)(currentDocumentClone),
     actionDocument,
     (previousValue, incomingValue) => {
       if (incomingValue === void 0) {
@@ -2042,12 +2550,18 @@ function getMixedPath(obj, path, defaultValue) {
   const result = resolve(obj, parts);
   return (0, import_lodash.isNil)(result) ? defaultValue : result;
 }
+function getEventConfigById(eventConfigs, id) {
+  const eventConfig = eventConfigs.find(
+    (eventConfiguration) => eventConfiguration.id === id
+  );
+  return getOrThrow(eventConfig, `Event config for ${id} not found`);
+}
 
 // ../commons/src/events/EventConfig.ts
 var import_zod_openapi8 = require("zod-openapi");
-(0, import_zod_openapi8.extendZodWithOpenApi)(import_zod18.z);
-var EventConfig = import_zod18.z.object({
-  id: import_zod18.z.string().describe(
+(0, import_zod_openapi8.extendZodWithOpenApi)(import_zod20.z);
+var EventConfig = import_zod20.z.object({
+  id: import_zod20.z.string().describe(
     'A machine-readable identifier for the event, e.g. "birth" or "death"'
   ),
   dateOfEvent: FieldReference.optional(),
@@ -2057,10 +2571,10 @@ var EventConfig = import_zod18.z.object({
   ),
   summary: SummaryConfig,
   label: TranslationConfig,
-  actions: import_zod18.z.array(ActionConfig),
+  actions: import_zod20.z.array(ActionConfig),
   declaration: DeclarationFormConfig,
-  deduplication: import_zod18.z.array(DeduplicationConfig).optional().default([]),
-  advancedSearch: import_zod18.z.array(AdvancedSearchConfig).optional().default([])
+  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);
@@ -2122,12 +2636,12 @@ var definePage = (page) => PageConfig.parse(page);
 var defineFormPage = (formPage) => FormPageConfig.parse(formPage);
 
 // ../commons/src/events/WorkqueueConfig.ts
-var import_zod25 = require("zod");
+var import_zod27 = require("zod");
 
 // ../commons/src/events/serializers/user/serializer.ts
-var import_zod19 = require("zod");
-var SerializedUserField = import_zod19.z.object({
-  $userField: import_zod19.z.enum([
+var import_zod21 = require("zod");
+var SerializedUserField = import_zod21.z.object({
+  $userField: import_zod21.z.enum([
     "id",
     "name",
     "role",
@@ -2328,7 +2842,7 @@ function createFieldConditionals(fieldId) {
           properties: {
             [fieldId]: {
               type: ["string", "boolean"],
-              const: { $data: `1/${comparedFieldId}` }
+              const: { $data: `/$form/${comparedFieldId}` }
             },
             [comparedFieldId]: { type: ["string", "boolean"] }
           },
@@ -2438,6 +2952,23 @@ function createFieldConditionals(fieldId) {
         }
       },
       required: [fieldId]
+    }),
+    getId: () => ({ fieldId }),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    object: (options) => defineFormConditional({
+      type: "object",
+      properties: {
+        [fieldId]: {
+          type: "object",
+          properties: Object.fromEntries(
+            Object.entries(options).map(([key, value]) => {
+              return [key, value.properties.$form.properties[key]];
+            })
+          ),
+          required: Object.keys(options)
+        }
+      },
+      required: [fieldId]
     })
   };
 }
@@ -2513,87 +3044,78 @@ var event = Object.assign(eventFn, {
 });
 
 // ../commons/src/events/WorkqueueColumnConfig.ts
-var import_zod21 = require("zod");
+var import_zod23 = require("zod");
 
 // ../commons/src/events/EventMetadata.ts
-var import_zod20 = require("zod");
-var EventStatus = {
-  CREATED: "CREATED",
-  NOTIFIED: "NOTIFIED",
-  DECLARED: "DECLARED",
-  VALIDATED: "VALIDATED",
-  REGISTERED: "REGISTERED",
-  CERTIFIED: "CERTIFIED",
-  REJECTED: "REJECTED",
-  ARCHIVED: "ARCHIVED"
-};
-var eventStatusValues = [
-  EventStatus.CREATED,
-  EventStatus.NOTIFIED,
-  EventStatus.DECLARED,
-  EventStatus.VALIDATED,
-  EventStatus.REGISTERED,
-  EventStatus.CERTIFIED,
-  EventStatus.REJECTED,
-  EventStatus.ARCHIVED
-];
-var EventStatusEnum = import_zod20.z.enum(eventStatusValues);
+var import_zod22 = require("zod");
+var EventStatus = import_zod22.z.enum([
+  "CREATED",
+  "NOTIFIED",
+  "DECLARED",
+  "VALIDATED",
+  "REGISTERED",
+  "CERTIFIED",
+  "REJECTED",
+  "ARCHIVED"
+]);
 var CustomFlags = {
   CERTIFICATE_PRINTED: "certificate-printed"
 };
-var Flag = import_zod20.z.string().regex(
+var Flag = import_zod22.z.string().regex(
   new RegExp(
     `^(${Object.values(ActionType).join("|").toLowerCase()}):(${Object.values(
       ActionStatus
     ).join("|").toLowerCase()})$`
   ),
   "Flag must be in the format ActionType:ActionStatus (lowerCase)"
-).or(import_zod20.z.nativeEnum(CustomFlags));
-var eventStatuses = Object.values(EventStatus);
-var EventStatuses = import_zod20.z.nativeEnum(EventStatus);
-var ZodDate = import_zod20.z.string().date();
-var ActionCreationMetadata = import_zod20.z.object({
-  createdAt: import_zod20.z.string().datetime().describe("The timestamp when the action request was created."),
-  createdBy: import_zod20.z.string().describe("ID of the user who created the action request."),
+).or(import_zod22.z.nativeEnum(CustomFlags));
+var ZodDate = import_zod22.z.string().date();
+var ActionCreationMetadata = import_zod22.z.object({
+  createdAt: import_zod22.z.string().datetime().describe("The timestamp when the action request was created."),
+  createdBy: import_zod22.z.string().describe("ID of the user who created the action request."),
   createdAtLocation: CreatedAtLocation.describe(
     "Location of the user who created the action request."
   ),
-  acceptedAt: import_zod20.z.string().datetime().describe("Timestamp when the action request was accepted."),
-  createdByRole: import_zod20.z.string().describe("Role of the user at the time of action request creation."),
-  createdBySignature: import_zod20.z.string().nullish().describe("Signature of the user who created the action request.")
+  createdByUserType: import_zod22.z.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
+  acceptedAt: import_zod22.z.string().datetime().describe("Timestamp when the action request was accepted."),
+  createdByRole: import_zod22.z.string().describe("Role of the user at the time of action request creation."),
+  createdBySignature: import_zod22.z.string().nullish().describe("Signature of the user who created the action request.")
 });
 var RegistrationCreationMetadata = ActionCreationMetadata.extend({
-  registrationNumber: import_zod20.z.string().describe(
+  registrationNumber: import_zod22.z.string().describe(
     "Registration number of the event. Always present for accepted registrations."
   )
 });
-var LegalStatuses = import_zod20.z.object({
-  [EventStatus.DECLARED]: ActionCreationMetadata.nullish(),
-  [EventStatus.REGISTERED]: RegistrationCreationMetadata.nullish()
+var LegalStatuses = import_zod22.z.object({
+  [EventStatus.enum.DECLARED]: ActionCreationMetadata.nullish(),
+  [EventStatus.enum.REGISTERED]: RegistrationCreationMetadata.nullish()
 });
-var EventMetadata = import_zod20.z.object({
-  id: import_zod20.z.string(),
-  type: import_zod20.z.string().describe("The type of event, such as birth, death, or marriage."),
-  status: EventStatuses,
+var EventMetadata = import_zod22.z.object({
+  id: import_zod22.z.string(),
+  type: import_zod22.z.string().describe("The type of event, such as birth, death, or marriage."),
+  status: EventStatus,
   legalStatuses: LegalStatuses.describe(
     "Metadata related to the legal registration of the event, such as who registered it and when."
   ),
-  createdAt: import_zod20.z.string().datetime().describe("The timestamp when the event was first created and saved."),
+  createdAt: import_zod22.z.string().datetime().describe("The timestamp when the event was first created and saved."),
   dateOfEvent: ZodDate.nullish(),
-  createdBy: import_zod20.z.string().describe("ID of the user who created the event."),
-  updatedByUserRole: import_zod20.z.string().describe("Role of the user who last updated the declaration."),
+  createdBy: import_zod22.z.string().describe("ID of the user who created the event."),
+  createdByUserType: import_zod22.z.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
+  updatedByUserRole: import_zod22.z.string().describe("Role of the user who last changed the status."),
   createdAtLocation: CreatedAtLocation.describe(
     "Location of the user who created the event."
   ),
-  createdBySignature: import_zod20.z.string().nullish().describe("Signature of the user who created the event."),
-  updatedAtLocation: import_zod20.z.string().nullish().describe("Location of the user who last updated the declaration."),
-  updatedAt: import_zod20.z.string().datetime().describe("Timestamp of the most recent declaration update."),
-  assignedTo: import_zod20.z.string().nullish().describe("ID of the user currently assigned to the event."),
-  updatedBy: import_zod20.z.string().nullish().describe("ID of the user who last updated the declaration."),
-  trackingId: import_zod20.z.string().describe(
+  createdBySignature: import_zod22.z.string().nullish().describe("Signature of the user who created the event."),
+  updatedAtLocation: import_zod22.z.string().nullish().describe("Location of the user who last changed the status."),
+  updatedAt: import_zod22.z.string().datetime().describe(
+    "Timestamp of the most recent *accepted* status change. Possibly 3rd party update, if action is validation asynchronously."
+  ),
+  assignedTo: import_zod22.z.string().nullish().describe("ID of the user currently assigned to the event."),
+  updatedBy: import_zod22.z.string().nullish().describe("ID of the user who last changed the status."),
+  trackingId: import_zod22.z.string().describe(
     "System-generated tracking ID used by informants or registrars to look up the event."
   ),
-  flags: import_zod20.z.array(Flag)
+  flags: import_zod22.z.array(Flag)
 });
 var EventMetadataKeysArray = [
   "id",
@@ -2602,6 +3124,7 @@ var EventMetadataKeysArray = [
   "createdAt",
   "dateOfEvent",
   "createdBy",
+  "createdByUserType",
   "updatedByUserRole",
   "createdAtLocation",
   "updatedAtLocation",
@@ -2612,7 +3135,7 @@ var EventMetadataKeysArray = [
   "legalStatuses",
   "flags"
 ];
-var EventMetadataKeys = import_zod20.z.enum(EventMetadataKeysArray);
+var EventMetadataKeys = import_zod22.z.enum(EventMetadataKeysArray);
 var eventMetadataLabelMap = {
   "event.assignedTo": {
     id: "event.assignedTo.label",
@@ -2624,6 +3147,11 @@ var eventMetadataLabelMap = {
     defaultMessage: "Created",
     description: "Created At"
   },
+  "event.createdByUserType": {
+    id: "event.createdByUserType.label",
+    defaultMessage: "createdByUserType",
+    description: "createdByUserType:user or system"
+  },
   "event.dateOfEvent": {
     id: "event.dateOfEvent.label",
     defaultMessage: "Date of Event",
@@ -2689,13 +3217,14 @@ var eventMetadataLabelMap = {
 // ../commons/src/events/WorkqueueColumnConfig.ts
 var WorkqueueColumnKeysArray = [
   ...EventMetadataKeysArray,
-  "title"
+  "title",
+  "outbox"
 ];
-var WorkqueueColumnKeys = import_zod21.z.enum(WorkqueueColumnKeysArray);
-var WorkqueueColumnValue = import_zod21.z.object({
+var WorkqueueColumnKeys = import_zod23.z.enum(WorkqueueColumnKeysArray);
+var WorkqueueColumnValue = import_zod23.z.object({
   $event: WorkqueueColumnKeys
 });
-var WorkqueueColumn = import_zod21.z.object({
+var WorkqueueColumn = import_zod23.z.object({
   label: TranslationConfig,
   value: WorkqueueColumnValue
 });
@@ -2706,96 +3235,112 @@ function defineWorkqueuesColumns(workqueueColumns) {
 }
 
 // ../commons/src/events/CountryConfigQueryInput.ts
-var import_zod23 = require("zod");
+var import_zod25 = require("zod");
 
 // ../commons/src/events/EventIndex.ts
-var import_zod22 = require("zod");
+var import_zod24 = require("zod");
 var import_zod_openapi9 = require("zod-openapi");
-(0, import_zod_openapi9.extendZodWithOpenApi)(import_zod22.z);
+(0, import_zod_openapi9.extendZodWithOpenApi)(import_zod24.z);
 var EventIndex = EventMetadata.extend({
   declaration: EventState
 }).openapi({
   ref: "EventIndex"
 });
-var EventSearchIndex = import_zod22.z.record(import_zod22.z.string(), import_zod22.z.any()).and(
-  import_zod22.z.object({
-    type: import_zod22.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
   })
 ).openapi({
   ref: "EventSearchIndex"
 });
-var Fuzzy = import_zod22.z.object({ type: import_zod22.z.literal("fuzzy"), term: import_zod22.z.string() }).openapi({
+var Fuzzy = import_zod24.z.object({ type: import_zod24.z.literal("fuzzy"), term: import_zod24.z.string() }).openapi({
   ref: "Fuzzy"
 });
-var Exact = import_zod22.z.object({ type: import_zod22.z.literal("exact"), term: import_zod22.z.string() }).openapi({
+var Exact = import_zod24.z.object({ type: import_zod24.z.literal("exact"), term: import_zod24.z.string() }).openapi({
   ref: "Exact"
 });
-var AnyOf = import_zod22.z.object({
-  type: import_zod22.z.literal("anyOf"),
-  terms: import_zod22.z.array(import_zod22.z.string())
+var ExactStatus = import_zod24.z.object({
+  type: import_zod24.z.literal("exact"),
+  term: EventStatus
 }).openapi({
-  ref: "AnyOf"
+  ref: "ExactStatus"
 });
-var ExactStatus = import_zod22.z.object({
-  type: import_zod22.z.literal("exact"),
-  term: EventStatusEnum
+var AnyOf = import_zod24.z.object({
+  type: import_zod24.z.literal("anyOf"),
+  terms: import_zod24.z.array(import_zod24.z.string())
 }).openapi({
-  ref: "ExactStatus"
+  ref: "AnyOf"
 });
-var AnyOfStatus = import_zod22.z.object({
-  type: import_zod22.z.literal("anyOf"),
-  terms: import_zod22.z.array(EventStatusEnum)
+var AnyOfStatus = import_zod24.z.object({
+  type: import_zod24.z.literal("anyOf"),
+  terms: import_zod24.z.array(EventStatus)
 }).openapi({
   ref: "AnyOfStatus"
 });
-var Range = import_zod22.z.object({
-  type: import_zod22.z.literal("range"),
-  gte: import_zod22.z.string(),
-  lte: import_zod22.z.string()
+var Range = import_zod24.z.object({
+  type: import_zod24.z.literal("range"),
+  gte: import_zod24.z.string(),
+  lte: import_zod24.z.string()
 }).openapi({
   ref: "Range"
 });
-var Not = import_zod22.z.object({ type: import_zod22.z.literal("not"), term: import_zod22.z.string() }).openapi({
+var Not = import_zod24.z.object({ type: import_zod24.z.literal("not"), term: import_zod24.z.string() }).openapi({
   ref: "Not"
 });
-var Within = import_zod22.z.object({ type: import_zod22.z.literal("within"), location: import_zod22.z.string() }).openapi({
+var Within = import_zod24.z.object({ type: import_zod24.z.literal("within"), location: import_zod24.z.string() }).openapi({
   ref: "Within"
 });
-var DateCondition = import_zod22.z.union([Exact, Range]).openapi({
+var RangeDate = Range.extend({
+  gte: import_zod24.z.string().date().or(import_zod24.z.string().datetime()),
+  lte: import_zod24.z.string().date().or(import_zod24.z.string().datetime())
+}).openapi({
+  ref: "RangeDate"
+});
+var ExactDate = Exact.extend({
+  term: import_zod24.z.string().date().or(import_zod24.z.string().datetime())
+}).openapi({
+  ref: "ExactDate"
+});
+var DateCondition = import_zod24.z.union([ExactDate, RangeDate]).openapi({
   ref: "DateCondition"
 });
-var QueryInput = import_zod22.z.lazy(
-  () => import_zod22.z.union([
-    import_zod22.z.discriminatedUnion("type", [Fuzzy, Exact, Range, Within, AnyOf, Not]),
-    import_zod22.z.record(import_zod22.z.string(), QueryInput)
+var QueryInput = import_zod24.z.lazy(
+  () => import_zod24.z.union([
+    import_zod24.z.discriminatedUnion("type", [Fuzzy, Exact, Range, Within, AnyOf, Not]),
+    import_zod24.z.record(import_zod24.z.string(), QueryInput)
   ])
 ).openapi({
   ref: "QueryInput"
 });
-var QueryExpression = import_zod22.z.object({
-  eventType: import_zod22.z.string(),
-  status: import_zod22.z.optional(import_zod22.z.union([AnyOfStatus, ExactStatus])),
-  createdAt: import_zod22.z.optional(DateCondition),
-  updatedAt: import_zod22.z.optional(DateCondition),
-  "legalStatus.REGISTERED.createdAt": import_zod22.z.optional(DateCondition),
-  "legalStatus.REGISTERED.createdAtLocation": import_zod22.z.optional(
-    import_zod22.z.union([Within, Exact])
+var QueryExpression = import_zod24.z.object({
+  id: import_zod24.z.optional(import_zod24.z.string()),
+  eventType: import_zod24.z.string(),
+  status: import_zod24.z.optional(import_zod24.z.union([AnyOfStatus, ExactStatus])),
+  createdAt: import_zod24.z.optional(DateCondition),
+  updatedAt: import_zod24.z.optional(DateCondition),
+  "legalStatus.REGISTERED.createdAt": import_zod24.z.optional(DateCondition),
+  "legalStatus.REGISTERED.createdAtLocation": import_zod24.z.optional(
+    import_zod24.z.union([Within, Exact])
   ),
-  createdAtLocation: import_zod22.z.optional(import_zod22.z.union([Within, Exact])),
-  updatedAtLocation: import_zod22.z.optional(import_zod22.z.union([Within, Exact])),
-  assignedTo: import_zod22.z.optional(Exact),
-  createdBy: import_zod22.z.optional(Exact),
-  updatedBy: import_zod22.z.optional(Exact),
-  trackingId: import_zod22.z.optional(Exact),
-  flags: import_zod22.z.optional(import_zod22.z.array(import_zod22.z.union([AnyOf, Not]))),
+  "legalStatus.REGISTERED.registrationNumber": import_zod24.z.optional(Exact),
+  createdAtLocation: import_zod24.z.optional(import_zod24.z.union([Within, Exact])),
+  updatedAtLocation: import_zod24.z.optional(import_zod24.z.union([Within, Exact])),
+  assignedTo: import_zod24.z.optional(Exact),
+  createdByUserType: TokenUserType,
+  createdBy: import_zod24.z.optional(Exact),
+  updatedBy: import_zod24.z.optional(Exact),
+  trackingId: import_zod24.z.optional(Exact),
+  flags: import_zod24.z.optional(import_zod24.z.array(import_zod24.z.union([AnyOf, Not]))),
   data: QueryInput
-}).partial().openapi({
+}).partial().refine((obj) => Object.values(obj).some((val) => val !== void 0), {
+  message: "At least one query field must be specified."
+}).openapi({
   ref: "QueryExpression"
 });
-var QueryType = import_zod22.z.object({
-  type: import_zod22.z.literal("and").or(import_zod22.z.literal("or")).openapi({ default: "and" }),
-  clauses: import_zod22.z.preprocess(
+var QueryType = import_zod24.z.object({
+  type: import_zod24.z.literal("and").or(import_zod24.z.literal("or")).openapi({ default: "and" }),
+  clauses: import_zod24.z.preprocess(
     (val) => {
       if (typeof val === "string") {
         return [JSON.parse(val)];
@@ -2805,22 +3350,13 @@ var QueryType = import_zod22.z.object({
       }
       return val;
     },
-    import_zod22.z.array(QueryExpression).openapi({
+    import_zod24.z.array(QueryExpression).nonempty("At least one clause is required.").openapi({
       default: [
         {
           eventType: TENNIS_CLUB_MEMBERSHIP,
           status: {
             type: "anyOf",
-            terms: [
-              "CREATED",
-              "NOTIFIED",
-              "DECLARED",
-              "VALIDATED",
-              "REGISTERED",
-              "CERTIFIED",
-              "REJECTED",
-              "ARCHIVED"
-            ]
+            terms: EventStatus.options
           },
           updatedAt: {
             type: "range",
@@ -2837,50 +3373,51 @@ var QueryType = import_zod22.z.object({
 });
 
 // ../commons/src/events/CountryConfigQueryInput.ts
-var SerializableExact = import_zod23.z.object({
-  type: import_zod23.z.literal("exact"),
-  term: import_zod23.z.union([import_zod23.z.string(), SerializedUserField])
+var SerializableExact = import_zod25.z.object({
+  type: import_zod25.z.literal("exact"),
+  term: import_zod25.z.union([import_zod25.z.string(), SerializedUserField])
 });
-var SerializableWithin = import_zod23.z.object({
-  type: import_zod23.z.literal("within"),
-  location: import_zod23.z.union([import_zod23.z.string(), SerializedUserField])
+var SerializableWithin = import_zod25.z.object({
+  type: import_zod25.z.literal("within"),
+  location: import_zod25.z.union([import_zod25.z.string(), SerializedUserField])
 });
-var SerializedQueryExpression = import_zod23.z.object({
-  eventType: import_zod23.z.string(),
-  status: import_zod23.z.optional(import_zod23.z.union([AnyOfStatus, ExactStatus])),
-  createdAt: import_zod23.z.optional(DateCondition),
-  updatedAt: import_zod23.z.optional(DateCondition),
-  createdAtLocation: import_zod23.z.optional(
-    import_zod23.z.union([SerializableWithin, SerializableExact])
+var SerializedQueryExpression = import_zod25.z.object({
+  eventType: import_zod25.z.string(),
+  status: import_zod25.z.optional(import_zod25.z.union([AnyOfStatus, ExactStatus])),
+  createdAt: import_zod25.z.optional(DateCondition),
+  updatedAt: import_zod25.z.optional(DateCondition),
+  createdAtLocation: import_zod25.z.optional(
+    import_zod25.z.union([SerializableWithin, SerializableExact])
   ),
-  updatedAtLocation: import_zod23.z.optional(
-    import_zod23.z.union([SerializableWithin, SerializableExact])
+  updatedAtLocation: import_zod25.z.optional(
+    import_zod25.z.union([SerializableWithin, SerializableExact])
   ),
-  assignedTo: import_zod23.z.optional(SerializableExact),
-  createdBy: import_zod23.z.optional(SerializableExact),
-  updatedBy: import_zod23.z.optional(SerializableExact),
-  trackingId: import_zod23.z.optional(Exact),
-  flags: import_zod23.z.optional(import_zod23.z.array(import_zod23.z.union([AnyOf, Not]))),
+  assignedTo: import_zod25.z.optional(SerializableExact),
+  createdBy: import_zod25.z.optional(SerializableExact),
+  createdByUserType: TokenUserType,
+  updatedBy: import_zod25.z.optional(SerializableExact),
+  trackingId: import_zod25.z.optional(Exact),
+  flags: import_zod25.z.optional(import_zod25.z.array(import_zod25.z.union([AnyOf, Not]))),
   data: QueryInput
 }).partial();
-var Or2 = import_zod23.z.object({
-  type: import_zod23.z.literal("or"),
-  clauses: import_zod23.z.array(SerializedQueryExpression)
+var Or2 = import_zod25.z.object({
+  type: import_zod25.z.literal("or"),
+  clauses: import_zod25.z.array(SerializedQueryExpression)
 });
-var And2 = import_zod23.z.object({
-  type: import_zod23.z.literal("and"),
-  clauses: import_zod23.z.array(SerializedQueryExpression)
+var And2 = import_zod25.z.object({
+  type: import_zod25.z.literal("and"),
+  clauses: import_zod25.z.array(SerializedQueryExpression)
 });
-var CountryConfigQueryType = import_zod23.z.discriminatedUnion("type", [And2, Or2]);
-var CountryConfigQueryInputType = import_zod23.z.union([
+var CountryConfigQueryType = import_zod25.z.discriminatedUnion("type", [And2, Or2]);
+var CountryConfigQueryInputType = import_zod25.z.union([
   SerializedQueryExpression,
   And2,
   Or2
 ]);
 
 // ../commons/src/icons.ts
-var import_zod24 = require("zod");
-var AvailableIcons = import_zod24.z.enum([
+var import_zod26 = require("zod");
+var AvailableIcons = import_zod26.z.enum([
   "Archived",
   "Assigned",
   "Certified",
@@ -2984,7 +3521,7 @@ var AvailableIcons = import_zod24.z.enum([
 ]);
 
 // ../commons/src/events/WorkqueueConfig.ts
-var dateOfEventColumn = defineWorkqueuesColumns([
+var mandatoryColumns = defineWorkqueuesColumns([
   {
     label: {
       id: "workqueues.dateOfEvent",
@@ -3002,38 +3539,42 @@ var dateOfEventColumn = defineWorkqueuesColumns([
     value: event.field("updatedAt")
   }
 ]);
-var WorkqueueActionsWithDefault = import_zod25.z.enum([
+var WorkqueueActionsWithDefault = import_zod27.z.enum([
   ...workqueueActions.options,
   "DEFAULT"
 ]);
-var WorkqueueConfig = import_zod25.z.object({
-  slug: import_zod25.z.string().describe("Determines the url of the workqueue."),
+var WorkqueueConfig = import_zod27.z.object({
+  slug: import_zod27.z.string().describe("Determines the url of the workqueue."),
   name: TranslationConfig.describe(
     "Title of the workflow (both in navigation and on the page)"
   ),
   query: CountryConfigQueryType,
-  actions: import_zod25.z.array(
-    import_zod25.z.object({
+  actions: import_zod27.z.array(
+    import_zod27.z.object({
       type: WorkqueueActionsWithDefault,
-      conditionals: import_zod25.z.array(Conditional).optional()
+      conditionals: import_zod27.z.array(Conditional).optional()
     })
   ),
-  columns: import_zod25.z.array(WorkqueueColumn).default(dateOfEventColumn),
+  columns: import_zod27.z.array(WorkqueueColumn).default(mandatoryColumns),
   icon: AvailableIcons
 }).describe("Configuration for workqueue.");
-var WorkqueueConfigInput = import_zod25.z.object({
-  slug: import_zod25.z.string().describe("Determines the url of the workqueue."),
+var WorkqueueConfigWithoutQuery = WorkqueueConfig.omit({
+  query: true,
+  columns: true
+});
+var WorkqueueConfigInput = import_zod27.z.object({
+  slug: import_zod27.z.string().describe("Determines the url of the workqueue."),
   name: TranslationConfig.describe(
     "Title of the workflow (both in navigation and on the page)"
   ),
   query: CountryConfigQueryInputType,
-  actions: import_zod25.z.array(
-    import_zod25.z.object({
+  actions: import_zod27.z.array(
+    import_zod27.z.object({
       type: WorkqueueActionsWithDefault,
-      conditionals: import_zod25.z.array(Conditional).optional()
+      conditionals: import_zod27.z.array(Conditional).optional()
     })
   ),
-  columns: import_zod25.z.array(WorkqueueColumn).default(dateOfEventColumn),
+  columns: import_zod27.z.array(WorkqueueColumn).default(mandatoryColumns),
   icon: AvailableIcons
 });
 function defineWorkqueue(workqueueInput) {
@@ -3044,10 +3585,10 @@ function defineWorkqueue(workqueueInput) {
 function defineWorkqueues(workqueues) {
   return workqueues.map((workqueue) => defineWorkqueue(workqueue));
 }
-var WorkqueueCountInput = import_zod25.z.array(
-  import_zod25.z.object({ slug: import_zod25.z.string(), query: QueryType })
+var WorkqueueCountInput = import_zod27.z.array(
+  import_zod27.z.object({ slug: import_zod27.z.string(), query: QueryType })
 );
-var WorkqueueCountOutput = import_zod25.z.record(import_zod25.z.string(), import_zod25.z.number());
+var WorkqueueCountOutput = import_zod27.z.record(import_zod27.z.string(), import_zod27.z.number());
 
 // ../commons/src/events/workqueueDefaultColumns.ts
 var defaultWorkqueueColumns = [
@@ -3070,42 +3611,42 @@ var defaultWorkqueueColumns = [
 ];
 
 // ../commons/src/events/Draft.ts
-var import_zod27 = require("zod");
+var import_zod29 = require("zod");
 
 // ../commons/src/events/ActionInput.ts
-var import_zod26 = require("zod");
+var import_zod28 = require("zod");
 var import_zod_openapi10 = require("zod-openapi");
 var import_uuid3 = require("uuid");
-(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod26.z);
-var BaseActionInput = import_zod26.z.object({
-  eventId: import_zod26.z.string(),
-  transactionId: import_zod26.z.string(),
+(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod28.z);
+var BaseActionInput = import_zod28.z.object({
+  eventId: import_zod28.z.string(),
+  transactionId: import_zod28.z.string(),
   declaration: ActionUpdate.default({}),
   annotation: ActionUpdate.optional(),
-  originalActionId: import_zod26.z.string().optional(),
-  keepAssignment: import_zod26.z.boolean().optional()
+  originalActionId: import_zod28.z.string().optional(),
+  keepAssignment: import_zod28.z.boolean().optional()
 });
 var CreateActionInput = BaseActionInput.merge(
-  import_zod26.z.object({
-    type: import_zod26.z.literal(ActionType.CREATE).default(ActionType.CREATE),
+  import_zod28.z.object({
+    type: import_zod28.z.literal(ActionType.CREATE).default(ActionType.CREATE),
     createdAtLocation: CreatedAtLocation
   })
 );
 var RegisterActionInput = BaseActionInput.merge(
-  import_zod26.z.object({
-    type: import_zod26.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
-    registrationNumber: import_zod26.z.string().optional()
+  import_zod28.z.object({
+    type: import_zod28.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
+    registrationNumber: import_zod28.z.string().optional()
   })
 );
 var ValidateActionInput = BaseActionInput.merge(
-  import_zod26.z.object({
-    type: import_zod26.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
-    duplicates: import_zod26.z.array(import_zod26.z.string())
+  import_zod28.z.object({
+    type: import_zod28.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
+    duplicates: import_zod28.z.array(import_zod28.z.string())
   })
 );
 var NotifyActionInput = BaseActionInput.merge(
-  import_zod26.z.object({
-    type: import_zod26.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
+  import_zod28.z.object({
+    type: import_zod28.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
   })
 ).openapi({
   default: {
@@ -3117,68 +3658,68 @@ var NotifyActionInput = BaseActionInput.merge(
   }
 });
 var DeclareActionInput = BaseActionInput.merge(
-  import_zod26.z.object({
-    type: import_zod26.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
+  import_zod28.z.object({
+    type: import_zod28.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
   })
 );
 var PrintCertificateActionInput = BaseActionInput.merge(
-  import_zod26.z.object({
-    type: import_zod26.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
+  import_zod28.z.object({
+    type: import_zod28.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RejectDeclarationActionInput = BaseActionInput.merge(
-  import_zod26.z.object({
-    type: import_zod26.z.literal(ActionType.REJECT).default(ActionType.REJECT),
+  import_zod28.z.object({
+    type: import_zod28.z.literal(ActionType.REJECT).default(ActionType.REJECT),
     reason: RejectionReason
   })
 );
 var MarkedAsDuplicateActionInput = BaseActionInput.merge(
-  import_zod26.z.object({
-    type: import_zod26.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
+  import_zod28.z.object({
+    type: import_zod28.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveActionInput = BaseActionInput.merge(
-  import_zod26.z.object({
-    type: import_zod26.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE),
+  import_zod28.z.object({
+    type: import_zod28.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE),
     reason: RejectionReason
   })
 );
 var AssignActionInput = BaseActionInput.merge(
-  import_zod26.z.object({
-    type: import_zod26.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
-    assignedTo: import_zod26.z.string()
+  import_zod28.z.object({
+    type: import_zod28.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
+    assignedTo: import_zod28.z.string()
   })
 );
 var UnassignActionInput = BaseActionInput.merge(
-  import_zod26.z.object({
-    type: import_zod26.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
-    assignedTo: import_zod26.z.literal(null).default(null)
+  import_zod28.z.object({
+    type: import_zod28.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
+    assignedTo: import_zod28.z.literal(null).default(null)
   })
 );
 var RequestCorrectionActionInput = BaseActionInput.merge(
-  import_zod26.z.object({
-    type: import_zod26.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
+  import_zod28.z.object({
+    type: import_zod28.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
   })
 );
 var RejectCorrectionActionInput = BaseActionInput.merge(
-  import_zod26.z.object({
-    requestId: import_zod26.z.string(),
-    type: import_zod26.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
+  import_zod28.z.object({
+    requestId: import_zod28.z.string(),
+    type: import_zod28.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
   })
 );
 var ApproveCorrectionActionInput = BaseActionInput.merge(
-  import_zod26.z.object({
-    requestId: import_zod26.z.string(),
-    type: import_zod26.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
+  import_zod28.z.object({
+    requestId: import_zod28.z.string(),
+    type: import_zod28.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
   })
 );
 var ReadActionInput = BaseActionInput.merge(
-  import_zod26.z.object({
-    type: import_zod26.z.literal(ActionType.READ).default(ActionType.READ)
+  import_zod28.z.object({
+    type: import_zod28.z.literal(ActionType.READ).default(ActionType.READ)
   })
 );
-var DeleteActionInput = import_zod26.z.object({ eventId: import_zod26.z.string() });
-var ActionInput = import_zod26.z.discriminatedUnion("type", [
+var DeleteActionInput = import_zod28.z.object({ eventId: import_zod28.z.string() });
+var ActionInput = import_zod28.z.discriminatedUnion("type", [
   CreateActionInput.openapi({ ref: "CreateActionInput" }),
   ValidateActionInput.openapi({ ref: "ValidateActionInput" }),
   RegisterActionInput.openapi({ ref: "RegisterActionInput" }),
@@ -3207,18 +3748,18 @@ var ActionInput = import_zod26.z.discriminatedUnion("type", [
 });
 
 // ../commons/src/events/Draft.ts
-var Draft = import_zod27.z.object({
-  id: import_zod27.z.string(),
-  eventId: import_zod27.z.string(),
-  transactionId: import_zod27.z.string(),
-  createdAt: import_zod27.z.string().datetime(),
+var Draft = import_zod29.z.object({
+  id: import_zod29.z.string(),
+  eventId: import_zod29.z.string(),
+  transactionId: import_zod29.z.string(),
+  createdAt: import_zod29.z.string().datetime(),
   action: ActionBase.extend({
     type: ActionTypes
   }).omit({ id: true })
 });
 var DraftInput = BaseActionInput.extend({
   type: ActionTypes,
-  status: import_zod27.z.enum([
+  status: import_zod29.z.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
@@ -3226,24 +3767,24 @@ var DraftInput = BaseActionInput.extend({
 });
 
 // ../commons/src/events/EventInput.ts
-var import_zod28 = require("zod");
+var import_zod30 = require("zod");
 var import_uuid4 = require("uuid");
-var EventInput = import_zod28.z.object({
-  transactionId: import_zod28.z.string(),
-  type: import_zod28.z.string()
+var EventInput = import_zod30.z.object({
+  transactionId: import_zod30.z.string(),
+  type: import_zod30.z.string()
 }).openapi({ default: { transactionId: (0, import_uuid4.v4)(), type: "v2.birth" } });
 
 // ../commons/src/events/EventDocument.ts
-var import_zod29 = require("zod");
+var import_zod31 = require("zod");
 var import_zod_openapi11 = require("zod-openapi");
-(0, import_zod_openapi11.extendZodWithOpenApi)(import_zod29.z);
-var EventDocument = import_zod29.z.object({
-  id: import_zod29.z.string(),
-  type: import_zod29.z.string(),
-  createdAt: import_zod29.z.string().datetime(),
-  updatedAt: import_zod29.z.string().datetime(),
-  actions: import_zod29.z.array(Action),
-  trackingId: import_zod29.z.string()
+(0, import_zod_openapi11.extendZodWithOpenApi)(import_zod31.z);
+var EventDocument = import_zod31.z.object({
+  id: import_zod31.z.string(),
+  type: import_zod31.z.string(),
+  createdAt: import_zod31.z.string().datetime(),
+  updatedAt: import_zod31.z.string().datetime(),
+  actions: import_zod31.z.array(Action),
+  trackingId: import_zod31.z.string()
 }).openapi({ ref: "EventDocument" });
 
 // ../commons/src/events/state/utils.ts
@@ -3277,6 +3818,7 @@ function getDeclarationActionCreationMetadata(actionType, actions) {
     // When 3rd party API returns 200 OK, we assume that the request was accepted, and persist single 'accepted' action.
     createdAt: requestAction?.createdAt ?? acceptAction.createdAt,
     createdBy: requestAction?.createdBy ?? acceptAction.createdBy,
+    createdByUserType: requestAction?.createdByUserType ?? acceptAction.createdByUserType,
     createdAtLocation: requestAction?.createdAtLocation ?? acceptAction.createdAtLocation,
     acceptedAt: acceptAction.createdAt,
     createdByRole: requestAction?.createdByRole ?? acceptAction.createdByRole,
@@ -3284,17 +3826,18 @@ function getDeclarationActionCreationMetadata(actionType, actions) {
     registrationNumber
   };
 }
-function getDeclarationActionUpdateMetadata(actions) {
+function getActionUpdateMetadata(actions) {
   const createAction = getOrThrow(
     actions.find((action) => action.type === ActionType.CREATE),
     `Event has no ${ActionType.CREATE} action`
   );
-  return [ActionType.DECLARE, ActionType.VALIDATE, ActionType.REGISTER].reduce(
+  return StatusChangingActions.options.reduce(
     (metadata, actionType) => {
       const { accept, request } = getActionRequests(actionType, actions);
       return {
         createdAt: request?.createdAt ?? accept?.createdAt ?? metadata.createdAt,
         createdBy: request?.createdBy ?? accept?.createdBy ?? metadata.createdBy,
+        createdByUserType: request?.createdByUserType ?? accept?.createdByUserType ?? metadata.createdByUserType,
         createdAtLocation: request?.createdAtLocation ?? accept?.createdAtLocation ?? metadata.createdAtLocation,
         createdByRole: request?.createdByRole ?? accept?.createdByRole ?? metadata.createdByRole
       };
@@ -3302,6 +3845,7 @@ function getDeclarationActionUpdateMetadata(actions) {
     {
       createdAt: createAction.createdAt,
       createdBy: createAction.createdBy,
+      createdByUserType: createAction.createdByUserType,
       createdAtLocation: createAction.createdAtLocation,
       createdByRole: createAction.createdByRole
     }
@@ -3309,11 +3853,11 @@ function getDeclarationActionUpdateMetadata(actions) {
 }
 function getLegalStatuses(actions) {
   return {
-    [EventStatus.DECLARED]: getDeclarationActionCreationMetadata(
+    [EventStatus.enum.DECLARED]: getDeclarationActionCreationMetadata(
       ActionType.DECLARE,
       actions
     ),
-    [EventStatus.REGISTERED]: getDeclarationActionCreationMetadata(
+    [EventStatus.enum.REGISTERED]: getDeclarationActionCreationMetadata(
       ActionType.REGISTER,
       actions
     )
@@ -3326,26 +3870,26 @@ function getStatusFromActions(actions) {
     (a) => a.status === ActionStatus.Rejected
   );
   if (hasRejectedAction) {
-    return EventStatus.REJECTED;
+    return EventStatus.enum.REJECTED;
   }
   return actions.reduce((status, action) => {
     switch (action.type) {
       case ActionType.CREATE:
-        return EventStatus.CREATED;
+        return EventStatus.enum.CREATED;
       case ActionType.DECLARE:
-        return EventStatus.DECLARED;
+        return EventStatus.enum.DECLARED;
       case ActionType.VALIDATE:
-        return EventStatus.VALIDATED;
+        return EventStatus.enum.VALIDATED;
       case ActionType.REGISTER:
-        return EventStatus.REGISTERED;
+        return EventStatus.enum.REGISTERED;
       case ActionType.REJECT:
-        return EventStatus.REJECTED;
+        return EventStatus.enum.REJECTED;
       case ActionType.ARCHIVE:
-        return EventStatus.ARCHIVED;
+        return EventStatus.enum.ARCHIVED;
       case ActionType.NOTIFY:
-        return EventStatus.NOTIFIED;
+        return EventStatus.enum.NOTIFIED;
       case ActionType.PRINT_CERTIFICATE:
-        return EventStatus.CERTIFIED;
+        return EventStatus.enum.CERTIFIED;
       case ActionType.ASSIGN:
       case ActionType.UNASSIGN:
       case ActionType.REQUEST_CORRECTION:
@@ -3356,7 +3900,7 @@ function getStatusFromActions(actions) {
       default:
         return status;
     }
-  }, EventStatus.CREATED);
+  }, EventStatus.enum.CREATED);
 }
 function getFlagsFromActions(actions) {
   const sortedactions = actions.sort(
@@ -3448,7 +3992,7 @@ function deepDropNulls(obj) {
   return obj;
 }
 function isUndeclaredDraft(status) {
-  return status === EventStatus.CREATED;
+  return status === EventStatus.enum.CREATED;
 }
 function getAcceptedActions(event2) {
   return event2.actions.filter(
@@ -3463,10 +4007,11 @@ function getCurrentEventState(event2, config) {
   if (!creationAction) {
     throw new Error(`Event ${event2.id} has no creation action`);
   }
-  const acceptedActions = getAcceptedActions(event2);
-  const declarationUpdateMetadata = getDeclarationActionUpdateMetadata(
-    event2.actions
+  const acceptedActions = getAcceptedActions(event2).sort(
+    (a, b) => a.createdAt.localeCompare(b.createdAt)
   );
+  const requestActionMetadata = getActionUpdateMetadata(event2.actions);
+  const acceptedActionMetadata = getActionUpdateMetadata(acceptedActions);
   const declaration = aggregateActionDeclarations(acceptedActions);
   let dateOfEvent;
   if (config.dateOfEvent) {
@@ -3486,16 +4031,17 @@ function getCurrentEventState(event2, config) {
     legalStatuses: getLegalStatuses(event2.actions),
     createdAt: creationAction.createdAt,
     createdBy: creationAction.createdBy,
+    createdByUserType: creationAction.createdByUserType,
     createdAtLocation: creationAction.createdAtLocation,
     createdBySignature: creationAction.createdBySignature,
-    updatedAt: declarationUpdateMetadata.createdAt,
+    updatedAt: acceptedActionMetadata.createdAt,
     assignedTo: getAssignedUserFromActions(acceptedActions),
     assignedToSignature: getAssignedUserSignatureFromActions(acceptedActions),
-    updatedBy: declarationUpdateMetadata.createdBy,
-    updatedAtLocation: declarationUpdateMetadata.createdAtLocation,
+    updatedBy: requestActionMetadata.createdBy,
+    updatedAtLocation: requestActionMetadata.createdAtLocation,
     declaration,
     trackingId: event2.trackingId,
-    updatedByUserRole: declarationUpdateMetadata.createdByRole,
+    updatedByUserRole: requestActionMetadata.createdByRole,
     dateOfEvent,
     flags: getFlagsFromActions(event2.actions)
   });
@@ -3578,18 +4124,18 @@ function generateTransactionId() {
 }
 
 // ../commons/src/events/User.ts
-var import_zod30 = require("zod");
-var User = import_zod30.z.object({
-  id: import_zod30.z.string(),
-  name: import_zod30.z.array(
-    import_zod30.z.object({
-      use: import_zod30.z.string(),
-      given: import_zod30.z.array(import_zod30.z.string()),
-      family: import_zod30.z.string()
+var import_zod32 = require("zod");
+var User = import_zod32.z.object({
+  id: import_zod32.z.string(),
+  name: import_zod32.z.array(
+    import_zod32.z.object({
+      use: import_zod32.z.string(),
+      given: import_zod32.z.array(import_zod32.z.string()),
+      family: import_zod32.z.string()
     })
   ),
-  role: import_zod30.z.string(),
-  signatureFilename: import_zod30.z.string().optional()
+  role: import_zod32.z.string(),
+  signatureFilename: import_zod32.z.string().optional()
 });
 
 // ../commons/src/events/test.utils.ts
@@ -4274,7 +4820,7 @@ var PRINT_CERTIFICATE_FORM = defineActionForm({
 var TENNIS_CLUB_DECLARATION_REVIEW = {
   title: {
     id: "v2.event.tennis-club-membership.action.declare.form.review.title",
-    defaultMessage: "{applicant.firstname, select, __EMPTY__ {Member declaration} other {{applicant.surname, select, __EMPTY__ {Member declaration} other {Member declaration for {applicant.firstname} {applicant.surname}}}}}",
+    defaultMessage: "{applicant.name.firstname, select, __EMPTY__ {Member declaration} other {{applicant.name.surname, select, __EMPTY__ {Member declaration} other {Member declaration for {applicant.name.firstname} {applicant.name.surname}}}}}",
     description: "Title of the review page"
   },
   fields: [
@@ -4319,27 +4865,17 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
       },
       fields: [
         {
-          id: "applicant.firstname",
-          type: FieldType.TEXT,
+          id: "applicant.name",
+          type: FieldType.NAME,
           required: true,
+          hideLabel: true,
           conditionals: [],
           label: {
-            defaultMessage: "Applicant's first name",
+            defaultMessage: "Applicant's name",
             description: "This is the label for the field",
             id: "v2.event.tennis-club-membership.action.declare.form.section.who.field.firstname.label"
           }
         },
-        {
-          id: "applicant.surname",
-          type: FieldType.TEXT,
-          required: true,
-          conditionals: [],
-          label: {
-            defaultMessage: "Applicant's surname",
-            description: "This is the label for the field",
-            id: "v2.event.tennis-club-membership.action.declare.form.section.who.field.surname.label"
-          }
-        },
         {
           id: "applicant.email",
           type: "EMAIL",
@@ -4473,8 +5009,9 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
           }
         },
         {
-          id: "recommender.firstname",
-          type: FieldType.TEXT,
+          id: "recommender.name",
+          type: FieldType.NAME,
+          hideLabel: true,
           required: true,
           conditionals: [
             {
@@ -4483,27 +5020,11 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
             }
           ],
           label: {
-            defaultMessage: "Recommender's first name",
+            defaultMessage: "Recommender's name",
             description: "This is the label for the field",
             id: "v2.event.tennis-club-membership.action.declare.form.section.recommender.field.firstname.label"
           }
         },
-        {
-          id: "recommender.surname",
-          type: FieldType.TEXT,
-          required: true,
-          conditionals: [
-            {
-              type: ConditionalType.SHOW,
-              conditional: field("recommender.none").isFalsy()
-            }
-          ],
-          label: {
-            defaultMessage: "Recommender's surname",
-            description: "This is the label for the field",
-            id: "v2.event.tennis-club-membership.action.declare.form.section.recommender.field.surname.label"
-          }
-        },
         {
           id: "recommender.id",
           type: FieldType.TEXT,
@@ -4534,7 +5055,7 @@ var statusOptions = [
     }
   },
   {
-    value: EventStatus.CREATED,
+    value: EventStatus.enum.CREATED,
     label: {
       defaultMessage: "Draft",
       description: "Option for form field: status of record",
@@ -4542,7 +5063,7 @@ var statusOptions = [
     }
   },
   {
-    value: EventStatus.NOTIFIED,
+    value: EventStatus.enum.NOTIFIED,
     label: {
       defaultMessage: "Notified",
       description: "Option for form field: status of record",
@@ -4550,7 +5071,7 @@ var statusOptions = [
     }
   },
   {
-    value: EventStatus.DECLARED,
+    value: EventStatus.enum.DECLARED,
     label: {
       defaultMessage: "Declared",
       description: "Option for form field: status of record",
@@ -4558,7 +5079,7 @@ var statusOptions = [
     }
   },
   {
-    value: EventStatus.VALIDATED,
+    value: EventStatus.enum.VALIDATED,
     label: {
       defaultMessage: "Validated",
       description: "Option for form field: status of record",
@@ -4566,7 +5087,7 @@ var statusOptions = [
     }
   },
   {
-    value: EventStatus.REGISTERED,
+    value: EventStatus.enum.REGISTERED,
     label: {
       defaultMessage: "Registered",
       description: "Option for form field: status of record",
@@ -4574,7 +5095,7 @@ var statusOptions = [
     }
   },
   {
-    value: EventStatus.CERTIFIED,
+    value: EventStatus.enum.CERTIFIED,
     label: {
       defaultMessage: "Certified",
       description: "Option for form field: status of record",
@@ -4582,7 +5103,7 @@ var statusOptions = [
     }
   },
   {
-    value: EventStatus.REJECTED,
+    value: EventStatus.enum.REJECTED,
     label: {
       defaultMessage: "Rejected",
       description: "Option for form field: status of record",
@@ -4590,7 +5111,7 @@ var statusOptions = [
     }
   },
   {
-    value: EventStatus.ARCHIVED,
+    value: EventStatus.enum.ARCHIVED,
     label: {
       defaultMessage: "Archived",
       description: "Option for form field: status of record",
@@ -4654,38 +5175,25 @@ var tennisClubMembershipEvent = defineConfig({
     id: "v2.event.tennis-club-membership.label"
   },
   title: {
-    defaultMessage: "{applicant.firstname} {applicant.surname}",
+    defaultMessage: "{applicant.name.firstname} {applicant.name.surname}",
     description: "This is the title of the summary",
     id: "v2.event.tennis-club-membership.title"
   },
   summary: {
     fields: [
       {
-        id: "applicant.firstname",
+        fieldId: "applicant.name",
         label: {
-          defaultMessage: "Applicant's first name",
+          defaultMessage: "Applicant's name",
           description: "This is the label for the field",
           id: "event.tennis-club-membership.summary.field.firstname.label"
         },
-        value: {
-          defaultMessage: "{applicant.firstname}",
-          description: "This is the value to show in the summary",
-          id: "event.tennis-club-membership.summary.field.firstname"
-        },
         emptyValueMessage: {
           defaultMessage: "First name is not provided",
           description: "This is the message to show when the field is empty",
           id: "event.tennis-club-membership.summary.field.firstname.empty"
         }
       },
-      {
-        fieldId: "applicant.surname",
-        label: {
-          defaultMessage: "Applicant's last name",
-          description: "Label for surname",
-          id: "v2.event.tennis-club-membership.summary.field.surname.label"
-        }
-      },
       {
         fieldId: "applicant.email"
       }
@@ -5021,8 +5529,7 @@ var tennisClubMembershipEvent = defineConfig({
         id: "v2.event.tennis-club-membership.search.applicants"
       },
       fields: [
-        field("applicant.firstname").fuzzy(),
-        field("applicant.surname").fuzzy(),
+        field("applicant.name").fuzzy(),
         field("applicant.dob").range(),
         field("applicant.email").exact()
       ]
@@ -5033,10 +5540,7 @@ var tennisClubMembershipEvent = defineConfig({
         description: "Recommender details search field section title",
         id: "v2.event.tennis-club-membership.search.recommender"
       },
-      fields: [
-        field("recommender.firstname").fuzzy(),
-        field("recommender.surname").fuzzy()
-      ]
+      fields: [field("recommender.name").fuzzy()]
     }
   ],
   declaration: TENNIS_CLUB_DECLARATION_FORM
@@ -5051,21 +5555,21 @@ var footballClubMembershipEvent = defineConfig({
     id: "event.football-club-membership.label"
   },
   title: {
-    defaultMessage: "{applicant.firstname} {applicant.surname}",
+    defaultMessage: "{applicant.name.firstname} {applicant.name.surname}",
     description: "This is the title of the summary",
     id: "v2.event.football-club-membership.title"
   },
   summary: {
     fields: [
       {
-        id: "applicant.firstname",
+        id: "applicant.name.firstname",
         label: {
           defaultMessage: "Applicant's first name",
           description: "This is the label for the field",
           id: "event.football-club-membership.summary.field.firstname.label"
         },
         value: {
-          defaultMessage: "{applicant.firstname}",
+          defaultMessage: "{applicant.name.firstname}",
           description: "This is the value to show in the summary",
           id: "event.football-club-membership.summary.field.firstname"
         },
@@ -5076,7 +5580,7 @@ var footballClubMembershipEvent = defineConfig({
         }
       },
       {
-        fieldId: "applicant.surname",
+        fieldId: "applicant.name.surname",
         label: {
           defaultMessage: "Applicant's last name",
           description: "Label for surname",
@@ -5418,8 +5922,7 @@ var footballClubMembershipEvent = defineConfig({
         id: "v2.event.football-club-membership.search.applicants"
       },
       fields: [
-        field("applicant.firstname").fuzzy(),
-        field("applicant.surname").fuzzy(),
+        field("applicant.name").fuzzy(),
         field("applicant.dob").range(),
         field("applicant.email").exact()
       ]
@@ -5430,10 +5933,7 @@ var footballClubMembershipEvent = defineConfig({
         description: "Recommender details search field section title",
         id: "v2.event.football-club-membership.search.recommender"
       },
-      fields: [
-        field("recommender.firstname").fuzzy(),
-        field("recommender.surname").fuzzy()
-      ]
+      fields: [field("recommender.name").fuzzy()]
     }
   ],
   declaration: TENNIS_CLUB_DECLARATION_FORM
@@ -5498,33 +5998,261 @@ var libraryMembershipEvent = defineConfig({
   declaration: libraryMembershipForm
 });
 
+// ../commons/src/fixtures/v2-birth-event.ts
+var child = defineFormPage({
+  id: "child",
+  type: PageTypes.enum.FORM,
+  title: {
+    defaultMessage: "Child's details",
+    description: "Form section title for Child",
+    id: "v2.form.birth.child.title"
+  },
+  fields: [
+    {
+      id: "child.firstNames",
+      type: FieldType.TEXT,
+      required: true,
+      configuration: { maxLength: 32 },
+      hideLabel: true,
+      label: {
+        defaultMessage: "Child's  first name",
+        description: "This is the label for the field",
+        id: "v2.event.birth.action.declare.form.section.child.field.name.label"
+      }
+    },
+    {
+      id: "child.familyName",
+      type: FieldType.TEXT,
+      required: true,
+      configuration: { maxLength: 32 },
+      hideLabel: true,
+      label: {
+        defaultMessage: "Child's last name",
+        description: "This is the label for the field",
+        id: "v2.event.birth.action.declare.form.section.child.field.name.label"
+      }
+    },
+    {
+      id: "child.DoB",
+      type: "DATE",
+      required: true,
+      label: {
+        defaultMessage: "Date of birth",
+        description: "This is the label for the field",
+        id: "v2.event.birth.action.declare.form.section.child.field.dob.label"
+      }
+    }
+  ]
+});
+var mother = defineFormPage({
+  id: "mother",
+  type: PageTypes.enum.FORM,
+  title: {
+    defaultMessage: "Mother's details",
+    description: "Form section title for mothers details",
+    id: "v2.form.section.mother.title"
+  },
+  fields: [
+    {
+      id: "mother.firstNames",
+      configuration: { maxLength: 32 },
+      type: FieldType.TEXT,
+      required: true,
+      label: {
+        defaultMessage: "First name(s)",
+        description: "This is the label for the field",
+        id: `v2.event.birth.action.declare.form.section.person.field.firstname.label`
+      }
+    },
+    {
+      id: `mother.familyName`,
+      configuration: { maxLength: 32 },
+      type: FieldType.TEXT,
+      required: true,
+      label: {
+        defaultMessage: "Last name",
+        description: "This is the label for the field",
+        id: `v2.event.birth.action.declare.form.section.person.field.surname.label`
+      }
+    },
+    {
+      id: `mother.DoB`,
+      type: "DATE",
+      required: true,
+      label: {
+        defaultMessage: "Date of birth",
+        description: "This is the label for the field",
+        id: `v2.event.birth.action.declare.form.section.person.field.dob.label`
+      }
+    },
+    {
+      id: "mother.identifier",
+      type: FieldType.ID,
+      required: true,
+      label: {
+        defaultMessage: "ID Number",
+        description: "This is the label for the field",
+        id: `v2.event.birth.action.declare.form.section.person.field.nid.label`
+      }
+    }
+  ]
+});
+var BIRTH_DECLARATION_FORM = defineDeclarationForm({
+  label: {
+    defaultMessage: "Birth decalration form",
+    id: "v2.event.birth.action.declare.form.label",
+    description: "This is what this form is referred as in the system"
+  },
+  pages: [child, mother]
+});
+var v2BirthEvent = defineConfig({
+  id: BIRTH_EVENT,
+  title: {
+    defaultMessage: "{child.name.firstname} {child.name.surname}",
+    description: "This is the title of the summary",
+    id: "v2.event.birth.title"
+  },
+  label: {
+    defaultMessage: "Birth",
+    description: "This is what this event is referred as in the system",
+    id: "v2.event.birth.label"
+  },
+  summary: {
+    fields: []
+  },
+  actions: [],
+  declaration: BIRTH_DECLARATION_FORM
+});
+
 // ../commons/src/events/test.utils.ts
-function fieldConfigsToActionPayload(fields) {
+var import_zod33 = require("zod");
+var TestUserRole = import_zod33.z.enum([
+  "FIELD_AGENT",
+  "LOCAL_REGISTRAR",
+  "LOCAL_SYSTEM_ADMIN",
+  "NATIONAL_REGISTRAR",
+  "REGISTRATION_AGENT"
+]);
+function pickRandom(rng, items) {
+  return items[Math.floor(rng() * items.length)];
+}
+function generateRandomName(rng) {
+  const firstnames = [
+    "Danny",
+    "John",
+    "Jane",
+    "Emily",
+    "Michael",
+    "Sarah",
+    "Chris",
+    "Jessica",
+    "Sara",
+    "Sarachella",
+    "Sarandera",
+    "Zara"
+  ];
+  const surnames = [
+    "Doe",
+    "Smith",
+    "Johnson",
+    "Brown",
+    "Williams",
+    "Jones",
+    "Garcia",
+    "Miller",
+    "Saranen",
+    "Sarajanen",
+    "Sarthua",
+    "Tsarakovski",
+    "Salamander",
+    "Zarathustra"
+  ];
+  return {
+    firstname: pickRandom(rng, firstnames),
+    surname: pickRandom(rng, surnames)
+  };
+}
+function mapFieldTypeToMockValue(field2, i, rng) {
+  switch (field2.type) {
+    case FieldType.DIVIDER:
+    case FieldType.TEXT:
+    case FieldType.TEXTAREA:
+    case FieldType.BULLET_LIST:
+    case FieldType.PAGE_HEADER:
+    case FieldType.LOCATION:
+    case FieldType.SELECT:
+    case FieldType.COUNTRY:
+    case FieldType.RADIO_GROUP:
+    case FieldType.PARAGRAPH:
+    case FieldType.ADMINISTRATIVE_AREA:
+    case FieldType.FACILITY:
+    case FieldType.PHONE:
+    case FieldType.ID:
+    case FieldType.OFFICE:
+      return `${field2.id}-${field2.type}-${i}`;
+    case FieldType.NAME:
+      return generateRandomName(rng);
+    case FieldType.NUMBER:
+      return 19;
+    case FieldType.EMAIL:
+      return "test@opencrvs.org";
+    case FieldType.ADDRESS:
+      return {
+        country: "FAR",
+        addressType: AddressType.DOMESTIC,
+        province: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
+        district: "5ef450bc-712d-48ad-93f3-8da0fa453baa",
+        urbanOrRural: "URBAN",
+        town: "Example Town",
+        residentialArea: "Example Residential Area",
+        street: "Example Street",
+        number: "55",
+        zipCode: "123456"
+      };
+    case FieldType.DATE:
+      return "2021-01-01";
+    case FieldType.DATE_RANGE:
+      return ["2021-01-01", "2021-01-02"];
+    case FieldType.CHECKBOX:
+      return true;
+    case FieldType.SIGNATURE:
+    case FieldType.FILE:
+      return {
+        filename: "4f095fc4-4312-4de2-aa38-86dcc0f71044.png",
+        originalFilename: "abcd.png",
+        type: "image/png"
+      };
+    case FieldType.FILE_WITH_OPTIONS:
+    case FieldType.DATA:
+      return void 0;
+  }
+}
+function fieldConfigsToActionPayload(fields, rng) {
   return fields.reduce(
     (acc, field2, i) => ({
       ...acc,
-      [field2.id]: mapFieldTypeToMockValue(field2, i)
+      [field2.id]: mapFieldTypeToMockValue(field2, i, rng)
     }),
     {}
   );
 }
-function generateActionDeclarationInput(configuration, action) {
+function generateActionDeclarationInput(configuration, action, rng) {
   const parsed = DeclarationUpdateActions.safeParse(action);
   if (parsed.success) {
     const fields = getDeclarationFields(configuration);
     const declarationConfig = getDeclaration(configuration);
-    const declaration = fieldConfigsToActionPayload(fields);
+    const declaration = fieldConfigsToActionPayload(fields, rng);
     return omitHiddenPaginatedFields(declarationConfig, declaration);
   }
   console.warn(`${action} is not a declaration action. Setting data as {}.`);
   return {};
 }
-function generateActionAnnotationInput(configuration, action) {
+function generateActionAnnotationInput(configuration, action, rng) {
   const actionConfig = configuration.actions.find(
     (ac) => ac.type === action
   );
   const annotationFields = actionConfig ? getActionAnnotationFields(actionConfig) : [];
-  const annotation = fieldConfigsToActionPayload(annotationFields);
+  const annotation = fieldConfigsToActionPayload(annotationFields, rng);
   const visibleVerificationPageIds = getVisibleVerificationPageIds(
     findRecordActionPages(configuration, action),
     annotation
@@ -5542,198 +6270,227 @@ function generateActionAnnotationInput(configuration, action) {
     ...visiblePageVerificationMap
   };
 }
-var eventPayloadGenerator = {
-  create: (input = {}) => ({
-    transactionId: input.transactionId ?? getUUID(),
-    type: input.type ?? TENNIS_CLUB_MEMBERSHIP
-  }),
-  patch: (id, input = {}) => ({
-    transactionId: input.transactionId ?? getUUID(),
-    type: input.type ?? TENNIS_CLUB_MEMBERSHIP,
-    id
-  }),
-  draft: ({ eventId, actionType }, input = {}) => (0, import_lodash2.merge)(
-    {
-      id: getUUID(),
-      eventId,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      transactionId: getUUID(),
-      action: {
-        transactionId: getUUID(),
-        type: actionType,
-        status: ActionStatus.Accepted,
-        declaration: {
-          "applicant.firstname": "Max",
-          "applicant.surname": "McLaren",
-          "applicant.dob": "2020-01-02",
-          "recommender.none": true
-        },
-        annotation: {
-          "correction.requester.relationship": "ANOTHER_AGENT",
-          "correction.request.reason": "Child's name was incorrect"
-        },
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        createdBy: "@todo",
-        createdByRole: "@todo",
-        createdAtLocation: "@todo"
-      }
-    },
-    input
-  ),
-  actions: {
-    declare: (eventId, input = {}) => ({
-      type: ActionType.DECLARE,
-      transactionId: input.transactionId ?? getUUID(),
-      declaration: input.declaration ?? generateActionDeclarationInput(
-        tennisClubMembershipEvent,
-        ActionType.DECLARE
-      ),
-      annotation: input.annotation ?? generateActionAnnotationInput(
-        tennisClubMembershipEvent,
-        ActionType.DECLARE
-      ),
-      eventId
-    }),
-    /**
-     * Notify allows sending incomplete data. Think it as 'partial declare' for now.
-     */
-    notify: (eventId, input = {}) => {
-      let declaration = input.declaration;
-      if (!declaration) {
-        const partialDeclaration = (0, import_lodash2.omitBy)(
-          generateActionDeclarationInput(
-            tennisClubMembershipEvent,
-            ActionType.DECLARE
-          ),
-          import_lodash2.isString
-        );
-        declaration = partialDeclaration;
-      }
-      return {
-        type: ActionType.NOTIFY,
-        transactionId: input.transactionId ?? getUUID(),
-        declaration,
-        eventId
-      };
-    },
-    validate: (eventId, input = {}) => ({
-      type: ActionType.VALIDATE,
-      transactionId: input.transactionId ?? getUUID(),
-      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(),
-      declaration: {},
-      // @TODO: Check whether generator is needed?
-      annotation: {},
-      duplicates: [],
-      eventId,
-      reason: {
-        message: `${ActionType.ARCHIVE}`,
-        isDuplicate: isDuplicate ?? false
-      }
-    }),
-    reject: (eventId, input = {}) => ({
-      type: ActionType.REJECT,
-      transactionId: input.transactionId ?? getUUID(),
-      declaration: {},
-      annotation: input.annotation ?? generateActionAnnotationInput(
-        tennisClubMembershipEvent,
-        ActionType.REJECT
-      ),
-      duplicates: [],
-      eventId,
-      reason: { message: `${ActionType.REJECT}` }
-    }),
-    register: (eventId, input = {}) => ({
-      type: ActionType.REGISTER,
+function eventPayloadGenerator(rng) {
+  return {
+    create: (input = {}) => ({
       transactionId: input.transactionId ?? getUUID(),
-      declaration: input.declaration ?? generateActionDeclarationInput(
-        tennisClubMembershipEvent,
-        ActionType.REGISTER
-      ),
-      annotation: input.annotation ?? generateActionAnnotationInput(
-        tennisClubMembershipEvent,
-        ActionType.REGISTER
-      ),
-      eventId
+      type: input.type ?? TENNIS_CLUB_MEMBERSHIP
     }),
-    printCertificate: (eventId, input = {}) => ({
-      type: ActionType.PRINT_CERTIFICATE,
+    patch: (id, input = {}) => ({
       transactionId: input.transactionId ?? getUUID(),
-      declaration: {},
-      annotation: input.annotation ?? generateActionAnnotationInput(
-        tennisClubMembershipEvent,
-        ActionType.PRINT_CERTIFICATE
-      ),
-      eventId
+      type: input.type ?? TENNIS_CLUB_MEMBERSHIP,
+      id
     }),
-    correction: {
-      request: (eventId, input = {}) => ({
-        type: ActionType.REQUEST_CORRECTION,
+    draft: ({ eventId, actionType }, input = {}) => (0, import_lodash2.merge)(
+      {
+        id: getUUID(),
+        eventId,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        transactionId: getUUID(),
+        action: {
+          transactionId: getUUID(),
+          type: actionType,
+          status: ActionStatus.Accepted,
+          declaration: {
+            "applicant.name": {
+              firstname: "Max",
+              surname: "McLaren"
+            },
+            "applicant.dob": "2020-01-02",
+            "recommender.none": true
+          },
+          annotation: {
+            "correction.requester.relationship": "ANOTHER_AGENT",
+            "correction.request.reason": "Child's name was incorrect"
+          },
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          createdBy: "@todo",
+          createdByUserType: TokenUserType.Enum.user,
+          createdByRole: "@todo",
+          createdAtLocation: "@todo"
+        }
+      },
+      input
+    ),
+    actions: {
+      declare: (eventId, input = {}) => ({
+        type: ActionType.DECLARE,
         transactionId: input.transactionId ?? getUUID(),
         declaration: input.declaration ?? generateActionDeclarationInput(
           tennisClubMembershipEvent,
-          ActionType.REQUEST_CORRECTION
+          ActionType.DECLARE,
+          rng
         ),
         annotation: input.annotation ?? generateActionAnnotationInput(
           tennisClubMembershipEvent,
-          ActionType.REQUEST_CORRECTION
+          ActionType.DECLARE,
+          rng
         ),
+        eventId,
+        ...input
+      }),
+      /**
+       * Notify allows sending incomplete data. Think it as 'partial declare' for now.
+       */
+      notify: (eventId, input = {}) => {
+        let declaration = input.declaration;
+        if (!declaration) {
+          const partialDeclaration = (0, import_lodash2.omitBy)(
+            generateActionDeclarationInput(
+              tennisClubMembershipEvent,
+              ActionType.DECLARE,
+              rng
+            ),
+            import_lodash2.isString
+          );
+          declaration = partialDeclaration;
+        }
+        return {
+          type: ActionType.NOTIFY,
+          transactionId: input.transactionId ?? getUUID(),
+          declaration,
+          eventId,
+          keepAssignment: input.keepAssignment
+        };
+      },
+      validate: (eventId, input = {}) => ({
+        type: ActionType.VALIDATE,
+        transactionId: input.transactionId ?? getUUID(),
+        declaration: input.declaration ?? generateActionDeclarationInput(
+          tennisClubMembershipEvent,
+          ActionType.VALIDATE,
+          rng
+        ),
+        annotation: input.annotation ?? generateActionAnnotationInput(
+          tennisClubMembershipEvent,
+          ActionType.VALIDATE,
+          rng
+        ),
+        duplicates: [],
+        eventId,
+        ...input
+      }),
+      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
       }),
-      approve: (eventId, requestId, input = {}) => ({
-        type: ActionType.APPROVE_CORRECTION,
+      archive: (eventId, input = {}, isDuplicate) => ({
+        type: ActionType.ARCHIVE,
+        transactionId: input.transactionId ?? getUUID(),
+        declaration: {},
+        // @TODO: Check whether generator is needed?
+        annotation: {},
+        duplicates: [],
+        eventId,
+        reason: {
+          message: `${ActionType.ARCHIVE}`,
+          isDuplicate: isDuplicate ?? false
+        },
+        ...input
+      }),
+      reject: (eventId, input = {}) => ({
+        type: ActionType.REJECT,
         transactionId: input.transactionId ?? getUUID(),
         declaration: {},
         annotation: input.annotation ?? generateActionAnnotationInput(
           tennisClubMembershipEvent,
-          ActionType.APPROVE_CORRECTION
+          ActionType.REJECT,
+          rng
         ),
+        duplicates: [],
         eventId,
-        requestId
+        reason: { message: `${ActionType.REJECT}` },
+        ...input
       }),
-      reject: (eventId, requestId, input = {}) => ({
-        type: ActionType.REJECT_CORRECTION,
+      register: (eventId, input = {}) => ({
+        type: ActionType.REGISTER,
+        transactionId: input.transactionId ?? getUUID(),
+        declaration: input.declaration ?? generateActionDeclarationInput(
+          tennisClubMembershipEvent,
+          ActionType.REGISTER,
+          rng
+        ),
+        annotation: input.annotation ?? generateActionAnnotationInput(
+          tennisClubMembershipEvent,
+          ActionType.REGISTER,
+          rng
+        ),
+        eventId,
+        ...input
+      }),
+      printCertificate: (eventId, input = {}) => ({
+        type: ActionType.PRINT_CERTIFICATE,
         transactionId: input.transactionId ?? getUUID(),
         declaration: {},
         annotation: input.annotation ?? generateActionAnnotationInput(
           tennisClubMembershipEvent,
-          ActionType.REJECT_CORRECTION
+          ActionType.PRINT_CERTIFICATE,
+          rng
         ),
         eventId,
-        requestId
-      })
+        ...input
+      }),
+      correction: {
+        request: (eventId, input = {}) => ({
+          type: ActionType.REQUEST_CORRECTION,
+          transactionId: input.transactionId ?? getUUID(),
+          declaration: input.declaration ?? generateActionDeclarationInput(
+            tennisClubMembershipEvent,
+            ActionType.REQUEST_CORRECTION,
+            rng
+          ),
+          annotation: input.annotation ?? generateActionAnnotationInput(
+            tennisClubMembershipEvent,
+            ActionType.REQUEST_CORRECTION,
+            rng
+          ),
+          eventId,
+          keepAssignment: input.keepAssignment
+        }),
+        approve: (eventId, requestId, input = {}) => ({
+          type: ActionType.APPROVE_CORRECTION,
+          transactionId: input.transactionId ?? getUUID(),
+          declaration: {},
+          annotation: input.annotation ?? generateActionAnnotationInput(
+            tennisClubMembershipEvent,
+            ActionType.APPROVE_CORRECTION,
+            rng
+          ),
+          eventId,
+          requestId,
+          keepAssignment: input.keepAssignment
+        }),
+        reject: (eventId, requestId, input = {}) => ({
+          type: ActionType.REJECT_CORRECTION,
+          transactionId: input.transactionId ?? getUUID(),
+          declaration: {},
+          annotation: input.annotation ?? generateActionAnnotationInput(
+            tennisClubMembershipEvent,
+            ActionType.REJECT_CORRECTION,
+            rng
+          ),
+          eventId,
+          requestId,
+          keepAssignment: input.keepAssignment
+        })
+      }
     }
-  }
-};
+  };
+}
 function generateActionDocument({
   configuration,
   action,
+  rng = () => 0.1,
   defaults = {}
 }) {
   const actionBase = {
@@ -5741,10 +6498,11 @@ function generateActionDocument({
     // @TODO: This should be fixed in the future.
     createdAt: new Date(Date.now() - 500).toISOString(),
     createdBy: getUUID(),
-    createdByRole: "FIELD_AGENT",
+    createdByUserType: TokenUserType.Enum.user,
+    createdByRole: TestUserRole.Enum.FIELD_AGENT,
     id: getUUID(),
     createdAtLocation: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
-    declaration: generateActionDeclarationInput(configuration, action),
+    declaration: generateActionDeclarationInput(configuration, action, rng),
     annotation: {},
     status: ActionStatus.Accepted,
     transactionId: getUUID(),
@@ -5796,13 +6554,14 @@ function generateActionDocument({
 }
 function generateEventDocument({
   configuration,
-  actions
+  actions,
+  rng = () => 0.1
 }) {
   return {
     trackingId: getUUID(),
     type: configuration.id,
     actions: actions.map(
-      (action) => generateActionDocument({ configuration, action })
+      (action) => generateActionDocument({ configuration, action, rng })
     ),
     // 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.
@@ -5813,10 +6572,16 @@ function generateEventDocument({
     updatedAt: new Date(Date.now() - 1e3).toISOString()
   };
 }
-function generateEventDraftDocument(eventId, actionType = ActionType.DECLARE, declaration = {}) {
+function generateEventDraftDocument({
+  eventId,
+  actionType,
+  rng = () => 0.1,
+  declaration = {}
+}) {
   const action = generateActionDocument({
     configuration: tennisClubMembershipEvent,
-    action: actionType
+    action: actionType,
+    rng
   });
   return {
     id: getUUID(),
@@ -5832,51 +6597,29 @@ function generateEventDraftDocument(eventId, actionType = ActionType.DECLARE, de
     eventId
   };
 }
-function pickRandom(rng, items) {
-  return items[Math.floor(rng() * items.length)];
-}
 function getRandomDatetime(rng, start, end) {
   const range = end.getTime() - start.getTime();
   const offset = Math.floor(rng() * range);
   const randomDate = new Date(start.getTime() + offset);
   return randomDate.toISOString();
 }
+function getRandomDate(rng, start, end) {
+  const datetime = getRandomDatetime(rng, new Date(start), new Date(end));
+  return datetime.split("T")[0];
+}
 function generateRandomApplicant(rng) {
-  const firstNames = [
-    "Danny",
-    "John",
-    "Jane",
-    "Emily",
-    "Michael",
-    "Sarah",
-    "Chris",
-    "Jessica"
-  ];
-  const surnames = [
-    "Doe",
-    "Smith",
-    "Johnson",
-    "Brown",
-    "Williams",
-    "Jones",
-    "Garcia",
-    "Miller"
-  ];
-  const randomFirstName = pickRandom(rng, firstNames);
-  const randomSurname = pickRandom(rng, surnames);
-  const randomDob = getRandomDatetime(
-    rng,
-    /* @__PURE__ */ new Date("1990-01-01"),
-    /* @__PURE__ */ new Date("2010-12-31")
-  ).split("T")[0];
+  const { firstname, surname } = generateRandomName(rng);
+  const randomDob = getRandomDate(rng, "1990-01-01", "2010-12-31");
   return {
     "recommender.none": true,
-    "applicant.firstname": randomFirstName,
-    "applicant.surname": randomSurname,
+    "applicant.name": {
+      firstname,
+      surname
+    },
     "applicant.dob": randomDob
   };
 }
-function createPseudoRandomNumberGenerator(seed) {
+function createPrng(seed) {
   const MODULUS = 2 ** 32;
   const MULTIPLIER = 1664525;
   const INCREMENT = 1013904223;
@@ -5902,7 +6645,7 @@ function generateRandomSignature(rng) {
   return `/random-bucket/${generateUuid(rng)}.png`;
 }
 var eventQueryDataGenerator = (overrides = {}, seed = 1) => {
-  const rng = createPseudoRandomNumberGenerator(seed);
+  const rng = createPrng(seed);
   const createdAt = getRandomDatetime(
     rng,
     /* @__PURE__ */ new Date("2024-01-01"),
@@ -5911,8 +6654,9 @@ var eventQueryDataGenerator = (overrides = {}, seed = 1) => {
   return {
     id: overrides.id ?? generateUuid(rng),
     type: overrides.type ?? TENNIS_CLUB_MEMBERSHIP,
-    status: overrides.status ?? pickRandom(rng, eventStatuses),
+    status: overrides.status ?? pickRandom(rng, EventStatus.options),
     createdAt: overrides.createdAt ?? createdAt,
+    createdByUserType: overrides.createdByUserType ?? "user",
     createdBy: overrides.createdBy ?? generateUuid(rng),
     createdAtLocation: overrides.createdAtLocation ?? generateUuid(rng),
     updatedAtLocation: overrides.updatedAtLocation ?? generateUuid(rng),
@@ -5965,7 +6709,9 @@ function isFieldValueWithoutTemplates(value) {
   if (isTemplateVariable(value)) {
     return false;
   }
-  if (typeof value === "object" && Object.values(value).some((val) => isTemplateVariable(val))) {
+  if (typeof value === "object" && // @todo remove ts-ignore
+  //@ts-ignore
+  Object.values(value).some((val) => isTemplateVariable(val))) {
     return false;
   }
   return true;
@@ -5988,234 +6734,6 @@ function isFieldConfigDefaultValue(value) {
 
 // ../commons/src/events/scopes.ts
 var import_lodash3 = require("lodash");
-
-// ../commons/src/scopes.ts
-var import_zod31 = require("zod");
-var SCOPES = {
-  // TODO v1.8 legacy scopes
-  NATLSYSADMIN: "natlsysadmin",
-  BYPASSRATELIMIT: "bypassratelimit",
-  DECLARE: "declare",
-  REGISTER: "register",
-  VALIDATE: "validate",
-  DEMO: "demo",
-  CERTIFY: "certify",
-  PERFORMANCE: "performance",
-  SYSADMIN: "sysadmin",
-  TEAMS: "teams",
-  CONFIG: "config",
-  // systems / integrations
-  WEBHOOK: "webhook",
-  NATIONALID: "nationalId",
-  NOTIFICATION_API: "notification-api",
-  RECORDSEARCH: "recordsearch",
-  /**
-   * @TODO This is a temporary scope to be used for V2 Events custom events declaration
-   */
-  RECORD_DECLARE: "record.declare-birth",
-  // declare
-  RECORD_IMPORT: "record.import",
-  // declare
-  RECORD_DECLARE_BIRTH: "record.declare-birth",
-  RECORD_DECLARE_BIRTH_MY_JURISDICTION: "record.declare-birth:my-jurisdiction",
-  RECORD_DECLARE_DEATH: "record.declare-death",
-  RECORD_DECLARE_DEATH_MY_JURISDICTION: "record.declare-death:my-jurisdiction",
-  RECORD_DECLARE_MARRIAGE: "record.declare-marriage",
-  RECORD_DECLARE_MARRIAGE_MY_JURISDICTION: "record.declare-marriage:my-jurisdiction",
-  RECORD_SUBMIT_INCOMPLETE: "record.declaration-submit-incomplete",
-  RECORD_SUBMIT_FOR_REVIEW: "record.declaration-submit-for-review",
-  RECORD_UNASSIGN_OTHERS: "record.unassign-others",
-  // validate
-  RECORD_SUBMIT_FOR_APPROVAL: "record.declaration-submit-for-approval",
-  RECORD_SUBMIT_FOR_UPDATES: "record.declaration-submit-for-updates",
-  RECORD_DECLARATION_EDIT: "record.declaration-edit",
-  RECORD_REVIEW_DUPLICATES: "record.review-duplicates",
-  RECORD_DECLARATION_ARCHIVE: "record.declaration-archive",
-  RECORD_DECLARATION_REINSTATE: "record.declaration-reinstate",
-  // register
-  RECORD_REGISTER: "record.register",
-  // certify
-  RECORD_EXPORT_RECORDS: "record.export-records",
-  RECORD_DECLARATION_PRINT: "record.declaration-print",
-  RECORD_PRINT_RECORDS_SUPPORTING_DOCUMENTS: "record.declaration-print-supporting-documents",
-  RECORD_REGISTRATION_PRINT: "record.registration-print",
-  // v1.8
-  /**
-   * This scope is used to **print and **issue certified copies of a record
-   * after it has been registered. Previously Registrars had this permission.
-   */
-  RECORD_PRINT_ISSUE_CERTIFIED_COPIES: "record.registration-print&issue-certified-copies",
-  RECORD_PRINT_CERTIFIED_COPIES: "record.registration-print-certified-copies",
-  // v1.8
-  RECORD_BULK_PRINT_CERTIFIED_COPIES: "record.registration-bulk-print-certified-copies",
-  // v1.8
-  RECORD_REGISTRATION_VERIFY_CERTIFIED_COPIES: "record.registration-verify-certified-copies",
-  // v1.8
-  // correct
-  RECORD_REGISTRATION_REQUEST_CORRECTION: "record.registration-request-correction",
-  RECORD_REGISTRATION_CORRECT: "record.registration-correct",
-  RECORD_REGISTRATION_REQUEST_REVOCATION: "record.registration-request-revocation",
-  // v1.8
-  RECORD_REGISTRATION_REVOKE: "record.registration-revoke",
-  // v1.8
-  RECORD_REGISTRATION_REQUEST_REINSTATEMENT: "record.registration-request-reinstatement",
-  // v1.8
-  RECORD_REGISTRATION_REINSTATE: "record.registration-reinstate",
-  // v1.8
-  RECORD_CONFIRM_REGISTRATION: "record.confirm-registration",
-  RECORD_REJECT_REGISTRATION: "record.reject-registration",
-  // search
-  SEARCH_BIRTH_MY_JURISDICTION: "search.birth:my-jurisdiction",
-  SEARCH_BIRTH: "search.birth",
-  SEARCH_DEATH_MY_JURISDICTION: "search.death:my-jurisdiction",
-  SEARCH_DEATH: "search.death",
-  SEARCH_MARRIAGE_MY_JURISDICTION: "search.marriage:my-jurisdiction",
-  SEARCH_MARRIAGE: "search.marriage",
-  // audit v1.8
-  RECORD_READ: "record.read",
-  RECORD_READ_AUDIT: "record.read-audit",
-  RECORD_READ_COMMENTS: "record.read-comments",
-  RECORD_CREATE_COMMENTS: "record.create-comments",
-  // profile
-  PROFILE_UPDATE: "profile.update",
-  //v1.8
-  PROFILE_ELECTRONIC_SIGNATURE: "profile.electronic-signature",
-  // performance
-  PERFORMANCE_READ: "performance.read",
-  PERFORMANCE_READ_DASHBOARDS: "performance.read-dashboards",
-  PERFORMANCE_EXPORT_VITAL_STATISTICS: "performance.vital-statistics-export",
-  // organisation
-  ORGANISATION_READ_LOCATIONS: "organisation.read-locations:all",
-  ORGANISATION_READ_LOCATIONS_MY_OFFICE: "organisation.read-locations:my-office",
-  ORGANISATION_READ_LOCATIONS_MY_JURISDICTION: "organisation.read-locations:my-jurisdiction",
-  // user
-  USER_READ: "user.read:all",
-  USER_READ_MY_OFFICE: "user.read:my-office",
-  USER_READ_MY_JURISDICTION: "user.read:my-jurisdiction",
-  USER_READ_ONLY_MY_AUDIT: "user.read:only-my-audit",
-  //v1.8
-  USER_CREATE: "user.create:all",
-  USER_CREATE_MY_JURISDICTION: "user.create:my-jurisdiction",
-  USER_UPDATE: "user.update:all",
-  USER_UPDATE_MY_JURISDICTION: "user.update:my-jurisdiction",
-  // config
-  CONFIG_UPDATE_ALL: "config.update:all",
-  // data seeding
-  USER_DATA_SEEDING: "user.data-seeding"
-};
-var LiteralScopes = import_zod31.z.union([
-  import_zod31.z.literal(SCOPES.NATLSYSADMIN),
-  import_zod31.z.literal(SCOPES.BYPASSRATELIMIT),
-  import_zod31.z.literal(SCOPES.DECLARE),
-  import_zod31.z.literal(SCOPES.REGISTER),
-  import_zod31.z.literal(SCOPES.VALIDATE),
-  import_zod31.z.literal(SCOPES.DEMO),
-  import_zod31.z.literal(SCOPES.CERTIFY),
-  import_zod31.z.literal(SCOPES.PERFORMANCE),
-  import_zod31.z.literal(SCOPES.SYSADMIN),
-  import_zod31.z.literal(SCOPES.TEAMS),
-  import_zod31.z.literal(SCOPES.CONFIG),
-  import_zod31.z.literal(SCOPES.WEBHOOK),
-  import_zod31.z.literal(SCOPES.NATIONALID),
-  import_zod31.z.literal(SCOPES.NOTIFICATION_API),
-  import_zod31.z.literal(SCOPES.RECORDSEARCH),
-  import_zod31.z.literal(SCOPES.RECORD_IMPORT),
-  import_zod31.z.literal(SCOPES.RECORD_DECLARE_BIRTH),
-  import_zod31.z.literal(SCOPES.RECORD_DECLARE_BIRTH_MY_JURISDICTION),
-  import_zod31.z.literal(SCOPES.RECORD_DECLARE_DEATH),
-  import_zod31.z.literal(SCOPES.RECORD_DECLARE_DEATH_MY_JURISDICTION),
-  import_zod31.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE),
-  import_zod31.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE_MY_JURISDICTION),
-  import_zod31.z.literal(SCOPES.RECORD_SUBMIT_INCOMPLETE),
-  import_zod31.z.literal(SCOPES.RECORD_SUBMIT_FOR_REVIEW),
-  import_zod31.z.literal(SCOPES.RECORD_UNASSIGN_OTHERS),
-  import_zod31.z.literal(SCOPES.RECORD_SUBMIT_FOR_APPROVAL),
-  import_zod31.z.literal(SCOPES.RECORD_SUBMIT_FOR_UPDATES),
-  import_zod31.z.literal(SCOPES.RECORD_DECLARATION_EDIT),
-  import_zod31.z.literal(SCOPES.RECORD_REVIEW_DUPLICATES),
-  import_zod31.z.literal(SCOPES.RECORD_DECLARATION_ARCHIVE),
-  import_zod31.z.literal(SCOPES.RECORD_DECLARATION_REINSTATE),
-  import_zod31.z.literal(SCOPES.RECORD_REGISTER),
-  import_zod31.z.literal(SCOPES.RECORD_EXPORT_RECORDS),
-  import_zod31.z.literal(SCOPES.RECORD_DECLARATION_PRINT),
-  import_zod31.z.literal(SCOPES.RECORD_PRINT_RECORDS_SUPPORTING_DOCUMENTS),
-  import_zod31.z.literal(SCOPES.RECORD_REGISTRATION_PRINT),
-  import_zod31.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
-  import_zod31.z.literal(SCOPES.RECORD_PRINT_CERTIFIED_COPIES),
-  import_zod31.z.literal(SCOPES.RECORD_BULK_PRINT_CERTIFIED_COPIES),
-  import_zod31.z.literal(SCOPES.RECORD_REGISTRATION_VERIFY_CERTIFIED_COPIES),
-  import_zod31.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_CORRECTION),
-  import_zod31.z.literal(SCOPES.RECORD_REGISTRATION_CORRECT),
-  import_zod31.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_REVOCATION),
-  import_zod31.z.literal(SCOPES.RECORD_REGISTRATION_REVOKE),
-  import_zod31.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_REINSTATEMENT),
-  import_zod31.z.literal(SCOPES.RECORD_REGISTRATION_REINSTATE),
-  import_zod31.z.literal(SCOPES.RECORD_CONFIRM_REGISTRATION),
-  import_zod31.z.literal(SCOPES.RECORD_REJECT_REGISTRATION),
-  import_zod31.z.literal(SCOPES.SEARCH_BIRTH_MY_JURISDICTION),
-  import_zod31.z.literal(SCOPES.SEARCH_BIRTH),
-  import_zod31.z.literal(SCOPES.SEARCH_DEATH_MY_JURISDICTION),
-  import_zod31.z.literal(SCOPES.SEARCH_DEATH),
-  import_zod31.z.literal(SCOPES.SEARCH_MARRIAGE_MY_JURISDICTION),
-  import_zod31.z.literal(SCOPES.SEARCH_MARRIAGE),
-  import_zod31.z.literal(SCOPES.RECORD_READ),
-  import_zod31.z.literal(SCOPES.RECORD_READ_AUDIT),
-  import_zod31.z.literal(SCOPES.RECORD_READ_COMMENTS),
-  import_zod31.z.literal(SCOPES.RECORD_CREATE_COMMENTS),
-  import_zod31.z.literal(SCOPES.PROFILE_UPDATE),
-  import_zod31.z.literal(SCOPES.PROFILE_ELECTRONIC_SIGNATURE),
-  import_zod31.z.literal(SCOPES.PERFORMANCE_READ),
-  import_zod31.z.literal(SCOPES.PERFORMANCE_READ_DASHBOARDS),
-  import_zod31.z.literal(SCOPES.PERFORMANCE_EXPORT_VITAL_STATISTICS),
-  import_zod31.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS),
-  import_zod31.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_OFFICE),
-  import_zod31.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_JURISDICTION),
-  import_zod31.z.literal(SCOPES.USER_READ),
-  import_zod31.z.literal(SCOPES.USER_READ_MY_OFFICE),
-  import_zod31.z.literal(SCOPES.USER_READ_MY_JURISDICTION),
-  import_zod31.z.literal(SCOPES.USER_READ_ONLY_MY_AUDIT),
-  import_zod31.z.literal(SCOPES.USER_CREATE),
-  import_zod31.z.literal(SCOPES.USER_CREATE_MY_JURISDICTION),
-  import_zod31.z.literal(SCOPES.USER_UPDATE),
-  import_zod31.z.literal(SCOPES.USER_UPDATE_MY_JURISDICTION),
-  import_zod31.z.literal(SCOPES.CONFIG_UPDATE_ALL),
-  import_zod31.z.literal(SCOPES.USER_DATA_SEEDING)
-]);
-var rawConfigurableScopeRegex = /^([a-zA-Z\.]+)\[((?:\w+=[\w.-]+(?:\|[\w.-]+)*)(?:,[\w]+=[\w.-]+(?:\|[\w.-]+)*)*)\]$/;
-var rawConfigurableScope = import_zod31.z.string().regex(rawConfigurableScopeRegex);
-var CreateUserScope = import_zod31.z.object({
-  type: import_zod31.z.literal("user.create"),
-  options: import_zod31.z.object({
-    role: import_zod31.z.array(import_zod31.z.string())
-  })
-});
-var EditUserScope = import_zod31.z.object({
-  type: import_zod31.z.literal("user.edit"),
-  options: import_zod31.z.object({
-    role: import_zod31.z.array(import_zod31.z.string())
-  })
-});
-var WorkqueueScope = import_zod31.z.object({
-  type: import_zod31.z.literal("workqueue"),
-  options: import_zod31.z.object({
-    id: import_zod31.z.array(import_zod31.z.string())
-  })
-});
-var NotifyRecordScope = import_zod31.z.object({
-  type: import_zod31.z.literal("record.notify"),
-  options: import_zod31.z.object({
-    event: import_zod31.z.array(import_zod31.z.string())
-  })
-});
-var ConfigurableScopes = import_zod31.z.discriminatedUnion("type", [
-  CreateUserScope,
-  EditUserScope,
-  WorkqueueScope,
-  NotifyRecordScope
-]);
-var scopes = Object.values(SCOPES);
-
-// ../commons/src/events/scopes.ts
 var CONFIG_GET_ALLOWED_SCOPES = [
   SCOPES.RECORD_DECLARE,
   SCOPES.RECORD_READ,
@@ -6292,6 +6810,12 @@ var ACTION_ALLOWED_CONFIGURABLE_SCOPES = {
   [ActionType.UNASSIGN]: [],
   [ActionType.DETECT_DUPLICATE]: []
 };
+var WRITE_ACTION_SCOPES = [
+  ...ACTION_ALLOWED_SCOPES[ActionType.DECLARE],
+  ...ACTION_ALLOWED_SCOPES[ActionType.VALIDATE],
+  ...ACTION_ALLOWED_SCOPES[ActionType.REGISTER],
+  ...ACTION_ALLOWED_SCOPES[ActionType.PRINT_CERTIFICATE]
+];
 function hasAnyOfScopes(a, b) {
   return (0, import_lodash3.intersection)(a, b).length > 0;
 }
@@ -6311,11 +6835,44 @@ function filterUnallowedActions(actions, userScopes) {
   }
   return [ActionType.READ];
 }
+function getUserActionsByStatus(status, assignmentActions, userScopes) {
+  switch (status) {
+    case EventStatus.enum.CREATED: {
+      return [ActionType.READ, ActionType.DECLARE, ActionType.DELETE];
+    }
+    case EventStatus.enum.NOTIFIED:
+    case EventStatus.enum.DECLARED: {
+      return [...assignmentActions, ActionType.READ, ActionType.VALIDATE];
+    }
+    case EventStatus.enum.VALIDATED: {
+      return [...assignmentActions, ActionType.READ, ActionType.REGISTER];
+    }
+    case EventStatus.enum.CERTIFIED:
+    case EventStatus.enum.REGISTERED: {
+      return [
+        ...assignmentActions,
+        ActionType.READ,
+        ActionType.PRINT_CERTIFICATE,
+        ActionType.REQUEST_CORRECTION
+      ];
+    }
+    case EventStatus.enum.REJECTED: {
+      const validateScopes = ACTION_ALLOWED_SCOPES[ActionType.VALIDATE];
+      const canValidate = hasAnyOfScopes(userScopes, validateScopes);
+      const declarationAction = canValidate ? ActionType.VALIDATE : ActionType.DECLARE;
+      return [...assignmentActions, ActionType.READ, declarationAction];
+    }
+    case EventStatus.enum.ARCHIVED:
+      return [...assignmentActions, ActionType.READ];
+    default:
+      return [ActionType.READ];
+  }
+}
 
 // ../commons/src/events/serializers/user/deserializer.ts
-var import_zod32 = require("zod");
+var import_zod34 = require("zod");
 var UserWithPrimaryOffice = User.extend({
-  primaryOfficeId: import_zod32.z.string()
+  primaryOfficeId: import_zod34.z.string()
 });
 function userDeserializer(serializedUserField, user2) {
   if (typeof serializedUserField === "string") {
@@ -6335,6 +6892,7 @@ function deserializeQueryExpression(expression, user2) {
       ...expression.assignedTo,
       term: userDeserializer(expression.assignedTo.term, user2)
     },
+    createdByUserType: expression.createdByUserType,
     createdBy: expression.createdBy && {
       ...expression.createdBy,
       term: userDeserializer(expression.createdBy.term, user2)
@@ -6370,6 +6928,8 @@ function deserializeQuery(query, user2) {
     ...query,
     clauses: query.clauses.map(
       (clause) => deserializeQueryExpression(clause, user2)
+      // SAFETY: This cast should be safe because `query.clauses` has already been validated as non-empty by the Zod schema.
+      // Without the cast, TypeScript cannot infer the tuple type required by the target interface.
     )
   };
 }