@nira-opencrvs/toolkit 1.9.11-rc.1f36427

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,233 @@
+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>;
+        matchAgainst: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        boost?: number | undefined;
+        matchAgainst?: string | undefined;
+    }, {
+        boost?: number | undefined;
+        matchAgainst?: string | 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>>;
+        matchAgainst: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        boost: number;
+        fuzziness: string | number;
+        matchAgainst?: string | undefined;
+    }, {
+        boost?: number | undefined;
+        matchAgainst?: string | undefined;
+        fuzziness?: string | number | undefined;
+    }>>>;
+}>, "strip", z.ZodTypeAny, {
+    type: "fuzzy";
+    options: {
+        boost: number;
+        fuzziness: string | number;
+        matchAgainst?: string | undefined;
+    };
+    fieldId: string;
+}, {
+    type: "fuzzy";
+    fieldId: string;
+    options?: {
+        boost?: number | undefined;
+        matchAgainst?: string | 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>;
+        matchAgainst: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        boost?: number | undefined;
+        matchAgainst?: string | undefined;
+    }, {
+        boost?: number | undefined;
+        matchAgainst?: string | 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>;
+        matchAgainst: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        boost: number;
+        value?: string | undefined;
+        matchAgainst?: string | undefined;
+    }, {
+        value?: string | undefined;
+        boost?: number | undefined;
+        matchAgainst?: string | undefined;
+    }>>>;
+}>, "strip", z.ZodTypeAny, {
+    type: "strict";
+    options: {
+        boost: number;
+        value?: string | undefined;
+        matchAgainst?: string | undefined;
+    };
+    fieldId: string;
+}, {
+    type: "strict";
+    fieldId: string;
+    options?: {
+        value?: string | undefined;
+        boost?: number | undefined;
+        matchAgainst?: string | 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>;
+        matchAgainst: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        boost?: number | undefined;
+        matchAgainst?: string | undefined;
+    }, {
+        boost?: number | undefined;
+        matchAgainst?: string | 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>>;
+        matchAgainst: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        boost: number;
+        days: number;
+        matchAgainst?: string | undefined;
+        pivot?: number | undefined;
+    }, {
+        days: number;
+        boost?: number | undefined;
+        matchAgainst?: string | undefined;
+        pivot?: number | undefined;
+    }>;
+}>, "strip", z.ZodTypeAny, {
+    type: "dateRange";
+    options: {
+        boost: number;
+        days: number;
+        matchAgainst?: string | undefined;
+        pivot?: number | undefined;
+    };
+    fieldId: string;
+}, {
+    type: "dateRange";
+    options: {
+        days: number;
+        boost?: number | undefined;
+        matchAgainst?: string | 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;
+    query: ClauseOutput;
+    label: TranslationConfig;
+}, {
+    id: string;
+    query: ClauseInput;
+    label: {
+        id: string;
+        description: string;
+        defaultMessage: string;
+    };
+}>;
+export type DeduplicationConfigInput = z.input<typeof DeduplicationConfig>;
+export type DeduplicationConfig = z.infer<typeof DeduplicationConfig>;
+export {};
+//# sourceMappingURL=DeduplicationConfig.d.ts.map

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

@@ -0,0 +1,118 @@
+import { z } from 'zod';
+export declare const Draft: z.ZodObject<{
+    id: z.ZodBranded<z.ZodString, "UUID">;
+    eventId: z.ZodBranded<z.ZodString, "UUID">;
+    transactionId: z.ZodString;
+    createdAt: z.ZodString;
+    action: z.ZodObject<Omit<z.objectUtil.extendShape<{
+        id: z.ZodBranded<z.ZodString, "UUID">;
+        transactionId: z.ZodString;
+        createdByUserType: z.ZodEnum<["user", "system"]>;
+        createdAt: z.ZodString;
+        createdBy: z.ZodString;
+        createdByRole: z.ZodString;
+        createdBySignature: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        createdAtLocation: z.ZodOptional<z.ZodNullable<z.ZodBranded<z.ZodString, "UUID">>>;
+        declaration: z.ZodRecord<z.ZodString, z.ZodType<import("./FieldValue").FieldUpdateValue, z.ZodTypeDef, import("./FieldValue").FieldUpdateValue>>;
+        annotation: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./FieldValue").FieldUpdateValue, z.ZodTypeDef, import("./FieldValue").FieldUpdateValue>>>>;
+        status: z.ZodEnum<["Requested", "Accepted", "Rejected"]>;
+        originalActionId: z.ZodNullable<z.ZodOptional<z.ZodBranded<z.ZodString, "UUID">>>;
+    }, {
+        type: z.ZodEnum<["CREATE", "NOTIFY", "DECLARE", "VALIDATE", "REGISTER", "DUPLICATE_DETECTED", "REJECT", "MARK_AS_DUPLICATE", "MARK_AS_NOT_DUPLICATE", "ARCHIVE", "PRINT_CERTIFICATE", "REQUEST_CORRECTION", "REJECT_CORRECTION", "APPROVE_CORRECTION", "READ", "ASSIGN", "UNASSIGN"]>;
+    }>, "id" | "createdAtLocation">, "strip", z.ZodTypeAny, {
+        type: "CREATE" | "NOTIFY" | "DECLARE" | "VALIDATE" | "REGISTER" | "DUPLICATE_DETECTED" | "REJECT" | "MARK_AS_DUPLICATE" | "MARK_AS_NOT_DUPLICATE" | "ARCHIVE" | "PRINT_CERTIFICATE" | "REQUEST_CORRECTION" | "REJECT_CORRECTION" | "APPROVE_CORRECTION" | "READ" | "ASSIGN" | "UNASSIGN";
+        status: "Rejected" | "Requested" | "Accepted";
+        transactionId: string;
+        createdByUserType: "system" | "user";
+        createdAt: string;
+        createdBy: string;
+        createdByRole: string;
+        declaration: Record<string, import("./FieldValue").FieldUpdateValue>;
+        createdBySignature?: string | null | undefined;
+        annotation?: Record<string, import("./FieldValue").FieldUpdateValue> | null | undefined;
+        originalActionId?: (string & z.BRAND<"UUID">) | null | undefined;
+    }, {
+        type: "CREATE" | "NOTIFY" | "DECLARE" | "VALIDATE" | "REGISTER" | "DUPLICATE_DETECTED" | "REJECT" | "MARK_AS_DUPLICATE" | "MARK_AS_NOT_DUPLICATE" | "ARCHIVE" | "PRINT_CERTIFICATE" | "REQUEST_CORRECTION" | "REJECT_CORRECTION" | "APPROVE_CORRECTION" | "READ" | "ASSIGN" | "UNASSIGN";
+        status: "Rejected" | "Requested" | "Accepted";
+        transactionId: string;
+        createdByUserType: "system" | "user";
+        createdAt: string;
+        createdBy: string;
+        createdByRole: string;
+        declaration: Record<string, import("./FieldValue").FieldUpdateValue>;
+        createdBySignature?: string | null | undefined;
+        annotation?: Record<string, import("./FieldValue").FieldUpdateValue> | null | undefined;
+        originalActionId?: string | null | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    id: string & z.BRAND<"UUID">;
+    transactionId: string;
+    createdAt: string;
+    eventId: string & z.BRAND<"UUID">;
+    action: {
+        type: "CREATE" | "NOTIFY" | "DECLARE" | "VALIDATE" | "REGISTER" | "DUPLICATE_DETECTED" | "REJECT" | "MARK_AS_DUPLICATE" | "MARK_AS_NOT_DUPLICATE" | "ARCHIVE" | "PRINT_CERTIFICATE" | "REQUEST_CORRECTION" | "REJECT_CORRECTION" | "APPROVE_CORRECTION" | "READ" | "ASSIGN" | "UNASSIGN";
+        status: "Rejected" | "Requested" | "Accepted";
+        transactionId: string;
+        createdByUserType: "system" | "user";
+        createdAt: string;
+        createdBy: string;
+        createdByRole: string;
+        declaration: Record<string, import("./FieldValue").FieldUpdateValue>;
+        createdBySignature?: string | null | undefined;
+        annotation?: Record<string, import("./FieldValue").FieldUpdateValue> | null | undefined;
+        originalActionId?: (string & z.BRAND<"UUID">) | null | undefined;
+    };
+}, {
+    id: string;
+    transactionId: string;
+    createdAt: string;
+    eventId: string;
+    action: {
+        type: "CREATE" | "NOTIFY" | "DECLARE" | "VALIDATE" | "REGISTER" | "DUPLICATE_DETECTED" | "REJECT" | "MARK_AS_DUPLICATE" | "MARK_AS_NOT_DUPLICATE" | "ARCHIVE" | "PRINT_CERTIFICATE" | "REQUEST_CORRECTION" | "REJECT_CORRECTION" | "APPROVE_CORRECTION" | "READ" | "ASSIGN" | "UNASSIGN";
+        status: "Rejected" | "Requested" | "Accepted";
+        transactionId: string;
+        createdByUserType: "system" | "user";
+        createdAt: string;
+        createdBy: string;
+        createdByRole: string;
+        declaration: Record<string, import("./FieldValue").FieldUpdateValue>;
+        createdBySignature?: string | null | undefined;
+        annotation?: Record<string, import("./FieldValue").FieldUpdateValue> | null | undefined;
+        originalActionId?: string | null | undefined;
+    };
+}>;
+export declare const DraftInput: z.ZodObject<z.objectUtil.extendShape<{
+    eventId: z.ZodBranded<z.ZodString, "UUID">;
+    transactionId: z.ZodString;
+    declaration: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<import("./FieldValue").FieldUpdateValue, z.ZodTypeDef, import("./FieldValue").FieldUpdateValue>>>;
+    annotation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./FieldValue").FieldUpdateValue, z.ZodTypeDef, import("./FieldValue").FieldUpdateValue>>>;
+    originalActionId: z.ZodOptional<z.ZodBranded<z.ZodString, "UUID">>;
+    keepAssignment: z.ZodOptional<z.ZodBoolean>;
+    createdAtLocation: z.ZodOptional<z.ZodNullable<z.ZodBranded<z.ZodString, "UUID">>>;
+}, {
+    type: z.ZodEnum<["CREATE", "NOTIFY", "DECLARE", "VALIDATE", "REGISTER", "DUPLICATE_DETECTED", "REJECT", "MARK_AS_DUPLICATE", "MARK_AS_NOT_DUPLICATE", "ARCHIVE", "PRINT_CERTIFICATE", "REQUEST_CORRECTION", "REJECT_CORRECTION", "APPROVE_CORRECTION", "READ", "ASSIGN", "UNASSIGN"]>;
+    status: z.ZodEnum<["Requested", "Accepted", "Rejected"]>;
+}>, "strip", z.ZodTypeAny, {
+    type: "CREATE" | "NOTIFY" | "DECLARE" | "VALIDATE" | "REGISTER" | "DUPLICATE_DETECTED" | "REJECT" | "MARK_AS_DUPLICATE" | "MARK_AS_NOT_DUPLICATE" | "ARCHIVE" | "PRINT_CERTIFICATE" | "REQUEST_CORRECTION" | "REJECT_CORRECTION" | "APPROVE_CORRECTION" | "READ" | "ASSIGN" | "UNASSIGN";
+    status: "Rejected" | "Requested" | "Accepted";
+    transactionId: string;
+    declaration: Record<string, import("./FieldValue").FieldUpdateValue>;
+    eventId: string & z.BRAND<"UUID">;
+    createdAtLocation?: (string & z.BRAND<"UUID">) | null | undefined;
+    annotation?: Record<string, import("./FieldValue").FieldUpdateValue> | undefined;
+    originalActionId?: (string & z.BRAND<"UUID">) | undefined;
+    keepAssignment?: boolean | undefined;
+}, {
+    type: "CREATE" | "NOTIFY" | "DECLARE" | "VALIDATE" | "REGISTER" | "DUPLICATE_DETECTED" | "REJECT" | "MARK_AS_DUPLICATE" | "MARK_AS_NOT_DUPLICATE" | "ARCHIVE" | "PRINT_CERTIFICATE" | "REQUEST_CORRECTION" | "REJECT_CORRECTION" | "APPROVE_CORRECTION" | "READ" | "ASSIGN" | "UNASSIGN";
+    status: "Rejected" | "Requested" | "Accepted";
+    transactionId: string;
+    eventId: string;
+    createdAtLocation?: string | null | undefined;
+    declaration?: Record<string, import("./FieldValue").FieldUpdateValue> | undefined;
+    annotation?: Record<string, import("./FieldValue").FieldUpdateValue> | undefined;
+    originalActionId?: string | undefined;
+    keepAssignment?: boolean | undefined;
+}>;
+export type Draft = z.infer<typeof Draft>;
+export type DraftInput = z.infer<typeof DraftInput>;
+//# sourceMappingURL=Draft.d.ts.map

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

@@ -0,0 +1,139 @@
+import { z } from 'zod';
+import { AddressField, NameField } from './FieldConfig';
+/**
+ * Dynamically builds a Zod schema for a "NAME" field based on its configuration.
+ *
+ * Why this exists: each form field can have its own "required" configuration.
+ * NAME fields are composite — made up of subfields like firstname, surname, and middlename.
+ * We can’t just hardcode a single Zod schema for all names, because different forms
+ * (e.g. applicant, father, mother) may require different parts.
+ *
+ * This function reads the configuration and builds a schema that respects which
+ * subfields are required and which are optional.
+ */
+export declare function getDynamicNameValue(field: NameField): z.ZodObject<{
+    firstname: z.ZodString;
+    surname: z.ZodString;
+    middlename: z.ZodString | z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    firstname: string;
+    surname: string;
+    middlename?: string | undefined;
+}, {
+    firstname: string;
+    surname: string;
+    middlename?: string | undefined;
+}>;
+export type DynamicNameValue = ReturnType<typeof getDynamicNameValue>;
+/**
+ * Dynamically builds a Zod schema for an "ADDRESS" field.
+ *
+ * Why this exists:
+ * The address field is dynamic — its structure depends on whether it’s a domestic
+ * or international address and which street-level fields (e.g. house number, ward, block)
+ * are configured for that event type.
+ *
+ * The validation ensures:
+ *  - Required core fields (country, addressType) are always present.
+ *  - Administrative area (like a district or region) can be optional.
+ *  - Street-level details are validated against the configured set of keys.
+ *    This prevents clients from sending unexpected data keys that don’t exist
+ *    in the configuration (a common data integrity issue).
+ */
+export declare function getDynamicAddressFieldValue(field: AddressField): z.ZodEffects<z.ZodDiscriminatedUnion<"addressType", [z.ZodObject<z.objectUtil.extendShape<{
+    country: z.ZodString;
+    streetLevelDetails: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, {
+    addressType: z.ZodLiteral<"DOMESTIC">;
+    administrativeArea: z.ZodString;
+}>, "strip", z.ZodTypeAny, {
+    country: string;
+    addressType: "DOMESTIC";
+    administrativeArea: string;
+    streetLevelDetails?: Record<string, string> | undefined;
+}, {
+    country: string;
+    addressType: "DOMESTIC";
+    administrativeArea: string;
+    streetLevelDetails?: Record<string, string> | undefined;
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    country: z.ZodString;
+    streetLevelDetails: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, {
+    addressType: z.ZodLiteral<"INTERNATIONAL">;
+}>, "strip", z.ZodTypeAny, {
+    country: string;
+    addressType: "INTERNATIONAL";
+    streetLevelDetails?: Record<string, string> | undefined;
+}, {
+    country: string;
+    addressType: "INTERNATIONAL";
+    streetLevelDetails?: Record<string, string> | undefined;
+}>]>, {
+    country: string;
+    addressType: "DOMESTIC";
+    administrativeArea: string;
+    streetLevelDetails?: Record<string, string> | undefined;
+} | {
+    country: string;
+    addressType: "INTERNATIONAL";
+    streetLevelDetails?: Record<string, string> | undefined;
+}, {
+    country: string;
+    addressType: "DOMESTIC";
+    administrativeArea: string;
+    streetLevelDetails?: Record<string, string> | undefined;
+} | {
+    country: string;
+    addressType: "INTERNATIONAL";
+    streetLevelDetails?: Record<string, string> | undefined;
+}> | z.ZodEffects<z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<"addressType", [z.ZodObject<z.objectUtil.extendShape<{
+    country: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    streetLevelDetails: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>>;
+}, {
+    addressType: z.ZodLiteral<"DOMESTIC">;
+    administrativeArea: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}>, "strip", z.ZodTypeAny, {
+    addressType: "DOMESTIC";
+    country?: string | null | undefined;
+    streetLevelDetails?: Record<string, string | null> | null | undefined;
+    administrativeArea?: string | null | undefined;
+}, {
+    addressType: "DOMESTIC";
+    country?: string | null | undefined;
+    streetLevelDetails?: Record<string, string | null> | null | undefined;
+    administrativeArea?: string | null | undefined;
+}>, z.ZodObject<z.objectUtil.extendShape<{
+    country: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    streetLevelDetails: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodString>>>>;
+}, {
+    addressType: z.ZodLiteral<"INTERNATIONAL">;
+}>, "strip", z.ZodTypeAny, {
+    addressType: "INTERNATIONAL";
+    country?: string | null | undefined;
+    streetLevelDetails?: Record<string, string | null> | null | undefined;
+}, {
+    addressType: "INTERNATIONAL";
+    country?: string | null | undefined;
+    streetLevelDetails?: Record<string, string | null> | null | undefined;
+}>]>>>, {
+    addressType: "DOMESTIC";
+    country?: string | null | undefined;
+    streetLevelDetails?: Record<string, string | null> | null | undefined;
+    administrativeArea?: string | null | undefined;
+} | {
+    addressType: "INTERNATIONAL";
+    country?: string | null | undefined;
+    streetLevelDetails?: Record<string, string | null> | null | undefined;
+} | null | undefined, {
+    addressType: "DOMESTIC";
+    country?: string | null | undefined;
+    streetLevelDetails?: Record<string, string | null> | null | undefined;
+    administrativeArea?: string | null | undefined;
+} | {
+    addressType: "INTERNATIONAL";
+    country?: string | null | undefined;
+    streetLevelDetails?: Record<string, string | null> | null | undefined;
+} | null | undefined>;
+export type DynamicAddressFieldValue = ReturnType<typeof getDynamicAddressFieldValue>;
+//# sourceMappingURL=DynamicFieldValue.d.ts.map