@forklaunch/validator 0.3.12 → 0.4.0

package/lib/index-V6qNDTlr.d.mts

@@ -0,0 +1,476 @@
+import { Prettify } from '@forklaunch/common';
+import { SchemaObject } from 'openapi3-ts/oas31';
+import { TObject as TObject$1, TNever, StaticDecode, TUnknown, TLiteral, TSchema, TKind, TProperties } from '@sinclair/typebox';
+import { TypeCheck } from '@sinclair/typebox/compiler';
+import { ZodObject as ZodObject$1, ZodRawShape, ZodOptional, ZodArray, ZodUnion, ZodLiteral, ZodType, z, ZodTypeAny, ZodNever, ZodUnknown } from 'zod';
+
+/**
+ * Represents a catch-all schema type.
+ */
+type TCatchall = TSchema;
+/**
+ * Represents the shape of an object schema.
+ */
+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.
+ */
+type TObject<T> = T extends TObjectShape ? TObject$1<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.
+ */
+type TSchemaTranslate<T> = T extends TCatchall ? StaticDecode<T> : TNever;
+/**
+ * Represents an unboxed object schema where each key can have an idiomatic schema.
+ */
+type UnboxedTObjectSchema = {
+    [key: KeyTypes]: TIdiomaticSchema;
+};
+/**
+ * Represents an idiomatic schema which can be an unboxed object schema or a literal schema.
+ */
+type TIdiomaticSchema = UnboxedTObjectSchema | LiteralSchema;
+/**
+ * Represents a container for a union of idiomatic schemas.
+ */
+type TUnionContainer = [...TIdiomaticSchema[]];
+/**
+ * Resolves a union container to a tuple of resolved idiomatic schemas.
+ *
+ * @template T - The union container to resolve.
+ */
+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.
+ */
+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;
+
+/**
+ * This module provides a Zod-based schema definition.
+ * It includes various types, schema creation, validation, and OpenAPI integration.
+ *
+ * @module ZodSchemaValidator
+ */
+
+/**
+ * Class representing a Zod schema definition.
+ * @implements {StaticSchemaValidator}
+ */
+declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodObject$1<ZodRawShape>>(schema: T) => ZodResolve<T>), <T extends ZodIdiomaticSchema>(schema: T) => ZodResolve<T>, <T extends ZodIdiomaticSchema>(schema: T) => ZodOptional<ZodResolve<T>>, <T extends ZodIdiomaticSchema>(schema: T) => ZodArray<ZodResolve<T>>, <T extends ZodUnionContainer>(schemas: T) => ZodUnion<UnionZodResolve<T>>, <T extends LiteralSchema>(value: T) => ZodLiteral<ZodResolve<T>>, <T extends LiteralSchema>(schemaEnum: Record<string, T>) => ZodUnion<UnionZodResolve<[T, T, ...T[]]>>, (value: unknown) => value is ZodType, <T extends ZodCatchall>(schema: T, value: unknown) => boolean, <T extends ZodCatchall>(schema: T, value: unknown) => ParseResult<ZodResolve<T>>, <T extends ZodIdiomaticSchema>(schema: T) => SchemaObject> {
+    _Type: 'Zod';
+    _SchemaCatchall: ZodType;
+    _ValidSchemaObject: ZodObject$1<ZodRawShape> | ZodArray<ZodObject$1<ZodRawShape>>;
+    string: z.ZodString;
+    uuid: z.ZodString;
+    email: z.ZodString;
+    uri: z.ZodString;
+    number: z.ZodNumber;
+    bigint: z.ZodBigInt;
+    boolean: z.ZodEffects<z.ZodBoolean, boolean, unknown>;
+    date: z.ZodDate;
+    symbol: z.ZodSymbol;
+    nullish: ZodUnion<[z.ZodVoid, z.ZodNull, z.ZodUndefined]>;
+    any: z.ZodAny;
+    unknown: z.ZodUnknown;
+    never: z.ZodNever;
+    /**
+     * Pretty print Zod errors.
+     *
+     * @param {ZodError} error - The Zod error to pretty print.
+     * @returns
+     */
+    private prettyPrintZodErrors;
+    /**
+     * Compiles schema if this exists, for optimal performance.
+     *
+     * @param {ZodObject<ZodRawShape>} schema - The schema to compile.
+     * @returns {ZodResolve<T>} - The compiled schema.
+     */
+    compile<T extends ZodObject$1<ZodRawShape>>(schema: T): ZodResolve<T>;
+    /**
+     * Convert a schema to a Zod schema.
+     * @param {ZodIdiomaticSchema} schema - The schema to convert.
+     * @returns {ZodResolve<T>} The resolved schema.
+     */
+    schemify<T extends ZodIdiomaticSchema>(schema: T): ZodResolve<T>;
+    /**
+     * Make a schema optional.
+     * @param {ZodIdiomaticSchema} schema - The schema to make optional.
+     * @returns {ZodOptional<ZodResolve<T>>} The optional schema.
+     */
+    optional<T extends ZodIdiomaticSchema>(schema: T): ZodOptional<ZodResolve<T>>;
+    /**
+     * Create an array schema.
+     * @param {ZodIdiomaticSchema} schema - The schema to use for array items.
+     * @returns {ZodArray<ZodResolve<T>>} The array schema.
+     */
+    array<T extends ZodIdiomaticSchema>(schema: T): ZodArray<ZodResolve<T>>;
+    /**
+     * Create a union schema.
+     * @param {ZodUnionContainer} schemas - The schemas to union.
+     * @returns {ZodUnion<UnionZodResolve<T>>} The union schema.
+     */
+    union<T extends ZodUnionContainer>(schemas: T): ZodUnion<UnionZodResolve<T>>;
+    /**
+     * Create a literal schema.
+     * @param {LiteralSchema} value - The literal value.
+     * @returns {ZodLiteral<ZodResolve<T>>} The literal schema.
+     */
+    literal<T extends LiteralSchema>(value: T): ZodLiteral<ZodResolve<T>>;
+    /**
+     * Create an enum schema.
+     * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
+     * @returns {ZodUnion<UnionZodResolve<[T, T, ...T[]]>>} The enum schema.
+     */
+    enum_<T extends LiteralSchema>(schemaEnum: Record<string, T>): ZodUnion<UnionZodResolve<[T, T, ...T[]]>>;
+    /**
+     * Checks if a value is a Zod schema.
+     * @param {unknown} value - The value to check.
+     * @returns {boolean} True if the value is a Zod schema.
+     */
+    isSchema(value: unknown): value is ZodType;
+    /**
+     * Validate a value against a schema.
+     * @param {ZodCatchall} schema - The schema to validate against.
+     * @param {unknown} value - The value to validate.
+     * @returns {boolean} True if valid, otherwise false.
+     */
+    validate<T extends ZodCatchall>(schema: T, value: unknown): boolean;
+    /**
+     * Parses a value to a schema validation.
+     *
+     * @param {ZodCatchall} schema - The schema to validate against.
+     * @param {unknown} value - The value to validate.
+     * @returns {ParseResult} - The discrimintated parsed value if successful, the error if unsuccessful.
+     */
+    parse<T extends ZodCatchall>(schema: T, value: unknown): ParseResult<ZodResolve<T>>;
+    /**
+     * Convert a schema to an OpenAPI schema object.
+     * @param {ZodIdiomaticSchema} schema - The schema to convert.
+     * @returns {SchemaObject} The OpenAPI schema object.
+     */
+    openapi<T extends ZodIdiomaticSchema>(schema: T): SchemaObject;
+}
+
+/**
+ * Represents a catch-all Zod schema type.
+ */
+type ZodCatchall = ZodTypeAny;
+/**
+ * Represents the shape of a Zod object schema.
+ */
+type ZodObjectShape = ZodRawShape;
+/**
+ * Represents a Zod object schema type. If the type T is a Zod object shape, it will return the original ZodObject type of T. Otherwise, it returns ZodNever.
+ *
+ * @template T - The type to check and possibly convert to a Zod object schema.
+ */
+type ZodObject<T> = T extends ZodObjectShape ? ZodObject$1<T> : ZodNever;
+/**
+ * Translates a Zod schema type T to its static type if T extends ZodCatchall. Otherwise, it returns ZodNever.
+ *
+ * @template T - The Zod schema type to translate.
+ */
+type ZodSchemaTranslate<T> = T extends ZodCatchall ? z.infer<T> : ZodNever;
+/**
+ * Represents an unboxed Zod object schema where each key can have an idiomatic schema.
+ */
+type ZodObjectSchema = UnboxedObjectSchema<ZodSchemaValidator>;
+/**
+ * Represents an idiomatic schema for Zod which can be an unboxed object schema or a literal schema.
+ */
+type ZodIdiomaticSchema = IdiomaticSchema<ZodSchemaValidator>;
+/**
+ * Represents a container for a union of Zod idiomatic schemas.
+ */
+type ZodUnionContainer = readonly [
+    ZodIdiomaticSchema,
+    ZodIdiomaticSchema,
+    ...ZodIdiomaticSchema[]
+];
+/**
+ * Resolves a union container to a tuple of resolved Zod idiomatic schemas.
+ *
+ * @template T - The union container to resolve.
+ */
+type UnionZodResolve<T extends ZodUnionContainer> = T extends [
+    infer A extends ZodIdiomaticSchema,
+    infer B extends ZodIdiomaticSchema,
+    ...infer C extends ZodIdiomaticSchema[]
+] ? [
+    ZodResolve<A>,
+    ZodResolve<B>,
+    ...{
+        [K in keyof C]: ZodResolve<C[K]>;
+    }
+] : [ZodNever, ZodNever];
+/**
+ * Resolves a Zod schema type T to its resolved type. The depth is limited to 31 to prevent infinite recursion.
+ *
+ * @template T - The Zod schema type to resolve.
+ * @template Depth - The current depth of the resolution.
+ */
+type ZodResolve<T, Depth extends number = 0> = Depth extends 31 ? ZodUnknown : T extends LiteralSchema ? ZodLiteral<T> : T extends ZodType ? T : T extends ZodObjectSchema ? ZodObject<{
+    [K in keyof T]: ZodResolve<T[K], Increment<Depth>>;
+}> : ZodNever;
+
+/**
+ * The result associated with an attempted parsing.
+ *
+ */
+type ParseResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error?: string;
+};
+/**
+ * Interface representing a schema validator.
+ *
+ * @template SchematicFunction - The function type for schemifying a schema.
+ * @template OptionalFunction - The function type for making a schema optional.
+ * @template ArrayFunction - The function type for converting a schema into an array.
+ * @template UnionFunction - The function type for unionizing multiple schemas.
+ * @template LiteralFunction - The function type for creating a literal schema.
+ * @template ValidationFunction - The function type for validating a value against a schema.
+ * @template ParseFunction - The function type for parsing a value against a schema.
+ * @template OpenAPIFunction - The function type for converting a schema into an OpenAPI schema object.
+ */
+interface SchemaValidator<CompilationFunction = <T>(schema: T) => unknown, SchematicFunction = <T>(schema: T) => unknown, OptionalFunction = <T>(schema: T) => unknown, ArrayFunction = <T>(schema: T) => unknown, UnionFunction = <T>(schemas: T[]) => unknown, LiteralFunction = <T extends LiteralSchema>(schema: T) => unknown, EnumFunction = <T extends LiteralSchema>(schemaEnum: Record<string, T>) => unknown, SchemaGuardFunction = <T>(value: unknown) => value is T, ValidationFunction = <T>(schema: T, value: unknown) => boolean, ParseFunction = <T>(schema: T, value: unknown) => ParseResult<SchemaResolve<T>>, OpenAPIFunction = <T>(schema: T) => SchemaObject> {
+    /**
+     * The type of the schema validator. Meant to be used with non-null assertions.
+     */
+    _Type: unknown;
+    /**
+     * The catch-all type for the schema. Meant to be used with non-null assertions.
+     */
+    _SchemaCatchall: unknown;
+    /**
+     * The valid schema object type. Meant to be used with non-null assertions.
+     */
+    _ValidSchemaObject: unknown;
+    /**
+     * Validator for string type.
+     */
+    string: unknown;
+    /**
+     * Validator for uuid type.
+     */
+    uuid: unknown;
+    /**
+     * Validator for uri type.
+     */
+    uri: unknown;
+    /**
+     * Validator for email type.
+     */
+    email: unknown;
+    /**
+     * Validator for number type.
+     */
+    number: unknown;
+    /**
+     * Validator for bigint type.
+     */
+    bigint: unknown;
+    /**
+     * Validator for boolean type.
+     */
+    boolean: unknown;
+    /**
+     * Validator for date type.
+     */
+    date: unknown;
+    /**
+     * Validator for symbol type.
+     */
+    symbol: unknown;
+    /**
+     * Validator for nullish type.
+     */
+    nullish: unknown;
+    /**
+     * Validator for any type.
+     */
+    any: unknown;
+    /**
+     * Validator for unknown type.
+     */
+    unknown: unknown;
+    /**
+     * Validator for never type.
+     */
+    never: unknown;
+    /**
+     * Compiles schema if this exists, for optimal performance.
+     *
+     * @param {T} schema - The schema to compile.
+     * @returns {unknown} - The compiled schema.
+     */
+    compile: CompilationFunction;
+    /**
+     * Converts a valid schema input into a schemified form.
+     *
+     * @param {T} schema - The schema to schemify.
+     * @returns {unknown} - The schemified form of the schema.
+     */
+    schemify: SchematicFunction;
+    /**
+     * Converts a schema into an optional schema.
+     *
+     * @param {T} schema - The schema to make optional.
+     * @returns {unknown} - The optional form of the schema.
+     */
+    optional: OptionalFunction;
+    /**
+     * Converts a schema into an array schema.
+     *
+     * @param {T} schema - The schema to convert into an array.
+     * @returns {unknown} - The array form of the schema.
+     */
+    array: ArrayFunction;
+    /**
+     * Converts multiple schemas into a union schema.
+     *
+     * @param {T[]} schemas - The schemas to unionize.
+     * @returns {unknown} - The union form of the schemas.
+     */
+    union: UnionFunction;
+    /**
+     * Creates a literal schema from a value.
+     *
+     * @param {T} value - The literal value.
+     * @returns {unknown} - The literal schema.
+     */
+    literal: LiteralFunction;
+    /**
+     * Creates an enum schema from a record of literal values.
+     *
+     * @param {Record<string, T>} schemaEnum - The enum schema.
+     * @returns {unknown} - The enum schema.
+     */
+    enum_: EnumFunction;
+    /**
+     * Checks if a value is a schema.
+     *
+     * @param {unknown} value - The value to check.
+     * @returns {boolean} - Whether the value is a schema.
+     */
+    isSchema: SchemaGuardFunction;
+    /**
+     * Validates a value against a schema.
+     *
+     * @param {T} schema - The schema to validate against.
+     * @param {unknown} value - The value to validate.
+     * @returns {boolean} - Whether the value is valid according to the schema.
+     */
+    validate: ValidationFunction;
+    /**
+     * Parses a value to a schema validation.
+     *
+     * @param {T} schema - The schema to validate against.
+     * @param {unknown} value - The value to validate.
+     * @returns {ParseResult} - The discrimintated parsed value if successful, the error if unsuccessful.
+     */
+    parse: ParseFunction;
+    /**
+     * Converts a schema into an OpenAPI schema object.
+     *
+     * @param {T} schema - The schema to convert.
+     * @returns {SchemaObject} - The OpenAPI schema object.
+     */
+    openapi: OpenAPIFunction;
+}
+/**
+ * Type representing any schema validator.
+ */
+type AnySchemaValidator = SchemaValidator<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> & {
+    /**
+     * The type of the schema resolver.
+     */
+    _Type: keyof SchemaResolve<unknown>;
+};
+/**
+ * Interface representing schema resolution for different validation libraries.
+ *
+ * @template T - The type of the schema to resolve.
+ */
+interface SchemaResolve<T> {
+    /**
+     * Schema resolution for Zod.
+     */
+    Zod: ZodResolve<T>;
+    /**
+     * Schema resolution for TypeBox.
+     */
+    TypeBox: TResolve<T>;
+}
+/**
+ * Interface representing schema translation for different validation libraries.
+ *
+ * @template T - The type of the schema to translate.
+ */
+interface SchemaTranslate<T> {
+    /**
+     * Schema translation for Zod.
+     */
+    Zod: ZodSchemaTranslate<T>;
+    /**
+     * Schema translation for TypeBox.
+     */
+    TypeBox: TSchemaTranslate<T>;
+}
+/**
+ * Type representing the prettified schema translation.
+ *
+ * @template T - The type of the schema to translate.
+ * @template SV - The type of the schema validator.
+ */
+type SchemaPrettify<T, SV extends AnySchemaValidator> = Prettify<SchemaTranslate<T>[SV['_Type']]>;
+/**
+ * Type representing a schema, which can be a valid schema object or an idiomatic schema.
+ *
+ * @template T - The type of the schema.
+ * @template SV - The type of the schema validator.
+ */
+type Schema<T extends SV['_ValidSchemaObject'] | IdiomaticSchema<SV>, SV extends AnySchemaValidator> = SchemaPrettify<SchemaResolve<T>[SV['_Type']], SV>;
+/**
+ * Represents a schema for an unboxed object where each key can have an idiomatic schema.
+ *
+ * @template SV - The type of the schema validator.
+ */
+type UnboxedObjectSchema<SV extends AnySchemaValidator> = {
+    [key: KeyTypes]: IdiomaticSchema<SV>;
+};
+/**
+ * Represents a schema that can be a literal value.
+ */
+type LiteralSchema = string | number | boolean;
+/**
+ * Represents an idiomatic schema which can be an unboxed object schema, a literal schema, or a catch-all type.
+ *
+ * @template SV - The type of the schema validator.
+ */
+type IdiomaticSchema<SV extends AnySchemaValidator> = LiteralSchema | SV['_SchemaCatchall'] | UnboxedObjectSchema<SV>;
+/**
+ * Increments a number type by one, with support up to 50.
+ *
+ * @template T - The number type to increment.
+ */
+type Increment<T extends number> = T extends 0 ? 1 : T extends 1 ? 2 : T extends 2 ? 3 : T extends 3 ? 4 : T extends 4 ? 5 : T extends 5 ? 6 : T extends 6 ? 7 : T extends 7 ? 8 : T extends 8 ? 9 : T extends 9 ? 10 : T extends 10 ? 11 : T extends 11 ? 12 : T extends 12 ? 13 : T extends 13 ? 14 : T extends 14 ? 15 : T extends 15 ? 16 : T extends 16 ? 17 : T extends 17 ? 18 : T extends 18 ? 19 : T extends 19 ? 20 : T extends 20 ? 21 : T extends 21 ? 22 : T extends 22 ? 23 : T extends 23 ? 24 : T extends 24 ? 25 : T extends 25 ? 26 : T extends 26 ? 27 : T extends 27 ? 28 : T extends 28 ? 29 : T extends 29 ? 30 : T extends 30 ? 31 : T extends 31 ? 32 : T extends 32 ? 33 : T extends 33 ? 34 : T extends 34 ? 35 : T extends 35 ? 36 : T extends 36 ? 37 : T extends 37 ? 38 : T extends 38 ? 39 : T extends 39 ? 40 : T extends 40 ? 41 : T extends 41 ? 42 : T extends 42 ? 43 : T extends 43 ? 44 : T extends 44 ? 45 : T extends 45 ? 46 : T extends 46 ? 47 : T extends 47 ? 48 : T extends 48 ? 49 : T extends 49 ? 50 : 50;
+/**
+ * Represents key types that can be used in the schema.
+ */
+type KeyTypes = string | number;
+
+export { type AnySchemaValidator as A, type IdiomaticSchema as I, type KeyTypes as K, type LiteralSchema as L, type ParseResult as P, type SchemaValidator as S, type TObject as T, type UnionZodResolve as U, ZodSchemaValidator as Z, type ZodIdiomaticSchema as a, type ZodResolve as b, type ZodUnionContainer as c, type ZodCatchall as d, type TIdiomaticSchema as e, type TResolve as f, type TUnionContainer as g, type UnionTResolve as h, type SchemaResolve as i, type SchemaTranslate as j, type Schema as k, type UnboxedObjectSchema as l, type Increment as m };