@forklaunch/validator 0.3.12 → 0.4.0

package/lib/src/typebox/typeboxSchemaValidator.js

@@ -1,362 +0,0 @@
-/**
- * This module provides a TypeScript-based schema definition using the TypeBox library.
- * It includes various types, schema creation, validation, and OpenAPI integration.
- *
- * @module TypeboxSchemaValidator
- */
-import { Kind, KindGuard, Type } from '@sinclair/typebox';
-import { TypeCheck, TypeCompiler } from '@sinclair/typebox/compiler';
-import { DefaultErrorFunction, SetErrorFunction, ValueErrorType } from '@sinclair/typebox/errors';
-import { Value } from '@sinclair/typebox/value';
-/**
- * Typebox custom error function
- */
-SetErrorFunction((params) => {
-    switch (params.errorType) {
-        case ValueErrorType.Union:
-        case ValueErrorType.Array:
-        case ValueErrorType.String:
-        case ValueErrorType.Number:
-            return params.schema.errorType
-                ? `Expected ${params.schema.errorType} value${params.schema.errorSuffix ? 's' : ''}`
-                : DefaultErrorFunction(params);
-        default:
-            return DefaultErrorFunction(params);
-    }
-});
-/**
- * Class representing a TypeBox schema definition.
- * @implements {SchemaValidator}
- */
-export class TypeboxSchemaValidator {
-    _Type;
-    _SchemaCatchall;
-    _ValidSchemaObject;
-    string = Type.String();
-    // uuid = Type.String({ format: 'uuid' });
-    uuid = Type.String({
-        pattern: '^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$',
-        errorType: 'uuid'
-    });
-    uri = Type.String({
-        pattern: '^[a-zA-Z][a-zA-Z\\d+-.]*:[^\\s]*$',
-        errorType: 'uri'
-    });
-    email = Type.String({
-        pattern: '(?:[a-z0-9!#$%&\'*+/=?^_{|}~-]+(?:\\.[a-z0-9!#$%&\'*+/=?^_{|}~-]+)*|"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)])',
-        errorType: 'email'
-    });
-    number = Type.Transform(Type.Union([
-        Type.Number(),
-        Type.String({ pattern: '^[0-9]+$' }),
-        Type.Boolean(),
-        Type.Null(),
-        Type.Date(),
-        Type.BigInt()
-    ], {
-        errorType: 'number-like',
-        openapiType: Type.Number()
-    }))
-        .Decode((value) => {
-        if (typeof value !== 'number') {
-            const num = Number(value);
-            if (isNaN(num)) {
-                throw new Error('Invalid number');
-            }
-            else {
-                return num;
-            }
-        }
-        return value;
-    })
-        .Encode(Number);
-    bigint = Type.Transform(Type.Union([
-        Type.BigInt(),
-        Type.Number(),
-        Type.String({ pattern: '^[0-9]+$' }),
-        Type.Boolean(),
-        Type.Date()
-    ], {
-        errorType: 'BigInt-like',
-        openapiType: Type.BigInt()
-    }))
-        .Decode((value) => {
-        if (typeof value !== 'bigint') {
-            try {
-                return BigInt(value instanceof Date ? value.getTime() : value);
-            }
-            catch {
-                throw new Error('Invalid bigint');
-            }
-        }
-        return value;
-    })
-        .Encode(BigInt);
-    boolean = Type.Transform(Type.Union([
-        Type.Boolean(),
-        Type.String({
-            pattern: '^(t|T)(r|R)(u|U)(e|E)$|^(f|F)(a|A)(l|L)(s|S)(e|E)$'
-        })
-    ], {
-        errorType: 'boolean-like',
-        openapiType: Type.Boolean()
-    }))
-        .Decode((value) => {
-        if (typeof value === 'string') {
-            if (value.toLowerCase() === 'true')
-                return true;
-            if (value.toLowerCase() === 'false')
-                return false;
-        }
-        else {
-            return value;
-        }
-    })
-        .Encode(Boolean);
-    date = Type.Transform(Type.Union([
-        Type.Date(),
-        Type.Number(),
-        Type.String({
-            pattern: '^\\d{4}(-\\d{2}){0,2}(T\\d{2}:\\d{2}(:\\d{2}(\\.\\d{1,3})?)?(Z|([+-]\\d{2}:\\d{2}))?)?$|^\\d{1,2}\\/\\d{1,2}\\/\\d{4}$|^\\d{4}\\/\\d{1,2}\\/\\d{1,2}$|^\\d+$'
-        }),
-        Type.Boolean(),
-        Type.Null()
-    ], {
-        errorType: 'date',
-        openapiType: Type.Date()
-    }))
-        .Decode((value) => {
-        if (!(value instanceof Date)) {
-            if (value === null || typeof value === 'boolean') {
-                return new Date(value ? 1 : 0);
-            }
-            return new Date(value);
-        }
-        return value;
-    })
-        .Encode((value) => new Date(value));
-    symbol = Type.Symbol();
-    nullish = Type.Union([Type.Void(), Type.Null(), Type.Undefined()], {
-        errorType: 'nullish'
-    });
-    any = Type.Any();
-    unknown = Type.Unknown();
-    never = Type.Never();
-    /**
-     * Extracts the error type of a schema for error messages.
-     *
-     * @param {TCatchall} schema - A schema that contains some type information.
-     * @returns The type of the schema for error messages.
-     */
-    errorType(schema) {
-        if (Object.hasOwn(schema, 'errorType')) {
-            return schema.errorType;
-        }
-        else if (KindGuard.IsLiteral(schema)) {
-            return schema.const;
-        }
-        return schema[Kind].toLowerCase();
-    }
-    /**
-     * Pretty print TypeBox errors.
-     *
-     * @param {ValueError[]} errors
-     * @returns
-     */
-    prettyPrintTypeBoxErrors(errors) {
-        if (!errors || errors.length === 0)
-            return;
-        const errorMessages = errors.map((err, index) => {
-            const path = err.path.length > 0 ? err.path.split('/').slice(1).join(' > ') : 'root';
-            return `${index + 1}. Path: ${path}\n   Message: ${err.message}`;
-        });
-        return `Validation failed with the following errors:\n${errorMessages.join('\n\n')}`;
-    }
-    /**
-     * Compiles schema if this exists, for optimal performance.
-     *
-     * @param {TObject<TProperties>} schema - The schema to compile.
-     * @returns {TypeCheck<T>} - The compiled schema.
-     */
-    compile(schema) {
-        return TypeCompiler.Compile(schema);
-    }
-    /**
-     * Convert a schema to a TypeBox schema.
-     * @param {TIdiomaticSchema} schema - The schema to convert.
-     * @returns {TResolve<T>} The resolved schema.
-     */
-    schemify(schema) {
-        if (typeof schema === 'string' ||
-            typeof schema === 'number' ||
-            typeof schema === 'boolean') {
-            return Type.Literal(schema);
-        }
-        if (KindGuard.IsSchema(schema) || schema instanceof TypeCheck) {
-            return schema;
-        }
-        const newSchema = {};
-        Object.getOwnPropertyNames(schema).forEach((key) => {
-            if (KindGuard.IsSchema(schema[key])) {
-                newSchema[key] = schema[key];
-            }
-            else {
-                const schemified = this.schemify(schema[key]);
-                newSchema[key] = schemified;
-            }
-        });
-        return Type.Object(newSchema);
-    }
-    /**
-     * Make a schema optional.
-     * @param {TIdiomaticSchema} schema - The schema to make optional.
-     * @returns {TOptional<TResolve<T>>} The optional schema.
-     */
-    optional(schema) {
-        const schemified = KindGuard.IsSchema(schema)
-            ? schema
-            : this.schemify(schema);
-        return Type.Optional(schemified);
-    }
-    /**
-     * Create an array schema.
-     * @param {TIdiomaticSchema} schema - The schema to use for array items.
-     * @returns {TArray<TResolve<T>>} The array schema.
-     */
-    array(schema) {
-        const schemified = KindGuard.IsSchema(schema)
-            ? schema
-            : this.schemify(schema);
-        return Type.Array(schemified, {
-            errorType: `array of ${this.errorType(schemified)}`
-        });
-    }
-    /**
-     * Create a union schema.
-     * @param {TUnionContainer} schemas - The schemas to union.
-     * @returns {TUnion<UnionTResolve<T>>} The union schema.
-     *
-     * WARNING: If "nullish" or TUndefined is included in the union, the key will still be expected.
-     * This is a limitation of TypeBox. Consider using "optional" instead.
-     */
-    union(schemas) {
-        const unionTypes = schemas.map((schema) => {
-            return KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
-        });
-        return Type.Union(unionTypes, {
-            errorType: `any of ${unionTypes
-                .map((s) => this.errorType(s))
-                .join(', ')}`,
-            errorSuffix: true
-        });
-    }
-    /**
-     * Create a literal schema.
-     * @param {LiteralSchema} value - The literal value.
-     * @returns {TLiteral<T>} The literal schema.
-     */
-    literal(value) {
-        return Type.Literal(value, {
-            errorType: value
-        });
-    }
-    /**
-     * Create an enum schema.
-     * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
-     * @returns {TUnion<UnionTResolve<T[]>>} The enum schema.
-     */
-    enum_(schemaEnum) {
-        return this.union(Object.values(schemaEnum));
-    }
-    /**
-     * Check if a value is a TypeBox object schema.
-     * @param {unknown} value - The value to check.
-     * @returns {boolean} True if the value is a TypeBox object schema.
-     */
-    isSchema(value) {
-        return KindGuard.IsSchema(value);
-    }
-    /**
-     * Validate a value against a schema.
-     *
-     * @param {TSchema} schema - The schema to validate against.
-     * @param {unknown} value - The value to validate.
-     * @returns {boolean} True if valid, otherwise false.
-     */
-    validate(schema, value) {
-        if (schema instanceof TypeCheck) {
-            return schema.Check(value);
-        }
-        else {
-            const schemified = KindGuard.IsSchema(schema)
-                ? schema
-                : this.schemify(schema);
-            return Value.Check(schemified, value);
-        }
-    }
-    /**
-     * Parse a value against a schema.
-     *
-     * @param {TSchema} schema - The schema to validate against.
-     * @param {unknown} value - The value to validate.
-     * @returns {ParseResult<TResolve<T>>} The parsing result.
-     */
-    parse(schema, value) {
-        let errors = [];
-        let conversion;
-        if (schema instanceof TypeCheck) {
-            if (schema.Check(value)) {
-                conversion = schema.Decode(value);
-            }
-            else {
-                errors = Array.from(schema.Errors(value));
-            }
-        }
-        else {
-            const schemified = KindGuard.IsSchema(schema)
-                ? schema
-                : this.schemify(schema);
-            if (Value.Check(schemified, value)) {
-                conversion = Value.Decode(schemified, value);
-            }
-            else {
-                errors = Array.from(Value.Errors(schemified, value));
-            }
-        }
-        return errors != null && errors.length === 0
-            ? {
-                ok: true,
-                value: conversion
-            }
-            : {
-                ok: false,
-                error: this.prettyPrintTypeBoxErrors(errors)
-            };
-    }
-    /**
-     * Convert a schema to an OpenAPI schema object.
-     * @param {TIdiomaticSchema | TSchema} schema - The schema to convert.
-     * @returns {SchemaObject} The OpenAPI schema object.
-     */
-    openapi(schema) {
-        const schemified = KindGuard.IsSchema(schema)
-            ? schema
-            : this.schemify(schema);
-        if (Object.hasOwn(schemified, 'openapiType') ||
-            KindGuard.IsLiteral(schemified)) {
-            return schemified.openapiType;
-        }
-        const newSchema = Object.assign({}, schemified);
-        if (Object.hasOwn(newSchema, 'properties')) {
-            newSchema.properties = { ...schemified.properties };
-            if (newSchema.properties) {
-                Object.entries(newSchema.properties).forEach(([key, value]) => {
-                    if (KindGuard.IsSchema(value) && newSchema.properties) {
-                        newSchema.properties[key] = this.openapi(value);
-                    }
-                });
-            }
-        }
-        return newSchema;
-    }
-}

