@open-norantec/utilities 1.0.1-alpha.9 → 2.0.0-alpha.0

package/dist/schemas.d.ts

@@ -0,0 +1,498 @@
+import { z } from './zod';
+export declare namespace Schemas {
+    const ID: z.ZodUUID;
+    const ID_LIST: z.ZodArray<z.ZodUUID>;
+    const ID_LIST_OBJECT: z.ZodObject<{
+        idList: z.ZodArray<z.ZodUUID>;
+    }, z.core.$strip>;
+    const ID_OBJECT: z.ZodObject<{
+        id: z.ZodUUID;
+    }, z.core.$strip>;
+    const JSON_STRING: z.ZodString;
+    const DATE_STRING: z.ZodString;
+    const TIME_RECORD: z.ZodObject<{
+        createdAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    const ORDER_ORIENTATION: z.ZodEnum<{
+        ASC: "ASC";
+        DESC: "DESC";
+    }>;
+    const WHERE_CLAUSE_OP: z.ZodEnum<{
+        values: "values";
+        adjacent: "adjacent";
+        any: "any";
+        between: "between";
+        col: "col";
+        contained: "contained";
+        contains: "contains";
+        endsWith: "endsWith";
+        eq: "eq";
+        gt: "gt";
+        gte: "gte";
+        iLike: "iLike";
+        in: "in";
+        iRegexp: "iRegexp";
+        is: "is";
+        like: "like";
+        lt: "lt";
+        lte: "lte";
+        match: "match";
+        ne: "ne";
+        noExtendLeft: "noExtendLeft";
+        noExtendRight: "noExtendRight";
+        not: "not";
+        notBetween: "notBetween";
+        notILike: "notILike";
+        notIn: "notIn";
+        notIRegexp: "notIRegexp";
+        notLike: "notLike";
+        notRegexp: "notRegexp";
+        overlap: "overlap";
+        placeholder: "placeholder";
+        regexp: "regexp";
+        startsWith: "startsWith";
+        strictLeft: "strictLeft";
+        strictRight: "strictRight";
+        substring: "substring";
+    }>;
+    const LOG_LEVEL: z.ZodEnum<{
+        error: "error";
+        warn: "warn";
+        info: "info";
+        verbose: "verbose";
+        debug: "debug";
+    }>;
+    const COMMON_RESULT: z.ZodObject<{
+        succeeded: z.ZodBoolean;
+        content: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodUUID>;
+        createdAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    const WHERE_CLAUSE: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        field: z.ZodString;
+        op: z.ZodEnum<{
+            values: "values";
+            adjacent: "adjacent";
+            any: "any";
+            between: "between";
+            col: "col";
+            contained: "contained";
+            contains: "contains";
+            endsWith: "endsWith";
+            eq: "eq";
+            gt: "gt";
+            gte: "gte";
+            iLike: "iLike";
+            in: "in";
+            iRegexp: "iRegexp";
+            is: "is";
+            like: "like";
+            lt: "lt";
+            lte: "lte";
+            match: "match";
+            ne: "ne";
+            noExtendLeft: "noExtendLeft";
+            noExtendRight: "noExtendRight";
+            not: "not";
+            notBetween: "notBetween";
+            notILike: "notILike";
+            notIn: "notIn";
+            notIRegexp: "notIRegexp";
+            notLike: "notLike";
+            notRegexp: "notRegexp";
+            overlap: "overlap";
+            placeholder: "placeholder";
+            regexp: "regexp";
+            startsWith: "startsWith";
+            strictLeft: "strictLeft";
+            strictRight: "strictRight";
+            substring: "substring";
+        }>;
+        type: z.ZodLiteral<"condition">;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        literal: z.ZodString;
+        params: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+        type: z.ZodLiteral<"literal">;
+    }, z.core.$strip>], "type">;
+    const CONDITION_ONLY_WHERE_CLAUSE: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        field: z.ZodString;
+        op: z.ZodEnum<{
+            values: "values";
+            adjacent: "adjacent";
+            any: "any";
+            between: "between";
+            col: "col";
+            contained: "contained";
+            contains: "contains";
+            endsWith: "endsWith";
+            eq: "eq";
+            gt: "gt";
+            gte: "gte";
+            iLike: "iLike";
+            in: "in";
+            iRegexp: "iRegexp";
+            is: "is";
+            like: "like";
+            lt: "lt";
+            lte: "lte";
+            match: "match";
+            ne: "ne";
+            noExtendLeft: "noExtendLeft";
+            noExtendRight: "noExtendRight";
+            not: "not";
+            notBetween: "notBetween";
+            notILike: "notILike";
+            notIn: "notIn";
+            notIRegexp: "notIRegexp";
+            notLike: "notLike";
+            notRegexp: "notRegexp";
+            overlap: "overlap";
+            placeholder: "placeholder";
+            regexp: "regexp";
+            startsWith: "startsWith";
+            strictLeft: "strictLeft";
+            strictRight: "strictRight";
+            substring: "substring";
+        }>;
+        type: z.ZodLiteral<"condition">;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        literal: z.ZodString;
+        params: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+        type: z.ZodLiteral<"literal">;
+    }, z.core.$strip>], "type">;
+    const ORDER_ITEM: z.ZodObject<{
+        field: z.ZodString;
+        orientation: z.ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>;
+    }, z.core.$strip>;
+    const PAGINATION_OPTIONS: z.ZodObject<{
+        cursorField: z.ZodUnion<readonly [z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodUndefined]>;
+        cursorFieldOrderOrientation: z.ZodUnion<readonly [z.ZodDefault<z.ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>, z.ZodUndefined]>;
+        lastCursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        search: z.ZodOptional<z.ZodObject<{
+            fields: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                field: z.ZodString;
+                ratio: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            }, z.core.$strip>]>>;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        order: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            orientation: z.ZodEnum<{
+                ASC: "ASC";
+                DESC: "DESC";
+            }>;
+        }, z.core.$strip>>>;
+        orderField: z.ZodUnion<readonly [z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodUndefined]>;
+        orderFieldOrderOrientation: z.ZodUnion<readonly [z.ZodDefault<z.ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>, z.ZodUndefined]>;
+        where: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                values: "values";
+                adjacent: "adjacent";
+                any: "any";
+                between: "between";
+                col: "col";
+                contained: "contained";
+                contains: "contains";
+                endsWith: "endsWith";
+                eq: "eq";
+                gt: "gt";
+                gte: "gte";
+                iLike: "iLike";
+                in: "in";
+                iRegexp: "iRegexp";
+                is: "is";
+                like: "like";
+                lt: "lt";
+                lte: "lte";
+                match: "match";
+                ne: "ne";
+                noExtendLeft: "noExtendLeft";
+                noExtendRight: "noExtendRight";
+                not: "not";
+                notBetween: "notBetween";
+                notILike: "notILike";
+                notIn: "notIn";
+                notIRegexp: "notIRegexp";
+                notLike: "notLike";
+                notRegexp: "notRegexp";
+                overlap: "overlap";
+                placeholder: "placeholder";
+                regexp: "regexp";
+                startsWith: "startsWith";
+                strictLeft: "strictLeft";
+                strictRight: "strictRight";
+                substring: "substring";
+            }>;
+            type: z.ZodLiteral<"condition">;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            literal: z.ZodString;
+            params: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+            type: z.ZodLiteral<"literal">;
+        }, z.core.$strip>], "type">>>>;
+    }, z.core.$strip>;
+    const FIND_ONE_OPTIONS: z.ZodObject<{
+        search: z.ZodOptional<z.ZodObject<{
+            fields: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                field: z.ZodString;
+                ratio: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            }, z.core.$strip>]>>;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        cursorField: z.ZodUnion<readonly [z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodUndefined]>;
+        cursorFieldOrderOrientation: z.ZodUnion<readonly [z.ZodDefault<z.ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>, z.ZodUndefined]>;
+        order: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            orientation: z.ZodEnum<{
+                ASC: "ASC";
+                DESC: "DESC";
+            }>;
+        }, z.core.$strip>>>;
+        orderField: z.ZodUnion<readonly [z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodUndefined]>;
+        orderFieldOrderOrientation: z.ZodUnion<readonly [z.ZodDefault<z.ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>, z.ZodUndefined]>;
+        where: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                values: "values";
+                adjacent: "adjacent";
+                any: "any";
+                between: "between";
+                col: "col";
+                contained: "contained";
+                contains: "contains";
+                endsWith: "endsWith";
+                eq: "eq";
+                gt: "gt";
+                gte: "gte";
+                iLike: "iLike";
+                in: "in";
+                iRegexp: "iRegexp";
+                is: "is";
+                like: "like";
+                lt: "lt";
+                lte: "lte";
+                match: "match";
+                ne: "ne";
+                noExtendLeft: "noExtendLeft";
+                noExtendRight: "noExtendRight";
+                not: "not";
+                notBetween: "notBetween";
+                notILike: "notILike";
+                notIn: "notIn";
+                notIRegexp: "notIRegexp";
+                notLike: "notLike";
+                notRegexp: "notRegexp";
+                overlap: "overlap";
+                placeholder: "placeholder";
+                regexp: "regexp";
+                startsWith: "startsWith";
+                strictLeft: "strictLeft";
+                strictRight: "strictRight";
+                substring: "substring";
+            }>;
+            type: z.ZodLiteral<"condition">;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            literal: z.ZodString;
+            params: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+            type: z.ZodLiteral<"literal">;
+        }, z.core.$strip>], "type">>>>;
+    }, z.core.$strip>;
+    const PAGINATION_RESULT: z.ZodObject<{
+        hasNext: z.ZodBoolean;
+        nextCursor: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+        previousCursor: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+    }, z.core.$strip>;
+    const FILE: z.ZodObject<{
+        mimeType: z.ZodString;
+        name: z.ZodString;
+        progres: z.ZodNumber;
+        size: z.ZodNumber;
+        url: z.ZodString;
+        createdAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        updatedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    const CONDITION_ONLY_PAGINATION_OPTIONS: z.ZodObject<{
+        search: z.ZodOptional<z.ZodObject<{
+            fields: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                field: z.ZodString;
+                ratio: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            }, z.core.$strip>]>>;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        cursorField: z.ZodUnion<readonly [z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodUndefined]>;
+        cursorFieldOrderOrientation: z.ZodUnion<readonly [z.ZodDefault<z.ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>, z.ZodUndefined]>;
+        lastCursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        order: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            orientation: z.ZodEnum<{
+                ASC: "ASC";
+                DESC: "DESC";
+            }>;
+        }, z.core.$strip>>>;
+        orderField: z.ZodUnion<readonly [z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodUndefined]>;
+        orderFieldOrderOrientation: z.ZodUnion<readonly [z.ZodDefault<z.ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>, z.ZodUndefined]>;
+        where: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                values: "values";
+                adjacent: "adjacent";
+                any: "any";
+                between: "between";
+                col: "col";
+                contained: "contained";
+                contains: "contains";
+                endsWith: "endsWith";
+                eq: "eq";
+                gt: "gt";
+                gte: "gte";
+                iLike: "iLike";
+                in: "in";
+                iRegexp: "iRegexp";
+                is: "is";
+                like: "like";
+                lt: "lt";
+                lte: "lte";
+                match: "match";
+                ne: "ne";
+                noExtendLeft: "noExtendLeft";
+                noExtendRight: "noExtendRight";
+                not: "not";
+                notBetween: "notBetween";
+                notILike: "notILike";
+                notIn: "notIn";
+                notIRegexp: "notIRegexp";
+                notLike: "notLike";
+                notRegexp: "notRegexp";
+                overlap: "overlap";
+                placeholder: "placeholder";
+                regexp: "regexp";
+                startsWith: "startsWith";
+                strictLeft: "strictLeft";
+                strictRight: "strictRight";
+                substring: "substring";
+            }>;
+            type: z.ZodLiteral<"condition">;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            literal: z.ZodString;
+            params: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+            type: z.ZodLiteral<"literal">;
+        }, z.core.$strip>], "type">>>>;
+    }, z.core.$strip>;
+    const CONDITION_ONLY_FIND_ONE_OPTIONS: z.ZodObject<{
+        search: z.ZodOptional<z.ZodObject<{
+            fields: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                field: z.ZodString;
+                ratio: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+            }, z.core.$strip>]>>;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        cursorField: z.ZodUnion<readonly [z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodUndefined]>;
+        cursorFieldOrderOrientation: z.ZodUnion<readonly [z.ZodDefault<z.ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>, z.ZodUndefined]>;
+        order: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            orientation: z.ZodEnum<{
+                ASC: "ASC";
+                DESC: "DESC";
+            }>;
+        }, z.core.$strip>>>;
+        orderField: z.ZodUnion<readonly [z.ZodDefault<z.ZodOptional<z.ZodString>>, z.ZodUndefined]>;
+        orderFieldOrderOrientation: z.ZodUnion<readonly [z.ZodDefault<z.ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>>, z.ZodUndefined]>;
+        where: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                values: "values";
+                adjacent: "adjacent";
+                any: "any";
+                between: "between";
+                col: "col";
+                contained: "contained";
+                contains: "contains";
+                endsWith: "endsWith";
+                eq: "eq";
+                gt: "gt";
+                gte: "gte";
+                iLike: "iLike";
+                in: "in";
+                iRegexp: "iRegexp";
+                is: "is";
+                like: "like";
+                lt: "lt";
+                lte: "lte";
+                match: "match";
+                ne: "ne";
+                noExtendLeft: "noExtendLeft";
+                noExtendRight: "noExtendRight";
+                not: "not";
+                notBetween: "notBetween";
+                notILike: "notILike";
+                notIn: "notIn";
+                notIRegexp: "notIRegexp";
+                notLike: "notLike";
+                notRegexp: "notRegexp";
+                overlap: "overlap";
+                placeholder: "placeholder";
+                regexp: "regexp";
+                startsWith: "startsWith";
+                strictLeft: "strictLeft";
+                strictRight: "strictRight";
+                substring: "substring";
+            }>;
+            type: z.ZodLiteral<"condition">;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            literal: z.ZodString;
+            params: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+            type: z.ZodLiteral<"literal">;
+        }, z.core.$strip>], "type">>>>;
+    }, z.core.$strip>;
+}
+export declare namespace SchemaTypes {
+    type CommonResult = z.output<typeof Schemas.COMMON_RESULT>;
+    type File = z.infer<typeof Schemas.FILE>;
+    type FindOneOptions = z.infer<typeof Schemas.FIND_ONE_OPTIONS>;
+    type IDObject = z.infer<typeof Schemas.ID_OBJECT>;
+    type LogLevel = z.infer<typeof Schemas.LOG_LEVEL>;
+    type OrderItem = z.infer<typeof Schemas.ORDER_ITEM>;
+    type OrderOrientation = z.infer<typeof Schemas.ORDER_ORIENTATION>;
+    type PaginationOptions = z.infer<typeof Schemas.PAGINATION_OPTIONS>;
+    type PaginationResult = z.infer<typeof Schemas.PAGINATION_RESULT>;
+    type TimeRecord = z.infer<typeof Schemas.TIME_RECORD>;
+    type WhereClause = z.infer<typeof Schemas.WHERE_CLAUSE>;
+    type WhereClauseOp = z.infer<typeof Schemas.WHERE_CLAUSE_OP>;
+}

