@forklaunch/validator 0.4.11 → 0.5.0

package/lib/src/typebox/index.d.ts

@@ -1,126 +1,11 @@
 import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
-import { SchemaObject } from 'openapi3-ts/oas31';
 import * as _sinclair_typebox_compiler from '@sinclair/typebox/compiler';
-import { TypeCheck } from '@sinclair/typebox/compiler';
-import { S as SchemaValidator$1, T as TObject, f as TIdiomaticSchema, g as TResolve, h as TUnionContainer, i as UnionTResolve, L as LiteralSchema, j as TCatchall, a as ParseResult } from '../../schema.types-BA3PeCI5.js';
-export { l as TObjectShape, k as TOuterArray, m as TSchemaTranslate, n as UnboxedTObjectSchema } from '../../schema.types-BA3PeCI5.js';
+import { T as TypeboxSchemaValidator, f as TIdiomaticSchema, g as TResolve, h as TUnionTupleContainer, i as UnionTupleTResolve, L as LiteralSchema, j as TCatchall, a as ParseResult } from '../../schema.types-BL6n8u4w.js';
+export { m as TObject, l as TObjectShape, k as TOuterArray, n as TSchemaTranslate, o as UnboxedTObjectSchema } from '../../schema.types-BL6n8u4w.js';
 import * as _sinclair_typebox from '@sinclair/typebox';
-import { TProperties, TOptional, TArray, TUnion, TLiteral, TSchema } from '@sinclair/typebox';
 import '@forklaunch/common';
 import 'zod';
 
-/**
- * Class representing a TypeBox schema definition.
- * @implements {SchemaValidator}
- */
-declare class TypeboxSchemaValidator implements SchemaValidator$1<(<T extends TObject<TProperties>>(schema: T) => TypeCheck<T>), <T extends TIdiomaticSchema>(schema: T) => TResolve<T>, <T extends TIdiomaticSchema>(schema: T) => TOptional<TResolve<T>>, <T extends TIdiomaticSchema>(schema: T) => TArray<TResolve<T>>, <T extends TUnionContainer>(schemas: [...T]) => TUnion<UnionTResolve<T>>, <T extends LiteralSchema>(value: T) => TLiteral<T>, <T extends Record<string, LiteralSchema>>(schemaEnum: T) => TUnion<[
-    {
-        [K in keyof T]: TLiteral<T[K]>;
-    }[keyof T]
-]>, (value: unknown) => value is TSchema, <T extends TIdiomaticSchema | TCatchall>(schema: T, value: unknown) => boolean, <T extends TIdiomaticSchema | TCatchall>(schema: T, value: unknown) => ParseResult<TResolve<T>>, <T extends TIdiomaticSchema | TCatchall>(schema: T) => SchemaObject> {
-    _Type: "TypeBox";
-    _SchemaCatchall: TSchema;
-    _ValidSchemaObject: TObject<TProperties> | TArray<TObject<TProperties>>;
-    string: _sinclair_typebox.TString;
-    uuid: _sinclair_typebox.TString;
-    uri: _sinclair_typebox.TString;
-    email: _sinclair_typebox.TString;
-    number: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull, _sinclair_typebox.TDate, _sinclair_typebox.TBigInt]>, number>;
-    bigint: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TBigInt, _sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TDate]>, bigint>;
-    boolean: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TBoolean, _sinclair_typebox.TString]>, boolean>;
-    date: _sinclair_typebox.TTransform<TUnion<[_sinclair_typebox.TDate, _sinclair_typebox.TNumber, _sinclair_typebox.TString, _sinclair_typebox.TBoolean, _sinclair_typebox.TNull]>, Date>;
-    symbol: _sinclair_typebox.TSymbol;
-    nullish: TUnion<[_sinclair_typebox.TVoid, _sinclair_typebox.TNull, _sinclair_typebox.TUndefined]>;
-    any: _sinclair_typebox.TAny;
-    unknown: _sinclair_typebox.TUnknown;
-    never: _sinclair_typebox.TNever;
-    /**
-     * 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.
-     */
-    private errorType;
-    /**
-     * Compiles schema if this exists, for optimal performance.
-     *
-     * @param {TObject<TProperties>} schema - The schema to compile.
-     * @returns {TypeCheck<T>} - The compiled schema.
-     */
-    compile<T extends TObject<TProperties>>(schema: T): TypeCheck<T>;
-    /**
-     * 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.
-     *
-     * 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<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>;
-    /**
-     * Create an enum schema.
-     * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
-     * @returns {TUnion<UnionTResolve<T[]>>} The enum schema.
-     */
-    enum_<T extends Record<string, LiteralSchema>>(schemaEnum: T): TUnion<[
-        {
-            [K in keyof T]: TLiteral<T[K]>;
-        }[keyof T]
-    ]>;
-    /**
-     * 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: unknown): value is TSchema;
-    /**
-     * 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 TIdiomaticSchema | TSchema>(schema: T | TypeCheck<TResolve<T>>, value: unknown): boolean;
-    /**
-     * 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<T extends TIdiomaticSchema | TSchema>(schema: T | TypeCheck<TResolve<T>>, value: unknown): ParseResult<TResolve<T>>;
-    /**
-     * 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 TypeboxSchemaValidator instance.
  * @returns {TypeboxSchemaValidator} The TypeboxSchemaValidator instance.
@@ -166,6 +51,18 @@ declare const symbol: _sinclair_typebox.TSymbol;
  * TypeBox schema definition for undefined, null, void types.
  */
 declare const nullish: _sinclair_typebox.TUnion<[_sinclair_typebox.TVoid, _sinclair_typebox.TNull, _sinclair_typebox.TUndefined]>;
