@ecrvs/opencrvs-toolkit 1.8.1-rc.a7ee8fb

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

@@ -0,0 +1,2 @@
+export declare const CreatedAtLocation: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBranded<import("zod").ZodString, "UUID">>>;
+//# sourceMappingURL=CreatedAtLocation.d.ts.map

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

@@ -0,0 +1,209 @@
+import { z } from 'zod';
+import { TranslationConfig } from './TranslationConfig';
+declare const FuzzyMatcher: z.ZodObject<z.objectUtil.extendShape<{
+    /**
+     * Reference to the field used in matching.
+     *
+     * For `dateRange` type matcher the value of this field will also
+     * be used as the origin date to calculate the distance from.
+     */
+    fieldId: z.ZodString;
+    options: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        boost: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        boost?: number | undefined;
+    }, {
+        boost?: number | undefined;
+    }>>>;
+}, {
+    type: z.ZodLiteral<"fuzzy">;
+    options: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        /**
+         * 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: z.ZodDefault<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>>;
+        boost: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        boost: number;
+        fuzziness: string | number;
+    }, {
+        boost?: number | undefined;
+        fuzziness?: string | number | undefined;
+    }>>>;
+}>, "strip", z.ZodTypeAny, {
+    type: "fuzzy";
+    options: {
+        boost: number;
+        fuzziness: string | number;
+    };
+    fieldId: string;
+}, {
+    type: "fuzzy";
+    fieldId: string;
+    options?: {
+        boost?: number | undefined;
+        fuzziness?: string | number | undefined;
+    } | undefined;
+}>;
+export type FuzzyMatcherOptions = z.input<typeof FuzzyMatcher>['options'];
+declare const StrictMatcher: z.ZodObject<z.objectUtil.extendShape<{
+    /**
+     * Reference to the field used in matching.
+     *
+     * For `dateRange` type matcher the value of this field will also
+     * be used as the origin date to calculate the distance from.
+     */
+    fieldId: z.ZodString;
+    options: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        boost: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        boost?: number | undefined;
+    }, {
+        boost?: number | undefined;
+    }>>>;
+}, {
+    type: z.ZodLiteral<"strict">;
+    options: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        boost: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        /**
+         * The constant value to be present in the field for both records
+         */
+        value: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        boost: number;
+        value?: string | undefined;
+    }, {
+        value?: string | undefined;
+        boost?: number | undefined;
+    }>>>;
+}>, "strip", z.ZodTypeAny, {
+    type: "strict";
+    options: {
+        boost: number;
+        value?: string | undefined;
+    };
+    fieldId: string;
+}, {
+    type: "strict";
+    fieldId: string;
+    options?: {
+        value?: string | undefined;
+        boost?: number | undefined;
+    } | undefined;
+}>;
+export type StrictMatcherOptions = z.input<typeof StrictMatcher>['options'];
+declare const DateRangeMatcher: z.ZodObject<z.objectUtil.extendShape<{
+    /**
+     * Reference to the field used in matching.
+     *
+     * For `dateRange` type matcher the value of this field will also
+     * be used as the origin date to calculate the distance from.
+     */
+    fieldId: z.ZodString;
+    options: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        boost: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        boost?: number | undefined;
+    }, {
+        boost?: number | undefined;
+    }>>>;
+}, {
+    type: z.ZodLiteral<"dateRange">;
+    options: z.ZodObject<{
+        /**
+         * The distance pivot in days. Distance from the origin (the value of
+         * fieldId) at which relevance scores receive half of the boost value
+         */
+        pivot: z.ZodOptional<z.ZodNumber>;
+        days: z.ZodNumber;
+        boost: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        boost: number;
+        days: number;
+        pivot?: number | undefined;
+    }, {
+        days: number;
+        boost?: number | undefined;
+        pivot?: number | undefined;
+    }>;
+}>, "strip", z.ZodTypeAny, {
+    type: "dateRange";
+    options: {
+        boost: number;
+        days: number;
+        pivot?: number | undefined;
+    };
+    fieldId: string;
+}, {
+    type: "dateRange";
+    options: {
+        days: number;
+        boost?: number | undefined;
+        pivot?: number | undefined;
+    };
+    fieldId: string;
+}>;
+export type DateRangeMatcherOptions = z.input<typeof DateRangeMatcher>['options'];
+export type NotInput = {
+    type: 'not';
+    clause: ClauseInput;
+};
+export type NotOutput = {
+    type: 'not';
+    clause: ClauseOutput;
+};
+export type AndInput = {
+    type: 'and';
+    clauses: ClauseInput[];
+};
+export type AndOutput = {
+    type: 'and';
+    clauses: ClauseOutput[];
+};
+export type OrInput = {
+    type: 'or';
+    clauses: ClauseInput[];
+};
+export type OrOutput = {
+    type: 'or';
+    clauses: ClauseOutput[];
+};
+export type ClauseInput = NotInput | AndInput | OrInput | z.input<typeof FuzzyMatcher> | z.input<typeof StrictMatcher> | z.input<typeof DateRangeMatcher>;
+export type ClauseOutput = NotOutput | AndOutput | OrOutput | z.output<typeof FuzzyMatcher> | z.output<typeof StrictMatcher> | z.output<typeof DateRangeMatcher>;
+/**
+ * Defines a deduplication clause. Clauses are either matcher clauses or logical clauses. Logical clauses (and, or) are used to combine multiple clauses.
+ * Since the definiton is recursive, we use z.lazy to define the schema.
+ * Zod supports recursive schemas, but needs help with Input and Output types.
+ *
+ * Default assumption is that the ZodType is the input. Markers use default values, so we need to explicitly define output type, too.
+ *
+ */
+export declare const Clause: z.ZodType<ClauseOutput, z.ZodTypeDef, ClauseInput>;
+export type Clause = z.infer<typeof Clause>;
+export declare const DeduplicationConfig: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodObject<import("./TranslationConfig").MessageDescriptorZod, "strip", z.ZodTypeAny, TranslationConfig, {
+        id: string;
+        description: string;
+        defaultMessage: string;
+    }>;
+    query: z.ZodType<ClauseOutput, z.ZodTypeDef, ClauseInput>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    label: TranslationConfig;
+    query: ClauseOutput;
+}, {
+    id: string;
+    label: {
+        id: string;
+        description: string;
+        defaultMessage: string;
+    };
+    query: ClauseInput;
+}>;
+export type DeduplicationConfigInput = z.input<typeof DeduplicationConfig>;
+export type DeduplicationConfig = z.infer<typeof DeduplicationConfig>;
+export {};
+//# sourceMappingURL=DeduplicationConfig.d.ts.map