package/lib/src/typebox/types/schema.types.d.ts

@@ -1,59 +0,0 @@
-import { TObject as OriginalTObject, StaticDecode, TArray, TKind, TLiteral, TNever, TProperties, TSchema, TUnknown } from '@sinclair/typebox';
-import { TypeCheck } from '@sinclair/typebox/compiler';
-import { Increment, KeyTypes, LiteralSchema } from '../../shared/types/schema.types';
-/**
- * Represents a catch-all schema type.
- */
-export type TCatchall = TSchema;
-/**
- * Represents an outer array schema type. If the type T is an object shape, it will return an array schema of T. Otherwise, it returns TNever.
- *
- * @template T - The type to check and possibly convert to an array schema.
- */
-export type TOuterArray<T> = T extends TObject<TObjectShape> ? TArray<T> : TNever;
-/**
- * Represents the shape of an object schema.
- */
-export type TObjectShape = TProperties;
-/**
- * Represents an object schema type. If the type T is an object shape, it will return the original TObject type of T. Otherwise, it returns TNever.
- *
- * @template T - The type to check and possibly convert to an object schema.
- */
-export type TObject<T> = T extends TObjectShape ? OriginalTObject<T> : TNever;
-/**
- * Translates a schema type T to its static type if T extends TCatchall. Otherwise, it returns TNever.
- *
- * @template T - The schema type to translate.
- */
-export type TSchemaTranslate<T> = T extends TCatchall ? StaticDecode<T> : TNever;
-/**
- * Represents an unboxed object schema where each key can have an idiomatic schema.
- */
-export type UnboxedTObjectSchema = {
-    [key: KeyTypes]: TIdiomaticSchema;
-};
-/**
- * Represents an idiomatic schema which can be an unboxed object schema or a literal schema.
- */
-export type TIdiomaticSchema = UnboxedTObjectSchema | LiteralSchema;
-/**
- * Represents a container for a union of idiomatic schemas.
- */
-export type TUnionContainer = [...TIdiomaticSchema[]];
-/**
- * Resolves a union container to a tuple of resolved idiomatic schemas.
- *
- * @template T - The union container to resolve.
- */
-export type UnionTResolve<T extends TUnionContainer> = T extends (infer UnionTypes)[] ? [TResolve<UnionTypes>] : TNever;
-/**
- * Resolves a schema type T to its resolved type. The depth is limited to 12 to prevent infinite recursion, due to StaticDecode limitations.
- *
- * @template T - The schema type to resolve.
- * @template Depth - The current depth of the resolution.
- */
-export type TResolve<T, Depth extends number = 0> = Depth extends 12 ? TUnknown : T extends LiteralSchema ? TLiteral<T> : T extends TSchema ? T : T extends TKind ? T : T extends TObject<TObjectShape> ? T : T extends UnboxedTObjectSchema ? TObject<{
-    [K in keyof T]: TResolve<T[K], Increment<Depth>>;
-}> : T extends TypeCheck<infer Type> ? TResolve<Type, Increment<Depth>> : TNever;
-//# sourceMappingURL=schema.types.d.ts.map

