@opencrvs/toolkit 1.9.8-rc.0cafd28 → 1.9.8-rc.0cf339f

package/dist/commons/events/eventConfigValidation.d.ts

@@ -0,0 +1,8 @@
+import * as z from 'zod/v4';
+import { EventConfig } from './EventConfig';
+export declare function validateAdvancedSearchConfig(event: EventConfig, ctx: z.RefinementCtx<EventConfig>): void;
+export declare function validateDateOfEvent(event: EventConfig, ctx: z.RefinementCtx<EventConfig>): void;
+export declare function validatePlaceOfEvent(event: EventConfig, ctx: z.RefinementCtx<EventConfig>): void;
+export declare function validateActionFlags(event: EventConfig, ctx: z.RefinementCtx<EventConfig>): void;
+export declare function validateActionOrder(event: EventConfig, ctx: z.RefinementCtx<EventConfig>): void;
+//# sourceMappingURL=eventConfigValidation.d.ts.map

package/dist/commons/events/field.d.ts

@@ -124,6 +124,20 @@ export declare function field(fieldId: string, options?: {
             isValidAdministrativeLeafLevel(): import("../conditionals/conditionals").JSONSchema;
             matches(pattern: string): import("../conditionals/conditionals").JSONSchema;
             isBetween(min: number, max: number): import("../conditionals/conditionals").JSONSchema;
+            customClientValidator(fn: (value: unknown, context: {
+                $now: string;
+                $online: boolean;
+            } & {
+                $form: import("./ActionDocument").EventState | Record<string, unknown>;
+            }) => boolean): import("../conditionals/conditionals").JSONSchema;
+            customClientEvaluation(fn: (value: unknown, context: {
+                $now: string;
+                $online: boolean;
+            } & {
+                $form: import("./ActionDocument").EventState | Record<string, unknown>;
+            }) => any): {
+                $$code: string;
+            };
             getId: () => {
                 fieldId: string;
             };
@@ -182,6 +196,20 @@ export declare function field(fieldId: string, options?: {
         isValidAdministrativeLeafLevel(): import("../conditionals/conditionals").JSONSchema;
         matches(pattern: string): import("../conditionals/conditionals").JSONSchema;
         isBetween(min: number, max: number): import("../conditionals/conditionals").JSONSchema;
+        customClientValidator(fn: (value: unknown, context: {
+            $now: string;
+            $online: boolean;
+        } & {
+            $form: import("./ActionDocument").EventState | Record<string, unknown>;
+        }) => boolean): import("../conditionals/conditionals").JSONSchema;
+        customClientEvaluation(fn: (value: unknown, context: {
+            $now: string;
+            $online: boolean;
+        } & {
+            $form: import("./ActionDocument").EventState | Record<string, unknown>;
+        }) => any): {
+            $$code: string;
+        };
         getId: () => {
             fieldId: string;
         };
@@ -248,6 +276,20 @@ export declare function field(fieldId: string, options?: {
             isValidAdministrativeLeafLevel(): import("../conditionals/conditionals").JSONSchema;
             matches(pattern: string): import("../conditionals/conditionals").JSONSchema;
             isBetween(min: number, max: number): import("../conditionals/conditionals").JSONSchema;
+            customClientValidator(fn: (value: unknown, context: {
+                $now: string;
+                $online: boolean;
+            } & {
+                $form: import("./ActionDocument").EventState | Record<string, unknown>;
+            }) => boolean): import("../conditionals/conditionals").JSONSchema;
+            customClientEvaluation(fn: (value: unknown, context: {
+                $now: string;
+                $online: boolean;
+            } & {
+                $form: import("./ActionDocument").EventState | Record<string, unknown>;
+            }) => any): {
+                $$code: string;
+            };
             getId: () => {
                 fieldId: string;
             };
@@ -312,6 +354,20 @@ export declare function field(fieldId: string, options?: {
             isValidAdministrativeLeafLevel(): import("../conditionals/conditionals").JSONSchema;
             matches(pattern: string): import("../conditionals/conditionals").JSONSchema;
             isBetween(min: number, max: number): import("../conditionals/conditionals").JSONSchema;
+            customClientValidator(fn: (value: unknown, context: {
+                $now: string;
+                $online: boolean;
+            } & {
+                $form: import("./ActionDocument").EventState | Record<string, unknown>;
+            }) => boolean): import("../conditionals/conditionals").JSONSchema;
+            customClientEvaluation(fn: (value: unknown, context: {
+                $now: string;
+                $online: boolean;
+            } & {
+                $form: import("./ActionDocument").EventState | Record<string, unknown>;
+            }) => any): {
+                $$code: string;
+            };
             getId: () => {
                 fieldId: string;
             };
@@ -375,6 +431,20 @@ export declare function field(fieldId: string, options?: {
             isValidAdministrativeLeafLevel(): import("../conditionals/conditionals").JSONSchema;
             matches(pattern: string): import("../conditionals/conditionals").JSONSchema;
             isBetween(min: number, max: number): import("../conditionals/conditionals").JSONSchema;
+            customClientValidator(fn: (value: unknown, context: {
+                $now: string;
+                $online: boolean;
+            } & {
+                $form: import("./ActionDocument").EventState | Record<string, unknown>;
+            }) => boolean): import("../conditionals/conditionals").JSONSchema;
+            customClientEvaluation(fn: (value: unknown, context: {
+                $now: string;
+                $online: boolean;
+            } & {
+                $form: import("./ActionDocument").EventState | Record<string, unknown>;
+            }) => any): {
+                $$code: string;
+            };
             getId: () => {
                 fieldId: string;
             };
@@ -431,6 +501,20 @@ export declare function field(fieldId: string, options?: {
         isValidAdministrativeLeafLevel(): import("../conditionals/conditionals").JSONSchema;
         matches(pattern: string): import("../conditionals/conditionals").JSONSchema;
         isBetween(min: number, max: number): import("../conditionals/conditionals").JSONSchema;
+        customClientValidator(fn: (value: unknown, context: {
+            $now: string;
+            $online: boolean;
+        } & {
+            $form: import("./ActionDocument").EventState | Record<string, unknown>;
+        }) => boolean): import("../conditionals/conditionals").JSONSchema;
+        customClientEvaluation(fn: (value: unknown, context: {
+            $now: string;
+            $online: boolean;
+        } & {
+            $form: import("./ActionDocument").EventState | Record<string, unknown>;
+        }) => any): {
+            $$code: string;
+        };
         getId: () => {
             fieldId: string;
         };
@@ -498,6 +582,20 @@ export declare function field(fieldId: string, options?: {
             isValidAdministrativeLeafLevel(): import("../conditionals/conditionals").JSONSchema;
             matches(pattern: string): import("../conditionals/conditionals").JSONSchema;
             isBetween(min: number, max: number): import("../conditionals/conditionals").JSONSchema;
+            customClientValidator(fn: (value: unknown, context: {
+                $now: string;
+                $online: boolean;
+            } & {
+                $form: import("./ActionDocument").EventState | Record<string, unknown>;
+            }) => boolean): import("../conditionals/conditionals").JSONSchema;
+            customClientEvaluation(fn: (value: unknown, context: {
+                $now: string;
+                $online: boolean;
+            } & {
+                $form: import("./ActionDocument").EventState | Record<string, unknown>;
+            }) => any): {
+                $$code: string;
+            };
             getId: () => {
                 fieldId: string;
             };
@@ -556,6 +654,20 @@ export declare function field(fieldId: string, options?: {
         isValidAdministrativeLeafLevel(): import("../conditionals/conditionals").JSONSchema;
         matches(pattern: string): import("../conditionals/conditionals").JSONSchema;
         isBetween(min: number, max: number): import("../conditionals/conditionals").JSONSchema;
+        customClientValidator(fn: (value: unknown, context: {
+            $now: string;
+            $online: boolean;
+        } & {
+            $form: import("./ActionDocument").EventState | Record<string, unknown>;
+        }) => boolean): import("../conditionals/conditionals").JSONSchema;
+        customClientEvaluation(fn: (value: unknown, context: {
+            $now: string;
+            $online: boolean;
+        } & {
+            $form: import("./ActionDocument").EventState | Record<string, unknown>;
+        }) => any): {
+            $$code: string;
+        };
         getId: () => {
             fieldId: string;
         };
@@ -623,6 +735,20 @@ export declare function field(fieldId: string, options?: {
             isValidAdministrativeLeafLevel(): import("../conditionals/conditionals").JSONSchema;
             matches(pattern: string): import("../conditionals/conditionals").JSONSchema;
             isBetween(min: number, max: number): import("../conditionals/conditionals").JSONSchema;
+            customClientValidator(fn: (value: unknown, context: {
+                $now: string;
+                $online: boolean;
+            } & {
+                $form: import("./ActionDocument").EventState | Record<string, unknown>;
+            }) => boolean): import("../conditionals/conditionals").JSONSchema;
+            customClientEvaluation(fn: (value: unknown, context: {
+                $now: string;
+                $online: boolean;
+            } & {
+                $form: import("./ActionDocument").EventState | Record<string, unknown>;
+            }) => any): {
+                $$code: string;
+            };
             getId: () => {
                 fieldId: string;
             };
@@ -681,6 +807,20 @@ export declare function field(fieldId: string, options?: {
         isValidAdministrativeLeafLevel(): import("../conditionals/conditionals").JSONSchema;
         matches(pattern: string): import("../conditionals/conditionals").JSONSchema;
         isBetween(min: number, max: number): import("../conditionals/conditionals").JSONSchema;
+        customClientValidator(fn: (value: unknown, context: {
+            $now: string;
+            $online: boolean;
+        } & {
+            $form: import("./ActionDocument").EventState | Record<string, unknown>;
+        }) => boolean): import("../conditionals/conditionals").JSONSchema;
+        customClientEvaluation(fn: (value: unknown, context: {
+            $now: string;
+            $online: boolean;
+        } & {
+            $form: import("./ActionDocument").EventState | Record<string, unknown>;
+        }) => any): {
+            $$code: string;
+        };
         getId: () => {
             fieldId: string;
         };
@@ -737,6 +877,20 @@ export declare function field(fieldId: string, options?: {
     isValidAdministrativeLeafLevel(): import("../conditionals/conditionals").JSONSchema;
     matches(pattern: string): import("../conditionals/conditionals").JSONSchema;
     isBetween(min: number, max: number): import("../conditionals/conditionals").JSONSchema;
+    customClientValidator(fn: (value: unknown, context: {
+        $now: string;
+        $online: boolean;
+    } & {
+        $form: import("./ActionDocument").EventState | Record<string, unknown>;
+    }) => boolean): import("../conditionals/conditionals").JSONSchema;
+    customClientEvaluation(fn: (value: unknown, context: {
+        $now: string;
+        $online: boolean;
+    } & {
+        $form: import("./ActionDocument").EventState | Record<string, unknown>;
+    }) => any): {
+        $$code: string;
+    };
     getId: () => {
         fieldId: string;
     };

package/dist/commons/events/index.d.ts

@@ -39,6 +39,7 @@ export * from './FileUtils';
 export * from '../conditionals/conditionals';
 export * from '../conditionals/validate';
 export * from './field';
+export * from './Flag';
 export * from './event';
 export * from './locations';
 export { UUID } from '../uuid';

package/dist/commons/events/locations.d.ts

@@ -1,24 +1,31 @@
-import { z } from 'zod';
-export declare const LocationType: z.ZodEnum<["ADMIN_STRUCTURE", "CRVS_OFFICE", "HEALTH_FACILITY"]>;
+import * as z from 'zod/v4';
+/** @deprecated */
+export declare const LocationTypeV1: z.ZodEnum<{
+    ADMIN_STRUCTURE: "ADMIN_STRUCTURE";
+    HEALTH_FACILITY: "HEALTH_FACILITY";
+    CRVS_OFFICE: "CRVS_OFFICE";
+}>;
+export type LocationTypeV1 = z.infer<typeof LocationTypeV1>;
+export declare const LocationType: z.ZodEnum<{
+    HEALTH_FACILITY: "HEALTH_FACILITY";
+    CRVS_OFFICE: "CRVS_OFFICE";
+}>;
 export type LocationType = z.infer<typeof LocationType>;
+export declare const AdministrativeArea: z.ZodObject<{
+    id: z.core.$ZodBranded<z.ZodUUID, "UUID">;
+    name: z.ZodString;
+    externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    parentId: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "UUID">>;
+    validUntil: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>;
+export type AdministrativeArea = z.infer<typeof AdministrativeArea>;
 export declare const Location: z.ZodObject<{
-    id: z.ZodBranded<z.ZodString, "UUID">;
+    id: z.core.$ZodBranded<z.ZodUUID, "UUID">;
     name: z.ZodString;
-    parentId: z.ZodNullable<z.ZodBranded<z.ZodString, "UUID">>;
-    validUntil: z.ZodNullable<z.ZodString>;
-    locationType: z.ZodNullable<z.ZodEnum<["ADMIN_STRUCTURE", "CRVS_OFFICE", "HEALTH_FACILITY"]>>;
-}, "strip", z.ZodTypeAny, {
-    id: string & z.BRAND<"UUID">;
-    name: string;
-    parentId: (string & z.BRAND<"UUID">) | null;
-    validUntil: string | null;
-    locationType: "ADMIN_STRUCTURE" | "HEALTH_FACILITY" | "CRVS_OFFICE" | null;
-}, {
-    id: string;
-    name: string;
-    parentId: string | null;
-    validUntil: string | null;
-    locationType: "ADMIN_STRUCTURE" | "HEALTH_FACILITY" | "CRVS_OFFICE" | null;
-}>;
+    externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    administrativeAreaId: z.ZodNullable<z.core.$ZodBranded<z.ZodUUID, "UUID">>;
+    validUntil: z.ZodNullable<z.ZodISODateTime>;
+    locationType: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
 export type Location = z.infer<typeof Location>;
 //# sourceMappingURL=locations.d.ts.map

package/dist/commons/events/scopes.d.ts

@@ -5,9 +5,9 @@ export declare const ACTION_SCOPE_MAP: {
     READ: "record.read"[];
     CREATE: "record.create"[];
     NOTIFY: "record.notify"[];
-    DECLARE: ("record.register" | "record.declare" | "record.declared.validate")[];
+    DECLARE: ("record.register" | "record.declare")[];
+    EDIT: "record.declared.edit"[];
     DELETE: "record.declare"[];
-    VALIDATE: ("record.register" | "record.declared.validate")[];
     REGISTER: "record.register"[];
     PRINT_CERTIFICATE: "record.registered.print-certified-copies"[];
     REQUEST_CORRECTION: ("record.registered.request-correction" | "record.registered.correct")[];
@@ -21,9 +21,10 @@ export declare const ACTION_SCOPE_MAP: {
     ASSIGN: null;
     UNASSIGN: null;
     DUPLICATE_DETECTED: never[];
+    CUSTOM: never[];
 };
 export declare function hasAnyOfScopes(a: Scope[], b: Scope[]): boolean;
-export declare function configurableEventScopeAllowed(scopes: Scope[], allowedConfigurableScopes: ConfigurableScopeType[], eventType: string): boolean;
+export declare function configurableEventScopeAllowed(scopes: Scope[], allowedConfigurableScopes: ConfigurableScopeType[], eventType: string, customActionType?: string): boolean;
 /**
  * Checks if a given action is allowed for the provided scopes and event type.
  *
@@ -36,7 +37,7 @@ export declare function configurableEventScopeAllowed(scopes: Scope[], allowedCo
  * @param {string} eventType - The type of event for which the action is being checked.
  * @returns {boolean} True if the action is in scope for the user, otherwise false.
  */
-export declare function isActionInScope(scopes: Scope[], action: DisplayableAction, eventType: string): boolean;
+export declare function isActionInScope(scopes: Scope[], action: DisplayableAction, eventType: string, customActionType?: string): boolean;
 /**
  * A shared utility to check if the user can read a record.
  * This will be removed in 1.10 and implemented by scopes.

package/dist/commons/events/state/availableActions.d.ts

@@ -1,6 +1,4 @@
 import { DisplayableAction } from '../ActionType';
 import { EventIndex } from '../EventIndex';
-import { EventStatus, Flag } from '../EventMetadata';
-export declare function getAvailableActions(status: EventStatus, flags: Flag[]): DisplayableAction[];
 export declare function getAvailableActionsForEvent(event: EventIndex): DisplayableAction[];
 //# sourceMappingURL=availableActions.d.ts.map

package/dist/commons/events/state/flags.d.ts

@@ -1,4 +1,22 @@
-import { Action } from '../ActionDocument';
-import { Flag } from '../EventMetadata';
-export declare function getFlagsFromActions(actions: Action[]): Flag[];
+import { Flag, CustomFlag } from '../Flag';
+import { EventConfig } from '../EventConfig';
+import { EventDocument } from '../EventDocument';
+/**
+ * This function resolves custom flags for an event based on its actions.
+ * Flags are not stored to the event state or any database directly, instead they are always computed/evaluated from the event actions.
+ *
+ * Processes accepted actions in chronological order, evaluating flag conditions
+ * at each action step. Flags can be added or removed based on action configurations
+ * and conditional logic. Duplicate flags are filtered out.
+ *
+ * @param event - The event document containing actions and metadata
+ * @param eventConfiguration - The configuration object for the event type defining action rules and flag behaviors
+ * @returns An array of unique custom flag IDs that apply to the event after processing all non-meta actions
+ *
+ * @example
+ * const flags = resolveEventCustomFlags(eventDoc, config);
+ * // Returns: ['flag-1', 'flag-3']
+ */
+export declare function resolveEventCustomFlags(event: EventDocument, eventConfiguration: EventConfig): CustomFlag[];
+export declare function getEventFlags(event: EventDocument, config: EventConfig): Flag[];
 //# sourceMappingURL=flags.d.ts.map

package/dist/commons/events/state/index.d.ts

@@ -7,7 +7,7 @@ import { Draft } from '../Draft';
 import { EventConfig } from '../EventConfig';
 import { UUID } from '../../uuid';
 import { DocumentPath, FullDocumentPath, FullDocumentUrl } from '../../documents';
-export declare function getStatusFromActions(actions: Array<Action>): "ARCHIVED" | "DECLARED" | "REGISTERED" | "VALIDATED" | "CREATED" | "NOTIFIED";
+export declare function getStatusFromActions(actions: Array<Action>): "ARCHIVED" | "DECLARED" | "REGISTERED" | "CREATED" | "NOTIFIED";
 export declare function getAssignedUserFromActions(actions: Array<ActionDocument>): string | null;
 export declare function getAssignedUserSignatureFromActions(actions: Array<ActionDocument>): string | null;
 type NonNullableDeep<T> = T extends [unknown, ...unknown[]] ? {
@@ -28,6 +28,10 @@ export declare const DEFAULT_DATE_OF_EVENT_PROPERTY = "createdAt";
 export declare function resolveDateOfEvent(eventMetadata: {
     createdAt: string;
 }, declaration: EventState, config: EventConfig): string | undefined;
+export declare const DEFAULT_PLACE_OF_EVENT_PROPERTY = "createdAtLocation";
+export declare function resolvePlaceOfEvent(eventMetadata: {
+    createdAtLocation?: UUID | undefined | null;
+}, declaration: EventState, config: EventConfig): UUID | undefined | null;
 export declare function extractPotentialDuplicatesFromActions(actions: Action[]): PotentialDuplicate[];
 /**
  * NOTE: This function should not run field validations. It should return the state based on the actions, without considering context (users, roles, permissions, etc).
@@ -38,9 +42,7 @@ export declare function extractPotentialDuplicatesFromActions(actions: Action[])
  * @returns Calculates a snapshot summary of the event based on the actions taken on it.
  * @see EventIndex for the description of the returned object.
  */
-export declare function getCurrentEventState(event: EventDocument, 
-/** @TODO: remove config parameter, it is only used by resolveDateOfEvent. See if it can be achieved in some other way. */
-config: EventConfig): EventIndex;
+export declare function getCurrentEventState(event: EventDocument, config: EventConfig): EventIndex;
 /**
  * @returns the future state of the event with drafts applied to all fields.
  *
@@ -62,47 +64,48 @@ export declare function applyDeclarationToEventIndex(eventIndex: EventIndex, dec
  *
  */
 export declare function applyDraftToEventIndex(eventIndex: EventIndex, draft: Draft, eventConfiguration: EventConfig): {
+    id: string & import("zod").$brand<"UUID">;
     type: string;
-    id: string & import("zod").BRAND<"UUID">;
-    status: "ARCHIVED" | "DECLARED" | "REGISTERED" | "VALIDATED" | "CREATED" | "NOTIFIED";
-    createdAt: string;
-    createdBy: string;
-    declaration: Record<string, import("..").FieldValue>;
-    trackingId: string;
-    updatedAt: string;
+    status: "ARCHIVED" | "DECLARED" | "REGISTERED" | "CREATED" | "NOTIFIED";
     legalStatuses: {
         DECLARED?: {
             createdAt: string;
             createdBy: string;
-            createdByRole: string;
             acceptedAt: string;
+            createdAtLocation?: (string & import("zod").$brand<"UUID">) | null | undefined;
             createdByUserType?: "system" | "user" | null | undefined;
+            createdByRole?: string | undefined;
             createdBySignature?: string | null | undefined;
-            createdAtLocation?: (string & import("zod").BRAND<"UUID">) | null | undefined;
         } | null | undefined;
         REGISTERED?: {
             createdAt: string;
             createdBy: string;
-            createdByRole: string;
-            registrationNumber: string;
             acceptedAt: string;
+            registrationNumber: string;
+            createdAtLocation?: (string & import("zod").$brand<"UUID">) | null | undefined;
             createdByUserType?: "system" | "user" | null | undefined;
+            createdByRole?: string | undefined;
             createdBySignature?: string | null | undefined;
-            createdAtLocation?: (string & import("zod").BRAND<"UUID">) | null | undefined;
         } | null | undefined;
     };
-    updatedByUserRole: string;
+    createdAt: string;
+    createdBy: string;
+    updatedAt: string;
+    trackingId: string;
     potentialDuplicates: {
-        id: string & import("zod").BRAND<"UUID">;
+        id: string & import("zod").$brand<"UUID">;
         trackingId: string;
     }[];
     flags: string[];
+    declaration: Record<string, import("..").FieldValue>;
+    dateOfEvent?: string | null | undefined;
+    placeOfEvent?: (string & import("zod").$brand<"UUID">) | null | undefined;
     createdByUserType?: "system" | "user" | null | undefined;
+    updatedByUserRole?: string | null | undefined;
+    createdAtLocation?: (string & import("zod").$brand<"UUID">) | null | undefined;
     createdBySignature?: string | null | undefined;
-    createdAtLocation?: (string & import("zod").BRAND<"UUID">) | null | undefined;
+    updatedAtLocation?: (string & import("zod").$brand<"UUID">) | null | undefined;
     assignedTo?: string | null | undefined;
-    dateOfEvent?: string | null | undefined;
-    updatedAtLocation?: (string & import("zod").BRAND<"UUID">) | null | undefined;
     updatedBy?: string | null | undefined;
 };
 /**