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

package/dist/events/index.js

@@ -71,6 +71,7 @@ __export(events_exports, {
   DeclarationUpdateActions: () => DeclarationUpdateActions,
   DeclareActionInput: () => DeclareActionInput,
   DeduplicationConfig: () => DeduplicationConfig,
+  DeleteActionInput: () => DeleteActionInput,
   DisplayOnReviewConditional: () => DisplayOnReviewConditional,
   Draft: () => Draft,
   DraftInput: () => DraftInput,
@@ -145,6 +146,7 @@ __export(events_exports, {
   defineFormConditional: () => defineFormConditional,
   defineFormPage: () => defineFormPage,
   definePage: () => definePage,
+  defineWorkqueue: () => defineWorkqueue,
   errorMessages: () => errorMessages,
   event: () => event,
   eventMetadataLabelMap: () => eventMetadataLabelMap,
@@ -172,6 +174,7 @@ __export(events_exports, {
   getActionReviewFields: () => getActionReviewFields,
   getAllAnnotationFields: () => getAllAnnotationFields,
   getAnnotationFromDrafts: () => getAnnotationFromDrafts,
+  getAssignedUserFromActions: () => getAssignedUserFromActions,
   getCurrentEventState: () => getCurrentEventState,
   getCurrentEventStateWithDrafts: () => getCurrentEventStateWithDrafts,
   getDeclaration: () => getDeclaration,
@@ -224,7 +227,6 @@ __export(events_exports, {
   user: () => user,
   validate: () => validate,
   validateFieldInput: () => validateFieldInput,
-  validateWorkqueueConfig: () => validateWorkqueueConfig,
   writeActions: () => writeActions
 });
 module.exports = __toCommonJS(events_exports);
@@ -234,9 +236,12 @@ var import_zod9 = require("zod");
 
 // ../commons/src/events/Conditional.ts
 var import_zod = require("zod");
-var Conditional = import_zod.z.custom(
-  (val) => typeof val === "object" && val !== null
-);
+var import_zod_openapi = require("zod-openapi");
+(0, import_zod_openapi.extendZodWithOpenApi)(import_zod.z);
+var Conditional = import_zod.z.custom((val) => typeof val === "object" && val !== null).openapi({
+  description: "JSON schema conditional configuration",
+  ref: "Conditional"
+});
 var ConditionalType = {
   SHOW: "SHOW",
   ENABLE: "ENABLE",
@@ -273,7 +278,10 @@ var FieldConditional = import_zod.z.discriminatedUnion("type", [
   EnableConditional,
   // Field output can be shown / hidden on the review page
   DisplayOnReviewConditional
-]);
+]).openapi({
+  description: "Field conditional configuration",
+  ref: "FieldConditional"
+});
 
 // ../commons/src/events/PageConfig.ts
 var import_zod6 = require("zod");
@@ -283,6 +291,8 @@ var import_zod5 = require("zod");
 
 // ../commons/src/events/TranslationConfig.ts
 var import_zod2 = require("zod");
+var import_zod_openapi2 = require("zod-openapi");
+(0, import_zod_openapi2.extendZodWithOpenApi)(import_zod2.z);
 var TranslationConfig = import_zod2.z.object({
   id: import_zod2.z.string().describe(
     "The identifier of the translation referred in translation CSV files"
@@ -291,8 +301,14 @@ var TranslationConfig = import_zod2.z.object({
   description: import_zod2.z.string().describe(
     "Describe the translation for a translator to be able to identify it."
   )
+}).openapi({
+  description: "Translation configuration",
+  ref: "TranslationConfig"
 });
 
+// ../commons/src/events/FieldConfig.ts
+var import_zod_openapi3 = require("zod-openapi");
+
 // ../commons/src/events/FieldType.ts
 var FieldType = {
   ADDRESS: "ADDRESS",
@@ -443,6 +459,7 @@ var FieldUpdateValue = import_zod4.z.union([
 ]);
 
 // ../commons/src/events/FieldConfig.ts
+(0, import_zod_openapi3.extendZodWithOpenApi)(import_zod5.z);
 var FieldId = import_zod5.z.string();
 var DependencyExpression = import_zod5.z.object({
   dependsOn: import_zod5.z.array(FieldId).default([]),
@@ -702,10 +719,14 @@ var FieldConfig = import_zod5.z.discriminatedUnion("type", [
   EmailField,
   FileUploadWithOptions,
   DataField
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-]);
+]).openapi({
+  description: "Form field configuration",
+  ref: "FieldConfig"
+});
 
 // ../commons/src/events/PageConfig.ts
+var import_zod_openapi4 = require("zod-openapi");
+(0, import_zod_openapi4.extendZodWithOpenApi)(import_zod6.z);
 var PageTypes = import_zod6.z.enum(["FORM", "VERIFICATION"]);
 var PageConfigBase = import_zod6.z.object({
   id: import_zod6.z.string().describe("Unique identifier for the page"),
@@ -717,6 +738,9 @@ var PageConfigBase = import_zod6.z.object({
 });
 var FormPageConfig = PageConfigBase.extend({
   type: import_zod6.z.literal(PageTypes.enum.FORM).default(PageTypes.enum.FORM)
+}).openapi({
+  description: "Form page configuration",
+  ref: "FormPageConfig"
 });
 var VerificationActionConfig = import_zod6.z.object({
   verify: import_zod6.z.object({ label: TranslationConfig }),
@@ -727,7 +751,10 @@ var VerificationActionConfig = import_zod6.z.object({
       body: TranslationConfig
     })
   })
-}).describe("Actions available on the verification page");
+}).describe("Actions available on the verification page").openapi({
+  description: "Verification action configuration",
+  ref: "VerificationActionConfig"
+});
 var VerificationPageConfig = FormPageConfig.extend({
   type: import_zod6.z.literal(PageTypes.enum.VERIFICATION),
   actions: VerificationActionConfig
@@ -827,6 +854,8 @@ var ActionFormConfig = import_zod8.z.object({
 var FormConfig = import_zod8.z.union([DeclarationFormConfig, ActionFormConfig]);
 
 // ../commons/src/events/ActionConfig.ts
+var import_zod_openapi5 = require("zod-openapi");
+(0, import_zod_openapi5.extendZodWithOpenApi)(import_zod9.z);
 var ActionConditional2 = import_zod9.z.discriminatedUnion("type", [
   /** If conditional is defined, the action is shown to the user only if the condition is met */
   ShowConditional,
@@ -904,18 +933,24 @@ var ApproveCorrectionConfig = ActionConfigBase.merge(
   })
 );
 var ActionConfig = import_zod9.z.discriminatedUnion("type", [
-  DeclareConfig,
-  ValidateConfig,
-  RejectDeclarationConfig,
-  MarkedAsDuplicateConfig,
-  ArchiveConfig,
-  RegisterConfig,
-  DeleteConfig,
-  PrintCertificateActionConfig,
-  RequestCorrectionConfig,
-  RejectCorrectionConfig,
-  ApproveCorrectionConfig
-]);
+  /*
+   * OpenAPI references are defined here so our generated OpenAPI spec knows to reuse the models
+   * and treat them as "models" instead of duplicating the data structure in each endpoint.
+   */
+  DeclareConfig.openapi({ ref: "DeclareActionConfig" }),
+  ValidateConfig.openapi({ ref: "ValidateActionConfig" }),
+  RejectDeclarationConfig.openapi({ ref: "RejectDeclarationActionConfig" }),
+  MarkedAsDuplicateConfig.openapi({ ref: "MarkedAsDuplicateActionConfig" }),
+  ArchiveConfig.openapi({ ref: "ArchiveActionConfig" }),
+  RegisterConfig.openapi({ ref: "RegisterActionConfig" }),
+  DeleteConfig.openapi({ ref: "DeleteActionConfig" }),
+  PrintCertificateActionConfig.openapi({
+    ref: "PrintCertificateActionConfig"
+  }),
+  RequestCorrectionConfig.openapi({ ref: "RequestCorrectionActionConfig" }),
+  RejectCorrectionConfig.openapi({ ref: "RejectCorrectionActionConfig" }),
+  ApproveCorrectionConfig.openapi({ ref: "ApproveCorrectionActionConfig" })
+]).openapi({ ref: "ActionConfig" });
 var DeclarationActionConfig = import_zod9.z.discriminatedUnion("type", [
   DeclareConfig,
   ValidateConfig,
@@ -959,10 +994,12 @@ var LanguageConfig = import_zod11.z.object({
 });
 
 // ../commons/src/events/EventConfig.ts
-var import_zod20 = require("zod");
+var import_zod16 = require("zod");
 
 // ../commons/src/events/DeduplicationConfig.ts
 var import_zod12 = require("zod");
+var import_zod_openapi6 = require("zod-openapi");
+(0, import_zod_openapi6.extendZodWithOpenApi)(import_zod12.z);
 var FieldReference = import_zod12.z.string();
 var Matcher = import_zod12.z.object({
   fieldId: import_zod12.z.string(),
@@ -1023,7 +1060,9 @@ var Clause = import_zod12.z.lazy(
     DateRangeMatcher,
     DateDistanceMatcher
   ])
-);
+).openapi({
+  ref: "Clause"
+});
 var DeduplicationConfig = import_zod12.z.object({
   id: import_zod12.z.string(),
   label: TranslationConfig,
@@ -1057,119 +1096,15 @@ var SummaryConfig = import_zod13.z.object({
   fields: import_zod13.z.array(import_zod13.z.union([Field, ReferenceField])).describe("Fields rendered in summary view.")
 }).describe("Configuration for summary in event.");
 
-// ../commons/src/events/WorkqueueConfig.ts
-var import_zod15 = require("zod");
-
-// ../commons/src/events/EventMetadata.ts
-var import_zod14 = require("zod");
-var EventStatus = {
-  CREATED: "CREATED",
-  NOTIFIED: "NOTIFIED",
-  DECLARED: "DECLARED",
-  VALIDATED: "VALIDATED",
-  REGISTERED: "REGISTERED",
-  CERTIFIED: "CERTIFIED",
-  REJECTED: "REJECTED",
-  ARCHIVED: "ARCHIVED"
-};
-var eventStatuses = Object.values(EventStatus);
-var EventStatuses = import_zod14.z.nativeEnum(EventStatus);
-var EventMetadata = import_zod14.z.object({
-  id: import_zod14.z.string(),
-  type: import_zod14.z.string(),
-  status: EventStatuses,
-  createdAt: import_zod14.z.string().datetime(),
-  createdBy: import_zod14.z.string(),
-  createdAtLocation: import_zod14.z.string(),
-  updatedAtLocation: import_zod14.z.string(),
-  modifiedAt: import_zod14.z.string().datetime(),
-  assignedTo: import_zod14.z.string().nullish(),
-  updatedBy: import_zod14.z.string(),
-  trackingId: import_zod14.z.string(),
-  registrationNumber: import_zod14.z.string().nullish()
-});
-var eventMetadataLabelMap = {
-  "event.assignedTo": {
-    id: "event.assignedTo.label",
-    defaultMessage: "Assigned To",
-    description: "Assigned To"
-  },
-  "event.createdAt": {
-    id: "event.createdAt.label",
-    defaultMessage: "Created",
-    description: "Created At"
-  },
-  "event.createdAtLocation": {
-    id: "event.createdAtLocation.label",
-    defaultMessage: "Location",
-    description: "Created At Location"
-  },
-  "event.updatedAtLocation": {
-    id: "event.updatedAtLocation.label",
-    defaultMessage: "Location",
-    description: "Updated At Location"
-  },
-  "event.createdBy": {
-    id: "event.createdBy.label",
-    defaultMessage: "Created By",
-    description: "Created By"
-  },
-  "event.id": {
-    id: "event.id.label",
-    defaultMessage: "ID",
-    description: "ID"
-  },
-  "event.modifiedAt": {
-    id: "event.modifiedAt.label",
-    defaultMessage: "Updated",
-    description: "Modified At"
-  },
-  "event.status": {
-    id: "event.status.label",
-    defaultMessage: "Status",
-    description: "Status"
-  },
-  "event.type": {
-    id: "event.type.label",
-    defaultMessage: "Type",
-    description: "Type"
-  },
-  "event.updatedBy": {
-    id: "event.updatedBy.label",
-    defaultMessage: "Updated By",
-    description: "Updated By"
-  },
-  "event.trackingId": {
-    id: "event.trackingId.label",
-    defaultMessage: "Tracking ID",
-    description: "Tracking ID"
-  },
-  "event.registrationNumber": {
-    id: "event.registrationNumber.label",
-    defaultMessage: "Registration Number",
-    description: "Registration Number"
-  }
-};
-
-// ../commons/src/events/WorkqueueConfig.ts
-var WorkqueueConfig = import_zod15.z.object({
-  id: import_zod15.z.string().describe("Unique identifier for workqueue."),
-  filters: import_zod15.z.array(
-    import_zod15.z.object({
-      status: import_zod15.z.array(EventStatuses).describe("Defines which statusese are included in the workqueue.")
-    })
-  ).describe("Filters to be applied to workqueue.")
-}).describe("Configuration for workqueue.");
-
 // ../commons/src/events/AdvancedSearchConfig.ts
-var import_zod16 = require("zod");
-var AdvancedSearchConfig = import_zod16.z.object({
+var import_zod14 = require("zod");
+var AdvancedSearchConfig = import_zod14.z.object({
   title: TranslationConfig.describe("Advanced search tab title"),
-  fields: import_zod16.z.array(
-    import_zod16.z.object({
-      fieldId: import_zod16.z.string(),
-      config: import_zod16.z.object({
-        type: import_zod16.z.enum(["FUZZY", "EXACT", "RANGE"]).describe("Determines the type of field")
+  fields: import_zod14.z.array(
+    import_zod14.z.object({
+      fieldId: import_zod14.z.string(),
+      config: import_zod14.z.object({
+        type: import_zod14.z.enum(["FUZZY", "EXACT", "RANGE"]).describe("Determines the type of field")
       }).optional().describe("Configuration options for the field")
     })
   ).optional().default([]).describe("Advanced search fields.")
@@ -1178,139 +1113,13 @@ var AdvancedSearchConfig = import_zod16.z.object({
 // ../commons/src/events/utils.ts
 var import_lodash = require("lodash");
 
-// ../commons/src/workqueues/WorkqueueConfig.ts
-var import_zod18 = require("zod");
-
-// ../commons/src/workqueues/defaultColumns.ts
-var import_zod17 = require("zod");
-var WorkQueueColumnConfig = import_zod17.z.object({
-  id: import_zod17.z.string(),
-  label: TranslationConfig
-});
-var defaultColumns = {
-  event: {
-    id: "event",
-    label: {
-      defaultMessage: "Event",
-      description: "This is the label for the workqueue column",
-      id: "workqueue.default.column.event"
-    }
-  },
-  status: {
-    id: "status",
-    label: {
-      defaultMessage: "Status",
-      description: "This is the label for the workqueue column",
-      id: "workqueue.default.column.status"
-    }
-  },
-  createdAt: {
-    id: "createdAt",
-    label: {
-      defaultMessage: "Created",
-      description: "This is the label for the workqueue column",
-      id: "workqueue.default.column.createdAt"
-    }
-  },
-  modifiedAt: {
-    id: "modifiedAt",
-    label: {
-      defaultMessage: "Modified",
-      description: "This is the label for the workqueue column",
-      id: "workqueue.default.column.modifiedAt"
-    }
-  }
-};
-var DefaultColumnKeys = import_zod17.z.enum(
-  Object.keys(defaultColumns)
-);
-
-// ../commons/src/workqueues/WorkqueueConfig.ts
-var rootWorkqueueConfig = import_zod18.z.object({
-  id: import_zod18.z.string(),
-  title: TranslationConfig,
-  columns: import_zod18.z.array(WorkQueueColumnConfig),
-  defaultColumns: import_zod18.z.array(DefaultColumnKeys)
-});
-var defineWorkqueue = (config) => rootWorkqueueConfig.parse(config);
-
-// ../commons/src/workqueues/all.ts
-var allWorkqueue = defineWorkqueue({
-  id: "all",
-  title: {
-    defaultMessage: "All events",
-    description: "This is the label for the workqueue",
-    id: "workqueue.all.label"
-  },
-  columns: [
-    {
-      id: "title",
-      label: {
-        defaultMessage: "Title",
-        description: "This is the label for the workqueue column",
-        id: "workqueue.all.column.title"
-      }
-    }
-  ],
-  defaultColumns: ["event", "status", "createdAt", "modifiedAt"]
-});
-
-// ../commons/src/workqueues/readyForReview.ts
-var inReviewWorkqueue = defineWorkqueue({
-  id: "ready-for-review",
-  title: {
-    defaultMessage: "Ready for review",
-    description: "Label for in review workqueue",
-    id: "event.workqueue.in-review.label"
-  },
-  columns: [
-    {
-      id: "title",
-      label: {
-        defaultMessage: "Title",
-        description: "This is the label for the workqueue column",
-        id: "workqueue.in-reveiw.column.title"
-      }
-    }
-  ],
-  defaultColumns: ["event", "createdAt", "modifiedAt"]
-});
-
-// ../commons/src/workqueues/readyToPrint.ts
-var registeredWorkqueue = defineWorkqueue({
-  id: "registered",
-  title: {
-    defaultMessage: "Ready to print",
-    description: "Label for registered workqueue",
-    id: "event.workqueue.registered.label"
-  },
-  columns: [
-    {
-      id: "title",
-      label: {
-        defaultMessage: "Title",
-        description: "This is the label for the workqueue column",
-        id: "workqueue.registered.column.title"
-      }
-    }
-  ],
-  defaultColumns: ["event", "createdAt", "modifiedAt"]
-});
-
-// ../commons/src/workqueues/index.ts
-var workqueues = {
-  all: allWorkqueue,
-  registered: registeredWorkqueue,
-  inReview: inReviewWorkqueue
-};
-
 // ../commons/src/conditionals/validate.ts
 var import_ajv = __toESM(require("ajv"));
 var import_ajv_formats = __toESM(require("ajv-formats"));
 var import_date_fns = require("date-fns");
 
 // ../commons/src/events/FieldTypeMapping.ts
-var import_zod19 = require("zod");
+var import_zod15 = require("zod");
 function mapFieldTypeToZod(type, required) {
   let schema;
   switch (type) {
@@ -1363,7 +1172,7 @@ function createValidationSchema(config) {
   for (const field2 of config) {
     shape[field2.id] = mapFieldTypeToZod(field2.type, field2.required);
   }
-  return import_zod19.z.object(shape);
+  return import_zod15.z.object(shape);
 }
 function mapFieldTypeToMockValue(field2, i) {
   switch (field2.type) {
@@ -1772,18 +1581,6 @@ function getActionReview(configuration, actionType) {
 function getActionReviewFields(configuration, actionType) {
   return getActionReview(configuration, actionType).fields;
 }
-function validateWorkqueueConfig(workqueueConfigs) {
-  workqueueConfigs.map((workqueue) => {
-    const rootWorkqueue = Object.values(workqueues).find(
-      (wq) => wq.id === workqueue.id
-    );
-    if (!rootWorkqueue) {
-      throw new Error(
-        `Invalid workqueue configuration: workqueue not found with id: ${workqueue.id}`
-      );
-    }
-  });
-}
 function isPageVisible(page, formValues) {
   if (!page.conditional) {
     return true;
@@ -1855,17 +1652,18 @@ function isWriteAction(actionType) {
 }
 
 // ../commons/src/events/EventConfig.ts
-var EventConfig = import_zod20.z.object({
-  id: import_zod20.z.string().describe(
+var import_zod_openapi7 = require("zod-openapi");
+(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod16.z);
+var EventConfig = import_zod16.z.object({
+  id: import_zod16.z.string().describe(
     'A machine-readable identifier for the event, e.g. "birth" or "death"'
   ),
   summary: SummaryConfig,
   label: TranslationConfig,
-  actions: import_zod20.z.array(ActionConfig),
+  actions: import_zod16.z.array(ActionConfig),
   declaration: DeclarationFormConfig,
-  workqueues: import_zod20.z.array(WorkqueueConfig),
-  deduplication: import_zod20.z.array(DeduplicationConfig).optional().default([]),
-  advancedSearch: import_zod20.z.array(AdvancedSearchConfig).optional().default([])
+  deduplication: import_zod16.z.array(DeduplicationConfig).optional().default([]),
+  advancedSearch: import_zod16.z.array(AdvancedSearchConfig).optional().default([])
 }).superRefine((event2, ctx) => {
   const allFields = findAllFields(event2);
   const fieldIds = allFields.map((field2) => field2.id);
@@ -1891,6 +1689,8 @@ var EventConfig = import_zod20.z.object({
       path: ["advancedSearch"]
     });
   }
+}).openapi({
+  ref: "EventConfig"
 });
 
 // ../commons/src/events/EventConfigInput.ts
@@ -1899,269 +1699,312 @@ var defineActionForm = (actionForm) => ActionFormConfig.parse(actionForm);
 var definePage = (page) => PageConfig.parse(page);
 var defineFormPage = (formPage) => FormPageConfig.parse(formPage);
 
+// ../commons/src/events/WorkqueueConfig.ts
+var import_zod17 = require("zod");
+var WorkqueueConfig = import_zod17.z.object({
+  slug: import_zod17.z.string().describe("Determines the url of the workqueue."),
+  name: TranslationConfig.describe(
+    "Title of the workflow (both in navigation and on the page)"
+  ),
+  /**
+   * Placeholder untill the following gets merged to develop
+   * https://github.com/opencrvs/opencrvs-core/blob/5fbe9854a88504a7a13fcc856b3e82594b70c38c/packages/commons/src/events/EventIndex.ts#L92-L93
+   */
+  query: import_zod17.z.string(),
+  actions: import_zod17.z.array(
+    import_zod17.z.object({
+      type: import_zod17.z.string(),
+      conditionals: import_zod17.z.array(Conditional).optional()
+    })
+  )
+}).describe("Configuration for workqueue.");
+function defineWorkqueue(workqueues) {
+  return workqueues.map((workqueue) => WorkqueueConfig.parse(workqueue));
+}
+
 // ../commons/src/events/Draft.ts
-var import_zod23 = require("zod");
+var import_zod20 = require("zod");
 
 // ../commons/src/events/ActionDocument.ts
-var import_zod21 = require("zod");
-var ActionUpdate = import_zod21.z.record(import_zod21.z.string(), FieldUpdateValue);
+var import_zod18 = require("zod");
+var import_zod_openapi8 = require("zod-openapi");
+(0, import_zod_openapi8.extendZodWithOpenApi)(import_zod18.z);
+var ActionUpdate = import_zod18.z.record(import_zod18.z.string(), FieldUpdateValue);
 var ActionStatus = {
   Requested: "Requested",
   Accepted: "Accepted",
   Rejected: "Rejected"
 };
-var ActionBase = import_zod21.z.object({
-  id: import_zod21.z.string(),
-  createdAt: import_zod21.z.string().datetime(),
-  createdBy: import_zod21.z.string(),
+var ActionBase = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  transactionId: import_zod18.z.string(),
+  createdAt: import_zod18.z.string().datetime(),
+  createdBy: import_zod18.z.string(),
+  createdByRole: import_zod18.z.string(),
   declaration: ActionUpdate,
   annotation: ActionUpdate.optional(),
-  createdAtLocation: import_zod21.z.string(),
-  status: import_zod21.z.enum([
+  createdAtLocation: import_zod18.z.string(),
+  status: import_zod18.z.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
   ]),
   // If the action is an asynchronous confirmation for another action, we will save the original action id here.
-  originalActionId: import_zod21.z.string().optional()
+  originalActionId: import_zod18.z.string().optional()
 });
 var AssignedAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod21.z.string()
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.ASSIGN),
+    assignedTo: import_zod18.z.string()
   })
 );
 var UnassignedAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.UNASSIGN),
-    assignedTo: import_zod21.z.literal(null).default(null)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.UNASSIGN),
+    assignedTo: import_zod18.z.literal(null)
   })
 );
 var RegisterAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.REGISTER),
-    registrationNumber: import_zod21.z.string().optional()
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.REGISTER),
+    registrationNumber: import_zod18.z.string().optional()
   })
 );
 var DeclareAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.DECLARE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.DECLARE)
   })
 );
 var ValidateAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.VALIDATE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.VALIDATE)
   })
 );
 var RejectAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.REJECT)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.REJECT)
   })
 );
 var MarkAsDuplicateAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.MARKED_AS_DUPLICATE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.ARCHIVE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.ARCHIVE)
   })
 );
 var CreatedAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.CREATE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.CREATE)
   })
 );
 var NotifiedAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.NOTIFY)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.NOTIFY)
   })
 );
 var PrintCertificateAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.PRINT_CERTIFICATE)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RequestedCorrectionAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.REQUEST_CORRECTION)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.REQUEST_CORRECTION)
   })
 );
 var ApprovedCorrectionAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.APPROVE_CORRECTION),