package/lib/src/typebox/types/schema.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.types.d.ts","sourceRoot":"","sources":["../../../../src/typebox/types/schema.types.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,IAAI,eAAe,EAC1B,YAAY,EACZ,MAAM,EACN,KAAK,EACL,QAAQ,EACR,MAAM,EACN,WAAW,EACX,OAAO,EACP,QAAQ,EACT,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EACL,SAAS,EACT,QAAQ,EACR,aAAa,EACd,MAAM,iCAAiC,CAAC;AAEzC;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC;AAEhC;;;;GAIG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IACvB,CAAC,SAAS,OAAO,CAAC,YAAY,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;AAEvD;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC;AAEvC;;;;GAIG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,SAAS,YAAY,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;AAE9E;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GACjD,YAAY,CAAC,CAAC,CAAC,GACf,MAAM,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,CAAC,GAAG,EAAE,QAAQ,GAAG,gBAAgB,CAAC;CACnC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,oBAAoB,GAAG,aAAa,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,gBAAgB,EAAE,CAAC,CAAC;AAEtD;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,eAAe,IACjD,CAAC,SAAS,CAAC,MAAM,UAAU,CAAC,EAAE,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,GAAG,MAAM,CAAC;AAEnE;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,KAAK,SAAS,MAAM,GAAG,CAAC,IAAI,KAAK,SAAS,EAAE,GAChE,QAAQ,GACR,CAAC,SAAS,aAAa,GACrB,QAAQ,CAAC,CAAC,CAAC,GACX,CAAC,SAAS,OAAO,GACf,CAAC,GACD,CAAC,SAAS,KAAK,GACb,CAAC,GACD,CAAC,SAAS,OAAO,CAAC,YAAY,CAAC,GAC7B,CAAC,GACD,CAAC,SAAS,oBAAoB,GAC5B,OAAO,CAAC;KACL,CAAC,IAAI,MAAM,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;CACjD,CAAC,GACF,CAAC,SAAS,SAAS,CAAC,MAAM,IAAI,CAAC,GAC7B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC,GAChC,MAAM,CAAC"}

