@forklaunch/validator 0.1.0 → 0.1.2

package/dist/typebox.d.ts

@@ -0,0 +1,145 @@
+/**
+ * This module provides a TypeScript-based schema definition using the TypeBox library.
+ * It includes various types, schema creation, validation, and OpenAPI integration.
+ *
+ * @module TypeboxSchemaDefinition
+ */
+import { TSchema, TArray, TOptional, TUnion, TLiteral } from '@sinclair/typebox';
+import { LiteralSchema } from './types/schema.types';
+import { SchemaDefinition } from './interfaces/schemaDefinition.interfaces';
+import { SchemaObject } from 'openapi3-ts/oas31';
+import { TUnionContainer, TIdiomaticSchema, TResolve, UnionTResolve } from './types/typebox.schema.types';
+/**
+ * Class representing a TypeBox schema definition.
+ * @implements {SchemaDefinition}
+ */
+export declare class TypeboxSchemaDefinition implements SchemaDefinition<TUnionContainer, TIdiomaticSchema, TSchema> {
+    string: import("@sinclair/typebox").TString;
+    number: import("@sinclair/typebox").TNumber;
+    bigint: import("@sinclair/typebox").TBigInt;
+    boolean: import("@sinclair/typebox").TBoolean;
+    date: import("@sinclair/typebox").TDate;
+    symbol: import("@sinclair/typebox").TSymbol;
+    empty: TUnion<[import("@sinclair/typebox").TVoid, import("@sinclair/typebox").TNull, import("@sinclair/typebox").TUndefined]>;
+    any: import("@sinclair/typebox").TAny;
+    unknown: import("@sinclair/typebox").TUnknown;
+    never: import("@sinclair/typebox").TNever;
+    /**
+     * Convert a schema to a TypeBox schema.
+     * @param {TIdiomaticSchema} schema - The schema to convert.
+     * @returns {TResolve<T>} The resolved schema.
+     */
+    schemify<T extends TIdiomaticSchema>(schema: T): TResolve<T>;
+    /**
+     * Make a schema optional.
+     * @param {TIdiomaticSchema} schema - The schema to make optional.
+     * @returns {TOptional<TResolve<T>>} The optional schema.
+     */
+    optional<T extends TIdiomaticSchema>(schema: T): TOptional<TResolve<T>>;
+    /**
+     * Create an array schema.
+     * @param {TIdiomaticSchema} schema - The schema to use for array items.
+     * @returns {TArray<TResolve<T>>} The array schema.
+     */
+    array<T extends TIdiomaticSchema>(schema: T): TArray<TResolve<T>>;
+    /**
+     * Create a union schema.
+     * @param {TUnionContainer} schemas - The schemas to union.
+     * @returns {TUnion<UnionTResolve<T>>} The union schema.
+     */
+    union<T extends TUnionContainer>(schemas: T): TUnion<UnionTResolve<T>>;
+    /**
+     * Create a literal schema.
+     * @param {LiteralSchema} value - The literal value.
+     * @returns {TLiteral<T>} The literal schema.
+     */
+    literal<T extends LiteralSchema>(value: T): TLiteral<T>;
+    /**
+     * 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<T extends TSchema>(schema: T, value: unknown): boolean;
+    /**
+     * Convert a schema to an OpenAPI schema object.
+     * @param {TIdiomaticSchema | TSchema} schema - The schema to convert.
+     * @returns {SchemaObject} The OpenAPI schema object.
+     */
+    openapi<T extends TIdiomaticSchema | TSchema>(schema: T): SchemaObject;
+}
+/**
+ * Factory function for creating a TypeboxSchemaDefinition instance.
+ * @returns {TypeboxSchemaDefinition} The TypeboxSchemaDefinition instance.
+ */
+export declare const TypeboxSchema: () => TypeboxSchemaDefinition;
+declare const schemaDefinition: TypeboxSchemaDefinition;
+/**
+ * TypeBox schema definition for string type.
+ */
+export declare const string: typeof schemaDefinition.string;
+/**
+ * TypeBox schema definition for number type.
+ */
+export declare const number: typeof schemaDefinition.number;
+/**
+ * TypeBox schema definition for bigint type.
+ */
+export declare const bigint: typeof schemaDefinition.bigint;
+/**
+ * TypeBox schema definition for boolean type.
+ */
+export declare const boolean: typeof schemaDefinition.boolean;
+/**
+ * TypeBox schema definition for date type.
+ */
+export declare const date: typeof schemaDefinition.date;
+/**
+ * TypeBox schema definition for symbol type.
+ */
+export declare const symbol: typeof schemaDefinition.symbol;
+/**
+ * TypeBox schema definition for undefined, null, void types.
+ */
+export declare const empty: typeof schemaDefinition.empty;
+/**
+ * TypeBox schema definition for any type.
+ */
+export declare const any: typeof schemaDefinition.any;
+/**
+ * TypeBox schema definition for unknown type.
+ */
+export declare const unknown: typeof schemaDefinition.unknown;
+/**
+ * TypeBox schema definition for never type.
+ */
+export declare const never: typeof schemaDefinition.never;
+/**
+ * Transforms valid schema into TypeBox schema.
+ */
+export declare const schemify: typeof schemaDefinition.schemify;
+/**
+ * Makes a valid schema optional.
+ */
+export declare const optional: typeof schemaDefinition.optional;
+/**
+ * Defines an array for a valid schema.
+ */
+export declare const array: typeof schemaDefinition.array;
+/**
+ * Defines a union for a valid schema.
+ */
+export declare const union: typeof schemaDefinition.union;
+/**
+ * Defines a literal for a valid schema.
+ */
+export declare const literal: typeof schemaDefinition.literal;
+/**
+ * Validates a value against a valid schema.
+ */
+export declare const validate: typeof schemaDefinition.validate;
+/**
+ * Generates an OpenAPI schema object from a valid schema.
+ */
+export declare const openapi: typeof schemaDefinition.openapi;
+export {};

