@opencrvs/toolkit 1.8.0-rc.fec1d5d → 1.8.0-rc.fef0fdd

package/dist/events/index.js

@@ -32,6 +32,7 @@ var events_exports = {};
 __export(events_exports, {
   ACTION_ALLOWED_CONFIGURABLE_SCOPES: () => ACTION_ALLOWED_CONFIGURABLE_SCOPES,
   ACTION_ALLOWED_SCOPES: () => ACTION_ALLOWED_SCOPES,
+  AVAILABLE_ACTIONS_BY_EVENT_STATUS: () => AVAILABLE_ACTIONS_BY_EVENT_STATUS,
   Action: () => Action,
   ActionBase: () => ActionBase,
   ActionConditional: () => ActionConditional,
@@ -103,6 +104,7 @@ __export(events_exports, {
   EventState: () => EventState,
   EventStatus: () => EventStatus,
   Exact: () => Exact,
+  ExactDate: () => ExactDate,
   ExactStatus: () => ExactStatus,
   FieldConditional: () => FieldConditional,
   FieldConfig: () => FieldConfig,
@@ -139,6 +141,7 @@ __export(events_exports, {
   QueryInput: () => QueryInput,
   QueryType: () => QueryType,
   Range: () => Range,
+  RangeDate: () => RangeDate,
   ReadActionInput: () => ReadActionInput,
   RegisterAction: () => RegisterAction,
   RegisterActionInput: () => RegisterActionInput,
@@ -155,8 +158,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,
@@ -164,8 +169,10 @@ __export(events_exports, {
   UrbanAddressValue: () => UrbanAddressValue,
   User: () => User,
   ValidateActionInput: () => ValidateActionInput,
+  ValidationConfig: () => ValidationConfig,
   VerificationActionConfig: () => VerificationActionConfig,
   VerificationPageConfig: () => VerificationPageConfig,
+  WRITE_ACTION_SCOPES: () => WRITE_ACTION_SCOPES,
   Within: () => Within,
   WorkqueueActionsWithDefault: () => WorkqueueActionsWithDefault,
   WorkqueueColumn: () => WorkqueueColumn,
@@ -174,6 +181,7 @@ __export(events_exports, {
   WorkqueueColumnValue: () => WorkqueueColumnValue,
   WorkqueueConfig: () => WorkqueueConfig,
   WorkqueueConfigInput: () => WorkqueueConfigInput,
+  WorkqueueConfigWithoutQuery: () => WorkqueueConfigWithoutQuery,
   WorkqueueCountInput: () => WorkqueueCountInput,
   WorkqueueCountOutput: () => WorkqueueCountOutput,
   ZodDate: () => ZodDate,
@@ -209,7 +217,6 @@ __export(events_exports, {
   eventQueryDataGenerator: () => eventQueryDataGenerator,
   field: () => field,
   fieldTypes: () => fieldTypes,
-  filterUnallowedActions: () => filterUnallowedActions,
   findActiveDrafts: () => findActiveDrafts,
   findAllFields: () => findAllFields,
   findLastAssignmentAction: () => findLastAssignmentAction,
@@ -221,8 +228,10 @@ __export(events_exports, {
   generateEventDraftDocument: () => generateEventDraftDocument,
   generateRandomName: () => generateRandomName,
   generateRandomSignature: () => generateRandomSignature,
+  generateRegistrationNumber: () => generateRegistrationNumber,
   generateTransactionId: () => generateTransactionId,
   generateTranslationConfig: () => generateTranslationConfig,
+  generateUuid: () => generateUuid,
   generateWorkqueues: () => generateWorkqueues,
   getAcceptedActions: () => getAcceptedActions,
   getActionAnnotation: () => getActionAnnotation,
@@ -565,6 +574,10 @@ var FieldReference = import_zod5.z.object({
   $$field: FieldId
 }).describe("Reference to a field by its ID");
 var ParentReference = FieldReference.optional();
+var ValidationConfig = import_zod5.z.object({
+  validator: Conditional,
+  message: TranslationConfig
+});
 var BaseField = import_zod5.z.object({
   id: FieldId,
   parent: ParentReference,
@@ -572,12 +585,7 @@ var BaseField = import_zod5.z.object({
   required: import_zod5.z.boolean().default(false).optional(),
   secured: import_zod5.z.boolean().default(false).optional(),
   placeholder: TranslationConfig.optional(),
-  validation: import_zod5.z.array(
-    import_zod5.z.object({
-      validator: Conditional,
-      message: TranslationConfig
-    })
-  ).default([]).optional(),
+  validation: import_zod5.z.array(ValidationConfig).default([]).optional(),
   label: TranslationConfig,
   helperText: TranslationConfig.optional(),
   hideLabel: import_zod5.z.boolean().default(false).optional()
@@ -967,6 +975,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,
@@ -1147,7 +1165,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");
@@ -1286,6 +1304,9 @@ var BaseField3 = import_zod14.z.object({
        'conditionals' to an empty array ('[]') in the search config. This ensures they
        are always rendered in the advanced search form.
       `
+  ),
+  validations: import_zod14.z.array(ValidationConfig).default([]).optional().describe(
+    `In advanced search, we sometimes need to override the default field validations.`
   )
 });
 var SearchQueryParams = import_zod14.z.object({
@@ -1321,127 +1342,560 @@ 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
+// ../commons/src/uuid.ts
+var import_uuid = require("uuid");
 var import_zod15 = require("zod");
-var CreatedAtLocation = import_zod15.z.string().nullish();
+var UUID = import_zod15.z.string().uuid().brand("UUID");
+function getUUID() {
+  return (0, import_uuid.v4)();
+}
+
+// ../commons/src/events/CreatedAtLocation.ts
+var CreatedAtLocation = UUID.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: UUID,
+  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([
+  annotation: ActionUpdate.optional().nullable(),
+  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: UUID.optional().nullable().describe(
+    "Reference to the original action that was asynchronously rejected or accepted by 3rd party integration."
+  )
 });
 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)
   })
 );
 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" }),
@@ -1464,20 +1918,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()
     })
   )
 });
@@ -1488,7 +1942,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) {
@@ -1548,7 +2002,7 @@ function createValidationSchema(config) {
   for (const field2 of config) {
     shape[field2.id] = mapFieldTypeToZod(field2.type, field2.required);
   }
-  return import_zod17.z.object(shape);
+  return import_zod19.z.object(shape);
 }
 function mapFieldTypeToEmptyValue(field2) {
   switch (field2.type) {
@@ -1901,12 +2355,6 @@ function getValidatorsForField(fieldId, validations) {
   }).filter((x) => x !== null);
 }
 
-// ../commons/src/uuid.ts
-var import_uuid = require("uuid");
-function getUUID() {
-  return (0, import_uuid.v4)();
-}
-
 // ../commons/src/utils.ts
 function getOrThrow(x, message) {
   if (x === void 0 || x === null) {
@@ -2013,8 +2461,9 @@ function createEmptyDraft(eventId, draftId, actionType) {
       declaration: {},
       annotation: {},
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      createdByUserType: TokenUserType.Enum.user,
       createdBy: "@todo",
-      createdAtLocation: "@todo",
+      createdAtLocation: "00000000-0000-0000-0000-000000000000",
       status: ActionStatus.Accepted,
       transactionId: "@todo",
       createdByRole: "@todo"
@@ -2117,9 +2566,9 @@ function getEventConfigById(eventConfigs, id) {
 
 // ../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(),
@@ -2129,10 +2578,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);
@@ -2194,12 +2643,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",
@@ -2602,11 +3051,11 @@ 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 = import_zod20.z.enum([
+var import_zod22 = require("zod");
+var EventStatus = import_zod22.z.enum([
   "CREATED",
   "NOTIFIED",
   "DECLARED",
@@ -2619,57 +3068,63 @@ var EventStatus = import_zod20.z.enum([
 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 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({
+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."),
+var EventMetadata = import_zod22.z.object({
+  id: UUID,
+  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: UUID.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",
@@ -2678,6 +3133,7 @@ var EventMetadataKeysArray = [
   "createdAt",
   "dateOfEvent",
   "createdBy",
+  "createdByUserType",
   "updatedByUserRole",
   "createdAtLocation",
   "updatedAtLocation",
@@ -2688,7 +3144,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",
@@ -2700,6 +3156,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",
@@ -2765,13 +3226,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
 });
@@ -2782,98 +3244,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())
-}).openapi({
-  ref: "AnyOf"
-});
-var ExactStatus = import_zod22.z.object({
-  type: import_zod22.z.literal("exact"),
+var ExactStatus = import_zod24.z.object({
+  type: import_zod24.z.literal("exact"),
   term: EventStatus
 }).openapi({
   ref: "ExactStatus"
 });
-var AnyOfStatus = import_zod22.z.object({
-  type: import_zod22.z.literal("anyOf"),
-  terms: import_zod22.z.array(EventStatus)
+var AnyOf = import_zod24.z.object({
+  type: import_zod24.z.literal("anyOf"),
+  terms: import_zod24.z.array(import_zod24.z.string())
+}).openapi({
+  ref: "AnyOf"
+});
+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({
-  id: import_zod22.z.optional(import_zod22.z.string()),
-  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])
   ),
-  "legalStatus.REGISTERED.registrationNumber": import_zod22.z.optional(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)];
@@ -2883,7 +3359,7 @@ var QueryType = import_zod22.z.object({
       }
       return val;
     },
-    import_zod22.z.array(QueryExpression).nonempty("At least one clause is required.").openapi({
+    import_zod24.z.array(QueryExpression).nonempty("At least one clause is required.").openapi({
       default: [
         {
           eventType: TENNIS_CLUB_MEMBERSHIP,
@@ -2906,50 +3382,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",
@@ -3071,38 +3548,42 @@ var mandatoryColumns = 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(mandatoryColumns),
+  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(mandatoryColumns),
+  columns: import_zod27.z.array(WorkqueueColumn).default(mandatoryColumns),
   icon: AvailableIcons
 });
 function defineWorkqueue(workqueueInput) {
@@ -3113,10 +3594,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 = [
@@ -3139,115 +3620,115 @@ 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: UUID,
+  transactionId: import_zod28.z.string(),
   declaration: ActionUpdate.default({}),
   annotation: ActionUpdate.optional(),
-  originalActionId: import_zod26.z.string().optional(),
-  keepAssignment: import_zod26.z.boolean().optional()
+  originalActionId: UUID.optional(),
+  // should not be part of base action.
+  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()
   })
-);
+).strict();
 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: {
     eventId: "<event-id-here>",
-    transactionId: (0, import_uuid3.v4)(),
+    transactionId: getUUID(),
     declaration: {},
     annotation: {},
     type: ActionType.NOTIFY
   }
 });
 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: UUID });
+var ActionInput = import_zod28.z.discriminatedUnion("type", [
   CreateActionInput.openapi({ ref: "CreateActionInput" }),
   ValidateActionInput.openapi({ ref: "ValidateActionInput" }),
   RegisterActionInput.openapi({ ref: "RegisterActionInput" }),
@@ -3276,18 +3757,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: UUID,
+  eventId: UUID,
+  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
@@ -3295,24 +3776,24 @@ var DraftInput = BaseActionInput.extend({
 });
 
 // ../commons/src/events/EventInput.ts
-var import_zod28 = require("zod");
-var import_uuid4 = require("uuid");
-var EventInput = import_zod28.z.object({
-  transactionId: import_zod28.z.string(),
-  type: import_zod28.z.string()
-}).openapi({ default: { transactionId: (0, import_uuid4.v4)(), type: "v2.birth" } });
+var import_zod30 = require("zod");
+var import_uuid8 = require("uuid");
+var EventInput = import_zod30.z.object({
+  transactionId: import_zod30.z.string(),
+  type: import_zod30.z.string()
+}).openapi({ default: { transactionId: (0, import_uuid8.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: UUID,
+  type: import_zod31.z.string(),
+  createdAt: import_zod31.z.string().datetime(),
+  updatedAt: import_zod31.z.string().datetime(),
+  actions: import_zod31.z.array(Action),
+  trackingId: import_zod31.z.string()
 }).openapi({ ref: "EventDocument" });
 
 // ../commons/src/events/state/utils.ts
@@ -3346,6 +3827,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,
@@ -3353,17 +3835,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
       };
@@ -3371,6 +3854,7 @@ function getDeclarationActionUpdateMetadata(actions) {
     {
       createdAt: createAction.createdAt,
       createdBy: createAction.createdBy,
+      createdByUserType: createAction.createdByUserType,
       createdAtLocation: createAction.createdAtLocation,
       createdByRole: createAction.createdByRole
     }
@@ -3535,9 +4019,8 @@ function getCurrentEventState(event2, config) {
   const acceptedActions = getAcceptedActions(event2).sort(
     (a, b) => a.createdAt.localeCompare(b.createdAt)
   );
-  const declarationUpdateMetadata = getDeclarationActionUpdateMetadata(
-    event2.actions
-  );
+  const requestActionMetadata = getActionUpdateMetadata(event2.actions);
+  const acceptedActionMetadata = getActionUpdateMetadata(acceptedActions);
   const declaration = aggregateActionDeclarations(acceptedActions);
   let dateOfEvent;
   if (config.dateOfEvent) {
@@ -3557,16 +4040,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)
   });
@@ -3649,18 +4133,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
@@ -5651,6 +6135,14 @@ var v2BirthEvent = defineConfig({
 });
 
 // ../commons/src/events/test.utils.ts
+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)];
 }
@@ -5823,6 +6315,7 @@ function eventPayloadGenerator(rng) {
           },
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           createdBy: "@todo",
+          createdByUserType: TokenUserType.Enum.user,
           createdByRole: "@todo",
           createdAtLocation: "@todo"
         }
@@ -6008,16 +6501,18 @@ function generateActionDocument({
   configuration,
   action,
   rng = () => 0.1,
-  defaults = {}
+  defaults = {},
+  user: user2 = {}
 }) {
   const actionBase = {
     // 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.
     createdAt: new Date(Date.now() - 500).toISOString(),
-    createdBy: getUUID(),
-    createdByRole: "FIELD_AGENT",
+    createdBy: user2.id ?? getUUID(),
+    createdByUserType: TokenUserType.Enum.user,
+    createdByRole: TestUserRole.Enum.FIELD_AGENT,
     id: getUUID(),
-    createdAtLocation: "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
+    createdAtLocation: user2.primaryOfficeId ?? "a45b982a-5c7b-4bd9-8fd8-a42d0994054c",
     declaration: generateActionDeclarationInput(configuration, action, rng),
     annotation: {},
     status: ActionStatus.Accepted,
@@ -6032,7 +6527,7 @@ function generateActionDocument({
     case ActionType.DECLARE:
       return { ...actionBase, type: action };
     case ActionType.UNASSIGN:
-      return { ...actionBase, type: action, assignedTo: null };
+      return { ...actionBase, type: action };
     case ActionType.ASSIGN:
       return { ...actionBase, assignedTo: getUUID(), type: action };
     case ActionType.VALIDATE:
@@ -6071,13 +6566,14 @@ function generateActionDocument({
 function generateEventDocument({
   configuration,
   actions,
-  rng = () => 0.1
+  rng = () => 0.1,
+  user: user2
 }) {
   return {
     trackingId: getUUID(),
     type: configuration.id,
     actions: actions.map(
-      (action) => generateActionDocument({ configuration, action, rng })
+      (action) => generateActionDocument({ configuration, action, rng, user: user2 })
     ),
     // 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.
@@ -6145,7 +6641,7 @@ function createPrng(seed) {
     return state / MODULUS;
   };
 }
-function generateUuid(rng) {
+function generateUuid(rng = () => 0.1) {
   return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
     const r = Math.floor(rng() * 16);
     const v = c === "x" ? r : r & 3 | 8;
@@ -6157,6 +6653,11 @@ function generateTrackingId(rng) {
   const trackingId = uuid.slice(0, 6).toUpperCase();
   return trackingId;
 }
+function generateRegistrationNumber(rng) {
+  const uuid = generateUuid(rng).replace(/-/g, "");
+  const registrationNumber = uuid.slice(0, 12).toUpperCase();
+  return registrationNumber;
+}
 function generateRandomSignature(rng) {
   return `/random-bucket/${generateUuid(rng)}.png`;
 }
@@ -6172,6 +6673,7 @@ var eventQueryDataGenerator = (overrides = {}, seed = 1) => {
     type: overrides.type ?? TENNIS_CLUB_MEMBERSHIP,
     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),
@@ -6249,234 +6751,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,
@@ -6553,30 +6827,20 @@ 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;
 }
-function filterUnallowedActions(actions, userScopes) {
-  const allowedActions = actions.filter((action) => {
-    const requiredScopes = ACTION_ALLOWED_SCOPES[action];
-    if (requiredScopes === null) {
-      return true;
-    }
-    return hasAnyOfScopes(userScopes, requiredScopes);
-  });
-  const hasOtherAllowedActions = allowedActions.some(
-    (action) => !isMetaAction(action)
-  );
-  if (hasOtherAllowedActions) {
-    return allowedActions;
-  }
-  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") {
@@ -6596,6 +6860,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)
@@ -6636,3 +6901,51 @@ function deserializeQuery(query, user2) {
     )
   };
 }
+
+// ../commons/src/events/state/availableActions.ts
+var AVAILABLE_ACTIONS_BY_EVENT_STATUS = {
+  [EventStatus.enum.CREATED]: [
+    ActionType.READ,
+    ActionType.DECLARE,
+    ActionType.NOTIFY,
+    ActionType.DELETE
+  ],
+  [EventStatus.enum.NOTIFIED]: [
+    ActionType.READ,
+    ActionType.DECLARE,
+    ActionType.ARCHIVE,
+    ActionType.REJECT
+  ],
+  [EventStatus.enum.DECLARED]: [
+    ActionType.READ,
+    ActionType.VALIDATE,
+    ActionType.ARCHIVE,
+    ActionType.REJECT
+  ],
+  [EventStatus.enum.VALIDATED]: [
+    ActionType.READ,
+    ActionType.REGISTER,
+    ActionType.ARCHIVE,
+    ActionType.REJECT
+  ],
+  [EventStatus.enum.REJECTED]: [
+    ActionType.READ,
+    ActionType.DECLARE,
+    ActionType.VALIDATE
+  ],
+  [EventStatus.enum.REGISTERED]: [
+    ActionType.READ,
+    ActionType.PRINT_CERTIFICATE,
+    ActionType.REQUEST_CORRECTION
+  ],
+  [EventStatus.enum.CERTIFIED]: [
+    ActionType.READ,
+    ActionType.PRINT_CERTIFICATE,
+    ActionType.REQUEST_CORRECTION
+  ],
+  [EventStatus.enum.ARCHIVED]: [
+    ActionType.READ,
+    ActionType.ASSIGN,
+    ActionType.UNASSIGN
+  ]
+};