@opencrvs/toolkit 1.8.1-rc.6c27961 → 1.8.1-rc.6eacccb

package/dist/events/index.js

@@ -40,6 +40,7 @@ __export(events_exports, {
   ActionConfigBase: () => ActionConfigBase,
   ActionCreationMetadata: () => ActionCreationMetadata,
   ActionDocument: () => ActionDocument,
+  ActionFlag: () => ActionFlag,
   ActionFormConfig: () => ActionFormConfig,
   ActionInput: () => ActionInput,
   ActionStatus: () => ActionStatus,
@@ -95,6 +96,7 @@ __export(events_exports, {
   EventDocument: () => EventDocument,
   EventFieldConfigSchema: () => EventFieldConfigSchema,
   EventFieldId: () => EventFieldId,
+  EventFieldIdInput: () => EventFieldIdInput,
   EventIndex: () => EventIndex,
   EventInput: () => EventInput,
   EventMetadata: () => EventMetadata,
@@ -129,8 +131,10 @@ __export(events_exports, {
   InherentFlags: () => InherentFlags,
   LanguageConfig: () => LanguageConfig,
   LegalStatuses: () => LegalStatuses,
+  METADATA_FIELD_PREFIX: () => METADATA_FIELD_PREFIX,
   MarkedAsDuplicateActionInput: () => MarkedAsDuplicateActionInput,
   MimeType: () => MimeType,
+  NameConfig: () => NameConfig,
   NameFieldUpdateValue: () => NameFieldUpdateValue,
   NameFieldValue: () => NameFieldValue,
   NonEmptyTextValue: () => NonEmptyTextValue,
@@ -168,6 +172,7 @@ __export(events_exports, {
   TENNIS_CLUB_MEMBERSHIP: () => TENNIS_CLUB_MEMBERSHIP,
   TEST_SYSTEM_IANA_TIMEZONE: () => TEST_SYSTEM_IANA_TIMEZONE,
   TestUserRole: () => TestUserRole,
+  TextField: () => TextField,
   TextValue: () => TextValue,
   TimeValue: () => TimeValue,
   TranslationConfig: () => TranslationConfig,
@@ -179,7 +184,6 @@ __export(events_exports, {
   ValidationConfig: () => ValidationConfig,
   VerificationActionConfig: () => VerificationActionConfig,
   VerificationPageConfig: () => VerificationPageConfig,
-  VisibleStatus: () => VisibleStatus,
   WRITE_ACTION_SCOPES: () => WRITE_ACTION_SCOPES,
   Within: () => Within,
   WorkqueueActionsWithDefault: () => WorkqueueActionsWithDefault,
@@ -198,6 +202,7 @@ __export(events_exports, {
   annotationActions: () => annotationActions,
   applyDeclarationToEventIndex: () => applyDeclarationToEventIndex,
   applyDraftsToEventIndex: () => applyDraftsToEventIndex,
+  areCertificateConditionsMet: () => areCertificateConditionsMet,
   areConditionsMet: () => areConditionsMet,
   compositeFieldTypes: () => compositeFieldTypes,
   createEmptyDraft: () => createEmptyDraft,
@@ -321,6 +326,7 @@ __export(events_exports, {
   or: () => or,
   resolveDateOfEvent: () => resolveDateOfEvent,
   runFieldValidations: () => runFieldValidations,
+  runStructuralValidations: () => runStructuralValidations,
   timePeriodToDateRange: () => timePeriodToDateRange,
   user: () => user,
   validate: () => validate,
@@ -335,7 +341,7 @@ var TENNIS_CLUB_MEMBERSHIP = "tennis-club-membership";
 var BIRTH_EVENT = "v2-birth";
 
 // ../commons/src/events/ActionConfig.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 
 // ../commons/src/events/Conditional.ts
 var import_zod = require("zod");
@@ -555,7 +561,7 @@ var import_zod6 = require("zod");
 var import_zod4 = require("zod");
 var import_zod_openapi3 = require("zod-openapi");
 (0, import_zod_openapi3.extendZodWithOpenApi)(import_zod4.z);
-var FullDocumentURL = import_zod4.z.string().brand("FullDocumentURL").describe(
+var FullDocumentUrl = import_zod4.z.string().brand("FullDocumentUrl").describe(
   "A full url with protocol, host, bucket name, starting from the root of the S3 server, https://minio/bucket-name/document-id.jpg"
 );
 var FullDocumentPath = import_zod4.z.string().transform((val) => val.startsWith("/") ? val : `/${val}`).openapi({ effectType: "input", type: "string" }).describe(
@@ -607,13 +613,13 @@ var UrbanAddressUpdateValue = AdminStructure.extend({
   zipCode: import_zod5.z.string().nullish()
 });
 var NameFieldValue = import_zod5.z.object({
-  firstname: import_zod5.z.string().min(1),
-  surname: import_zod5.z.string().min(1),
+  firstname: import_zod5.z.string(),
+  surname: import_zod5.z.string(),
   middlename: import_zod5.z.string().optional()
 });
 var NameFieldUpdateValue = import_zod5.z.object({
-  firstname: import_zod5.z.string().nullish(),
-  surname: import_zod5.z.string().nullish(),
+  firstname: import_zod5.z.string(),
+  surname: import_zod5.z.string(),
   middlename: import_zod5.z.string().nullish()
 }).or(import_zod5.z.null()).or(import_zod5.z.undefined());
 var RuralAddressUpdateValue = AdminStructure.extend({
@@ -910,18 +916,32 @@ var SelectDateRangeField = BaseField.extend({
   defaultValue: SelectDateRangeValue.optional(),
   options: import_zod7.z.array(SelectDateRangeOption).describe("A list of options")
 }).describe("Select input with date range options");
+var NameConfig = import_zod7.z.object({
+  firstname: import_zod7.z.object({ required: import_zod7.z.boolean() }).optional(),
+  middlename: import_zod7.z.object({ required: import_zod7.z.boolean() }).optional(),
+  surname: import_zod7.z.object({ required: import_zod7.z.boolean() }).optional()
+});
 var NameField = BaseField.extend({
   type: import_zod7.z.literal(FieldType.NAME),
   defaultValue: import_zod7.z.object({
-    firstname: NonEmptyTextValue,
-    surname: NonEmptyTextValue
+    firstname: NonEmptyTextValue.optional(),
+    middlename: NonEmptyTextValue.optional(),
+    surname: NonEmptyTextValue.optional()
   }).optional(),
   configuration: import_zod7.z.object({
+    name: NameConfig.default({
+      firstname: { required: true },
+      surname: { required: true }
+    }).optional(),
     maxLength: import_zod7.z.number().optional().describe("Maximum length of the text"),
     prefix: TranslationConfig.optional(),
     postfix: TranslationConfig.optional(),
-    includeMiddlename: import_zod7.z.boolean().default(false).optional().describe("To make middle name visible in Name form field"),
     searchMode: import_zod7.z.boolean().optional()
+  }).default({
+    name: {
+      firstname: { required: true },
+      surname: { required: true }
+    }
   }).optional()
 }).describe("Name input field");
 var PhoneField = BaseField.extend({
@@ -1094,91 +1114,168 @@ var ActionFormConfig = import_zod9.z.object({
 });
 var FormConfig = import_zod9.z.union([DeclarationFormConfig, ActionFormConfig]);
 
-// ../commons/src/events/ActionConfig.ts
+// ../commons/src/events/DeduplicationConfig.ts
+var import_zod10 = require("zod");
 var import_zod_openapi6 = require("zod-openapi");
 (0, import_zod_openapi6.extendZodWithOpenApi)(import_zod10.z);
-var ActionConditional2 = import_zod10.z.discriminatedUnion("type", [
+var FieldReference2 = import_zod10.z.string();
+var Matcher = import_zod10.z.object({
+  /**
+   * The reference to the field to match against.
+   *
+   * For `dateDistance` type matcher the value of this field will
+   * be used as the origin date to calculate the distance from.
+   */
+  fieldId: FieldReference2,
+  options: import_zod10.z.object({
+    boost: import_zod10.z.number().optional()
+  }).optional().default({
+    boost: 1
+  })
+});
+var FuzzyMatcher = Matcher.extend({
+  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_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({
+    fuzziness: "AUTO:4,7",
+    boost: 1
+  })
+});
+var StrictMatcher = Matcher.extend({
+  type: import_zod10.z.literal("strict"),
+  options: import_zod10.z.object({
+    boost: import_zod10.z.number().optional().default(1)
+  }).optional().default({
+    boost: 1
+  })
+});
+var DateDistanceMatcher = Matcher.extend({
+  type: import_zod10.z.literal("dateDistance"),
+  options: import_zod10.z.object({
+    days: import_zod10.z.number(),
+    boost: import_zod10.z.number().optional().default(1)
+  })
+});
+var And = import_zod10.z.object({
+  type: import_zod10.z.literal("and"),
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  clauses: import_zod10.z.lazy(() => Clause.array())
+});
+var Or = import_zod10.z.object({
+  type: import_zod10.z.literal("or"),
+  // eslint-disable-next-line @typescript-eslint/no-use-before-define
+  clauses: import_zod10.z.lazy(() => Clause.array())
+});
+var Clause = import_zod10.z.lazy(
+  () => import_zod10.z.discriminatedUnion("type", [
+    And,
+    Or,
+    FuzzyMatcher,
+    StrictMatcher,
+    DateDistanceMatcher
+  ])
+).openapi({
+  ref: "Clause"
+});
+var DeduplicationConfig = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  label: TranslationConfig,
+  query: Clause
+});
+
+// ../commons/src/events/ActionConfig.ts
+var import_zod_openapi7 = require("zod-openapi");
+(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod11.z);
+var ActionConditional2 = import_zod11.z.discriminatedUnion("type", [
   /** If conditional is defined, the action is shown to the user only if the condition is met */
   ShowConditional,
   /** If conditional is defined, the action is enabled only if the condition is met */
   EnableConditional
 ]);
-var DeclarationReviewConfig = import_zod10.z.object({
+var DeclarationReviewConfig = import_zod11.z.object({
   title: TranslationConfig.describe("Title of the review page"),
-  fields: import_zod10.z.array(FieldConfig).describe("Fields to be rendered on the review page for annotations.")
+  fields: import_zod11.z.array(FieldConfig).describe("Fields to be rendered on the review page for annotations.")
 }).describe("Configuration for **declaration** review page.");
-var ActionConfigBase = import_zod10.z.object({
+var ActionConfigBase = import_zod11.z.object({
   label: TranslationConfig,
-  conditionals: import_zod10.z.array(ActionConditional2).optional().default([]),
-  draft: import_zod10.z.boolean().optional()
+  conditionals: import_zod11.z.array(ActionConditional2).optional().default([]),
+  deduplication: DeduplicationConfig.optional(),
+  draft: import_zod11.z.boolean().optional()
 });
 var ReadActionConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.READ),
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.READ),
     review: DeclarationReviewConfig
   })
 );
 var DeclareConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.DECLARE),
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.DECLARE),
     review: DeclarationReviewConfig
   })
 );
 var ValidateConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.VALIDATE),
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.VALIDATE),
     review: DeclarationReviewConfig
   })
 );
 var RegisterConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.REGISTER),
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.REGISTER),
     review: DeclarationReviewConfig
   })
 );
 var RejectDeclarationConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.REJECT)
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.REJECT)
   })
 );
 var MarkedAsDuplicateConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.MARKED_AS_DUPLICATE)
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.MARKED_AS_DUPLICATE)
   })
 );
 var ArchiveConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.ARCHIVE)
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.ARCHIVE)
   })
 );
 var DeleteConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.DELETE)
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.DELETE)
   })
 );
 var PrintCertificateActionConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.PRINT_CERTIFICATE),
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.PRINT_CERTIFICATE),
     printForm: ActionFormConfig
   })
 );
 var RequestCorrectionConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.REQUEST_CORRECTION),
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.REQUEST_CORRECTION),
     correctionForm: ActionFormConfig
   })
 );
 var RejectCorrectionConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.REJECT_CORRECTION)
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.REJECT_CORRECTION)
   })
 );
 var ApproveCorrectionConfig = ActionConfigBase.merge(
-  import_zod10.z.object({
-    type: import_zod10.z.literal(ActionType.APPROVE_CORRECTION)
+  import_zod11.z.object({
+    type: import_zod11.z.literal(ActionType.APPROVE_CORRECTION)
   })
 );
-var ActionConfig = import_zod10.z.discriminatedUnion("type", [
+var ActionConfig = import_zod11.z.discriminatedUnion("type", [
   /*
    * OpenAPI references are defined here so our generated OpenAPI spec knows to reuse the models
    * and treat them as "models" instead of duplicating the data structure in each endpoint.
@@ -1198,124 +1295,52 @@ var ActionConfig = import_zod10.z.discriminatedUnion("type", [
   RejectCorrectionConfig.openapi({ ref: "RejectCorrectionActionConfig" }),
   ApproveCorrectionConfig.openapi({ ref: "ApproveCorrectionActionConfig" })
 ]).openapi({ ref: "ActionConfig" });
-var DeclarationActionConfig = import_zod10.z.discriminatedUnion("type", [
+var DeclarationActionConfig = import_zod11.z.discriminatedUnion("type", [
   DeclareConfig,
   ValidateConfig,
   RegisterConfig
 ]);
 
 // ../commons/src/events/offline/CertificateConfig.ts
-var import_zod11 = require("zod");
-var FontFamily = import_zod11.z.object({
-  normal: import_zod11.z.string(),
-  bold: import_zod11.z.string(),
-  italics: import_zod11.z.string(),
-  bolditalics: import_zod11.z.string()
+var import_zod12 = require("zod");
+var FontFamily = import_zod12.z.object({
+  normal: import_zod12.z.string(),
+  bold: import_zod12.z.string(),
+  italics: import_zod12.z.string(),
+  bolditalics: import_zod12.z.string()
 });
-var CertificateConfig = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  event: import_zod11.z.string(),
+var CertificateConfig = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  event: import_zod12.z.string(),
   label: TranslationConfig,
-  isDefault: import_zod11.z.boolean(),
-  fee: import_zod11.z.object({
-    onTime: import_zod11.z.number(),
-    late: import_zod11.z.number(),
-    delayed: import_zod11.z.number()
+  isDefault: import_zod12.z.boolean(),
+  fee: import_zod12.z.object({
+    onTime: import_zod12.z.number(),
+    late: import_zod12.z.number(),
+    delayed: import_zod12.z.number()
   }),
-  svgUrl: import_zod11.z.string(),
-  fonts: import_zod11.z.record(FontFamily).optional()
+  svgUrl: import_zod12.z.string(),
+  fonts: import_zod12.z.record(FontFamily).optional(),
+  conditionals: import_zod12.z.array(ShowConditional).optional()
 });
 var CertificateTemplateConfig = CertificateConfig.extend({
-  hash: import_zod11.z.string().optional(),
-  svg: import_zod11.z.string()
+  hash: import_zod12.z.string().optional(),
+  svg: import_zod12.z.string()
 });
 
 // ../commons/src/events/offline/LanguageConfig.ts
-var import_zod12 = require("zod");
-var LanguageConfig = import_zod12.z.object({
-  lang: import_zod12.z.string(),
+var import_zod13 = require("zod");
+var LanguageConfig = import_zod13.z.object({
+  lang: import_zod13.z.string(),
   /**
    * client.csv contents
    */
-  messages: import_zod12.z.record(import_zod12.z.string())
+  messages: import_zod13.z.record(import_zod13.z.string())
 });
 
 // ../commons/src/events/EventConfig.ts
 var import_zod21 = require("zod");
 
-// ../commons/src/events/DeduplicationConfig.ts
-var import_zod13 = require("zod");
-var import_zod_openapi7 = require("zod-openapi");
-(0, import_zod_openapi7.extendZodWithOpenApi)(import_zod13.z);
-var FieldReference2 = import_zod13.z.string();
-var Matcher = import_zod13.z.object({
-  fieldId: import_zod13.z.string(),
-  options: import_zod13.z.object({
-    boost: import_zod13.z.number().optional()
-  }).optional().default({})
-});
-var FuzzyMatcher = Matcher.extend({
-  type: import_zod13.z.literal("fuzzy"),
-  options: import_zod13.z.object({
-    /**
-     * Names of length 3 or less characters = 0 edits allowed
-     * Names of length 4 - 6 characters = 1 edit allowed
-     * Names of length >7 characters = 2 edits allowed
-     */
-    fuzziness: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).optional().default("AUTO:4,7"),
-    boost: import_zod13.z.number().optional().default(1)
-  }).optional().default({})
-});
-var StrictMatcher = Matcher.extend({
-  type: import_zod13.z.literal("strict"),
-  options: import_zod13.z.object({
-    boost: import_zod13.z.number().optional().default(1)
-  }).optional().default({})
-});
-var DateRangeMatcher = Matcher.extend({
-  type: import_zod13.z.literal("dateRange"),
-  options: import_zod13.z.object({
-    days: import_zod13.z.number(),
-    origin: FieldReference2,
-    boost: import_zod13.z.number().optional().default(1)
-  })
-});
-var DateDistanceMatcher = Matcher.extend({
-  type: import_zod13.z.literal("dateDistance"),
-  options: import_zod13.z.object({
-    days: import_zod13.z.number(),
-    origin: FieldReference2,
-    boost: import_zod13.z.number().optional().default(1)
-  })
-});
-var And = import_zod13.z.object({
-  type: import_zod13.z.literal("and"),
-  // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clauses: import_zod13.z.lazy(() => Clause.array())
-});
-var Or = import_zod13.z.object({
-  type: import_zod13.z.literal("or"),
-  // eslint-disable-next-line @typescript-eslint/no-use-before-define
-  clauses: import_zod13.z.lazy(() => Clause.array())
-});
-var Clause = import_zod13.z.lazy(
-  () => import_zod13.z.discriminatedUnion("type", [
-    And,
-    Or,
-    FuzzyMatcher,
-    StrictMatcher,
-    DateRangeMatcher,
-    DateDistanceMatcher
-  ])
-).openapi({
-  ref: "Clause"
-});
-var DeduplicationConfig = import_zod13.z.object({
-  id: import_zod13.z.string(),
-  label: TranslationConfig,
-  query: Clause
-});
-
 // ../commons/src/events/SummaryConfig.ts
 var import_zod14 = require("zod");
 var BaseField2 = import_zod14.z.object({
@@ -1395,22 +1420,30 @@ var FieldConfigSchema = BaseField3.extend({
   fieldType: import_zod15.z.literal("field"),
   alternateFieldIds: import_zod15.z.array(import_zod15.z.string()).optional().describe(
     `Sometimes there might be need to search a value against multiple field of same FormField type. For example
-      search Country, Province, District against child.address.private and child.address.other. In such case, we 
+      search Country, Province, District against child.address.private and child.address.other. In such case, we
       add a one field as fieldId, and accomodate others in alternateFieldIds`
   ),
-  excludeInSearchQuery: import_zod15.z.boolean().default(false).optional().describe(`Sometimes there will be search fields which are used to 
-    conditionally display another search field, but its not needed in search query. For example, child.placeOfBirth 
+  excludeInSearchQuery: import_zod15.z.boolean().default(false).optional().describe(`Sometimes there will be search fields which are used to
+    conditionally display another search field, but its not needed in search query. For example, child.placeOfBirth
     is select field, which has 3 options, FACILITY, PRIVATE_HOME, OTHER. Upon selecting any of the option, pops up another field
     related to the selected option, whose value is required in the search query. But child.placeOfBirth itself is not needed in the query.
     In such case, populate this field (excludeInSearchQuery) with boolean true`)
 });
-var EventFieldId = import_zod15.z.enum([
+var EventFieldIdInput = import_zod15.z.enum([
   "trackingId",
   "status",
   "legalStatuses.REGISTERED.acceptedAt",
   "legalStatuses.REGISTERED.createdAtLocation",
   "updatedAt"
 ]);
+var METADATA_FIELD_PREFIX = "event.";
+var EventFieldId = import_zod15.z.enum([
+  `${METADATA_FIELD_PREFIX}trackingId`,
+  `${METADATA_FIELD_PREFIX}status`,
+  `${METADATA_FIELD_PREFIX}legalStatuses.REGISTERED.acceptedAt`,
+  `${METADATA_FIELD_PREFIX}legalStatuses.REGISTERED.createdAtLocation`,
+  `${METADATA_FIELD_PREFIX}updatedAt`
+]);
 var EventFieldConfigSchema = BaseField3.extend({
   fieldId: EventFieldId,
   fieldType: import_zod15.z.literal("event")
@@ -2045,7 +2078,7 @@ var ResolvedUser = import_zod19.z.object({
 });
 
 // ../commons/src/conditionals/validate.ts
-var import_ajv = __toESM(require("ajv"));
+var import__ = __toESM(require("ajv/dist/2019"));
 var import_ajv_formats = __toESM(require("ajv-formats"));
 var import_date_fns = require("date-fns");
 
@@ -2259,9 +2292,11 @@ var isNonInteractiveFieldType = (field2) => {
 };
 
 // ../commons/src/conditionals/validate.ts
-var ajv = new import_ajv.default({
+var ajv = new import__.default({
   $data: true,
-  allowUnionTypes: true
+  allowUnionTypes: true,
+  strict: false
+  // Allow minContains and other newer features
 });
 (0, import_ajv_formats.default)(ajv);
 ajv.addKeyword({
@@ -2434,6 +2469,23 @@ function validateFieldInput({
   const rawError = zodType.safeParse(value, { errorMap: zodToIntlErrorMap });
   return rawError.error?.issues.map((issue) => issue.message) ?? [];
 }
+function runStructuralValidations({
+  field: field2,
+  values
+}) {
+  if (!isFieldVisible(field2, values) || isFieldEmptyAndNotRequired(field2, values)) {
+    return {
+      errors: []
+    };
+  }
+  const fieldValidationResult = validateFieldInput({
+    field: field2,
+    value: values[field2.id]
+  });
+  return {
+    errors: fieldValidationResult
+  };
+}
 function runFieldValidations({
   field: field2,
   values
@@ -2499,6 +2551,11 @@ function getValidatorsForField(fieldId, validations) {
     };
   }).filter((x) => x !== null);
 }
+function areCertificateConditionsMet(conditions, values) {
+  return conditions.every((condition) => {
+    return ajv.validate(condition.conditional, values);
+  });
+}
 
 // ../commons/src/utils.ts
 function getOrThrow(x, message) {
@@ -2719,16 +2776,16 @@ function timePeriodToDateRange(value) {
   let startDate;
   switch (value) {
     case "last7Days":
-      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 6);
+      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 7);
       break;
     case "last30Days":
-      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 29);
+      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 30);
       break;
     case "last90Days":
-      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 89);
+      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 90);
       break;
     case "last365Days":
-      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 364);
+      startDate = (0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), 365);
       break;
   }
   return {
@@ -2753,7 +2810,6 @@ var EventConfig = import_zod21.z.object({
   label: TranslationConfig,
   actions: import_zod21.z.array(ActionConfig),
   declaration: DeclarationFormConfig,
-  deduplication: import_zod21.z.array(DeduplicationConfig).optional().default([]),
   advancedSearch: import_zod21.z.array(AdvancedSearchConfig).optional().default([])
 }).superRefine((event2, ctx) => {
   const allFields = findAllFields(event2);
@@ -3095,8 +3151,9 @@ function createFieldConditionals(fieldId) {
       properties: {
         [fieldId]: {
           type: "string",
-          pattern: "^[\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*( [\\p{Script=Latin}0-9'._-]*(\\([\\p{Script=Latin}0-9'._-]+\\))?[\\p{Script=Latin}0-9'._-]*)*$",
-          description: "Name must contain only letters, numbers, and allowed special characters ('._-). No double spaces."
+          minLength: 1,
+          pattern: "^[\\p{Script=Latin}0-9'.-]*(\\([\\p{Script=Latin}0-9'.-]+\\))?[\\p{Script=Latin}0-9'.-]*( [\\p{Script=Latin}0-9'.-]*(\\([\\p{Script=Latin}0-9'.-]+\\))?[\\p{Script=Latin}0-9'.-]*)*$",
+          description: "Name must contain only letters, numbers, and allowed special characters ('.-). No double spaces."
         }
       }
     }),
@@ -3209,7 +3266,7 @@ function createSearchConfig(baseField) {
 // ../commons/src/event-config/event-configuration.ts
 function createEventFieldConfig(fieldId) {
   const baseField = {
-    fieldId,
+    fieldId: `${METADATA_FIELD_PREFIX}${fieldId}`,
     fieldType: "event"
   };
   return createSearchConfig(baseField);
@@ -3222,32 +3279,107 @@ function eventFn(fieldId) {
 var event = Object.assign(eventFn, {
   /**
    * Checks if the event contains a specific action type.
+   * Can be used directly as a conditional or chained with additional methods.
    * @param action - The action type to check for.
    */
-  hasAction: (action) => defineConditional({
-    type: "object",
-    properties: {
-      $event: {
+  hasAction: (action) => {
+    const basicConditional = defineConditional({
+      type: "object",
+      properties: {
+        $event: {
+          type: "object",
+          properties: {
+            actions: {
+              type: "array",
+              contains: {
+                type: "object",
+                properties: {
+                  type: {
+                    const: action
+                  }
+                },
+                required: ["type"]
+              }
+            }
+          },
+          required: ["actions"]
+        }
+      },
+      required: ["$event"]
+    });
+    const buildActionConstraints = (additionalFields) => {
+      const actionProperties = {
+        type: { const: action }
+      };
+      const requiredFields = ["type"];
+      if (additionalFields) {
+        Object.entries(additionalFields).forEach(([key, value]) => {
+          actionProperties[key] = { const: value };
+          requiredFields.push(key);
+        });
+      }
+      return { actionProperties, requiredFields };
+    };
+    const createCountConditional = (countType, count, additionalFields) => {
+      const { actionProperties, requiredFields } = buildActionConstraints(additionalFields);
+      return defineConditional({
         type: "object",
         properties: {
-          actions: {
-            type: "array",
-            contains: {
-              type: "object",
-              properties: {
-                type: {
-                  const: action
-                }
-              },
-              required: ["type"]
-            }
+          $event: {
+            type: "object",
+            properties: {
+              actions: {
+                type: "array",
+                contains: {
+                  type: "object",
+                  properties: actionProperties,
+                  required: requiredFields
+                },
+                [countType]: count
+              }
+            },
+            required: ["actions"]
           }
         },
-        required: ["actions"]
-      }
-    },
-    required: ["$event"]
-  }),
+        required: ["$event"]
+      });
+    };
+    const withMinMax = (additionalFields) => {
+      return {
+        /**
+         * Creates a conditional that checks if the event contains a specific action type
+         * with a minimum count of occurrences.
+         *
+         * @param minCount - The minimum number of actions required.
+         */
+        minCount: (minCount) => createCountConditional("minContains", minCount, additionalFields),
+        /**
+         * Builds a conditional that sets a maximum count for the number of actions.
+         * This is useful for limiting the number of actions of a specific type in a single event.
+         */
+        maxCount: (maxCount) => createCountConditional("maxContains", maxCount, additionalFields)
+      };
+    };
+    const chainableMethods = {
+      /**
+       * Adds additional field constraints to the action matching.
+       *
+       * @param fields - Object containing additional fields to match on the action.
+       */
+      withFields: (fields) => withMinMax(fields),
+      /**
+       * Adds template ID constraint to the action matching.
+       * This is a convenience method that adds content.templateId to the fields.
+       *
+       * @param id - The template ID to match against.
+       */
+      withTemplate: (id) => withMinMax({
+        content: { templateId: id }
+      }),
+      ...withMinMax()
+    };
+    return { ...basicConditional, ...chainableMethods };
+  },
   field(field2) {
     return {
       $event: field2
@@ -3266,24 +3398,23 @@ var EventStatus = import_zod23.z.enum([
   "DECLARED",
   "VALIDATED",
   "REGISTERED",
-  "CERTIFIED",
   "ARCHIVED"
 ]);
-var VisibleStatus = import_zod23.z.enum([...EventStatus.options, "REJECTED"]);
 var InherentFlags = {
-  PRINTED: "printed",
+  PENDING_CERTIFICATION: "pending-certification",
   INCOMPLETE: "incomplete",
   REJECTED: "rejected",
   CORRECTION_REQUESTED: "correction-requested"
 };
-var Flag = import_zod23.z.string().regex(
+var ActionFlag = import_zod23.z.string().regex(
   new RegExp(
     `^(${Object.values(ActionType).join("|").toLowerCase()}):(${Object.values(
       ActionStatus
     ).join("|").toLowerCase()})$`
   ),
   "Flag must be in the format ActionType:ActionStatus (lowerCase)"
-).or(import_zod23.z.nativeEnum(InherentFlags));
+);
+var Flag = ActionFlag.or(import_zod23.z.nativeEnum(InherentFlags));
 var ZodDate = import_zod23.z.string().date();
 var ActionCreationMetadata = import_zod23.z.object({
   createdAt: import_zod23.z.string().datetime().describe("The timestamp when the action request was created."),
@@ -3799,7 +3930,8 @@ var WorkqueueConfig = import_zod28.z.object({
     })
   ),
   columns: import_zod28.z.array(WorkqueueColumn).default(mandatoryColumns),
-  icon: AvailableIcons
+  icon: AvailableIcons,
+  emptyMessage: TranslationConfig.optional()
 }).describe("Configuration for workqueue.");
 var WorkqueueConfigWithoutQuery = WorkqueueConfig.omit({
   query: true,
@@ -3818,7 +3950,8 @@ var WorkqueueConfigInput = import_zod28.z.object({
     })
   ),
   columns: import_zod28.z.array(WorkqueueColumn).default(mandatoryColumns),
-  icon: AvailableIcons
+  icon: AvailableIcons,
+  emptyMessage: TranslationConfig.optional()
 });
 function defineWorkqueue(workqueueInput) {
   const queryInput = workqueueInput.query;
@@ -4120,16 +4253,19 @@ function getLegalStatuses(actions) {
 }
 
 // ../commons/src/events/state/flags.ts
-function isCertificatePrinted(actions) {
+function isPendingCertification(actions) {
+  if (getStatusFromActions(actions) !== EventStatus.enum.REGISTERED) {
+    return false;
+  }
   return actions.reduce((prev, { type }) => {
     if (type === ActionType.PRINT_CERTIFICATE) {
-      return true;
+      return false;
     }
     if (type === ActionType.APPROVE_CORRECTION) {
-      return false;
+      return true;
     }
     return prev;
-  }, false);
+  }, true);
 }
 function isCorrectionRequested(actions) {
   return actions.reduce((prev, { type }) => {
@@ -4164,8 +4300,8 @@ function getFlagsFromActions(actions) {
     const flag = joinValues([type, status], ":").toLowerCase();
     return flag;
   });
-  if (isCertificatePrinted(sortedActions)) {
-    flags.push(InherentFlags.PRINTED);
+  if (isPendingCertification(sortedActions)) {
+    flags.push(InherentFlags.PENDING_CERTIFICATION);
   }
   if (isCorrectionRequested(sortedActions)) {
     flags.push(InherentFlags.CORRECTION_REQUESTED);
@@ -4196,7 +4332,6 @@ function getStatusFromActions(actions) {
       case ActionType.NOTIFY:
         return EventStatus.enum.NOTIFIED;
       case ActionType.PRINT_CERTIFICATE:
-        return EventStatus.enum.CERTIFIED;
       case ActionType.ASSIGN:
       case ActionType.UNASSIGN:
       case ActionType.REJECT:
@@ -5161,7 +5296,27 @@ var TENNIS_CLUB_DECLARATION_FORM = defineDeclarationForm({
             defaultMessage: "Applicant's name",
             description: "This is the label for the field",
             id: "v2.event.tennis-club-membership.action.declare.form.section.who.field.firstname.label"
-          }
+          },
+          configuration: {
+            name: {
+              firstname: { required: true },
+              middlename: { required: false },
+              surname: { required: true }
+            }
+          },
+          validation: [
+            {
+              validator: field("applicant.name").object({
+                firstname: field("firstname").isValidEnglishName(),
+                surname: field("surname").isValidEnglishName()
+              }),
+              message: {
+                defaultMessage: "Input contains invalid characters. Please use only letters (a-z, A-Z), numbers (0-9), hyphens (-), apostrophes(') and underscores (_)",
+                description: "This is the error message for invalid name",
+                id: "v2.error.invalidName"
+              }
+            }
+          ]
         },
         {
           id: "applicant.email",
@@ -5383,22 +5538,6 @@ var statusOptions = [
       id: "v2.advancedSearch.form.recordStatusRegistered"
     }
   },
-  {
-    value: EventStatus.enum.CERTIFIED,
-    label: {
-      defaultMessage: "Certified",
-      description: "Option for form field: status of record",
-      id: "v2.advancedSearch.form.recordStatusCertified"
-    }
-  },
-  {
-    value: VisibleStatus.enum.REJECTED,
-    label: {
-      defaultMessage: "Rejected",
-      description: "Option for form field: status of record",
-      id: "v2.advancedSearch.form.recordStatusRejected"
-    }
-  },
   {
     value: EventStatus.enum.ARCHIVED,
     label: {
@@ -6308,33 +6447,24 @@ var child = defineFormPage({
   },
   fields: [
     {
-      id: "child.firstNames",
-      type: FieldType.TEXT,
-      required: true,
-      configuration: { maxLength: 32 },
-      hideLabel: true,
-      label: {
-        defaultMessage: "Child's  first name",
-        description: "This is the label for the field",
-        id: "v2.event.birth.action.declare.form.section.child.field.name.label"
-      }
-    },
-    {
-      id: "child.familyName",
-      type: FieldType.TEXT,
+      id: "child.name",
+      type: FieldType.NAME,
       required: true,
       configuration: { maxLength: 32 },
       hideLabel: true,
       label: {
-        defaultMessage: "Child's last name",
+        defaultMessage: "Child's name",
         description: "This is the label for the field",
         id: "v2.event.birth.action.declare.form.section.child.field.name.label"
-      }
+      },
+      validation: []
     },
     {
-      id: "child.DoB",
+      id: "child.dob",
       type: "DATE",
       required: true,
+      secured: true,
+      validation: [],
       label: {
         defaultMessage: "Date of birth",
         description: "This is the label for the field",
@@ -6353,46 +6483,43 @@ var mother = defineFormPage({
   },
   fields: [
     {
-      id: "mother.firstNames",
-      configuration: { maxLength: 32 },
-      type: FieldType.TEXT,
+      id: "mother.name",
+      type: FieldType.NAME,
       required: true,
-      label: {
-        defaultMessage: "First name(s)",
-        description: "This is the label for the field",
-        id: `v2.event.birth.action.declare.form.section.person.field.firstname.label`
-      }
-    },
-    {
-      id: `mother.familyName`,
       configuration: { maxLength: 32 },
-      type: FieldType.TEXT,
-      required: true,
+      hideLabel: true,
       label: {
-        defaultMessage: "Last name",
+        defaultMessage: "Mother's name",
         description: "This is the label for the field",
-        id: `v2.event.birth.action.declare.form.section.person.field.surname.label`
-      }
+        id: "v2.event.birth.action.declare.form.section.mother.field.name.label"
+      },
+      conditionals: [],
+      validation: []
     },
     {
-      id: `mother.DoB`,
+      id: "mother.dob",
       type: "DATE",
       required: true,
+      secured: true,
+      validation: [],
       label: {
         defaultMessage: "Date of birth",
         description: "This is the label for the field",
-        id: `v2.event.birth.action.declare.form.section.person.field.dob.label`
-      }
+        id: "v2.event.birth.action.declare.form.section.person.field.dob.label"
+      },
+      conditionals: []
     },
     {
-      id: "mother.identifier",
+      id: "mother.nid",
       type: FieldType.ID,
       required: true,
       label: {
         defaultMessage: "ID Number",
         description: "This is the label for the field",
-        id: `v2.event.birth.action.declare.form.section.person.field.nid.label`
-      }
+        id: "v2.event.birth.action.declare.form.section.person.field.nid.label"
+      },
+      conditionals: [],
+      validation: []
     }
   ]
 });
@@ -6850,7 +6977,11 @@ function generateActionDocument({
     case ActionType.NOTIFY:
       return { ...actionBase, type: action };
     case ActionType.PRINT_CERTIFICATE:
-      return { ...actionBase, type: action };
+      return {
+        ...actionBase,
+        type: action,
+        content: defaults.content
+      };
     case ActionType.REQUEST_CORRECTION:
       return { ...actionBase, type: action };
     case ActionType.APPROVE_CORRECTION:
@@ -7250,14 +7381,6 @@ var AVAILABLE_ACTIONS_BY_EVENT_STATUS = {
     ActionType.REJECT_CORRECTION,
     ExclusiveActions.REVIEW_CORRECTION_REQUEST
   ],
-  [EventStatus.enum.CERTIFIED]: [
-    ActionType.READ,
-    ActionType.PRINT_CERTIFICATE,
-    ActionType.REQUEST_CORRECTION,
-    ActionType.APPROVE_CORRECTION,
-    ActionType.REJECT_CORRECTION,
-    ExclusiveActions.REVIEW_CORRECTION_REQUEST
-  ],
   [EventStatus.enum.ARCHIVED]: [
     ActionType.READ,
     ActionType.ASSIGN,
@@ -7265,9 +7388,12 @@ var AVAILABLE_ACTIONS_BY_EVENT_STATUS = {
   ]
 };
 var getAvailableActionsForEvent = (event2) => {
-  return event2.flags.includes(InherentFlags.REJECTED) ? [
-    ActionType.READ,
-    event2.status === EventStatus.Enum.VALIDATED ? ActionType.VALIDATE : ActionType.DECLARE,
-    ActionType.ARCHIVE
-  ] : AVAILABLE_ACTIONS_BY_EVENT_STATUS[event2.status];
+  if (event2.flags.includes(InherentFlags.REJECTED)) {
+    return [
+      ActionType.READ,
+      event2.status === EventStatus.Enum.VALIDATED ? ActionType.VALIDATE : ActionType.DECLARE,
+      ActionType.ARCHIVE
+    ];
+  }
+  return AVAILABLE_ACTIONS_BY_EVENT_STATUS[event2.status];
 };