package/lib/src/typebox/types/schema.types.js

@@ -1 +0,0 @@
-export {};

package/lib/src/zod/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/zod/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,YAAY,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC"}

package/lib/src/zod/staticSchemaValidator.d.ts

@@ -1,99 +0,0 @@
-import { ZodSchemaValidator } from './zodSchemaValidator';
-/**
- * Factory function for creating a ZodSchemaValidator instance.
- * @returns {ZodSchemaValidator} The ZodSchemaValidator instance.
- */
-export declare const SchemaValidator: () => ZodSchemaValidator;
-/**
- * Zod schema definition for string type.
- */
-export declare const string: import("zod").ZodString;
-/**
- * Zod schema definition for UUID type.
- */
-export declare const uuid: import("zod").ZodString;
-/**
- * Zod schema definition for email type.
- */
-export declare const email: import("zod").ZodString;
-/**
- * Zod schema definition for URI type.
- */
-export declare const uri: import("zod").ZodString;
-/**
- * Zod schema definition for number type.
- */
-export declare const number: import("zod").ZodNumber;
-/**
- * Zod schema definition for bigint type.
- */
-export declare const bigint: import("zod").ZodBigInt;
-/**
- * Zod schema definition for boolean type.
- */
-export declare const boolean: import("zod").ZodEffects<import("zod").ZodBoolean, boolean, unknown>;
-/**
- * Zod schema definition for date type.
- */
-export declare const date: import("zod").ZodDate;
-/**
- * Zod schema definition for symbol type.
- */
-export declare const symbol: import("zod").ZodSymbol;
-/**
- * Zod schema definition for undefined, null, void types.
- */
-export declare const nullish: import("zod").ZodUnion<[import("zod").ZodVoid, import("zod").ZodNull, import("zod").ZodUndefined]>;
-/**
- * Zod schema definition for any type.
- */
-export declare const any: import("zod").ZodAny;
-/**
- * Zod schema definition for unknown type.
- */
-export declare const unknown: import("zod").ZodUnknown;
-/**
- * Zod schema definition for never type.
- */
-export declare const never: import("zod").ZodNever;
-/**
- * Transforms valid schema into Zod schema.
- */
-export declare const schemify: <T extends import("./types/schema.types").ZodIdiomaticSchema>(schema: T) => import("./types/schema.types").ZodResolve<T>;
-/**
- * Makes a valid schema optional.
- */
-export declare const optional: <T extends import("./types/schema.types").ZodIdiomaticSchema>(schema: T) => import("zod").ZodOptional<import("./types/schema.types").ZodResolve<T>>;
-/**
- * Defines an array for a valid schema.
- */
-export declare const array: <T extends import("./types/schema.types").ZodIdiomaticSchema>(schema: T) => import("zod").ZodArray<import("./types/schema.types").ZodResolve<T>>;
-/**
- * Defines a union for a valid schema.
- */
-export declare const union: <T extends import("./types/schema.types").ZodUnionContainer>(schemas: T) => import("zod").ZodUnion<import("./types/schema.types").UnionZodResolve<T>>;
-/**
- * Defines a literal for a valid schema.
- */
-export declare const literal: <T extends import("../..").LiteralSchema>(value: T) => import("zod").ZodLiteral<import("./types/schema.types").ZodResolve<T>>;
-/**
- * Defines an enum for a valid schema.
- */
-export declare const enum_: <T extends import("../..").LiteralSchema>(schemaEnum: Record<string, T>) => import("zod").ZodUnion<import("./types/schema.types").UnionZodResolve<[T, T, ...T[]]>>;
-/**
- * Checks if a value is a Zod schema.
- */
-export declare const isSchema: (value: unknown) => value is import("zod").ZodSchema;
-/**
- * Validates a value against a valid schema.
- */
-export declare const validate: <T extends import("./types/schema.types").ZodCatchall>(schema: T, value: unknown) => boolean;
-/**
- * Parses a value to be conformant to a particular schema.
- */
-export declare const parse: <T extends import("./types/schema.types").ZodCatchall>(schema: T, value: unknown) => import("../..").ParseResult<import("./types/schema.types").ZodResolve<T>>;
-/**
- * Generates an OpenAPI schema object from a valid schema.
- */
-export declare const openapi: <T extends import("./types/schema.types").ZodIdiomaticSchema>(schema: T) => import("openapi3-ts/oas31").SchemaObject;
-//# sourceMappingURL=staticSchemaValidator.d.ts.map