package/dist/typebox.js

@@ -0,0 +1,191 @@
+"use strict";
+/**
+ * This module provides a TypeScript-based schema definition using the TypeBox library.
+ * It includes various types, schema creation, validation, and OpenAPI integration.
+ *
+ * @module TypeboxSchemaDefinition
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openapi = exports.validate = exports.literal = exports.union = exports.array = exports.optional = exports.schemify = exports.never = exports.unknown = exports.any = exports.empty = exports.symbol = exports.date = exports.boolean = exports.bigint = exports.number = exports.string = exports.TypeboxSchema = exports.TypeboxSchemaDefinition = void 0;
+const typebox_1 = require("@sinclair/typebox");
+const value_1 = require("@sinclair/typebox/value");
+/**
+ * Class representing a TypeBox schema definition.
+ * @implements {SchemaDefinition}
+ */
+class TypeboxSchemaDefinition {
+    string = typebox_1.Type.String();
+    number = typebox_1.Type.Number();
+    bigint = typebox_1.Type.BigInt();
+    boolean = typebox_1.Type.Boolean();
+    date = typebox_1.Type.Date();
+    symbol = typebox_1.Type.Symbol();
+    empty = typebox_1.Type.Union([typebox_1.Type.Void(), typebox_1.Type.Null(), typebox_1.Type.Undefined()]);
+    any = typebox_1.Type.Any();
+    unknown = typebox_1.Type.Unknown();
+    never = typebox_1.Type.Never();
+    /**
+     * 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 typebox_1.Type.Literal(schema);
+        }
+        if (typebox_1.Kind in schema) {
+            return schema;
+        }
+        const newSchema = {};
+        Object.getOwnPropertyNames(schema).forEach((key) => {
+            if (typeof schema[key] === 'object' && typebox_1.Kind in schema[key]) {
+                newSchema[key] = schema[key];
+            }
+            else {
+                const scheme = this.schemify(schema[key]);
+                newSchema[key] = scheme;
+            }
+        });
+        return typebox_1.Type.Object(newSchema);
+    }
+    /**
+     * Make a schema optional.
+     * @param {TIdiomaticSchema} schema - The schema to make optional.
+     * @returns {TOptional<TResolve<T>>} The optional schema.
+     */
+    optional(schema) {
+        if (typebox_1.Kind in schema) {
+            return typebox_1.Type.Optional(schema);
+        }
+        const scheme = this.schemify(schema);
+        return typebox_1.Type.Optional(scheme);
+    }
+    /**
+     * Create an array schema.
+     * @param {TIdiomaticSchema} schema - The schema to use for array items.
+     * @returns {TArray<TResolve<T>>} The array schema.
+     */
+    array(schema) {
+        if (typebox_1.Kind in schema) {
+            return typebox_1.Type.Array(schema);
+        }
+        const scheme = this.schemify(schema);
+        return typebox_1.Type.Array(scheme);
+    }
+    /**
+     * Create a union schema.
+     * @param {TUnionContainer} schemas - The schemas to union.
+     * @returns {TUnion<UnionTResolve<T>>} The union schema.
+     */
+    union(schemas) {
+        const unionTypes = schemas.map((schema) => {
+            if (typebox_1.Kind in schema) {
+                return schema;
+            }
+            return this.schemify(schema);
+        });
+        return typebox_1.Type.Union(unionTypes);
+    }
+    /**
+     * Create a literal schema.
+     * @param {LiteralSchema} value - The literal value.
+     * @returns {TLiteral<T>} The literal schema.
+     */
+    literal(value) {
+        return typebox_1.Type.Literal(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) {
+        return value_1.Value.Check(schema, value);
+    }
+    /**
+     * Convert a schema to an OpenAPI schema object.
+     * @param {TIdiomaticSchema | TSchema} schema - The schema to convert.
+     * @returns {SchemaObject} The OpenAPI schema object.
+     */
+    openapi(schema) {
+        return this.schemify(schema);
+    }
+}
+exports.TypeboxSchemaDefinition = TypeboxSchemaDefinition;
+/**
+ * Factory function for creating a TypeboxSchemaDefinition instance.
+ * @returns {TypeboxSchemaDefinition} The TypeboxSchemaDefinition instance.
+ */
+const TypeboxSchema = () => new TypeboxSchemaDefinition();
+exports.TypeboxSchema = TypeboxSchema;
+const schemaDefinition = (0, exports.TypeboxSchema)();
+/**
+ * TypeBox schema definition for string type.
+ */
+exports.string = schemaDefinition.string;
+/**
+ * TypeBox schema definition for number type.
+ */
+exports.number = schemaDefinition.number;
+/**
+ * TypeBox schema definition for bigint type.
+ */
+exports.bigint = schemaDefinition.bigint;
+/**
+ * TypeBox schema definition for boolean type.
+ */
+exports.boolean = schemaDefinition.boolean;
+/**
+ * TypeBox schema definition for date type.
+ */
+exports.date = schemaDefinition.date;
+/**
+ * TypeBox schema definition for symbol type.
+ */
+exports.symbol = schemaDefinition.symbol;
+/**
+ * TypeBox schema definition for undefined, null, void types.
+ */
+exports.empty = schemaDefinition.empty;
+/**
+ * TypeBox schema definition for any type.
+ */
+exports.any = schemaDefinition.any;
+/**
+ * TypeBox schema definition for unknown type.
+ */
+exports.unknown = schemaDefinition.unknown;
+/**
+ * TypeBox schema definition for never type.
+ */
+exports.never = schemaDefinition.never;
+/**
+ * Transforms valid schema into TypeBox schema.
+ */
+exports.schemify = schemaDefinition.schemify.bind(schemaDefinition);
+/**
+ * Makes a valid schema optional.
+ */
+exports.optional = schemaDefinition.optional.bind(schemaDefinition);
+/**
+ * Defines an array for a valid schema.
+ */
+exports.array = schemaDefinition.array.bind(schemaDefinition);
+/**
+ * Defines a union for a valid schema.
+ */
+exports.union = schemaDefinition.union.bind(schemaDefinition);
+/**
+ * Defines a literal for a valid schema.
+ */
+exports.literal = schemaDefinition.literal.bind(schemaDefinition);
+/**
+ * Validates a value against a valid schema.
+ */
+exports.validate = schemaDefinition.validate.bind(schemaDefinition);
+/**
+ * Generates an OpenAPI schema object from a valid schema.
+ */
+exports.openapi = schemaDefinition.openapi.bind(schemaDefinition);
+//# sourceMappingURL=typebox.js.map

package/dist/typebox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typebox.js","sourceRoot":"","sources":["../typebox.ts"],"names":[],"mappings":"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"}

package/dist/types/schema.types.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Represents a schema for an unboxed object where each key can have an idiomatic schema.
+ *
+ * @template Catchall - The type to use for catch-all cases in the schema.
+ */
+export type UnboxedObjectSchema<Catchall> = {
+    [key: KeyTypes]: IdiomaticSchema<Catchall>;
+};
+/**
+ * Represents a schema that can be a literal value.
+ */
+export 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 Catchall - The type to use for catch-all cases in the schema.
+ */
+export type IdiomaticSchema<Catchall> = UnboxedObjectSchema<Catchall> | LiteralSchema | Catchall;
+/**
+ * Increments a number type by one, with support up to 50.
+ *
+ * @template T - The number type to increment.
+ */
+export 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.
+ */
+export type KeyTypes = string | number;

package/dist/types/schema.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=schema.types.js.map

package/dist/types/schema.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.types.js","sourceRoot":"","sources":["../../types/schema.types.ts"],"names":[],"mappings":""}

package/dist/types/typebox.schema.types.d.ts

@@ -0,0 +1,63 @@
+import { TSchema, TObject as OriginalTObject, TArray, TLiteral, TNever, Static, TProperties, TKind, TAny } from '@sinclair/typebox';
+import { Increment, KeyTypes, LiteralSchema } from './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 ? Static<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 A extends TIdiomaticSchema[]
+] ? [
+    ...{
+        [K in keyof A]: TResolve<A[K]>;
+    }
+] : [];
+/**
+ * Resolves a schema type T to its resolved type. The depth is limited to 40 to prevent infinite recursion.
+ *
+ * @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 22 ? TAny : T extends TKind ? T : T extends LiteralSchema ? TLiteral<T> : T extends UnboxedTObjectSchema ? TObject<{
+    [K in keyof T]: TResolve<T[K], Increment<Depth>>;
+}> : TNever;

package/dist/types/typebox.schema.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=typebox.schema.types.js.map

package/dist/types/typebox.schema.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typebox.schema.types.js","sourceRoot":"","sources":["../../types/typebox.schema.types.ts"],"names":[],"mappings":""}

package/dist/types/zod.schema.types.d.ts

@@ -0,0 +1,65 @@
+import { ZodArray, ZodObject as OriginalZodObject, ZodRawShape, ZodType, ZodTypeAny, z, ZodLiteral, ZodNever, ZodAny } from "zod";
+import { IdiomaticSchema, UnboxedObjectSchema, LiteralSchema, Increment } from "./schema.types";
+/**
+ * Represents a catch-all Zod schema type.
+ */
+export type ZodCatchall = ZodTypeAny;
+/**
+ * Represents an outer array schema type for Zod. If the type T is a Zod object, it will return an array schema of T. Otherwise, it returns ZodNever.
+ *
+ * @template T - The type to check and possibly convert to an array schema.
+ */
+export type ZodOuterArray<T> = T extends ZodObject<ZodObjectShape> ? ZodArray<T> : ZodNever;
+/**
+ * Represents the shape of a Zod object schema.
+ */
+export 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.
+ */
+export type ZodObject<T> = T extends ZodObjectShape ? OriginalZodObject<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.
+ */
+export type ZodSchemaTranslate<T> = T extends ZodCatchall ? z.infer<T> : ZodNever;
+/**
+ * Represents an unboxed Zod object schema where each key can have an idiomatic schema.
+ */
+export type ZodObjectSchema = UnboxedObjectSchema<ZodCatchall>;
+/**
+ * Represents an idiomatic schema for Zod which can be an unboxed object schema or a literal schema.
+ */
+export type ZodIdiomaticSchema = IdiomaticSchema<ZodCatchall>;
+/**
+ * Represents a container for a union of Zod idiomatic schemas.
+ */
+export 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.
+ */
+export 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 22 to prevent infinite recursion.
+ *
+ * @template T - The Zod schema type to resolve.
+ * @template Depth - The current depth of the resolution.
+ */
+export type ZodResolve<T, Depth extends number = 0> = Depth extends 22 ? ZodAny : T extends LiteralSchema ? ZodLiteral<T> : T extends ZodType | ZodObject<any> ? T : T extends ZodObjectSchema ? ZodObject<{
+    [K in keyof T]: ZodResolve<T[K], Increment<Depth>>;
+}> : ZodNever;