-    requestId: import_zod21.z.string()
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.APPROVE_CORRECTION),
+    requestId: import_zod18.z.string()
   })
 );
 var RejectedCorrectionAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.REJECT_CORRECTION),
-    requestId: import_zod21.z.string()
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.REJECT_CORRECTION),
+    requestId: import_zod18.z.string()
   })
 );
 var ReadAction = ActionBase.merge(
-  import_zod21.z.object({
-    type: import_zod21.z.literal(ActionType.READ)
+  import_zod18.z.object({
+    type: import_zod18.z.literal(ActionType.READ)
   })
 );
-var ActionDocument = import_zod21.z.discriminatedUnion("type", [
-  CreatedAction,
-  ValidateAction,
-  RejectAction,
-  MarkAsDuplicateAction,
-  ArchiveAction,
-  NotifiedAction,
-  RegisterAction,
-  DeclareAction,
-  AssignedAction,
-  RequestedCorrectionAction,
-  ApprovedCorrectionAction,
-  RejectedCorrectionAction,
-  UnassignedAction,
-  PrintCertificateAction,
-  ReadAction
-]);
+var ActionDocument = import_zod18.z.discriminatedUnion("type", [
+  CreatedAction.openapi({ ref: "CreatedAction" }),
+  ValidateAction.openapi({ ref: "ValidateAction" }),
+  RejectAction.openapi({ ref: "RejectAction" }),
+  MarkAsDuplicateAction.openapi({ ref: "MarkAsDuplicateAction" }),
+  ArchiveAction.openapi({ ref: "ArchiveAction" }),
+  NotifiedAction.openapi({ ref: "NotifiedAction" }),
+  RegisterAction.openapi({ ref: "RegisterAction" }),
+  DeclareAction.openapi({ ref: "DeclareAction" }),
+  AssignedAction.openapi({ ref: "AssignedAction" }),
+  RequestedCorrectionAction.openapi({ ref: "RequestedCorrectionAction" }),
+  ApprovedCorrectionAction.openapi({ ref: "ApprovedCorrectionAction" }),
+  RejectedCorrectionAction.openapi({ ref: "RejectedCorrectionAction" }),
+  UnassignedAction.openapi({ ref: "UnassignedAction" }),
+  PrintCertificateAction.openapi({ ref: "PrintCertificateAction" }),
+  ReadAction.openapi({ ref: "ReadAction" })
+]).openapi({
+  ref: "ActionDocument"
+});
 var AsyncRejectActionDocument = ActionBase.omit({
   declaration: true,
   annotation: true,
   createdBy: true,
+  createdByRole: true,
   createdAtLocation: true
 }).merge(
-  import_zod21.z.object({
-    type: import_zod21.z.enum(ConfirmableActions),
-    status: import_zod21.z.literal(ActionStatus.Rejected)
+  import_zod18.z.object({
+    type: import_zod18.z.enum(ConfirmableActions),
+    status: import_zod18.z.literal(ActionStatus.Rejected)
   })
 );
-var Action = import_zod21.z.union([ActionDocument, AsyncRejectActionDocument]);
-var ResolvedUser = import_zod21.z.object({
-  id: import_zod21.z.string(),
-  role: import_zod21.z.string(),
-  name: import_zod21.z.array(
-    import_zod21.z.object({
-      use: import_zod21.z.string(),
-      given: import_zod21.z.array(import_zod21.z.string()),
-      family: import_zod21.z.string()
+var Action = import_zod18.z.union([ActionDocument, AsyncRejectActionDocument]);
+var ResolvedUser = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  role: import_zod18.z.string(),
+  name: import_zod18.z.array(
+    import_zod18.z.object({
+      use: import_zod18.z.string(),
+      given: import_zod18.z.array(import_zod18.z.string()),
+      family: import_zod18.z.string()
     })
   )
 });
 
 // ../commons/src/events/ActionInput.ts
-var import_zod22 = require("zod");
-var BaseActionInput = import_zod22.z.object({
-  eventId: import_zod22.z.string(),
-  transactionId: import_zod22.z.string(),
+var import_zod19 = require("zod");
+var import_zod_openapi9 = require("zod-openapi");
+(0, import_zod_openapi9.extendZodWithOpenApi)(import_zod19.z);
+var BaseActionInput = import_zod19.z.object({
+  eventId: import_zod19.z.string(),
+  transactionId: import_zod19.z.string(),
   declaration: ActionUpdate.default({}),
   annotation: ActionUpdate.optional(),
-  originalActionId: import_zod22.z.string().optional(),
-  keepAssignment: import_zod22.z.boolean().optional()
+  originalActionId: import_zod19.z.string().optional(),
+  keepAssignment: import_zod19.z.boolean().optional()
 });
 var CreateActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.CREATE).default(ActionType.CREATE),
-    createdAtLocation: import_zod22.z.string()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.CREATE).default(ActionType.CREATE),
+    createdAtLocation: import_zod19.z.string()
   })
 );
 var RegisterActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
-    registrationNumber: import_zod22.z.string().optional()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
+    registrationNumber: import_zod19.z.string().optional()
   })
 );
 var ValidateActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
-    duplicates: import_zod22.z.array(import_zod22.z.string())
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
+    duplicates: import_zod19.z.array(import_zod19.z.string())
   })
 );
 var NotifyActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
   })
 );
 var DeclareActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
   })
 );
 var PrintCertificateActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RejectDeclarationActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.REJECT).default(ActionType.REJECT)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.REJECT).default(ActionType.REJECT)
   })
 );
 var MarkedAsDuplicateActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE)
   })
 );
 var AssignActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
