@opencrvs/toolkit 1.9.10-rc.fec884e → 1.9.10

package/dist/events/index.js

@@ -226,7 +226,6 @@ __export(events_exports, {
   applyDraftToEventIndex: () => applyDraftToEventIndex,
   areCertificateConditionsMet: () => areCertificateConditionsMet,
   areConditionsMet: () => areConditionsMet,
-  buildFormState: () => buildFormState,
   canUserReadEvent: () => canUserReadEvent,
   compositeFieldTypes: () => compositeFieldTypes,
   configurableEventScopeAllowed: () => configurableEventScopeAllowed,
@@ -261,8 +260,6 @@ __export(events_exports, {
   findAllFields: () => findAllFields,
   findLastAssignmentAction: () => findLastAssignmentAction,
   findRecordActionPages: () => findRecordActionPages,
-  flattenFieldReference: () => flattenFieldReference,
-  flattenFormState: () => flattenFormState,
   generateActionDeclarationInput: () => generateActionDeclarationInput,
   generateActionDocument: () => generateActionDocument,
   generateActionDuplicateDeclarationInput: () => generateActionDuplicateDeclarationInput,
@@ -324,7 +321,6 @@ __export(events_exports, {
   isFieldConfigDefaultValue: () => isFieldConfigDefaultValue,
   isFieldDisplayedOnReview: () => isFieldDisplayedOnReview,
   isFieldEnabled: () => isFieldEnabled,
-  isFieldGroupFieldType: () => isFieldGroupFieldType,
   isFieldReference: () => isFieldReference,
   isFieldValue: () => isFieldValue,
   isFieldValueWithoutTemplates: () => isFieldValueWithoutTemplates,
@@ -367,7 +363,6 @@ __export(events_exports, {
   mandatoryColumns: () => mandatoryColumns,
   mapFieldTypeToEmptyValue: () => mapFieldTypeToEmptyValue,
   mapFieldTypeToZod: () => mapFieldTypeToZod,
-  mapFormState: () => mapFormState,
   mergeDrafts: () => mergeDrafts,
   never: () => never,
   not: () => not,
@@ -592,7 +587,6 @@ var FieldType = {
   PARAGRAPH: "PARAGRAPH",
   PAGE_HEADER: "PAGE_HEADER",
   RADIO_GROUP: "RADIO_GROUP",
-  FIELD_GROUP: "FIELD_GROUP",
   FILE: "FILE",
   FILE_WITH_OPTIONS: "FILE_WITH_OPTIONS",
   BULLET_LIST: "BULLET_LIST",
@@ -2279,7 +2273,9 @@ var AdministrativeAreas = import_zod16.z.enum([
   "CRVS_OFFICE"
 ]);
 var AdministrativeAreaConfiguration = import_zod16.z.object({
-  partOf: FieldReference.optional(),
+  partOf: import_zod16.z.object({
+    $declaration: import_zod16.z.string()
+  }).optional().describe("Parent location"),
   type: AdministrativeAreas
 }).describe("Administrative area options");
 var AdministrativeArea = BaseField.extend({
@@ -2364,11 +2360,6 @@ var ButtonField = BaseField.extend({
     text: TranslationConfig.describe("Text to display on the button")
   })
 }).describe("Generic button without any built-in functionality");
-var FieldGroup = BaseField.extend({
-  type: import_zod16.z.literal(FieldType.FIELD_GROUP),
-  // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  fields: import_zod16.z.lazy(() => import_zod16.z.array(FieldConfig))
-});
 var AlphaPrintButton = BaseField.extend({
   type: import_zod16.z.literal(FieldType.ALPHA_PRINT_BUTTON),
   configuration: import_zod16.z.object({
@@ -2476,7 +2467,6 @@ var LoaderField = BaseField.extend({
   "A non-interactive field that indicates an in progress operation in form"
 );
 var FieldConfig = import_zod16.z.discriminatedUnion("type", [
-  FieldGroup,
   Address,
   TextField,
   NumberField,
@@ -2824,7 +2814,7 @@ var LanguageConfig = import_zod22.z.object({
 });
 
 // ../commons/src/events/EventConfig.ts
-var import_zod28 = require("zod");
+var import_zod27 = require("zod");
 
 // ../commons/src/events/SummaryConfig.ts
 var import_zod23 = require("zod");
@@ -2981,11 +2971,8 @@ 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_zod27 = require("zod");
-var import_date_fns = require("date-fns");
-
-// ../commons/src/events/FieldTypeMapping.ts
 var import_zod26 = require("zod");
+var import_date_fns = require("date-fns");
 
 // ../commons/src/events/DynamicFieldValue.ts
 var import_zod25 = require("zod");
@@ -3018,15 +3005,6 @@ function getDynamicAddressFieldValue(field3) {
 function mapFieldTypeToZod(field3, actionType) {
   let schema;
   switch (field3.type) {
-    case FieldType.FIELD_GROUP:
-      schema = import_zod26.z.object(
-        field3.fields.reduce((acc, subfield) => {
-          return {
-            ...acc,
-            [subfield.id]: mapFieldTypeToZod(subfield)
-          };
-        }, {})
-      );
     case FieldType.DATE:
       schema = DateValue;
       break;
@@ -3114,15 +3092,6 @@ function mapFieldTypeToZod(field3, actionType) {
 }
 function mapFieldTypeToEmptyValue(field3) {
   switch (field3.type) {
-    case FieldType.FIELD_GROUP:
-      const nestedEmpty = field3.fields.reduce(
-        (acc, subfield) => ({
-          ...acc,
-          [subfield.id]: mapFieldTypeToEmptyValue(subfield)
-        }),
-        {}
-      );
-      return nestedEmpty;
     case FieldType.DIVIDER:
     case FieldType.TEXT:
     case FieldType.TEXTAREA:
@@ -3250,9 +3219,6 @@ var isCheckboxFieldType = (field3) => {
 var isRadioGroupFieldType = (field3) => {
   return field3.config.type === FieldType.RADIO_GROUP;
 };
-var isFieldGroupFieldType = (field3) => {
-  return field3.config.type === FieldType.FIELD_GROUP;
-};
 var isLocationFieldType = (field3) => {
   return field3.config.type === FieldType.LOCATION;
 };
@@ -3312,9 +3278,9 @@ var ajv = new import__.default({
   strict: false
   // Allow minContains and other newer features
 });
-var DataContext = import_zod27.z.object({
-  rootData: import_zod27.z.object({
-    $leafAdminStructureLocationIds: import_zod27.z.array(import_zod27.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) {
@@ -3601,17 +3567,15 @@ function runStructuralValidations({
   return fieldValidationResult;
 }
 function runFieldValidations({
-  field: config,
-  form,
-  value,
+  field: field3,
+  values,
   context
 }) {
-  const field3 = { config, value };
-  if (!isFieldVisible(field3.config, form, context)) {
+  if (!isFieldVisible(field3, values, context) || isFieldEmptyAndNotRequired(field3, values)) {
     return [];
   }
   const conditionalParameters = {
-    $form: form,
+    $form: values,
     $now: (0, import_date_fns.formatISO)(/* @__PURE__ */ new Date(), { representation: "date" }),
     /**
      * In real use cases, there can be hundreds of thousands of locations.
@@ -3624,33 +3588,12 @@ function runFieldValidations({
     $online: isOnline(),
     $user: context.user
   };
-  if (isFieldGroupFieldType(field3)) {
-    const subfieldErrors = buildFormState(
-      field3.config.fields,
-      (subfield) => runFieldValidations({
-        field: subfield,
-        value: field3.value[subfield.id],
-        form,
-        context
-      })
-    );
-    if (flattenFormState(subfieldErrors).length !== 0) {
-      return subfieldErrors;
-    }
-    return runCustomFieldValidations({
-      field: field3.config,
-      conditionalParameters
-    });
-  }
-  if (isFieldEmptyAndNotRequired(field3.config, form)) {
-    return [];
-  }
   const fieldValidationResult = validateFieldInput({
-    field: field3.config,
-    value
+    field: field3,
+    value: values[field3.id]
   });
   const customValidationResults = runCustomFieldValidations({
-    field: field3.config,
+    field: field3,
     conditionalParameters
   });
   return [...fieldValidationResult, ...customValidationResults];
@@ -3705,7 +3648,7 @@ function areCertificateConditionsMet(conditions, values) {
 }
 
 // ../commons/src/utils.ts
-var z28 = __toESM(require("zod"));
+var z27 = __toESM(require("zod"));
 var _ = __toESM(require("lodash"));
 function getOrThrow(x, message) {
   if (x === void 0 || x === null) {
@@ -3716,11 +3659,11 @@ function getOrThrow(x, message) {
 function joinValues(values, separator = " ") {
   return values.filter((value) => !!value).join(separator).trim();
 }
-var FullNameV1 = z28.array(
-  z28.object({
-    use: z28.string(),
-    family: z28.string(),
-    given: z28.array(z28.string())
+var FullNameV1 = z27.array(
+  z27.object({
+    use: z27.string(),
+    family: z27.string(),
+    given: z27.array(z27.string())
   })
 );
 function omitKeyDeep(obj, keyToRemove) {
@@ -3909,50 +3852,6 @@ function findLastAssignmentAction(actions) {
     ({ type }) => type === ActionType.ASSIGN || type === ActionType.UNASSIGN
   ).reduce((latestAction, action) => !latestAction || action.createdAt > latestAction.createdAt ? action : latestAction, void 0);
 }
-function buildFormState(fields, mapper) {
-  return fields.reduce(
-    (acc, field3) => {
-      if (field3.type === FieldType.FIELD_GROUP) {
-        acc[field3.id] = buildFormState(field3.fields, mapper);
-        return acc;
-      }
-      const mappedValue = mapper(field3);
-      if (mappedValue) {
-        acc[field3.id] = mappedValue;
-      }
-      return acc;
-    },
-    {}
-  );
-}
-function mapFormState(state, fn) {
-  return Object.entries(state).reduce(
-    (mappedState, [key, value]) => {
-      if (!value) {
-        return mappedState;
-      }
-      if (Array.isArray(value)) {
-        mappedState[key] = fn(value);
-        return mappedState;
-      }
-      mappedState[key] = mapFormState(value, fn);
-      return mappedState;
-    },
-    {}
-  );
-}
-function flattenFormState(state, path = []) {
-  if (Array.isArray(state)) {
-    if (state.length === 0) {
-      return [];
-    }
-    return [[path, state]];
-  }
-  return Object.entries(state).filter((e) => e[1] !== void 0).flatMap((e) => flattenFormState(e[1], [...path, e[0]]));
-}
-function flattenFieldReference(ref) {
-  return [ref.$$field, ...ref.$$subfield];
-}
 function isWriteAction(actionType) {
   return writeActions.safeParse(actionType).success;
 }
@@ -4686,12 +4585,12 @@ function createFieldConditionals(fieldId) {
 }
 
 // ../commons/src/events/EventConfig.ts
-(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod28.z);
-var EventFieldReference = import_zod28.z.object({ $$event: EventMetadataDateFieldIdInput }).describe(
+(0, import_zod_openapi10.extendZodWithOpenApi)(import_zod27.z);
+var EventFieldReference = import_zod27.z.object({ $$event: EventMetadataDateFieldIdInput }).describe(
   "Reference to a field defined in the event metadata, using the field id."
 );
-var EventConfig = import_zod28.z.object({
-  id: import_zod28.z.string().describe(
+var EventConfig = import_zod27.z.object({
+  id: import_zod27.z.string().describe(
     'Machine-readable identifier of the event (e.g. "birth", "death").'
   ),
   dateOfEvent: FieldReference.or(EventFieldReference).optional().describe(
@@ -4709,13 +4608,13 @@ var EventConfig = import_zod28.z.object({
   label: TranslationConfig.describe(
     "Human-readable label for the event type."
   ),
-  actions: import_zod28.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_zod28.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) => {
@@ -4780,7 +4679,7 @@ var definePage = (page) => PageConfig.parse(page);
 var defineFormPage = (formPage) => FormPageConfig.parse(formPage);
 
 // ../commons/src/events/WorkqueueConfig.ts
-var import_zod32 = require("zod");
+var import_zod31 = require("zod");
 
 // ../commons/src/searchConfigs.ts
 function createSearchConfig(baseField) {
@@ -4981,17 +4880,17 @@ var event = Object.assign(eventFn, {
 });
 
 // ../commons/src/events/WorkqueueColumnConfig.ts
-var import_zod29 = require("zod");
+var import_zod28 = require("zod");
 var WorkqueueColumnKeysArray = [
   ...EventMetadataKeysArray,
   "title",
   "outbox"
 ];
-var WorkqueueColumnKeys = import_zod29.z.enum(WorkqueueColumnKeysArray);
-var WorkqueueColumnValue = import_zod29.z.object({
+var WorkqueueColumnKeys = import_zod28.z.enum(WorkqueueColumnKeysArray);
+var WorkqueueColumnValue = import_zod28.z.object({
   $event: WorkqueueColumnKeys
 });
-var WorkqueueColumn = import_zod29.z.object({
+var WorkqueueColumn = import_zod28.z.object({
   label: TranslationConfig,
   value: WorkqueueColumnValue
 });
@@ -5002,57 +4901,57 @@ function defineWorkqueuesColumns(workqueueColumns) {
 }
 
 // ../commons/src/events/CountryConfigQueryInput.ts
-var import_zod30 = require("zod");
-var SerializableExact = import_zod30.z.object({
-  type: import_zod30.z.literal("exact"),
-  term: import_zod30.z.union([import_zod30.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_zod30.z.object({
-  type: import_zod30.z.literal("within"),
-  location: import_zod30.z.union([import_zod30.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_zod30.z.object({
-  eventType: import_zod30.z.string(),
-  status: import_zod30.z.optional(import_zod30.z.union([AnyOfStatus, ExactStatus])),
-  createdAt: import_zod30.z.optional(DateCondition),
-  updatedAt: import_zod30.z.optional(DateCondition),
-  "legalStatuses.REGISTERED.createdAt": import_zod30.z.optional(DateCondition),
-  "legalStatuses.REGISTERED.createdAtLocation": import_zod30.z.optional(
-    import_zod30.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_zod30.z.optional(Exact),
-  createdAtLocation: import_zod30.z.optional(
-    import_zod30.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_zod30.z.optional(
-    import_zod30.z.union([SerializableWithin, SerializableExact])
+  updatedAtLocation: import_zod29.z.optional(
+    import_zod29.z.union([SerializableWithin, SerializableExact])
   ),
-  assignedTo: import_zod30.z.optional(SerializableExact),
-  createdBy: import_zod30.z.optional(SerializableExact),
+  assignedTo: import_zod29.z.optional(SerializableExact),
+  createdBy: import_zod29.z.optional(SerializableExact),
   createdByUserType: ExactUserType,
-  updatedBy: import_zod30.z.optional(SerializableExact),
-  trackingId: import_zod30.z.optional(Exact),
-  flags: import_zod30.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_zod30.z.object({
-  type: import_zod30.z.literal("or"),
-  clauses: import_zod30.z.array(SerializedQueryExpression)
+var Or2 = import_zod29.z.object({
+  type: import_zod29.z.literal("or"),
+  clauses: import_zod29.z.array(SerializedQueryExpression)
 });
-var And2 = import_zod30.z.object({
-  type: import_zod30.z.literal("and"),
-  clauses: import_zod30.z.array(SerializedQueryExpression)
+var And2 = import_zod29.z.object({
+  type: import_zod29.z.literal("and"),
+  clauses: import_zod29.z.array(SerializedQueryExpression)
 });
-var CountryConfigQueryType = import_zod30.z.discriminatedUnion("type", [And2, Or2]);
-var CountryConfigQueryInputType = import_zod30.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_zod31 = require("zod");
-var AvailableIcons = import_zod31.z.enum([
+var import_zod30 = require("zod");
+var AvailableIcons = import_zod30.z.enum([
   "Archived",
   "Assigned",
   "Certified",
@@ -5173,23 +5072,23 @@ var mandatoryColumns = defineWorkqueuesColumns([
     value: event.field("updatedAt")
   }
 ]);
-var WorkqueueActionsWithDefault = import_zod32.z.enum([
+var WorkqueueActionsWithDefault = import_zod31.z.enum([
   ...workqueueActions.options,
   "DEFAULT"
 ]);
-var WorkqueueConfig = import_zod32.z.object({
-  slug: import_zod32.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_zod32.z.array(
-    import_zod32.z.object({
+  actions: import_zod31.z.array(
+    import_zod31.z.object({
       type: WorkqueueActionsWithDefault,
-      conditionals: import_zod32.z.array(Conditional).optional()
+      conditionals: import_zod31.z.array(Conditional).optional()
     })
   ),
-  columns: import_zod32.z.array(WorkqueueColumn).default(mandatoryColumns),
+  columns: import_zod31.z.array(WorkqueueColumn).default(mandatoryColumns),
   icon: AvailableIcons,
   emptyMessage: TranslationConfig.optional()
 }).describe("Configuration for workqueue.");
@@ -5197,19 +5096,19 @@ var WorkqueueConfigWithoutQuery = WorkqueueConfig.omit({
   query: true,
   columns: true
 });
-var WorkqueueConfigInput = import_zod32.z.object({
-  slug: import_zod32.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_zod32.z.array(
-    import_zod32.z.object({
+  actions: import_zod31.z.array(
+    import_zod31.z.object({
       type: WorkqueueActionsWithDefault,
-      conditionals: import_zod32.z.array(Conditional).optional()
+      conditionals: import_zod31.z.array(Conditional).optional()
     })
   ),
-  columns: import_zod32.z.array(WorkqueueColumn).default(mandatoryColumns),
+  columns: import_zod31.z.array(WorkqueueColumn).default(mandatoryColumns),
   icon: AvailableIcons,
   emptyMessage: TranslationConfig.optional()
 });
@@ -5221,10 +5120,10 @@ function defineWorkqueue(workqueueInput) {
 function defineWorkqueues(workqueues) {
   return workqueues.map((workqueue) => defineWorkqueue(workqueue));
 }
-var WorkqueueCountInput = import_zod32.z.array(
-  import_zod32.z.object({ slug: import_zod32.z.string(), query: QueryType })
+var WorkqueueCountInput = import_zod31.z.array(
+  import_zod31.z.object({ slug: import_zod31.z.string(), query: QueryType })
 );
-var WorkqueueCountOutput = import_zod32.z.record(import_zod32.z.string(), import_zod32.z.number());
+var WorkqueueCountOutput = import_zod31.z.record(import_zod31.z.string(), import_zod31.z.number());
 
 // ../commons/src/events/workqueueDefaultColumns.ts
 var defaultWorkqueueColumns = [
@@ -5247,45 +5146,45 @@ var defaultWorkqueueColumns = [
 ];
 
 // ../commons/src/events/Draft.ts
-var import_zod34 = require("zod");
+var import_zod33 = require("zod");
 
 // ../commons/src/events/ActionInput.ts
-var import_zod33 = require("zod");
+var import_zod32 = require("zod");
 var import_zod_openapi11 = require("zod-openapi");
-(0, import_zod_openapi11.extendZodWithOpenApi)(import_zod33.z);
-var BaseActionInput = import_zod33.z.object({
+(0, import_zod_openapi11.extendZodWithOpenApi)(import_zod32.z);
+var BaseActionInput = import_zod32.z.object({
   eventId: UUID,
-  transactionId: import_zod33.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_zod33.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_zod33.z.object({
-    type: import_zod33.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_zod33.z.object({
-    type: import_zod33.z.literal(ActionType.REGISTER).default(ActionType.REGISTER),
-    registrationNumber: import_zod33.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_zod33.z.object({
-    type: import_zod33.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_zod33.z.object({
-    type: import_zod33.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.NOTIFY).default(ActionType.NOTIFY)
   })
 ).openapi({
   default: {
@@ -5297,86 +5196,86 @@ var NotifyActionInput = BaseActionInput.merge(
   }
 });
 var DeclareActionInput = BaseActionInput.merge(
-  import_zod33.z.object({
-    type: import_zod33.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_zod33.z.object({
-    type: import_zod33.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_zod33.z.object({
-    type: import_zod33.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_zod33.z.object({
-    type: import_zod33.z.literal(ActionType.DUPLICATE_DETECTED).default(ActionType.DUPLICATE_DETECTED),
-    content: import_zod33.z.object({
-      duplicates: import_zod33.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_zod33.z.object({
-    type: import_zod33.z.literal(ActionType.MARK_AS_DUPLICATE).default(ActionType.MARK_AS_DUPLICATE),
-    content: import_zod33.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_zod33.z.object({
-    type: import_zod33.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_zod33.z.object({
-    type: import_zod33.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_zod33.z.object({
-    type: import_zod33.z.literal(ActionType.ASSIGN),
-    assignedTo: import_zod33.z.string()
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.ASSIGN),
+    assignedTo: import_zod32.z.string()
   })
 );
 var UnassignActionInput = BaseActionInput.merge(
-  import_zod33.z.object({
-    type: import_zod33.z.literal(ActionType.UNASSIGN).default(ActionType.UNASSIGN),
-    assignedTo: import_zod33.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_zod33.z.object({
-    type: import_zod33.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_zod33.z.object({
-    requestId: import_zod33.z.string(),
-    type: import_zod33.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_zod33.z.object({
-    requestId: import_zod33.z.string(),
-    type: import_zod33.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_zod33.z.object({
-    type: import_zod33.z.literal(ActionType.READ).default(ActionType.READ)
+  import_zod32.z.object({
+    type: import_zod32.z.literal(ActionType.READ).default(ActionType.READ)
   })
 );
-var DeleteActionInput = import_zod33.z.object({ eventId: UUID });
-var ActionInput = import_zod33.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" }),
@@ -5411,11 +5310,11 @@ var ActionInput = import_zod33.z.discriminatedUnion("type", [
 });
 
 // ../commons/src/events/Draft.ts
-var Draft = import_zod34.z.object({
+var Draft = import_zod33.z.object({
   id: UUID,
   eventId: UUID,
-  transactionId: import_zod34.z.string(),
-  createdAt: import_zod34.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 })
@@ -5424,7 +5323,7 @@ var Draft = import_zod34.z.object({
 );
 var DraftInput = BaseActionInput.extend({
   type: ActionTypes.exclude([ActionTypes.Enum.DELETE]),
-  status: import_zod34.z.enum([
+  status: import_zod33.z.enum([
     ActionStatus.Requested,
     ActionStatus.Accepted,
     ActionStatus.Rejected
@@ -5432,26 +5331,26 @@ var DraftInput = BaseActionInput.extend({
 });
 
 // ../commons/src/events/EventInput.ts
-var import_zod35 = require("zod");
+var import_zod34 = require("zod");
 var import_uuid10 = require("uuid");
-var EventInput = import_zod35.z.object({
-  transactionId: import_zod35.z.string(),
-  type: import_zod35.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_zod36 = require("zod");
+var import_zod35 = require("zod");
 var import_zod_openapi12 = require("zod-openapi");
-(0, import_zod_openapi12.extendZodWithOpenApi)(import_zod36.z);
-var EventDocument = import_zod36.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_zod36.z.string().describe("Type of the event (e.g. birth, death, marriage)."),
-  createdAt: import_zod36.z.string().datetime().describe("Timestamp indicating when the event was created."),
-  updatedAt: import_zod36.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_zod36.z.array(Action).describe("Ordered list of actions associated with the event."),
-  trackingId: import_zod36.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" });
@@ -8341,9 +8240,9 @@ var digitalIdentityEvent = defineConfig({
 });
 
 // ../commons/src/events/test.utils.ts
-var import_zod37 = require("zod");
+var import_zod36 = require("zod");
 var TEST_SYSTEM_IANA_TIMEZONE = "Asia/Dhaka";
-var TestUserRole = import_zod37.z.enum([
+var TestUserRole = import_zod36.z.enum([
   "FIELD_AGENT",
   "LOCAL_REGISTRAR",
   "LOCAL_SYSTEM_ADMIN",
@@ -8413,19 +8312,6 @@ function generateRandomSignature(rng) {
 }
 function mapFieldTypeToMockValue(field3, i, rng) {
   switch (field3.type) {
-    case FieldType.FIELD_GROUP:
-      const nestedValue = field3.fields.reduce(
-        (acc, subfield, index) => ({
-          ...acc,
-          [subfield.id]: mapFieldTypeToMockValue(
-            subfield,
-            i * 1e3 + index,
-            rng
-          )
-        }),
-        {}
-      );
-      return nestedValue;
     case FieldType.DIVIDER:
     case FieldType.TEXT:
     case FieldType.TEXTAREA:
@@ -9401,16 +9287,16 @@ function getFilePathsFromEvent(event2) {
 }
 
 // ../commons/src/events/locations.ts
-var import_zod38 = require("zod");
-var LocationType = import_zod38.z.enum([
+var import_zod37 = require("zod");
+var LocationType = import_zod37.z.enum([
   "ADMIN_STRUCTURE",
   "CRVS_OFFICE",
   "HEALTH_FACILITY"
 ]);
-var Location = import_zod38.z.object({
+var Location = import_zod37.z.object({
   id: UUID,
-  name: import_zod38.z.string(),
+  name: import_zod37.z.string(),
   parentId: UUID.nullable(),
-  validUntil: import_zod38.z.string().datetime().nullable(),
+  validUntil: import_zod37.z.string().datetime().nullable(),
   locationType: LocationType.nullable()
 });