+/**
+ * TypeBox schema definition for void type.
+ */
+declare const void_: _sinclair_typebox.TVoid;
+/**
+ * TypeBox schema definition for null type.
+ */
+declare const null_: _sinclair_typebox.TNull;
+/**
+ * TypeBox schema definition for undefined type.
+ */
+declare const undefined_: _sinclair_typebox.TUndefined;
 /**
  * TypeBox schema definition for any type.
  */
@@ -193,7 +90,7 @@ declare const array: <T extends TIdiomaticSchema>(schema: T) => _sinclair_typebo
 /**
  * Defines a union for a valid schema.
  */
-declare const union: <T extends TUnionContainer>(schemas: [...T]) => _sinclair_typebox.TUnion<UnionTResolve<T>>;
+declare const union: <T extends TUnionTupleContainer>(schemas: [...T]) => _sinclair_typebox.TUnion<UnionTupleTResolve<T>>;
 /**
  * Defines a literal for a valid schema.
  */
@@ -202,6 +99,18 @@ declare const literal: <T extends LiteralSchema>(value: T) => _sinclair_typebox.
  * Defines an enum for a valid schema.
  */
 declare const enum_: <T extends Record<string, LiteralSchema>>(schemaEnum: T) => _sinclair_typebox.TUnion<[{ [K in keyof T]: _sinclair_typebox.TLiteral<T[K]>; }[keyof T]]>;
+/**
+ * Defines a function for a valid schema.
+ */
+declare const function_: <Args extends TUnionTupleContainer, ReturnType extends TIdiomaticSchema>(args: [...Args], returnType: ReturnType) => _sinclair_typebox.TFunction<UnionTupleTResolve<Args>, TResolve<ReturnType>>;
+/**
+ * Defines a record for a valid schema.
+ */
+declare const record: <Key extends TIdiomaticSchema, Value extends TIdiomaticSchema>(key: Key, value: Value) => _sinclair_typebox.TRecord<TResolve<Key>, TResolve<Value>>;
+/**
+ * Defines a promise for a valid schema.
+ */
+declare const promise: <T extends TIdiomaticSchema>(schema: T) => _sinclair_typebox.TPromise<TResolve<T>>;
 /**
  * Checks if a value is a TypeBox schema.
  */
@@ -209,14 +118,14 @@ declare const isSchema: (value: unknown) => value is _sinclair_typebox.TSchema;
 /**
  * Validates a value against a valid schema.
  */