-    assignedTo: import_zod22.z.string()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
+    assignedTo: import_zod19.z.string()
   })
 );
 var UnassignActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
-    assignedTo: import_zod22.z.literal(null).default(null)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
+    assignedTo: import_zod19.z.literal(null).default(null)
   })
 );
 var RequestCorrectionActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
   })
 );
 var RejectCorrectionActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    requestId: import_zod22.z.string(),
-    type: import_zod22.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
+  import_zod19.z.object({
+    requestId: import_zod19.z.string(),
+    type: import_zod19.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
   })
 );
 var ApproveCorrectionActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    requestId: import_zod22.z.string(),
-    type: import_zod22.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
+  import_zod19.z.object({
+    requestId: import_zod19.z.string(),
+    type: import_zod19.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
   })
 );
 var ReadActionInput = BaseActionInput.merge(
-  import_zod22.z.object({
-    type: import_zod22.z.literal(ActionType.READ).default(ActionType.READ)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.READ).default(ActionType.READ)
   })
 );
-var ActionInput = import_zod22.z.discriminatedUnion("type", [
-  CreateActionInput,
-  ValidateActionInput,
-  RegisterActionInput,
-  NotifyActionInput,
-  DeclareActionInput,
-  RejectDeclarationActionInput,
-  MarkedAsDuplicateActionInput,
-  ArchiveActionInput,
-  AssignActionInput,
-  UnassignActionInput,
-  PrintCertificateActionInput,
-  RequestCorrectionActionInput,
-  RejectCorrectionActionInput,
-  ApproveCorrectionActionInput,
-  ReadActionInput
-]);
+var DeleteActionInput = import_zod19.z.object({ eventId: import_zod19.z.string() });
+var ActionInput = import_zod19.z.discriminatedUnion("type", [
+  CreateActionInput.openapi({ ref: "CreateActionInput" }),
+  ValidateActionInput.openapi({ ref: "ValidateActionInput" }),
+  RegisterActionInput.openapi({ ref: "RegisterActionInput" }),
+  NotifyActionInput.openapi({ ref: "NotifyActionInput" }),
+  DeclareActionInput.openapi({ ref: "DeclareActionInput" }),
+  RejectDeclarationActionInput.openapi({
+    ref: "RejectDeclarationActionInput"
+  }),
+  MarkedAsDuplicateActionInput.openapi({
+    ref: "MarkedAsDuplicateActionInput"
+  }),
+  ArchiveActionInput.openapi({ ref: "ArchiveActionInput" }),
+  AssignActionInput.openapi({ ref: "AssignActionInput" }),
+  UnassignActionInput.openapi({ ref: "UnassignActionInput" }),
+  PrintCertificateActionInput.openapi({ ref: "PrintCertificateActionInput" }),
+  RequestCorrectionActionInput.openapi({
+    ref: "RequestCorrectionActionInput"
+  }),
+  RejectCorrectionActionInput.openapi({ ref: "RejectCorrectionActionInput" }),
+  ApproveCorrectionActionInput.openapi({
+    ref: "ApproveCorrectionActionInput"
+  }),
+  ReadActionInput.openapi({ ref: "ReadActionInput" })
+]).openapi({
+  ref: "ActionInput"
+});
 
 // ../commons/src/events/Draft.ts
