@forklaunch/validator 0.3.12 → 0.4.0

package/lib/src/zod/index.js

@@ -1 +1,291 @@
-export * from './staticSchemaValidator';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/zod/index.ts
+var zod_exports = {};
+__export(zod_exports, {
+  SchemaValidator: () => SchemaValidator,
+  any: () => any,
+  array: () => array,
+  bigint: () => bigint,
+  boolean: () => boolean,
+  date: () => date,
+  email: () => email,
+  enum_: () => enum_,
+  isSchema: () => isSchema,
+  literal: () => literal,
+  never: () => never,
+  nullish: () => nullish,
+  number: () => number,
+  openapi: () => openapi,
+  optional: () => optional,
+  parse: () => parse,
+  schemify: () => schemify,
+  string: () => string,
+  symbol: () => symbol,
+  union: () => union,
+  unknown: () => unknown,
+  uri: () => uri,
+  uuid: () => uuid,
+  validate: () => validate
+});
+module.exports = __toCommonJS(zod_exports);
+
+// src/zod/zodSchemaValidator.ts
+var import_zod_openapi = require("@anatine/zod-openapi");
+var import_zod = require("zod");
+var ZodSchemaValidator = class {
+  _Type;
+  _SchemaCatchall;
+  _ValidSchemaObject;
+  string = import_zod.z.string();
+  uuid = import_zod.z.coerce.string().uuid();
+  email = import_zod.z.coerce.string().email();
+  uri = import_zod.z.coerce.string().url();
+  number = import_zod.z.coerce.number();
+  bigint = import_zod.z.coerce.bigint();
+  boolean = import_zod.z.preprocess((val) => {
+    if (typeof val === "string") {
+      if (val.toLowerCase() === "true") return true;
+      if (val.toLowerCase() === "false") return false;
+    }
+    return val;
+  }, import_zod.z.boolean());
+  date = import_zod.z.coerce.date();
+  symbol = import_zod.z.symbol();
+  nullish = import_zod.z.union([import_zod.z.void(), import_zod.z.null(), import_zod.z.undefined()]);
+  any = import_zod.z.any();
+  unknown = import_zod.z.unknown();
+  never = import_zod.z.never();
+  /**
+   * Pretty print Zod errors.
+   *
+   * @param {ZodError} error - The Zod error to pretty print.
+   * @returns
+   */
+  prettyPrintZodErrors(error) {
+    if (!error) return;
+    const errorMessages = error.errors.map((err, index) => {
+      const path = err.path.length > 0 ? err.path.join(" > ") : "root";
+      return `${index + 1}. Path: ${path}
+   Message: ${err.message}`;
+    });
+    return `Validation failed with the following errors:
+${errorMessages.join("\n\n")}`;
+  }
+  /**
+   * Compiles schema if this exists, for optimal performance.
+   *
+   * @param {ZodObject<ZodRawShape>} schema - The schema to compile.
+   * @returns {ZodResolve<T>} - The compiled schema.
+   */
+  compile(schema) {
+    return schema;
+  }
+  /**
+   * Convert a schema to a Zod schema.
+   * @param {ZodIdiomaticSchema} schema - The schema to convert.
+   * @returns {ZodResolve<T>} The resolved schema.
+   */
+  schemify(schema) {
+    if (typeof schema === "string" || typeof schema === "number" || typeof schema === "boolean") {
+      return import_zod.z.literal(schema);
+    }
+    if (schema instanceof import_zod.ZodType) {
+      return schema;
+    }
+    const newSchema = {};
+    Object.getOwnPropertyNames(schema).forEach((key) => {
+      if (schema[key] instanceof import_zod.ZodType) {
+        newSchema[key] = schema[key];
+      } else {
+        newSchema[key] = this.schemify(schema[key]);
+      }
+    });
+    return import_zod.z.object(newSchema);
+  }
+  /**
+   * Make a schema optional.
+   * @param {ZodIdiomaticSchema} schema - The schema to make optional.
+   * @returns {ZodOptional<ZodResolve<T>>} The optional schema.
+   */
+  optional(schema) {
+    if (schema instanceof import_zod.ZodType) {
+      return schema.optional();
+    } else {
+      return this.schemify(schema).optional();
+    }
+  }
+  /**
+   * Create an array schema.
+   * @param {ZodIdiomaticSchema} schema - The schema to use for array items.
+   * @returns {ZodArray<ZodResolve<T>>} The array schema.
+   */
+  array(schema) {
+    if (schema instanceof import_zod.ZodType) {
+      return schema.array();
+    } else {
+      return this.schemify(schema).array();
+    }
+  }
+  /**
+   * Create a union schema.
+   * @param {ZodUnionContainer} schemas - The schemas to union.
+   * @returns {ZodUnion<UnionZodResolve<T>>} The union schema.
+   */
+  union(schemas) {
+    const resolvedSchemas = schemas.map((schema) => {
+      if (schema instanceof import_zod.ZodType) {
+        return schema;
+      }
+      return this.schemify(schema);
+    });
+    return import_zod.z.union(
+      resolvedSchemas
+    );
+  }
+  /**
+   * Create a literal schema.
+   * @param {LiteralSchema} value - The literal value.
+   * @returns {ZodLiteral<ZodResolve<T>>} The literal schema.
+   */
+  literal(value) {
+    return import_zod.z.literal(value);
+  }
+  /**
+   * Create an enum schema.
+   * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
+   * @returns {ZodUnion<UnionZodResolve<[T, T, ...T[]]>>} The enum schema.
+   */
+  enum_(schemaEnum) {
+    return this.union(Object.values(schemaEnum));
+  }
+  /**
+   * 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) {
+    return value instanceof import_zod.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(schema, value) {
+    return schema.safeParse(value).success;
+  }
+  /**
+   * 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(schema, value) {
+    try {
+      const result = schema.safeParse(value);
+      return result.success ? { ok: true, value: result.data } : {
+        ok: false,
+        error: this.prettyPrintZodErrors(result.error)
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: `Unexpected zod safeParse error: ${error.message}`
+      };
+    }
+  }
+  /**
+   * Convert a schema to an OpenAPI schema object.
+   * @param {ZodIdiomaticSchema} schema - The schema to convert.
+   * @returns {SchemaObject} The OpenAPI schema object.
+   */
+  openapi(schema) {
+    return (0, import_zod_openapi.generateSchema)(this.schemify(schema));
+  }
+};
+
+// src/zod/staticSchemaValidator.ts
+var SchemaValidator = () => new ZodSchemaValidator();
+var StaticSchemaValidator = SchemaValidator();
+var string = StaticSchemaValidator.string;
+var uuid = StaticSchemaValidator.uuid;
+var email = StaticSchemaValidator.email;
+var uri = StaticSchemaValidator.uri;
+var number = StaticSchemaValidator.number;
+var bigint = StaticSchemaValidator.bigint;
+var boolean = StaticSchemaValidator.boolean;
+var date = StaticSchemaValidator.date;
+var symbol = StaticSchemaValidator.symbol;
+var nullish = StaticSchemaValidator.nullish;
+var any = StaticSchemaValidator.any;
+var unknown = StaticSchemaValidator.unknown;
+var never = StaticSchemaValidator.never;
+var schemify = StaticSchemaValidator.schemify.bind(
+  StaticSchemaValidator
+);
+var optional = StaticSchemaValidator.optional.bind(
+  StaticSchemaValidator
+);
+var array = StaticSchemaValidator.array.bind(StaticSchemaValidator);
+var union = StaticSchemaValidator.union.bind(StaticSchemaValidator);
+var literal = StaticSchemaValidator.literal.bind(
+  StaticSchemaValidator
+);
+var enum_ = StaticSchemaValidator.enum_.bind(StaticSchemaValidator);
+var isSchema = StaticSchemaValidator.isSchema.bind(
+  StaticSchemaValidator
+);
+var validate = StaticSchemaValidator.validate.bind(
+  StaticSchemaValidator
+);
+var parse = StaticSchemaValidator.parse.bind(StaticSchemaValidator);
+var openapi = StaticSchemaValidator.openapi.bind(
+  StaticSchemaValidator
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SchemaValidator,
+  any,
+  array,
+  bigint,
+  boolean,
+  date,
+  email,
+  enum_,
+  isSchema,
+  literal,
+  never,
+  nullish,
+  number,
+  openapi,
+  optional,
+  parse,
+  schemify,
+  string,
+  symbol,
+  union,
+  unknown,
+  uri,
+  uuid,
+  validate
+});

