@opencrvs/toolkit 1.8.1-rc.c6281e8 → 1.8.1-rc.c7fcaa3

package/dist/events/index.js

@@ -40,6 +40,7 @@ __export(events_exports, {
   ActionConfigBase: () => ActionConfigBase,
   ActionCreationMetadata: () => ActionCreationMetadata,
   ActionDocument: () => ActionDocument,
+  ActionFlag: () => ActionFlag,
   ActionFormConfig: () => ActionFormConfig,
   ActionInput: () => ActionInput,
   ActionStatus: () => ActionStatus,
@@ -51,6 +52,7 @@ __export(events_exports, {
   AddressType: () => AddressType,
   AdministrativeAreas: () => AdministrativeAreas,
   AdvancedSearchConfig: () => AdvancedSearchConfig,
+  AnyFileField: () => AnyFileField,
   AnyOf: () => AnyOf,
   AnyOfStatus: () => AnyOfStatus,
   ApproveCorrectionActionInput: () => ApproveCorrectionActionInput,
@@ -95,6 +97,7 @@ __export(events_exports, {
   EventDocument: () => EventDocument,
   EventFieldConfigSchema: () => EventFieldConfigSchema,
   EventFieldId: () => EventFieldId,
+  EventFieldIdInput: () => EventFieldIdInput,
   EventIndex: () => EventIndex,
   EventInput: () => EventInput,
   EventMetadata: () => EventMetadata,
@@ -115,6 +118,7 @@ __export(events_exports, {
   FieldType: () => FieldType,
   FieldUpdateValue: () => FieldUpdateValue,
   FieldValue: () => FieldValue,
+  FileFieldType: () => FileFieldType,
   FileFieldValue: () => FileFieldValue,
   FileFieldValueWithOption: () => FileFieldValueWithOption,
   FileFieldWithOptionValue: () => FileFieldWithOptionValue,
@@ -129,8 +133,10 @@ __export(events_exports, {
   InherentFlags: () => InherentFlags,
   LanguageConfig: () => LanguageConfig,
   LegalStatuses: () => LegalStatuses,
+  METADATA_FIELD_PREFIX: () => METADATA_FIELD_PREFIX,
   MarkedAsDuplicateActionInput: () => MarkedAsDuplicateActionInput,
   MimeType: () => MimeType,
+  NameConfig: () => NameConfig,
   NameFieldUpdateValue: () => NameFieldUpdateValue,
   NameFieldValue: () => NameFieldValue,
   NonEmptyTextValue: () => NonEmptyTextValue,
@@ -139,6 +145,7 @@ __export(events_exports, {
   PageConfig: () => PageConfig,
   PageTypes: () => PageTypes,
   PrintCertificateActionInput: () => PrintCertificateActionInput,
+  PrintContent: () => PrintContent,
   QueryExpression: () => QueryExpression,
   QueryInput: () => QueryInput,
   QueryType: () => QueryType,
@@ -167,6 +174,7 @@ __export(events_exports, {
   TENNIS_CLUB_MEMBERSHIP: () => TENNIS_CLUB_MEMBERSHIP,
   TEST_SYSTEM_IANA_TIMEZONE: () => TEST_SYSTEM_IANA_TIMEZONE,
   TestUserRole: () => TestUserRole,
+  TextField: () => TextField,
   TextValue: () => TextValue,
   TimeValue: () => TimeValue,
   TranslationConfig: () => TranslationConfig,
@@ -178,7 +186,6 @@ __export(events_exports, {
   ValidationConfig: () => ValidationConfig,
   VerificationActionConfig: () => VerificationActionConfig,
   VerificationPageConfig: () => VerificationPageConfig,
-  VisibleStatus: () => VisibleStatus,
   WRITE_ACTION_SCOPES: () => WRITE_ACTION_SCOPES,
   Within: () => Within,
   WorkqueueActionsWithDefault: () => WorkqueueActionsWithDefault,
@@ -196,13 +203,15 @@ __export(events_exports, {
   and: () => and,
   annotationActions: () => annotationActions,
   applyDeclarationToEventIndex: () => applyDeclarationToEventIndex,
-  applyDraftsToEventIndex: () => applyDraftsToEventIndex,
+  applyDraftToEventIndex: () => applyDraftToEventIndex,
+  areCertificateConditionsMet: () => areCertificateConditionsMet,
   areConditionsMet: () => areConditionsMet,
   compositeFieldTypes: () => compositeFieldTypes,
   createEmptyDraft: () => createEmptyDraft,
   createFieldConditionals: () => createFieldConditionals,
   createPrng: () => createPrng,
   createValidationSchema: () => createValidationSchema,
+  dangerouslyGetCurrentEventStateWithDrafts: () => dangerouslyGetCurrentEventStateWithDrafts,
   deepDropNulls: () => deepDropNulls,
   deepMerge: () => deepMerge,
   defaultWorkqueueColumns: () => defaultWorkqueueColumns,
@@ -224,7 +233,7 @@ __export(events_exports, {
   eventQueryDataGenerator: () => eventQueryDataGenerator,
   field: () => field,
   fieldTypes: () => fieldTypes,
-  findActiveDrafts: () => findActiveDrafts,
+  findActiveDraftForEvent: () => findActiveDraftForEvent,
   findAllFields: () => findAllFields,
   findLastAssignmentAction: () => findLastAssignmentAction,
   findRecordActionPages: () => findRecordActionPages,
@@ -252,7 +261,6 @@ __export(events_exports, {
   getAssignedUserSignatureFromActions: () => getAssignedUserSignatureFromActions,
   getAvailableActionsForEvent: () => getAvailableActionsForEvent,
   getCurrentEventState: () => getCurrentEventState,
-  getCurrentEventStateWithDrafts: () => getCurrentEventStateWithDrafts,
   getDeclaration: () => getDeclaration,
   getDeclarationFieldById: () => getDeclarationFieldById,
   getDeclarationFields: () => getDeclarationFields,
@@ -312,6 +320,7 @@ __export(events_exports, {
   mapFieldTypeToEmptyValue: () => mapFieldTypeToEmptyValue,
   mapFieldTypeToMockValue: () => mapFieldTypeToMockValue,
   mapFieldTypeToZod: () => mapFieldTypeToZod,
+  mergeDrafts: () => mergeDrafts,
   never: () => never,
   not: () => not,
   omitHiddenAnnotationFields: () => omitHiddenAnnotationFields,
@@ -320,6 +329,7 @@ __export(events_exports, {
   or: () => or,
   resolveDateOfEvent: () => resolveDateOfEvent,
   runFieldValidations: () => runFieldValidations,
+  runStructuralValidations: () => runStructuralValidations,
   timePeriodToDateRange: () => timePeriodToDateRange,
   user: () => user,
   validate: () => validate,
@@ -334,7 +344,7 @@ var TENNIS_CLUB_MEMBERSHIP = "tennis-club-membership";
 var BIRTH_EVENT = "v2-birth";
 
 // ../commons/src/events/ActionConfig.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 
 // ../commons/src/events/Conditional.ts
 var import_zod = require("zod");
@@ -504,9 +514,10 @@ function isMetaAction(actionType) {
 }
 
 // ../commons/src/events/FieldConfig.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 
 // ../commons/src/events/FieldType.ts
+var import_zod4 = require("zod");
 var FieldType = {
   NAME: "NAME",
   PHONE: "PHONE",
@@ -539,6 +550,11 @@ var FieldType = {
   SIGNATURE: "SIGNATURE",
   DATA: "DATA"
 };
+var FileFieldType = import_zod4.z.enum([
+  FieldType.FILE,
+  FieldType.FILE_WITH_OPTIONS,
+  FieldType.SIGNATURE
+]);
 var fieldTypes = Object.values(FieldType);
 var compositeFieldTypes = [
   FieldType.DATE_RANGE,
@@ -548,24 +564,24 @@ var compositeFieldTypes = [
 ];
 
 // ../commons/src/events/FieldValue.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 
 // ../commons/src/documents.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 var import_zod_openapi3 = require("zod-openapi");
-(0, import_zod_openapi3.extendZodWithOpenApi)(import_zod4.z);
-var FullDocumentURL = import_zod4.z.string().brand("FullDocumentURL").describe(
+(0, import_zod_openapi3.extendZodWithOpenApi)(import_zod5.z);
+var FullDocumentUrl = import_zod5.z.string().brand("FullDocumentUrl").describe(
   "A full url with protocol, host, bucket name, starting from the root of the S3 server, https://minio/bucket-name/document-id.jpg"
 );
-var FullDocumentPath = import_zod4.z.string().transform((val) => val.startsWith("/") ? val : `/${val}`).openapi({ effectType: "input", type: "string" }).describe(
+var FullDocumentPath = import_zod5.z.string().transform((val) => val.startsWith("/") ? val : `/${val}`).openapi({ effectType: "input", type: "string" }).describe(
   "A full absolute path with bucket name, starting from the root of the S3 server, /bucket-name/document-id.jpg"
 );
-var DocumentPath = import_zod4.z.string().brand("DocumentPath").describe(
+var DocumentPath = import_zod5.z.string().brand("DocumentPath").describe(
   "A full identifier starting from the root of the S3 bucket, e.g. /document-id.jpg or /directory/document-id.jpg but never /bucket-name/document-id.jpg"
 );
 
 // ../commons/src/events/CompositeFieldValue.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 var GeographicalArea = {
   URBAN: "URBAN",
   RURAL: "RURAL"
@@ -574,110 +590,110 @@ var AddressType = {
   DOMESTIC: "DOMESTIC",
   INTERNATIONAL: "INTERNATIONAL"
 };
-var FileFieldValue = import_zod5.z.object({
+var FileFieldValue = import_zod6.z.object({
   path: FullDocumentPath,
-  originalFilename: import_zod5.z.string(),
-  type: import_zod5.z.string()
+  originalFilename: import_zod6.z.string(),
+  type: import_zod6.z.string()
 });
-var AdminStructure = import_zod5.z.object({
-  country: import_zod5.z.string(),
-  addressType: import_zod5.z.literal(AddressType.DOMESTIC),
-  province: import_zod5.z.string(),
-  district: import_zod5.z.string()
+var AdminStructure = import_zod6.z.object({
+  country: import_zod6.z.string(),
+  addressType: import_zod6.z.literal(AddressType.DOMESTIC),
+  province: import_zod6.z.string(),
+  district: import_zod6.z.string()
 });
 var UrbanAddressValue = AdminStructure.extend({
-  urbanOrRural: import_zod5.z.literal(GeographicalArea.URBAN),
-  town: import_zod5.z.string().optional(),
-  residentialArea: import_zod5.z.string().optional(),
-  street: import_zod5.z.string().optional(),
-  number: import_zod5.z.string().optional(),
-  zipCode: import_zod5.z.string().optional()
+  urbanOrRural: import_zod6.z.literal(GeographicalArea.URBAN),
+  town: import_zod6.z.string().optional(),
+  residentialArea: import_zod6.z.string().optional(),
+  street: import_zod6.z.string().optional(),
+  number: import_zod6.z.string().optional(),
+  zipCode: import_zod6.z.string().optional()
 });
 var RuralAddressValue = AdminStructure.extend({
-  urbanOrRural: import_zod5.z.literal(GeographicalArea.RURAL),
-  village: import_zod5.z.string().optional()
+  urbanOrRural: import_zod6.z.literal(GeographicalArea.RURAL),
+  village: import_zod6.z.string().optional()
 });
 var UrbanAddressUpdateValue = AdminStructure.extend({
-  urbanOrRural: import_zod5.z.literal(GeographicalArea.URBAN),
-  town: import_zod5.z.string().nullish(),
-  residentialArea: import_zod5.z.string().nullish(),
-  street: import_zod5.z.string().nullish(),
-  number: import_zod5.z.string().nullish(),
-  zipCode: import_zod5.z.string().nullish()
+  urbanOrRural: import_zod6.z.literal(GeographicalArea.URBAN),
+  town: import_zod6.z.string().nullish(),
+  residentialArea: import_zod6.z.string().nullish(),
+  street: import_zod6.z.string().nullish(),
+  number: import_zod6.z.string().nullish(),
+  zipCode: import_zod6.z.string().nullish()
 });
-var NameFieldValue = import_zod5.z.object({
-  firstname: import_zod5.z.string(),
-  surname: import_zod5.z.string(),
-  middlename: import_zod5.z.string().optional()
+var NameFieldValue = import_zod6.z.object({
+  firstname: import_zod6.z.string(),
+  surname: import_zod6.z.string(),
+  middlename: import_zod6.z.string().optional()
 });
-var NameFieldUpdateValue = import_zod5.z.object({
-  firstname: import_zod5.z.string().nullish(),
-  surname: import_zod5.z.string().nullish(),
-  middlename: import_zod5.z.string().nullish()
-}).or(import_zod5.z.null()).or(import_zod5.z.undefined());
+var NameFieldUpdateValue = import_zod6.z.object({
+  firstname: import_zod6.z.string(),
+  surname: import_zod6.z.string(),
+  middlename: import_zod6.z.string().nullish()
+}).or(import_zod6.z.null()).or(import_zod6.z.undefined());
 var RuralAddressUpdateValue = AdminStructure.extend({
-  urbanOrRural: import_zod5.z.literal(GeographicalArea.RURAL),
-  village: import_zod5.z.string().nullish()
+  urbanOrRural: import_zod6.z.literal(GeographicalArea.RURAL),
+  village: import_zod6.z.string().nullish()
 });
-var GenericAddressValue = import_zod5.z.object({
-  country: import_zod5.z.string(),
-  addressType: import_zod5.z.literal(AddressType.INTERNATIONAL),
-  state: import_zod5.z.string(),
-  district2: import_zod5.z.string(),
-  cityOrTown: import_zod5.z.string().optional(),
-  addressLine1: import_zod5.z.string().optional(),
-  addressLine2: import_zod5.z.string().optional(),
-  addressLine3: import_zod5.z.string().optional(),
-  postcodeOrZip: import_zod5.z.string().optional()
+var GenericAddressValue = import_zod6.z.object({
+  country: import_zod6.z.string(),
+  addressType: import_zod6.z.literal(AddressType.INTERNATIONAL),
+  state: import_zod6.z.string(),
+  district2: import_zod6.z.string(),
+  cityOrTown: import_zod6.z.string().optional(),
+  addressLine1: import_zod6.z.string().optional(),
+  addressLine2: import_zod6.z.string().optional(),
+  addressLine3: import_zod6.z.string().optional(),
+  postcodeOrZip: import_zod6.z.string().optional()
 });
-var AddressFieldValue = import_zod5.z.discriminatedUnion("urbanOrRural", [UrbanAddressValue, RuralAddressValue]).or(GenericAddressValue);
-var GenericAddressUpdateValue = import_zod5.z.object({
-  country: import_zod5.z.string(),
-  addressType: import_zod5.z.literal(AddressType.INTERNATIONAL),
-  state: import_zod5.z.string(),
-  district2: import_zod5.z.string(),
-  cityOrTown: import_zod5.z.string().nullish(),
-  addressLine1: import_zod5.z.string().nullish(),
-  addressLine2: import_zod5.z.string().nullish(),
-  addressLine3: import_zod5.z.string().nullish(),
-  postcodeOrZip: import_zod5.z.string().nullish()
+var AddressFieldValue = import_zod6.z.discriminatedUnion("urbanOrRural", [UrbanAddressValue, RuralAddressValue]).or(GenericAddressValue);
+var GenericAddressUpdateValue = import_zod6.z.object({
+  country: import_zod6.z.string(),
+  addressType: import_zod6.z.literal(AddressType.INTERNATIONAL),
+  state: import_zod6.z.string(),
+  district2: import_zod6.z.string(),
+  cityOrTown: import_zod6.z.string().nullish(),
+  addressLine1: import_zod6.z.string().nullish(),
+  addressLine2: import_zod6.z.string().nullish(),
+  addressLine3: import_zod6.z.string().nullish(),
+  postcodeOrZip: import_zod6.z.string().nullish()
 });
-var AddressFieldUpdateValue = import_zod5.z.discriminatedUnion("urbanOrRural", [
+var AddressFieldUpdateValue = import_zod6.z.discriminatedUnion("urbanOrRural", [
   UrbanAddressUpdateValue,
   RuralAddressUpdateValue
 ]).or(GenericAddressUpdateValue);
-var FileFieldValueWithOption = import_zod5.z.object({
+var FileFieldValueWithOption = import_zod6.z.object({
   path: FullDocumentPath,
-  originalFilename: import_zod5.z.string(),
-  type: import_zod5.z.string(),
-  option: import_zod5.z.string()
+  originalFilename: import_zod6.z.string(),
+  type: import_zod6.z.string(),
+  option: import_zod6.z.string()
 });
-var FileFieldWithOptionValue = import_zod5.z.array(FileFieldValueWithOption);
+var FileFieldWithOptionValue = import_zod6.z.array(FileFieldValueWithOption);
 
 // ../commons/src/events/FieldValue.ts
-var TextValue = import_zod6.z.string();
+var TextValue = import_zod7.z.string();
 var NonEmptyTextValue = TextValue.min(1);
-var DateValue = import_zod6.z.string().date().describe("Date in the format YYYY-MM-DD");
-var TimeValue = import_zod6.z.string().regex(/^([01][0-9]|2[0-3]):[0-5][0-9]$/);
-var DatetimeValue = import_zod6.z.string().datetime();
-var SelectDateRangeValue = import_zod6.z.enum([
+var DateValue = import_zod7.z.string().date().describe("Date in the format YYYY-MM-DD");
+var TimeValue = import_zod7.z.string().regex(/^([01][0-9]|2[0-3]):[0-5][0-9]$/);
+var DatetimeValue = import_zod7.z.string().datetime();
+var SelectDateRangeValue = import_zod7.z.enum([
   "last7Days",
   "last30Days",
   "last90Days",
   "last365Days"
 ]);
-var DateRangeFieldValue = import_zod6.z.object({
+var DateRangeFieldValue = import_zod7.z.object({
   start: DateValue,
   end: DateValue
 }).or(DateValue).describe(
   "Date range with start and end dates in the format YYYY-MM-DD. Inclusive start, exclusive end."
 );
-var EmailValue = import_zod6.z.string().email();
-var CheckboxFieldValue = import_zod6.z.boolean();
-var NumberFieldValue = import_zod6.z.number();
-var DataFieldValue = import_zod6.z.undefined();
-var SignatureFieldValue = import_zod6.z.string();
-var FieldValue = import_zod6.z.union([
+var EmailValue = import_zod7.z.string().email();
+var CheckboxFieldValue = import_zod7.z.boolean();
+var NumberFieldValue = import_zod7.z.number();
+var DataFieldValue = import_zod7.z.undefined();
+var SignatureFieldValue = import_zod7.z.string();
+var FieldValue = import_zod7.z.union([
   TextValue,
   DateValue,
   TimeValue,
@@ -694,7 +710,7 @@ var FieldValue = import_zod6.z.union([
   NameFieldValue,
   NameFieldUpdateValue
 ]);
-var FieldUpdateValue = import_zod6.z.union([
+var FieldUpdateValue = import_zod7.z.union([
   TextValue,
   DateValue,
   TimeValue,
@@ -713,67 +729,67 @@ var FieldUpdateValue = import_zod6.z.union([
 
 // ../commons/src/events/FieldConfig.ts
 var import_zod_openapi4 = require("zod-openapi");
-(0, import_zod_openapi4.extendZodWithOpenApi)(import_zod7.z);
-var FieldId = import_zod7.z.string().describe("Unique identifier for the field");
-var FieldReference = import_zod7.z.object({
+(0, import_zod_openapi4.extendZodWithOpenApi)(import_zod8.z);
+var FieldId = import_zod8.z.string().describe("Unique identifier for the field");
+var FieldReference = import_zod8.z.object({
   $$field: FieldId
 }).describe("Reference to a field by its ID");
-var ValidationConfig = import_zod7.z.object({
+var ValidationConfig = import_zod8.z.object({
   validator: Conditional,
   message: TranslationConfig
 });
-var BaseField = import_zod7.z.object({
+var BaseField = import_zod8.z.object({
   id: FieldId,
   label: TranslationConfig,
   parent: FieldReference.optional().describe(
     "Reference to a parent field. If a field has a parent, it will be reset when the parent field is changed."
   ),
-  required: import_zod7.z.boolean().default(false).optional(),
-  conditionals: import_zod7.z.array(FieldConditional).default([]).optional(),
-  secured: import_zod7.z.boolean().default(false).optional(),
+  required: import_zod8.z.boolean().default(false).optional(),
+  conditionals: import_zod8.z.array(FieldConditional).default([]).optional(),
+  secured: import_zod8.z.boolean().default(false).optional(),
   placeholder: TranslationConfig.optional(),
-  validation: import_zod7.z.array(ValidationConfig).default([]).optional(),
+  validation: import_zod8.z.array(ValidationConfig).default([]).optional(),
   helperText: TranslationConfig.optional(),
-  hideLabel: import_zod7.z.boolean().default(false).optional(),
-  uncorrectable: import_zod7.z.boolean().default(false).optional().describe(
+  hideLabel: import_zod8.z.boolean().default(false).optional(),
+  uncorrectable: import_zod8.z.boolean().default(false).optional().describe(
     "Indicates if the field can be changed during a record correction."
   )
 });
 var Divider = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.DIVIDER)
+  type: import_zod8.z.literal(FieldType.DIVIDER)
 });
 var TextField = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.TEXT),
+  type: import_zod8.z.literal(FieldType.TEXT),
   defaultValue: NonEmptyTextValue.optional(),
-  configuration: import_zod7.z.object({
-    maxLength: import_zod7.z.number().optional().describe("Maximum length of the text"),
-    type: import_zod7.z.enum(["text", "password"]).optional(),
+  configuration: import_zod8.z.object({
+    maxLength: import_zod8.z.number().optional().describe("Maximum length of the text"),
+    type: import_zod8.z.enum(["text", "password"]).optional(),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).default({ type: "text" }).optional()
 }).describe("Text input");
 var NumberField = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.NUMBER),
+  type: import_zod8.z.literal(FieldType.NUMBER),
   defaultValue: NumberFieldValue.optional(),
-  configuration: import_zod7.z.object({
-    min: import_zod7.z.number().optional().describe("Minimum value"),
-    max: import_zod7.z.number().optional().describe("Maximum value"),
+  configuration: import_zod8.z.object({
+    min: import_zod8.z.number().optional().describe("Minimum value"),
+    max: import_zod8.z.number().optional().describe("Maximum value"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).optional()
 }).describe("Number input");
 var TextAreaField = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.TEXTAREA),
+  type: import_zod8.z.literal(FieldType.TEXTAREA),
   defaultValue: NonEmptyTextValue.optional(),
-  configuration: import_zod7.z.object({
-    maxLength: import_zod7.z.number().optional().describe("Maximum length of the text"),
-    rows: import_zod7.z.number().optional().describe("Number of visible text lines"),
-    cols: import_zod7.z.number().optional().describe("Number of visible columns"),
+  configuration: import_zod8.z.object({
+    maxLength: import_zod8.z.number().optional().describe("Maximum length of the text"),
+    rows: import_zod8.z.number().optional().describe("Number of visible text lines"),
+    cols: import_zod8.z.number().optional().describe("Number of visible columns"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).default({ rows: 4 }).optional()
 }).describe("Multiline text input");
-var ImageMimeType = import_zod7.z.enum([
+var ImageMimeType = import_zod8.z.enum([
   "image/png",
   "image/jpg",
   "image/jpeg",
@@ -782,53 +798,53 @@ var ImageMimeType = import_zod7.z.enum([
 var MimeType = ImageMimeType;
 var DEFAULT_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
 var SignatureField = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.SIGNATURE),
+  type: import_zod8.z.literal(FieldType.SIGNATURE),
   signaturePromptLabel: TranslationConfig.describe(
     "Title of the signature modal"
   ),
   defaultValue: SignatureFieldValue.optional(),
-  configuration: import_zod7.z.object({
-    maxFileSize: import_zod7.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+  configuration: import_zod8.z.object({
+    maxFileSize: import_zod8.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
     acceptedFileTypes: MimeType.array().optional().describe("List of allowed file formats for the signature")
   }).default({
     maxFileSize: DEFAULT_MAX_FILE_SIZE_BYTES
   })
 }).describe("Signature input field");
 var EmailField = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.EMAIL),
-  configuration: import_zod7.z.object({
-    maxLength: import_zod7.z.number().optional().describe("Maximum length of the text")
+  type: import_zod8.z.literal(FieldType.EMAIL),
+  configuration: import_zod8.z.object({
+    maxLength: import_zod8.z.number().optional().describe("Maximum length of the text")
   }).default({ maxLength: 10 }).optional(),
   defaultValue: NonEmptyTextValue.optional()
 });
 var DateField = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.DATE),
+  type: import_zod8.z.literal(FieldType.DATE),
   defaultValue: DateValue.optional(),
-  configuration: import_zod7.z.object({
+  configuration: import_zod8.z.object({
     notice: TranslationConfig.describe(
       "Text to display above the date input"
     ).optional()
   }).optional()
 }).describe("A single date input (yyyy-MM-dd)");
 var TimeField = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.TIME),
+  type: import_zod8.z.literal(FieldType.TIME),
   defaultValue: TimeValue.optional(),
-  configuration: import_zod7.z.object({
+  configuration: import_zod8.z.object({
     notice: TranslationConfig.describe(
       "Text to display above the time input"
     ).optional()
   }).optional()
 }).describe("A single date input (HH-mm)");
 var DateRangeField = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.DATE_RANGE),
+  type: import_zod8.z.literal(FieldType.DATE_RANGE),
   defaultValue: DateRangeFieldValue.optional(),
-  configuration: import_zod7.z.object({
+  configuration: import_zod8.z.object({
     notice: TranslationConfig.describe(
       "Text to display above the date input"
     ).optional()
   }).optional()
 }).describe("A date range input ({ start: yyyy-MM-dd, end: yyyy-MM-dd })");
-var HtmlFontVariant = import_zod7.z.enum([
+var HtmlFontVariant = import_zod8.z.enum([
   "reg12",
   "reg14",
   "reg16",
@@ -838,31 +854,31 @@ var HtmlFontVariant = import_zod7.z.enum([
   "h2",
   "h1"
 ]);
-var ParagraphConfiguration = import_zod7.z.object({
-  styles: import_zod7.z.object({
+var ParagraphConfiguration = import_zod8.z.object({
+  styles: import_zod8.z.object({
     fontVariant: HtmlFontVariant.optional().describe(
       "Font variant to use for the paragraph text"
     ),
-    hint: import_zod7.z.boolean().optional().describe("When true, paragraph is styled as a hint with grey color")
+    hint: import_zod8.z.boolean().optional().describe("When true, paragraph is styled as a hint with grey color")
   }).optional()
 }).default({});
 var Paragraph = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.PARAGRAPH),
+  type: import_zod8.z.literal(FieldType.PARAGRAPH),
   defaultValue: NonEmptyTextValue.optional(),
   configuration: ParagraphConfiguration
 }).describe("A read-only HTML <p> paragraph");
 var PageHeader = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.PAGE_HEADER),
+  type: import_zod8.z.literal(FieldType.PAGE_HEADER),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("A read-only header component for form pages");
 var File = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.FILE),
+  type: import_zod8.z.literal(FieldType.FILE),
   defaultValue: FileFieldValue.optional(),
-  configuration: import_zod7.z.object({
-    maxFileSize: import_zod7.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+  configuration: import_zod8.z.object({
+    maxFileSize: import_zod8.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
     acceptedFileTypes: MimeType.array().optional().describe("List of allowed file formats for the signature"),
-    style: import_zod7.z.object({
-      width: import_zod7.z.enum(["full", "auto"]).optional().describe(
+    style: import_zod8.z.object({
+      width: import_zod8.z.enum(["full", "auto"]).optional().describe(
         "Whether the file upload button should take the full width of the container or not"
       )
     }).optional(),
@@ -871,140 +887,176 @@ var File = BaseField.extend({
     maxFileSize: DEFAULT_MAX_FILE_SIZE_BYTES
   })
 }).describe("File upload");
-var SelectOption = import_zod7.z.object({
-  value: import_zod7.z.string().describe("The value of the option"),
+var SelectOption = import_zod8.z.object({
+  value: import_zod8.z.string().describe("The value of the option"),
   label: TranslationConfig.describe("The label of the option")
 });
 var RadioGroup = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.RADIO_GROUP),
+  type: import_zod8.z.literal(FieldType.RADIO_GROUP),
   defaultValue: TextValue.optional(),
-  options: import_zod7.z.array(SelectOption).describe("A list of options"),
-  configuration: import_zod7.z.object({
-    styles: import_zod7.z.object({
-      size: import_zod7.z.enum(["NORMAL", "LARGE"]).optional()
+  options: import_zod8.z.array(SelectOption).describe("A list of options"),
+  configuration: import_zod8.z.object({
+    styles: import_zod8.z.object({
+      size: import_zod8.z.enum(["NORMAL", "LARGE"]).optional()
     }).optional()
   }).optional()
 }).describe("Grouped radio options");
 var BulletList = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.BULLET_LIST),
+  type: import_zod8.z.literal(FieldType.BULLET_LIST),
   defaultValue: TextValue.optional(),
-  items: import_zod7.z.array(TranslationConfig).describe("A list of items"),
-  configuration: import_zod7.z.object({
-    styles: import_zod7.z.object({
+  items: import_zod8.z.array(TranslationConfig).describe("A list of items"),
+  configuration: import_zod8.z.object({
+    styles: import_zod8.z.object({
       fontVariant: HtmlFontVariant.optional()
     }).optional()
   }).default({})
 }).describe("A list of bullet points");
 var Select = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.SELECT),
+  type: import_zod8.z.literal(FieldType.SELECT),
   defaultValue: TextValue.optional(),
-  options: import_zod7.z.array(SelectOption).describe("A list of options")
+  options: import_zod8.z.array(SelectOption).describe("A list of options")
 }).describe("Select input");
-var SelectDateRangeOption = import_zod7.z.object({
+var SelectDateRangeOption = import_zod8.z.object({
   value: SelectDateRangeValue.describe("The value of the option"),
   label: TranslationConfig.describe("The label of the option")
 });
 var SelectDateRangeField = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.SELECT_DATE_RANGE),
+  type: import_zod8.z.literal(FieldType.SELECT_DATE_RANGE),
   defaultValue: SelectDateRangeValue.optional(),
-  options: import_zod7.z.array(SelectDateRangeOption).describe("A list of options")
+  options: import_zod8.z.array(SelectDateRangeOption).describe("A list of options")
 }).describe("Select input with date range options");
+var NameConfig = import_zod8.z.object({
+  firstname: import_zod8.z.object({ required: import_zod8.z.boolean(), label: TranslationConfig.optional() }).optional(),
+  middlename: import_zod8.z.object({ required: import_zod8.z.boolean(), label: TranslationConfig.optional() }).optional(),
+  surname: import_zod8.z.object({ required: import_zod8.z.boolean(), label: TranslationConfig.optional() }).optional()
+});
 var NameField = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.NAME),
-  defaultValue: import_zod7.z.object({
-    firstname: NonEmptyTextValue,
-    surname: NonEmptyTextValue
+  type: import_zod8.z.literal(FieldType.NAME),
+  defaultValue: import_zod8.z.object({
+    firstname: NonEmptyTextValue.optional(),
+    middlename: NonEmptyTextValue.optional(),
+    surname: NonEmptyTextValue.optional()
   }).optional(),
-  configuration: import_zod7.z.object({
-    maxLength: import_zod7.z.number().optional().describe("Maximum length of the text"),
+  configuration: import_zod8.z.object({
+    name: NameConfig.default({
+      firstname: { required: true },
+      surname: { required: true }
+    }).optional(),
+    order: import_zod8.z.array(import_zod8.z.enum(["firstname", "middlename", "surname"])).optional(),
+    maxLength: import_zod8.z.number().optional().describe("Maximum length of the text"),
     prefix: TranslationConfig.optional(),
-    postfix: TranslationConfig.optional(),
-    includeMiddlename: import_zod7.z.boolean().default(false).optional().describe("To make middle name visible in Name form field"),
-    searchMode: import_zod7.z.boolean().optional()
+    postfix: TranslationConfig.optional()
+  }).default({
+    name: {
+      firstname: { required: true },
+      surname: { required: true }
+    }
   }).optional()
 }).describe("Name input field");
 var PhoneField = BaseField.extend({
   defaultValue: NonEmptyTextValue.optional(),
-  type: import_zod7.z.literal(FieldType.PHONE)
+  type: import_zod8.z.literal(FieldType.PHONE)
 }).describe("Phone input field");
 var IdField = BaseField.extend({
   defaultValue: NonEmptyTextValue.optional(),
-  type: import_zod7.z.literal(FieldType.ID)
+  type: import_zod8.z.literal(FieldType.ID)
 }).describe("ID input field");
 var Checkbox = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.CHECKBOX),
+  type: import_zod8.z.literal(FieldType.CHECKBOX),
   defaultValue: CheckboxFieldValue.optional()
 }).describe("Boolean checkbox field");
 var Country = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.COUNTRY),
+  type: import_zod8.z.literal(FieldType.COUNTRY),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("Country select field");
-var AdministrativeAreas = import_zod7.z.enum([
+var AdministrativeAreas = import_zod8.z.enum([
   "ADMIN_STRUCTURE",
   "HEALTH_FACILITY",
   "CRVS_OFFICE"
 ]);
-var AdministrativeAreaConfiguration = import_zod7.z.object({
-  partOf: import_zod7.z.object({
-    $declaration: import_zod7.z.string()
+var AdministrativeAreaConfiguration = import_zod8.z.object({
+  partOf: import_zod8.z.object({
+    $declaration: import_zod8.z.string()
   }).optional().describe("Parent location"),
   type: AdministrativeAreas
 }).describe("Administrative area options");
 var AdministrativeArea = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.ADMINISTRATIVE_AREA),
+  type: import_zod8.z.literal(FieldType.ADMINISTRATIVE_AREA),
   defaultValue: NonEmptyTextValue.optional(),
   configuration: AdministrativeAreaConfiguration
 }).describe("Administrative area input field e.g. facility, office");
 var Location = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.LOCATION),
+  type: import_zod8.z.literal(FieldType.LOCATION),
   defaultValue: NonEmptyTextValue.optional(),
-  configuration: import_zod7.z.object({
-    searchableResource: import_zod7.z.array(import_zod7.z.enum(["locations", "facilities", "offices"])).optional()
+  configuration: import_zod8.z.object({
+    searchableResource: import_zod8.z.array(import_zod8.z.enum(["locations", "facilities", "offices"])).optional()
   }).optional()
 }).describe("Input field for a location");
 var FileUploadWithOptions = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.FILE_WITH_OPTIONS),
-  options: import_zod7.z.array(SelectOption).describe("A list of options"),
+  type: import_zod8.z.literal(FieldType.FILE_WITH_OPTIONS),
+  options: import_zod8.z.array(SelectOption).describe("A list of options"),
   defaultValue: FileFieldWithOptionValue.optional(),
-  configuration: import_zod7.z.object({
-    maxFileSize: import_zod7.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+  configuration: import_zod8.z.object({
+    maxFileSize: import_zod8.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
     acceptedFileTypes: MimeType.array().optional().describe("List of allowed file formats for the signature")
   }).default({
     maxFileSize: DEFAULT_MAX_FILE_SIZE_BYTES
   })
 });
 var Facility = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.FACILITY),
+  type: import_zod8.z.literal(FieldType.FACILITY),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("Input field for a facility");
 var Office = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.OFFICE),
+  type: import_zod8.z.literal(FieldType.OFFICE),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("Input field for an office");
 var Address = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.ADDRESS),
-  defaultValue: AddressFieldValue.optional(),
-  configuration: import_zod7.z.object({
-    searchMode: import_zod7.z.boolean().optional()
-  }).optional()
+  type: import_zod8.z.literal(FieldType.ADDRESS),
+  configuration: import_zod8.z.object({
+    lineSeparator: import_zod8.z.string().optional(),
+    fields: import_zod8.z.array(
+      import_zod8.z.enum([
+        "number",
+        "country",
+        "province",
+        "addressType",
+        "district",
+        "urbanOrRural",
+        "town",
+        "residentialArea",
+        "street",
+        "zipCode",
+        "village",
+        "state",
+        "district2",
+        "cityOrTown",
+        "addressLine1",
+        "addressLine2",
+        "addressLine3",
+        "postcodeOrZip"
+      ])
+    ).optional()
+  }).optional(),
+  defaultValue: AddressFieldValue.optional()
 }).describe("Address input field \u2013 a combination of location and text fields");
-var DataEntry = import_zod7.z.union([
-  import_zod7.z.object({
+var DataEntry = import_zod8.z.union([
+  import_zod8.z.object({
     label: TranslationConfig,
-    value: TranslationConfig.or(import_zod7.z.string())
+    value: TranslationConfig.or(import_zod8.z.string())
   }),
-  import_zod7.z.object({
-    fieldId: import_zod7.z.string()
+  import_zod8.z.object({
+    fieldId: import_zod8.z.string()
   })
 ]);
 var DataField = BaseField.extend({
-  type: import_zod7.z.literal(FieldType.DATA),
-  configuration: import_zod7.z.object({
+  type: import_zod8.z.literal(FieldType.DATA),
+  configuration: import_zod8.z.object({
     subtitle: TranslationConfig.optional(),
-    data: import_zod7.z.array(DataEntry)
+    data: import_zod8.z.array(DataEntry)
   })
 }).describe("Data field for displaying read-only data");
-var FieldConfig = import_zod7.z.discriminatedUnion("type", [
+var FieldConfig = import_zod8.z.discriminatedUnion("type", [
   Address,
   TextField,
   NumberField,
@@ -1037,19 +1089,24 @@ var FieldConfig = import_zod7.z.discriminatedUnion("type", [
   description: "Form field configuration",
   ref: "FieldConfig"
 });
+var AnyFileField = import_zod8.z.discriminatedUnion("type", [
+  SignatureField,
+  File,
+  FileUploadWithOptions
+]);
 
 // ../commons/src/events/FormConfig.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // ../commons/src/events/PageConfig.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var import_zod_openapi5 = require("zod-openapi");
-(0, import_zod_openapi5.extendZodWithOpenApi)(import_zod8.z);
-var PageTypes = import_zod8.z.enum(["FORM", "VERIFICATION"]);
-var PageConfigBase = import_zod8.z.object({
-  id: import_zod8.z.string().describe("Unique identifier for the page"),
+(0, import_zod_openapi5.extendZodWithOpenApi)(import_zod9.z);
+var PageTypes = import_zod9.z.enum(["FORM", "VERIFICATION"]);
+var PageConfigBase = import_zod9.z.object({
+  id: import_zod9.z.string().describe("Unique identifier for the page"),
   title: TranslationConfig.describe("Header title of the page"),
-  fields: import_zod8.z.array(FieldConfig).describe("Fields to be rendered on the page"),
+  fields: import_zod9.z.array(FieldConfig).describe("Fields to be rendered on the page"),
   conditional: Conditional.optional().describe(
     "Page will be shown if condition is met. If conditional is not defined, the page will be always shown."
   )
@@ -1058,13 +1115,13 @@ var PageConfigBase = import_zod8.z.object({
   ref: "FormPageConfig"
 });
 var FormPageConfig = PageConfigBase.extend({
-  type: import_zod8.z.literal(PageTypes.enum.FORM).default(PageTypes.enum.FORM)
+  type: import_zod9.z.literal(PageTypes.enum.FORM).default(PageTypes.enum.FORM)
 });
-var VerificationActionConfig = import_zod8.z.object({
-  verify: import_zod8.z.object({ label: TranslationConfig }),
-  cancel: import_zod8.z.object({
+var VerificationActionConfig = import_zod9.z.object({
+  verify: import_zod9.z.object({ label: TranslationConfig }),
+  cancel: import_zod9.z.object({
     label: TranslationConfig,
-    confirmation: import_zod8.z.object({
+    confirmation: import_zod9.z.object({
       title: TranslationConfig,
       body: TranslationConfig
     })
@@ -1074,110 +1131,110 @@ var VerificationActionConfig = import_zod8.z.object({
   ref: "VerificationActionConfig"
 });
 var VerificationPageConfig = FormPageConfig.extend({
-  type: import_zod8.z.literal(PageTypes.enum.VERIFICATION),
+  type: import_zod9.z.literal(PageTypes.enum.VERIFICATION),
   actions: VerificationActionConfig
 });
-var PageConfig = import_zod8.z.discriminatedUnion("type", [
+var PageConfig = import_zod9.z.discriminatedUnion("type", [
   FormPageConfig,
   VerificationPageConfig
 ]);
 
 // ../commons/src/events/FormConfig.ts
-var DeclarationFormConfig = import_zod9.z.object({
+var DeclarationFormConfig = import_zod10.z.object({
   label: TranslationConfig.describe("Human readable description of the form"),
-  pages: import_zod9.z.array(FormPageConfig)
+  pages: import_zod10.z.array(FormPageConfig)
 }).describe("Configuration for a declaration form");
-var ActionFormConfig = import_zod9.z.object({
+var ActionFormConfig = import_zod10.z.object({
   label: TranslationConfig.describe("Human readable description of the form"),
-  pages: import_zod9.z.array(PageConfig)
+  pages: import_zod10.z.array(PageConfig)
 });
-var FormConfig = import_zod9.z.union([DeclarationFormConfig, ActionFormConfig]);
+var FormConfig = import_zod10.z.union([DeclarationFormConfig, ActionFormConfig]);
 
 // ../commons/src/events/ActionConfig.ts
 var import_zod_openapi6 = require("zod-openapi");
-(0, import_zod_openapi6.extendZodWithOpenApi)(import_zod10.z);
-var ActionConditional2 = import_zod10.z.discriminatedUnion("type", [
+(0, import_zod_openapi6.extendZodWithOpenApi)(import_zod11.z);
+var ActionConditional2 = import_zod11.z.discriminatedUnion("type", [
   /** If conditional is defined, the action is shown to the user only if the condition is met */
   ShowConditional,
   /** If conditional is defined, the action is enabled only if the condition is met */
   EnableConditional
 ]);
-var DeclarationReviewConfig = import_zod10.z.object({
+var DeclarationReviewConfig = import_zod11.z.object({
   title: TranslationConfig.describe("Title of the review page"),
-  fields: import_zod10.z.array(FieldConfig).describe("Fields to be rendered on the review page for annotations.")
+  fields: import_zod11.z.array(FieldConfig).describe("Fields to be rendered on the review page for annotations.")
 }).describe("Configuration for **declaration** review page.");
-var ActionConfigBase = import_zod10.z.object({
+var ActionConfigBase = import_zod11.z.object({
   label: TranslationConfig,
-  conditionals: import_zod10.z.array(ActionConditional2).optional().default([]),
-  draft: import_zod10.z.boolean().optional()
+  conditionals: import_zod11.z.array(ActionConditional2).optional().default([]),
+  draft: import_zod11.z.boolean().optional()
 });
 var ReadActionConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.READ),
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.READ),
     review: DeclarationReviewConfig
   })
 );
 var DeclareConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.DECLARE),
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.DECLARE),
     review: DeclarationReviewConfig
   })
 );
 var ValidateConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.VALIDATE),
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.VALIDATE),
     review: DeclarationReviewConfig
   })
 );
 var RegisterConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.REGISTER),
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.REGISTER),
     review: DeclarationReviewConfig
   })
 );
 var RejectDeclarationConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.REJECT)
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.REJECT)
   })
 );
 var MarkedAsDuplicateConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.MARKED_AS_DUPLICATE)
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.ARCHIVE)
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.ARCHIVE)
   })
 );
 var DeleteConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.DELETE)
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.DELETE)
   })
 );
 var PrintCertificateActionConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.PRINT_CERTIFICATE),
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.PRINT_CERTIFICATE),
     printForm: ActionFormConfig
   })
 );
 var RequestCorrectionConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.REQUEST_CORRECTION),
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.REQUEST_CORRECTION),
     correctionForm: ActionFormConfig
   })
 );
 var RejectCorrectionConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.REJECT_CORRECTION)
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.REJECT_CORRECTION)
   })
 );
 var ApproveCorrectionConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.APPROVE_CORRECTION)
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.APPROVE_CORRECTION)
   })
 );
-var ActionConfig = import_zod10.z.discriminatedUnion("type", [
+var ActionConfig = import_zod11.z.discriminatedUnion("type", [
   /*
    * OpenAPI references are defined here so our generated OpenAPI spec knows to reuse the models
    * and treat them as "models" instead of duplicating the data structure in each endpoint.
@@ -1197,108 +1254,109 @@ var ActionConfig = import_zod10.z.discriminatedUnion("type", [
   RejectCorrectionConfig.openapi({ ref: "RejectCorrectionActionConfig" }),
   ApproveCorrectionConfig.openapi({ ref: "ApproveCorrectionActionConfig" })
 ]).openapi({ ref: "ActionConfig" });
-var DeclarationActionConfig = import_zod10.z.discriminatedUnion("type", [
+var DeclarationActionConfig = import_zod11.z.discriminatedUnion("type", [
   DeclareConfig,
   ValidateConfig,
   RegisterConfig
 ]);
 
 // ../commons/src/events/offline/CertificateConfig.ts
-var import_zod11 = require("zod");
-var FontFamily = import_zod11.z.object({
-  normal: import_zod11.z.string(),
-  bold: import_zod11.z.string(),
-  italics: import_zod11.z.string(),
-  bolditalics: import_zod11.z.string()
+var import_zod12 = require("zod");
+var FontFamily = import_zod12.z.object({
+  normal: import_zod12.z.string(),
+  bold: import_zod12.z.string(),
+  italics: import_zod12.z.string(),
+  bolditalics: import_zod12.z.string()
 });
-var CertificateConfig = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  event: import_zod11.z.string(),
+var CertificateConfig = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  event: import_zod12.z.string(),
   label: TranslationConfig,
-  isDefault: import_zod11.z.boolean(),
-  fee: import_zod11.z.object({
-    onTime: import_zod11.z.number(),
-    late: import_zod11.z.number(),
-    delayed: import_zod11.z.number()
+  isDefault: import_zod12.z.boolean(),
+  fee: import_zod12.z.object({
+    onTime: import_zod12.z.number(),
+    late: import_zod12.z.number(),
+    delayed: import_zod12.z.number()
   }),
-  svgUrl: import_zod11.z.string(),
-  fonts: import_zod11.z.record(FontFamily).optional()
+  svgUrl: import_zod12.z.string(),
+  fonts: import_zod12.z.record(FontFamily).optional(),
+  conditionals: import_zod12.z.array(ShowConditional).optional()
 });
 var CertificateTemplateConfig = CertificateConfig.extend({
-  hash: import_zod11.z.string().optional(),
-  svg: import_zod11.z.string()
+  hash: import_zod12.z.string().optional(),
+  svg: import_zod12.z.string()
 });
 
 // ../commons/src/events/offline/LanguageConfig.ts
-var import_zod12 = require("zod");
-var LanguageConfig = import_zod12.z.object({
-  lang: import_zod12.z.string(),
+var import_zod13 = require("zod");
+var LanguageConfig = import_zod13.z.object({
+  lang: import_zod13.z.string(),
   /**
    * client.csv contents
    */
-  messages: import_zod12.z.record(import_zod12.z.string())
+  messages: import_zod13.z.record(import_zod13.z.string())
 });
 
 // ../commons/src/events/EventConfig.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 
 // ../commons/src/events/DeduplicationConfig.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 var import_zod_openapi7 = require("zod-openapi");
-(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod13.z);
-var FieldReference2 = import_zod13.z.string();
-var Matcher = import_zod13.z.object({
-  fieldId: import_zod13.z.string(),
-  options: import_zod13.z.object({
-    boost: import_zod13.z.number().optional()
+(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod14.z);
+var FieldReference2 = import_zod14.z.string();
+var Matcher = import_zod14.z.object({
+  fieldId: import_zod14.z.string(),
+  options: import_zod14.z.object({
+    boost: import_zod14.z.number().optional()
   }).optional().default({})
 });
 var FuzzyMatcher = Matcher.extend({
-  type: import_zod13.z.literal("fuzzy"),
-  options: import_zod13.z.object({
+  type: import_zod14.z.literal("fuzzy"),
+  options: import_zod14.z.object({
     /**
      * Names of length 3 or less characters = 0 edits allowed
      * Names of length 4 - 6 characters = 1 edit allowed
      * Names of length >7 characters = 2 edits allowed
      */
-    fuzziness: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).optional().default("AUTO:4,7"),
-    boost: import_zod13.z.number().optional().default(1)
+    fuzziness: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]).optional().default("AUTO:4,7"),
+    boost: import_zod14.z.number().optional().default(1)
   }).optional().default({})
 });
 var StrictMatcher = Matcher.extend({
-  type: import_zod13.z.literal("strict"),
-  options: import_zod13.z.object({
-    boost: import_zod13.z.number().optional().default(1)
+  type: import_zod14.z.literal("strict"),
+  options: import_zod14.z.object({
+    boost: import_zod14.z.number().optional().default(1)
   }).optional().default({})
 });
 var DateRangeMatcher = Matcher.extend({
-  type: import_zod13.z.literal("dateRange"),
-  options: import_zod13.z.object({
-    days: import_zod13.z.number(),
+  type: import_zod14.z.literal("dateRange"),
+  options: import_zod14.z.object({
+    days: import_zod14.z.number(),
     origin: FieldReference2,
-    boost: import_zod13.z.number().optional().default(1)
+    boost: import_zod14.z.number().optional().default(1)
   })
 });
 var DateDistanceMatcher = Matcher.extend({
-  type: import_zod13.z.literal("dateDistance"),
-  options: import_zod13.z.object({
-    days: import_zod13.z.number(),
+  type: import_zod14.z.literal("dateDistance"),
+  options: import_zod14.z.object({
+    days: import_zod14.z.number(),
     origin: FieldReference2,
-    boost: import_zod13.z.number().optional().default(1)
+    boost: import_zod14.z.number().optional().default(1)
   })
 });
-var And = import_zod13.z.object({
-  type: import_zod13.z.literal("and"),
+var And = import_zod14.z.object({
+  type: import_zod14.z.literal("and"),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clauses: import_zod13.z.lazy(() => Clause.array())
+  clauses: import_zod14.z.lazy(() => Clause.array())
 });
-var Or = import_zod13.z.object({
-  type: import_zod13.z.literal("or"),
+var Or = import_zod14.z.object({
+  type: import_zod14.z.literal("or"),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clauses: import_zod13.z.lazy(() => Clause.array())
+  clauses: import_zod14.z.lazy(() => Clause.array())
 });
-var Clause = import_zod13.z.lazy(
-  () => import_zod13.z.discriminatedUnion("type", [
+var Clause = import_zod14.z.lazy(
+  () => import_zod14.z.discriminatedUnion("type", [
     And,
     Or,
     FuzzyMatcher,
@@ -1309,43 +1367,43 @@ var Clause = import_zod13.z.lazy(
 ).openapi({
   ref: "Clause"
 });
-var DeduplicationConfig = import_zod13.z.object({
-  id: import_zod13.z.string(),
+var DeduplicationConfig = import_zod14.z.object({
+  id: import_zod14.z.string(),
   label: TranslationConfig,
   query: Clause
 });
 
 // ../commons/src/events/SummaryConfig.ts
-var import_zod14 = require("zod");
-var BaseField2 = import_zod14.z.object({
+var import_zod15 = require("zod");
+var BaseField2 = import_zod15.z.object({
   emptyValueMessage: TranslationConfig.optional(),
-  conditionals: import_zod14.z.array(ShowConditional).default([]).optional()
+  conditionals: import_zod15.z.array(ShowConditional).default([]).optional()
 });
 var ReferenceField = BaseField2.extend({
-  fieldId: import_zod14.z.string(),
+  fieldId: import_zod15.z.string(),
   label: TranslationConfig.optional().describe(
     "By default, the configured field's label is used. This can be overridden by providing a custom label."
   )
 }).describe("Field directly referencing event data with field id");
 var Field = BaseField2.extend({
-  id: import_zod14.z.string().describe("Id of summary field"),
+  id: import_zod15.z.string().describe("Id of summary field"),
   value: TranslationConfig.describe(
     "Summary field value. Can utilise values defined in configuration and EventMetadata"
   ),
   label: TranslationConfig
 }).describe("Custom configured field");
-var SummaryConfig = import_zod14.z.object({
-  fields: import_zod14.z.array(import_zod14.z.union([Field, ReferenceField])).describe("Fields rendered in summary view.")
+var SummaryConfig = import_zod15.z.object({
+  fields: import_zod15.z.array(import_zod15.z.union([Field, ReferenceField])).describe("Fields rendered in summary view.")
 }).describe("Configuration for summary in event.");
 
 // ../commons/src/events/AdvancedSearchConfig.ts
-var import_zod15 = require("zod");
-var MatchType = import_zod15.z.enum(["fuzzy", "exact", "range", "within"]);
-var BaseField3 = import_zod15.z.object({
-  config: import_zod15.z.object({
+var import_zod16 = require("zod");
+var MatchType = import_zod16.z.enum(["fuzzy", "exact", "range", "within"]);
+var BaseField3 = import_zod16.z.object({
+  config: import_zod16.z.object({
     type: MatchType.describe("Determines the type of field")
   }),
-  options: import_zod15.z.array(SelectOption).optional(),
+  options: import_zod16.z.array(SelectOption).optional(),
   searchCriteriaLabelPrefix: TranslationConfig.optional().describe(
     `
     This property determines whether to add a prefix (such as "Child" or "Applicant") before the field label
@@ -1366,7 +1424,7 @@ var BaseField3 = import_zod15.z.object({
     in the country-config > event.advancedSearch configuration. For example: field("child.dob", { searchCriteriaLabelPrefix: TranslationConfig }).
     `
   ),
-  conditionals: import_zod15.z.array(FieldConditional).default([]).optional().describe(
+  conditionals: import_zod16.z.array(FieldConditional).default([]).optional().describe(
     `
        In advanced search, we sometimes need to override the default field visibility conditionals.
 
@@ -1380,60 +1438,68 @@ var BaseField3 = import_zod15.z.object({
        are always rendered in the advanced search form.
       `
   ),
-  validations: import_zod15.z.array(ValidationConfig).default([]).optional().describe(
+  validations: import_zod16.z.array(ValidationConfig).default([]).optional().describe(
     `In advanced search, we sometimes need to override the default field validations.`
   )
 });
-var SearchQueryParams = import_zod15.z.object({
-  eventType: import_zod15.z.string().optional().describe(
+var SearchQueryParams = import_zod16.z.object({
+  eventType: import_zod16.z.string().optional().describe(
     "Defines type of event so that when redirecting to Advanced Search page, appropriate tab can be selected"
   )
 }).catchall(FieldValue);
 var FieldConfigSchema = BaseField3.extend({
-  fieldId: import_zod15.z.string(),
-  fieldType: import_zod15.z.literal("field"),
-  alternateFieldIds: import_zod15.z.array(import_zod15.z.string()).optional().describe(
+  fieldId: import_zod16.z.string(),
+  fieldType: import_zod16.z.literal("field"),
+  alternateFieldIds: import_zod16.z.array(import_zod16.z.string()).optional().describe(
     `Sometimes there might be need to search a value against multiple field of same FormField type. For example
-      search Country, Province, District against child.address.private and child.address.other. In such case, we 
+      search Country, Province, District against child.address.private and child.address.other. In such case, we
       add a one field as fieldId, and accomodate others in alternateFieldIds`
   ),
-  excludeInSearchQuery: import_zod15.z.boolean().default(false).optional().describe(`Sometimes there will be search fields which are used to 
-    conditionally display another search field, but its not needed in search query. For example, child.placeOfBirth 
+  excludeInSearchQuery: import_zod16.z.boolean().default(false).optional().describe(`Sometimes there will be search fields which are used to
+    conditionally display another search field, but its not needed in search query. For example, child.placeOfBirth
     is select field, which has 3 options, FACILITY, PRIVATE_HOME, OTHER. Upon selecting any of the option, pops up another field
     related to the selected option, whose value is required in the search query. But child.placeOfBirth itself is not needed in the query.
     In such case, populate this field (excludeInSearchQuery) with boolean true`)
 });
-var EventFieldId = import_zod15.z.enum([
+var EventFieldIdInput = import_zod16.z.enum([
   "trackingId",
   "status",
   "legalStatuses.REGISTERED.acceptedAt",
   "legalStatuses.REGISTERED.createdAtLocation",
   "updatedAt"
 ]);
+var METADATA_FIELD_PREFIX = "event.";
+var EventFieldId = import_zod16.z.enum([
+  `${METADATA_FIELD_PREFIX}trackingId`,
+  `${METADATA_FIELD_PREFIX}status`,
+  `${METADATA_FIELD_PREFIX}legalStatuses.REGISTERED.acceptedAt`,
+  `${METADATA_FIELD_PREFIX}legalStatuses.REGISTERED.createdAtLocation`,
+  `${METADATA_FIELD_PREFIX}updatedAt`
+]);
 var EventFieldConfigSchema = BaseField3.extend({
   fieldId: EventFieldId,
-  fieldType: import_zod15.z.literal("event")
+  fieldType: import_zod16.z.literal("event")
 });
-var SearchField = import_zod15.z.discriminatedUnion("fieldType", [
+var SearchField = import_zod16.z.discriminatedUnion("fieldType", [
   FieldConfigSchema,
   EventFieldConfigSchema
 ]);
-var AdvancedSearchConfig = import_zod15.z.object({
+var AdvancedSearchConfig = import_zod16.z.object({
   title: TranslationConfig.describe("Advanced search tab title"),
-  fields: import_zod15.z.array(SearchField).describe("Advanced search fields.")
+  fields: import_zod16.z.array(SearchField).describe("Advanced search fields.")
 });
 
 // ../commons/src/events/utils.ts
 var import_lodash = require("lodash");
 
 // ../commons/src/events/ActionDocument.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 var import_zod_openapi8 = require("zod-openapi");
 
 // ../commons/src/uuid.ts
 var import_uuid = require("uuid");
-var import_zod16 = require("zod");
-var UUID = import_zod16.z.string().uuid().brand("UUID");
+var import_zod17 = require("zod");
+var UUID = import_zod17.z.string().uuid().brand("UUID");
 function getUUID() {
   return (0, import_uuid.v4)();
 }
@@ -1443,10 +1509,10 @@ var CreatedAtLocation = UUID.nullish();
 
 // ../commons/src/authentication.ts
 var import_jwt_decode = __toESM(require("jwt-decode"));
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 
 // ../commons/src/scopes.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 var SCOPES = {
   // TODO v1.8 legacy scopes
   NATLSYSADMIN: "natlsysadmin",
@@ -1559,108 +1625,108 @@ var SCOPES = {
   // data seeding
   USER_DATA_SEEDING: "user.data-seeding"
 };
-var LegacyScopes = import_zod17.z.union([
-  import_zod17.z.literal(SCOPES.NATLSYSADMIN),
-  import_zod17.z.literal(SCOPES.BYPASSRATELIMIT),
-  import_zod17.z.literal(SCOPES.DECLARE),
-  import_zod17.z.literal(SCOPES.REGISTER),
-  import_zod17.z.literal(SCOPES.VALIDATE),
-  import_zod17.z.literal(SCOPES.DEMO),
-  import_zod17.z.literal(SCOPES.CERTIFY),
-  import_zod17.z.literal(SCOPES.PERFORMANCE),
-  import_zod17.z.literal(SCOPES.SYSADMIN),
-  import_zod17.z.literal(SCOPES.TEAMS),
-  import_zod17.z.literal(SCOPES.CONFIG)
+var LegacyScopes = import_zod18.z.union([
+  import_zod18.z.literal(SCOPES.NATLSYSADMIN),
+  import_zod18.z.literal(SCOPES.BYPASSRATELIMIT),
+  import_zod18.z.literal(SCOPES.DECLARE),
+  import_zod18.z.literal(SCOPES.REGISTER),
+  import_zod18.z.literal(SCOPES.VALIDATE),
+  import_zod18.z.literal(SCOPES.DEMO),
+  import_zod18.z.literal(SCOPES.CERTIFY),
+  import_zod18.z.literal(SCOPES.PERFORMANCE),
+  import_zod18.z.literal(SCOPES.SYSADMIN),
+  import_zod18.z.literal(SCOPES.TEAMS),
+  import_zod18.z.literal(SCOPES.CONFIG)
 ]);
-var IntegrationScopes = import_zod17.z.union([
-  import_zod17.z.literal(SCOPES.WEBHOOK),
-  import_zod17.z.literal(SCOPES.NATIONALID),
-  import_zod17.z.literal(SCOPES.NOTIFICATION_API),
-  import_zod17.z.literal(SCOPES.RECORDSEARCH)
+var IntegrationScopes = import_zod18.z.union([
+  import_zod18.z.literal(SCOPES.WEBHOOK),
+  import_zod18.z.literal(SCOPES.NATIONALID),
+  import_zod18.z.literal(SCOPES.NOTIFICATION_API),
+  import_zod18.z.literal(SCOPES.RECORDSEARCH)
 ]);
-var DeclareScopes = import_zod17.z.union([
-  import_zod17.z.literal(SCOPES.RECORD_DECLARE),
-  import_zod17.z.literal(SCOPES.RECORD_IMPORT),
-  import_zod17.z.literal(SCOPES.RECORD_DECLARE_BIRTH),
-  import_zod17.z.literal(SCOPES.RECORD_DECLARE_BIRTH_MY_JURISDICTION),
-  import_zod17.z.literal(SCOPES.RECORD_DECLARE_DEATH),
-  import_zod17.z.literal(SCOPES.RECORD_DECLARE_DEATH_MY_JURISDICTION),
-  import_zod17.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE),
-  import_zod17.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE_MY_JURISDICTION),
-  import_zod17.z.literal(SCOPES.RECORD_SUBMIT_INCOMPLETE),
-  import_zod17.z.literal(SCOPES.RECORD_SUBMIT_FOR_REVIEW)
+var DeclareScopes = import_zod18.z.union([
+  import_zod18.z.literal(SCOPES.RECORD_DECLARE),
+  import_zod18.z.literal(SCOPES.RECORD_IMPORT),
+  import_zod18.z.literal(SCOPES.RECORD_DECLARE_BIRTH),
+  import_zod18.z.literal(SCOPES.RECORD_DECLARE_BIRTH_MY_JURISDICTION),
+  import_zod18.z.literal(SCOPES.RECORD_DECLARE_DEATH),
+  import_zod18.z.literal(SCOPES.RECORD_DECLARE_DEATH_MY_JURISDICTION),
+  import_zod18.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE),
+  import_zod18.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE_MY_JURISDICTION),
+  import_zod18.z.literal(SCOPES.RECORD_SUBMIT_INCOMPLETE),
+  import_zod18.z.literal(SCOPES.RECORD_SUBMIT_FOR_REVIEW)
 ]);
-var UnassignScope = import_zod17.z.literal(SCOPES.RECORD_UNASSIGN_OTHERS);
-var ValidateScopes = import_zod17.z.union([
-  import_zod17.z.literal(SCOPES.RECORD_SUBMIT_FOR_APPROVAL),
-  import_zod17.z.literal(SCOPES.RECORD_SUBMIT_FOR_UPDATES),
-  import_zod17.z.literal(SCOPES.RECORD_DECLARATION_EDIT),
-  import_zod17.z.literal(SCOPES.RECORD_REVIEW_DUPLICATES),
-  import_zod17.z.literal(SCOPES.RECORD_DECLARATION_ARCHIVE),
-  import_zod17.z.literal(SCOPES.RECORD_DECLARATION_REINSTATE)
+var UnassignScope = import_zod18.z.literal(SCOPES.RECORD_UNASSIGN_OTHERS);
+var ValidateScopes = import_zod18.z.union([
+  import_zod18.z.literal(SCOPES.RECORD_SUBMIT_FOR_APPROVAL),
+  import_zod18.z.literal(SCOPES.RECORD_SUBMIT_FOR_UPDATES),
+  import_zod18.z.literal(SCOPES.RECORD_DECLARATION_EDIT),
+  import_zod18.z.literal(SCOPES.RECORD_REVIEW_DUPLICATES),
+  import_zod18.z.literal(SCOPES.RECORD_DECLARATION_ARCHIVE),
+  import_zod18.z.literal(SCOPES.RECORD_DECLARATION_REINSTATE)
 ]);
-var RegisterScope = import_zod17.z.literal(SCOPES.RECORD_REGISTER);
-var CertifyScopes = import_zod17.z.union([
-  import_zod17.z.literal(SCOPES.RECORD_EXPORT_RECORDS),
-  import_zod17.z.literal(SCOPES.RECORD_DECLARATION_PRINT),
-  import_zod17.z.literal(SCOPES.RECORD_PRINT_RECORDS_SUPPORTING_DOCUMENTS),
-  import_zod17.z.literal(SCOPES.RECORD_REGISTRATION_PRINT),
-  import_zod17.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
-  import_zod17.z.literal(SCOPES.RECORD_PRINT_CERTIFIED_COPIES),
-  import_zod17.z.literal(SCOPES.RECORD_BULK_PRINT_CERTIFIED_COPIES),
-  import_zod17.z.literal(SCOPES.RECORD_REGISTRATION_VERIFY_CERTIFIED_COPIES)
+var RegisterScope = import_zod18.z.literal(SCOPES.RECORD_REGISTER);
+var CertifyScopes = import_zod18.z.union([
+  import_zod18.z.literal(SCOPES.RECORD_EXPORT_RECORDS),
+  import_zod18.z.literal(SCOPES.RECORD_DECLARATION_PRINT),
+  import_zod18.z.literal(SCOPES.RECORD_PRINT_RECORDS_SUPPORTING_DOCUMENTS),
+  import_zod18.z.literal(SCOPES.RECORD_REGISTRATION_PRINT),
+  import_zod18.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
+  import_zod18.z.literal(SCOPES.RECORD_PRINT_CERTIFIED_COPIES),
+  import_zod18.z.literal(SCOPES.RECORD_BULK_PRINT_CERTIFIED_COPIES),
+  import_zod18.z.literal(SCOPES.RECORD_REGISTRATION_VERIFY_CERTIFIED_COPIES)
 ]);
-var CorrectionScopes = import_zod17.z.union([
-  import_zod17.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_CORRECTION),
-  import_zod17.z.literal(SCOPES.RECORD_REGISTRATION_CORRECT),
-  import_zod17.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_REVOCATION),
-  import_zod17.z.literal(SCOPES.RECORD_REGISTRATION_REVOKE),
-  import_zod17.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_REINSTATEMENT),
-  import_zod17.z.literal(SCOPES.RECORD_REGISTRATION_REINSTATE),
-  import_zod17.z.literal(SCOPES.RECORD_CONFIRM_REGISTRATION),
-  import_zod17.z.literal(SCOPES.RECORD_REJECT_REGISTRATION)
+var CorrectionScopes = import_zod18.z.union([
+  import_zod18.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_CORRECTION),
+  import_zod18.z.literal(SCOPES.RECORD_REGISTRATION_CORRECT),
+  import_zod18.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_REVOCATION),
+  import_zod18.z.literal(SCOPES.RECORD_REGISTRATION_REVOKE),
+  import_zod18.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_REINSTATEMENT),
+  import_zod18.z.literal(SCOPES.RECORD_REGISTRATION_REINSTATE),
+  import_zod18.z.literal(SCOPES.RECORD_CONFIRM_REGISTRATION),
+  import_zod18.z.literal(SCOPES.RECORD_REJECT_REGISTRATION)
 ]);
-var SearchScopes = import_zod17.z.union([
-  import_zod17.z.literal(SCOPES.SEARCH_BIRTH_MY_JURISDICTION),
-  import_zod17.z.literal(SCOPES.SEARCH_BIRTH),
-  import_zod17.z.literal(SCOPES.SEARCH_DEATH_MY_JURISDICTION),
-  import_zod17.z.literal(SCOPES.SEARCH_DEATH),
-  import_zod17.z.literal(SCOPES.SEARCH_MARRIAGE_MY_JURISDICTION),
-  import_zod17.z.literal(SCOPES.SEARCH_MARRIAGE)
+var SearchScopes = import_zod18.z.union([
+  import_zod18.z.literal(SCOPES.SEARCH_BIRTH_MY_JURISDICTION),
+  import_zod18.z.literal(SCOPES.SEARCH_BIRTH),
+  import_zod18.z.literal(SCOPES.SEARCH_DEATH_MY_JURISDICTION),
+  import_zod18.z.literal(SCOPES.SEARCH_DEATH),
+  import_zod18.z.literal(SCOPES.SEARCH_MARRIAGE_MY_JURISDICTION),
+  import_zod18.z.literal(SCOPES.SEARCH_MARRIAGE)
 ]);
-var AuditScopes = import_zod17.z.union([
-  import_zod17.z.literal(SCOPES.RECORD_READ),
-  import_zod17.z.literal(SCOPES.RECORD_READ_AUDIT),
-  import_zod17.z.literal(SCOPES.RECORD_READ_COMMENTS),
-  import_zod17.z.literal(SCOPES.RECORD_CREATE_COMMENTS)
+var AuditScopes = import_zod18.z.union([
+  import_zod18.z.literal(SCOPES.RECORD_READ),
+  import_zod18.z.literal(SCOPES.RECORD_READ_AUDIT),
+  import_zod18.z.literal(SCOPES.RECORD_READ_COMMENTS),
+  import_zod18.z.literal(SCOPES.RECORD_CREATE_COMMENTS)
 ]);
-var ProfileScopes = import_zod17.z.union([
-  import_zod17.z.literal(SCOPES.PROFILE_UPDATE),
-  import_zod17.z.literal(SCOPES.PROFILE_ELECTRONIC_SIGNATURE)
+var ProfileScopes = import_zod18.z.union([
+  import_zod18.z.literal(SCOPES.PROFILE_UPDATE),
+  import_zod18.z.literal(SCOPES.PROFILE_ELECTRONIC_SIGNATURE)
 ]);
-var PerformanceScopes = import_zod17.z.union([
-  import_zod17.z.literal(SCOPES.PERFORMANCE_READ),
-  import_zod17.z.literal(SCOPES.PERFORMANCE_READ_DASHBOARDS),
-  import_zod17.z.literal(SCOPES.PERFORMANCE_EXPORT_VITAL_STATISTICS)
+var PerformanceScopes = import_zod18.z.union([
+  import_zod18.z.literal(SCOPES.PERFORMANCE_READ),
+  import_zod18.z.literal(SCOPES.PERFORMANCE_READ_DASHBOARDS),
+  import_zod18.z.literal(SCOPES.PERFORMANCE_EXPORT_VITAL_STATISTICS)
 ]);
-var OrganisationScopes = import_zod17.z.union([
-  import_zod17.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS),
-  import_zod17.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_OFFICE),
-  import_zod17.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_JURISDICTION)
+var OrganisationScopes = import_zod18.z.union([
+  import_zod18.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS),
+  import_zod18.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_OFFICE),
+  import_zod18.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_JURISDICTION)
 ]);
-var UserScopes = import_zod17.z.union([
-  import_zod17.z.literal(SCOPES.USER_READ),
-  import_zod17.z.literal(SCOPES.USER_READ_MY_OFFICE),
-  import_zod17.z.literal(SCOPES.USER_READ_MY_JURISDICTION),
-  import_zod17.z.literal(SCOPES.USER_READ_ONLY_MY_AUDIT),
-  import_zod17.z.literal(SCOPES.USER_CREATE),
-  import_zod17.z.literal(SCOPES.USER_CREATE_MY_JURISDICTION),
-  import_zod17.z.literal(SCOPES.USER_UPDATE),
-  import_zod17.z.literal(SCOPES.USER_UPDATE_MY_JURISDICTION)
+var UserScopes = import_zod18.z.union([
+  import_zod18.z.literal(SCOPES.USER_READ),
+  import_zod18.z.literal(SCOPES.USER_READ_MY_OFFICE),
+  import_zod18.z.literal(SCOPES.USER_READ_MY_JURISDICTION),
+  import_zod18.z.literal(SCOPES.USER_READ_ONLY_MY_AUDIT),
+  import_zod18.z.literal(SCOPES.USER_CREATE),
+  import_zod18.z.literal(SCOPES.USER_CREATE_MY_JURISDICTION),
+  import_zod18.z.literal(SCOPES.USER_UPDATE),
+  import_zod18.z.literal(SCOPES.USER_UPDATE_MY_JURISDICTION)
 ]);
-var ConfigScope = import_zod17.z.literal(SCOPES.CONFIG_UPDATE_ALL);
-var DataSeedingScope = import_zod17.z.literal(SCOPES.USER_DATA_SEEDING);
-var LiteralScopes = import_zod17.z.union([
+var ConfigScope = import_zod18.z.literal(SCOPES.CONFIG_UPDATE_ALL);
+var DataSeedingScope = import_zod18.z.literal(SCOPES.USER_DATA_SEEDING);
+var LiteralScopes = import_zod18.z.union([
   LegacyScopes,
   IntegrationScopes,
   UnassignScope,
@@ -1679,39 +1745,39 @@ var LiteralScopes = import_zod17.z.union([
   DataSeedingScope
 ]);
 var rawConfigurableScopeRegex = /^([a-zA-Z\.]+)\[((?:\w+=[\w.-]+(?:\|[\w.-]+)*)(?:,[\w]+=[\w.-]+(?:\|[\w.-]+)*)*)\]$/;
-var rawConfigurableScope = import_zod17.z.string().regex(rawConfigurableScopeRegex);
-var CreateUserScope = import_zod17.z.object({
-  type: import_zod17.z.literal("user.create"),
-  options: import_zod17.z.object({
-    role: import_zod17.z.array(import_zod17.z.string())
+var rawConfigurableScope = import_zod18.z.string().regex(rawConfigurableScopeRegex);
+var CreateUserScope = import_zod18.z.object({
+  type: import_zod18.z.literal("user.create"),
+  options: import_zod18.z.object({
+    role: import_zod18.z.array(import_zod18.z.string())
   })
 });
-var EditUserScope = import_zod17.z.object({
-  type: import_zod17.z.literal("user.edit"),
-  options: import_zod17.z.object({
-    role: import_zod17.z.array(import_zod17.z.string())
+var EditUserScope = import_zod18.z.object({
+  type: import_zod18.z.literal("user.edit"),
+  options: import_zod18.z.object({
+    role: import_zod18.z.array(import_zod18.z.string())
   })
 });
-var WorkqueueScope = import_zod17.z.object({
-  type: import_zod17.z.literal("workqueue"),
-  options: import_zod17.z.object({
-    id: import_zod17.z.array(import_zod17.z.string())
+var WorkqueueScope = import_zod18.z.object({
+  type: import_zod18.z.literal("workqueue"),
+  options: import_zod18.z.object({
+    id: import_zod18.z.array(import_zod18.z.string())
   })
 });
-var NotifyRecordScope = import_zod17.z.object({
-  type: import_zod17.z.literal("record.notify"),
-  options: import_zod17.z.object({
-    event: import_zod17.z.array(import_zod17.z.string())
+var NotifyRecordScope = import_zod18.z.object({
+  type: import_zod18.z.literal("record.notify"),
+  options: import_zod18.z.object({
+    event: import_zod18.z.array(import_zod18.z.string())
   })
 });
-var SearchScope = import_zod17.z.object({
-  type: import_zod17.z.literal("search"),
-  options: import_zod17.z.object({
-    event: import_zod17.z.array(import_zod17.z.string()).length(1),
-    access: import_zod17.z.array(import_zod17.z.enum(["my-jurisdiction", "all"])).length(1)
+var SearchScope = import_zod18.z.object({
+  type: import_zod18.z.literal("search"),
+  options: import_zod18.z.object({
+    event: import_zod18.z.array(import_zod18.z.string()).length(1),
+    access: import_zod18.z.array(import_zod18.z.enum(["my-jurisdiction", "all"])).length(1)
   })
 });
-var ConfigurableRawScopes = import_zod17.z.discriminatedUnion("type", [
+var ConfigurableRawScopes = import_zod18.z.discriminatedUnion("type", [
   SearchScope,
   CreateUserScope,
   EditUserScope,
@@ -1719,7 +1785,7 @@ var ConfigurableRawScopes = import_zod17.z.discriminatedUnion("type", [
   NotifyRecordScope
 ]);
 var scopes = Object.values(SCOPES);
-var ActionScopes = import_zod17.z.union([
+var ActionScopes = import_zod18.z.union([
   DeclareScopes,
   ValidateScopes,
   RegisterScope,
@@ -1870,30 +1936,30 @@ var DEFAULT_ROLES_DEFINITION = [
     ]
   }
 ];
-var TokenUserType = import_zod18.z.enum(["user", "system"]);
-var TokenWithBearer = import_zod18.z.string().regex(/^Bearer\s/);
+var TokenUserType = import_zod19.z.enum(["user", "system"]);
+var TokenWithBearer = import_zod19.z.string().regex(/^Bearer\s/);
 
 // ../commons/src/events/ActionDocument.ts
-(0, import_zod_openapi8.extendZodWithOpenApi)(import_zod19.z);
-var ActionUpdate = import_zod19.z.record(import_zod19.z.string(), FieldUpdateValue);
-var EventState = import_zod19.z.record(import_zod19.z.string(), FieldValue);
+(0, import_zod_openapi8.extendZodWithOpenApi)(import_zod20.z);
+var ActionUpdate = import_zod20.z.record(import_zod20.z.string(), FieldUpdateValue);
+var EventState = import_zod20.z.record(import_zod20.z.string(), FieldValue);
 var ActionStatus = {
   Requested: "Requested",
   Accepted: "Accepted",
   Rejected: "Rejected"
 };
-var ActionBase = import_zod19.z.object({
+var ActionBase = import_zod20.z.object({
   id: UUID,
-  transactionId: import_zod19.z.string(),
+  transactionId: import_zod20.z.string(),
   createdByUserType: TokenUserType,
-  createdAt: import_zod19.z.string().datetime(),
-  createdBy: import_zod19.z.string(),
-  createdByRole: import_zod19.z.string(),
-  createdBySignature: import_zod19.z.string().nullish().describe("Reference to signature of the user who created the action"),
+  createdAt: import_zod20.z.string().datetime(),
+  createdBy: import_zod20.z.string(),
+  createdByRole: import_zod20.z.string(),
+  createdBySignature: import_zod20.z.string().nullish().describe("Reference to signature of the user who created the action"),
   createdAtLocation: CreatedAtLocation,
   declaration: ActionUpdate,
   annotation: ActionUpdate.optional().nullable(),
-  status: import_zod19.z.enum([
+  status: import_zod20.z.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
@@ -1902,94 +1968,107 @@ var ActionBase = import_zod19.z.object({
   originalActionId: UUID.optional().nullable().describe(
     "Reference to the original action that was asynchronously rejected or accepted by 3rd party integration."
   )
+  // 'content' field reserved for additional data
+  // Each action can define its own content specifc to the action
+  // See PrintCertificateAction
 });
 var AssignedAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod19.z.string()
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.ASSIGN),
+    assignedTo: import_zod20.z.string()
+    // TODO move into 'content' property
   })
 );
 var UnassignedAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.UNASSIGN)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.UNASSIGN)
   })
 );
 var RegisterAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REGISTER),
-    registrationNumber: import_zod19.z.string().optional()
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.REGISTER),
+    registrationNumber: import_zod20.z.string().optional()
+    // TODO move into 'content' property
   })
 );
 var DeclareAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.DECLARE)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.DECLARE)
   })
 );
 var ValidateAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.VALIDATE)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.VALIDATE)
   })
 );
-var RejectionReason = import_zod19.z.object({
-  message: import_zod19.z.string().min(1, { message: "Message cannot be empty" }).describe("Message describing reason for rejection or archiving"),
-  isDuplicate: import_zod19.z.boolean().optional().describe("If a declaration is duplicated")
+var RejectionReason = import_zod20.z.object({
+  message: import_zod20.z.string().min(1, { message: "Message cannot be empty" }).describe("Message describing reason for rejection or archiving"),
+  isDuplicate: import_zod20.z.boolean().optional().describe("If a declaration is duplicated")
 });
 var RejectAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REJECT),
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.REJECT),
     reason: RejectionReason
+    // TODO move into 'content' property
   })
 );
 var MarkAsDuplicateAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.MARKED_AS_DUPLICATE)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.ARCHIVE),
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.ARCHIVE),
     reason: RejectionReason
+    // TODO move into 'content' property
   })
 );
 var CreatedAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.CREATE)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.CREATE)
   })
 );
 var NotifiedAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.NOTIFY)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.NOTIFY)
   })
 );
+var PrintContent = import_zod20.z.object({
+  templateId: import_zod20.z.string().optional()
+});
 var PrintCertificateAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.PRINT_CERTIFICATE)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.PRINT_CERTIFICATE),
+    content: PrintContent.optional().nullable()
   })
 );
 var RequestedCorrectionAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REQUEST_CORRECTION)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.REQUEST_CORRECTION)
   })
 );
 var ApprovedCorrectionAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.APPROVE_CORRECTION),
-    requestId: import_zod19.z.string()
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.APPROVE_CORRECTION),
+    requestId: import_zod20.z.string()
+    // TODO move into 'content' property
   })
 );
 var RejectedCorrectionAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REJECT_CORRECTION),
-    requestId: import_zod19.z.string(),
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.REJECT_CORRECTION),
+    requestId: import_zod20.z.string(),
+    // TODO move into 'content' property
     reason: RejectionReason
   })
 );
 var ReadAction = ActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.READ)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.READ)
   })
 );
-var ActionDocument = import_zod19.z.discriminatedUnion("type", [
+var ActionDocument = import_zod20.z.discriminatedUnion("type", [
   CreatedAction.openapi({ ref: "CreatedAction" }),
   ValidateAction.openapi({ ref: "ValidateAction" }),
   RejectAction.openapi({ ref: "RejectAction" }),
@@ -2012,31 +2091,31 @@ var AsyncRejectActionDocument = ActionBase.omit({
   declaration: true,
   annotation: true
 }).merge(
-  import_zod19.z.object({
-    type: import_zod19.z.enum(ConfirmableActions),
-    status: import_zod19.z.literal(ActionStatus.Rejected)
+  import_zod20.z.object({
+    type: import_zod20.z.enum(ConfirmableActions),
+    status: import_zod20.z.literal(ActionStatus.Rejected)
   })
 );
-var Action = import_zod19.z.union([ActionDocument, AsyncRejectActionDocument]);
-var ResolvedUser = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  role: import_zod19.z.string(),
-  name: import_zod19.z.array(
-    import_zod19.z.object({
-      use: import_zod19.z.string(),
-      given: import_zod19.z.array(import_zod19.z.string()),
-      family: import_zod19.z.string()
+var Action = import_zod20.z.union([ActionDocument, AsyncRejectActionDocument]);
+var ResolvedUser = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  role: import_zod20.z.string(),
+  name: import_zod20.z.array(
+    import_zod20.z.object({
+      use: import_zod20.z.string(),
+      given: import_zod20.z.array(import_zod20.z.string()),
+      family: import_zod20.z.string()
     })
   )
 });
 
 // ../commons/src/conditionals/validate.ts
-var import_ajv = __toESM(require("ajv"));
+var import__ = __toESM(require("ajv/dist/2019"));
 var import_ajv_formats = __toESM(require("ajv-formats"));
 var import_date_fns = require("date-fns");
 
 // ../commons/src/events/FieldTypeMapping.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 function mapFieldTypeToZod(type, required) {
   let schema;
   switch (type) {
@@ -2102,7 +2181,7 @@ function createValidationSchema(config) {
   for (const field2 of config) {
     shape[field2.id] = mapFieldTypeToZod(field2.type, field2.required);
   }
-  return import_zod20.z.object(shape);
+  return import_zod21.z.object(shape);
 }
 function mapFieldTypeToEmptyValue(field2) {
   switch (field2.type) {
@@ -2245,9 +2324,11 @@ var isNonInteractiveFieldType = (field2) => {
 };
 
 // ../commons/src/conditionals/validate.ts
-var ajv = new import_ajv.default({
+var ajv = new import__.default({
   $data: true,
-  allowUnionTypes: true
+  allowUnionTypes: true,
+  strict: false
+  // Allow minContains and other newer features
 });
 (0, import_ajv_formats.default)(ajv);
 ajv.addKeyword({
@@ -2420,6 +2501,23 @@ function validateFieldInput({
   const rawError = zodType.safeParse(value, { errorMap: zodToIntlErrorMap });
   return rawError.error?.issues.map((issue) => issue.message) ?? [];
 }
+function runStructuralValidations({
+  field: field2,
+  values
+}) {
+  if (!isFieldVisible(field2, values) || isFieldEmptyAndNotRequired(field2, values)) {
+    return {
+      errors: []
+    };
+  }
+  const fieldValidationResult = validateFieldInput({
+    field: field2,
+    value: values[field2.id]
+  });
+  return {
+    errors: fieldValidationResult
+  };
+}
 function runFieldValidations({
   field: field2,
   values
@@ -2485,6 +2583,11 @@ function getValidatorsForField(fieldId, validations) {
     };
   }).filter((x) => x !== null);
 }
+function areCertificateConditionsMet(conditions, values) {
+  return conditions.every((condition) => {
+    return ajv.validate(condition.conditional, values);
+  });
+}
 
 // ../commons/src/utils.ts
 function getOrThrow(x, message) {
@@ -2586,10 +2689,16 @@ function omitHiddenPaginatedFields(formConfig, declaration) {
   const visiblePagesFormFields = formConfig.pages.filter((p) => isPageVisible(p, declaration)).flatMap((p) => p.fields);
   return omitHiddenFields(visiblePagesFormFields, declaration);
 }
-function findActiveDrafts(event2, drafts) {
-  const actions = event2.actions.slice().filter(({ type }) => type !== ActionType.READ).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+function findActiveDraftForEvent(event2, draft) {
+  const actions = (0, import_lodash.orderBy)(
+    event2.actions.filter(({ type }) => type !== ActionType.READ),
+    ["createdAt"],
+    ["asc"]
+  );
   const lastAction = actions[actions.length - 1];
-  return drafts.filter(({ createdAt }) => createdAt >= lastAction.createdAt).filter(({ eventId }) => eventId === event2.id);
+  const isDraftActive = draft.createdAt >= lastAction.createdAt;
+  const isDraftForEvent = event2.id === draft.eventId;
+  return isDraftActive && isDraftForEvent ? draft : void 0;
 }
 function createEmptyDraft(eventId, draftId, actionType) {
   return {
@@ -2705,16 +2814,16 @@ function timePeriodToDateRange(value) {
   let startDate;
   switch (value) {
     case "last7Days":
-      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 6);
+      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 7);
       break;
     case "last30Days":
-      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 29);
+      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 30);
       break;
     case "last90Days":
-      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 89);
+      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 90);
       break;
     case "last365Days":
-      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 364);
+      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 365);
       break;
   }
   return {
@@ -2722,12 +2831,35 @@ function timePeriodToDateRange(value) {
     endDate: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
+function mergeDrafts(currentDraft, incomingDraft) {
+  if (currentDraft.eventId !== incomingDraft.eventId) {
+    throw new Error(
+      `Cannot merge drafts for different events: ${currentDraft.eventId} and ${incomingDraft.eventId}`
+    );
+  }
+  return {
+    ...currentDraft,
+    ...incomingDraft,
+    action: {
+      ...currentDraft.action,
+      ...incomingDraft.action,
+      declaration: deepMerge(
+        currentDraft.action.declaration,
+        incomingDraft.action.declaration
+      ),
+      annotation: deepMerge(
+        currentDraft.action.annotation ?? {},
+        incomingDraft.action.annotation ?? {}
+      )
+    }
+  };
+}
 
 // ../commons/src/events/EventConfig.ts
 var import_zod_openapi9 = require("zod-openapi");
-(0, import_zod_openapi9.extendZodWithOpenApi)(import_zod21.z);
-var EventConfig = import_zod21.z.object({
-  id: import_zod21.z.string().describe(
+(0, import_zod_openapi9.extendZodWithOpenApi)(import_zod22.z);
+var EventConfig = import_zod22.z.object({
+  id: import_zod22.z.string().describe(
     'A machine-readable identifier for the event, e.g. "birth" or "death"'
   ),
   dateOfEvent: FieldReference.optional(),
@@ -2737,10 +2869,10 @@ var EventConfig = import_zod21.z.object({
   ),
   summary: SummaryConfig,
   label: TranslationConfig,
-  actions: import_zod21.z.array(ActionConfig),
+  actions: import_zod22.z.array(ActionConfig),
   declaration: DeclarationFormConfig,
-  deduplication: import_zod21.z.array(DeduplicationConfig).optional().default([]),
-  advancedSearch: import_zod21.z.array(AdvancedSearchConfig).optional().default([])
+  deduplication: import_zod22.z.array(DeduplicationConfig).optional().default([]),
+  advancedSearch: import_zod22.z.array(AdvancedSearchConfig).optional().default([])
 }).superRefine((event2, ctx) => {
   const allFields = findAllFields(event2);
   const fieldIds = allFields.map((field2) => field2.id);
@@ -2824,12 +2956,12 @@ var definePage = (page) => PageConfig.parse(page);
 var defineFormPage = (formPage) => FormPageConfig.parse(formPage);
 
 // ../commons/src/events/WorkqueueConfig.ts
-var import_zod28 = require("zod");
+var import_zod29 = require("zod");
 
 // ../commons/src/events/serializers/user/serializer.ts
-var import_zod22 = require("zod");
-var SerializedUserField = import_zod22.z.object({
-  $userField: import_zod22.z.enum([
+var import_zod23 = require("zod");
+var SerializedUserField = import_zod23.z.object({
+  $userField: import_zod23.z.enum([
     "id",
     "name",
     "role",
@@ -3081,8 +3213,9 @@ function createFieldConditionals(fieldId) {
       properties: {
         [fieldId]: {
           type: "string",
-          pattern: "^[\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*( [\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*)*$",
-          description: "Name must contain only letters, numbers, and allowed special characters ('._-). No double spaces."
+          minLength: 1,
+          pattern: "^[\\p{Script=Latin}0-9'.-]*(\\([\\p{Script=Latin}0-9'.-]+\\))?[\\p{Script=Latin}0-9'.-]*( [\\p{Script=Latin}0-9'.-]*(\\([\\p{Script=Latin}0-9'.-]+\\))?[\\p{Script=Latin}0-9'.-]*)*$",
+          description: "Name must contain only letters, numbers, and allowed special characters ('.-). No double spaces."
         }
       }
     }),
@@ -3195,7 +3328,7 @@ function createSearchConfig(baseField) {
 // ../commons/src/event-config/event-configuration.ts
 function createEventFieldConfig(fieldId) {
   const baseField = {
-    fieldId,
+    fieldId: `${METADATA_FIELD_PREFIX}${fieldId}`,
     fieldType: "event"
   };
   return createSearchConfig(baseField);
@@ -3208,32 +3341,107 @@ function eventFn(fieldId) {
 var event = Object.assign(eventFn, {
   /**
    * Checks if the event contains a specific action type.
+   * Can be used directly as a conditional or chained with additional methods.
    * @param action - The action type to check for.
    */
-  hasAction: (action) => defineConditional({
-    type: "object",
-    properties: {
-      $event: {
+  hasAction: (action) => {
+    const basicConditional = defineConditional({
+      type: "object",
+      properties: {
+        $event: {
+          type: "object",
+          properties: {
+            actions: {
+              type: "array",
+              contains: {
+                type: "object",
+                properties: {
+                  type: {
+                    const: action
+                  }
+                },
+                required: ["type"]
+              }
+            }
+          },
+          required: ["actions"]
+        }
+      },
+      required: ["$event"]
+    });
+    const buildActionConstraints = (additionalFields) => {
+      const actionProperties = {
+        type: { const: action }
+      };
+      const requiredFields = ["type"];
+      if (additionalFields) {
+        Object.entries(additionalFields).forEach(([key, value]) => {
+          actionProperties[key] = { const: value };
+          requiredFields.push(key);
+        });
+      }
+      return { actionProperties, requiredFields };
+    };
+    const createCountConditional = (countType, count, additionalFields) => {
+      const { actionProperties, requiredFields } = buildActionConstraints(additionalFields);
+      return defineConditional({
         type: "object",
         properties: {
-          actions: {
-            type: "array",
-            contains: {
-              type: "object",
-              properties: {
-                type: {
-                  const: action
-                }
-              },
-              required: ["type"]
-            }
+          $event: {
+            type: "object",
+            properties: {
+              actions: {
+                type: "array",
+                contains: {
+                  type: "object",
+                  properties: actionProperties,
+                  required: requiredFields
+                },
+                [countType]: count
+              }
+            },
+            required: ["actions"]
           }
         },
-        required: ["actions"]
-      }
-    },
-    required: ["$event"]
-  }),
+        required: ["$event"]
+      });
+    };
+    const withMinMax = (additionalFields) => {
+      return {
+        /**
+         * Creates a conditional that checks if the event contains a specific action type
+         * with a minimum count of occurrences.
+         *
+         * @param minCount - The minimum number of actions required.
+         */
+        minCount: (minCount) => createCountConditional("minContains", minCount, additionalFields),
+        /**
+         * Builds a conditional that sets a maximum count for the number of actions.
+         * This is useful for limiting the number of actions of a specific type in a single event.
+         */
+        maxCount: (maxCount) => createCountConditional("maxContains", maxCount, additionalFields)
+      };
+    };
+    const chainableMethods = {
+      /**
+       * Adds additional field constraints to the action matching.
+       *
+       * @param fields - Object containing additional fields to match on the action.
+       */
+      withFields: (fields) => withMinMax(fields),
+      /**
+       * Adds template ID constraint to the action matching.
+       * This is a convenience method that adds content.templateId to the fields.
+       *
+       * @param id - The template ID to match against.
+       */
+      withTemplate: (id) => withMinMax({
+        content: { templateId: id }
+      }),
+      ...withMinMax()
+    };
+    return { ...basicConditional, ...chainableMethods };
+  },
   field(field2) {
     return {
       $event: field2
@@ -3242,83 +3450,82 @@ var event = Object.assign(eventFn, {
 });
 
 // ../commons/src/events/WorkqueueColumnConfig.ts
-var import_zod24 = require("zod");
+var import_zod25 = require("zod");
 
 // ../commons/src/events/EventMetadata.ts
-var import_zod23 = require("zod");
-var EventStatus = import_zod23.z.enum([
+var import_zod24 = require("zod");
+var EventStatus = import_zod24.z.enum([
   "CREATED",
   "NOTIFIED",
   "DECLARED",
   "VALIDATED",
   "REGISTERED",
-  "CERTIFIED",
   "ARCHIVED"
 ]);
-var VisibleStatus = import_zod23.z.enum([...EventStatus.options, "REJECTED"]);
 var InherentFlags = {
-  PRINTED: "printed",
+  PENDING_CERTIFICATION: "pending-certification",
   INCOMPLETE: "incomplete",
   REJECTED: "rejected",
   CORRECTION_REQUESTED: "correction-requested"
 };
-var Flag = import_zod23.z.string().regex(
+var ActionFlag = import_zod24.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_zod23.z.nativeEnum(InherentFlags));
-var ZodDate = import_zod23.z.string().date();
-var ActionCreationMetadata = import_zod23.z.object({
-  createdAt: import_zod23.z.string().datetime().describe("The timestamp when the action request was created."),
-  createdBy: import_zod23.z.string().describe("ID of the user who created the action request."),
+);
+var Flag = ActionFlag.or(import_zod24.z.nativeEnum(InherentFlags));
+var ZodDate = import_zod24.z.string().date();
+var ActionCreationMetadata = import_zod24.z.object({
+  createdAt: import_zod24.z.string().datetime().describe("The timestamp when the action request was created."),
+  createdBy: import_zod24.z.string().describe("ID of the user who created the action request."),
   createdAtLocation: CreatedAtLocation.describe(
     "Location of the user who created the action request."
   ),
-  createdByUserType: import_zod23.z.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
-  acceptedAt: import_zod23.z.string().datetime().describe("Timestamp when the action request was accepted."),
-  createdByRole: import_zod23.z.string().describe("Role of the user at the time of action request creation."),
-  createdBySignature: import_zod23.z.string().nullish().describe("Signature of the user who created the action request.")
+  createdByUserType: import_zod24.z.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
+  acceptedAt: import_zod24.z.string().datetime().describe("Timestamp when the action request was accepted."),
+  createdByRole: import_zod24.z.string().describe("Role of the user at the time of action request creation."),
+  createdBySignature: import_zod24.z.string().nullish().describe("Signature of the user who created the action request.")
 });
 var RegistrationCreationMetadata = ActionCreationMetadata.extend({
-  registrationNumber: import_zod23.z.string().describe(
+  registrationNumber: import_zod24.z.string().describe(
     "Registration number of the event. Always present for accepted registrations."
   )
 });
-var LegalStatuses = import_zod23.z.object({
+var LegalStatuses = import_zod24.z.object({
   [EventStatus.enum.DECLARED]: ActionCreationMetadata.nullish(),
   [EventStatus.enum.REGISTERED]: RegistrationCreationMetadata.nullish()
 });
-var EventMetadata = import_zod23.z.object({
+var EventMetadata = import_zod24.z.object({
   id: UUID,
-  type: import_zod23.z.string().describe("The type of event, such as birth, death, or marriage."),
+  type: import_zod24.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_zod23.z.string().datetime().describe("The timestamp when the event was first created and saved."),
+  createdAt: import_zod24.z.string().datetime().describe("The timestamp when the event was first created and saved."),
   dateOfEvent: ZodDate.nullish(),
-  createdBy: import_zod23.z.string().describe("ID of the user who created the event."),
-  createdByUserType: import_zod23.z.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
-  updatedByUserRole: import_zod23.z.string().describe("Role of the user who last changed the status."),
+  createdBy: import_zod24.z.string().describe("ID of the user who created the event."),
+  createdByUserType: import_zod24.z.enum(["user", "system"]).nullish().describe("Whether the user is a normal user or a system."),
+  updatedByUserRole: import_zod24.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_zod23.z.string().nullish().describe("Signature of the user who created the event."),
+  createdBySignature: import_zod24.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_zod23.z.string().datetime().describe(
+  updatedAt: import_zod24.z.string().datetime().describe(
     "Timestamp of the most recent *accepted* status change. Possibly 3rd party update, if action is validation asynchronously."
   ),
-  assignedTo: import_zod23.z.string().nullish().describe("ID of the user currently assigned to the event."),
-  updatedBy: import_zod23.z.string().nullish().describe("ID of the user who last changed the status."),
-  trackingId: import_zod23.z.string().describe(
+  assignedTo: import_zod24.z.string().nullish().describe("ID of the user currently assigned to the event."),
+  updatedBy: import_zod24.z.string().nullish().describe("ID of the user who last changed the status."),
+  trackingId: import_zod24.z.string().describe(
     "System-generated tracking ID used by informants or registrars to look up the event."
   ),
-  flags: import_zod23.z.array(Flag)
+  flags: import_zod24.z.array(Flag)
 });
 var EventMetadataKeysArray = [
   "id",
@@ -3338,7 +3545,7 @@ var EventMetadataKeysArray = [
   "legalStatuses",
   "flags"
 ];
-var EventMetadataKeys = import_zod23.z.enum(EventMetadataKeysArray);
+var EventMetadataKeys = import_zod24.z.enum(EventMetadataKeysArray);
 var eventMetadataLabelMap = {
   "event.assignedTo": {
     id: "event.assignedTo.label",
@@ -3423,11 +3630,11 @@ var WorkqueueColumnKeysArray = [
   "title",
   "outbox"
 ];
-var WorkqueueColumnKeys = import_zod24.z.enum(WorkqueueColumnKeysArray);
-var WorkqueueColumnValue = import_zod24.z.object({
+var WorkqueueColumnKeys = import_zod25.z.enum(WorkqueueColumnKeysArray);
+var WorkqueueColumnValue = import_zod25.z.object({
   $event: WorkqueueColumnKeys
 });
-var WorkqueueColumn = import_zod24.z.object({
+var WorkqueueColumn = import_zod25.z.object({
   label: TranslationConfig,
   value: WorkqueueColumnValue
 });
@@ -3438,120 +3645,120 @@ function defineWorkqueuesColumns(workqueueColumns) {
 }
 
 // ../commons/src/events/CountryConfigQueryInput.ts
-var import_zod26 = require("zod");
+var import_zod27 = require("zod");
 
 // ../commons/src/events/EventIndex.ts
-var import_zod25 = require("zod");
+var import_zod26 = require("zod");
 var import_zod_openapi10 = require("zod-openapi");
-(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod25.z);
+(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod26.z);
 var EventIndex = EventMetadata.extend({
   declaration: EventState
 }).openapi({
   ref: "EventIndex"
 });
-var EventSearchIndex = import_zod25.z.record(import_zod25.z.string(), import_zod25.z.any()).and(
-  import_zod25.z.object({
-    type: import_zod25.z.string()
+var EventSearchIndex = import_zod26.z.record(import_zod26.z.string(), import_zod26.z.any()).and(
+  import_zod26.z.object({
+    type: import_zod26.z.string()
     // Ensures "type" (event-id) exists and is a string
   })
 ).openapi({
   ref: "EventSearchIndex"
 });
-var Fuzzy = import_zod25.z.object({ type: import_zod25.z.literal("fuzzy"), term: import_zod25.z.string() }).openapi({
+var Fuzzy = import_zod26.z.object({ type: import_zod26.z.literal("fuzzy"), term: import_zod26.z.string() }).openapi({
   ref: "Fuzzy"
 });
-var Exact = import_zod25.z.object({ type: import_zod25.z.literal("exact"), term: import_zod25.z.string() }).openapi({
+var Exact = import_zod26.z.object({ type: import_zod26.z.literal("exact"), term: import_zod26.z.string() }).openapi({
   ref: "Exact"
 });
-var ExactStatus = import_zod25.z.object({
-  type: import_zod25.z.literal("exact"),
+var ExactStatus = import_zod26.z.object({
+  type: import_zod26.z.literal("exact"),
   term: EventStatus
 }).openapi({
   ref: "ExactStatus"
 });
-var ExactUserType = import_zod25.z.object({
-  type: import_zod25.z.literal("exact"),
+var ExactUserType = import_zod26.z.object({
+  type: import_zod26.z.literal("exact"),
   term: TokenUserType
 }).openapi({
   ref: "ExactUserType"
 });
-var AnyOf = import_zod25.z.object({
-  type: import_zod25.z.literal("anyOf"),
-  terms: import_zod25.z.array(import_zod25.z.string())
+var AnyOf = import_zod26.z.object({
+  type: import_zod26.z.literal("anyOf"),
+  terms: import_zod26.z.array(import_zod26.z.string())
 }).openapi({
   ref: "AnyOf"
 });
-var AnyOfStatus = import_zod25.z.object({
-  type: import_zod25.z.literal("anyOf"),
-  terms: import_zod25.z.array(EventStatus)
+var AnyOfStatus = import_zod26.z.object({
+  type: import_zod26.z.literal("anyOf"),
+  terms: import_zod26.z.array(EventStatus)
 }).openapi({
   ref: "AnyOfStatus"
 });
-var Range = import_zod25.z.object({
-  type: import_zod25.z.literal("range"),
-  gte: import_zod25.z.string(),
-  lte: import_zod25.z.string()
+var Range = import_zod26.z.object({
+  type: import_zod26.z.literal("range"),
+  gte: import_zod26.z.string(),
+  lte: import_zod26.z.string()
 }).openapi({
   ref: "Range"
 });
-var ContainsFlags = import_zod25.z.object({
-  anyOf: import_zod25.z.array(Flag).optional(),
-  noneOf: import_zod25.z.array(Flag).optional()
+var ContainsFlags = import_zod26.z.object({
+  anyOf: import_zod26.z.array(Flag).optional(),
+  noneOf: import_zod26.z.array(Flag).optional()
 }).openapi({
   ref: "ContainsFlags"
 });
-var Within = import_zod25.z.object({ type: import_zod25.z.literal("within"), location: import_zod25.z.string() }).openapi({
+var Within = import_zod26.z.object({ type: import_zod26.z.literal("within"), location: import_zod26.z.string() }).openapi({
   ref: "Within"
 });
-var RangeDate = import_zod25.z.object({
-  type: import_zod25.z.literal("range"),
-  gte: import_zod25.z.string().date().or(import_zod25.z.string().datetime()),
-  lte: import_zod25.z.string().date().or(import_zod25.z.string().datetime())
+var RangeDate = import_zod26.z.object({
+  type: import_zod26.z.literal("range"),
+  gte: import_zod26.z.string().date().or(import_zod26.z.string().datetime()),
+  lte: import_zod26.z.string().date().or(import_zod26.z.string().datetime())
 }).openapi({ ref: "RangeDate" });
 var ExactDate = Exact.extend({
-  term: import_zod25.z.string().date().or(import_zod25.z.string().datetime())
+  term: import_zod26.z.string().date().or(import_zod26.z.string().datetime())
 }).openapi({
   ref: "ExactDate"
 });
-var TimePeriod = import_zod25.z.object({
-  type: import_zod25.z.literal("timePeriod"),
+var TimePeriod = import_zod26.z.object({
+  type: import_zod26.z.literal("timePeriod"),
   term: SelectDateRangeValue
 }).openapi({
   ref: "TimePeriod"
 });
-var DateCondition = import_zod25.z.union([ExactDate, RangeDate, TimePeriod]).openapi({
+var DateCondition = import_zod26.z.union([ExactDate, RangeDate, TimePeriod]).openapi({
   ref: "DateCondition"
 });
-var QueryInput = import_zod25.z.lazy(
-  () => import_zod25.z.union([
-    import_zod25.z.discriminatedUnion("type", [Fuzzy, Exact, Range, Within, AnyOf]),
-    import_zod25.z.record(import_zod25.z.string(), QueryInput)
+var QueryInput = import_zod26.z.lazy(
+  () => import_zod26.z.union([
+    import_zod26.z.discriminatedUnion("type", [Fuzzy, Exact, Range, Within, AnyOf]),
+    import_zod26.z.record(import_zod26.z.string(), QueryInput)
   ])
 ).openapi({
   ref: "QueryInput"
 });
-var QueryExpression = import_zod25.z.object({
-  id: import_zod25.z.optional(import_zod25.z.string()),
-  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),
-  "legalStatuses.REGISTERED.acceptedAt": import_zod25.z.optional(DateCondition),
-  "legalStatuses.DECLARED.createdAtLocation": import_zod25.z.optional(
-    import_zod25.z.union([Within, Exact])
+var QueryExpression = import_zod26.z.object({
+  id: import_zod26.z.optional(import_zod26.z.string()),
+  eventType: import_zod26.z.string(),
+  status: import_zod26.z.optional(import_zod26.z.union([AnyOfStatus, ExactStatus])),
+  createdAt: import_zod26.z.optional(DateCondition),
+  updatedAt: import_zod26.z.optional(DateCondition),
+  "legalStatuses.REGISTERED.acceptedAt": import_zod26.z.optional(DateCondition),
+  "legalStatuses.DECLARED.createdAtLocation": import_zod26.z.optional(
+    import_zod26.z.union([Within, Exact])
   ),
-  "legalStatuses.REGISTERED.createdAtLocation": import_zod25.z.optional(
-    import_zod25.z.union([Within, Exact])
+  "legalStatuses.REGISTERED.createdAtLocation": import_zod26.z.optional(
+    import_zod26.z.union([Within, Exact])
   ),
-  "legalStatuses.REGISTERED.registrationNumber": import_zod25.z.optional(Exact),
-  createdAtLocation: import_zod25.z.optional(import_zod25.z.union([Within, Exact])),
-  updatedAtLocation: import_zod25.z.optional(import_zod25.z.union([Within, Exact])),
-  assignedTo: import_zod25.z.optional(Exact),
-  createdByUserType: import_zod25.z.optional(ExactUserType),
-  createdBy: import_zod25.z.optional(Exact),
-  updatedBy: import_zod25.z.optional(Exact),
-  trackingId: import_zod25.z.optional(Exact),
-  flags: import_zod25.z.optional(ContainsFlags),
+  "legalStatuses.REGISTERED.registrationNumber": import_zod26.z.optional(Exact),
+  createdAtLocation: import_zod26.z.optional(import_zod26.z.union([Within, Exact])),
+  updatedAtLocation: import_zod26.z.optional(import_zod26.z.union([Within, Exact])),
+  assignedTo: import_zod26.z.optional(Exact),
+  createdByUserType: import_zod26.z.optional(ExactUserType),
+  createdBy: import_zod26.z.optional(Exact),
+  updatedBy: import_zod26.z.optional(Exact),
+  trackingId: import_zod26.z.optional(Exact),
+  flags: import_zod26.z.optional(ContainsFlags),
   // @todo: The type for this comes out as "any"
   data: QueryInput
 }).partial().refine((obj) => Object.values(obj).some((val) => val !== void 0), {
@@ -3559,9 +3766,9 @@ var QueryExpression = import_zod25.z.object({
 }).openapi({
   ref: "QueryExpression"
 });
-var QueryType = import_zod25.z.object({
-  type: import_zod25.z.literal("and").or(import_zod25.z.literal("or")).openapi({ default: "and" }),
-  clauses: import_zod25.z.preprocess(
+var QueryType = import_zod26.z.object({
+  type: import_zod26.z.literal("and").or(import_zod26.z.literal("or")).openapi({ default: "and" }),
+  clauses: import_zod26.z.preprocess(
     (val) => {
       if (typeof val === "string") {
         return [JSON.parse(val)];
@@ -3571,7 +3778,7 @@ var QueryType = import_zod25.z.object({
       }
       return val;
     },
-    import_zod25.z.array(QueryExpression).nonempty("At least one clause is required.").openapi({
+    import_zod26.z.array(QueryExpression).nonempty("At least one clause is required.").openapi({
       default: [
         {
           eventType: TENNIS_CLUB_MEMBERSHIP,
@@ -3598,56 +3805,56 @@ var SearchScopeAccessLevels = {
 };
 
 // ../commons/src/events/CountryConfigQueryInput.ts
-var SerializableExact = import_zod26.z.object({
-  type: import_zod26.z.literal("exact"),
-  term: import_zod26.z.union([import_zod26.z.string(), SerializedUserField])
+var SerializableExact = import_zod27.z.object({
+  type: import_zod27.z.literal("exact"),
+  term: import_zod27.z.union([import_zod27.z.string(), SerializedUserField])
 });
-var SerializableWithin = import_zod26.z.object({
-  type: import_zod26.z.literal("within"),
-  location: import_zod26.z.union([import_zod26.z.string(), SerializedUserField])
+var SerializableWithin = import_zod27.z.object({
+  type: import_zod27.z.literal("within"),
+  location: import_zod27.z.union([import_zod27.z.string(), SerializedUserField])
 });
-var SerializedQueryExpression = import_zod26.z.object({
-  eventType: import_zod26.z.string(),
-  status: import_zod26.z.optional(import_zod26.z.union([AnyOfStatus, ExactStatus])),
-  createdAt: import_zod26.z.optional(DateCondition),
-  updatedAt: import_zod26.z.optional(DateCondition),
-  "legalStatuses.REGISTERED.createdAt": import_zod26.z.optional(DateCondition),
-  "legalStatuses.REGISTERED.createdAtLocation": import_zod26.z.optional(
-    import_zod26.z.union([Within, Exact])
+var SerializedQueryExpression = import_zod27.z.object({
+  eventType: import_zod27.z.string(),
+  status: import_zod27.z.optional(import_zod27.z.union([AnyOfStatus, ExactStatus])),
+  createdAt: import_zod27.z.optional(DateCondition),
+  updatedAt: import_zod27.z.optional(DateCondition),
+  "legalStatuses.REGISTERED.createdAt": import_zod27.z.optional(DateCondition),
+  "legalStatuses.REGISTERED.createdAtLocation": import_zod27.z.optional(
+    import_zod27.z.union([Within, Exact])
   ),
-  "legalStatuses.REGISTERED.registrationNumber": import_zod26.z.optional(Exact),
-  createdAtLocation: import_zod26.z.optional(
-    import_zod26.z.union([SerializableWithin, SerializableExact])
+  "legalStatuses.REGISTERED.registrationNumber": import_zod27.z.optional(Exact),
+  createdAtLocation: import_zod27.z.optional(
+    import_zod27.z.union([SerializableWithin, SerializableExact])
   ),
-  updatedAtLocation: import_zod26.z.optional(
-    import_zod26.z.union([SerializableWithin, SerializableExact])
+  updatedAtLocation: import_zod27.z.optional(
+    import_zod27.z.union([SerializableWithin, SerializableExact])
   ),
-  assignedTo: import_zod26.z.optional(SerializableExact),
-  createdBy: import_zod26.z.optional(SerializableExact),
+  assignedTo: import_zod27.z.optional(SerializableExact),
+  createdBy: import_zod27.z.optional(SerializableExact),
   createdByUserType: ExactUserType,
-  updatedBy: import_zod26.z.optional(SerializableExact),
-  trackingId: import_zod26.z.optional(Exact),
-  flags: import_zod26.z.optional(ContainsFlags),
+  updatedBy: import_zod27.z.optional(SerializableExact),
+  trackingId: import_zod27.z.optional(Exact),
+  flags: import_zod27.z.optional(ContainsFlags),
   data: QueryInput
 }).partial();
-var Or2 = import_zod26.z.object({
-  type: import_zod26.z.literal("or"),
-  clauses: import_zod26.z.array(SerializedQueryExpression)
+var Or2 = import_zod27.z.object({
+  type: import_zod27.z.literal("or"),
+  clauses: import_zod27.z.array(SerializedQueryExpression)
 });
-var And2 = import_zod26.z.object({
-  type: import_zod26.z.literal("and"),
-  clauses: import_zod26.z.array(SerializedQueryExpression)
+var And2 = import_zod27.z.object({
+  type: import_zod27.z.literal("and"),
+  clauses: import_zod27.z.array(SerializedQueryExpression)
 });
-var CountryConfigQueryType = import_zod26.z.discriminatedUnion("type", [And2, Or2]);
-var CountryConfigQueryInputType = import_zod26.z.union([
+var CountryConfigQueryType = import_zod27.z.discriminatedUnion("type", [And2, Or2]);
+var CountryConfigQueryInputType = import_zod27.z.union([
   SerializedQueryExpression,
   And2,
   Or2
 ]);
 
 // ../commons/src/icons.ts
-var import_zod27 = require("zod");
-var AvailableIcons = import_zod27.z.enum([
+var import_zod28 = require("zod");
+var AvailableIcons = import_zod28.z.enum([
   "Archived",
   "Assigned",
   "Certified",
@@ -3768,43 +3975,45 @@ var mandatoryColumns = defineWorkqueuesColumns([
     value: event.field("updatedAt")
   }
 ]);
-var WorkqueueActionsWithDefault = import_zod28.z.enum([
+var WorkqueueActionsWithDefault = import_zod29.z.enum([
   ...workqueueActions.options,
   "DEFAULT"
 ]);
-var WorkqueueConfig = import_zod28.z.object({
-  slug: import_zod28.z.string().describe("Determines the url of the workqueue."),
+var WorkqueueConfig = import_zod29.z.object({
+  slug: import_zod29.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_zod28.z.array(
-    import_zod28.z.object({
+  actions: import_zod29.z.array(
+    import_zod29.z.object({
       type: WorkqueueActionsWithDefault,
-      conditionals: import_zod28.z.array(Conditional).optional()
+      conditionals: import_zod29.z.array(Conditional).optional()
     })
   ),
-  columns: import_zod28.z.array(WorkqueueColumn).default(mandatoryColumns),
-  icon: AvailableIcons
+  columns: import_zod29.z.array(WorkqueueColumn).default(mandatoryColumns),
+  icon: AvailableIcons,
+  emptyMessage: TranslationConfig.optional()
 }).describe("Configuration for workqueue.");
 var WorkqueueConfigWithoutQuery = WorkqueueConfig.omit({
   query: true,
   columns: true
 });
-var WorkqueueConfigInput = import_zod28.z.object({
-  slug: import_zod28.z.string().describe("Determines the url of the workqueue."),
+var WorkqueueConfigInput = import_zod29.z.object({
+  slug: import_zod29.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_zod28.z.array(
-    import_zod28.z.object({
+  actions: import_zod29.z.array(
+    import_zod29.z.object({
       type: WorkqueueActionsWithDefault,
-      conditionals: import_zod28.z.array(Conditional).optional()
+      conditionals: import_zod29.z.array(Conditional).optional()
     })
   ),
-  columns: import_zod28.z.array(WorkqueueColumn).default(mandatoryColumns),
-  icon: AvailableIcons
+  columns: import_zod29.z.array(WorkqueueColumn).default(mandatoryColumns),
+  icon: AvailableIcons,
+  emptyMessage: TranslationConfig.optional()
 });
 function defineWorkqueue(workqueueInput) {
   const queryInput = workqueueInput.query;
@@ -3814,10 +4023,10 @@ function defineWorkqueue(workqueueInput) {
 function defineWorkqueues(workqueues) {
   return workqueues.map((workqueue) => defineWorkqueue(workqueue));
 }
-var WorkqueueCountInput = import_zod28.z.array(
-  import_zod28.z.object({ slug: import_zod28.z.string(), query: QueryType })
+var WorkqueueCountInput = import_zod29.z.array(
+  import_zod29.z.object({ slug: import_zod29.z.string(), query: QueryType })
 );
-var WorkqueueCountOutput = import_zod28.z.record(import_zod28.z.string(), import_zod28.z.number());
+var WorkqueueCountOutput = import_zod29.z.record(import_zod29.z.string(), import_zod29.z.number());
 
 // ../commons/src/events/workqueueDefaultColumns.ts
 var defaultWorkqueueColumns = [
@@ -3840,42 +4049,42 @@ var defaultWorkqueueColumns = [
 ];
 
 // ../commons/src/events/Draft.ts
-var import_zod30 = require("zod");
+var import_zod31 = require("zod");
 
 // ../commons/src/events/ActionInput.ts
-var import_zod29 = require("zod");
+var import_zod30 = require("zod");
 var import_zod_openapi11 = require("zod-openapi");
-(0, import_zod_openapi11.extendZodWithOpenApi)(import_zod29.z);
-var BaseActionInput = import_zod29.z.object({
+(0, import_zod_openapi11.extendZodWithOpenApi)(import_zod30.z);
+var BaseActionInput = import_zod30.z.object({
   eventId: UUID,
-  transactionId: import_zod29.z.string(),
+  transactionId: import_zod30.z.string(),
   declaration: ActionUpdate.default({}),
   annotation: ActionUpdate.optional(),
   originalActionId: UUID.optional(),
   // should not be part of base action.
-  keepAssignment: import_zod29.z.boolean().optional()
+  keepAssignment: import_zod30.z.boolean().optional()
 });
 var CreateActionInput = BaseActionInput.merge(
-  import_zod29.z.object({
-    type: import_zod29.z.literal(ActionType.CREATE).default(ActionType.CREATE),
+  import_zod30.z.object({
+    type: import_zod30.z.literal(ActionType.CREATE).default(ActionType.CREATE),
     createdAtLocation: CreatedAtLocation
   })
 );
 var RegisterActionInput = BaseActionInput.merge(
-  import_zod29.z.object({
-    type: import_zod29.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
-    registrationNumber: import_zod29.z.string().optional()
+  import_zod30.z.object({
+    type: import_zod30.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
+    registrationNumber: import_zod30.z.string().optional()
   })
 ).strict();
 var ValidateActionInput = BaseActionInput.merge(
-  import_zod29.z.object({
-    type: import_zod29.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
-    duplicates: import_zod29.z.array(import_zod29.z.string())
+  import_zod30.z.object({
+    type: import_zod30.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
+    duplicates: import_zod30.z.array(import_zod30.z.string())
   })
 );
 var NotifyActionInput = BaseActionInput.merge(
-  import_zod29.z.object({
-    type: import_zod29.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
+  import_zod30.z.object({
+    type: import_zod30.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
   })
 ).openapi({
   default: {
@@ -3887,69 +4096,70 @@ var NotifyActionInput = BaseActionInput.merge(
   }
 });
 var DeclareActionInput = BaseActionInput.merge(
-  import_zod29.z.object({
-    type: import_zod29.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
+  import_zod30.z.object({
+    type: import_zod30.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
   })
 );
 var PrintCertificateActionInput = BaseActionInput.merge(
-  import_zod29.z.object({
-    type: import_zod29.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
+  import_zod30.z.object({
+    type: import_zod30.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE),
+    content: PrintContent.optional()
   })
 );
 var RejectDeclarationActionInput = BaseActionInput.merge(
-  import_zod29.z.object({
-    type: import_zod29.z.literal(ActionType.REJECT).default(ActionType.REJECT),
+  import_zod30.z.object({
+    type: import_zod30.z.literal(ActionType.REJECT).default(ActionType.REJECT),
     reason: RejectionReason
   })
 );
 var MarkedAsDuplicateActionInput = BaseActionInput.merge(
-  import_zod29.z.object({
-    type: import_zod29.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
+  import_zod30.z.object({
+    type: import_zod30.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveActionInput = BaseActionInput.merge(
-  import_zod29.z.object({
-    type: import_zod29.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE),
+  import_zod30.z.object({
+    type: import_zod30.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE),
     reason: RejectionReason
   })
 );
 var AssignActionInput = BaseActionInput.merge(
-  import_zod29.z.object({
-    type: import_zod29.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
-    assignedTo: import_zod29.z.string()
+  import_zod30.z.object({
+    type: import_zod30.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
+    assignedTo: import_zod30.z.string()
   })
 );
 var UnassignActionInput = BaseActionInput.merge(
-  import_zod29.z.object({
-    type: import_zod29.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
-    assignedTo: import_zod29.z.literal(null).default(null)
+  import_zod30.z.object({
+    type: import_zod30.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
+    assignedTo: import_zod30.z.literal(null).default(null)
   })
 );
 var RequestCorrectionActionInput = BaseActionInput.merge(
-  import_zod29.z.object({
-    type: import_zod29.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
+  import_zod30.z.object({
+    type: import_zod30.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
   })
 );
 var RejectCorrectionActionInput = BaseActionInput.merge(
-  import_zod29.z.object({
-    requestId: import_zod29.z.string(),
-    type: import_zod29.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION),
+  import_zod30.z.object({
+    requestId: import_zod30.z.string(),
+    type: import_zod30.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION),
     reason: RejectionReason
   })
 );
 var ApproveCorrectionActionInput = BaseActionInput.merge(
-  import_zod29.z.object({
-    requestId: import_zod29.z.string(),
-    type: import_zod29.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
+  import_zod30.z.object({
+    requestId: import_zod30.z.string(),
+    type: import_zod30.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
   })
 );
 var ReadActionInput = BaseActionInput.merge(
-  import_zod29.z.object({
-    type: import_zod29.z.literal(ActionType.READ).default(ActionType.READ)
+  import_zod30.z.object({
+    type: import_zod30.z.literal(ActionType.READ).default(ActionType.READ)
   })
 );
-var DeleteActionInput = import_zod29.z.object({ eventId: UUID });
-var ActionInput = import_zod29.z.discriminatedUnion("type", [
+var DeleteActionInput = import_zod30.z.object({ eventId: UUID });
+var ActionInput = import_zod30.z.discriminatedUnion("type", [
   CreateActionInput.openapi({ ref: "CreateActionInput" }),
   ValidateActionInput.openapi({ ref: "ValidateActionInput" }),
   RegisterActionInput.openapi({ ref: "RegisterActionInput" }),
@@ -3978,18 +4188,18 @@ var ActionInput = import_zod29.z.discriminatedUnion("type", [
 });
 
 // ../commons/src/events/Draft.ts
-var Draft = import_zod30.z.object({
+var Draft = import_zod31.z.object({
   id: UUID,
   eventId: UUID,
-  transactionId: import_zod30.z.string(),
-  createdAt: import_zod30.z.string().datetime(),
+  transactionId: import_zod31.z.string(),
+  createdAt: import_zod31.z.string().datetime(),
   action: ActionBase.extend({
-    type: ActionTypes
+    type: ActionTypes.exclude([ActionTypes.Enum.DELETE])
   }).omit({ id: true })
 });
 var DraftInput = BaseActionInput.extend({
-  type: ActionTypes,
-  status: import_zod30.z.enum([
+  type: ActionTypes.exclude([ActionTypes.Enum.DELETE]),
+  status: import_zod31.z.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
@@ -3997,26 +4207,29 @@ var DraftInput = BaseActionInput.extend({
 });
 
 // ../commons/src/events/EventInput.ts
-var import_zod31 = require("zod");
+var import_zod32 = require("zod");
 var import_uuid8 = require("uuid");
-var EventInput = import_zod31.z.object({
-  transactionId: import_zod31.z.string(),
-  type: import_zod31.z.string()
+var EventInput = import_zod32.z.object({
+  transactionId: import_zod32.z.string(),
+  type: import_zod32.z.string()
 }).openapi({ default: { transactionId: (0, import_uuid8.v4)(), type: "v2.birth" } });
 
 // ../commons/src/events/EventDocument.ts
-var import_zod32 = require("zod");
+var import_zod33 = require("zod");
 var import_zod_openapi12 = require("zod-openapi");
-(0, import_zod_openapi12.extendZodWithOpenApi)(import_zod32.z);
-var EventDocument = import_zod32.z.object({
+(0, import_zod_openapi12.extendZodWithOpenApi)(import_zod33.z);
+var EventDocument = import_zod33.z.object({
   id: UUID,
-  type: import_zod32.z.string(),
-  createdAt: import_zod32.z.string().datetime(),
-  updatedAt: import_zod32.z.string().datetime(),
-  actions: import_zod32.z.array(Action),
-  trackingId: import_zod32.z.string()
+  type: import_zod33.z.string(),
+  createdAt: import_zod33.z.string().datetime(),
+  updatedAt: import_zod33.z.string().datetime(),
+  actions: import_zod33.z.array(Action),
+  trackingId: import_zod33.z.string()
 }).openapi({ ref: "EventDocument" });
 
+// ../commons/src/events/state/index.ts
+var import_lodash3 = require("lodash");
+
 // ../commons/src/events/state/utils.ts
 var import_lodash2 = require("lodash");
 function getActionRequests(actionType, actions) {
@@ -4105,16 +4318,19 @@ function getLegalStatuses(actions) {
 }
 
 // ../commons/src/events/state/flags.ts
-function isCertificatePrinted(actions) {
+function isPendingCertification(actions) {
+  if (getStatusFromActions(actions) !== EventStatus.enum.REGISTERED) {
+    return false;
+  }
   return actions.reduce((prev, { type }) => {
     if (type === ActionType.PRINT_CERTIFICATE) {
-      return true;
+      return false;
     }
     if (type === ActionType.APPROVE_CORRECTION) {
-      return false;
+      return true;
     }
     return prev;
-  }, false);
+  }, true);
 }
 function isCorrectionRequested(actions) {
   return actions.reduce((prev, { type }) => {
@@ -4149,8 +4365,8 @@ function getFlagsFromActions(actions) {
     const flag = joinValues([type, status], ":").toLowerCase();
     return flag;
   });
-  if (isCertificatePrinted(sortedActions)) {
-    flags.push(InherentFlags.PRINTED);
+  if (isPendingCertification(sortedActions)) {
+    flags.push(InherentFlags.PENDING_CERTIFICATION);
   }
   if (isCorrectionRequested(sortedActions)) {
     flags.push(InherentFlags.CORRECTION_REQUESTED);
@@ -4181,7 +4397,6 @@ function getStatusFromActions(actions) {
       case ActionType.NOTIFY:
         return EventStatus.enum.NOTIFIED;
       case ActionType.PRINT_CERTIFICATE:
-        return EventStatus.enum.CERTIFIED;
       case ActionType.ASSIGN:
       case ActionType.UNASSIGN:
       case ActionType.REJECT:
@@ -4304,30 +4519,36 @@ function getCurrentEventState(event2, config) {
     flags: getFlagsFromActions(event2.actions)
   });
 }
-function getCurrentEventStateWithDrafts({
+function dangerouslyGetCurrentEventStateWithDrafts({
   event: event2,
-  drafts,
+  draft,
   configuration
 }) {
   const actions = event2.actions.slice().sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-  const activeDrafts = findActiveDrafts(event2, drafts).map((draft) => draft.action).flatMap((action) => {
-    if (action.type === ActionType.REQUEST_CORRECTION) {
-      return [
-        action,
-        {
-          ...action,
-          type: ActionType.APPROVE_CORRECTION
-        }
-      ];
-    }
-    return [action];
-  });
-  const actionWithDrafts = [...actions, ...activeDrafts].sort();
-  const withDrafts = {
+  const draftActions = draft.action.type === ActionType.REQUEST_CORRECTION ? (
+    /*
+     * If the action encountered is "REQUEST_CORRECTION", we want to pretend like it was approved
+     * so previews etc are shown correctly
+     */
+    [
+      draft.action,
+      {
+        id: getUUID(),
+        ...draft.action,
+        type: ActionType.APPROVE_CORRECTION
+      }
+    ]
+  ) : [{ ...draft.action, id: getUUID() }];
+  const actionsWithDraft = (0, import_lodash3.orderBy)(
+    [...actions, ...draftActions],
+    ["createdAt"],
+    "asc"
+  );
+  const eventWithDraft = {
     ...event2,
-    actions: actionWithDrafts
+    actions: actionsWithDraft
   };
-  return getCurrentEventState(withDrafts, configuration);
+  return getCurrentEventState(eventWithDraft, configuration);
 }
 function applyDeclarationToEventIndex(eventIndex, declaration, eventConfiguration) {
   const updatedDeclaration = deepMerge(eventIndex.declaration, declaration);
@@ -4341,18 +4562,18 @@ function applyDeclarationToEventIndex(eventIndex, declaration, eventConfiguratio
     declaration: updatedDeclaration
   };
 }
-function applyDraftsToEventIndex(eventIndex, drafts, eventConfiguration) {
+function applyDraftToEventIndex(eventIndex, draft, eventConfiguration) {
   const indexedAt = eventIndex.updatedAt;
-  const activeDrafts = drafts.filter(({ createdAt }) => new Date(createdAt) > new Date(indexedAt)).map((draft) => draft.action).sort();
-  if (activeDrafts.length === 0) {
+  const activeDraft = draft && draft.createdAt >= indexedAt ? draft : void 0;
+  if (!activeDraft) {
     return eventIndex;
   }
   return applyDeclarationToEventIndex(
     {
       ...eventIndex,
-      updatedAt: activeDrafts[activeDrafts.length - 1].createdAt
+      updatedAt: activeDraft.createdAt
     },
-    activeDrafts[activeDrafts.length - 1].declaration,
+    activeDraft.action.declaration,
     eventConfiguration
   );
 }
@@ -4366,18 +4587,17 @@ function getAnnotationFromDrafts(drafts) {
 function getActionAnnotation({
   event: event2,
   actionType,
-  drafts = []
+  draft
 }) {
   const activeActions = getAcceptedActions(event2);
-  const action = activeActions.find(
-    (activeAction) => actionType === activeAction.type
+  const action = (0, import_lodash3.findLast)(activeActions, (a) => a.type === actionType);
+  const matchingDraft = draft?.action.type === actionType ? draft : void 0;
+  const sortedActions = (0, import_lodash3.orderBy)(
+    [action, matchingDraft?.action].filter((a) => a !== void 0),
+    "createdAt",
+    "asc"
   );
-  const eventDrafts = drafts.filter((draft) => draft.eventId === event2.id);
-  const sorted = [
-    ...action ? [action] : [],
-    ...eventDrafts.map((draft) => draft.action)
-  ].sort();
-  const annotation = sorted.reduce((ann, sortedAction) => {
+  const annotation = sortedActions.reduce((ann, sortedAction) => {
     return deepMerge(ann, sortedAction.annotation ?? {});
   }, {});
   return deepDropNulls(annotation);
@@ -4395,23 +4615,23 @@ function generateTransactionId() {
 }
 
 // ../commons/src/events/User.ts
-var import_zod33 = require("zod");
-var User = import_zod33.z.object({
-  id: import_zod33.z.string(),
-  name: import_zod33.z.array(
-    import_zod33.z.object({
-      use: import_zod33.z.string(),
-      given: import_zod33.z.array(import_zod33.z.string()),
-      family: import_zod33.z.string()
+var import_zod34 = require("zod");
+var User = import_zod34.z.object({
+  id: import_zod34.z.string(),
+  name: import_zod34.z.array(
+    import_zod34.z.object({
+      use: import_zod34.z.string(),
+      given: import_zod34.z.array(import_zod34.z.string()),
+      family: import_zod34.z.string()
     })
   ),
-  role: import_zod33.z.string(),
+  role: import_zod34.z.string(),
   avatar: FullDocumentPath.optional(),
   signature: FullDocumentPath.optional()
 });
 
 // ../commons/src/events/test.utils.ts
-var import_lodash3 = require("lodash");
+var import_lodash4 = require("lodash");
 var import_date_fns4 = require("date-fns");
 
 // ../commons/src/field-config/field-configuration.ts
@@ -5146,7 +5366,27 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
             defaultMessage: "Applicant's name",
             description: "This is the label for the field",
             id: "v2.event.tennis-club-membership.action.declare.form.section.who.field.firstname.label"
-          }
+          },
+          configuration: {
+            name: {
+              firstname: { required: true },
+              middlename: { required: false },
+              surname: { required: true }
+            }
+          },
+          validation: [
+            {
+              validator: field("applicant.name").object({
+                firstname: field("firstname").isValidEnglishName(),
+                surname: field("surname").isValidEnglishName()
+              }),
+              message: {
+                defaultMessage: "Input contains invalid characters. Please use only letters (a-z, A-Z), numbers (0-9), hyphens (-), apostrophes(') and underscores (_)",
+                description: "This is the error message for invalid name",
+                id: "v2.error.invalidName"
+              }
+            }
+          ]
         },
         {
           id: "applicant.email",
@@ -5368,22 +5608,6 @@ var statusOptions = [
       id: "v2.advancedSearch.form.recordStatusRegistered"
     }
   },
-  {
-    value: EventStatus.enum.CERTIFIED,
-    label: {
-      defaultMessage: "Certified",
-      description: "Option for form field: status of record",
-      id: "v2.advancedSearch.form.recordStatusCertified"
-    }
-  },
-  {
-    value: VisibleStatus.enum.REJECTED,
-    label: {
-      defaultMessage: "Rejected",
-      description: "Option for form field: status of record",
-      id: "v2.advancedSearch.form.recordStatusRejected"
-    }
-  },
   {
     value: EventStatus.enum.ARCHIVED,
     label: {
@@ -6409,9 +6633,9 @@ var v2BirthEvent = defineConfig({
 });
 
 // ../commons/src/events/test.utils.ts
-var import_zod34 = require("zod");
+var import_zod35 = require("zod");
 var TEST_SYSTEM_IANA_TIMEZONE = "Asia/Dhaka";
-var TestUserRole = import_zod34.z.enum([
+var TestUserRole = import_zod35.z.enum([
   "FIELD_AGENT",
   "LOCAL_REGISTRAR",
   "LOCAL_SYSTEM_ADMIN",
@@ -6576,7 +6800,7 @@ function eventPayloadGenerator(rng) {
       eventId,
       actionType,
       annotation
-    }, input = {}) => (0, import_lodash3.merge)(
+    }, input = {}) => (0, import_lodash4.merge)(
       {
         id: getUUID(),
         eventId,
@@ -6635,13 +6859,13 @@ function eventPayloadGenerator(rng) {
       notify: (eventId, input = {}) => {
         let declaration = input.declaration;
         if (!declaration) {
-          const partialDeclaration = (0, import_lodash3.omitBy)(
+          const partialDeclaration = (0, import_lodash4.omitBy)(
             generateActionDeclarationInput(
               tennisClubMembershipEvent,
               ActionType.DECLARE,
               rng
             ),
-            import_lodash3.isString
+            import_lodash4.isString
           );
           declaration = partialDeclaration;
         }
@@ -6688,7 +6912,6 @@ function eventPayloadGenerator(rng) {
         type: ActionType.ARCHIVE,
         transactionId: input.transactionId ?? getUUID(),
         declaration: {},
-        // @TODO: Check whether generator is needed?
         annotation: {},
         duplicates: [],
         eventId,
@@ -6744,7 +6967,7 @@ function eventPayloadGenerator(rng) {
         request: (eventId, input = {}) => ({
           type: ActionType.REQUEST_CORRECTION,
           transactionId: input.transactionId ?? getUUID(),
-          declaration: input.declaration ?? (0, import_lodash3.omit)(
+          declaration: input.declaration ?? (0, import_lodash4.omit)(
             generateActionDeclarationInput(
               tennisClubMembershipEvent,
               ActionType.REQUEST_CORRECTION,
@@ -6835,7 +7058,11 @@ function generateActionDocument({
     case ActionType.NOTIFY:
       return { ...actionBase, type: action };
     case ActionType.PRINT_CERTIFICATE:
-      return { ...actionBase, type: action };
+      return {
+        ...actionBase,
+        type: action,
+        content: defaults.content
+      };
     case ActionType.REQUEST_CORRECTION:
       return { ...actionBase, type: action };
     case ActionType.APPROVE_CORRECTION:
@@ -6898,7 +7125,8 @@ function generateEventDraftDocument({
       declaration: {
         ...action.declaration,
         ...declaration
-      }
+      },
+      annotation: action.annotation
     },
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     eventId
@@ -7005,7 +7233,12 @@ var generateWorkqueues = (slug = "all-events") => defineWorkqueues([
       type: "and",
       clauses: [{ eventType: tennisClubMembershipEvent.id }]
     },
-    actions: [],
+    actions: [
+      {
+        type: "DEFAULT",
+        conditionals: []
+      }
+    ],
     icon: "Draft"
   }
 ]);
@@ -7021,9 +7254,7 @@ function isFieldValueWithoutTemplates(value) {
   if (isTemplateVariable(value)) {
     return false;
   }
-  if (typeof value === "object" && // @todo remove ts-ignore
-  //@ts-ignore
-  Object.values(value).some((val) => isTemplateVariable(val))) {
+  if (typeof value === "object" && value !== null && Object.values(value).some((val) => isTemplateVariable(val))) {
     return false;
   }
   return true;
@@ -7045,7 +7276,7 @@ function isFieldConfigDefaultValue(value) {
 }
 
 // ../commons/src/events/scopes.ts
-var import_lodash4 = require("lodash");
+var import_lodash5 = require("lodash");
 var CONFIG_GET_ALLOWED_SCOPES = [
   SCOPES.RECORD_DECLARE,
   SCOPES.RECORD_READ,
@@ -7133,13 +7364,13 @@ var WRITE_ACTION_SCOPES = [
   ...ACTION_ALLOWED_SCOPES[ActionType.PRINT_CERTIFICATE]
 ];
 function hasAnyOfScopes(a, b) {
-  return (0, import_lodash4.intersection)(a, b).length > 0;
+  return (0, import_lodash5.intersection)(a, b).length > 0;
 }
 
 // ../commons/src/events/serializers/user/deserializer.ts
-var import_zod35 = require("zod");
+var import_zod36 = require("zod");
 var UserWithPrimaryOffice = User.extend({
-  primaryOfficeId: import_zod35.z.string()
+  primaryOfficeId: import_zod36.z.string()
 });
 function userDeserializer(serializedUserField, user2) {
   if (typeof serializedUserField === "string") {
@@ -7235,14 +7466,6 @@ var AVAILABLE_ACTIONS_BY_EVENT_STATUS = {
     ActionType.REJECT_CORRECTION,
     ExclusiveActions.REVIEW_CORRECTION_REQUEST
   ],
-  [EventStatus.enum.CERTIFIED]: [
-    ActionType.READ,
-    ActionType.PRINT_CERTIFICATE,
-    ActionType.REQUEST_CORRECTION,
-    ActionType.APPROVE_CORRECTION,
-    ActionType.REJECT_CORRECTION,
-    ExclusiveActions.REVIEW_CORRECTION_REQUEST
-  ],
   [EventStatus.enum.ARCHIVED]: [
     ActionType.READ,
     ActionType.ASSIGN,
@@ -7250,9 +7473,12 @@ var AVAILABLE_ACTIONS_BY_EVENT_STATUS = {
   ]
 };
 var getAvailableActionsForEvent = (event2) => {
-  return event2.flags.includes(InherentFlags.REJECTED) ? [
-    ActionType.READ,
-    event2.status === EventStatus.Enum.VALIDATED ? ActionType.VALIDATE : ActionType.DECLARE,
-    ActionType.ARCHIVE
-  ] : AVAILABLE_ACTIONS_BY_EVENT_STATUS[event2.status];
+  if (event2.flags.includes(InherentFlags.REJECTED)) {
+    return [
+      ActionType.READ,
+      event2.status === EventStatus.Enum.VALIDATED ? ActionType.VALIDATE : ActionType.DECLARE,
+      ActionType.ARCHIVE
+    ];
+  }
+  return AVAILABLE_ACTIONS_BY_EVENT_STATUS[event2.status];
 };