@lucaapp/service-utils 4.10.0 → 4.12.0

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 };