@opencrvs/toolkit 1.9.6-rc.7b05346 → 1.9.6-rc.8a2de14

package/dist/events/index.js

@@ -361,6 +361,7 @@ __export(events_exports, {
   mergeDrafts: () => mergeDrafts,
   never: () => never,
   not: () => not,
+  now: () => now,
   omitHiddenAnnotationFields: () => omitHiddenAnnotationFields,
   omitHiddenFields: () => omitHiddenFields,
   omitHiddenPaginatedFields: () => omitHiddenPaginatedFields,
@@ -385,7 +386,7 @@ var TENNIS_CLUB_MEMBERSHIP = "tennis-club-membership";
 var BIRTH_EVENT = "birth";
 
 // ../commons/src/events/ActionConfig.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 
 // ../commons/src/events/TranslationConfig.ts
 var import_zod = require("zod");
@@ -508,7 +509,7 @@ function isMetaAction(actionType) {
 }
 
 // ../commons/src/events/FieldConfig.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 
 // ../commons/src/events/Conditional.ts
 var import_zod3 = require("zod");
@@ -1905,9 +1906,22 @@ var SearchScopeAccessLevels = {
   ALL: "all"
 };
 
+// ../commons/src/events/serializers/date/serializer.ts
+var import_zod15 = require("zod");
+var SerializedNowDateTime = import_zod15.z.object({
+  $$date: import_zod15.z.literal("now").optional(),
+  $$time: import_zod15.z.literal("now").optional()
+});
+function todayDateTimeValueSerializer() {
+  return {
+    $$date: "now",
+    $$time: "now"
+  };
+}
+
 // ../commons/src/events/FieldConfig.ts
-(0, import_zod_openapi6.extendZodWithOpenApi)(import_zod15.z);
-var FieldId = import_zod15.z.string().refine(
+(0, import_zod_openapi6.extendZodWithOpenApi)(import_zod16.z);
+var FieldId = import_zod16.z.string().refine(
   /*
    * Disallow underscores '_' in field ids.
    * Why? Theres two reasons:
@@ -1920,160 +1934,164 @@ var FieldId = import_zod15.z.string().refine(
     message: `id: '${val}' must not contain underscores '_'`
   })
 ).describe("Unique identifier for the field");
-var FieldReference = import_zod15.z.object({
+var FieldReference = import_zod16.z.object({
   $$field: FieldId,
-  $$subfield: import_zod15.z.array(import_zod15.z.string()).optional().describe(
+  $$subfield: import_zod16.z.array(import_zod16.z.string()).optional().describe(
     'If the FieldValue is an object, subfield can be used to refer to e.g. `["foo", "bar"]` in `{ foo: { bar: 3 } }`'
   )
 }).describe("Reference to a field by its ID");
-var ValidationConfig = import_zod15.z.object({
+var ValidationConfig = import_zod16.z.object({
   validator: Conditional,
   message: TranslationConfig
 });
-var requiredSchema = import_zod15.z.union([
-  import_zod15.z.boolean(),
-  import_zod15.z.object({
+var requiredSchema = import_zod16.z.union([
+  import_zod16.z.boolean(),
+  import_zod16.z.object({
     message: TranslationConfig.describe("Custom required validation message")
   })
 ]).default(false).optional();
-var BaseField = import_zod15.z.object({
+var BaseField = import_zod16.z.object({
   id: FieldId.describe("Unique identifier of the field."),
   label: TranslationConfig.describe("Human-readable label of the field."),
-  parent: FieldReference.or(import_zod15.z.array(FieldReference)).optional().describe(
+  parent: FieldReference.or(import_zod16.z.array(FieldReference)).optional().describe(
     "Reference to the parent field or fields. When a parent field changes, this field is reset."
   ),
   required: requiredSchema.describe(
     "Indicates whether the field is mandatory."
   ),
-  conditionals: import_zod15.z.array(FieldConditional).default([]).optional().describe(
+  conditionals: import_zod16.z.array(FieldConditional).default([]).optional().describe(
     "Conditions determining when the field is shown or enabled. By default, the field is always shown and enabled."
   ),
-  secured: import_zod15.z.boolean().default(false).optional().describe(
+  secured: import_zod16.z.boolean().default(false).optional().describe(
     "Indicates whether the field is secured. Secured fields are not indexed for search and are only visible when explicitly assigned."
   ),
   placeholder: TranslationConfig.optional(),
-  validation: import_zod15.z.array(ValidationConfig).default([]).optional().describe("Additional validation rules applied to the field."),
+  validation: import_zod16.z.array(ValidationConfig).default([]).optional().describe("Additional validation rules applied to the field."),
   helperText: TranslationConfig.optional(),
-  hideLabel: import_zod15.z.boolean().default(false).optional(),
-  uncorrectable: import_zod15.z.boolean().default(false).optional().describe(
+  hideLabel: import_zod16.z.boolean().default(false).optional(),
+  uncorrectable: import_zod16.z.boolean().default(false).optional().describe(
     "Indicates whether the field can be modified during record correction."
   ),
-  value: FieldReference.or(import_zod15.z.array(FieldReference)).optional().describe(
+  value: FieldReference.or(import_zod16.z.array(FieldReference)).optional().describe(
     "Reference to the source field or fields. When a value is defined, it is copied from the parent field when changed. If multiple references are provided, the first truthy value is used."
   ),
-  analytics: import_zod15.z.boolean().default(false).optional().describe(
+  analytics: import_zod16.z.boolean().default(false).optional().describe(
     "Indicates whether the field is included in analytics. When enabled, its value becomes available in the analytics dashboard."
   )
 }).describe("Common properties shared across all field types.");
 var Divider = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.DIVIDER)
+  type: import_zod16.z.literal(FieldType.DIVIDER)
 });
 var TextField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.TEXT),
-  defaultValue: import_zod15.z.union([NonEmptyTextValue, SerializedUserField]).optional(),
-  configuration: import_zod15.z.object({
-    maxLength: import_zod15.z.number().optional().describe("Maximum length of the text"),
-    type: import_zod15.z.enum(["text", "password"]).optional(),
+  type: import_zod16.z.literal(FieldType.TEXT),
+  defaultValue: import_zod16.z.union([NonEmptyTextValue, SerializedUserField]).optional(),
+  configuration: import_zod16.z.object({
+    maxLength: import_zod16.z.number().optional().describe("Maximum length of the text"),
+    type: import_zod16.z.enum(["text", "password"]).optional(),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).default({ type: "text" }).optional()
 }).describe("Text input");
 var NumberField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.NUMBER),
+  type: import_zod16.z.literal(FieldType.NUMBER),
   defaultValue: NumberFieldValue.optional(),
-  configuration: import_zod15.z.object({
-    min: import_zod15.z.number().optional().describe("Minimum value"),
-    max: import_zod15.z.number().optional().describe("Maximum value"),
+  configuration: import_zod16.z.object({
+    min: import_zod16.z.number().optional().describe("Minimum value"),
+    max: import_zod16.z.number().optional().describe("Maximum value"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).optional()
 }).describe("Number input");
 var TextAreaField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.TEXTAREA),
+  type: import_zod16.z.literal(FieldType.TEXTAREA),
   defaultValue: NonEmptyTextValue.optional(),
-  configuration: import_zod15.z.object({
-    maxLength: import_zod15.z.number().optional().describe("Maximum length of the text"),
-    rows: import_zod15.z.number().optional().describe("Number of visible text lines"),
-    cols: import_zod15.z.number().optional().describe("Number of visible columns"),
+  configuration: import_zod16.z.object({
+    maxLength: import_zod16.z.number().optional().describe("Maximum length of the text"),
+    rows: import_zod16.z.number().optional().describe("Number of visible text lines"),
+    cols: import_zod16.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_zod15.z.enum([
+var ImageMimeType = import_zod16.z.enum([
   "image/png",
   "image/jpg",
   "image/jpeg",
   "image/svg+xml"
 ]);
-var DocumentMimeType = import_zod15.z.enum([
+var DocumentMimeType = import_zod16.z.enum([
   "application/pdf",
   "application/msword",
   "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
   "application/vnd.oasis.opendocument.text"
 ]);
-var MimeType = import_zod15.z.enum([
+var MimeType = import_zod16.z.enum([
   ...ImageMimeType.options,
   ...DocumentMimeType.options
 ]);
 var DEFAULT_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
 var SignatureField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.SIGNATURE),
+  type: import_zod16.z.literal(FieldType.SIGNATURE),
   signaturePromptLabel: TranslationConfig.describe(
     "Title of the signature modal"
   ),
   defaultValue: SignatureFieldValue.optional(),
-  configuration: import_zod15.z.object({
-    maxFileSize: import_zod15.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+  configuration: import_zod16.z.object({
+    maxFileSize: import_zod16.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_zod15.z.literal(FieldType.EMAIL),
-  configuration: import_zod15.z.object({
-    maxLength: import_zod15.z.number().optional().describe("Maximum length of the text")
+  type: import_zod16.z.literal(FieldType.EMAIL),
+  configuration: import_zod16.z.object({
+    maxLength: import_zod16.z.number().optional().describe("Maximum length of the text")
   }).default({ maxLength: 10 }).optional(),
   defaultValue: NonEmptyTextValue.optional()
 });
 var DateField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.DATE),
-  defaultValue: DateValue.optional(),
-  configuration: import_zod15.z.object({
+  type: import_zod16.z.literal(FieldType.DATE),
+  defaultValue: SerializedNowDateTime.transform(() => ({
+    $$date: "now"
+  })).or(DateValue).optional().openapi({ effectType: "input", type: "object" }).describe("Default date value(yyyy-MM-dd)"),
+  configuration: import_zod16.z.object({
     notice: TranslationConfig.describe(
       "Text to display above the date input"
     ).optional()
   }).optional()
 }).describe("A single date input (yyyy-MM-dd)");
 var AgeField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.AGE),
+  type: import_zod16.z.literal(FieldType.AGE),
   defaultValue: NumberFieldValue.optional(),
-  configuration: import_zod15.z.object({
+  configuration: import_zod16.z.object({
     asOfDate: FieldReference,
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   })
 }).describe("An age input field which uses the current date as the asOfDate");
 var TimeField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.TIME),
-  defaultValue: TimeValue.optional(),
-  configuration: import_zod15.z.object({
-    use12HourFormat: import_zod15.z.boolean().optional().describe("Whether to use 12-hour format"),
+  type: import_zod16.z.literal(FieldType.TIME),
+  defaultValue: SerializedNowDateTime.transform(() => ({
+    $$time: "now"
+  })).or(TimeValue).optional().openapi({ effectType: "input", type: "object" }).describe("Default time value (HH-mm)"),
+  configuration: import_zod16.z.object({
+    use12HourFormat: import_zod16.z.boolean().optional().describe("Whether to use 12-hour format"),
     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_zod15.z.literal(FieldType.DATE_RANGE),
+  type: import_zod16.z.literal(FieldType.DATE_RANGE),
   defaultValue: DateRangeFieldValue.optional(),
-  configuration: import_zod15.z.object({
+  configuration: import_zod16.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_zod15.z.enum([
+var HtmlFontVariant = import_zod16.z.enum([
   "reg12",
   "reg14",
   "reg16",
@@ -2083,34 +2101,34 @@ var HtmlFontVariant = import_zod15.z.enum([
   "h2",
   "h1"
 ]);
-var ParagraphConfiguration = import_zod15.z.object({
-  styles: import_zod15.z.object({
+var ParagraphConfiguration = import_zod16.z.object({
+  styles: import_zod16.z.object({
     fontVariant: HtmlFontVariant.optional().describe(
       "Font variant to use for the paragraph text"
     ),
-    hint: import_zod15.z.boolean().optional().describe("When true, paragraph is styled as a hint with grey color")
+    hint: import_zod16.z.boolean().optional().describe("When true, paragraph is styled as a hint with grey color")
   }).optional()
 }).default({});
 var Paragraph = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.PARAGRAPH),
+  type: import_zod16.z.literal(FieldType.PARAGRAPH),
   defaultValue: NonEmptyTextValue.optional(),
   configuration: ParagraphConfiguration
 }).describe("A read-only HTML <p> paragraph");
 var PageHeader = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.PAGE_HEADER),
+  type: import_zod16.z.literal(FieldType.PAGE_HEADER),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("A read-only header component for form pages");
 var File = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.FILE),
+  type: import_zod16.z.literal(FieldType.FILE),
   defaultValue: FileFieldValue.optional(),
-  configuration: import_zod15.z.object({
-    maxFileSize: import_zod15.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+  configuration: import_zod16.z.object({
+    maxFileSize: import_zod16.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"),
-    maxImageSize: import_zod15.z.object({
-      targetSize: import_zod15.z.object({ width: import_zod15.z.number(), height: import_zod15.z.number() })
+    maxImageSize: import_zod16.z.object({
+      targetSize: import_zod16.z.object({ width: import_zod16.z.number(), height: import_zod16.z.number() })
     }).optional(),
-    style: import_zod15.z.object({
-      width: import_zod15.z.enum(["full", "auto"]).optional().describe(
+    style: import_zod16.z.object({
+      width: import_zod16.z.enum(["full", "auto"]).optional().describe(
         "Whether the file upload button should take the full width of the container or not"
       )
     }).optional(),
@@ -2119,46 +2137,46 @@ var File = BaseField.extend({
     maxFileSize: DEFAULT_MAX_FILE_SIZE_BYTES
   })
 }).describe("File upload");
-var SelectOption = import_zod15.z.object({
-  value: import_zod15.z.string().describe("The value of the option"),
-  label: import_zod15.z.union([import_zod15.z.string(), TranslationConfig]).describe("The label of the option")
+var SelectOption = import_zod16.z.object({
+  value: import_zod16.z.string().describe("The value of the option"),
+  label: import_zod16.z.union([import_zod16.z.string(), TranslationConfig]).describe("The label of the option")
 });
 var NumberWithUnitField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.NUMBER_WITH_UNIT),
+  type: import_zod16.z.literal(FieldType.NUMBER_WITH_UNIT),
   defaultValue: NumberWithUnitFieldValue.optional(),
-  options: import_zod15.z.array(SelectOption).describe("A list of options for the unit select"),
-  configuration: import_zod15.z.object({
-    min: import_zod15.z.number().optional().describe("Minimum value of the number field"),
-    max: import_zod15.z.number().optional().describe("Maximum value of the number field"),
+  options: import_zod16.z.array(SelectOption).describe("A list of options for the unit select"),
+  configuration: import_zod16.z.object({
+    min: import_zod16.z.number().optional().describe("Minimum value of the number field"),
+    max: import_zod16.z.number().optional().describe("Maximum value of the number field"),
     numberFieldPlaceholder: TranslationConfig.optional().describe(
       "Placeholder for the number field"
     )
   }).optional()
 }).describe("Number with unit input");
 var RadioGroup = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.RADIO_GROUP),
+  type: import_zod16.z.literal(FieldType.RADIO_GROUP),
   defaultValue: TextValue.optional(),
-  options: import_zod15.z.array(SelectOption).describe("A list of options"),
-  configuration: import_zod15.z.object({
-    styles: import_zod15.z.object({
-      size: import_zod15.z.enum(["NORMAL", "LARGE"]).optional()
+  options: import_zod16.z.array(SelectOption).describe("A list of options"),
+  configuration: import_zod16.z.object({
+    styles: import_zod16.z.object({
+      size: import_zod16.z.enum(["NORMAL", "LARGE"]).optional()
     }).optional()
   }).optional()
 }).describe("Grouped radio options");
 var BulletList = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.BULLET_LIST),
+  type: import_zod16.z.literal(FieldType.BULLET_LIST),
   defaultValue: TextValue.optional(),
-  items: import_zod15.z.array(TranslationConfig).describe("A list of items"),
-  configuration: import_zod15.z.object({
-    styles: import_zod15.z.object({
+  items: import_zod16.z.array(TranslationConfig).describe("A list of items"),
+  configuration: import_zod16.z.object({
+    styles: import_zod16.z.object({
       fontVariant: HtmlFontVariant.optional()
     }).optional()
   }).default({})
 }).describe("A list of bullet points");
 var Select = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.SELECT),
+  type: import_zod16.z.literal(FieldType.SELECT),
   defaultValue: TextValue.optional(),
-  options: import_zod15.z.array(SelectOption).describe("A list of options"),
+  options: import_zod16.z.array(SelectOption).describe("A list of options"),
   noOptionsMessage: TranslationConfig.optional().describe(
     `
     A translation configuration object used to display a message when no options are available.
@@ -2170,34 +2188,34 @@ var Select = BaseField.extend({
   `
   )
 }).describe("Select input");
-var SelectDateRangeOption = import_zod15.z.object({
+var SelectDateRangeOption = import_zod16.z.object({
   value: SelectDateRangeValue.describe("The value of the option"),
   label: TranslationConfig.describe("The label of the option")
 });
 var SelectDateRangeField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.SELECT_DATE_RANGE),
+  type: import_zod16.z.literal(FieldType.SELECT_DATE_RANGE),
   defaultValue: SelectDateRangeValue.optional(),
-  options: import_zod15.z.array(SelectDateRangeOption).describe("A list of options")
+  options: import_zod16.z.array(SelectDateRangeOption).describe("A list of options")
 }).describe("Select input with date range options");
-var NameConfig = import_zod15.z.object({
-  firstname: import_zod15.z.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional(),
-  middlename: import_zod15.z.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional(),
-  surname: import_zod15.z.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional()
+var NameConfig = import_zod16.z.object({
+  firstname: import_zod16.z.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional(),
+  middlename: import_zod16.z.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional(),
+  surname: import_zod16.z.object({ required: requiredSchema, label: TranslationConfig.optional() }).optional()
 });
 var NameField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.NAME),
-  defaultValue: import_zod15.z.object({
+  type: import_zod16.z.literal(FieldType.NAME),
+  defaultValue: import_zod16.z.object({
     firstname: SerializedUserField.or(NonEmptyTextValue).optional(),
     middlename: SerializedUserField.or(NonEmptyTextValue).optional(),
     surname: SerializedUserField.or(NonEmptyTextValue).optional()
   }).optional(),
-  configuration: import_zod15.z.object({
+  configuration: import_zod16.z.object({
     name: NameConfig.default({
       firstname: { required: true },
       surname: { required: true }
     }).optional(),
-    order: import_zod15.z.array(import_zod15.z.enum(["firstname", "middlename", "surname"])).optional(),
-    maxLength: import_zod15.z.number().optional().describe("Maximum length of the text"),
+    order: import_zod16.z.array(import_zod16.z.enum(["firstname", "middlename", "surname"])).optional(),
+    maxLength: import_zod16.z.number().optional().describe("Maximum length of the text"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).default({
@@ -2209,51 +2227,51 @@ var NameField = BaseField.extend({
 }).describe("Name input field");
 var PhoneField = BaseField.extend({
   defaultValue: NonEmptyTextValue.optional(),
-  type: import_zod15.z.literal(FieldType.PHONE)
+  type: import_zod16.z.literal(FieldType.PHONE)
 }).describe("Phone input field");
 var IdField = BaseField.extend({
   defaultValue: NonEmptyTextValue.optional(),
-  type: import_zod15.z.literal(FieldType.ID)
+  type: import_zod16.z.literal(FieldType.ID)
 }).describe("ID input field");
 var Checkbox = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.CHECKBOX),
+  type: import_zod16.z.literal(FieldType.CHECKBOX),
   defaultValue: CheckboxFieldValue.default(false)
 }).describe("Boolean checkbox field");
 var Country = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.COUNTRY),
+  type: import_zod16.z.literal(FieldType.COUNTRY),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("Country select field");
-var AdministrativeAreas = import_zod15.z.enum([
+var AdministrativeAreas = import_zod16.z.enum([
   "ADMIN_STRUCTURE",
   "HEALTH_FACILITY",
   "CRVS_OFFICE"
 ]);
-var AdministrativeAreaConfiguration = import_zod15.z.object({
-  partOf: import_zod15.z.object({
-    $declaration: import_zod15.z.string()
+var AdministrativeAreaConfiguration = import_zod16.z.object({
+  partOf: import_zod16.z.object({
+    $declaration: import_zod16.z.string()
   }).optional().describe("Parent location"),
   type: AdministrativeAreas
 }).describe("Administrative area options");
 var AdministrativeArea = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.ADMINISTRATIVE_AREA),
+  type: import_zod16.z.literal(FieldType.ADMINISTRATIVE_AREA),
   defaultValue: NonEmptyTextValue.optional(),
   configuration: AdministrativeAreaConfiguration
 }).describe("Administrative area input field e.g. facility, office");
 var LocationInput = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.LOCATION),
+  type: import_zod16.z.literal(FieldType.LOCATION),
   defaultValue: NonEmptyTextValue.optional(),
-  configuration: import_zod15.z.object({
-    searchableResource: import_zod15.z.array(import_zod15.z.enum(["locations", "facilities", "offices"]))
+  configuration: import_zod16.z.object({
+    searchableResource: import_zod16.z.array(import_zod16.z.enum(["locations", "facilities", "offices"]))
   })
 }).describe("Input field for a location");
 var FileUploadWithOptions = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.FILE_WITH_OPTIONS),
-  options: import_zod15.z.array(SelectOption).describe("A list of options"),
+  type: import_zod16.z.literal(FieldType.FILE_WITH_OPTIONS),
+  options: import_zod16.z.array(SelectOption).describe("A list of options"),
   defaultValue: FileFieldWithOptionValue.optional(),
-  configuration: import_zod15.z.object({
-    maxFileSize: import_zod15.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
-    maxImageSize: import_zod15.z.object({
-      targetSize: import_zod15.z.object({ width: import_zod15.z.number(), height: import_zod15.z.number() })
+  configuration: import_zod16.z.object({
+    maxFileSize: import_zod16.z.number().describe("Maximum file size in bytes").default(DEFAULT_MAX_FILE_SIZE_BYTES),
+    maxImageSize: import_zod16.z.object({
+      targetSize: import_zod16.z.object({ width: import_zod16.z.number(), height: import_zod16.z.number() })
     }).optional(),
     acceptedFileTypes: MimeType.array().optional().describe("List of allowed file formats for the signature")
   }).default({
@@ -2261,93 +2279,93 @@ var FileUploadWithOptions = BaseField.extend({
   })
 });
 var Facility = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.FACILITY),
+  type: import_zod16.z.literal(FieldType.FACILITY),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("Input field for a facility");
 var Office = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.OFFICE),
+  type: import_zod16.z.literal(FieldType.OFFICE),
   defaultValue: NonEmptyTextValue.optional()
 }).describe("Input field for an office");
 var DefaultAddressFieldValue = DomesticAddressFieldValue.extend({
-  administrativeArea: import_zod15.z.union([UUID, SerializedUserField]).optional()
+  administrativeArea: import_zod16.z.union([UUID, SerializedUserField]).optional()
 });
 var Address = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.ADDRESS),
-  configuration: import_zod15.z.object({
-    lineSeparator: import_zod15.z.string().optional(),
-    fields: import_zod15.z.array(import_zod15.z.enum(["country", "administrativeArea"])).optional(),
-    administrativeLevels: import_zod15.z.array(import_zod15.z.string()).optional(),
-    streetAddressForm: import_zod15.z.array(
-      import_zod15.z.object({
-        id: import_zod15.z.string(),
+  type: import_zod16.z.literal(FieldType.ADDRESS),
+  configuration: import_zod16.z.object({
+    lineSeparator: import_zod16.z.string().optional(),
+    fields: import_zod16.z.array(import_zod16.z.enum(["country", "administrativeArea"])).optional(),
+    administrativeLevels: import_zod16.z.array(import_zod16.z.string()).optional(),
+    streetAddressForm: import_zod16.z.array(
+      import_zod16.z.object({
+        id: import_zod16.z.string(),
         required: requiredSchema,
         label: TranslationConfig,
-        type: import_zod15.z.literal(FieldType.TEXT),
-        conditionals: import_zod15.z.array(FieldConditional).default([]).optional(),
+        type: import_zod16.z.literal(FieldType.TEXT),
+        conditionals: import_zod16.z.array(FieldConditional).default([]).optional(),
         parent: FieldReference.optional()
       })
     ).optional()
   }).optional(),
   defaultValue: DefaultAddressFieldValue.optional()
 }).describe("Address input field \u2013 a combination of location and text fields");
-var StaticDataEntry = import_zod15.z.object({
-  id: import_zod15.z.string().describe("ID for the data entry."),
+var StaticDataEntry = import_zod16.z.object({
+  id: import_zod16.z.string().describe("ID for the data entry."),
   label: TranslationConfig,
-  value: TranslationConfig.or(import_zod15.z.string()).or(FieldReference)
+  value: TranslationConfig.or(import_zod16.z.string()).or(FieldReference)
 }).describe("Static data entry");
-var DataEntry = import_zod15.z.union([StaticDataEntry, import_zod15.z.object({ fieldId: import_zod15.z.string() })]).describe(
+var DataEntry = import_zod16.z.union([StaticDataEntry, import_zod16.z.object({ fieldId: import_zod16.z.string() })]).describe(
   "Data entry can be either a static data entry, or a reference to another field in the current form or the declaration."
 );
 var DataField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.DATA),
-  configuration: import_zod15.z.object({
+  type: import_zod16.z.literal(FieldType.DATA),
+  configuration: import_zod16.z.object({
     subtitle: TranslationConfig.optional(),
-    data: import_zod15.z.array(DataEntry)
+    data: import_zod16.z.array(DataEntry)
   })
 }).describe("Data field for displaying read-only data");
 var ButtonField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.BUTTON),
+  type: import_zod16.z.literal(FieldType.BUTTON),
   defaultValue: ButtonFieldValue.optional(),
-  configuration: import_zod15.z.object({
-    icon: import_zod15.z.string().optional().describe(
+  configuration: import_zod16.z.object({
+    icon: import_zod16.z.string().optional().describe(
       "Icon for the button. You can find icons from OpenCRVS UI-Kit."
     ),
-    loading: import_zod15.z.boolean().optional().describe("Whether the button is in a loading state and shows a spinner"),
+    loading: import_zod16.z.boolean().optional().describe("Whether the button is in a loading state and shows a spinner"),
     text: TranslationConfig.describe("Text to display on the button")
   })
 }).describe("Generic button without any built-in functionality");
 var AlphaPrintButton = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.ALPHA_PRINT_BUTTON),
-  configuration: import_zod15.z.object({
-    template: import_zod15.z.string().describe("Template ID from countryconfig templates to use for printing"),
+  type: import_zod16.z.literal(FieldType.ALPHA_PRINT_BUTTON),
+  configuration: import_zod16.z.object({
+    template: import_zod16.z.string().describe("Template ID from countryconfig templates to use for printing"),
     buttonLabel: TranslationConfig.optional().describe(
       "Label for the print button"
     )
   })
 }).describe("Print button field for printing certificates");
 var HttpField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.HTTP),
+  type: import_zod16.z.literal(FieldType.HTTP),
   defaultValue: HttpFieldValue.optional(),
-  configuration: import_zod15.z.object({
+  configuration: import_zod16.z.object({
     trigger: FieldReference,
-    url: import_zod15.z.string().describe("URL to send the HTTP request to"),
-    method: import_zod15.z.enum(["GET", "POST", "PUT", "DELETE"]),
-    headers: import_zod15.z.record(import_zod15.z.string()).optional(),
-    body: import_zod15.z.record(import_zod15.z.any()).optional(),
-    errorValue: import_zod15.z.any().optional().describe("Value to set if the request fails"),
-    params: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.union([import_zod15.z.string(), FieldReference])).optional(),
-    timeout: import_zod15.z.number().default(15e3).describe("Request timeout in milliseconds")
+    url: import_zod16.z.string().describe("URL to send the HTTP request to"),
+    method: import_zod16.z.enum(["GET", "POST", "PUT", "DELETE"]),
+    headers: import_zod16.z.record(import_zod16.z.string()).optional(),
+    body: import_zod16.z.record(import_zod16.z.any()).optional(),
+    errorValue: import_zod16.z.any().optional().describe("Value to set if the request fails"),
+    params: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.union([import_zod16.z.string(), FieldReference])).optional(),
+    timeout: import_zod16.z.number().default(15e3).describe("Request timeout in milliseconds")
   })
 }).describe("HTTP request function triggered by a button click or other event");
 var SearchField = HttpField.extend({
-  type: import_zod15.z.literal(FieldType.SEARCH),
+  type: import_zod16.z.literal(FieldType.SEARCH),
   configuration: SearchQuery.pick({
     query: true,
     limit: true,
     offset: true
   }).extend({
     validation: ValidationConfig,
-    indicators: import_zod15.z.object({
+    indicators: import_zod16.z.object({
       loading: TranslationConfig.optional().describe(
         "Text to display while the search is in progress"
       ),
@@ -2362,7 +2380,7 @@ var SearchField = HttpField.extend({
       ),
       confirmButton: TranslationConfig.optional(),
       clearButton: TranslationConfig.optional(),
-      clearModal: import_zod15.z.object({
+      clearModal: import_zod16.z.object({
         title: TranslationConfig.optional(),
         description: TranslationConfig.optional(),
         cancel: TranslationConfig.optional(),
@@ -2373,17 +2391,17 @@ var SearchField = HttpField.extend({
   })
 });
 var LinkButtonField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.LINK_BUTTON),
-  configuration: import_zod15.z.object({
-    url: import_zod15.z.string().describe("URL to open"),
+  type: import_zod16.z.literal(FieldType.LINK_BUTTON),
+  configuration: import_zod16.z.object({
+    url: import_zod16.z.string().describe("URL to open"),
     text: TranslationConfig.describe("Text to display on the button"),
-    icon: import_zod15.z.string().optional().describe("Icon for the button. You can find icons from OpenCRVS UI-Kit.")
+    icon: import_zod16.z.string().optional().describe("Icon for the button. You can find icons from OpenCRVS UI-Kit.")
   })
 }).describe("Button that opens a link");
 var VerificationStatus = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.VERIFICATION_STATUS),
+  type: import_zod16.z.literal(FieldType.VERIFICATION_STATUS),
   defaultValue: VerificationStatusValue.optional(),
-  configuration: import_zod15.z.object({
+  configuration: import_zod16.z.object({
     status: TranslationConfig.describe("Text to display on the status pill."),
     description: TranslationConfig.describe(
       "Explaining text on the banner in form."
@@ -2391,38 +2409,38 @@ var VerificationStatus = BaseField.extend({
   })
 });
 var QueryParamReaderField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.QUERY_PARAM_READER),
-  configuration: import_zod15.z.object({
-    pickParams: import_zod15.z.array(import_zod15.z.string()).describe("List of query parameters to read from the URL")
+  type: import_zod16.z.literal(FieldType.QUERY_PARAM_READER),
+  configuration: import_zod16.z.object({
+    pickParams: import_zod16.z.array(import_zod16.z.string()).describe("List of query parameters to read from the URL")
   })
 }).describe(
   "A field that maps URL query params into form values and clears them afterward"
 );
 var QrReaderField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.QR_READER),
+  type: import_zod16.z.literal(FieldType.QR_READER),
   defaultValue: QrReaderFieldValue.optional(),
-  configuration: import_zod15.z.object({
-    validator: import_zod15.z.custom(
+  configuration: import_zod16.z.object({
+    validator: import_zod16.z.custom(
       (val) => typeof val === "object" && val !== null
     )
   }).optional()
 });
 var IdReaderField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.ID_READER),
+  type: import_zod16.z.literal(FieldType.ID_READER),
   defaultValue: IdReaderFieldValue.optional(),
-  methods: import_zod15.z.array(
-    import_zod15.z.union([QrReaderField, LinkButtonField]).describe("Methods for reading an ID")
+  methods: import_zod16.z.array(
+    import_zod16.z.union([QrReaderField, LinkButtonField]).describe("Methods for reading an ID")
   )
 });
 var LoaderField = BaseField.extend({
-  type: import_zod15.z.literal(FieldType.LOADER),
-  configuration: import_zod15.z.object({
+  type: import_zod16.z.literal(FieldType.LOADER),
+  configuration: import_zod16.z.object({
     text: TranslationConfig.describe("Display text above the loading spinner")
   })
 }).describe(
   "A non-interactive field that indicates an in progress operation in form"
 );
-var FieldConfig = import_zod15.z.discriminatedUnion("type", [
+var FieldConfig = import_zod16.z.discriminatedUnion("type", [
   Address,
   TextField,
   NumberField,
@@ -2467,27 +2485,27 @@ var FieldConfig = import_zod15.z.discriminatedUnion("type", [
   description: "Form field configuration",
   ref: "FieldConfig"
 });
-var AnyFileField = import_zod15.z.discriminatedUnion("type", [
+var AnyFileField = import_zod16.z.discriminatedUnion("type", [
   SignatureField,
   File,
   FileUploadWithOptions
 ]);
 
 // ../commons/src/events/FormConfig.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 
 // ../commons/src/events/PageConfig.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 var import_zod_openapi7 = require("zod-openapi");
-(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod16.z);
-var PageTypes = import_zod16.z.enum(["FORM", "VERIFICATION"]);
-var PageConfigBase = import_zod16.z.object({
-  id: import_zod16.z.string().describe("Unique identifier for the page"),
+(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod17.z);
+var PageTypes = import_zod17.z.enum(["FORM", "VERIFICATION"]);
+var PageConfigBase = import_zod17.z.object({
+  id: import_zod17.z.string().describe("Unique identifier for the page"),
   title: TranslationConfig.describe("Header title of the page"),
-  requireCompletionToContinue: import_zod16.z.boolean().default(false).describe(
+  requireCompletionToContinue: import_zod17.z.boolean().default(false).describe(
     "If true, all required fields must be filled before continuing to the next page"
   ),
-  fields: import_zod16.z.array(FieldConfig).describe("Fields to be rendered on the page"),
+  fields: import_zod17.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."
   )
@@ -2496,13 +2514,13 @@ var PageConfigBase = import_zod16.z.object({
   ref: "FormPageConfig"
 });
 var FormPageConfig = PageConfigBase.extend({
-  type: import_zod16.z.literal(PageTypes.enum.FORM).default(PageTypes.enum.FORM)
+  type: import_zod17.z.literal(PageTypes.enum.FORM).default(PageTypes.enum.FORM)
 });
-var VerificationActionConfig = import_zod16.z.object({
-  verify: import_zod16.z.object({ label: TranslationConfig }),
-  cancel: import_zod16.z.object({
+var VerificationActionConfig = import_zod17.z.object({
+  verify: import_zod17.z.object({ label: TranslationConfig }),
+  cancel: import_zod17.z.object({
     label: TranslationConfig,
-    confirmation: import_zod16.z.object({
+    confirmation: import_zod17.z.object({
       title: TranslationConfig,
       body: TranslationConfig
     })
@@ -2512,33 +2530,33 @@ var VerificationActionConfig = import_zod16.z.object({
   ref: "VerificationActionConfig"
 });
 var VerificationPageConfig = FormPageConfig.extend({
-  type: import_zod16.z.literal(PageTypes.enum.VERIFICATION),
+  type: import_zod17.z.literal(PageTypes.enum.VERIFICATION),
   actions: VerificationActionConfig
 });
-var PageConfig = import_zod16.z.discriminatedUnion("type", [
+var PageConfig = import_zod17.z.discriminatedUnion("type", [
   FormPageConfig,
   VerificationPageConfig
 ]);
 
 // ../commons/src/events/FormConfig.ts
-var DeclarationFormConfig = import_zod17.z.object({
+var DeclarationFormConfig = import_zod18.z.object({
   label: TranslationConfig.describe("Human readable description of the form"),
-  pages: import_zod17.z.array(FormPageConfig)
+  pages: import_zod18.z.array(FormPageConfig)
 }).describe("Configuration of the declaration form.");
-var ActionFormConfig = import_zod17.z.object({
+var ActionFormConfig = import_zod18.z.object({
   label: TranslationConfig.describe("Human readable description of the form"),
-  pages: import_zod17.z.array(PageConfig)
+  pages: import_zod18.z.array(PageConfig)
 }).describe(
   "Configuration of the form used for system actions beyond declaration, supporting a wider range of page types."
 );
-var FormConfig = import_zod17.z.union([DeclarationFormConfig, ActionFormConfig]);
+var FormConfig = import_zod18.z.union([DeclarationFormConfig, ActionFormConfig]);
 
 // ../commons/src/events/DeduplicationConfig.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 var import_zod_openapi8 = require("zod-openapi");
-(0, import_zod_openapi8.extendZodWithOpenApi)(import_zod18.z);
-var FieldReference2 = import_zod18.z.string();
-var Matcher = import_zod18.z.object({
+(0, import_zod_openapi8.extendZodWithOpenApi)(import_zod19.z);
+var FieldReference2 = import_zod19.z.string();
+var Matcher = import_zod19.z.object({
   /**
    * Reference to the field used in matching.
    *
@@ -2546,68 +2564,68 @@ var Matcher = import_zod18.z.object({
    * be used as the origin date to calculate the distance from.
    */
   fieldId: FieldReference2,
-  options: import_zod18.z.object({
-    boost: import_zod18.z.number().optional()
+  options: import_zod19.z.object({
+    boost: import_zod19.z.number().optional()
   }).optional().default({
     boost: 1
   })
 });
 var FuzzyMatcher = Matcher.extend({
-  type: import_zod18.z.literal("fuzzy"),
-  options: import_zod18.z.object({
+  type: import_zod19.z.literal("fuzzy"),
+  options: import_zod19.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_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]).optional().default("AUTO:4,7"),
-    boost: import_zod18.z.number().optional().default(1)
+    fuzziness: import_zod19.z.union([import_zod19.z.string(), import_zod19.z.number()]).optional().default("AUTO:4,7"),
+    boost: import_zod19.z.number().optional().default(1)
   }).optional().default({
     fuzziness: "AUTO:4,7",
     boost: 1
   })
 });
 var StrictMatcher = Matcher.extend({
-  type: import_zod18.z.literal("strict"),
-  options: import_zod18.z.object({
-    boost: import_zod18.z.number().optional().default(1),
+  type: import_zod19.z.literal("strict"),
+  options: import_zod19.z.object({
+    boost: import_zod19.z.number().optional().default(1),
     /**
      * The constant value to be present in the field for both records
      */
-    value: import_zod18.z.string().optional()
+    value: import_zod19.z.string().optional()
   }).optional().default({
     boost: 1
   })
 });
 var DateRangeMatcher = Matcher.extend({
-  type: import_zod18.z.literal("dateRange"),
-  options: import_zod18.z.object({
+  type: import_zod19.z.literal("dateRange"),
+  options: import_zod19.z.object({
     /**
      * The distance pivot in days. Distance from the origin (the value of
      * fieldId) at which relevance scores receive half of the boost value
      */
-    pivot: import_zod18.z.number().optional(),
-    days: import_zod18.z.number(),
-    boost: import_zod18.z.number().optional().default(1)
+    pivot: import_zod19.z.number().optional(),
+    days: import_zod19.z.number(),
+    boost: import_zod19.z.number().optional().default(1)
   })
 });
-var Not = import_zod18.z.object({
-  type: import_zod18.z.literal("not"),
+var Not = import_zod19.z.object({
+  type: import_zod19.z.literal("not"),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clause: import_zod18.z.lazy(() => Clause)
+  clause: import_zod19.z.lazy(() => Clause)
 });
-var And = import_zod18.z.object({
-  type: import_zod18.z.literal("and"),
+var And = import_zod19.z.object({
+  type: import_zod19.z.literal("and"),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clauses: import_zod18.z.lazy(() => Clause.array())
+  clauses: import_zod19.z.lazy(() => Clause.array())
 });
-var Or = import_zod18.z.object({
-  type: import_zod18.z.literal("or"),
+var Or = import_zod19.z.object({
+  type: import_zod19.z.literal("or"),
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clauses: import_zod18.z.lazy(() => Clause.array())
+  clauses: import_zod19.z.lazy(() => Clause.array())
 });
-var Clause = import_zod18.z.lazy(
-  () => import_zod18.z.discriminatedUnion("type", [
+var Clause = import_zod19.z.lazy(
+  () => import_zod19.z.discriminatedUnion("type", [
     Not,
     And,
     Or,
@@ -2618,22 +2636,22 @@ var Clause = import_zod18.z.lazy(
 ).openapi({
   ref: "Clause"
 });
-var DeduplicationConfig = import_zod18.z.object({
-  id: import_zod18.z.string(),
+var DeduplicationConfig = import_zod19.z.object({
+  id: import_zod19.z.string(),
   label: TranslationConfig,
   query: Clause
 });
 
 // ../commons/src/events/ActionConfig.ts
 var import_zod_openapi9 = require("zod-openapi");
-(0, import_zod_openapi9.extendZodWithOpenApi)(import_zod19.z);
-var DeclarationReviewConfig = import_zod19.z.object({
+(0, import_zod_openapi9.extendZodWithOpenApi)(import_zod20.z);
+var DeclarationReviewConfig = import_zod20.z.object({
   title: TranslationConfig.describe("Title of the review page"),
-  fields: import_zod19.z.array(FieldConfig).describe("Fields displayed on the review page for annotations.")
+  fields: import_zod20.z.array(FieldConfig).describe("Fields displayed on the review page for annotations.")
 }).describe(
   "Configuration of the declaration review page for collecting event-related metadata."
 );
-var ActionConfigBase = import_zod19.z.object({
+var ActionConfigBase = import_zod20.z.object({
   label: TranslationConfig.describe("Human readable description of the action")
 });
 var DeclarationActionBase = ActionConfigBase.extend({
@@ -2641,66 +2659,66 @@ var DeclarationActionBase = ActionConfigBase.extend({
   deduplication: DeduplicationConfig.optional()
 });
 var ReadActionConfig = ActionConfigBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.READ),
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.READ),
     review: DeclarationReviewConfig.describe(
       "Configuration of the review page for read-only view."
     )
   })
 );
 var DeclareConfig = DeclarationActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.DECLARE)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.DECLARE)
   })
 );
 var ValidateConfig = DeclarationActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.VALIDATE)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.VALIDATE)
   })
 );
 var RegisterConfig = DeclarationActionBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REGISTER)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.REGISTER)
   })
 );
 var RejectDeclarationConfig = ActionConfigBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REJECT)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.REJECT)
   })
 );
 var ArchiveConfig = ActionConfigBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.ARCHIVE)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.ARCHIVE)
   })
 );
 var DeleteConfig = ActionConfigBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.DELETE)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.DELETE)
   })
 );
 var PrintCertificateActionConfig = ActionConfigBase.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),
     printForm: ActionFormConfig
   })
 );
 var RequestCorrectionConfig = ActionConfigBase.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),
     correctionForm: ActionFormConfig
   })
 );
 var RejectCorrectionConfig = ActionConfigBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REJECT_CORRECTION)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.REJECT_CORRECTION)
   })
 );
 var ApproveCorrectionConfig = ActionConfigBase.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.APPROVE_CORRECTION)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.APPROVE_CORRECTION)
   })
 );