-declare const validate: <T extends TIdiomaticSchema | _sinclair_typebox.TSchema>(schema: T | _sinclair_typebox_compiler.TypeCheck<TResolve<T>>, value: unknown) => boolean;
+declare const validate: <T extends TIdiomaticSchema | TCatchall>(schema: T | _sinclair_typebox_compiler.TypeCheck<TResolve<T>>, value: unknown) => boolean;
 /**
  * Parses a value against a valid schema.
  */
-declare const parse: <T extends TIdiomaticSchema | _sinclair_typebox.TSchema>(schema: T | _sinclair_typebox_compiler.TypeCheck<TResolve<T>>, value: unknown) => ParseResult<TResolve<T>>;
+declare const parse: <T extends TIdiomaticSchema | TCatchall>(schema: T | _sinclair_typebox_compiler.TypeCheck<TResolve<T>>, value: unknown) => ParseResult<TResolve<T>>;
 /**
  * Generates an OpenAPI schema object from a valid schema.
  */
-declare const openapi: <T extends TIdiomaticSchema | _sinclair_typebox.TSchema>(schema: T) => openapi3_ts_oas31.SchemaObject;
+declare const openapi: <T extends TIdiomaticSchema | TCatchall>(schema: T) => openapi3_ts_oas31.SchemaObject;
 
-export { SchemaValidator, TCatchall, TIdiomaticSchema, TObject, TResolve, TUnionContainer, TypeboxSchemaValidator, UnionTResolve, any, array, bigint, boolean, date, email, enum_, isSchema, literal, never, nullish, number, openapi, optional, parse, schemify, string, symbol, union, unknown, uri, uuid, validate };
+export { SchemaValidator, TCatchall, TIdiomaticSchema, TResolve, TUnionTupleContainer, TypeboxSchemaValidator, UnionTupleTResolve, any, array, bigint, boolean, date, email, enum_, function_, isSchema, literal, never, null_, nullish, number, openapi, optional, parse, promise, record, schemify, string, symbol, undefined_, union, unknown, uri, uuid, validate, void_ };

package/lib/src/typebox/index.js

@@ -28,22 +28,28 @@ __export(typebox_exports, {
   date: () => date,
   email: () => email,
   enum_: () => enum_,
+  function_: () => function_,
   isSchema: () => isSchema,
   literal: () => literal,
   never: () => never,
+  null_: () => null_,
   nullish: () => nullish,
   number: () => number,
   openapi: () => openapi,
   optional: () => optional,
   parse: () => parse,
+  promise: () => promise,
+  record: () => record,
   schemify: () => schemify,
   string: () => string,
   symbol: () => symbol,
+  undefined_: () => undefined_,
   union: () => union,
   unknown: () => unknown,
   uri: () => uri,
   uuid: () => uuid,
-  validate: () => validate
+  validate: () => validate,
+  void_: () => void_
 });
 module.exports = __toCommonJS(typebox_exports);
 
