@lucaapp/service-utils 4.9.1 → 4.11.0

package/dist/index.d.ts

@@ -16,4 +16,6 @@ export * from './lib/random';
 export * from './lib/crypto';
 export * from './lib/phone';
 export * from './lib/http';
+export * from './lib/jobs';
+export * from './lib/validation';
 export * from './types';

package/dist/index.js

@@ -32,4 +32,6 @@ __exportStar(require("./lib/random"), exports);
 __exportStar(require("./lib/crypto"), exports);
 __exportStar(require("./lib/phone"), exports);
 __exportStar(require("./lib/http"), exports);
+__exportStar(require("./lib/jobs"), exports);
+__exportStar(require("./lib/validation"), exports);
 __exportStar(require("./types"), exports);

package/dist/lib/jobs/index.d.ts

@@ -0,0 +1 @@
+export * from './jobTracker';

package/dist/lib/jobs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./jobTracker"), exports);

package/dist/lib/jobs/jobTracker.d.ts

@@ -0,0 +1,30 @@
+import { Logger } from 'pino';
+export type JsonSchema = Record<string, unknown>;
+export interface JobStatus {
+    jobId: string;
+    jobName: string;
+    method: string;
+    status: 'running' | 'completed' | 'failed';
+    result?: JsonSchema;
+    error?: string;
+    startedAt: string;
+    completedAt?: string;
+    duration?: number;
+}
+export interface RedisClient {
+    setex(key: string | Buffer, seconds: number, value: string | Buffer): Promise<string | void>;
+    get(key: string | Buffer): Promise<string | null>;
+    scan(cursor: number, command: string, pattern: string, countCommand: string, count: number): Promise<[string, string[]]>;
+}
+export declare const createJobTracker: (logger: Logger, redis: RedisClient) => {
+    createJobExecution: (jobName: string, method: string) => Promise<string>;
+    updateJobStatus: (jobId: string, result: JsonSchema, error?: Error) => Promise<void>;
+    getJobStatus: (jobId: string) => Promise<JobStatus | null>;
+    getAllRunningJobs: () => Promise<JobStatus[]>;
+    getLatestCompletions: () => Promise<Record<string, {
+        completedAt: string;
+        status: "completed" | "failed";
+        error?: string;
+    }>>;
+};
+export type JobTracker = ReturnType<typeof createJobTracker>;

package/dist/lib/jobs/jobTracker.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJobTracker = void 0;
+const uuid_1 = require("uuid");
+const JOB_STATUS_PREFIX = 'job:status:';
+const JOB_TTL = 24 * 60 * 60;
+const createJobTracker = (logger, redis) => {
+    const createJobExecution = async (jobName, method) => {
+        const jobId = (0, uuid_1.v4)();
+        const jobStatus = {
+            jobId,
+            jobName,
+            method,
+            status: 'running',
+            startedAt: new Date().toISOString(),
+        };
+        const key = `${JOB_STATUS_PREFIX}${jobId}`;
+        await redis.setex(key, JOB_TTL, JSON.stringify(jobStatus));
+        logger.info(`Created job execution: ${jobId} for job: ${jobName}, method: ${method}`);
+        return jobId;
+    };
+    const updateJobStatus = async (jobId, result, error) => {
+        const key = `${JOB_STATUS_PREFIX}${jobId}`;
+        const data = await redis.get(key);
+        if (!data) {
+            logger.warn(`Job status not found for jobId: ${jobId}`);
+            return;
+        }
+        const jobStatus = JSON.parse(data);
+        const completedAt = new Date();
+        const startedAt = new Date(jobStatus.startedAt);
+        const duration = completedAt.getTime() - startedAt.getTime();
+        if (error) {
+            jobStatus.status = 'failed';
+            jobStatus.error = error.message;
+        }
+        else {
+            jobStatus.status = 'completed';
+            jobStatus.result = result;
+        }
+        jobStatus.completedAt = completedAt.toISOString();
+        jobStatus.duration = duration;
+        await redis.setex(key, JOB_TTL, JSON.stringify(jobStatus));
+        logger.info(`Updated job status: ${jobId} - status: ${jobStatus.status}, duration: ${duration}ms`);
+    };
+    const getJobStatus = async (jobId) => {
+        const key = `${JOB_STATUS_PREFIX}${jobId}`;
+        const data = await redis.get(key);
+        if (!data) {
+            logger.warn(`Job status not found for jobId: ${jobId}`);
+            return null;
+        }
+        return JSON.parse(data);
+    };
+    const getAllRunningJobs = async () => {
+        const pattern = `${JOB_STATUS_PREFIX}*`;
+        const allJobs = [];
+        let cursor = 0;
+        do {
+            const [nextCursor, keys] = await redis.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
+            cursor = Number.parseInt(nextCursor, 10);
+            for (const key of keys) {
+                const data = await redis.get(key);
+                if (data) {
+                    const jobStatus = JSON.parse(data);
+                    if (jobStatus.status === 'running') {
+                        allJobs.push(jobStatus);
+                    }
+                }
+            }
+        } while (cursor !== 0);
+        logger.info(`Found ${allJobs.length} running jobs`);
+        return allJobs;
+    };
+    const getLatestCompletions = async () => {
+        const pattern = `${JOB_STATUS_PREFIX}*`;
+        const completions = new Map();
+        let cursor = 0;
+        do {
+            const [nextCursor, keys] = await redis.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
+            cursor = Number.parseInt(nextCursor, 10);
+            for (const key of keys) {
+                const data = await redis.get(key);
+                if (data) {
+                    const jobStatus = JSON.parse(data);
+                    if (jobStatus.completedAt &&
+                        (jobStatus.status === 'completed' || jobStatus.status === 'failed')) {
+                        const jobKey = `${jobStatus.jobName}/${jobStatus.method}`;
+                        const existing = completions.get(jobKey);
+                        if (!existing ||
+                            new Date(jobStatus.completedAt) > new Date(existing.completedAt)) {
+                            completions.set(jobKey, {
+                                completedAt: jobStatus.completedAt,
+                                status: jobStatus.status,
+                                error: jobStatus.error,
+                            });
+                        }
+                    }
+                }
+            }
+        } while (cursor !== 0);
+        logger.info(`Found ${completions.size} job completions`);
+        return Object.fromEntries(completions);
+    };
+    return {
+        createJobExecution,
+        updateJobStatus,
+        getJobStatus,
+        getAllRunningJobs,
+        getLatestCompletions,
+    };
+};
+exports.createJobTracker = createJobTracker;

