@opencrvs/toolkit 1.8.0-rc.f5b8a8a → 1.8.0-rc.f7e8fb5

package/dist/events/index.js

@@ -36,12 +36,14 @@ __export(events_exports, {
   ActionConfigBase: () => ActionConfigBase,
   ActionDocument: () => ActionDocument,
   ActionInput: () => ActionInput,
-  ActionMetadata: () => ActionMetadata,
   ActionType: () => ActionType,
+  ActionUpdate: () => ActionUpdate,
+  AddressFieldUpdateValue: () => AddressFieldUpdateValue,
   AddressFieldValue: () => AddressFieldValue,
+  AdministrativeAreas: () => AdministrativeAreas,
   AdvancedSearchConfig: () => AdvancedSearchConfig,
   ApproveCorrectionActionInput: () => ApproveCorrectionActionInput,
-  ArchivedActionInput: () => ArchivedActionInput,
+  ArchiveActionInput: () => ArchiveActionInput,
   BaseActionInput: () => BaseActionInput,
   CertificateConfig: () => CertificateConfig,
   CertificateTemplateConfig: () => CertificateTemplateConfig,
@@ -67,12 +69,14 @@ __export(events_exports, {
   EventStatuses: () => EventStatuses,
   FieldConfig: () => FieldConfig,
   FieldType: () => FieldType,
+  FieldUpdateValue: () => FieldUpdateValue,
   FieldValue: () => FieldValue,
   FileFieldValue: () => FileFieldValue,
   FileFieldValueWithOption: () => FileFieldValueWithOption,
   FileFieldWithOptionValue: () => FileFieldWithOptionValue,
   FormConfig: () => FormConfig,
   FormPage: () => FormPage,
+  GeographicalArea: () => GeographicalArea,
   LanguageConfig: () => LanguageConfig,
   MarkedAsDuplicateActionInput: () => MarkedAsDuplicateActionInput,
   NotifyActionInput: () => NotifyActionInput,
@@ -84,16 +88,23 @@ __export(events_exports, {
   RequestCorrectionActionInput: () => RequestCorrectionActionInput,
   RequiredTextValue: () => RequiredTextValue,
   ResolvedUser: () => ResolvedUser,
+  RuralAddressUpdateValue: () => RuralAddressUpdateValue,
+  RuralAddressValue: () => RuralAddressValue,
   ShowConditional: () => ShowConditional,
   SummaryConfig: () => SummaryConfig,
   TextValue: () => TextValue,
   TranslationConfig: () => TranslationConfig,
+  UrbanAddressUpdateValue: () => UrbanAddressUpdateValue,
+  UrbanAddressValue: () => UrbanAddressValue,
   ValidateActionInput: () => ValidateActionInput,
   WorkqueueConfig: () => WorkqueueConfig,
   alwaysTrue: () => alwaysTrue,
   and: () => and,
   applyDraftsToEventIndex: () => applyDraftsToEventIndex,
+  compositeFieldTypes: () => compositeFieldTypes,
+  createEmptyDraft: () => createEmptyDraft,
   createValidationSchema: () => createValidationSchema,
+  deepDropNulls: () => deepDropNulls,
   defineConditional: () => defineConditional,
   defineConfig: () => defineConfig,
   defineForm: () => defineForm,
@@ -107,12 +118,18 @@ __export(events_exports, {
   fieldTypes: () => fieldTypes,
   findActiveActionFields: () => findActiveActionFields,
   findActiveActionForm: () => findActiveActionForm,
+  findActiveActionFormFields: () => findActiveActionFormFields,
+  findActiveActionFormPages: () => findActiveActionFormPages,
+  findActiveDrafts: () => findActiveDrafts,
   findInputPageFields: () => findInputPageFields,
   findPageFields: () => findPageFields,
+  generateActionDocument: () => generateActionDocument,
   generateActionInput: () => generateActionInput,
   generateEventDocument: () => generateEventDocument,
   generateEventDraftDocument: () => generateEventDraftDocument,
   generateTransactionId: () => generateTransactionId,
+  getActiveActionFields: () => getActiveActionFields,
+  getActiveActionFormPages: () => getActiveActionFormPages,
   getAllFields: () => getAllFields,
   getAllPages: () => getAllPages,
   getCurrentEventState: () => getCurrentEventState,
@@ -130,19 +147,22 @@ __export(events_exports, {
   isDividerFieldType: () => isDividerFieldType,
   isEmailFieldType: () => isEmailFieldType,
   isFacilityFieldType: () => isFacilityFieldType,
+  isFieldConfigDefaultValue: () => isFieldConfigDefaultValue,
   isFieldEnabled: () => isFieldEnabled,
+  isFieldValue: () => isFieldValue,
+  isFieldValueWithoutTemplates: () => isFieldValueWithoutTemplates,
   isFieldVisible: () => isFieldVisible,
   isFileFieldType: () => isFileFieldType,
   isFileFieldWithOptionType: () => isFileFieldWithOptionType,
   isLocationFieldType: () => isLocationFieldType,
   isNumberFieldType: () => isNumberFieldType,
   isOfficeFieldType: () => isOfficeFieldType,
-  isOptionalUncheckedCheckbox: () => isOptionalUncheckedCheckbox,
   isPageHeaderFieldType: () => isPageHeaderFieldType,
   isParagraphFieldType: () => isParagraphFieldType,
   isRadioGroupFieldType: () => isRadioGroupFieldType,
   isSelectFieldType: () => isSelectFieldType,
   isSignatureFieldType: () => isSignatureFieldType,
+  isTemplateVariable: () => isTemplateVariable,
   isTextAreaFieldType: () => isTextAreaFieldType,
   isTextFieldType: () => isTextFieldType,
   isUndeclaredDraft: () => isUndeclaredDraft,
@@ -160,7 +180,7 @@ __export(events_exports, {
 module.exports = __toCommonJS(events_exports);
 
 // ../commons/src/events/ActionConfig.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 
 // ../commons/src/events/Conditional.ts
 var import_zod = require("zod");
@@ -189,10 +209,10 @@ var ActionConditional = import_zod.z.discriminatedUnion("type", [
 ]);
 
 // ../commons/src/events/FormConfig.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 
 // ../commons/src/events/FieldConfig.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 
 // ../commons/src/events/TranslationConfig.ts
 var import_zod2 = require("zod");
@@ -232,13 +252,21 @@ var FieldType = {
   SIGNATURE: "SIGNATURE"
 };
 var fieldTypes = Object.values(FieldType);
+var compositeFieldTypes = [
+  FieldType.ADDRESS,
+  FieldType.FILE_WITH_OPTIONS,
+  FieldType.FILE
+];
 
 // ../commons/src/events/FieldValue.ts
+var import_zod4 = require("zod");
+
+// ../commons/src/events/CompositeFieldValue.ts
 var import_zod3 = require("zod");
-var TextValue = import_zod3.z.string();
-var RequiredTextValue = TextValue.min(1);
-var DateValue = import_zod3.z.string().date().describe("Date in the format YYYY-MM-DD");
-var EmailValue = import_zod3.z.string().email();
+var GeographicalArea = {
+  URBAN: "URBAN",
+  RURAL: "RURAL"
+};
 var FileFieldValue = import_zod3.z.object({
   filename: import_zod3.z.string(),
   originalFilename: import_zod3.z.string(),
@@ -249,21 +277,37 @@ var AdminStructure = import_zod3.z.object({
   province: import_zod3.z.string(),
   district: import_zod3.z.string()
 });
-var UrbanAddress = AdminStructure.extend({
-  urbanOrRural: import_zod3.z.literal("URBAN"),
+var UrbanAddressValue = AdminStructure.extend({
+  urbanOrRural: import_zod3.z.literal(GeographicalArea.URBAN),
   town: import_zod3.z.string().optional(),
   residentialArea: import_zod3.z.string().optional(),
   street: import_zod3.z.string().optional(),
   number: import_zod3.z.string().optional(),
   zipCode: import_zod3.z.string().optional()
 });
-var RuralAddress = AdminStructure.extend({
-  urbanOrRural: import_zod3.z.literal("RURAL"),
+var RuralAddressValue = AdminStructure.extend({
+  urbanOrRural: import_zod3.z.literal(GeographicalArea.RURAL),
   village: import_zod3.z.string().optional()
 });
+var UrbanAddressUpdateValue = AdminStructure.extend({
+  urbanOrRural: import_zod3.z.literal(GeographicalArea.URBAN),
+  town: import_zod3.z.string().nullish(),
+  residentialArea: import_zod3.z.string().nullish(),
+  street: import_zod3.z.string().nullish(),
+  number: import_zod3.z.string().nullish(),
+  zipCode: import_zod3.z.string().nullish()
+});
+var RuralAddressUpdateValue = AdminStructure.extend({
+  urbanOrRural: import_zod3.z.literal(GeographicalArea.RURAL),
+  village: import_zod3.z.string().nullish()
+});
 var AddressFieldValue = import_zod3.z.discriminatedUnion("urbanOrRural", [
-  UrbanAddress,
-  RuralAddress
+  UrbanAddressValue,
+  RuralAddressValue
+]);
+var AddressFieldUpdateValue = import_zod3.z.discriminatedUnion("urbanOrRural", [
+  UrbanAddressUpdateValue,
+  RuralAddressUpdateValue
 ]);
 var FileFieldValueWithOption = import_zod3.z.object({
   filename: import_zod3.z.string(),
@@ -272,30 +316,46 @@ var FileFieldValueWithOption = import_zod3.z.object({
   option: import_zod3.z.string()
 });
 var FileFieldWithOptionValue = import_zod3.z.array(FileFieldValueWithOption);
-var CheckboxFieldValue = import_zod3.z.boolean();
-var NumberFieldValue = import_zod3.z.number();
-var FieldValue = import_zod3.z.union([
+
+// ../commons/src/events/FieldValue.ts
+var TextValue = import_zod4.z.string();
+var RequiredTextValue = TextValue.min(1);
+var DateValue = import_zod4.z.string().date().describe("Date in the format YYYY-MM-DD");
+var EmailValue = import_zod4.z.string().email();
+var CheckboxFieldValue = import_zod4.z.boolean();
+var NumberFieldValue = import_zod4.z.number();
+var FieldValue = import_zod4.z.union([
   TextValue,
   DateValue,
+  CheckboxFieldValue,
+  NumberFieldValue,
   FileFieldValue,
   FileFieldWithOptionValue,
+  UrbanAddressValue,
+  RuralAddressValue
+]);
+var FieldUpdateValue = import_zod4.z.union([
+  TextValue,
+  DateValue,
   CheckboxFieldValue,
   NumberFieldValue,
-  UrbanAddress,
-  RuralAddress
+  FileFieldValue,
+  FileFieldWithOptionValue,
+  UrbanAddressUpdateValue,
+  RuralAddressUpdateValue
 ]);
 
 // ../commons/src/events/FieldConfig.ts
-var FieldId = import_zod4.z.string();
-var DependencyExpression = import_zod4.z.object({
-  dependsOn: import_zod4.z.array(FieldId).default([]),
-  expression: import_zod4.z.string()
+var FieldId = import_zod5.z.string();
+var DependencyExpression = import_zod5.z.object({
+  dependsOn: import_zod5.z.array(FieldId).default([]),
+  expression: import_zod5.z.string()
 });
-var BaseField = import_zod4.z.object({
+var BaseField = import_zod5.z.object({
   id: FieldId,
-  defaultValue: import_zod4.z.union([
+  defaultValue: import_zod5.z.union([
     // These are the currently supported default values types
-    import_zod4.z.union([
+    import_zod5.z.union([
       TextValue,
       RequiredTextValue,
       DateValue,
@@ -304,82 +364,82 @@ var BaseField = import_zod4.z.object({
     ]),
     DependencyExpression
   ]).optional(),
-  conditionals: import_zod4.z.array(ActionConditional).default([]).optional(),
-  required: import_zod4.z.boolean().default(false).optional(),
-  disabled: import_zod4.z.boolean().default(false).optional(),
-  hidden: import_zod4.z.boolean().default(false).optional(),
+  conditionals: import_zod5.z.array(ActionConditional).default([]).optional(),
+  required: import_zod5.z.boolean().default(false).optional(),
+  disabled: import_zod5.z.boolean().default(false).optional(),
+  hidden: import_zod5.z.boolean().default(false).optional(),
   placeholder: TranslationConfig.optional(),
-  validation: import_zod4.z.array(
-    import_zod4.z.object({
+  validation: import_zod5.z.array(
+    import_zod5.z.object({
       validator: Conditional(),
       message: TranslationConfig
     })
   ).default([]).optional(),
-  dependsOn: import_zod4.z.array(FieldId).default([]).optional(),
+  dependsOn: import_zod5.z.array(FieldId).default([]).optional(),
   label: TranslationConfig,
-  hideLabel: import_zod4.z.boolean().default(false).optional()
+  hideLabel: import_zod5.z.boolean().default(false).optional()
 });
 var Divider = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.DIVIDER)
+  type: import_zod5.z.literal(FieldType.DIVIDER)
 });
 var TextField = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.TEXT),
-  defaultValue: import_zod4.z.union([RequiredTextValue, DependencyExpression]).optional(),
-  configuration: import_zod4.z.object({
-    maxLength: import_zod4.z.number().optional().describe("Maximum length of the text"),
-    type: import_zod4.z.enum(["text", "password"]).optional(),
+  type: import_zod5.z.literal(FieldType.TEXT),
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional(),
+  configuration: import_zod5.z.object({
+    maxLength: import_zod5.z.number().optional().describe("Maximum length of the text"),
+    type: import_zod5.z.enum(["text", "password"]).optional(),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).default({ type: "text" }).optional()
 }).describe("Text input");
 var NumberField = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.NUMBER),
-  defaultValue: import_zod4.z.union([NumberFieldValue, DependencyExpression]).optional(),
-  configuration: import_zod4.z.object({
-    min: import_zod4.z.number().optional().describe("Minimum value"),
-    max: import_zod4.z.number().optional().describe("Maximum value"),
+  type: import_zod5.z.literal(FieldType.NUMBER),
+  defaultValue: import_zod5.z.union([NumberFieldValue, DependencyExpression]).optional(),
+  configuration: import_zod5.z.object({
+    min: import_zod5.z.number().optional().describe("Minimum value"),
+    max: import_zod5.z.number().optional().describe("Maximum value"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).optional()
 }).describe("Number input");
 var TextAreaField = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.TEXTAREA),
-  defaultValue: import_zod4.z.union([RequiredTextValue, DependencyExpression]).optional(),
-  configuration: import_zod4.z.object({
-    maxLength: import_zod4.z.number().optional().describe("Maximum length of the text"),
-    rows: import_zod4.z.number().optional().describe("Number of visible text lines"),
-    cols: import_zod4.z.number().optional().describe("Number of visible columns"),
+  type: import_zod5.z.literal(FieldType.TEXTAREA),
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional(),
+  configuration: import_zod5.z.object({
+    maxLength: import_zod5.z.number().optional().describe("Maximum length of the text"),
+    rows: import_zod5.z.number().optional().describe("Number of visible text lines"),
+    cols: import_zod5.z.number().optional().describe("Number of visible columns"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional()
   }).default({ rows: 4 }).optional()
 }).describe("Multiline text input");
 var SignatureField = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.SIGNATURE),
+  type: import_zod5.z.literal(FieldType.SIGNATURE),
   signaturePromptLabel: TranslationConfig.describe(
     "Title of the signature modal"
   ),
-  configuration: import_zod4.z.object({
-    maxSizeMb: import_zod4.z.number().optional().describe("Maximum file size in MB"),
-    allowedFileFormats: import_zod4.z.array(import_zod4.z.string()).optional().describe("List of allowed file formats for the signature")
+  configuration: import_zod5.z.object({
+    maxSizeMb: import_zod5.z.number().optional().describe("Maximum file size in MB"),
+    allowedFileFormats: import_zod5.z.array(import_zod5.z.string()).optional().describe("List of allowed file formats for the signature")
   }).default({}).optional()
 }).describe("Signature input field");
 var EmailField = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.EMAIL),
-  configuration: import_zod4.z.object({
-    maxLength: import_zod4.z.number().optional().describe("Maximum length of the text")
+  type: import_zod5.z.literal(FieldType.EMAIL),
+  configuration: import_zod5.z.object({
+    maxLength: import_zod5.z.number().optional().describe("Maximum length of the text")
   }).default({ maxLength: 10 }).optional(),
-  defaultValue: import_zod4.z.union([RequiredTextValue, DependencyExpression]).optional()
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional()
 });
 var DateField = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.DATE),
-  defaultValue: import_zod4.z.union([DateValue, DependencyExpression]).optional(),
-  configuration: import_zod4.z.object({
+  type: import_zod5.z.literal(FieldType.DATE),
+  defaultValue: import_zod5.z.union([DateValue, DependencyExpression]).optional(),
+  configuration: import_zod5.z.object({
     notice: TranslationConfig.describe(
       "Text to display above the date input"
     ).optional()
   }).optional()
 }).describe("A single date input (dd-mm-YYYY)");
-var HtmlFontVariant = import_zod4.z.enum([
+var HtmlFontVariant = import_zod5.z.enum([
   "reg12",
   "reg14",
   "reg16",
@@ -390,97 +450,102 @@ var HtmlFontVariant = import_zod4.z.enum([
   "h1"
 ]);
 var Paragraph = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.PARAGRAPH),
-  defaultValue: import_zod4.z.union([RequiredTextValue, DependencyExpression]).optional(),
-  configuration: import_zod4.z.object({
-    styles: import_zod4.z.object({
+  type: import_zod5.z.literal(FieldType.PARAGRAPH),
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional(),
+  configuration: import_zod5.z.object({
+    styles: import_zod5.z.object({
       fontVariant: HtmlFontVariant.optional()
     }).optional()
   }).default({})
 }).describe("A read-only HTML <p> paragraph");
 var PageHeader = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.PAGE_HEADER),
-  defaultValue: import_zod4.z.union([RequiredTextValue, DependencyExpression]).optional()
+  type: import_zod5.z.literal(FieldType.PAGE_HEADER),
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional()
 }).describe("A read-only header component for form pages");
 var File = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.FILE),
-  options: import_zod4.z.object({
-    style: import_zod4.z.object({
-      fullWidth: import_zod4.z.boolean().describe(
+  type: import_zod5.z.literal(FieldType.FILE),
+  options: import_zod5.z.object({
+    style: import_zod5.z.object({
+      fullWidth: import_zod5.z.boolean().describe(
         "Whether the file upload button should take the full width of the container or not"
       )
     })
   }).optional()
 }).describe("File upload");
-var SelectOption = import_zod4.z.object({
-  value: import_zod4.z.string().describe("The value of the option"),
+var SelectOption = import_zod5.z.object({
+  value: import_zod5.z.string().describe("The value of the option"),
   label: TranslationConfig.describe("The label of the option")
 });
 var RadioGroup = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.RADIO_GROUP),
-  defaultValue: import_zod4.z.union([TextValue, DependencyExpression]).optional(),
-  options: import_zod4.z.array(SelectOption).describe("A list of options"),
-  configuration: import_zod4.z.object({
-    styles: import_zod4.z.object({
-      size: import_zod4.z.enum(["NORMAL", "LARGE"]).optional()
+  type: import_zod5.z.literal(FieldType.RADIO_GROUP),
+  defaultValue: import_zod5.z.union([TextValue, DependencyExpression]).optional(),
+  options: import_zod5.z.array(SelectOption).describe("A list of options"),
+  configuration: import_zod5.z.object({
+    styles: import_zod5.z.object({
+      size: import_zod5.z.enum(["NORMAL", "LARGE"]).optional()
     }).optional()
   }).optional()
 }).describe("Grouped radio options");
 var BulletList = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.BULLET_LIST),
-  defaultValue: import_zod4.z.string().optional(),
-  items: import_zod4.z.array(TranslationConfig).describe("A list of items"),
-  configuration: import_zod4.z.object({
-    styles: import_zod4.z.object({
+  type: import_zod5.z.literal(FieldType.BULLET_LIST),
+  defaultValue: import_zod5.z.string().optional(),
+  items: import_zod5.z.array(TranslationConfig).describe("A list of items"),
+  configuration: import_zod5.z.object({
+    styles: import_zod5.z.object({
       fontVariant: HtmlFontVariant.optional()
     }).optional()
   }).default({})
 }).describe("A list of bullet points");
 var Select = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.SELECT),
-  defaultValue: import_zod4.z.union([TextValue, DependencyExpression]).optional(),
-  options: import_zod4.z.array(SelectOption).describe("A list of options")
+  type: import_zod5.z.literal(FieldType.SELECT),
+  defaultValue: import_zod5.z.union([TextValue, DependencyExpression]).optional(),
+  options: import_zod5.z.array(SelectOption).describe("A list of options")
 }).describe("Select input");
 var Checkbox = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.CHECKBOX),
-  defaultValue: import_zod4.z.union([CheckboxFieldValue, DependencyExpression]).optional()
+  type: import_zod5.z.literal(FieldType.CHECKBOX),
+  defaultValue: import_zod5.z.union([CheckboxFieldValue, DependencyExpression]).optional()
 }).describe("Boolean checkbox field");
 var Country = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.COUNTRY),
-  defaultValue: import_zod4.z.union([RequiredTextValue, DependencyExpression]).optional()
+  type: import_zod5.z.literal(FieldType.COUNTRY),
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional()
 }).describe("Country select field");
-var AdministrativeAreaConfiguration = import_zod4.z.object({
-  partOf: import_zod4.z.object({
-    $data: import_zod4.z.string()
+var AdministrativeAreas = import_zod5.z.enum([
+  "ADMIN_STRUCTURE",
+  "HEALTH_FACILITY",
+  "CRVS_OFFICE"
+]);
+var AdministrativeAreaConfiguration = import_zod5.z.object({
+  partOf: import_zod5.z.object({
+    $data: import_zod5.z.string()
   }).optional().describe("Parent location"),
-  type: import_zod4.z.enum(["ADMIN_STRUCTURE", "HEALTH_FACILITY", "CRVS_OFFICE"])
+  type: AdministrativeAreas
 }).describe("Administrative area options");
 var AdministrativeArea = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.ADMINISTRATIVE_AREA),
-  defaultValue: import_zod4.z.union([RequiredTextValue, DependencyExpression]).optional(),
+  type: import_zod5.z.literal(FieldType.ADMINISTRATIVE_AREA),
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional(),
   configuration: AdministrativeAreaConfiguration
 }).describe("Administrative area input field e.g. facility, office");
 var Location = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.LOCATION),
-  defaultValue: import_zod4.z.union([RequiredTextValue, DependencyExpression]).optional()
+  type: import_zod5.z.literal(FieldType.LOCATION),
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional()
 }).describe("Input field for a location");
 var FileUploadWithOptions = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.FILE_WITH_OPTIONS),
-  options: import_zod4.z.array(SelectOption).describe("A list of options")
+  type: import_zod5.z.literal(FieldType.FILE_WITH_OPTIONS),
+  options: import_zod5.z.array(SelectOption).describe("A list of options")
 }).describe("Select input");
 var Facility = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.FACILITY),
-  defaultValue: import_zod4.z.union([RequiredTextValue, DependencyExpression]).optional()
+  type: import_zod5.z.literal(FieldType.FACILITY),
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional()
 }).describe("Input field for a facility");
 var Office = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.OFFICE),
-  defaultValue: import_zod4.z.union([RequiredTextValue, DependencyExpression]).optional()
+  type: import_zod5.z.literal(FieldType.OFFICE),
+  defaultValue: import_zod5.z.union([RequiredTextValue, DependencyExpression]).optional()
 }).describe("Input field for an office");
 var Address = BaseField.extend({
-  type: import_zod4.z.literal(FieldType.ADDRESS),
+  type: import_zod5.z.literal(FieldType.ADDRESS),
   defaultValue: AddressFieldValue.optional()
 }).describe("Address input field \u2013 a combination of location and text fields");
-var FieldConfig = import_zod4.z.discriminatedUnion("type", [
+var FieldConfig = import_zod5.z.discriminatedUnion("type", [
   Address,
   TextField,
   NumberField,
@@ -505,28 +570,28 @@ var FieldConfig = import_zod4.z.discriminatedUnion("type", [
 ]);
 
 // ../commons/src/events/FormConfig.ts
-var FormPage = import_zod5.z.object({
-  id: import_zod5.z.string().describe("Unique identifier for the page"),
+var FormPage = import_zod6.z.object({
+  id: import_zod6.z.string().describe("Unique identifier for the page"),
   title: TranslationConfig.describe("Header title of the page"),
-  fields: import_zod5.z.array(FieldConfig).describe("Fields to be rendered on the page")
+  fields: import_zod6.z.array(FieldConfig).describe("Fields to be rendered on the page")
 });
-var FormConfig = import_zod5.z.object({
+var FormConfig = import_zod6.z.object({
   label: TranslationConfig.describe("Human readable description of the form"),
-  version: import_zod5.z.object({
-    id: import_zod5.z.string().describe(
+  version: import_zod6.z.object({
+    id: import_zod6.z.string().describe(
       "Form version. Semantic versioning recommended. Example: 0.0.1"
     ),
     label: TranslationConfig.describe(
       "Human readable description of the version"
     )
   }),
-  active: import_zod5.z.boolean().default(false).describe("Whether the form is active"),
-  pages: import_zod5.z.array(FormPage),
-  review: import_zod5.z.object({
+  active: import_zod6.z.boolean().default(false).describe("Whether the form is active"),
+  pages: import_zod6.z.array(FormPage),
+  review: import_zod6.z.object({
     title: TranslationConfig.describe(
       "Title of the form to show in review page"
     ),
-    fields: import_zod5.z.array(FieldConfig).describe("Fields to be rendered on the review page for metadata")
+    fields: import_zod6.z.array(FieldConfig).describe("Fields to be rendered on the review page for metadata")
   })
 });
 
@@ -548,96 +613,90 @@ var ActionType = {
   CUSTOM: "CUSTOM",
   REJECT: "REJECT",
   MARKED_AS_DUPLICATE: "MARKED_AS_DUPLICATE",
-  ARCHIVED: "ARCHIVED"
+  ARCHIVE: "ARCHIVE"
 };
 
 // ../commons/src/events/ActionConfig.ts
-var ActionConditional2 = import_zod6.z.discriminatedUnion("type", [
+var ActionConditional2 = import_zod7.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 ActionConfigBase = import_zod6.z.object({
+var ActionConfigBase = import_zod7.z.object({
   label: TranslationConfig,
-  conditionals: import_zod6.z.array(ActionConditional2).optional().default([]),
-  draft: import_zod6.z.boolean().optional(),
-  forms: import_zod6.z.array(FormConfig)
+  conditionals: import_zod7.z.array(ActionConditional2).optional().default([]),
+  draft: import_zod7.z.boolean().optional(),
+  forms: import_zod7.z.array(FormConfig)
 });
 var DeclareConfig = ActionConfigBase.merge(
-  import_zod6.z.object({
-    type: import_zod6.z.literal(ActionType.DECLARE)
+  import_zod7.z.object({
+    type: import_zod7.z.literal(ActionType.DECLARE)
   })
 );
 var ValidateConfig = ActionConfigBase.merge(
-  import_zod6.z.object({
-    type: import_zod6.z.literal(ActionType.VALIDATE)
+  import_zod7.z.object({
+    type: import_zod7.z.literal(ActionType.VALIDATE)
   })
 );
 var RejectDeclarationConfig = ActionConfigBase.merge(
-  import_zod6.z.object({
-    type: import_zod6.z.literal(ActionType.REJECT),
-    comment: import_zod6.z.string(),
-    isDuplicate: import_zod6.z.boolean()
+  import_zod7.z.object({
+    type: import_zod7.z.literal(ActionType.REJECT)
   })
 );
 var MarkedAsDuplicateConfig = ActionConfigBase.merge(
-  import_zod6.z.object({
-    type: import_zod6.z.literal(ActionType.MARKED_AS_DUPLICATE),
-    comment: import_zod6.z.string(),
-    duplicates: import_zod6.z.array(import_zod6.z.string()).describe("UUIDs of duplicate records")
+  import_zod7.z.object({
+    type: import_zod7.z.literal(ActionType.MARKED_AS_DUPLICATE)
   })
 );
-var ArchivedConfig = ActionConfigBase.merge(
-  import_zod6.z.object({
-    type: import_zod6.z.literal(ActionType.ARCHIVED),
-    comment: import_zod6.z.string(),
-    isDuplicate: import_zod6.z.boolean()
+var ArchiveConfig = ActionConfigBase.merge(
+  import_zod7.z.object({
+    type: import_zod7.z.literal(ActionType.ARCHIVE)
   })
 );
 var RegisterConfig = ActionConfigBase.merge(
-  import_zod6.z.object({
-    type: import_zod6.z.literal(ActionType.REGISTER)
+  import_zod7.z.object({
+    type: import_zod7.z.literal(ActionType.REGISTER)
   })
 );
 var DeleteConfig = ActionConfigBase.merge(
-  import_zod6.z.object({
-    type: import_zod6.z.literal(ActionType.DELETE)
+  import_zod7.z.object({
+    type: import_zod7.z.literal(ActionType.DELETE)
   })
 );
 var PrintCertificateActionConfig = ActionConfigBase.merge(
-  import_zod6.z.object({
-    type: import_zod6.z.literal(ActionType.PRINT_CERTIFICATE)
+  import_zod7.z.object({
+    type: import_zod7.z.literal(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RequestCorrectionConfig = ActionConfigBase.merge(
-  import_zod6.z.object({
-    type: import_zod6.z.literal(ActionType.REQUEST_CORRECTION),
-    onboardingForm: import_zod6.z.array(FormPage),
-    additionalDetailsForm: import_zod6.z.array(FormPage)
+  import_zod7.z.object({
+    type: import_zod7.z.literal(ActionType.REQUEST_CORRECTION),
+    onboardingForm: import_zod7.z.array(FormPage),
+    additionalDetailsForm: import_zod7.z.array(FormPage)
   })
 );
 var RejectCorrectionConfig = ActionConfigBase.merge(
-  import_zod6.z.object({
-    type: import_zod6.z.literal(ActionType.REJECT_CORRECTION)
+  import_zod7.z.object({
+    type: import_zod7.z.literal(ActionType.REJECT_CORRECTION)
   })
 );
 var ApproveCorrectionConfig = ActionConfigBase.merge(
-  import_zod6.z.object({
-    type: import_zod6.z.literal(ActionType.APPROVE_CORRECTION)
+  import_zod7.z.object({
+    type: import_zod7.z.literal(ActionType.APPROVE_CORRECTION)
   })
 );
 var CustomConfig = ActionConfigBase.merge(
-  import_zod6.z.object({
-    type: import_zod6.z.literal(ActionType.CUSTOM)
+  import_zod7.z.object({
+    type: import_zod7.z.literal(ActionType.CUSTOM)
   })
 );
-var ActionConfig = import_zod6.z.discriminatedUnion("type", [
+var ActionConfig = import_zod7.z.discriminatedUnion("type", [
   DeclareConfig,
   ValidateConfig,
   RejectDeclarationConfig,
   MarkedAsDuplicateConfig,
-  ArchivedConfig,
+  ArchiveConfig,
   RegisterConfig,
   DeleteConfig,
   PrintCertificateActionConfig,
@@ -648,97 +707,97 @@ var ActionConfig = import_zod6.z.discriminatedUnion("type", [
 ]);
 
 // ../commons/src/events/offline/CertificateConfig.ts
-var import_zod7 = require("zod");
-var FontFamily = import_zod7.z.object({
-  normal: import_zod7.z.string(),
-  bold: import_zod7.z.string(),
-  italics: import_zod7.z.string(),
-  bolditalics: import_zod7.z.string()
+var import_zod8 = require("zod");
+var FontFamily = import_zod8.z.object({
+  normal: import_zod8.z.string(),
+  bold: import_zod8.z.string(),
+  italics: import_zod8.z.string(),
+  bolditalics: import_zod8.z.string()
 });
-var CertificateConfig = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  event: import_zod7.z.string(),
+var CertificateConfig = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  event: import_zod8.z.string(),
   label: TranslationConfig,
-  isDefault: import_zod7.z.boolean(),
-  fee: import_zod7.z.object({
-    onTime: import_zod7.z.number(),
-    late: import_zod7.z.number(),
-    delayed: import_zod7.z.number()
+  isDefault: import_zod8.z.boolean(),
+  fee: import_zod8.z.object({
+    onTime: import_zod8.z.number(),
+    late: import_zod8.z.number(),
+    delayed: import_zod8.z.number()
   }),
-  svgUrl: import_zod7.z.string(),
-  fonts: import_zod7.z.record(FontFamily).optional()
+  svgUrl: import_zod8.z.string(),
+  fonts: import_zod8.z.record(FontFamily).optional()
 });
 var CertificateTemplateConfig = CertificateConfig.extend({
-  hash: import_zod7.z.string().optional(),
-  svg: import_zod7.z.string()
+  hash: import_zod8.z.string().optional(),
+  svg: import_zod8.z.string()
 });
 
 // ../commons/src/events/offline/LanguageConfig.ts
-var import_zod8 = require("zod");
-var LanguageConfig = import_zod8.z.object({
-  lang: import_zod8.z.string(),
+var import_zod9 = require("zod");
+var LanguageConfig = import_zod9.z.object({
+  lang: import_zod9.z.string(),
   /**
    * client.csv contents
    */
-  messages: import_zod8.z.record(import_zod8.z.string())
+  messages: import_zod9.z.record(import_zod9.z.string())
 });
 
 // ../commons/src/events/EventConfig.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 
 // ../commons/src/events/DeduplicationConfig.ts
-var import_zod9 = require("zod");
-var FieldReference = import_zod9.z.string();
-var Matcher = import_zod9.z.object({
-  fieldId: import_zod9.z.string(),
-  options: import_zod9.z.object({
-    boost: import_zod9.z.number().optional()
+var import_zod10 = require("zod");
+var FieldReference = import_zod10.z.string();
+var Matcher = import_zod10.z.object({
+  fieldId: import_zod10.z.string(),
+  options: import_zod10.z.object({
+    boost: import_zod10.z.number().optional()
   }).optional().default({})
 });
 var FuzzyMatcher = Matcher.extend({
-  type: import_zod9.z.literal("fuzzy"),
-  options: import_zod9.z.object({
+  type: import_zod10.z.literal("fuzzy"),
+  options: import_zod10.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_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]).optional().default("AUTO:4,7"),
-    boost: import_zod9.z.number().optional().default(1)
+    fuzziness: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.number()]).optional().default("AUTO:4,7"),
+    boost: import_zod10.z.number().optional().default(1)
   }).optional().default({})
 });
 var StrictMatcher = Matcher.extend({
-  type: import_zod9.z.literal("strict"),
-  options: import_zod9.z.object({
-    boost: import_zod9.z.number().optional().default(1)
+  type: import_zod10.z.literal("strict"),
+  options: import_zod10.z.object({
+    boost: import_zod10.z.number().optional().default(1)
   }).optional().default({})
 });
 var DateRangeMatcher = Matcher.extend({
-  type: import_zod9.z.literal("dateRange"),
-  options: import_zod9.z.object({
-    days: import_zod9.z.number(),
+  type: import_zod10.z.literal("dateRange"),
+  options: import_zod10.z.object({
+    days: import_zod10.z.number(),
     origin: FieldReference,
-    boost: import_zod9.z.number().optional().default(1)
+    boost: import_zod10.z.number().optional().default(1)
   })
 });
 var DateDistanceMatcher = Matcher.extend({
-  type: import_zod9.z.literal("dateDistance"),
-  options: import_zod9.z.object({
-    days: import_zod9.z.number(),
+  type: import_zod10.z.literal("dateDistance"),
+  options: import_zod10.z.object({
+    days: import_zod10.z.number(),
     origin: FieldReference,
-    boost: import_zod9.z.number().optional().default(1)
+    boost: import_zod10.z.number().optional().default(1)
   })
 });
-var And = import_zod9.z.object({
-  type: import_zod9.z.literal("and"),
-  clauses: import_zod9.z.lazy(() => Clause.array())
+var And = import_zod10.z.object({
+  type: import_zod10.z.literal("and"),
+  clauses: import_zod10.z.lazy(() => Clause.array())
 });
-var Or = import_zod9.z.object({
-  type: import_zod9.z.literal("or"),
-  clauses: import_zod9.z.lazy(() => Clause.array())
+var Or = import_zod10.z.object({
+  type: import_zod10.z.literal("or"),
+  clauses: import_zod10.z.lazy(() => Clause.array())
 });
-var Clause = import_zod9.z.lazy(
-  () => import_zod9.z.discriminatedUnion("type", [
+var Clause = import_zod10.z.lazy(
+  () => import_zod10.z.discriminatedUnion("type", [
     And,
     Or,
     FuzzyMatcher,
@@ -747,37 +806,37 @@ var Clause = import_zod9.z.lazy(
     DateDistanceMatcher
   ])
 );
-var DeduplicationConfig = import_zod9.z.object({
-  id: import_zod9.z.string(),
+var DeduplicationConfig = import_zod10.z.object({
+  id: import_zod10.z.string(),
   label: TranslationConfig,
   query: Clause
 });
 
 // ../commons/src/events/SummaryConfig.ts
-var import_zod10 = require("zod");
-var Field = import_zod10.z.object({
-  id: import_zod10.z.string().describe("Id of summary field"),
+var import_zod11 = require("zod");
+var Field = import_zod11.z.object({
+  id: import_zod11.z.string().describe("Id of summary field"),
   value: TranslationConfig.describe(
     "Summary field value. Can utilise values defined in configuration and EventMetadata"
   ),
   label: TranslationConfig,
   emptyValueMessage: TranslationConfig.optional()
 });
-var Title = import_zod10.z.object({
-  id: import_zod10.z.string(),
+var Title = import_zod11.z.object({
+  id: import_zod11.z.string(),
   label: TranslationConfig.describe("Title content"),
   emptyValueMessage: TranslationConfig.optional()
 });
-var SummaryConfig = import_zod10.z.object({
+var SummaryConfig = import_zod11.z.object({
   title: Title.describe("Title of summary view."),
-  fields: import_zod10.z.array(Field).describe("Fields rendered in summary view.")
+  fields: import_zod11.z.array(Field).describe("Fields rendered in summary view.")
 }).describe("Configuration for summary in event.");
 
 // ../commons/src/events/WorkqueueConfig.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 
 // ../commons/src/events/EventMetadata.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var EventStatus = {
   CREATED: "CREATED",
   NOTIFIED: "NOTIFIED",
@@ -789,18 +848,18 @@ var EventStatus = {
   ARCHIVED: "ARCHIVED"
 };
 var eventStatuses = Object.values(EventStatus);
-var EventStatuses = import_zod11.z.nativeEnum(EventStatus);
-var EventMetadata = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  type: import_zod11.z.string(),
+var EventStatuses = import_zod12.z.nativeEnum(EventStatus);
+var EventMetadata = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  type: import_zod12.z.string(),
   status: EventStatuses,
-  createdAt: import_zod11.z.string().datetime(),
-  createdBy: import_zod11.z.string(),
-  createdAtLocation: import_zod11.z.string(),
-  modifiedAt: import_zod11.z.string().datetime(),
-  assignedTo: import_zod11.z.string().nullable(),
-  updatedBy: import_zod11.z.string(),
-  trackingId: import_zod11.z.string()
+  createdAt: import_zod12.z.string().datetime(),
+  createdBy: import_zod12.z.string(),
+  createdAtLocation: import_zod12.z.string(),
+  modifiedAt: import_zod12.z.string().datetime(),
+  assignedTo: import_zod12.z.string().nullish(),
+  updatedBy: import_zod12.z.string(),
+  trackingId: import_zod12.z.string()
 });
 var eventMetadataLabelMap = {
   "event.assignedTo": {
@@ -856,24 +915,24 @@ var eventMetadataLabelMap = {
 };
 
 // ../commons/src/events/WorkqueueConfig.ts
-var WorkqueueConfig = import_zod12.z.object({
-  id: import_zod12.z.string().describe("Unique identifier for workqueue."),
-  filters: import_zod12.z.array(
-    import_zod12.z.object({
-      status: import_zod12.z.array(EventStatuses).describe("Defines which statusese are included in the workqueue.")
+var WorkqueueConfig = import_zod13.z.object({
+  id: import_zod13.z.string().describe("Unique identifier for workqueue."),
+  filters: import_zod13.z.array(
+    import_zod13.z.object({
+      status: import_zod13.z.array(EventStatuses).describe("Defines which statusese are included in the workqueue.")
     })
   ).describe("Filters to be applied to workqueue.")
 }).describe("Configuration for workqueue.");
 
 // ../commons/src/events/AdvancedSearchConfig.ts
-var import_zod13 = require("zod");
-var AdvancedSearchConfig = import_zod13.z.object({
+var import_zod14 = require("zod");
+var AdvancedSearchConfig = import_zod14.z.object({
   title: TranslationConfig.describe("Advanced search tab title"),
-  fields: import_zod13.z.array(
-    import_zod13.z.object({
-      fieldId: import_zod13.z.string(),
-      config: import_zod13.z.object({
-        type: import_zod13.z.enum(["FUZZY", "EXACT", "RANGE"]).describe("Determines the type of field")
+  fields: import_zod14.z.array(
+    import_zod14.z.object({
+      fieldId: import_zod14.z.string(),
+      config: import_zod14.z.object({
+        type: import_zod14.z.enum(["FUZZY", "EXACT", "RANGE"]).describe("Determines the type of field")
       }).optional().describe("Configuration options for the field")
     })
   ).optional().default([]).describe("Advanced search fields.")
@@ -883,12 +942,12 @@ var AdvancedSearchConfig = import_zod13.z.object({
 var import_lodash = require("lodash");
 
 // ../commons/src/workqueues/WorkqueueConfig.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 
 // ../commons/src/workqueues/defaultColumns.ts
-var import_zod14 = require("zod");
-var WorkQueueColumnConfig = import_zod14.z.object({
-  id: import_zod14.z.string(),
+var import_zod15 = require("zod");
+var WorkQueueColumnConfig = import_zod15.z.object({
+  id: import_zod15.z.string(),
   label: TranslationConfig
 });
 var defaultColumns = {
@@ -925,16 +984,16 @@ var defaultColumns = {
     }
   }
 };
-var DefaultColumnKeys = import_zod14.z.enum(
+var DefaultColumnKeys = import_zod15.z.enum(
   Object.keys(defaultColumns)
 );
 
 // ../commons/src/workqueues/WorkqueueConfig.ts
-var rootWorkqueueConfig = import_zod15.z.object({
-  id: import_zod15.z.string(),
+var rootWorkqueueConfig = import_zod16.z.object({
+  id: import_zod16.z.string(),
   title: TranslationConfig,
-  columns: import_zod15.z.array(WorkQueueColumnConfig),
-  defaultColumns: import_zod15.z.array(DefaultColumnKeys)
+  columns: import_zod16.z.array(WorkQueueColumnConfig),
+  defaultColumns: import_zod16.z.array(DefaultColumnKeys)
 });
 var defineWorkqueue = (config) => rootWorkqueueConfig.parse(config);
 
@@ -1014,7 +1073,7 @@ var import_ajv_formats = __toESM(require("ajv-formats"));
 var import_date_fns = require("date-fns");
 
 // ../commons/src/events/FieldTypeMapping.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 function mapFieldTypeToZod(type, required) {
   let schema;
   switch (type) {
@@ -1054,17 +1113,17 @@ function mapFieldTypeToZod(type, required) {
       schema = FileFieldWithOptionValue;
       break;
     case FieldType.ADDRESS:
-      schema = AddressFieldValue;
+      schema = AddressFieldUpdateValue;
       break;
   }
-  return required ? schema : schema.optional();
+  return required ? schema : schema.nullish();
 }
 function createValidationSchema(config) {
   const shape = {};
   for (const field2 of config) {
     shape[field2.id] = mapFieldTypeToZod(field2.type, field2.required);
   }
-  return import_zod16.z.object(shape);
+  return import_zod17.z.object(shape);
 }
 function mapFieldTypeToMockValue(field2, i) {
   switch (field2.type) {
@@ -1317,6 +1376,20 @@ function validateFieldInput({
   return rawError.error?.issues.map((issue) => issue.message) ?? [];
 }
 
+// ../commons/src/utils.ts
+function getOrThrow(x, message) {
+  if (x === void 0 || x === null) {
+    throw new Error(message);
+  }
+  return x;
+}
+
+// ../commons/src/uuid.ts
+var import_uuid = require("uuid");
+function getUUID() {
+  return (0, import_uuid.v4)();
+}
+
 // ../commons/src/events/utils.ts
 function isMetadataField(field2) {
   return field2 in eventMetadataLabelMap;
@@ -1396,14 +1469,36 @@ var findActiveActionForm = (configuration, action) => {
   const form = actionConfig?.forms.find((f) => f.active);
   return form;
 };
+var findActiveActionFormPages = (configuration, action) => {
+  return findActiveActionForm(configuration, action)?.pages;
+};
 var getFormFields = (formConfig) => {
   return formConfig.pages.flatMap((p) => p.fields);
 };
+var findActiveActionFormFields = (configuration, action) => {
+  const form = findActiveActionForm(configuration, action);
+  return form ? getFormFields(form) : void 0;
+};
 var findActiveActionFields = (configuration, action) => {
   const form = findActiveActionForm(configuration, action);
-  const reviewFields = form?.review.fields || [];
-  return (form ? getFormFields(form) : []).concat(reviewFields);
+  const reviewFields = form?.review.fields;
+  const formFields = form ? getFormFields(form) : void 0;
+  const allFields = formFields ? formFields.concat(reviewFields ?? []) : reviewFields;
+  return allFields;
 };
+var getActiveActionFormPages = (configuration, action) => {
+  return getOrThrow(
+    findActiveActionForm(configuration, action)?.pages,
+    "Form configuration not found for type: " + configuration.id
+  );
+};
+function getActiveActionFields(configuration, action) {
+  const fields = findActiveActionFields(configuration, action);
+  if (!fields) {
+    throw new Error(`No active field config found for action type ${action}`);
+  }
+  return fields;
+}
 function getEventConfiguration(eventConfigurations, type) {
   const config = eventConfigurations.find((config2) => config2.id === type);
   if (!config) {
@@ -1412,16 +1507,13 @@ function getEventConfiguration(eventConfigurations, type) {
   return config;
 }
 function isOptionalUncheckedCheckbox(field2, form) {
-  if (field2.type !== "CHECKBOX") {
-    return false;
-  }
-  if (field2.required) {
+  if (field2.type !== FieldType.CHECKBOX || field2.required) {
     return false;
   }
   return !form[field2.id];
 }
 function stripHiddenFields(fields, data) {
-  return (0, import_lodash.omitBy)(data, (_, fieldId) => {
+  return (0, import_lodash.omitBy)(data, (_2, fieldId) => {
     const field2 = fields.find((f) => f.id === fieldId);
     if (!field2) {
       return true;
@@ -1432,18 +1524,39 @@ function stripHiddenFields(fields, data) {
     return !isFieldVisible(field2, data);
   });
 }
+function findActiveDrafts(event2, drafts) {
+  const actions = event2.actions.slice().sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const lastAction = actions[actions.length - 1];
+  return drafts.filter(({ createdAt }) => createdAt >= lastAction.createdAt).filter(({ eventId }) => eventId === event2.id);
+}
+function createEmptyDraft(eventId, draftId, actionType) {
+  return {
+    id: draftId,
+    eventId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    transactionId: getUUID(),
+    action: {
+      type: actionType,
+      data: {},
+      metadata: {},
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      createdBy: "@todo",
+      createdAtLocation: "@todo"
+    }
+  };
+}
 
 // ../commons/src/events/EventConfig.ts
-var EventConfig = import_zod17.z.object({
-  id: import_zod17.z.string().describe(
+var EventConfig = import_zod18.z.object({
+  id: import_zod18.z.string().describe(
     'A machine-readable identifier for the event, e.g. "birth" or "death"'
   ),
   summary: SummaryConfig,
   label: TranslationConfig,
-  actions: import_zod17.z.array(ActionConfig),
-  workqueues: import_zod17.z.array(WorkqueueConfig),
-  deduplication: import_zod17.z.array(DeduplicationConfig).optional().default([]),
-  advancedSearch: import_zod17.z.array(AdvancedSearchConfig).optional().default([])
+  actions: import_zod18.z.array(ActionConfig),
+  workqueues: import_zod18.z.array(WorkqueueConfig),
+  deduplication: import_zod18.z.array(DeduplicationConfig).optional().default([]),
+  advancedSearch: import_zod18.z.array(AdvancedSearchConfig).optional().default([])
 }).superRefine((event2, ctx) => {
   const allFields = findPageFields(event2);
   const fieldIds = allFields.map((field2) => field2.id);
@@ -1476,107 +1589,107 @@ var defineForm = (form) => FormConfig.parse(form);
 var defineFormPage = (formPage) => FormPage.parse(formPage);
 
 // ../commons/src/events/Draft.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 
 // ../commons/src/events/ActionDocument.ts
-var import_zod18 = require("zod");
-var ActionMetadata = import_zod18.z.record(import_zod18.z.string(), FieldValue);
-var ActionBase = import_zod18.z.object({
-  id: import_zod18.z.string(),
-  createdAt: import_zod18.z.string().datetime(),
-  createdBy: import_zod18.z.string(),
-  data: import_zod18.z.record(import_zod18.z.string(), FieldValue),
-  metadata: ActionMetadata.optional(),
-  createdAtLocation: import_zod18.z.string()
+var import_zod19 = require("zod");
+var ActionUpdate = import_zod19.z.record(import_zod19.z.string(), FieldUpdateValue);
+var ActionBase = import_zod19.z.object({
+  id: import_zod19.z.string(),
+  createdAt: import_zod19.z.string().datetime(),
+  createdBy: import_zod19.z.string(),
+  data: ActionUpdate,
+  metadata: ActionUpdate.optional(),
+  createdAtLocation: import_zod19.z.string()
 });
 var AssignedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod18.z.string()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.ASSIGN),
+    assignedTo: import_zod19.z.string()
   })
 );
 var UnassignedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.UNASSIGN)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.UNASSIGN)
   })
 );
 var RegisterAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.REGISTER),
-    identifiers: import_zod18.z.object({
-      trackingId: import_zod18.z.string(),
-      registrationNumber: import_zod18.z.string()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.REGISTER),
+    identifiers: import_zod19.z.object({
+      trackingId: import_zod19.z.string(),
+      registrationNumber: import_zod19.z.string()
     })
   })
 );
 var DeclareAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.DECLARE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.DECLARE)
   })
 );
 var ValidateAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.VALIDATE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.VALIDATE)
   })
 );
 var RejectAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.REJECT)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.REJECT)
   })
 );
 var MarkAsDuplicateAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.MARKED_AS_DUPLICATE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.MARKED_AS_DUPLICATE)
   })
 );
-var ArchivedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.ARCHIVED)
+var ArchiveAction = ActionBase.merge(
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.ARCHIVE)
   })
 );
 var CreatedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.CREATE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.CREATE)
   })
 );
 var NotifiedAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.NOTIFY)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.NOTIFY)
   })
 );
 var PrintCertificateAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.PRINT_CERTIFICATE)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RequestedCorrectionAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.REQUEST_CORRECTION)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.REQUEST_CORRECTION)
   })
 );
 var ApprovedCorrectionAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.APPROVE_CORRECTION),
-    requestId: import_zod18.z.string()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.APPROVE_CORRECTION),
+    requestId: import_zod19.z.string()
   })
 );
 var RejectedCorrectionAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.REJECT_CORRECTION),
-    requestId: import_zod18.z.string()
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.REJECT_CORRECTION),
+    requestId: import_zod19.z.string()
   })
 );
 var CustomAction = ActionBase.merge(
-  import_zod18.z.object({
-    type: import_zod18.z.literal(ActionType.CUSTOM)
+  import_zod19.z.object({
+    type: import_zod19.z.literal(ActionType.CUSTOM)
   })
 );
-var ActionDocument = import_zod18.z.discriminatedUnion("type", [
+var ActionDocument = import_zod19.z.discriminatedUnion("type", [
   CreatedAction,
   ValidateAction,
   RejectAction,
   MarkAsDuplicateAction,
-  ArchivedAction,
+  ArchiveAction,
   NotifiedAction,
   RegisterAction,
   DeclareAction,
@@ -1588,107 +1701,106 @@ var ActionDocument = import_zod18.z.discriminatedUnion("type", [
   PrintCertificateAction,
   CustomAction
 ]);
-var ResolvedUser = import_zod18.z.object({
-  id: import_zod18.z.string(),
-  role: import_zod18.z.string(),
-  name: import_zod18.z.array(
-    import_zod18.z.object({
-      use: import_zod18.z.string(),
-      given: import_zod18.z.array(import_zod18.z.string()),
-      family: import_zod18.z.string()
+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()
     })
   )
 });
 
 // ../commons/src/events/ActionInput.ts
-var import_zod19 = require("zod");
-var BaseActionInput = import_zod19.z.object({
-  eventId: import_zod19.z.string(),
-  transactionId: import_zod19.z.string(),
-  incomplete: import_zod19.z.boolean().optional().default(false).describe("Allows action with partial data to be saved"),
-  data: import_zod19.z.record(import_zod19.z.string(), FieldValue),
-  metadata: import_zod19.z.record(import_zod19.z.string(), FieldValue).optional()
+var import_zod20 = require("zod");
+var BaseActionInput = import_zod20.z.object({
+  eventId: import_zod20.z.string(),
+  transactionId: import_zod20.z.string(),
+  data: ActionUpdate,
+  metadata: ActionUpdate.optional()
 });
 var CreateActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.CREATE).default(ActionType.CREATE),
-    createdAtLocation: import_zod19.z.string()
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.CREATE).default(ActionType.CREATE),
+    createdAtLocation: import_zod20.z.string()
   })
 );
 var RegisterActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
-    identifiers: import_zod19.z.object({
-      trackingId: import_zod19.z.string(),
-      registrationNumber: import_zod19.z.string()
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
+    identifiers: import_zod20.z.object({
+      trackingId: import_zod20.z.string(),
+      registrationNumber: import_zod20.z.string()
     })
   })
 );
 var ValidateActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
-    duplicates: import_zod19.z.array(import_zod19.z.string())
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.VALIDATE).default(ActionType.VALIDATE),
+    duplicates: import_zod20.z.array(import_zod20.z.string())
   })
 );
 var NotifyActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
   })
 );
 var DeclareActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.DECLARE).default(ActionType.DECLARE)
   })
 );
 var PrintCertificateActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.PRINT_CERTIFICATE).default(ActionType.PRINT_CERTIFICATE)
   })
 );
 var RejectDeclarationActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REJECT).default(ActionType.REJECT)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.REJECT).default(ActionType.REJECT)
   })
 );
 var MarkedAsDuplicateActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.MARKED_AS_DUPLICATE).default(ActionType.MARKED_AS_DUPLICATE)
   })
 );
-var ArchivedActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.ARCHIVED).default(ActionType.ARCHIVED)
+var ArchiveActionInput = BaseActionInput.merge(
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.ARCHIVE).default(ActionType.ARCHIVE)
   })
 );
 var AssignActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
-    assignedTo: import_zod19.z.string()
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.ASSIGN).default(ActionType.ASSIGN),
+    assignedTo: import_zod20.z.string()
   })
 );
 var UnassignActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN)
   })
 );
 var RequestCorrectionActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    type: import_zod19.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
+  import_zod20.z.object({
+    type: import_zod20.z.literal(ActionType.REQUEST_CORRECTION).default(ActionType.REQUEST_CORRECTION)
   })
 );
 var RejectCorrectionActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    requestId: import_zod19.z.string(),
-    type: import_zod19.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
+  import_zod20.z.object({
+    requestId: import_zod20.z.string(),
+    type: import_zod20.z.literal(ActionType.REJECT_CORRECTION).default(ActionType.REJECT_CORRECTION)
   })
 );
 var ApproveCorrectionActionInput = BaseActionInput.merge(
-  import_zod19.z.object({
-    requestId: import_zod19.z.string(),
-    type: import_zod19.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
+  import_zod20.z.object({
+    requestId: import_zod20.z.string(),
+    type: import_zod20.z.literal(ActionType.APPROVE_CORRECTION).default(ActionType.APPROVE_CORRECTION)
   })
 );
-var ActionInput = import_zod19.z.discriminatedUnion("type", [
+var ActionInput = import_zod20.z.discriminatedUnion("type", [
   CreateActionInput,
   ValidateActionInput,
   RegisterActionInput,
@@ -1696,7 +1808,7 @@ var ActionInput = import_zod19.z.discriminatedUnion("type", [
   DeclareActionInput,
   RejectDeclarationActionInput,
   MarkedAsDuplicateActionInput,
-  ArchivedActionInput,
+  ArchiveActionInput,
   AssignActionInput,
   UnassignActionInput,
   PrintCertificateActionInput,
@@ -1706,50 +1818,51 @@ var ActionInput = import_zod19.z.discriminatedUnion("type", [
 ]);
 
 // ../commons/src/events/Draft.ts
-var Draft = import_zod20.z.object({
-  id: import_zod20.z.string(),
-  eventId: import_zod20.z.string(),
-  transactionId: import_zod20.z.string(),
-  createdAt: import_zod20.z.string().datetime(),
+var Draft = import_zod21.z.object({
+  id: import_zod21.z.string(),
+  eventId: import_zod21.z.string(),
+  transactionId: import_zod21.z.string(),
+  createdAt: import_zod21.z.string().datetime(),
   action: ActionBase.extend({
-    type: import_zod20.z.enum(Object.values(ActionType))
+    type: import_zod21.z.enum(Object.values(ActionType))
   }).omit({ id: true })
 });
 var DraftInput = BaseActionInput.extend({
-  type: import_zod20.z.enum(Object.values(ActionType))
+  type: import_zod21.z.enum(Object.values(ActionType))
 });
 
 // ../commons/src/events/EventInput.ts
-var import_zod21 = require("zod");
-var EventInput = import_zod21.z.object({
-  transactionId: import_zod21.z.string(),
-  type: import_zod21.z.string()
+var import_zod22 = require("zod");
+var EventInput = import_zod22.z.object({
+  transactionId: import_zod22.z.string(),
+  type: import_zod22.z.string()
 });
 
 // ../commons/src/events/EventDocument.ts
-var import_zod22 = require("zod");
-var EventDocument = import_zod22.z.object({
-  id: import_zod22.z.string(),
-  type: import_zod22.z.string(),
-  createdAt: import_zod22.z.string().datetime(),
-  updatedAt: import_zod22.z.string().datetime(),
-  actions: import_zod22.z.array(ActionDocument),
-  trackingId: import_zod22.z.string()
+var import_zod23 = require("zod");
+var EventDocument = import_zod23.z.object({
+  id: import_zod23.z.string(),
+  type: import_zod23.z.string(),
+  createdAt: import_zod23.z.string().datetime(),
+  updatedAt: import_zod23.z.string().datetime(),
+  actions: import_zod23.z.array(ActionDocument),
+  trackingId: import_zod23.z.string()
 });
 
 // ../commons/src/events/EventIndex.ts
-var import_zod23 = require("zod");
+var import_zod24 = require("zod");
 var EventIndex = EventMetadata.extend({
-  data: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.any())
+  data: import_zod24.z.record(import_zod24.z.string(), import_zod24.z.any())
 });
-var EventSearchIndex = import_zod23.z.record(import_zod23.z.string(), import_zod23.z.any()).and(
-  import_zod23.z.object({
-    type: import_zod23.z.string()
+var EventSearchIndex = import_zod24.z.record(import_zod24.z.string(), import_zod24.z.any()).and(
+  import_zod24.z.object({
+    type: import_zod24.z.string()
     // Ensures "type" (event-id) exists and is a string
   })
 );
 
 // ../commons/src/events/state/index.ts
+var _ = __toESM(require("lodash"));
 function getStatusFromActions(actions) {
   return actions.reduce((status, action) => {
     if (action.type === ActionType.CREATE) {
@@ -1767,7 +1880,7 @@ function getStatusFromActions(actions) {
     if (action.type === ActionType.REJECT) {
       return EventStatus.REJECTED;
     }
-    if (action.type === ActionType.ARCHIVED) {
+    if (action.type === ActionType.ARCHIVE) {
       return EventStatus.ARCHIVED;
     }
     if (action.type === ActionType.NOTIFY) {
@@ -1801,19 +1914,46 @@ function getData(actions) {
       if (!requestAction) {
         return status;
       }
+      return deepMerge(status, requestAction.data);
+    }
+    return deepMerge(status, action.data);
+  }, {});
+}
+function deepDropNulls(obj) {
+  if (!_.isObject(obj)) return obj;
+  return Object.entries(obj).reduce((acc, [key, value]) => {
+    if (_.isObject(value)) {
+      value = deepDropNulls(value);
+    }
+    if (value !== null) {
       return {
-        ...status,
-        ...requestAction.data
+        ...acc,
+        [key]: value
       };
     }
-    return {
-      ...status,
-      ...action.data
-    };
+    return acc;
   }, {});
 }
-function isUndeclaredDraft(event2) {
-  return event2.actions.every(({ type }) => type === ActionType.CREATE);
+function deepMerge(currentDocument, actionDocument) {
+  return _.mergeWith(
+    currentDocument,
+    actionDocument,
+    (previousValue, incomingValue) => {
+      if (incomingValue === void 0) {
+        return previousValue;
+      }
+      if (_.isArray(incomingValue)) {
+        return incomingValue;
+      }
+      if (_.isObject(previousValue) && _.isObject(incomingValue)) {
+        return void 0;
+      }
+      return incomingValue;
+    }
+  );
+}
+function isUndeclaredDraft(status) {
+  return status === EventStatus.CREATED;
 }
 function getCurrentEventState(event2) {
   const creationAction = event2.actions.find(
@@ -1823,7 +1963,7 @@ function getCurrentEventState(event2) {
     throw new Error(`Event ${event2.id} has no creation action`);
   }
   const latestAction = event2.actions[event2.actions.length - 1];
-  return {
+  return deepDropNulls({
     id: event2.id,
     type: event2.type,
     status: getStatusFromActions(event2.actions),
@@ -1835,14 +1975,11 @@ function getCurrentEventState(event2) {
     updatedBy: latestAction.createdBy,
     data: getData(event2.actions),
     trackingId: event2.trackingId
-  };
+  });
 }
 function getCurrentEventStateWithDrafts(event2, drafts) {
-  const actions = event2.actions.slice().sort();
-  const lastAction = actions[actions.length - 1];
-  const activeDrafts = drafts.filter(({ eventId }) => eventId === event2.id).filter(
-    ({ createdAt }) => new Date(createdAt) > new Date(lastAction.createdAt)
-  ).map((draft) => draft.action).flatMap((action) => {
+  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,
@@ -1875,20 +2012,21 @@ function applyDraftsToEventIndex(eventIndex, drafts) {
     }
   };
 }
-function getMetadataForAction(event2, actionType, draftsForEvent) {
+function getMetadataForAction({
+  event: event2,
+  actionType,
+  drafts
+}) {
   const action = event2.actions.find((action2) => actionType === action2.type);
-  const drafts = draftsForEvent.filter((draft) => draft.eventId === event2.id);
+  const eventDrafts = drafts.filter((draft) => draft.eventId === event2.id);
   const sorted = [
     ...action ? [action] : [],
-    ...drafts.map((draft) => draft.action)
+    ...eventDrafts.map((draft) => draft.action)
   ].sort();
   const metadata = sorted.reduce((metadata2, action2) => {
-    return {
-      ...metadata2,
-      ...action2.metadata
-    };
+    return deepMerge(metadata2, action2.metadata ?? {});
   }, {});
-  return metadata;
+  return deepDropNulls(metadata);
 }
 
 // ../commons/src/events/defineConfig.ts
@@ -1902,12 +2040,6 @@ var defineConfig = (config) => {
   });
 };
 
-// ../commons/src/uuid.ts
-var import_uuid = require("uuid");
-function getUUID() {
-  return (0, import_uuid.v4)();
-}
-
 // ../commons/src/events/transactions.ts
 function generateTransactionId() {
   return getUUID();
@@ -2779,7 +2911,7 @@ var TENNIS_CLUB_FORM = defineForm({
   review: {
     title: {
       id: "v2.event.tennis-club-membership.action.declare.form.review.title",
-      defaultMessage: "Member declaration for {firstname} {surname}",
+      defaultMessage: "{applicant.firstname, select, __EMPTY__ {Member declaration} other {{applicant.surname, select, __EMPTY__ {Member declaration} other {Member declaration for {applicant.firstname} {applicant.surname}}}}}",
       description: "Title of the form to show in review page"
     },
     fields: [
@@ -3049,7 +3181,7 @@ var tennisClubMembershipEvent = defineConfig({
   ],
   actions: [
     {
-      type: "DECLARE",
+      type: ActionType.DECLARE,
       label: {
         defaultMessage: "Send an application",
         description: "This is shown as the action name anywhere the user can trigger the action from",
@@ -3058,25 +3190,25 @@ var tennisClubMembershipEvent = defineConfig({
       forms: [TENNIS_CLUB_FORM]
     },
     {
-      type: "REGISTER",
+      type: ActionType.VALIDATE,
       label: {
-        defaultMessage: "Register",
+        defaultMessage: "Validate",
         description: "This is shown as the action name anywhere the user can trigger the action from",
-        id: "event.tennis-club-membership.action.register.label"
+        id: "event.tennis-club-membership.action.validate.label"
       },
       forms: [TENNIS_CLUB_FORM]
     },
     {
-      type: "VALIDATE",
+      type: ActionType.REGISTER,
       label: {
-        defaultMessage: "Validate",
+        defaultMessage: "Register",
         description: "This is shown as the action name anywhere the user can trigger the action from",
-        id: "event.tennis-club-membership.action.validate.label"
+        id: "event.tennis-club-membership.action.register.label"
       },
-      forms: []
+      forms: [TENNIS_CLUB_FORM]
     },
     {
-      type: "REQUEST_CORRECTION",
+      type: ActionType.REQUEST_CORRECTION,
       label: {
         defaultMessage: "Request correction",
         description: "This is shown as the action name anywhere the user can trigger the action from",
@@ -3272,7 +3404,7 @@ var tennisClubMembershipEvent = defineConfig({
       ]
     },
     {
-      type: "APPROVE_CORRECTION",
+      type: ActionType.APPROVE_CORRECTION,
       forms: [TENNIS_CLUB_FORM],
       label: {
         defaultMessage: "Approve correction",
@@ -3327,6 +3459,24 @@ var tennisClubMembershipEvent = defineConfig({
           })
         }
       ]
+    },
+    {
+      type: ActionType.ARCHIVE,
+      label: {
+        id: "v2.event.tennis-club-membership.action.archive.label",
+        defaultMessage: "Archive",
+        description: "This is shown as the action name anywhere the user can trigger the action from"
+      },
+      forms: [TENNIS_CLUB_FORM]
+    },
+    {
+      type: ActionType.REJECT,
+      label: {
+        id: "v2.event.tennis-club-membership.action.reject.label",
+        defaultMessage: "Reject",
+        description: "This is shown as the action name anywhere the user can trigger the action from"
+      },
+      forms: [TENNIS_CLUB_FORM]
     }
   ],
   advancedSearch: [
@@ -3347,7 +3497,7 @@ var tennisClubMembershipEvent = defineConfig({
 
 // ../commons/src/events/test.utils.ts
 function generateActionInput(configuration, action) {
-  const fields = findActiveActionFields(configuration, action) ?? [];
+  const fields = findActiveActionFormFields(configuration, action) ?? [];
   const data = fields.reduce(
     (acc, field2, i) => ({
       ...acc,
@@ -3402,12 +3552,12 @@ var eventPayloadGenerator = {
     validate: (eventId, input = {}) => ({
       type: ActionType.VALIDATE,
       transactionId: input.transactionId ?? getUUID(),
-      data: input.data ?? {},
+      data: input.data ?? generateActionInput(tennisClubMembershipEvent, ActionType.VALIDATE),
       duplicates: [],
       eventId
     }),
     archive: (eventId, input = {}, isDuplicate) => ({
-      type: ActionType.ARCHIVED,
+      type: ActionType.ARCHIVE,
       transactionId: input.transactionId ?? getUUID(),
       data: input.data ?? {},
       metadata: { isDuplicate: isDuplicate ?? false },
@@ -3472,15 +3622,17 @@ var eventPayloadGenerator = {
 };
 function generateActionDocument({
   configuration,
-  action
+  action,
+  defaults = {}
 }) {
   const actionBase = {
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    createdAt: new Date(Date.now() - 500).toISOString(),
     createdBy: getUUID(),
     id: getUUID(),
     createdAtLocation: "TODO",
     data: generateActionInput(configuration, action),
-    metadata: {}
+    metadata: {},
+    ...defaults
   };
   switch (action) {
     case ActionType.DECLARE:
@@ -3491,7 +3643,7 @@ function generateActionDocument({
       return { ...actionBase, assignedTo: getUUID(), type: action };
     case ActionType.VALIDATE:
       return { ...actionBase, type: action };
-    case ActionType.ARCHIVED:
+    case ActionType.ARCHIVE:
       return { ...actionBase, type: action };
     case ActionType.REJECT:
       return { ...actionBase, type: action };
@@ -3529,9 +3681,9 @@ function generateEventDocument({
     actions: actions.map(
       (action) => generateActionDocument({ configuration, action })
     ),
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    createdAt: new Date(Date.now() - 1e3).toISOString(),
     id: getUUID(),
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    updatedAt: new Date(Date.now() - 1e3).toISOString()
   };
 }
 function generateEventDraftDocument(eventId, actionType = ActionType.DECLARE, data = {}) {
@@ -3571,3 +3723,33 @@ var eventQueryDataGenerator = (overrides = {}) => ({
   },
   trackingId: overrides.trackingId ?? "M3F8YQ"
 });
+
+// ../commons/src/events/TemplateConfig.ts
+function isTemplateVariable(value) {
+  return typeof value === "string" && value.startsWith("$");
+}
+function isFieldValue(value) {
+  return FieldValue.safeParse(value).success;
+}
+function isFieldValueWithoutTemplates(value) {
+  if (isTemplateVariable(value)) {
+    return false;
+  }
+  if (typeof value === "object" && Object.values(value).some((val) => isTemplateVariable(val))) {
+    return false;
+  }
+  return true;
+}
+function isFieldConfigDefaultValue(value) {
+  if (!value) return false;
+  if (isFieldValue(value)) {
+    return true;
+  }
+  if (isTemplateVariable(value)) {
+    return true;
+  }
+  if (typeof value === "object" && Object.values(value).every((v) => typeof v === "object" && v !== null)) {
+    return Object.values(value).every((v) => isFieldConfigDefaultValue(v));
+  }
+  return false;
+}