@@ -68,7 +74,6 @@ var TypeboxSchemaValidator = class {
   _SchemaCatchall;
   _ValidSchemaObject;
   string = import_typebox.Type.String();
-  // uuid = Type.String({ format: 'uuid' });
   uuid = import_typebox.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"
@@ -181,6 +186,9 @@ var TypeboxSchemaValidator = class {
   nullish = import_typebox.Type.Union([import_typebox.Type.Void(), import_typebox.Type.Null(), import_typebox.Type.Undefined()], {
     errorType: "nullish"
   });
+  void = import_typebox.Type.Void();
+  null = import_typebox.Type.Null();
+  undefined = import_typebox.Type.Undefined();
   any = import_typebox.Type.Any();
   unknown = import_typebox.Type.Unknown();
   never = import_typebox.Type.Never();
@@ -191,7 +199,7 @@ var TypeboxSchemaValidator = class {
    * @returns The type of the schema for error messages.
    */
   errorType(schema) {
-    if (Object.hasOwn(schema, "errorType")) {
+    if (import_typebox.KindGuard.IsSchema(schema) && Object.hasOwn(schema, "errorType")) {
       return schema.errorType;
     } else if (import_typebox.KindGuard.IsLiteral(schema)) {
       return schema.const;
@@ -236,7 +244,7 @@ var TypeboxSchemaValidator = class {
    * @returns {TOptional<TResolve<T>>} The optional schema.
    */
   optional(schema) {
-    const schemified = import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    const schemified = this.schemify(schema);
     return import_typebox.Type.Optional(schemified);
   }
   /**
@@ -245,22 +253,22 @@ var TypeboxSchemaValidator = class {
    * @returns {TArray<TResolve<T>>} The array schema.
    */
   array(schema) {
-    const schemified = import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    const schemified = this.schemify(schema);
     return import_typebox.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.
+   * @param {TUnionTupleContainer} schemas - The schemas to union.
+   * @returns {TUnion<UnionTupleTResolve<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 import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+      return this.schemify(schema);
     });
     return import_typebox.Type.Union(unionTypes, {
       errorType: `any of ${unionTypes.map((s) => this.errorType(s)).join(", ")}`,
@@ -280,13 +288,45 @@ var TypeboxSchemaValidator = class {
   /**
    * Create an enum schema.
    * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
-   * @returns {TUnion<UnionTResolve<T[]>>} The enum schema.
+   * @returns {TUnion<UnionTupleTResolve<T[]>>} The enum schema.
    */
   enum_(schemaEnum) {
     return this.union(
       Object.values(schemaEnum).map((value) => this.literal(value))
     );
   }
+  /**
+   * Create a function schema.
+   * @param {TSchema[]} args - The arguments of the function.
+   * @param {TAny} returnType - The return type of the function.
+   * @returns {TFunction<Args, ReturnType>} The function schema.
+   */
+  function_(args, returnType) {
+    const schemaArgs = args.map((schema) => {
+      return this.schemify(schema);
+    });
+    const schemaReturnType = this.schemify(returnType);
+    return import_typebox.Type.Function(schemaArgs, schemaReturnType);
+  }
+  /**
+   * Create a record schema.
+   * @param {TIdiomaticSchema} key - The key schema.
+   * @param {TIdiomaticSchema} value - The value schema.
+   * @returns {TRecord<TResolve<Key>, TResolve<Value>>} The record schema.
+   */
+  record(key, value) {
+    const keySchema = this.schemify(key);
+    const valueSchema = this.schemify(value);
+    return import_typebox.Type.Record(keySchema, valueSchema);
+  }
+  /**
+   * Create a promise schema.
+   * @param {TIdiomaticSchema} schema - The schema to use for the promise.
+   * @returns {TPromise<TResolve<T>>} The promise schema.
+   */
+  promise(schema) {
+    return import_typebox.Type.Promise(this.schemify(schema));
+  }
   /**
    * Check if a value is a TypeBox object schema.
    * @param {unknown} value - The value to check.
@@ -306,7 +346,7 @@ var TypeboxSchemaValidator = class {
     if (schema instanceof import_compiler.TypeCheck) {
       return schema.Check(value);
     } else {
-      const schemified = import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+      const schemified = this.schemify(schema);
       return import_value.Value.Check(schemified, value);
     }
   }
@@ -327,7 +367,7 @@ var TypeboxSchemaValidator = class {
         errors = Array.from(schema.Errors(value));
       }
     } else {
-      const schemified = import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+      const schemified = this.schemify(schema);
       if (import_value.Value.Check(schemified, value)) {
         conversion = import_value.Value.Decode(schemified, value);
       } else {
@@ -374,11 +414,11 @@ var TypeboxSchemaValidator = class {
   }
   /**
    * Convert a schema to an OpenAPI schema object.
-   * @param {TIdiomaticSchema | TSchema} schema - The schema to convert.
+   * @param {TIdiomaticSchema | TCatchall} schema - The schema to convert.
    * @returns {SchemaObject} The OpenAPI schema object.
    */
   openapi(schema) {
-    const schemified = import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    const schemified = this.schemify(schema);
     if (Object.hasOwn(schemified, "openapiType") || import_typebox.KindGuard.IsLiteral(schemified)) {
       return schemified.openapiType;
     }
@@ -410,6 +450,9 @@ var boolean = StaticSchemaValidator.boolean;
 var date = StaticSchemaValidator.date;
 var symbol = StaticSchemaValidator.symbol;
 var nullish = StaticSchemaValidator.nullish;
+var void_ = StaticSchemaValidator.void;
+var null_ = StaticSchemaValidator.null;
+var undefined_ = StaticSchemaValidator.undefined;
 var any = StaticSchemaValidator.any;
 var unknown = StaticSchemaValidator.unknown;
 var never = StaticSchemaValidator.never;
@@ -425,6 +468,13 @@ var literal = StaticSchemaValidator.literal.bind(
   StaticSchemaValidator
 );
 var enum_ = StaticSchemaValidator.enum_.bind(StaticSchemaValidator);
+var function_ = StaticSchemaValidator.function_.bind(
+  StaticSchemaValidator
+);
+var record = StaticSchemaValidator.record.bind(StaticSchemaValidator);
+var promise = StaticSchemaValidator.promise.bind(
+  StaticSchemaValidator
+);
 var isSchema = StaticSchemaValidator.isSchema.bind(
   StaticSchemaValidator
 );
@@ -445,20 +495,26 @@ var openapi = StaticSchemaValidator.openapi.bind(
   date,
   email,
   enum_,
+  function_,
   isSchema,
   literal,
   never,
+  null_,
   nullish,
   number,
   openapi,
   optional,
   parse,
+  promise,
+  record,
   schemify,
   string,
   symbol,
+  undefined_,
   union,
   unknown,
   uri,
   uuid,
-  validate
+  validate,
+  void_
 });

package/lib/src/typebox/index.mjs

@@ -27,7 +27,6 @@ var TypeboxSchemaValidator = class {
   _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"
@@ -140,6 +139,9 @@ var TypeboxSchemaValidator = class {
   nullish = Type.Union([Type.Void(), Type.Null(), Type.Undefined()], {
     errorType: "nullish"
   });
+  void = Type.Void();
+  null = Type.Null();
+  undefined = Type.Undefined();
   any = Type.Any();
   unknown = Type.Unknown();
   never = Type.Never();
@@ -150,7 +152,7 @@ var TypeboxSchemaValidator = class {
    * @returns The type of the schema for error messages.
    */
   errorType(schema) {
-    if (Object.hasOwn(schema, "errorType")) {
+    if (KindGuard.IsSchema(schema) && Object.hasOwn(schema, "errorType")) {
       return schema.errorType;
     } else if (KindGuard.IsLiteral(schema)) {
       return schema.const;
@@ -195,7 +197,7 @@ var TypeboxSchemaValidator = class {
    * @returns {TOptional<TResolve<T>>} The optional schema.
    */
   optional(schema) {
-    const schemified = KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    const schemified = this.schemify(schema);
     return Type.Optional(schemified);
   }
   /**
@@ -204,22 +206,22 @@ var TypeboxSchemaValidator = class {
    * @returns {TArray<TResolve<T>>} The array schema.
    */
   array(schema) {
-    const schemified = KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    const schemified = 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.
+   * @param {TUnionTupleContainer} schemas - The schemas to union.
+   * @returns {TUnion<UnionTupleTResolve<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 this.schemify(schema);
     });
     return Type.Union(unionTypes, {
       errorType: `any of ${unionTypes.map((s) => this.errorType(s)).join(", ")}`,
@@ -239,13 +241,45 @@ var TypeboxSchemaValidator = class {
   /**
    * Create an enum schema.
    * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
-   * @returns {TUnion<UnionTResolve<T[]>>} The enum schema.
+   * @returns {TUnion<UnionTupleTResolve<T[]>>} The enum schema.
    */
   enum_(schemaEnum) {
     return this.union(
       Object.values(schemaEnum).map((value) => this.literal(value))
     );
   }
+  /**
+   * Create a function schema.
+   * @param {TSchema[]} args - The arguments of the function.
+   * @param {TAny} returnType - The return type of the function.
+   * @returns {TFunction<Args, ReturnType>} The function schema.
+   */
+  function_(args, returnType) {
+    const schemaArgs = args.map((schema) => {
+      return this.schemify(schema);
+    });
+    const schemaReturnType = this.schemify(returnType);
+    return Type.Function(schemaArgs, schemaReturnType);
+  }
+  /**
+   * Create a record schema.
+   * @param {TIdiomaticSchema} key - The key schema.
+   * @param {TIdiomaticSchema} value - The value schema.
+   * @returns {TRecord<TResolve<Key>, TResolve<Value>>} The record schema.
+   */
+  record(key, value) {
+    const keySchema = this.schemify(key);
+    const valueSchema = this.schemify(value);
+    return Type.Record(keySchema, valueSchema);
+  }
+  /**
+   * Create a promise schema.
+   * @param {TIdiomaticSchema} schema - The schema to use for the promise.
+   * @returns {TPromise<TResolve<T>>} The promise schema.
+   */
+  promise(schema) {
+    return Type.Promise(this.schemify(schema));
+  }
   /**
    * Check if a value is a TypeBox object schema.
    * @param {unknown} value - The value to check.
@@ -265,7 +299,7 @@ var TypeboxSchemaValidator = class {
     if (schema instanceof TypeCheck) {
       return schema.Check(value);
     } else {
-      const schemified = KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+      const schemified = this.schemify(schema);
       return Value.Check(schemified, value);
     }
   }
@@ -286,7 +320,7 @@ var TypeboxSchemaValidator = class {
         errors = Array.from(schema.Errors(value));
       }
     } else {
-      const schemified = KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+      const schemified = this.schemify(schema);
       if (Value.Check(schemified, value)) {
         conversion = Value.Decode(schemified, value);
       } else {
@@ -333,11 +367,11 @@ var TypeboxSchemaValidator = class {
   }
   /**
    * Convert a schema to an OpenAPI schema object.
-   * @param {TIdiomaticSchema | TSchema} schema - The schema to convert.
+   * @param {TIdiomaticSchema | TCatchall} schema - The schema to convert.
    * @returns {SchemaObject} The OpenAPI schema object.
    */
   openapi(schema) {
-    const schemified = KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    const schemified = this.schemify(schema);
     if (Object.hasOwn(schemified, "openapiType") || KindGuard.IsLiteral(schemified)) {
       return schemified.openapiType;
     }
@@ -369,6 +403,9 @@ var boolean = StaticSchemaValidator.boolean;
 var date = StaticSchemaValidator.date;
 var symbol = StaticSchemaValidator.symbol;
 var nullish = StaticSchemaValidator.nullish;
+var void_ = StaticSchemaValidator.void;
+var null_ = StaticSchemaValidator.null;
+var undefined_ = StaticSchemaValidator.undefined;
 var any = StaticSchemaValidator.any;
 var unknown = StaticSchemaValidator.unknown;
 var never = StaticSchemaValidator.never;
@@ -384,6 +421,13 @@ var literal = StaticSchemaValidator.literal.bind(
   StaticSchemaValidator
 );
 var enum_ = StaticSchemaValidator.enum_.bind(StaticSchemaValidator);
+var function_ = StaticSchemaValidator.function_.bind(
+  StaticSchemaValidator
+);
+var record = StaticSchemaValidator.record.bind(StaticSchemaValidator);
+var promise = StaticSchemaValidator.promise.bind(
+  StaticSchemaValidator
+);
 var isSchema = StaticSchemaValidator.isSchema.bind(
   StaticSchemaValidator
 );
@@ -403,20 +447,26 @@ export {
   date,
   email,
   enum_,
+  function_,
   isSchema,
   literal,
   never,
+  null_,
   nullish,
   number,
   openapi,
   optional,
   parse,
+  promise,
+  record,
   schemify,
   string,
   symbol,
+  undefined_,
   union,
   unknown,
   uri,
   uuid,
-  validate
+  validate,
+  void_
 };

package/lib/src/zod/index.d.mts

@@ -1,6 +1,6 @@
 import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
-import { Z as ZodSchemaValidator, o as ZodIdiomaticSchema, p as ZodResolve, q as ZodUnionContainer, r as UnionZodResolve, L as LiteralSchema, s as ZodCatchall, a as ParseResult } from '../../schema.types-BA3PeCI5.mjs';
-export { x as UnboxedZodObjectSchema, v as ZodObject, u as ZodObjectShape, t as ZodOuterArray, w as ZodSchemaTranslate } from '../../schema.types-BA3PeCI5.mjs';
+import { Z as ZodSchemaValidator, p as ZodIdiomaticSchema, q as ZodResolve, r as ZodUnionContainer, s as UnionZodResolve, L as LiteralSchema, t as ZodTupleContainer, u as TupleZodResolve, v as ZodRecordKey, w as ZodCatchall, a as ParseResult } from '../../schema.types-BL6n8u4w.mjs';
+export { C as UnboxedZodObjectSchema, z as ZodObject, y as ZodObjectShape, x as ZodOuterArray, B as ZodSchemaTranslate } from '../../schema.types-BL6n8u4w.mjs';
 import * as zod from 'zod';
 import '@forklaunch/common';
 import '@sinclair/typebox';
@@ -51,6 +51,18 @@ declare const symbol: zod.ZodSymbol;
  * Zod schema definition for undefined, null, void types.
  */
 declare const nullish: zod.ZodUnion<[zod.ZodVoid, zod.ZodNull, zod.ZodUndefined]>;
+/**
+ * Zod schema definition for void type.
+ */
+declare const void_: zod.ZodVoid;
+/**
+ * Zod schema definition for null type.
+ */
+declare const null_: zod.ZodNull;
+/**
+ * Zod schema definition for undefined type.
+ */
+declare const undefined_: zod.ZodUndefined;
 /**
  * Zod schema definition for any type.
  */
@@ -82,11 +94,23 @@ declare const union: <T extends ZodUnionContainer>(schemas: T) => zod.ZodUnion<U
 /**
  * Defines a literal for a valid schema.
  */
-declare const literal: <T extends LiteralSchema>(value: T) => zod.ZodLiteral<ZodResolve<T>>;
+declare const literal: <T extends LiteralSchema>(value: T) => zod.ZodLiteral<T>;
 /**
  * Defines an enum for a valid schema.
  */
 declare const enum_: <T extends Record<string, LiteralSchema>>(schemaEnum: T) => zod.ZodUnion<[{ [K in keyof T]: zod.ZodLiteral<T[K]>; }[keyof T]]>;
+/**
+ * Defines a function for a valid schema.
+ */
+declare const function_: <Args extends ZodTupleContainer, ReturnType extends ZodIdiomaticSchema>(args: Args, returnType: ReturnType) => zod.ZodFunction<zod.ZodTuple<TupleZodResolve<Args>, null>, ZodResolve<ReturnType>>;
+/**
+ * Defines a record for a valid schema.
+ */
+declare const record: <Key extends ZodIdiomaticSchema, Value extends ZodIdiomaticSchema>(key: Key, value: Value) => zod.ZodRecord<ZodRecordKey<Key>, ZodResolve<Value>>;
+/**
+ * Defines a promise for a valid schema.
+ */
+declare const promise: <T extends ZodIdiomaticSchema>(schema: T) => zod.ZodPromise<ZodResolve<T>>;
 /**
  * Checks if a value is a Zod schema.
  */
@@ -104,4 +128,4 @@ declare const parse: <T extends ZodIdiomaticSchema | ZodCatchall>(schema: T, val
  */
 declare const openapi: <T extends ZodIdiomaticSchema | ZodCatchall>(schema: T) => openapi3_ts_oas31.SchemaObject;
 
-export { SchemaValidator, UnionZodResolve, ZodCatchall, ZodIdiomaticSchema, ZodResolve, ZodSchemaValidator, ZodUnionContainer, any, array, bigint, boolean, date, email, enum_, isSchema, literal, never, nullish, number, openapi, optional, parse, schemify, string, symbol, union, unknown, uri, uuid, validate };
+export { SchemaValidator, TupleZodResolve, UnionZodResolve, ZodCatchall, ZodIdiomaticSchema, ZodRecordKey, ZodResolve, ZodSchemaValidator, ZodTupleContainer, ZodUnionContainer, any, array, bigint, boolean, date, email, enum_, function_, isSchema, literal, never, null_, nullish, number, openapi, optional, parse, promise, record, schemify, string, symbol, undefined_, union, unknown, uri, uuid, validate, void_ };