package/dist/lib/money/supportedCurrencies.d.ts

@@ -4,6 +4,8 @@ export declare enum SupportedCurrencies {
     GBP = "GBP",
     USD = "USD",
     HUF = "HUF",
-    CZK = "CZK"
+    CZK = "CZK",
+    PLN = "PLN",
+    RON = "RON"
 }
 export declare const currencySymbols: Record<SupportedCurrencies, string>;

package/dist/lib/money/supportedCurrencies.js

@@ -9,6 +9,8 @@ var SupportedCurrencies;
     SupportedCurrencies["USD"] = "USD";
     SupportedCurrencies["HUF"] = "HUF";
     SupportedCurrencies["CZK"] = "CZK";
+    SupportedCurrencies["PLN"] = "PLN";
+    SupportedCurrencies["RON"] = "RON";
 })(SupportedCurrencies || (exports.SupportedCurrencies = SupportedCurrencies = {}));
 exports.currencySymbols = {
     [SupportedCurrencies.CHF]: 'CHF',
@@ -17,4 +19,6 @@ exports.currencySymbols = {
     [SupportedCurrencies.USD]: '$',
     [SupportedCurrencies.HUF]: 'Ft',
     [SupportedCurrencies.CZK]: 'Kč',
+    [SupportedCurrencies.PLN]: 'zł',
+    [SupportedCurrencies.RON]: 'lei',
 };

package/dist/lib/serviceIdentity/serviceIdentity.js

@@ -34,6 +34,7 @@ const api_1 = require("../api");
 const moment_1 = __importDefault(require("moment"));
 const requestTracer_1 = require("../requestTracer");
 const axios_1 = __importDefault(require("axios"));
+const axios_retry_1 = __importDefault(require("axios-retry"));
 const zod_1 = require("zod");
 const validator_1 = __importDefault(require("validator"));
 const JWT_ALGORITHM = 'ES256';
@@ -188,6 +189,17 @@ class ServiceIdentity {
         this.identityPrivateKey = identityPrivateKey;
         this.identityPublicKey = identityPublicKey;
         this.axiosClient = axios_1.default.create({ proxy: false });
+        // Configure axios-retry to handle 429 and respect Retry-After header
+        (0, axios_retry_1.default)(this.axiosClient, {
+            retries: 3,
+            retryDelay: axios_retry_1.default.exponentialDelay,
+            shouldResetTimeout: true,
+            retryCondition: (error) => {
+                // Retry on network errors, 5xx errors, and 429 (rate limit)
+                return (axios_retry_1.default.isNetworkOrIdempotentRequestError(error) ||
+                    error.response?.status === 429);
+            },
+        });
         if (!debug) {
             this.axiosClient.interceptors.response.use(response => response, error => {
                 if (Array.isArray(error?.config?.headers) &&

package/dist/lib/validation.d.ts

@@ -0,0 +1,430 @@
+import { z as zod, ZodEffects, ZodNumber, ZodObject, ZodString, ZodType, ZodTypeAny } from 'zod';
+import validator from 'validator';
+import { Money } from '../lib/money/money';
+export declare const preprocessArrayFromQueryString: (input: unknown) => string[] | unknown;
+export declare const preprocessNumberFromQueryString: (input: unknown) => number | unknown;
+export declare const preprocessBooleanFromQueryString: (input: unknown) => boolean | unknown;
+export declare const preprocessBooleanFromString: (input: unknown) => boolean | unknown;
+declare const z: {
+    string: () => ZodString;
+    safeString: () => ZodString;
+    safeText: () => ZodString;
+    safeBusinessStringForOnboarding: () => zod.ZodEffects<zod.ZodString, string, string>;
+    safeNameForOnboarding: () => zod.ZodEffects<zod.ZodString, string, string>;
+    nonemptyString: () => zod.ZodString;
+    alphaNumericString: () => zod.ZodString;
+    tableId: () => zod.ZodString;
+    uuid: () => ZodString;
+    uuidv4: () => zod.ZodEffects<zod.ZodString, string, string>;
+    email: () => ZodEffects<ZodString>;
+    phoneNumber: () => ZodEffects<ZodEffects<ZodString>>;
+    nullablePhoneNumber: () => zod.ZodEffects<zod.ZodEffects<zod.ZodString, string, string>, string | null, string>;
+    strongPassword: () => zod.ZodEffects<zod.ZodString, string, string>;
+    zipCode: (locale?: validator.PostalCodeLocale) => ZodEffects<ZodString, string>;
+    countryCode: () => zod.ZodString;
+    moneyDecimalString: (locale?: string) => zod.ZodEffects<zod.ZodString, string, string>;
+    moneyFromFloat: () => ZodEffects<ZodEffects<ZodNumber>, Money>;
+    moneyFromInt: () => ZodEffects<ZodNumber, Money>;
+    convertMoneyFieldsToCurrency: <T extends ZodObject<Record<string, ZodTypeAny>>>(schema: T) => ZodEffects<T>;
+    unixTimestamp: () => zod.ZodNumber;
+    integerString: (options?: {
+        maxLength?: number;
+        lt?: number;
+        gt?: number;
+        transform?: boolean;
+    }) => zod.ZodEffects<zod.ZodEffects<zod.ZodType<string, zod.ZodTypeDef, string>, string, string>, number, string>;
+    integerStringRaw: (options?: {
+        maxLength?: number;
+        lt?: number;
+        gt?: number;
+        transform?: boolean;
+    }) => typeof options.transform extends true ? ZodEffects<ZodType<number>> : ZodEffects<ZodType<string>>;
+    bigIntegerString: () => zod.ZodEffects<zod.ZodString, string, string>;
+    floatString: (options?: {
+        maxLength?: number;
+        lt: number;
+        gt: number;
+    }) => zod.ZodEffects<zod.ZodEffects<zod.ZodString, string, string>, number, string>;
+    hex: ({ min, max, length, rawLength, }?: {
+        min?: number;
+        max?: number;
+        length?: number;
+        rawLength?: number;
+    }) => zod.ZodEffects<zod.ZodString, string, string>;
+    sha256: () => zod.ZodEffects<zod.ZodString, string, string>;
+    base64: ({ min, max, length, rawLength, isBase64Url, }?: {
+        min?: number;
+        max?: number;
+        length?: number;
+        rawLength?: number;
+        isBase64Url?: boolean;
+    }) => ZodEffects<ZodString>;
+    bearerToken: () => ZodEffects<ZodEffects<ZodString>>;
+    jwt: ({ max }: {
+        max: number;
+    }) => ZodEffects<ZodString>;
+    ecPublicKey: () => zod.ZodEffects<zod.ZodString, string, string>;
+    ecCompressedPublicKey: () => zod.ZodEffects<zod.ZodString, string, string>;
+    uncompressedECPublicKey: () => zod.ZodEffects<zod.ZodString, string, string>;
+    ecSignature: () => zod.ZodEffects<zod.ZodString, string, string>;
+    iv: () => zod.ZodEffects<zod.ZodString, string, string>;
+    mac: () => zod.ZodEffects<zod.ZodString, string, string>;
+    traceId: () => zod.ZodEffects<zod.ZodString, string, string>;
+    isoDateString: () => ZodEffects<ZodString, string>;
+    rfc3339String: () => ZodEffects<ZodString, string>;
+    iso8601Date: () => zod.ZodEffects<zod.ZodString, string, string>;
+    urlHttpsString: () => zod.ZodEffects<zod.ZodString, string, string>;
+    urlHttpOrHttpsString: () => zod.ZodEffects<zod.ZodString, string, string>;
+    language: () => ZodTypeAny;
+    dsgcPayload: () => zod.ZodObject<{
+        certificates: zod.ZodArray<zod.ZodObject<{
+            certificateType: zod.ZodString;
+            country: zod.ZodString;
+            kid: zod.ZodString;
+            rawData: zod.ZodString;
+            signature: zod.ZodString;
+            thumbprint: zod.ZodString;
+            timestamp: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            kid: string;
+            timestamp: string;
+            signature: string;
+            certificateType: string;
+            country: string;
+            rawData: string;
+            thumbprint: string;
+        }, {
+            kid: string;
+            timestamp: string;
+            signature: string;
+            certificateType: string;
+            country: string;
+            rawData: string;
+            thumbprint: string;
+        }>, "many">;
+    }, "strip", zod.ZodTypeAny, {
+        certificates: {
+            kid: string;
+            timestamp: string;
+            signature: string;
+            certificateType: string;
+            country: string;
+            rawData: string;
+            thumbprint: string;
+        }[];
+    }, {
+        certificates: {
+            kid: string;
+            timestamp: string;
+            signature: string;
+            certificateType: string;
+            country: string;
+            rawData: string;
+            thumbprint: string;
+        }[];
+    }>;
+    dccListPayload: () => zod.ZodArray<zod.ZodObject<{
+        identifier: zod.ZodString;
+        version: zod.ZodString;
+        country: zod.ZodString;
+        hash: zod.ZodString;
+    }, "strip", zod.ZodTypeAny, {
+        version: string;
+        country: string;
+        identifier: string;
+        hash: string;
+    }, {
+        version: string;
+        country: string;
+        identifier: string;
+        hash: string;
+    }>, "many">;
+    dccRulePayload: () => zod.ZodObject<{
+        Identifier: zod.ZodString;
+        Type: zod.ZodString;
+        Country: zod.ZodString;
+        Version: zod.ZodString;
+        SchemaVersion: zod.ZodString;
+        Engine: zod.ZodString;
+        EngineVersion: zod.ZodString;
+        CertificateType: zod.ZodString;
+        Description: zod.ZodArray<zod.ZodObject<{
+            lang: zod.ZodString;
+            desc: zod.ZodString;
+        }, "strip", zod.ZodTypeAny, {
+            lang: string;
+            desc: string;
+        }, {
+            lang: string;
+            desc: string;
+        }>, "many">;
+        ValidFrom: zod.ZodString;
+        ValidTo: zod.ZodString;
+        AffectedFields: zod.ZodArray<zod.ZodString, "many">;
+        Logic: zod.ZodAny;
+    }, "strip", zod.ZodTypeAny, {
+        Identifier: string;
+        Type: string;
+        Country: string;
+        Version: string;
+        SchemaVersion: string;
+        Engine: string;
+        EngineVersion: string;
+        CertificateType: string;
+        Description: {
+            lang: string;
+            desc: string;
+        }[];
+        ValidFrom: string;
+        ValidTo: string;
+        AffectedFields: string[];
+        Logic?: any;
+    }, {
+        Identifier: string;
+        Type: string;
+        Country: string;
+        Version: string;
+        SchemaVersion: string;
+        Engine: string;
+        EngineVersion: string;
+        CertificateType: string;
+        Description: {
+            lang: string;
+            desc: string;
+        }[];
+        ValidFrom: string;
+        ValidTo: string;
+        AffectedFields: string[];
+        Logic?: any;
+    }>;
+    setErrorMap(map: zod.ZodErrorMap): void;
+    getErrorMap(): zod.ZodErrorMap;
+    defaultErrorMap: zod.ZodErrorMap;
+    addIssueToContext(ctx: zod.ParseContext, issueData: zod.IssueData): void;
+    makeIssue: (params: {
+        data: any;
+        path: (string | number)[];
+        errorMaps: zod.ZodErrorMap[];
+        issueData: zod.IssueData;
+    }) => zod.ZodIssue;
+    EMPTY_PATH: zod.ParsePath;
+    ParseStatus: typeof zod.ParseStatus;
+    INVALID: zod.INVALID;
+    DIRTY: <T>(value: T) => zod.DIRTY<T>;
+    OK: <T>(value: T) => zod.OK<T>;
+    isAborted: (x: zod.ParseReturnType<any>) => x is zod.INVALID;
+    isDirty: <T>(x: zod.ParseReturnType<T>) => x is zod.OK<T> | zod.DIRTY<T>;
+    isValid: <T>(x: zod.ParseReturnType<T>) => x is zod.OK<T> | zod.DIRTY<T>;
+    isAsync: <T>(x: zod.ParseReturnType<T>) => x is zod.AsyncParseReturnType<T>;
+    util: typeof zod.util;
+    objectUtil: typeof zod.objectUtil;
+    ZodParsedType: {
+        function: "function";
+        number: "number";
+        string: "string";
+        nan: "nan";
+        integer: "integer";
+        float: "float";
+        boolean: "boolean";
+        date: "date";
+        bigint: "bigint";
+        symbol: "symbol";
+        undefined: "undefined";
+        null: "null";
+        array: "array";
+        object: "object";
+        unknown: "unknown";
+        promise: "promise";
+        void: "void";
+        never: "never";
+        map: "map";
+        set: "set";
+    };
+    getParsedType: (data: any) => zod.ZodParsedType;
+    ZodType: typeof zod.ZodType;
+    ZodString: typeof zod.ZodString;
+    ZodNumber: typeof zod.ZodNumber;
+    ZodBigInt: typeof zod.ZodBigInt;
+    ZodBoolean: typeof zod.ZodBoolean;
+    ZodDate: typeof zod.ZodDate;
+    ZodSymbol: typeof zod.ZodSymbol;
+    ZodUndefined: typeof zod.ZodUndefined;
+    ZodNull: typeof zod.ZodNull;
+    ZodAny: typeof zod.ZodAny;
+    ZodUnknown: typeof zod.ZodUnknown;
+    ZodNever: typeof zod.ZodNever;
+    ZodVoid: typeof zod.ZodVoid;
+    ZodArray: typeof zod.ZodArray;
+    ZodObject: typeof zod.ZodObject;
+    ZodUnion: typeof zod.ZodUnion;
+    ZodDiscriminatedUnion: typeof zod.ZodDiscriminatedUnion;
+    ZodIntersection: typeof zod.ZodIntersection;
+    ZodTuple: typeof zod.ZodTuple;
+    ZodRecord: typeof zod.ZodRecord;
+    ZodMap: typeof zod.ZodMap;
+    ZodSet: typeof zod.ZodSet;
+    ZodFunction: typeof zod.ZodFunction;
+    ZodLazy: typeof zod.ZodLazy;
+    ZodLiteral: typeof zod.ZodLiteral;
+    ZodEnum: typeof zod.ZodEnum;
+    ZodNativeEnum: typeof zod.ZodNativeEnum;
+    ZodPromise: typeof zod.ZodPromise;
+    ZodEffects: typeof zod.ZodEffects;
+    ZodTransformer: typeof zod.ZodEffects;
+    ZodOptional: typeof zod.ZodOptional;
+    ZodNullable: typeof zod.ZodNullable;
+    ZodDefault: typeof zod.ZodDefault;
+    ZodCatch: typeof zod.ZodCatch;
+    ZodNaN: typeof zod.ZodNaN;
+    BRAND: typeof zod.BRAND;
+    ZodBranded: typeof zod.ZodBranded;
+    ZodPipeline: typeof zod.ZodPipeline;
+    ZodReadonly: typeof zod.ZodReadonly;
+    custom: <T>(check?: ((data: unknown) => any) | undefined, params?: string | (Partial<zod.util.Omit<zod.ZodCustomIssue, "code">> & {
+        fatal?: boolean;
+    }) | ((input: any) => Partial<zod.util.Omit<zod.ZodCustomIssue, "code">> & {
+        fatal?: boolean;
+    }), fatal?: boolean | undefined) => ZodType<T, zod.ZodTypeDef, T>;
+    Schema: typeof zod.ZodType;
+    ZodSchema: typeof zod.ZodType;
+    late: {
+        object: <T extends zod.ZodRawShape>(shape: () => T, params?: zod.RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, { [k_1 in keyof zod.objectUtil.addQuestionMarks<zod.baseObjectOutputType<T>, { [k in keyof zod.baseObjectOutputType<T>]: undefined extends zod.baseObjectOutputType<T>[k] ? never : k; }[keyof T]>]: zod.objectUtil.addQuestionMarks<zod.baseObjectOutputType<T>, { [k in keyof zod.baseObjectOutputType<T>]: undefined extends zod.baseObjectOutputType<T>[k] ? never : k; }[keyof T]>[k_1]; }, { [k_2 in keyof zod.baseObjectInputType<T>]: zod.baseObjectInputType<T>[k_2]; }>;
+    };
+    ZodFirstPartyTypeKind: typeof zod.ZodFirstPartyTypeKind;
+    coerce: {
+        string: (params?: ({
+            errorMap?: zod.ZodErrorMap | undefined;
+            invalid_type_error?: string | undefined;
+            required_error?: string | undefined;
+            description?: string | undefined;
+        } & {
+            coerce?: true | undefined;
+        }) | undefined) => ZodString;
+        number: (params?: ({
+            errorMap?: zod.ZodErrorMap | undefined;
+            invalid_type_error?: string | undefined;
+            required_error?: string | undefined;
+            description?: string | undefined;
+        } & {
+            coerce?: boolean | undefined;
+        }) | undefined) => ZodNumber;
+        boolean: (params?: ({
+            errorMap?: zod.ZodErrorMap | undefined;
+            invalid_type_error?: string | undefined;
+            required_error?: string | undefined;
+            description?: string | undefined;
+        } & {
+            coerce?: boolean | undefined;
+        }) | undefined) => zod.ZodBoolean;
+        bigint: (params?: ({
+            errorMap?: zod.ZodErrorMap | undefined;
+            invalid_type_error?: string | undefined;
+            required_error?: string | undefined;
+            description?: string | undefined;
+        } & {
+            coerce?: boolean | undefined;
+        }) | undefined) => zod.ZodBigInt;
+        date: (params?: ({
+            errorMap?: zod.ZodErrorMap | undefined;
+            invalid_type_error?: string | undefined;
+            required_error?: string | undefined;
+            description?: string | undefined;
+        } & {
+            coerce?: boolean | undefined;
+        }) | undefined) => zod.ZodDate;
+    };
+    any: (params?: zod.RawCreateParams) => zod.ZodAny;
+    array: <T extends ZodTypeAny>(schema: T, params?: zod.RawCreateParams) => zod.ZodArray<T, "many">;
+    bigint: (params?: ({
+        errorMap?: zod.ZodErrorMap | undefined;
+        invalid_type_error?: string | undefined;
+        required_error?: string | undefined;
+        description?: string | undefined;
+    } & {
+        coerce?: boolean | undefined;
+    }) | undefined) => zod.ZodBigInt;
+    boolean: (params?: ({
+        errorMap?: zod.ZodErrorMap | undefined;
+        invalid_type_error?: string | undefined;
+        required_error?: string | undefined;
+        description?: string | undefined;
+    } & {
+        coerce?: boolean | undefined;
+    }) | undefined) => zod.ZodBoolean;
+    date: (params?: ({
+        errorMap?: zod.ZodErrorMap | undefined;
+        invalid_type_error?: string | undefined;
+        required_error?: string | undefined;
+        description?: string | undefined;
+    } & {
+        coerce?: boolean | undefined;
+    }) | undefined) => zod.ZodDate;
+    discriminatedUnion: typeof zod.ZodDiscriminatedUnion.create;
+    effect: <I extends ZodTypeAny>(schema: I, effect: zod.Effect<I["_output"]>, params?: zod.RawCreateParams) => ZodEffects<I, I["_output"], zod.input<I>>;
+    enum: {
+        <U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: zod.RawCreateParams): zod.ZodEnum<zod.Writeable<T>>;
+        <U extends string, T extends [U, ...U[]]>(values: T, params?: zod.RawCreateParams): zod.ZodEnum<T>;
+    };
+    function: typeof zod.ZodFunction.create;
+    instanceof: <T extends abstract new (..._: any[]) => {}>(cls: T, params?: Partial<zod.util.Omit<zod.ZodCustomIssue, "code">> & {
+        fatal?: boolean;
+    }) => ZodType<InstanceType<T>, zod.ZodTypeDef, InstanceType<T>>;
+    intersection: <T extends ZodTypeAny, U extends ZodTypeAny>(left: T, right: U, params?: zod.RawCreateParams) => zod.ZodIntersection<T, U>;
+    lazy: <T extends ZodTypeAny>(getter: () => T, params?: zod.RawCreateParams) => zod.ZodLazy<T>;
+    literal: <T extends zod.Primitive>(value: T, params?: zod.RawCreateParams) => zod.ZodLiteral<T>;
+    map: <Key extends ZodTypeAny = zod.ZodTypeAny, Value extends ZodTypeAny = zod.ZodTypeAny>(keyType: Key, valueType: Value, params?: zod.RawCreateParams) => zod.ZodMap<Key, Value>;
+    nan: (params?: zod.RawCreateParams) => zod.ZodNaN;
+    nativeEnum: <T extends zod.EnumLike>(values: T, params?: zod.RawCreateParams) => zod.ZodNativeEnum<T>;
+    never: (params?: zod.RawCreateParams) => zod.ZodNever;
+    null: (params?: zod.RawCreateParams) => zod.ZodNull;
+    nullable: <T extends ZodTypeAny>(type: T, params?: zod.RawCreateParams) => zod.ZodNullable<T>;
+    number: (params?: ({
+        errorMap?: zod.ZodErrorMap | undefined;
+        invalid_type_error?: string | undefined;
+        required_error?: string | undefined;
+        description?: string | undefined;
+    } & {
+        coerce?: boolean | undefined;
+    }) | undefined) => ZodNumber;
+    object: <T extends zod.ZodRawShape>(shape: T, params?: zod.RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, { [k_1 in keyof zod.objectUtil.addQuestionMarks<zod.baseObjectOutputType<T>, { [k in keyof zod.baseObjectOutputType<T>]: undefined extends zod.baseObjectOutputType<T>[k] ? never : k; }[keyof T]>]: zod.objectUtil.addQuestionMarks<zod.baseObjectOutputType<T>, { [k in keyof zod.baseObjectOutputType<T>]: undefined extends zod.baseObjectOutputType<T>[k] ? never : k; }[keyof T]>[k_1]; }, { [k_2 in keyof zod.baseObjectInputType<T>]: zod.baseObjectInputType<T>[k_2]; }>;
+    oboolean: () => zod.ZodOptional<zod.ZodBoolean>;
+    onumber: () => zod.ZodOptional<ZodNumber>;
+    optional: <T extends ZodTypeAny>(type: T, params?: zod.RawCreateParams) => zod.ZodOptional<T>;
+    ostring: () => zod.ZodOptional<ZodString>;
+    pipeline: typeof zod.ZodPipeline.create;
+    preprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: zod.RefinementCtx) => unknown, schema: I, params?: zod.RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
+    promise: <T extends ZodTypeAny>(schema: T, params?: zod.RawCreateParams) => zod.ZodPromise<T>;
+    record: typeof zod.ZodRecord.create;
+    set: <Value extends ZodTypeAny = zod.ZodTypeAny>(valueType: Value, params?: zod.RawCreateParams) => zod.ZodSet<Value>;
+    strictObject: <T extends zod.ZodRawShape>(shape: T, params?: zod.RawCreateParams) => ZodObject<T, "strict", ZodTypeAny, { [k_1 in keyof zod.objectUtil.addQuestionMarks<zod.baseObjectOutputType<T>, { [k in keyof zod.baseObjectOutputType<T>]: undefined extends zod.baseObjectOutputType<T>[k] ? never : k; }[keyof T]>]: zod.objectUtil.addQuestionMarks<zod.baseObjectOutputType<T>, { [k in keyof zod.baseObjectOutputType<T>]: undefined extends zod.baseObjectOutputType<T>[k] ? never : k; }[keyof T]>[k_1]; }, { [k_2 in keyof zod.baseObjectInputType<T>]: zod.baseObjectInputType<T>[k_2]; }>;
+    symbol: (params?: zod.RawCreateParams) => zod.ZodSymbol;
+    transformer: <I extends ZodTypeAny>(schema: I, effect: zod.Effect<I["_output"]>, params?: zod.RawCreateParams) => ZodEffects<I, I["_output"], zod.input<I>>;
+    tuple: <T extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(schemas: T, params?: zod.RawCreateParams) => zod.ZodTuple<T, null>;
+    undefined: (params?: zod.RawCreateParams) => zod.ZodUndefined;
+    union: <T extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T, params?: zod.RawCreateParams) => zod.ZodUnion<T>;
+    unknown: (params?: zod.RawCreateParams) => zod.ZodUnknown;
+    void: (params?: zod.RawCreateParams) => zod.ZodVoid;
+    NEVER: never;
+    ZodIssueCode: {
+        invalid_type: "invalid_type";
+        invalid_literal: "invalid_literal";
+        custom: "custom";
+        invalid_union: "invalid_union";
+        invalid_union_discriminator: "invalid_union_discriminator";
+        invalid_enum_value: "invalid_enum_value";
+        unrecognized_keys: "unrecognized_keys";
+        invalid_arguments: "invalid_arguments";
+        invalid_return_type: "invalid_return_type";
+        invalid_date: "invalid_date";
+        invalid_string: "invalid_string";
+        too_small: "too_small";
+        too_big: "too_big";
+        invalid_intersection_types: "invalid_intersection_types";
+        not_multiple_of: "not_multiple_of";
+        not_finite: "not_finite";
+    };
+    quotelessJson: (obj: any) => string;
+    ZodError: typeof zod.ZodError;
+};
+export * from 'zod';
+export { z };

package/dist/lib/validation.js

@@ -0,0 +1,431 @@
+"use strict";
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types, max-lines */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.z = exports.preprocessBooleanFromString = exports.preprocessBooleanFromQueryString = exports.preprocessNumberFromQueryString = exports.preprocessArrayFromQueryString = void 0;
+const url_1 = require("url");
+const zod_1 = require("zod");
+const validator_1 = __importDefault(require("validator"));
+const min_1 = require("libphonenumber-js/min");
+const api_1 = require("../lib/api");
+const money_1 = require("../lib/money/money");
+const supportedCurrencies_1 = require("../lib/money/supportedCurrencies");
+const language_1 = require("../lib/negotiator/language");
+(0, api_1.extendZodWithOpenApi)(zod_1.z);
+// Regular expressions
+const SAFE_CHARACTERS_REGEX = /^[\w !&()+,./:@`|£À-ÿāăąćĉċčđēėęěĝğģĥħĩīįİıĵķĸĺļłńņōőœŗřśŝşšţŦũūŭůűųŵŷźżžơưếệ–-]*$/i;
+const NO_HTTP_REGEX = /^((?!http).)*$/i;
+const NO_FTP_REGEX = /^((?!ftp).)*$/i;
+const ALPHANUMERIC_REGEX = /^[\da-z]+$/i;
+const ONBOARDING_BUSINESS_ENTITY_REGEX = /^[\w !&'()*+,./£À-ÿāăąćĉċčđēėęěĝğģĥħĩīįİıĵķĸĺļłńņōőœŗřśŝşšţŦũūŭůűųŵŷźżžơưếệ''-]+$/i;
+const ONBOARDING_NAME_REGEX = /^[\s'.A-Za-z£À-žơưếệ''-]+$/;
+const COUNTRY_CODE_REGEX = /^[A-Z]{2}$/;
+const PASSWORD_REQUIREMENTS = {
+    minLength: 9,
+    minNumbers: 1,
+    minLowercase: 1,
+    minUppercase: 1,
+    minSymbols: 1,
+};
+// Helper functions for query string preprocessing
+const preprocessArrayFromQueryString = (input) => {
+    if (typeof input !== 'string')
+        return undefined;
+    return input.split(',');
+};
+exports.preprocessArrayFromQueryString = preprocessArrayFromQueryString;
+const preprocessNumberFromQueryString = (input) => {
+    if (input === '')
+        return undefined;
+    return input ? Number(input) : input;
+};
+exports.preprocessNumberFromQueryString = preprocessNumberFromQueryString;
+const preprocessBooleanFromQueryString = (input) => {
+    if (input === '')
+        return undefined;
+    if (typeof input !== 'string')
+        return undefined;
+    return input.toLowerCase() !== 'false';
+};
+exports.preprocessBooleanFromQueryString = preprocessBooleanFromQueryString;
+// Alias for backward compatibility
+exports.preprocessBooleanFromString = exports.preprocessBooleanFromQueryString;
+// Helper function for money validation
+const isValidMoneyAmount = (number) => validator_1.default.isCurrency(number.toString(10), {
+    require_decimal: false,
+    allow_decimal: true,
+    negative_sign_after_digits: false,
+    allow_negatives: true,
+    digits_after_decimal: [1, 2],
+});
+// Helper function for updating money fields with currency
+const updateMoneyFieldsWithCurrency = (object) => {
+    const currency = object.currency;
+    Object.keys(object).forEach(key => {
+        const value = object[key];
+        if (value instanceof money_1.Money) {
+            if (!currency) {
+                throw new Error('currency is required to convert money fields');
+            }
+            // eslint-disable-next-line no-param-reassign
+            object[key] = money_1.Money.fromAmount(value.getAmount(), currency);
+        }
+    });
+};
+// Extended zod with custom validators
+const z = {
+    ...zod_1.z,
+    // Override string to always trim
+    string: () => zod_1.z.string().trim(),
+    // String validators
+    safeString: () => z
+        .string()
+        .trim()
+        .regex(SAFE_CHARACTERS_REGEX)
+        .regex(NO_HTTP_REGEX)
+        .regex(NO_FTP_REGEX),
+    safeText: () => z.string().trim().regex(NO_HTTP_REGEX).regex(NO_FTP_REGEX),
+    safeBusinessStringForOnboarding: () => zod_1.z
+        .string()
+        .regex(ONBOARDING_BUSINESS_ENTITY_REGEX)
+        .max(255)
+        .trim()
+        .min(1)
+        .transform(value => value.trimEnd())
+        .openapi({
+        type: 'string',
+        example: 'My Business',
+    }),
+    safeNameForOnboarding: () => zod_1.z
+        .string()
+        .regex(ONBOARDING_NAME_REGEX)
+        .max(255)
+        .trim()
+        .min(1)
+        .transform(value => value.trimEnd())
+        .openapi({
+        type: 'string',
+        example: 'Alex',
+    }),
+    nonemptyString: () => z.string().trim().min(1),
+    alphaNumericString: () => zod_1.z.string().regex(ALPHANUMERIC_REGEX),
+    tableId: () => z.string(),
+    // UUID validators
+    uuid: () => zod_1.z.string().trim().uuid(),
+    uuidv4: () => zod_1.z
+        .string()
+        .length(36)
+        .refine(value => validator_1.default.isUUID(value, '4')),
+    // Email validator
+    email: () => zod_1.z
+        .string()
+        .trim()
+        .email()
+        .max(255)
+        .refine(value => validator_1.default.isEmail(value, {
+        allow_display_name: false,
+        require_display_name: false,
+        allow_utf8_local_part: true,
+        require_tld: true,
+        allow_ip_domain: false,
+        // @ts-expect-error: double escape as this is passed into new RegExp("[${blacklisted_chars}]")
+        blacklisted_chars: "=',\\\\",
+    }))
+        .openapi({
+        type: 'string',
+        example: 'test@nexenio.com',
+    }),
+    // Phone number validators
+    phoneNumber: () => zod_1.z
+        .string()
+        .trim()
+        .max(32)
+        .refine(value => {
+        return (0, min_1.parsePhoneNumber)(value, 'DE').isValid();
+    }, {
+        message: 'invalid phone number',
+    })
+        .transform(value => {
+        return (0, min_1.parsePhoneNumber)(value, 'DE').formatInternational();
+    })
+        .openapi({
+        type: 'string',
+        example: '+4917712345678',
+    }),
+    nullablePhoneNumber: () => zod_1.z
+        .string()
+        .trim()
+        .max(32)
+        .refine(value => {
+        if (value === '')
+            return true;
+        return (0, min_1.parsePhoneNumber)(value, 'DE').isValid();
+    }, {
+        message: 'invalid phone number',
+    })
+        .transform(value => {
+        if (value === '')
+            return null;
+        return (0, min_1.parsePhoneNumber)(value, 'DE').formatInternational();
+    })
+        .openapi({
+        type: 'string',
+        example: '+4917712345678',
+    }),
+    // Password validator
+    strongPassword: () => zod_1.z
+        .string()
+        .refine(value => validator_1.default.isStrongPassword(value, PASSWORD_REQUIREMENTS)),
+    // Postal code validators
+    zipCode: (locale) => z
+        .string()
+        .trim()
+        .max(255)
+        .refine(value => validator_1.default.isPostalCode(value, locale || 'any')),
+    countryCode: () => zod_1.z.string().regex(COUNTRY_CODE_REGEX),
+    // Money validators
+    moneyDecimalString: (locale) => zod_1.z
+        .string()
+        .max(255)
+        .refine(value => validator_1.default.isCurrency(value, {
+        require_decimal: true,
+        negative_sign_after_digits: false,
+        allow_negatives: true,
+        digits_after_decimal: [2],
+        symbol: '€',
+        symbol_after_digits: true,
+        allow_space_after_digits: true,
+        decimal_separator: locale === 'de' ? ',' : '.',
+        thousands_separator: locale === 'de' ? '.' : ',',
+    })),
+    moneyFromFloat: () => z
+        .number()
+        .refine(isValidMoneyAmount)
+        .transform(value => money_1.Money.fromFloat(value, supportedCurrencies_1.SupportedCurrencies.EUR))
+        .openapi({
+        type: 'number',
+    }),
+    moneyFromInt: () => z
+        .number()
+        .int()
+        .nonnegative()
+        .transform(value => money_1.Money.fromAmount(value, supportedCurrencies_1.SupportedCurrencies.EUR))
+        .openapi({
+        type: 'integer',
+    }),
+    convertMoneyFieldsToCurrency: (schema) => {
+        return schema.refine((object) => {
+            try {
+                updateMoneyFieldsWithCurrency(object);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }, {
+            message: 'Currency is required to convert money fields.',
+            path: ['currency'],
+        });
+    },
+    // Number validators
+    unixTimestamp: () => zod_1.z.number().int().positive(),
+    integerString: (options = {}) => z
+        .integerStringRaw(options)
+        .transform(value => Number.parseInt(value, 10))
+        .openapi({
+        type: 'string',
+    }),
+    integerStringRaw: (options = {}) => zod_1.z
+        .string()
+        .max(options.maxLength || 17)
+        .refine(value => validator_1.default.isInt(value, {
+        lt: options.lt || Number.MAX_SAFE_INTEGER,
+        gt: options.gt || Number.MIN_SAFE_INTEGER,
+        allow_leading_zeroes: false,
+    })),
+    bigIntegerString: () => zod_1.z
+        .string()
+        .max(2048)
+        .refine(value => validator_1.default.isInt(value, {
+        allow_leading_zeroes: false,
+    })),
+    floatString: (options) => zod_1.z
+        .string()
+        .max(options?.maxLength || 17)
+        .refine(value => validator_1.default.isFloat(value, {
+        lt: options?.lt || Number.MAX_SAFE_INTEGER,
+        gt: options?.gt || Number.MIN_SAFE_INTEGER,
+    }))
+        .transform(value => Number.parseFloat(value))
+        .openapi({
+        type: 'string',
+    }),
+    // Encoding validators
+    hex: ({ min, max, length, rawLength, } = {}) => zod_1.z
+        .string()
+        .min(min)
+        .max(max)
+        .length(length)
+        .refine(value => {
+        if (!validator_1.default.isHexadecimal(value))
+            return false;
+        if (!rawLength)
+            return true;
+        return Buffer.from(value, 'hex').length === rawLength;
+    }),
+    sha256: () => z.hex({ length: 64, rawLength: 32 }),
+    base64: ({ min, max, length, rawLength, isBase64Url = false, } = {}) => {
+        let schema = zod_1.z.string();
+        if (min !== undefined)
+            schema = schema.min(min);
+        if (max !== undefined)
+            schema = schema.max(max);
+        if (length !== undefined)
+            schema = schema.length(length);
+        return schema.refine(value => {
+            if (!validator_1.default.isBase64(value, { urlSafe: isBase64Url }))
+                return false;
+            if (!rawLength)
+                return true;
+            return (Buffer.from(value, isBase64Url ? 'base64url' : 'base64').length ===
+                rawLength);
+        });
+    },
+    bearerToken: () => zod_1.z
+        .string()
+        .trim()
+        .min(28)
+        .max(255)
+        .refine(value => {
+        return validator_1.default.isBase64(value.replace('Bearer ', ''));
+    })
+        .transform(value => value.replace('Bearer ', ''))
+        .openapi({
+        type: 'string',
+    }),
+    jwt: ({ max }) => z
+        .string()
+        .trim()
+        .max(max)
+        .refine(value => validator_1.default.isJWT(value)),
+    // Cryptographic validators
+    ecPublicKey: () => z.base64({ length: 88, rawLength: 65 }),
+    ecCompressedPublicKey: () => z.base64({ length: 44, rawLength: 33 }),
+    uncompressedECPublicKey: () => {
+        let schema = zod_1.z.string();
+        schema = schema.length(88);
+        return schema.refine(value => {
+            if (!validator_1.default.isBase64(value))
+                return false;
+            return Buffer.from(value, 'base64').length === 65;
+        });
+    },
+    ecSignature: () => z.base64({ max: 120 }),
+    iv: () => z.base64({ length: 24, rawLength: 16 }),
+    mac: () => z.base64({ length: 44, rawLength: 32 }),
+    traceId: () => z.base64({ length: 24, rawLength: 16 }),
+    // Date validators
+    isoDateString: () => z
+        .string()
+        .trim()
+        .refine(value => {
+        return validator_1.default.isISO8601(value, {
+            strict: true,
+        });
+    })
+        .openapi({
+        type: 'string',
+        format: 'date-time',
+        example: '2021-01-30T08:30:00Z',
+    }),
+    rfc3339String: () => z
+        .string()
+        .trim()
+        .refine(value => {
+        return validator_1.default.isRFC3339(value);
+    })
+        .openapi({
+        type: 'string',
+        format: 'date-time',
+        example: '2021-01-30T08:30:00Z',
+    }),
+    iso8601Date: () => zod_1.z.string().refine(value => validator_1.default.isISO8601(value)),
+    // URL validators
+    urlHttpsString: () => zod_1.z
+        .string()
+        .max(255)
+        .refine(value => validator_1.default.isURL(value, {
+        require_protocol: true,
+        protocols: ['https'],
+        allow_protocol_relative_urls: false,
+        disallow_auth: true,
+        require_host: true,
+    }) && validator_1.default.isFQDN(new url_1.URL(value).hostname), {
+        message: 'invalid url',
+    }),
+    urlHttpOrHttpsString: () => zod_1.z
+        .string()
+        .max(255)
+        .refine(value => validator_1.default.isURL(value, {
+        require_protocol: true,
+        protocols: ['http', 'https'],
+        allow_protocol_relative_urls: false,
+        disallow_auth: true,
+        require_host: true,
+    }) && validator_1.default.isFQDN(new url_1.URL(value).hostname), {
+        message: 'invalid url',
+    }),
+    // Language validator
+    language: () => z.enum(language_1.AVAILABLE_LANGUAGES),
+    // DCC/DSGC validators (for COVID certificate validation)
+    dsgcPayload: () => zod_1.z.object({
+        certificates: zod_1.z.array(zod_1.z.object({
+            certificateType: zod_1.z.string(),
+            country: zod_1.z.string(),
+            kid: zod_1.z.string(),
+            rawData: zod_1.z.string(),
+            signature: zod_1.z.string(),
+            thumbprint: zod_1.z.string(),
+            timestamp: zod_1.z.string(),
+        })),
+    }),
+    dccListPayload: () => zod_1.z.array(zod_1.z.object({
+        identifier: zod_1.z.string(),
+        version: zod_1.z.string(),
+        country: zod_1.z.string().length(2),
+        hash: zod_1.z.string(),
+    })),
+    dccRulePayload: () => zod_1.z.object({
+        Identifier: zod_1.z.string(),
+        Type: zod_1.z.string(),
+        Country: zod_1.z.string().length(2),
+        Version: zod_1.z.string(),
+        SchemaVersion: zod_1.z.string(),
+        Engine: zod_1.z.string(),
+        EngineVersion: zod_1.z.string(),
+        CertificateType: zod_1.z.string(),
+        Description: zod_1.z.array(zod_1.z.object({ lang: zod_1.z.string().length(2), desc: zod_1.z.string() })),
+        ValidFrom: zod_1.z.string(),
+        ValidTo: zod_1.z.string(),
+        AffectedFields: zod_1.z.array(zod_1.z.string()),
+        Logic: zod_1.z.any(),
+    }),
+};
+exports.z = z;
+__exportStar(require("zod"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lucaapp/service-utils",
-  "version": "4.9.1",
+  "version": "4.11.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -28,6 +28,7 @@
     "@types/node": "22.13.11",
     "@types/response-time": "^2.3.9",
     "@types/swagger-ui-express": "4.1.8",
+    "@types/validator": "13.7.1",
     "axios": "^1.12.2",
     "axios-rate-limit": "^1.4.0",
     "axios-retry": "^4.5.0",
@@ -52,6 +53,7 @@
     "swagger-ui-express": "5.0.1",
     "url-value-parser": "^2.2.0",
     "uuid": "^9.0.0",
+    "validator": "13.7.0",
     "zod": "3.22.3"
   },
   "devDependencies": {