package/lib/src/zod/index.mjs

@@ -0,0 +1,244 @@
+// src/zod/zodSchemaValidator.ts
+import { generateSchema } from "@anatine/zod-openapi";
+import {
+  ZodType,
+  z
+} from "zod";
+var ZodSchemaValidator = class {
+  _Type;
+  _SchemaCatchall;
+  _ValidSchemaObject;
+  string = z.string();
+  uuid = z.coerce.string().uuid();
+  email = z.coerce.string().email();
+  uri = z.coerce.string().url();
+  number = z.coerce.number();
+  bigint = z.coerce.bigint();
+  boolean = z.preprocess((val) => {
+    if (typeof val === "string") {
+      if (val.toLowerCase() === "true") return true;
+      if (val.toLowerCase() === "false") return false;
+    }
+    return val;
+  }, z.boolean());
+  date = z.coerce.date();
+  symbol = z.symbol();
+  nullish = z.union([z.void(), z.null(), z.undefined()]);
+  any = z.any();
+  unknown = z.unknown();
+  never = z.never();
+  /**
+   * Pretty print Zod errors.
+   *
+   * @param {ZodError} error - The Zod error to pretty print.
+   * @returns
+   */
+  prettyPrintZodErrors(error) {
+    if (!error) return;
+    const errorMessages = error.errors.map((err, index) => {
+      const path = err.path.length > 0 ? err.path.join(" > ") : "root";
+      return `${index + 1}. Path: ${path}
+   Message: ${err.message}`;
+    });
+    return `Validation failed with the following errors:
+${errorMessages.join("\n\n")}`;
+  }
+  /**
+   * Compiles schema if this exists, for optimal performance.
+   *
+   * @param {ZodObject<ZodRawShape>} schema - The schema to compile.
+   * @returns {ZodResolve<T>} - The compiled schema.
+   */
+  compile(schema) {
+    return schema;
+  }
+  /**
+   * Convert a schema to a Zod schema.
+   * @param {ZodIdiomaticSchema} schema - The schema to convert.
+   * @returns {ZodResolve<T>} The resolved schema.
+   */
+  schemify(schema) {
+    if (typeof schema === "string" || typeof schema === "number" || typeof schema === "boolean") {
+      return z.literal(schema);
+    }
+    if (schema instanceof ZodType) {
+      return schema;
+    }
+    const newSchema = {};
+    Object.getOwnPropertyNames(schema).forEach((key) => {
+      if (schema[key] instanceof ZodType) {
+        newSchema[key] = schema[key];
+      } else {
+        newSchema[key] = this.schemify(schema[key]);
+      }
+    });
+    return z.object(newSchema);
+  }
+  /**
+   * Make a schema optional.
+   * @param {ZodIdiomaticSchema} schema - The schema to make optional.
+   * @returns {ZodOptional<ZodResolve<T>>} The optional schema.
+   */
+  optional(schema) {
+    if (schema instanceof ZodType) {
+      return schema.optional();
+    } else {
+      return this.schemify(schema).optional();
+    }
+  }
+  /**
+   * Create an array schema.
+   * @param {ZodIdiomaticSchema} schema - The schema to use for array items.
+   * @returns {ZodArray<ZodResolve<T>>} The array schema.
+   */
+  array(schema) {
+    if (schema instanceof ZodType) {
+      return schema.array();
+    } else {
+      return this.schemify(schema).array();
+    }
+  }
+  /**
+   * Create a union schema.
+   * @param {ZodUnionContainer} schemas - The schemas to union.
+   * @returns {ZodUnion<UnionZodResolve<T>>} The union schema.
+   */
+  union(schemas) {
+    const resolvedSchemas = schemas.map((schema) => {
+      if (schema instanceof ZodType) {
+        return schema;
+      }
+      return this.schemify(schema);
+    });
+    return z.union(
+      resolvedSchemas
+    );
+  }
+  /**
+   * Create a literal schema.
+   * @param {LiteralSchema} value - The literal value.
+   * @returns {ZodLiteral<ZodResolve<T>>} The literal schema.
+   */
+  literal(value) {
+    return z.literal(value);
+  }
+  /**
+   * Create an enum schema.
+   * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
+   * @returns {ZodUnion<UnionZodResolve<[T, T, ...T[]]>>} The enum schema.
+   */
+  enum_(schemaEnum) {
+    return this.union(Object.values(schemaEnum));
+  }
+  /**
+   * 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) {
+    return value instanceof 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(schema, value) {
+    return schema.safeParse(value).success;
+  }
+  /**
+   * 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(schema, value) {
+    try {
+      const result = schema.safeParse(value);
+      return result.success ? { ok: true, value: result.data } : {
+        ok: false,
+        error: this.prettyPrintZodErrors(result.error)
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: `Unexpected zod safeParse error: ${error.message}`
+      };
+    }
+  }
+  /**
+   * Convert a schema to an OpenAPI schema object.
+   * @param {ZodIdiomaticSchema} schema - The schema to convert.
+   * @returns {SchemaObject} The OpenAPI schema object.
+   */
+  openapi(schema) {
+    return generateSchema(this.schemify(schema));
+  }
+};
+
+// src/zod/staticSchemaValidator.ts
+var SchemaValidator = () => new ZodSchemaValidator();
+var StaticSchemaValidator = SchemaValidator();
+var string = StaticSchemaValidator.string;
+var uuid = StaticSchemaValidator.uuid;
+var email = StaticSchemaValidator.email;
+var uri = StaticSchemaValidator.uri;
+var number = StaticSchemaValidator.number;
+var bigint = StaticSchemaValidator.bigint;
+var boolean = StaticSchemaValidator.boolean;
+var date = StaticSchemaValidator.date;
+var symbol = StaticSchemaValidator.symbol;
+var nullish = StaticSchemaValidator.nullish;
+var any = StaticSchemaValidator.any;
+var unknown = StaticSchemaValidator.unknown;
+var never = StaticSchemaValidator.never;
+var schemify = StaticSchemaValidator.schemify.bind(
+  StaticSchemaValidator
+);
+var optional = StaticSchemaValidator.optional.bind(
+  StaticSchemaValidator
+);
+var array = StaticSchemaValidator.array.bind(StaticSchemaValidator);
+var union = StaticSchemaValidator.union.bind(StaticSchemaValidator);
+var literal = StaticSchemaValidator.literal.bind(
+  StaticSchemaValidator
+);
+var enum_ = StaticSchemaValidator.enum_.bind(StaticSchemaValidator);
+var isSchema = StaticSchemaValidator.isSchema.bind(
+  StaticSchemaValidator
+);
+var validate = StaticSchemaValidator.validate.bind(
+  StaticSchemaValidator
+);
+var parse = StaticSchemaValidator.parse.bind(StaticSchemaValidator);
+var openapi = StaticSchemaValidator.openapi.bind(
+  StaticSchemaValidator
+);
+export {
+  SchemaValidator,
+  any,
+  array,
+  bigint,
+  boolean,
+  date,
+  email,
+  enum_,
+  isSchema,
+  literal,
+  never,
+  nullish,
+  number,
+  openapi,
+  optional,
+  parse,
+  schemify,
+  string,
+  symbol,
+  union,
+  unknown,
+  uri,
+  uuid,
+  validate
+};