package/lib/src/zod/staticSchemaValidator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"staticSchemaValidator.d.ts","sourceRoot":"","sources":["../../../src/zod/staticSchemaValidator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,eAAe,0BAAiC,CAAC;AAI9D;;GAEG;AACH,eAAO,MAAM,MAAM,yBAA+B,CAAC;AAEnD;;GAEG;AACH,eAAO,MAAM,IAAI,yBAA6B,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,KAAK,yBAA8B,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,GAAG,yBAA4B,CAAC;AAE7C;;GAEG;AACH,eAAO,MAAM,MAAM,yBAA+B,CAAC;AAEnD;;GAEG;AACH,eAAO,MAAM,MAAM,yBAA+B,CAAC;AAEnD;;GAEG;AACH,eAAO,MAAM,OAAO,sEAAgC,CAAC;AAErD;;GAEG;AACH,eAAO,MAAM,IAAI,uBAA6B,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,MAAM,yBAA+B,CAAC;AAEnD;;GAEG;AACH,eAAO,MAAM,OAAO,oGAAgC,CAAC;AAErD;;GAEG;AACH,eAAO,MAAM,GAAG,sBAA4B,CAAC;AAE7C;;GAEG;AACH,eAAO,MAAM,OAAO,0BAAgC,CAAC;AAErD;;GAEG;AACH,eAAO,MAAM,KAAK,wBAA8B,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,QAAQ,0HAEpB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,QAAQ,qJAEpB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,KAAK,kJAA0D,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,KAAK,uJAA0D,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,OAAO,+HAEnB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,KAAK,oKAA0D,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,QAAQ,sDAEpB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,QAAQ,8FAEpB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,KAAK,gKAA0D,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,OAAO,sHAEnB,CAAC"}