package/dist/schemas.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schemas = void 0;
+const date_util_class_1 = require("./date-util.class");
+const enum_util_class_1 = require("./enum-util.class");
+const enums_1 = require("./enums");
+const zod_1 = require("./zod");
+const FIND_ONE_OPTIONS_OMIT_PARAMS = {
+    limit: true,
+    lastCursor: true,
+};
+var Schemas;
+(function (Schemas) {
+    Schemas.ID = zod_1.z.uuid();
+    Schemas.ID_LIST = zod_1.z.array(Schemas.ID).min(1);
+    Schemas.ID_LIST_OBJECT = zod_1.z.object({
+        idList: Schemas.ID_LIST,
+    });
+    Schemas.ID_OBJECT = zod_1.z.object({
+        id: Schemas.ID,
+    });
+    Schemas.JSON_STRING = zod_1.z.string().refine((value) => {
+        try {
+            JSON.parse(value);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+    Schemas.DATE_STRING = zod_1.z.string().refine((value) => date_util_class_1.DateUtil.isValidDateString(value));
+    Schemas.TIME_RECORD = zod_1.z.object({
+        createdAt: Schemas.DATE_STRING.nullable().optional(),
+        updatedAt: Schemas.DATE_STRING.nullable().optional(),
+    });
+    Schemas.ORDER_ORIENTATION = enum_util_class_1.EnumUtil.createEnumSchema(enums_1.Enums.OrderOrientation);
+    Schemas.WHERE_CLAUSE_OP = enum_util_class_1.EnumUtil.createEnumSchema(enums_1.Enums.WhereClauseOp);
+    Schemas.LOG_LEVEL = enum_util_class_1.EnumUtil.createEnumSchema(enums_1.Enums.LogLevel);
+    Schemas.COMMON_RESULT = zod_1.z
+        .object({
+        succeeded: zod_1.z.boolean(),
+        content: zod_1.z.string().optional(),
+    })
+        .extend(Schemas.ID_OBJECT.partial().shape)
+        .extend(Schemas.TIME_RECORD.shape);
+    Schemas.WHERE_CLAUSE = zod_1.z.discriminatedUnion('type', [
+        zod_1.z.object({
+            field: zod_1.z.string(),
+            op: Schemas.WHERE_CLAUSE_OP,
+            type: zod_1.z.literal('condition'),
+            value: Schemas.JSON_STRING,
+        }),
+        zod_1.z.object({
+            literal: zod_1.z.string().min(1),
+            params: zod_1.z.array(zod_1.z.any()).optional(),
+            type: zod_1.z.literal('literal'),
+        }),
+    ]);
+    Schemas.CONDITION_ONLY_WHERE_CLAUSE = Schemas.WHERE_CLAUSE.superRefine((value, context) => {
+        if ((value === null || value === void 0 ? void 0 : value.type) === 'literal') {
+            context.addIssue({
+                code: 'custom',
+                message: 'Literal where clause item is strictly forbidden for safety reasons',
+            });
+        }
+    });
+    Schemas.ORDER_ITEM = zod_1.z.object({
+        field: zod_1.z.string(),
+        orientation: Schemas.ORDER_ORIENTATION,
+    });
+    Schemas.PAGINATION_OPTIONS = zod_1.z.object({
+        cursorField: zod_1.z.union([zod_1.z.string().optional().default('id'), zod_1.z.undefined()]),
+        cursorFieldOrderOrientation: zod_1.z.union([Schemas.ORDER_ORIENTATION.default('DESC'), zod_1.z.undefined()]),
+        lastCursor: zod_1.z.string().optional(),
+        limit: zod_1.z.number().min(0).optional(),
+        search: zod_1.z
+            .object({
+            fields: zod_1.z.array(zod_1.z.union([
+                zod_1.z.string().min(1),
+                zod_1.z.object({
+                    field: zod_1.z.string().min(1),
+                    ratio: zod_1.z.number().min(-1).max(1).optional().default(1),
+                }),
+            ])),
+            value: zod_1.z.string().min(1),
+        })
+            .optional(),
+        order: zod_1.z.array(Schemas.ORDER_ITEM).optional(),
+        orderField: zod_1.z.union([zod_1.z.string().optional().default('createdAt'), zod_1.z.undefined()]),
+        orderFieldOrderOrientation: zod_1.z.union([Schemas.ORDER_ORIENTATION.default('DESC'), zod_1.z.undefined()]),
+        where: zod_1.z.array(zod_1.z.array(Schemas.WHERE_CLAUSE).min(1)).optional(),
+    });
+    Schemas.FIND_ONE_OPTIONS = Schemas.PAGINATION_OPTIONS.omit(FIND_ONE_OPTIONS_OMIT_PARAMS);
+    Schemas.PAGINATION_RESULT = zod_1.z.object({
+        hasNext: zod_1.z.boolean(),
+        nextCursor: zod_1.z.union([zod_1.z.string(), zod_1.z.null()]),
+        previousCursor: zod_1.z.union([zod_1.z.string(), zod_1.z.null()]),
+    });
+    Schemas.FILE = zod_1.z
+        .object({
+        mimeType: zod_1.z.string(),
+        name: zod_1.z.string(),
+        progres: zod_1.z.number().min(0).max(1),
+        size: zod_1.z.number().min(0),
+        url: zod_1.z.string(),
+    })
+        .extend(Schemas.TIME_RECORD.shape);
+    Schemas.CONDITION_ONLY_PAGINATION_OPTIONS = Schemas.PAGINATION_OPTIONS.omit({
+        where: true,
+    }).extend({ where: zod_1.z.array(zod_1.z.array(Schemas.CONDITION_ONLY_WHERE_CLAUSE).min(1)).optional() });
+    Schemas.CONDITION_ONLY_FIND_ONE_OPTIONS = Schemas.CONDITION_ONLY_PAGINATION_OPTIONS.omit(FIND_ONE_OPTIONS_OMIT_PARAMS);
+})(Schemas || (exports.Schemas = Schemas = {}));
+console.log(Schemas.COMMON_RESULT.toJSONSchema());

package/dist/zod.d.ts

@@ -0,0 +1 @@
+export * from 'zod';

package/dist/zod.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("zod"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@open-norantec/utilities",
-    "version": "1.0.1-alpha.9",
+    "version": "2.0.0-alpha.0",
     "description": "NoranTec Utilities",
     "main": "dist/index.js",
     "scripts": {
@@ -30,23 +30,24 @@
     },
     "homepage": "https://github.com/norantec/utilities#readme",
     "devDependencies": {
-        "@stylistic/eslint-plugin": "^2.12.1",
         "@types/colors": "^1.1.3",
         "@types/node": "18.11.18",
-        "@typescript-eslint/eslint-plugin": "^8.0.0",
-        "@typescript-eslint/parser": "^8.0.0",
         "cross-env": "^7.0.3",
-        "eslint": "^8.0.0",
-        "eslint-config-prettier": "^9.0.0",
-        "eslint-plugin-prettier": "^5.0.0",
-        "prettier": "^3.0.0",
+        "eslint": "^10.3.0",
         "rimraf": "^6.0.1",
         "ts-node": "^10.0.0",
         "type-fest": "^4.37.0",
         "typescript": "~5.1.3"
     },
     "dependencies": {
+        "@stylistic/eslint-plugin": "5.10.0",
+        "@typescript-eslint/eslint-plugin": "^8.0.0",
+        "@typescript-eslint/parser": "^8.0.0",
         "colors": "^1.4.0",
-        "zod": "^3.25.67"
+        "eslint-config-prettier": "^10.0.0",
+        "eslint-plugin-prettier": "^5.0.0",
+        "prettier": "^3.0.0",
+        "uuid": "^11.1.0",
+        "zod": "^4.4.3"
     }
 }