package/lib/tests/utils/mockSchemaValidator.d.mts

@@ -0,0 +1,69 @@
+import { SchemaObject } from 'openapi3-ts/oas31';
+import { S as SchemaValidator, L as LiteralSchema, P as ParseResult } from '../../index-V6qNDTlr.mjs';
+import '@forklaunch/common';
+import '@sinclair/typebox';
+import '@sinclair/typebox/compiler';
+import 'zod';
+
+declare module '@forklaunch/validator' {
+    interface SchemaResolve<T> {
+        Mock: T;
+    }
+    interface SchemaTranslate<T> {
+        Mock: T;
+    }
+}
+type RecursiveUnion<T extends readonly string[]> = T extends readonly [
+    infer F extends string,
+    ...infer R extends readonly string[]
+] ? R extends [] ? F : `${F} | ${RecursiveUnion<R>}` : '';
+declare class MockSchemaValidator implements SchemaValidator<(<T extends string>(schema: T) => T), <T extends string>(schema: T) => T, <T extends string>(schema: T) => `optional ${T}`, <T extends string>(schema: T) => `array ${T}`, <T extends readonly string[]>(schemas: T) => RecursiveUnion<T>, <T extends LiteralSchema>(schema: T) => `literal ${T}`, <T extends LiteralSchema>(schemaEnum: Record<string, T>) => `enum ${T}`, (value: unknown) => value is string, <T extends string>(schema: T, value: string) => boolean, <T extends string>(schema: T, value: string) => ParseResult<T>, <T extends string>(schema: T) => SchemaObject> {
+    _Type: 'Mock';
+    _SchemaCatchall: string;
+    _ValidSchemaObject: string;
+    string: string;
+    uuid: string;
+    email: string;
+    uri: string;
+    number: string;
+    bigint: string;
+    boolean: string;
+    date: string;
+    symbol: string;
+    nullish: string;
+    any: string;
+    unknown: string;
+    never: string;
+    compile<T extends string>(schema: T): T;
+    schemify<T extends string>(schema: T): T;
+    optional<T extends string>(schema: T): `optional ${T}`;
+    array<T extends string>(schema: T): `array ${T}`;
+    union<T extends readonly string[]>(schemas: T): RecursiveUnion<T>;
+    literal<T extends LiteralSchema>(schema: T): `literal ${T}`;
+    enum_<T extends LiteralSchema>(schemaEnum: Record<string, T>): `enum ${T}`;
+    isSchema(value: unknown): value is string;
+    validate<T extends string>(schema: T, value: string): boolean;
+    parse<T extends string>(schema: T, value: string): ParseResult<T>;
+    openapi<T extends string>(_schema: T): SchemaObject;
+}
+declare const mockSchemaValidator: MockSchemaValidator;
+declare const string: string;
+declare const number: string;
+declare const bigint: string;
+declare const boolean: string;
+declare const date: string;
+declare const symbol: string;
+declare const nullish: string;
+declare const any: string;
+declare const unknown: string;
+declare const never: string;
+declare const schemify: <T extends string>(schema: T) => T;
+declare const optional: <T extends string>(schema: T) => `optional ${T}`;
+declare const array: <T extends string>(schema: T) => `array ${T}`;
+declare const union: <T extends readonly string[]>(schemas: T) => RecursiveUnion<T>;
+declare const literal: <T extends LiteralSchema>(schema: T) => `literal ${T}`;
+declare const enum_: <T extends LiteralSchema>(schemaEnum: Record<string, T>) => `enum ${T}`;
+declare const validate: <T extends string>(schema: T, value: string) => boolean;
+declare const openapi: <T extends string>(_schema: T) => SchemaObject;
+
+export { MockSchemaValidator, any, array, bigint, boolean, date, enum_, literal, mockSchemaValidator, never, nullish, number, openapi, optional, schemify, string, symbol, union, unknown, validate };