-var Draft = import_zod23.z.object({
-  id: import_zod23.z.string(),
-  eventId: import_zod23.z.string(),
-  transactionId: import_zod23.z.string(),
-  createdAt: import_zod23.z.string().datetime(),
+var Draft = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  eventId: import_zod20.z.string(),
+  transactionId: import_zod20.z.string(),
+  createdAt: import_zod20.z.string().datetime(),
   action: ActionBase.extend({
     type: ActionTypes
   }).omit({ id: true })
@@ -2170,33 +2013,132 @@ var DraftInput = BaseActionInput.extend({
   type: ActionTypes
 });
 
+// ../commons/src/events/EventMetadata.ts
+var import_zod21 = require("zod");
+var EventStatus = {
+  CREATED: "CREATED",
+  NOTIFIED: "NOTIFIED",
+  DECLARED: "DECLARED",
+  VALIDATED: "VALIDATED",
+  REGISTERED: "REGISTERED",
+  CERTIFIED: "CERTIFIED",
+  REJECTED: "REJECTED",
+  ARCHIVED: "ARCHIVED"
+};
+var eventStatuses = Object.values(EventStatus);
+var EventStatuses = import_zod21.z.nativeEnum(EventStatus);
+var EventMetadata = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  type: import_zod21.z.string(),
+  status: EventStatuses,
+  createdAt: import_zod21.z.string().datetime(),
+  createdBy: import_zod21.z.string(),
+  updatedByUserRole: import_zod21.z.string(),
+  createdAtLocation: import_zod21.z.string(),
+  updatedAtLocation: import_zod21.z.string(),
+  modifiedAt: import_zod21.z.string().datetime(),
+  assignedTo: import_zod21.z.string().nullish(),
+  updatedBy: import_zod21.z.string(),
+  trackingId: import_zod21.z.string(),
+  registrationNumber: import_zod21.z.string().nullish()
+});
+var eventMetadataLabelMap = {
+  "event.assignedTo": {
+    id: "event.assignedTo.label",
+    defaultMessage: "Assigned To",
+    description: "Assigned To"
+  },
+  "event.createdAt": {
+    id: "event.createdAt.label",
+    defaultMessage: "Created",
+    description: "Created At"
+  },
+  "event.createdAtLocation": {
+    id: "event.createdAtLocation.label",
+    defaultMessage: "Location",
+    description: "Created At Location"
+  },
+  "event.updatedAtLocation": {
+    id: "event.updatedAtLocation.label",
+    defaultMessage: "Location",
+    description: "Updated At Location"
+  },
+  "event.createdBy": {
+    id: "event.createdBy.label",
+    defaultMessage: "Created By",
+    description: "Created By"
+  },
+  "event.updatedByUserRole": {
+    id: "event.updatedByUserRole.label",
+    defaultMessage: "Updated By Role",
+    description: "Updated By Role"
+  },
+  "event.id": {
+    id: "event.id.label",
+    defaultMessage: "ID",
+    description: "ID"
+  },
+  "event.modifiedAt": {
+    id: "event.modifiedAt.label",
+    defaultMessage: "Updated",
+    description: "Modified At"
+  },
+  "event.status": {
+    id: "event.status.label",
+    defaultMessage: "Status",
+    description: "Status"
+  },
+  "event.type": {
+    id: "event.type.label",
+    defaultMessage: "Type",
+    description: "Type"
+  },
+  "event.updatedBy": {
+    id: "event.updatedBy.label",
+    defaultMessage: "Updated By",
+    description: "Updated By"
+  },
+  "event.trackingId": {
+    id: "event.trackingId.label",
+    defaultMessage: "Tracking ID",
+    description: "Tracking ID"
+  },
+  "event.registrationNumber": {
+    id: "event.registrationNumber.label",
+    defaultMessage: "Registration Number",
+    description: "Registration Number"
+  }
+};
+
 // ../commons/src/events/EventInput.ts