package/dist/types/zod.schema.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=zod.schema.types.js.map

package/dist/types/zod.schema.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod.schema.types.js","sourceRoot":"","sources":["../../types/zod.schema.types.ts"],"names":[],"mappings":""}

package/dist/zod.d.ts

@@ -0,0 +1,145 @@
+/**
+ * This module provides a Zod-based schema definition.
+ * It includes various types, schema creation, validation, and OpenAPI integration.
+ *
+ * @module ZodSchemaDefinition
+ */
+import { ZodArray, ZodOptional, ZodUnion, z, ZodLiteral } from "zod";
+import { LiteralSchema } from "./types/schema.types";
+import { SchemaDefinition } from "./interfaces/schemaDefinition.interfaces";
+import { SchemaObject } from 'openapi3-ts/oas31';
+import { ZodUnionContainer, ZodIdiomaticSchema, ZodCatchall, ZodResolve, UnionZodResolve } from "./types/zod.schema.types";
+/**
+ * Class representing a Zod schema definition.
+ * @implements {SchemaDefinition}
+ */
+export declare class ZodSchemaDefinition implements SchemaDefinition<ZodUnionContainer, ZodIdiomaticSchema, ZodCatchall> {
+    string: z.ZodString;
+    number: z.ZodNumber;
+    bigint: z.ZodBigInt;
+    boolean: z.ZodBoolean;
+    date: z.ZodDate;
+    symbol: z.ZodSymbol;
+    empty: ZodUnion<[z.ZodVoid, z.ZodNull, z.ZodUndefined]>;
+    any: z.ZodAny;
+    unknown: z.ZodUnknown;
+    never: z.ZodNever;
+    /**
+     * 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>>;
+    /**
+     * 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;
+    /**
+     * 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;
+}
+/**
+ * Factory function for creating a ZodSchemaDefinition instance.
+ * @returns {ZodSchemaDefinition} The ZodSchemaDefinition instance.
+ */
+export declare const ZodSchema: () => ZodSchemaDefinition;
+declare const schemaDefinition: ZodSchemaDefinition;
+/**
+ * Zod schema definition for string type.
+ */
+export declare const string: typeof schemaDefinition.string;
+/**
+ * Zod schema definition for number type.
+ */
+export declare const number: typeof schemaDefinition.number;
+/**
+ * Zod schema definition for bigint type.
+ */
+export declare const bigint: typeof schemaDefinition.bigint;
+/**
+ * Zod schema definition for boolean type.
+ */
+export declare const boolean: typeof schemaDefinition.boolean;
+/**
+ * Zod schema definition for date type.
+ */
+export declare const date: typeof schemaDefinition.date;
+/**
+ * Zod schema definition for symbol type.
+ */
+export declare const symbol: typeof schemaDefinition.symbol;
+/**
+ * Zod schema definition for undefined, null, void types.
+ */
+export declare const empty: typeof schemaDefinition.empty;
+/**
+ * Zod schema definition for any type.
+ */
+export declare const any: typeof schemaDefinition.any;
+/**
+ * Zod schema definition for unknown type.
+ */
+export declare const unknown: typeof schemaDefinition.unknown;
+/**
+ * Zod schema definition for never type.
+ */
+export declare const never: typeof schemaDefinition.never;
+/**
+ * Transforms valid schema into Zod schema.
+ */
+export declare const schemify: typeof schemaDefinition.schemify;
+/**
+ * Makes a valid schema optional.
+ */
+export declare const optional: typeof schemaDefinition.optional;
+/**
+ * Defines an array for a valid schema.
+ */
+export declare const array: typeof schemaDefinition.array;
+/**
+ * Defines a union for a valid schema.
+ */
+export declare const union: typeof schemaDefinition.union;
+/**
+ * Defines a literal for a valid schema.
+ */
+export declare const literal: typeof schemaDefinition.literal;
+/**
+ * Validates a value against a valid schema.
+ */
+export declare const validate: typeof schemaDefinition.validate;
+/**
+ * Generates an OpenAPI schema object from a valid schema.
+ */
+export declare const openapi: typeof schemaDefinition.openapi;
+export {};