package/lib/tests/utils/mockSchemaValidator.d.ts

@@ -1,7 +1,11 @@
 import { SchemaObject } from 'openapi3-ts/oas31';
-import { SchemaValidator } from '../../index';
-import { LiteralSchema, ParseResult } from '../../src/shared/types/schema.types';
-declare module '../../src/shared/types/schema.types' {
+import { S as SchemaValidator, L as LiteralSchema, P as ParseResult } from '../../index-V6qNDTlr.js';
+import '@forklaunch/common';
+import '@sinclair/typebox';
+import '@sinclair/typebox/compiler';
+import 'zod';
+
+declare module '@forklaunch/validator' {
     interface SchemaResolve<T> {
         Mock: T;
     }
@@ -13,7 +17,7 @@ type RecursiveUnion<T extends readonly string[]> = T extends readonly [
     infer F extends string,
     ...infer R extends readonly string[]
 ] ? R extends [] ? F : `${F} | ${RecursiveUnion<R>}` : '';
-export declare class MockSchemaValidator implements SchemaValidator<(<T extends string>(schema: T) => T), <T extends string>(schema: T) => T, <T extends string>(schema: T) => `optional ${T}`, <T extends string>(schema: T) => `array ${T}`, <T extends readonly string[]>(schemas: T) => RecursiveUnion<T>, <T extends LiteralSchema>(schema: T) => `literal ${T}`, <T extends LiteralSchema>(schemaEnum: Record<string, T>) => `enum ${T}`, (value: unknown) => value is string, <T extends string>(schema: T, value: string) => boolean, <T extends string>(schema: T, value: string) => ParseResult<T>, <T extends string>(schema: T) => SchemaObject> {
+declare class MockSchemaValidator implements SchemaValidator<(<T extends string>(schema: T) => T), <T extends string>(schema: T) => T, <T extends string>(schema: T) => `optional ${T}`, <T extends string>(schema: T) => `array ${T}`, <T extends readonly string[]>(schemas: T) => RecursiveUnion<T>, <T extends LiteralSchema>(schema: T) => `literal ${T}`, <T extends LiteralSchema>(schemaEnum: Record<string, T>) => `enum ${T}`, (value: unknown) => value is string, <T extends string>(schema: T, value: string) => boolean, <T extends string>(schema: T, value: string) => ParseResult<T>, <T extends string>(schema: T) => SchemaObject> {
     _Type: 'Mock';
     _SchemaCatchall: string;
     _ValidSchemaObject: string;
@@ -42,24 +46,24 @@ export declare class MockSchemaValidator implements SchemaValidator<(<T extends
     parse<T extends string>(schema: T, value: string): ParseResult<T>;
     openapi<T extends string>(_schema: T): SchemaObject;
 }
-export declare const mockSchemaValidator: MockSchemaValidator;
-export declare const string: string;
-export declare const number: string;
-export declare const bigint: string;
-export declare const boolean: string;
-export declare const date: string;
-export declare const symbol: string;
-export declare const nullish: string;
-export declare const any: string;
-export declare const unknown: string;
-export declare const never: string;
-export declare const schemify: <T extends string>(schema: T) => T;
-export declare const optional: <T extends string>(schema: T) => `optional ${T}`;
-export declare const array: <T extends string>(schema: T) => `array ${T}`;
-export declare const union: <T extends readonly string[]>(schemas: T) => RecursiveUnion<T>;
-export declare const literal: <T extends LiteralSchema>(schema: T) => `literal ${T}`;
-export declare const enum_: <T extends LiteralSchema>(schemaEnum: Record<string, T>) => `enum ${T}`;
-export declare const validate: <T extends string>(schema: T, value: string) => boolean;
-export declare const openapi: <T extends string>(_schema: T) => SchemaObject;
-export {};
-//# sourceMappingURL=mockSchemaValidator.d.ts.map
+declare const mockSchemaValidator: MockSchemaValidator;
+declare const string: string;
+declare const number: string;
+declare const bigint: string;
+declare const boolean: string;
+declare const date: string;
+declare const symbol: string;
+declare const nullish: string;
+declare const any: string;
+declare const unknown: string;
+declare const never: string;
+declare const schemify: <T extends string>(schema: T) => T;
+declare const optional: <T extends string>(schema: T) => `optional ${T}`;
+declare const array: <T extends string>(schema: T) => `array ${T}`;
+declare const union: <T extends readonly string[]>(schemas: T) => RecursiveUnion<T>;
+declare const literal: <T extends LiteralSchema>(schema: T) => `literal ${T}`;
+declare const enum_: <T extends LiteralSchema>(schemaEnum: Record<string, T>) => `enum ${T}`;
+declare const validate: <T extends string>(schema: T, value: string) => boolean;
+declare const openapi: <T extends string>(_schema: T) => SchemaObject;
+
+export { MockSchemaValidator, any, array, bigint, boolean, date, enum_, literal, mockSchemaValidator, never, nullish, number, openapi, optional, schemify, string, symbol, union, unknown, validate };