-var import_zod24 = require("zod");
-var EventInput = import_zod24.z.object({
-  transactionId: import_zod24.z.string(),
-  type: import_zod24.z.string()
+var import_zod22 = require("zod");
+var EventInput = import_zod22.z.object({
+  transactionId: import_zod22.z.string(),
+  type: import_zod22.z.string()
 });
 
 // ../commons/src/events/EventDocument.ts
-var import_zod25 = require("zod");
-var EventDocument = import_zod25.z.object({
-  id: import_zod25.z.string(),
-  type: import_zod25.z.string(),
-  createdAt: import_zod25.z.string().datetime(),
-  updatedAt: import_zod25.z.string().datetime(),
-  updatedAtLocation: import_zod25.z.string(),
-  actions: import_zod25.z.array(Action),
-  trackingId: import_zod25.z.string()
-});
+var import_zod23 = require("zod");
+var import_zod_openapi10 = require("zod-openapi");
+(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod23.z);
+var EventDocument = import_zod23.z.object({
+  id: import_zod23.z.string(),
+  type: import_zod23.z.string(),
+  createdAt: import_zod23.z.string().datetime(),
+  updatedAt: import_zod23.z.string().datetime(),
+  updatedAtLocation: import_zod23.z.string(),
+  actions: import_zod23.z.array(Action),
+  trackingId: import_zod23.z.string()
+}).openapi({ ref: "EventDocument" });
 
 // ../commons/src/events/EventIndex.ts
-var import_zod26 = require("zod");
+var import_zod24 = require("zod");
 var EventIndex = EventMetadata.extend({
-  declaration: import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any())
+  declaration: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.any())
 });