package/lib/src/zod/staticSchemaValidator.js

@@ -1,99 +0,0 @@
-import { ZodSchemaValidator } from './zodSchemaValidator';
-/**
- * Factory function for creating a ZodSchemaValidator instance.
- * @returns {ZodSchemaValidator} The ZodSchemaValidator instance.
- */
-export const SchemaValidator = () => new ZodSchemaValidator();
-const StaticSchemaValidator = SchemaValidator();
-/**
- * Zod schema definition for string type.
- */
-export const string = StaticSchemaValidator.string;
-/**
- * Zod schema definition for UUID type.
- */
-export const uuid = StaticSchemaValidator.uuid;
-/**
- * Zod schema definition for email type.
- */
-export const email = StaticSchemaValidator.email;
-/**
- * Zod schema definition for URI type.
- */
-export const uri = StaticSchemaValidator.uri;
-/**
- * Zod schema definition for number type.
- */
-export const number = StaticSchemaValidator.number;
-/**
- * Zod schema definition for bigint type.
- */
-export const bigint = StaticSchemaValidator.bigint;
-/**
- * Zod schema definition for boolean type.
- */
-export const boolean = StaticSchemaValidator.boolean;
-/**
- * Zod schema definition for date type.
- */
-export const date = StaticSchemaValidator.date;
-/**
- * Zod schema definition for symbol type.
- */
-export const symbol = StaticSchemaValidator.symbol;
-/**
- * Zod schema definition for undefined, null, void types.
- */
-export const nullish = StaticSchemaValidator.nullish;
-/**
- * Zod schema definition for any type.
- */
-export const any = StaticSchemaValidator.any;
-/**
- * Zod schema definition for unknown type.
- */
-export const unknown = StaticSchemaValidator.unknown;
-/**
- * Zod schema definition for never type.
- */
-export const never = StaticSchemaValidator.never;
-/**
- * Transforms valid schema into Zod schema.
- */
-export const schemify = StaticSchemaValidator.schemify.bind(StaticSchemaValidator);
-/**
- * Makes a valid schema optional.
- */
-export const optional = StaticSchemaValidator.optional.bind(StaticSchemaValidator);
-/**
- * Defines an array for a valid schema.
- */
-export const array = StaticSchemaValidator.array.bind(StaticSchemaValidator);
-/**
- * Defines a union for a valid schema.
- */
-export const union = StaticSchemaValidator.union.bind(StaticSchemaValidator);
-/**
- * Defines a literal for a valid schema.
- */
-export const literal = StaticSchemaValidator.literal.bind(StaticSchemaValidator);
-/**
- * Defines an enum for a valid schema.
- */
-export const enum_ = StaticSchemaValidator.enum_.bind(StaticSchemaValidator);
-/**
- * Checks if a value is a Zod schema.
- */
-export const isSchema = StaticSchemaValidator.isSchema.bind(StaticSchemaValidator);
-/**
- * Validates a value against a valid schema.
- */
-export const validate = StaticSchemaValidator.validate.bind(StaticSchemaValidator);
-/**
- * Parses a value to be conformant to a particular schema.
- */
-export const parse = StaticSchemaValidator.parse.bind(StaticSchemaValidator);
-/**
- * Generates an OpenAPI schema object from a valid schema.
- */
-export const openapi = StaticSchemaValidator.openapi.bind(StaticSchemaValidator);