-var ActionConfig = import_zod19.z.discriminatedUnion("type", [
+var ActionConfig = import_zod20.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.
@@ -2721,87 +2739,87 @@ var ActionConfig = import_zod19.z.discriminatedUnion("type", [
 ]).describe(
   "Configuration of an action available for an event. Data collected depends on the action type and is accessible through the annotation property in ActionDocument."
 ).openapi({ ref: "ActionConfig" });
-var DeclarationActionConfig = import_zod19.z.discriminatedUnion("type", [
+var DeclarationActionConfig = import_zod20.z.discriminatedUnion("type", [
   DeclareConfig,
   ValidateConfig,
   RegisterConfig
 ]);
 
 // ../commons/src/events/offline/CertificateConfig.ts
-var import_zod20 = require("zod");
-var FontFamily = import_zod20.z.object({
-  normal: import_zod20.z.string(),
-  bold: import_zod20.z.string(),
-  italics: import_zod20.z.string(),
-  bolditalics: import_zod20.z.string()
+var import_zod21 = require("zod");
+var FontFamily = import_zod21.z.object({
+  normal: import_zod21.z.string(),
+  bold: import_zod21.z.string(),
+  italics: import_zod21.z.string(),
+  bolditalics: import_zod21.z.string()
 });
-var CertificateConfig = import_zod20.z.object({
-  id: import_zod20.z.string(),
-  event: import_zod20.z.string(),
-  isV2Template: import_zod20.z.boolean().optional(),
+var CertificateConfig = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  event: import_zod21.z.string(),
+  isV2Template: import_zod21.z.boolean().optional(),
   label: TranslationConfig,
-  isDefault: import_zod20.z.boolean(),
-  fee: import_zod20.z.object({
-    onTime: import_zod20.z.number(),
-    late: import_zod20.z.number(),
-    delayed: import_zod20.z.number()
+  isDefault: import_zod21.z.boolean(),
+  fee: import_zod21.z.object({
+    onTime: import_zod21.z.number(),
+    late: import_zod21.z.number(),
+    delayed: import_zod21.z.number()
   }),
-  svgUrl: import_zod20.z.string(),
-  fonts: import_zod20.z.record(FontFamily).optional(),
-  conditionals: import_zod20.z.array(ShowConditional).optional()
+  svgUrl: import_zod21.z.string(),
+  fonts: import_zod21.z.record(FontFamily).optional(),
+  conditionals: import_zod21.z.array(ShowConditional).optional()
 });
 var CertificateTemplateConfig = CertificateConfig.extend({
-  hash: import_zod20.z.string().optional(),
-  svg: import_zod20.z.string()
+  hash: import_zod21.z.string().optional(),
+  svg: import_zod21.z.string()
 });
 
 // ../commons/src/events/offline/LanguageConfig.ts
-var import_zod21 = require("zod");
-var LanguageConfig = import_zod21.z.object({
-  lang: import_zod21.z.string(),
+var import_zod22 = require("zod");
+var LanguageConfig = import_zod22.z.object({
+  lang: import_zod22.z.string(),
   /**
    * client.csv contents
    */
-  messages: import_zod21.z.record(import_zod21.z.string())
+  messages: import_zod22.z.record(import_zod22.z.string())
 });
 
 // ../commons/src/events/EventConfig.ts
-var import_zod26 = require("zod");
+var import_zod27 = require("zod");
 
 // ../commons/src/events/SummaryConfig.ts
-var import_zod22 = require("zod");
-var BaseField2 = import_zod22.z.object({
+var import_zod23 = require("zod");
+var BaseField2 = import_zod23.z.object({
   emptyValueMessage: TranslationConfig.optional().describe(
     "Default message displayed when the field value is empty."
   ),
-  conditionals: import_zod22.z.array(ShowConditional).default([]).optional()
+  conditionals: import_zod23.z.array(ShowConditional).default([]).optional()
 });
 var ReferenceField = BaseField2.extend({
-  fieldId: import_zod22.z.string(),
+  fieldId: import_zod23.z.string(),
   label: TranslationConfig.optional().describe(
     "Overrides the default label from the referenced field when provided."
   )
 }).describe("Field referencing existing event data by field ID.");
 var Field = BaseField2.extend({
-  id: import_zod22.z.string().describe("Identifier of the summary field."),
+  id: import_zod23.z.string().describe("Identifier of the summary field."),
   value: TranslationConfig.describe(
     'Field value template supporting variables from configuration and EventMetadata (e.g. "{informant.phoneNo} {informant.email}").'
   ),
   label: TranslationConfig
 }).describe("Custom field defined for the summary view.");
-var SummaryConfig = import_zod22.z.object({
-  fields: import_zod22.z.array(import_zod22.z.union([Field, ReferenceField])).describe("Fields displayed in the event summary view.")
+var SummaryConfig = import_zod23.z.object({
+  fields: import_zod23.z.array(import_zod23.z.union([Field, ReferenceField])).describe("Fields displayed in the event summary view.")
 }).describe("Configuration of the event summary section.");
 
 // ../commons/src/events/AdvancedSearchConfig.ts
-var import_zod23 = require("zod");
-var MatchType = import_zod23.z.enum(["fuzzy", "exact", "range", "within"]);
-var BaseField3 = import_zod23.z.object({
-  config: import_zod23.z.object({
+var import_zod24 = require("zod");
+var MatchType = import_zod24.z.enum(["fuzzy", "exact", "range", "within"]);
+var BaseField3 = import_zod24.z.object({
+  config: import_zod24.z.object({
     type: MatchType.describe(
       "Determines the search type of field. How to match value."
     ),
-    searchFields: import_zod23.z.array(import_zod23.z.string()).optional().describe(
+    searchFields: import_zod24.z.array(import_zod24.z.string()).optional().describe(
       `
       Defines multiple form fields that should be searched when this field has a value.
       All specified fields will be combined using OR logic.
@@ -2811,7 +2829,7 @@ var BaseField3 = import_zod23.z.object({
       `
     )
   }),
-  type: import_zod23.z.nativeEnum(FieldType).optional().describe(
+  type: import_zod24.z.nativeEnum(FieldType).optional().describe(
     `
       Explicitly specify the field type for searchFields.
       This is required when searchFields is defined, to show the correct control in the UI.
@@ -2825,7 +2843,7 @@ var BaseField3 = import_zod23.z.object({
       This is required when searchFields is defined.            
       `
   ),
-  options: import_zod23.z.array(SelectOption).optional(),
+  options: import_zod24.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
@@ -2846,7 +2864,7 @@ var BaseField3 = import_zod23.z.object({
     in the country-config > event.advancedSearch configuration. For example: field("child.dob", { searchCriteriaLabelPrefix: TranslationConfig }).
     `
   ),
-  conditionals: import_zod23.z.array(FieldConditional).default([]).optional().describe(
+  conditionals: import_zod24.z.array(FieldConditional).default([]).optional().describe(
     `
        In advanced search, we sometimes need to override the default field visibility conditionals.
 
@@ -2860,20 +2878,20 @@ var BaseField3 = import_zod23.z.object({
        are always rendered in the advanced search form.
       `
   ),
-  validations: import_zod23.z.array(ValidationConfig).default([]).optional().describe(
+  validations: import_zod24.z.array(ValidationConfig).default([]).optional().describe(
     `Option for overriding the field validations specifically for advanced search form.`
   )
 });
-var SearchQueryParams = import_zod23.z.object({
-  eventType: import_zod23.z.string().optional().describe(
+var SearchQueryParams = import_zod24.z.object({
+  eventType: import_zod24.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_zod23.z.string(),
-  fieldType: import_zod23.z.literal("field")
+  fieldId: import_zod24.z.string(),
+  fieldType: import_zod24.z.literal("field")
 });
-var EventFieldIdInput = import_zod23.z.enum([
+var EventFieldIdInput = import_zod24.z.enum([
   "trackingId",
   "status",
   "legalStatuses.REGISTERED.acceptedAt",
@@ -2882,7 +2900,7 @@ var EventFieldIdInput = import_zod23.z.enum([
   "updatedAt"
 ]);
 var METADATA_FIELD_PREFIX = "event.";
-var EventFieldId = import_zod23.z.enum([
+var EventFieldId = import_zod24.z.enum([
   `${METADATA_FIELD_PREFIX}trackingId`,
   `${METADATA_FIELD_PREFIX}status`,
   `${METADATA_FIELD_PREFIX}legalStatuses.REGISTERED.acceptedAt`,
@@ -2892,29 +2910,29 @@ var EventFieldId = import_zod23.z.enum([
 ]);
 var EventFieldConfigSchema = BaseField3.extend({
   fieldId: EventFieldId,
-  fieldType: import_zod23.z.literal("event")
+  fieldType: import_zod24.z.literal("event")
 });
-var AdvancedSearchField = import_zod23.z.discriminatedUnion("fieldType", [FieldConfigSchema, EventFieldConfigSchema]).superRefine((data, ctx) => {
+var AdvancedSearchField = import_zod24.z.discriminatedUnion("fieldType", [FieldConfigSchema, EventFieldConfigSchema]).superRefine((data, ctx) => {
   if (data.config.searchFields && data.config.searchFields.length > 0) {
     if (!data.label) {
       ctx.addIssue({
-        code: import_zod23.z.ZodIssueCode.custom,
+        code: import_zod24.z.ZodIssueCode.custom,
         message: "label is required when config.searchFields is defined.",
         path: ["label"]
       });
     }
     if (!data.type) {
       ctx.addIssue({
-        code: import_zod23.z.ZodIssueCode.custom,
+        code: import_zod24.z.ZodIssueCode.custom,
         message: "type is required when config.searchFields is defined.",
         path: ["type"]
       });
     }
   }
 });
-var AdvancedSearchConfig = import_zod23.z.object({
+var AdvancedSearchConfig = import_zod24.z.object({
   title: TranslationConfig.describe("Advanced search tab title"),
-  fields: import_zod23.z.array(AdvancedSearchField).describe("Advanced search fields within the tab.")
+  fields: import_zod24.z.array(AdvancedSearchField).describe("Advanced search fields within the tab.")
 });
 
 // ../commons/src/events/utils.ts
@@ -2923,14 +2941,14 @@ var import_lodash = require("lodash");
 // ../commons/src/conditionals/validate.ts
 var import__ = __toESM(require("ajv/dist/2019"));
 var import_ajv_formats = __toESM(require("ajv-formats"));
-var import_zod25 = require("zod");
+var import_zod26 = require("zod");
 var import_date_fns = require("date-fns");
 
 // ../commons/src/events/DynamicFieldValue.ts
-var import_zod24 = require("zod");
+var import_zod25 = require("zod");
 function getDynamicNameValue(field3) {
   const nameConfiguration = field3.configuration?.name;
-  return import_zod24.z.object({
+  return import_zod25.z.object({
     firstname: nameConfiguration?.firstname?.required ? NonEmptyTextValue : TextValue,
     surname: nameConfiguration?.surname?.required ? NonEmptyTextValue : TextValue,
     middlename: nameConfiguration?.middlename?.required ? NonEmptyTextValue : TextValue.optional()
@@ -3230,9 +3248,9 @@ var ajv = new import__.default({
   strict: false
   // Allow minContains and other newer features
 });
-var DataContext = import_zod25.z.object({
-  rootData: import_zod25.z.object({
-    $leafAdminStructureLocationIds: import_zod25.z.array(import_zod25.z.object({ id: UUID }))
+var DataContext = import_zod26.z.object({
+  rootData: import_zod26.z.object({
+    $leafAdminStructureLocationIds: import_zod26.z.array(import_zod26.z.object({ id: UUID }))
   })
 });
 function resolveDataPath(rootData, dataPath, instancePath) {
@@ -3600,7 +3618,7 @@ function areCertificateConditionsMet(conditions, values) {
 }
 
 // ../commons/src/utils.ts
-var z26 = __toESM(require("zod"));
+var z27 = __toESM(require("zod"));
 function getOrThrow(x, message) {
   if (x === void 0 || x === null) {
     throw new Error(message);
@@ -3610,11 +3628,11 @@ function getOrThrow(x, message) {
 function joinValues(values, separator = " ") {
   return values.filter((value) => !!value).join(separator).trim();
 }
-var FullNameV1 = z26.array(
-  z26.object({
-    use: z26.string(),
-    family: z26.string(),
-    given: z26.array(z26.string())
+var FullNameV1 = z27.array(
+  z27.object({
+    use: z27.string(),
+    family: z27.string(),
+    given: z27.array(z27.string())
   })
 );
 function omitKeyDeep(obj, keyToRemove) {
@@ -3960,9 +3978,9 @@ function aggregateActionDeclarations(event2) {
 
 // ../commons/src/events/EventConfig.ts
 var import_zod_openapi10 = require("zod-openapi");
-(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod26.z);
-var EventConfig = import_zod26.z.object({
-  id: import_zod26.z.string().describe(
+(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod27.z);
+var EventConfig = import_zod27.z.object({
+  id: import_zod27.z.string().describe(
     'Machine-readable identifier of the event (e.g. "birth", "death").'
   ),
   dateOfEvent: FieldReference.optional().describe(
@@ -3980,13 +3998,13 @@ var EventConfig = import_zod26.z.object({
   label: TranslationConfig.describe(
     "Human-readable label for the event type."
   ),
-  actions: import_zod26.z.array(ActionConfig).describe(
+  actions: import_zod27.z.array(ActionConfig).describe(
     "Configuration of system-defined actions associated with the event."
   ),
   declaration: DeclarationFormConfig.describe(
     "Configuration of the form used to gather event data."
   ),
-  advancedSearch: import_zod26.z.array(AdvancedSearchConfig).optional().default([]).describe(
+  advancedSearch: import_zod27.z.array(AdvancedSearchConfig).optional().default([]).describe(
     "Configuration of fields available in the advanced search feature."
   )
 }).superRefine((event2, ctx) => {
@@ -4050,7 +4068,7 @@ var definePage = (page) => PageConfig.parse(page);
 var defineFormPage = (formPage) => FormPageConfig.parse(formPage);
 
 // ../commons/src/events/WorkqueueConfig.ts
-var import_zod30 = require("zod");
+var import_zod31 = require("zod");
 
 // ../commons/src/conditionals/conditionals.ts
 var objectHash = __toESM(require("object-hash"));
@@ -4126,6 +4144,7 @@ function wrapToPathOptional(condition, path) {
     };
   }, condition);
 }
+var now = Object.assign(todayDateTimeValueSerializer, {});
 var user = Object.assign(userSerializer, {
   hasScope: (scope) => defineConditional({
     type: "object",
@@ -4804,17 +4823,17 @@ var event = Object.assign(eventFn, {
 });
 
 // ../commons/src/events/WorkqueueColumnConfig.ts
-var import_zod27 = require("zod");
+var import_zod28 = require("zod");
 var WorkqueueColumnKeysArray = [
   ...EventMetadataKeysArray,
   "title",
   "outbox"
 ];
-var WorkqueueColumnKeys = import_zod27.z.enum(WorkqueueColumnKeysArray);
-var WorkqueueColumnValue = import_zod27.z.object({
+var WorkqueueColumnKeys = import_zod28.z.enum(WorkqueueColumnKeysArray);
+var WorkqueueColumnValue = import_zod28.z.object({
   $event: WorkqueueColumnKeys
 });
-var WorkqueueColumn = import_zod27.z.object({
+var WorkqueueColumn = import_zod28.z.object({
   label: TranslationConfig,
   value: WorkqueueColumnValue
 });
@@ -4825,57 +4844,57 @@ function defineWorkqueuesColumns(workqueueColumns) {
 }
 
 // ../commons/src/events/CountryConfigQueryInput.ts
-var import_zod28 = require("zod");
-var SerializableExact = import_zod28.z.object({
-  type: import_zod28.z.literal("exact"),
-  term: import_zod28.z.union([import_zod28.z.string(), SerializedUserField])
+var import_zod29 = require("zod");
+var SerializableExact = import_zod29.z.object({
+  type: import_zod29.z.literal("exact"),
+  term: import_zod29.z.union([import_zod29.z.string(), SerializedUserField])
 });
-var SerializableWithin = import_zod28.z.object({
-  type: import_zod28.z.literal("within"),
-  location: import_zod28.z.union([import_zod28.z.string(), SerializedUserField])
+var SerializableWithin = import_zod29.z.object({
+  type: import_zod29.z.literal("within"),
+  location: import_zod29.z.union([import_zod29.z.string(), SerializedUserField])
 });
-var SerializedQueryExpression = import_zod28.z.object({
-  eventType: import_zod28.z.string(),
-  status: import_zod28.z.optional(import_zod28.z.union([AnyOfStatus, ExactStatus])),
-  createdAt: import_zod28.z.optional(DateCondition),
-  updatedAt: import_zod28.z.optional(DateCondition),
-  "legalStatuses.REGISTERED.createdAt": import_zod28.z.optional(DateCondition),
-  "legalStatuses.REGISTERED.createdAtLocation": import_zod28.z.optional(
-    import_zod28.z.union([Within, Exact])
+var SerializedQueryExpression = import_zod29.z.object({
+  eventType: import_zod29.z.string(),
+  status: import_zod29.z.optional(import_zod29.z.union([AnyOfStatus, ExactStatus])),
+  createdAt: import_zod29.z.optional(DateCondition),
+  updatedAt: import_zod29.z.optional(DateCondition),
+  "legalStatuses.REGISTERED.createdAt": import_zod29.z.optional(DateCondition),
+  "legalStatuses.REGISTERED.createdAtLocation": import_zod29.z.optional(
+    import_zod29.z.union([Within, Exact])
   ),
-  "legalStatuses.REGISTERED.registrationNumber": import_zod28.z.optional(Exact),
-  createdAtLocation: import_zod28.z.optional(
-    import_zod28.z.union([SerializableWithin, SerializableExact])
+  "legalStatuses.REGISTERED.registrationNumber": import_zod29.z.optional(Exact),
+  createdAtLocation: import_zod29.z.optional(
+    import_zod29.z.union([SerializableWithin, SerializableExact])
   ),
-  updatedAtLocation: import_zod28.z.optional(
-    import_zod28.z.union([SerializableWithin, SerializableExact])
+  updatedAtLocation: import_zod29.z.optional(
+    import_zod29.z.union([SerializableWithin, SerializableExact])
   ),
-  assignedTo: import_zod28.z.optional(SerializableExact),
-  createdBy: import_zod28.z.optional(SerializableExact),
+  assignedTo: import_zod29.z.optional(SerializableExact),
+  createdBy: import_zod29.z.optional(SerializableExact),
   createdByUserType: ExactUserType,
-  updatedBy: import_zod28.z.optional(SerializableExact),
-  trackingId: import_zod28.z.optional(Exact),
-  flags: import_zod28.z.optional(ContainsFlags),
+  updatedBy: import_zod29.z.optional(SerializableExact),
+  trackingId: import_zod29.z.optional(Exact),
+  flags: import_zod29.z.optional(ContainsFlags),
   data: QueryInput
 }).partial();
-var Or2 = import_zod28.z.object({
-  type: import_zod28.z.literal("or"),
-  clauses: import_zod28.z.array(SerializedQueryExpression)
+var Or2 = import_zod29.z.object({
+  type: import_zod29.z.literal("or"),
+  clauses: import_zod29.z.array(SerializedQueryExpression)
 });
-var And2 = import_zod28.z.object({
-  type: import_zod28.z.literal("and"),
-  clauses: import_zod28.z.array(SerializedQueryExpression)
+var And2 = import_zod29.z.object({
+  type: import_zod29.z.literal("and"),
+  clauses: import_zod29.z.array(SerializedQueryExpression)
 });
-var CountryConfigQueryType = import_zod28.z.discriminatedUnion("type", [And2, Or2]);
-var CountryConfigQueryInputType = import_zod28.z.union([
+var CountryConfigQueryType = import_zod29.z.discriminatedUnion("type", [And2, Or2]);
+var CountryConfigQueryInputType = import_zod29.z.union([
   SerializedQueryExpression,
   And2,
   Or2
 ]);
 
 // ../commons/src/icons.ts
-var import_zod29 = require("zod");
-var AvailableIcons = import_zod29.z.enum([
+var import_zod30 = require("zod");
+var AvailableIcons = import_zod30.z.enum([
   "Archived",
   "Assigned",
   "Certified",
@@ -4996,23 +5015,23 @@ var mandatoryColumns = defineWorkqueuesColumns([
     value: event.field("updatedAt")
   }
 ]);
-var WorkqueueActionsWithDefault = import_zod30.z.enum([
+var WorkqueueActionsWithDefault = import_zod31.z.enum([
   ...workqueueActions.options,
   "DEFAULT"
 ]);
-var WorkqueueConfig = import_zod30.z.object({
-  slug: import_zod30.z.string().describe("Determines the url of the workqueue."),
+var WorkqueueConfig = import_zod31.z.object({
+  slug: import_zod31.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_zod30.z.array(
-    import_zod30.z.object({
+  actions: import_zod31.z.array(
+    import_zod31.z.object({
       type: WorkqueueActionsWithDefault,
-      conditionals: import_zod30.z.array(Conditional).optional()
+      conditionals: import_zod31.z.array(Conditional).optional()
     })
   ),
-  columns: import_zod30.z.array(WorkqueueColumn).default(mandatoryColumns),
+  columns: import_zod31.z.array(WorkqueueColumn).default(mandatoryColumns),
   icon: AvailableIcons,
   emptyMessage: TranslationConfig.optional()
 }).describe("Configuration for workqueue.");
@@ -5020,19 +5039,19 @@ var WorkqueueConfigWithoutQuery = WorkqueueConfig.omit({
   query: true,
   columns: true
 });
-var WorkqueueConfigInput = import_zod30.z.object({
-  slug: import_zod30.z.string().describe("Determines the url of the workqueue."),
+var WorkqueueConfigInput = import_zod31.z.object({
+  slug: import_zod31.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_zod30.z.array(
-    import_zod30.z.object({
+  actions: import_zod31.z.array(
+    import_zod31.z.object({
       type: WorkqueueActionsWithDefault,
-      conditionals: import_zod30.z.array(Conditional).optional()
+      conditionals: import_zod31.z.array(Conditional).optional()
     })
   ),
-  columns: import_zod30.z.array(WorkqueueColumn).default(mandatoryColumns),
+  columns: import_zod31.z.array(WorkqueueColumn).default(mandatoryColumns),
   icon: AvailableIcons,
   emptyMessage: TranslationConfig.optional()
 });
@@ -5044,10 +5063,10 @@ function defineWorkqueue(workqueueInput) {
 function defineWorkqueues(workqueues) {
   return workqueues.map((workqueue) => defineWorkqueue(workqueue));
 }
-var WorkqueueCountInput = import_zod30.z.array(
-  import_zod30.z.object({ slug: import_zod30.z.string(), query: QueryType })
+var WorkqueueCountInput = import_zod31.z.array(
+  import_zod31.z.object({ slug: import_zod31.z.string(), query: QueryType })
 );
-var WorkqueueCountOutput = import_zod30.z.record(import_zod30.z.string(), import_zod30.z.number());
+var WorkqueueCountOutput = import_zod31.z.record(import_zod31.z.string(), import_zod31.z.number());
 
 // ../commons/src/events/workqueueDefaultColumns.ts
 var defaultWorkqueueColumns = [
@@ -5070,45 +5089,45 @@ var defaultWorkqueueColumns = [
 ];
 
 // ../commons/src/events/Draft.ts
-var import_zod32 = require("zod");
+var import_zod33 = require("zod");
 
 // ../commons/src/events/ActionInput.ts
-var import_zod31 = require("zod");
+var import_zod32 = require("zod");
 var import_zod_openapi11 = require("zod-openapi");
-(0, import_zod_openapi11.extendZodWithOpenApi)(import_zod31.z);
-var BaseActionInput = import_zod31.z.object({
+(0, import_zod_openapi11.extendZodWithOpenApi)(import_zod32.z);
+var BaseActionInput = import_zod32.z.object({
   eventId: UUID,
-  transactionId: import_zod31.z.string(),
+  transactionId: import_zod32.z.string(),
   declaration: ActionUpdate.default({}),
   annotation: ActionUpdate.optional(),
   originalActionId: UUID.optional(),
   // should not be part of base action.
-  keepAssignment: import_zod31.z.boolean().optional(),
+  keepAssignment: import_zod32.z.boolean().optional(),
   // For normal users, the createdAtLocation is resolved on the backend from the user's primaryOfficeId.
   createdAtLocation: CreatedAtLocation.describe(
     "A valid office location ID. This is required for system users performing actions. The provided location must be a leaf-location, i.e. it must not have any children locations."
   )
 });
 var CreateActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.CREATE).default(ActionType.CREATE),
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.CREATE).default(ActionType.CREATE),
     createdAtLocation: CreatedAtLocation
   })
 );
 var RegisterActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
-    registrationNumber: import_zod31.z.string().optional()
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
+    registrationNumber: import_zod32.z.string().optional()
   })
 ).strict();
 var ValidateActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE)
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE)
   })
 );
 var NotifyActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
   })
 ).openapi({
   default: {
@@ -5120,86 +5139,86 @@ var NotifyActionInput = BaseActionInput.merge(
   }
 });
 var DeclareActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
   })
 );
 var PrintCertificateActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE),
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE),
     content: PrintContent.optional()
   })
 );
 var RejectDeclarationActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.REJECT).default(ActionType.REJECT),
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.REJECT).default(ActionType.REJECT),
     content: ReasonContent
   })
 );
 var DuplicateDetectedActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.DUPLICATE_DETECTED).default(ActionType.DUPLICATE_DETECTED),
-    content: import_zod31.z.object({
-      duplicates: import_zod31.z.array(PotentialDuplicate)
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.DUPLICATE_DETECTED).default(ActionType.DUPLICATE_DETECTED),
+    content: import_zod32.z.object({
+      duplicates: import_zod32.z.array(PotentialDuplicate)
     })
   })
 );
 var MarkAsDuplicateActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.MARK_AS_DUPLICATE).default(ActionType.MARK_AS_DUPLICATE),
-    content: import_zod31.z.object({
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.MARK_AS_DUPLICATE).default(ActionType.MARK_AS_DUPLICATE),
+    content: import_zod32.z.object({
       duplicateOf: UUID
     }).optional()
   })
 );
 var MarkNotDuplicateActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.MARK_AS_NOT_DUPLICATE).default(ActionType.MARK_AS_NOT_DUPLICATE)
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.MARK_AS_NOT_DUPLICATE).default(ActionType.MARK_AS_NOT_DUPLICATE)
   })
 );
 var ArchiveActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE),
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE),
     content: ReasonContent
   })
 );
 var AssignActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod31.z.string()
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.ASSIGN),
+    assignedTo: import_zod32.z.string()
   })
 );
 var UnassignActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
-    assignedTo: import_zod31.z.literal(null).default(null)
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
+    assignedTo: import_zod32.z.literal(null).default(null)
   })
 );
 var RequestCorrectionActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
   })
 );
 var RejectCorrectionActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    requestId: import_zod31.z.string(),
-    type: import_zod31.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION),
+  import_zod32.z.object({
+    requestId: import_zod32.z.string(),
+    type: import_zod32.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION),
     content: ReasonContent
   })
 );
 var ApproveCorrectionActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    requestId: import_zod31.z.string(),
-    type: import_zod31.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
+  import_zod32.z.object({
+    requestId: import_zod32.z.string(),
+    type: import_zod32.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
   })
 );
 var ReadActionInput = BaseActionInput.merge(
-  import_zod31.z.object({
-    type: import_zod31.z.literal(ActionType.READ).default(ActionType.READ)
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.READ).default(ActionType.READ)
   })
 );
-var DeleteActionInput = import_zod31.z.object({ eventId: UUID });
-var ActionInput = import_zod31.z.discriminatedUnion("type", [
+var DeleteActionInput = import_zod32.z.object({ eventId: UUID });
+var ActionInput = import_zod32.z.discriminatedUnion("type", [
   CreateActionInput.openapi({ ref: "CreateActionInput" }),
   ValidateActionInput.openapi({ ref: "ValidateActionInput" }),
   RegisterActionInput.openapi({ ref: "RegisterActionInput" }),
@@ -5234,11 +5253,11 @@ var ActionInput = import_zod31.z.discriminatedUnion("type", [
 });
 
 // ../commons/src/events/Draft.ts
-var Draft = import_zod32.z.object({
+var Draft = import_zod33.z.object({
   id: UUID,
   eventId: UUID,
-  transactionId: import_zod32.z.string(),
-  createdAt: import_zod32.z.string().datetime(),
+  transactionId: import_zod33.z.string(),
+  createdAt: import_zod33.z.string().datetime(),
   action: ActionBase.extend({
     type: ActionTypes.exclude([ActionTypes.Enum.DELETE])
   }).omit({ id: true, createdAtLocation: true })
@@ -5247,7 +5266,7 @@ var Draft = import_zod32.z.object({
 );
 var DraftInput = BaseActionInput.extend({
   type: ActionTypes.exclude([ActionTypes.Enum.DELETE]),
-  status: import_zod32.z.enum([
+  status: import_zod33.z.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
@@ -5255,26 +5274,26 @@ var DraftInput = BaseActionInput.extend({
 });
 
 // ../commons/src/events/EventInput.ts
-var import_zod33 = require("zod");
+var import_zod34 = require("zod");
 var import_uuid10 = require("uuid");
-var EventInput = import_zod33.z.object({
-  transactionId: import_zod33.z.string(),
-  type: import_zod33.z.string()
+var EventInput = import_zod34.z.object({
+  transactionId: import_zod34.z.string(),
+  type: import_zod34.z.string()
 }).openapi({ default: { transactionId: (0, import_uuid10.v4)(), type: "birth" } });
 
 // ../commons/src/events/EventDocument.ts
-var import_zod34 = require("zod");
+var import_zod35 = require("zod");
 var import_zod_openapi12 = require("zod-openapi");
-(0, import_zod_openapi12.extendZodWithOpenApi)(import_zod34.z);
-var EventDocument = import_zod34.z.object({
+(0, import_zod_openapi12.extendZodWithOpenApi)(import_zod35.z);
+var EventDocument = import_zod35.z.object({
   id: UUID.describe("Unique identifier of the event."),
-  type: import_zod34.z.string().describe("Type of the event (e.g. birth, death, marriage)."),
-  createdAt: import_zod34.z.string().datetime().describe("Timestamp indicating when the event was created."),
-  updatedAt: import_zod34.z.string().datetime().describe(
+  type: import_zod35.z.string().describe("Type of the event (e.g. birth, death, marriage)."),
+  createdAt: import_zod35.z.string().datetime().describe("Timestamp indicating when the event was created."),
+  updatedAt: import_zod35.z.string().datetime().describe(
     "Timestamp of the last update, excluding changes from actions."
   ),
-  actions: import_zod34.z.array(Action).describe("Ordered list of actions associated with the event."),
-  trackingId: import_zod34.z.string().describe(
+  actions: import_zod35.z.array(Action).describe("Ordered list of actions associated with the event."),
+  trackingId: import_zod35.z.string().describe(
     "System-generated tracking identifier used to look up the event."
   )
 }).openapi({ ref: "EventDocument" });
@@ -8127,9 +8146,9 @@ var digitalIdentityEvent = defineConfig({
 });
 
 // ../commons/src/events/test.utils.ts
-var import_zod35 = require("zod");
+var import_zod36 = require("zod");
 var TEST_SYSTEM_IANA_TIMEZONE = "Asia/Dhaka";
-var TestUserRole = import_zod35.z.enum([
+var TestUserRole = import_zod36.z.enum([
   "FIELD_AGENT",
   "LOCAL_REGISTRAR",
   "LOCAL_SYSTEM_ADMIN",
@@ -8888,7 +8907,8 @@ function isFieldValueWithoutTemplates(value) {
   if (isTemplateVariable(value)) {
     return false;
   }
-  if (typeof value === "object" && value !== null && Object.values(value).some((val) => isTemplateVariable(val))) {
+  if (typeof value === "object" && value !== null && // template variable can exist in both keys and values of an object
+  (Object.values(value).some((val) => isTemplateVariable(val)) || Object.keys(value).some((val) => isTemplateVariable(val)))) {
     return false;
   }
   return true;
@@ -9174,16 +9194,16 @@ function getFilePathsFromEvent(event2) {
 }
 
 // ../commons/src/events/locations.ts
-var import_zod36 = require("zod");
-var LocationType = import_zod36.z.enum([
+var import_zod37 = require("zod");
+var LocationType = import_zod37.z.enum([
   "ADMIN_STRUCTURE",
   "CRVS_OFFICE",
   "HEALTH_FACILITY"
 ]);
-var Location = import_zod36.z.object({
+var Location = import_zod37.z.object({
   id: UUID,
-  name: import_zod36.z.string(),
+  name: import_zod37.z.string(),
   parentId: UUID.nullable(),
-  validUntil: import_zod36.z.string().datetime().nullable(),
+  validUntil: import_zod37.z.string().datetime().nullable(),
   locationType: LocationType.nullable()
 });