-var EventSearchIndex = import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any()).and(
-  import_zod26.z.object({
-    type: import_zod26.z.string()
+var EventSearchIndex = import_zod24.z.record(import_zod24.z.string(), import_zod24.z.any()).and(
+  import_zod24.z.object({
+    type: import_zod24.z.string()
     // Ensures "type" (event-id) exists and is a string
   })
 );
@@ -2238,6 +2180,18 @@ function getStatusFromActions(actions) {
     }
   }, EventStatus.CREATED);
 }
+function getLastUpdatedByUserRoleFromActions(actions) {
+  const actionsWithRoles = actions.filter(
+    (action) => !isWriteAction(action.type) && action.status !== ActionStatus.Rejected
+  ).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const lastAction = actionsWithRoles.at(-1);
+  if (!lastAction) {
+    throw new Error(
+      "Should never happen, at least CREATE action should be present"
+    );
+  }
+  return ActionDocument.parse(lastAction).createdByRole;
+}
 function getAssignedUserFromActions(actions) {
   return actions.reduce((user2, action) => {
     if (action.type === ActionType.ASSIGN) {
@@ -2318,7 +2272,8 @@ function getCurrentEventState(event2) {
     updatedAtLocation: event2.updatedAtLocation,
     declaration: aggregateActionDeclarations(activeActions),
     trackingId: event2.trackingId,
-    registrationNumber
+    registrationNumber,
+    updatedByUserRole: getLastUpdatedByUserRoleFromActions(event2.actions)
   });
 }
 function getCurrentEventStateWithDrafts(event2, drafts) {
@@ -2366,7 +2321,7 @@ function getAnnotationFromDrafts(drafts) {
 function getActionAnnotation({
   event: event2,
   actionType,
-  drafts
+  drafts = []
 }) {
   const activeActions = getAcceptedActions(event2);
   const action = activeActions.find(
@@ -2385,7 +2340,6 @@ function getActionAnnotation({
 
 // ../commons/src/events/defineConfig.ts
 var defineConfig = (config) => {
-  validateWorkqueueConfig(config.workqueues);
   const input = EventConfig.parse(config);
   return input;
 };
@@ -3662,28 +3616,6 @@ var tennisClubMembershipEvent = defineConfig({
       }
     ]
   },
-  workqueues: [
-    {
-      id: "all",
-      filters: []
-    },
-    {
-      id: "ready-for-review",
-      filters: [
-        {
-          status: ["DECLARED"]
-        }
-      ]
-    },
-    {
-      id: "registered",
-      filters: [
-        {
-          status: ["REGISTERED"]
-        }
-      ]
-    }
-  ],
   actions: [
     {
       type: ActionType.DECLARE,
@@ -4062,6 +3994,7 @@ var eventPayloadGenerator = {
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       transactionId: getUUID(),
       action: {
+        transactionId: getUUID(),
         type: actionType,
         status: ActionStatus.Accepted,
         declaration: {
@@ -4076,6 +4009,7 @@ var eventPayloadGenerator = {
         },
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         createdBy: "@todo",
+        createdByRole: "@todo",
         createdAtLocation: "@todo"
       }
     },
@@ -4237,12 +4171,14 @@ function generateActionDocument({
     // @TODO: This should be fixed in the future.
     createdAt: new Date(Date.now() - 500).toISOString(),
     createdBy: getUUID(),
+    createdByRole: "FIELD_AGENT",
     id: getUUID(),
     createdAtLocation: "TODO",
     declaration: generateActionDeclarationInput(configuration, action),
     annotation: {},
     ...defaults,
-    status: ActionStatus.Accepted
+    status: ActionStatus.Accepted,
+    transactionId: getUUID()
   };
   switch (action) {
     case ActionType.READ:
@@ -4334,6 +4270,7 @@ var eventQueryDataGenerator = (overrides = {}) => ({
   modifiedAt: overrides.modifiedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
   assignedTo: overrides.assignedTo ?? null,
   updatedBy: overrides.updatedBy ?? getUUID(),
+  updatedByUserRole: overrides.updatedByUserRole ?? "FIELD_AGENT",
   declaration: overrides.declaration ?? {
     "recommender.none": true,
     "applicant.firstname": "Danny",