@forklaunch/validator 0.7.7 → 0.8.0

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

@@ -1,5 +1,5 @@
 import { SchemaObject } from 'openapi3-ts/oas31';
-import { S as SchemaValidator, L as LiteralSchema, a as ParseResult } from '../../schema.types-C3S1yoja.mjs';
+import { S as SchemaValidator, L as LiteralSchema, a as ParseResult } from '../../schema.types-BmSJeE9l.mjs';
 import '@forklaunch/common';
 import '@sinclair/typebox';
 import '@sinclair/typebox/compiler';
@@ -24,7 +24,7 @@ type SerializeStringArray<T extends string[]> = T extends [
  * A mock implementation of SchemaValidator for testing purposes.
  * This validator represents schemas as strings and provides simple string-based operations.
  */
-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}`, <Args extends string[], ReturnType extends string>(args: Args, returnType: ReturnType) => `function(${SerializeStringArray<Args>}) => ${ReturnType}`, <Key extends string, Value extends string>(key: Key, value: Value) => `{${Key}: ${Value}}`, <T extends string>(schema: T) => `Promise<${T}>`, (value: unknown) => value is string, <T extends string>(value: unknown, type: T) => value is T, <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>() => T), <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}`, <Args extends string[], ReturnType extends string>(args: Args, returnType: ReturnType) => `function(${SerializeStringArray<Args>}) => ${ReturnType}`, <Key extends string, Value extends string>(key: Key, value: Value) => `{${Key}: ${Value}}`, <T extends string>(schema: T) => `Promise<${T}>`, (value: unknown) => value is string, <T extends string>(value: unknown, type: T) => value is T, <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;
@@ -43,6 +43,7 @@ declare class MockSchemaValidator implements SchemaValidator<(<T extends string>
     never: string;
     binary: string;
     file: string;
+    type<T>(): T;
     /**
      * Compiles a schema string.
      *

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

@@ -1,5 +1,5 @@
 import { SchemaObject } from 'openapi3-ts/oas31';
-import { S as SchemaValidator, L as LiteralSchema, a as ParseResult } from '../../schema.types-C3S1yoja.js';
+import { S as SchemaValidator, L as LiteralSchema, a as ParseResult } from '../../schema.types-BmSJeE9l.js';
 import '@forklaunch/common';
 import '@sinclair/typebox';
 import '@sinclair/typebox/compiler';
@@ -24,7 +24,7 @@ type SerializeStringArray<T extends string[]> = T extends [
  * A mock implementation of SchemaValidator for testing purposes.
  * This validator represents schemas as strings and provides simple string-based operations.
  */
-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}`, <Args extends string[], ReturnType extends string>(args: Args, returnType: ReturnType) => `function(${SerializeStringArray<Args>}) => ${ReturnType}`, <Key extends string, Value extends string>(key: Key, value: Value) => `{${Key}: ${Value}}`, <T extends string>(schema: T) => `Promise<${T}>`, (value: unknown) => value is string, <T extends string>(value: unknown, type: T) => value is T, <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>() => T), <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}`, <Args extends string[], ReturnType extends string>(args: Args, returnType: ReturnType) => `function(${SerializeStringArray<Args>}) => ${ReturnType}`, <Key extends string, Value extends string>(key: Key, value: Value) => `{${Key}: ${Value}}`, <T extends string>(schema: T) => `Promise<${T}>`, (value: unknown) => value is string, <T extends string>(value: unknown, type: T) => value is T, <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;
@@ -43,6 +43,7 @@ declare class MockSchemaValidator implements SchemaValidator<(<T extends string>
     never: string;
     binary: string;
     file: string;
+    type<T>(): T;
     /**
      * Compiles a schema string.
      *

package/lib/__test__/utils/mockSchemaValidator.js

@@ -65,6 +65,9 @@ var MockSchemaValidator = class {
   never = "never";
   binary = "binary";
   file = "file";
+  type() {
+    return "type";
+  }
   /**
    * Compiles a schema string.
    *

package/lib/__test__/utils/mockSchemaValidator.mjs

@@ -19,6 +19,9 @@ var MockSchemaValidator = class {
   never = "never";
   binary = "binary";
   file = "file";
+  type() {
+    return "type";
+  }
   /**
    * Compiles a schema string.
    *

package/lib/index.d.mts

@@ -1,5 +1,5 @@
-import { P as ParseError } from './schema.types-C3S1yoja.mjs';
-export { A as AnySchemaValidator, I as IdiomaticSchema, e as Increment, K as KeyTypes, L as LiteralSchema, a as ParseResult, d as Schema, b as SchemaResolve, c as SchemaTranslate, S as SchemaValidator, U as UnboxedObjectSchema } from './schema.types-C3S1yoja.mjs';
+import { P as ParseError } from './schema.types-BmSJeE9l.mjs';
+export { A as AnySchemaValidator, I as IdiomaticSchema, e as Increment, K as KeyTypes, L as LiteralSchema, a as ParseResult, d as Schema, b as SchemaResolve, c as SchemaTranslate, S as SchemaValidator, U as UnboxedObjectSchema } from './schema.types-BmSJeE9l.mjs';
 import '@forklaunch/common';
 import 'openapi3-ts/oas31';
 import '@sinclair/typebox';

package/lib/index.d.ts

@@ -1,5 +1,5 @@
-import { P as ParseError } from './schema.types-C3S1yoja.js';
-export { A as AnySchemaValidator, I as IdiomaticSchema, e as Increment, K as KeyTypes, L as LiteralSchema, a as ParseResult, d as Schema, b as SchemaResolve, c as SchemaTranslate, S as SchemaValidator, U as UnboxedObjectSchema } from './schema.types-C3S1yoja.js';
+import { P as ParseError } from './schema.types-BmSJeE9l.js';
+export { A as AnySchemaValidator, I as IdiomaticSchema, e as Increment, K as KeyTypes, L as LiteralSchema, a as ParseResult, d as Schema, b as SchemaResolve, c as SchemaTranslate, S as SchemaValidator, U as UnboxedObjectSchema } from './schema.types-BmSJeE9l.js';
 import '@forklaunch/common';
 import 'openapi3-ts/oas31';
 import '@sinclair/typebox';

package/lib/{schema.types-C3S1yoja.d.mts → schema.types-BmSJeE9l.d.mts}

@@ -1,8 +1,8 @@
 import { Prettify } from '@forklaunch/common';
 import { SchemaObject } from 'openapi3-ts/oas31';
-import { TProperties, TOptional, TArray, TUnion, TLiteral, TFunction, TRecord, TPromise, TSchema, TString, TTransform, TNumber, TBoolean, TNull, TBigInt, TDate, TSymbol, TVoid, TUndefined, TAny, TUnknown, TNever, TKind, TObject, StaticDecode } from '@sinclair/typebox';
+import { TTransform, TAny, TProperties, TOptional, TArray, TUnion, TLiteral, TFunction, TRecord, TPromise, TSchema, TString, TNumber, TBoolean, TNull, TBigInt, TDate, TSymbol, TVoid, TUndefined, TUnknown, TNever, TKind, TObject, StaticDecode } from '@sinclair/typebox';
 import { TypeCheck } from '@sinclair/typebox/compiler';
-import { ZodObject as ZodObject$1, ZodRawShape, ZodOptional, ZodArray, ZodUnion, ZodLiteral, ZodFunction, ZodTuple, ZodRecord, ZodPromise, ZodType, z, ZodUnknown, ZodPipeline, ZodTypeAny, ZodEffects, ZodNever } from 'zod/v3';
+import { ZodType, ZodObject as ZodObject$1, ZodRawShape, ZodOptional, ZodArray, ZodUnion, ZodLiteral, ZodFunction, ZodTuple, ZodRecord, ZodPromise, z, ZodUnknown, ZodPipeline, ZodTypeAny, ZodEffects, ZodNever } from 'zod/v3';
 
 /**
  * This module provides a TypeScript-based schema definition using the TypeBox library.
@@ -15,7 +15,7 @@ import { ZodObject as ZodObject$1, ZodRawShape, ZodOptional, ZodArray, ZodUnion,
  * Class representing a TypeBox schema definition.
  * @implements {SchemaValidator}
  */
-declare class TypeboxSchemaValidator implements SchemaValidator<(<T extends SafeTObject<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 TUnionTupleContainer>(schemas: [...T]) => TUnion<UnionTupleTResolve<T>>, <T extends LiteralSchema>(value: T) => TLiteral<T>, <T extends Record<string, LiteralSchema>>(schemaEnum: T) => TUnion<[
+declare class TypeboxSchemaValidator implements SchemaValidator<(<T>() => TTransform<TAny, T>), <T extends SafeTObject<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 TUnionTupleContainer>(schemas: [...T]) => TUnion<UnionTupleTResolve<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]
@@ -226,7 +226,7 @@ type TResolve<T, Depth extends number = 0> = Depth extends 12 ? TUnknown : T ext
  * 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<T>, <T extends Record<string, LiteralSchema>>(schemaEnum: T) => ZodUnion<[
+declare class ZodSchemaValidator implements SchemaValidator<(<T>() => ZodType<T>), <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<T>, <T extends Record<string, LiteralSchema>>(schemaEnum: T) => ZodUnion<[
     {
         [K in keyof T]: ZodLiteral<T[K]>;
     }[keyof T]
@@ -250,7 +250,7 @@ declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodObjec
     any: z.ZodAny;
     unknown: z.ZodUnknown;
     never: z.ZodNever;
-    binary: z.ZodEffects<z.ZodString, Uint8Array<ArrayBufferLike>, string>;
+    binary: z.ZodEffects<z.ZodString, Uint8Array<ArrayBuffer>, string>;
     file: z.ZodEffects<z.ZodString, Blob, string>;
     type: <T>() => ZodType<T>;
     /**
@@ -478,7 +478,7 @@ type ParseResult<T> = {
  * @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, FunctionFunction = <Args, ReturnType>(args: Args, returnType: ReturnType) => unknown, RecordFunction = <Key, Value>(key: Key, value: Value) => unknown, PromiseFunction = <T>(schema: T) => unknown, SchemaGuardFunction = <T>(value: unknown) => value is T, InstanceOfFunction = <T>(value: unknown, type: T) => value is T, ValidationFunction = <T>(schema: T, value: unknown) => boolean, ParseFunction = <T>(schema: T, value: unknown) => ParseResult<SchemaResolve<T>>, OpenAPIFunction = <T>(schema: T) => SchemaObject> {
+interface SchemaValidator<TypeFunction = <T>() => T, 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, FunctionFunction = <Args, ReturnType>(args: Args, returnType: ReturnType) => unknown, RecordFunction = <Key, Value>(key: Key, value: Value) => unknown, PromiseFunction = <T>(schema: T) => unknown, SchemaGuardFunction = <T>(value: unknown) => value is T, InstanceOfFunction = <T>(value: unknown, type: T) => 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.
      */
@@ -551,6 +551,10 @@ interface SchemaValidator<CompilationFunction = <T>(schema: T) => unknown, Schem
      * Validator for file type
      */
     file: unknown;
+    /**
+     * Validator for type type
+     */
+    type: TypeFunction;
     /**
      * Compiles schema if this exists, for optimal performance.
      *
@@ -665,7 +669,7 @@ interface SchemaValidator<CompilationFunction = <T>(schema: T) => unknown, Schem
 /**
  * Type representing any schema validator.
  */
-type AnySchemaValidator = SchemaValidator<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> & {
+type AnySchemaValidator = SchemaValidator<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> & {
     /**
      * The type of the schema resolver.
      */

package/lib/{schema.types-C3S1yoja.d.ts → schema.types-BmSJeE9l.d.ts}

@@ -1,8 +1,8 @@
 import { Prettify } from '@forklaunch/common';
 import { SchemaObject } from 'openapi3-ts/oas31';
-import { TProperties, TOptional, TArray, TUnion, TLiteral, TFunction, TRecord, TPromise, TSchema, TString, TTransform, TNumber, TBoolean, TNull, TBigInt, TDate, TSymbol, TVoid, TUndefined, TAny, TUnknown, TNever, TKind, TObject, StaticDecode } from '@sinclair/typebox';
+import { TTransform, TAny, TProperties, TOptional, TArray, TUnion, TLiteral, TFunction, TRecord, TPromise, TSchema, TString, TNumber, TBoolean, TNull, TBigInt, TDate, TSymbol, TVoid, TUndefined, TUnknown, TNever, TKind, TObject, StaticDecode } from '@sinclair/typebox';
 import { TypeCheck } from '@sinclair/typebox/compiler';
-import { ZodObject as ZodObject$1, ZodRawShape, ZodOptional, ZodArray, ZodUnion, ZodLiteral, ZodFunction, ZodTuple, ZodRecord, ZodPromise, ZodType, z, ZodUnknown, ZodPipeline, ZodTypeAny, ZodEffects, ZodNever } from 'zod/v3';
+import { ZodType, ZodObject as ZodObject$1, ZodRawShape, ZodOptional, ZodArray, ZodUnion, ZodLiteral, ZodFunction, ZodTuple, ZodRecord, ZodPromise, z, ZodUnknown, ZodPipeline, ZodTypeAny, ZodEffects, ZodNever } from 'zod/v3';
 
 /**
  * This module provides a TypeScript-based schema definition using the TypeBox library.
@@ -15,7 +15,7 @@ import { ZodObject as ZodObject$1, ZodRawShape, ZodOptional, ZodArray, ZodUnion,
  * Class representing a TypeBox schema definition.
  * @implements {SchemaValidator}
  */
-declare class TypeboxSchemaValidator implements SchemaValidator<(<T extends SafeTObject<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 TUnionTupleContainer>(schemas: [...T]) => TUnion<UnionTupleTResolve<T>>, <T extends LiteralSchema>(value: T) => TLiteral<T>, <T extends Record<string, LiteralSchema>>(schemaEnum: T) => TUnion<[
+declare class TypeboxSchemaValidator implements SchemaValidator<(<T>() => TTransform<TAny, T>), <T extends SafeTObject<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 TUnionTupleContainer>(schemas: [...T]) => TUnion<UnionTupleTResolve<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]
@@ -226,7 +226,7 @@ type TResolve<T, Depth extends number = 0> = Depth extends 12 ? TUnknown : T ext
  * 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<T>, <T extends Record<string, LiteralSchema>>(schemaEnum: T) => ZodUnion<[
+declare class ZodSchemaValidator implements SchemaValidator<(<T>() => ZodType<T>), <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<T>, <T extends Record<string, LiteralSchema>>(schemaEnum: T) => ZodUnion<[
     {
         [K in keyof T]: ZodLiteral<T[K]>;
     }[keyof T]
@@ -250,7 +250,7 @@ declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodObjec
     any: z.ZodAny;
     unknown: z.ZodUnknown;
     never: z.ZodNever;
-    binary: z.ZodEffects<z.ZodString, Uint8Array<ArrayBufferLike>, string>;
+    binary: z.ZodEffects<z.ZodString, Uint8Array<ArrayBuffer>, string>;
     file: z.ZodEffects<z.ZodString, Blob, string>;
     type: <T>() => ZodType<T>;
     /**
@@ -478,7 +478,7 @@ type ParseResult<T> = {
  * @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, FunctionFunction = <Args, ReturnType>(args: Args, returnType: ReturnType) => unknown, RecordFunction = <Key, Value>(key: Key, value: Value) => unknown, PromiseFunction = <T>(schema: T) => unknown, SchemaGuardFunction = <T>(value: unknown) => value is T, InstanceOfFunction = <T>(value: unknown, type: T) => value is T, ValidationFunction = <T>(schema: T, value: unknown) => boolean, ParseFunction = <T>(schema: T, value: unknown) => ParseResult<SchemaResolve<T>>, OpenAPIFunction = <T>(schema: T) => SchemaObject> {
+interface SchemaValidator<TypeFunction = <T>() => T, 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, FunctionFunction = <Args, ReturnType>(args: Args, returnType: ReturnType) => unknown, RecordFunction = <Key, Value>(key: Key, value: Value) => unknown, PromiseFunction = <T>(schema: T) => unknown, SchemaGuardFunction = <T>(value: unknown) => value is T, InstanceOfFunction = <T>(value: unknown, type: T) => 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.
      */
@@ -551,6 +551,10 @@ interface SchemaValidator<CompilationFunction = <T>(schema: T) => unknown, Schem
      * Validator for file type
      */
     file: unknown;
+    /**
+     * Validator for type type
+     */
+    type: TypeFunction;
     /**
      * Compiles schema if this exists, for optimal performance.
      *
@@ -665,7 +669,7 @@ interface SchemaValidator<CompilationFunction = <T>(schema: T) => unknown, Schem
 /**
  * Type representing any schema validator.
  */
-type AnySchemaValidator = SchemaValidator<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> & {
+type AnySchemaValidator = SchemaValidator<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown> & {
     /**
      * The type of the schema resolver.
      */

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

@@ -1,6 +1,6 @@
 export * from '@sinclair/typebox';
-import { T as TypeboxSchemaValidator } from '../../schema.types-C3S1yoja.mjs';
-export { i as SafeTObject, f as TCatchall, l as TIdiomaticSchema, h as TObjectShape, g as TOuterArray, o as TResolve, j as TSchemaTranslate, m as TUnionTupleContainer, k as UnboxedTObjectSchema, n as UnionTupleTResolve } from '../../schema.types-C3S1yoja.mjs';
+import { T as TypeboxSchemaValidator } from '../../schema.types-BmSJeE9l.mjs';
+export { i as SafeTObject, f as TCatchall, l as TIdiomaticSchema, h as TObjectShape, g as TOuterArray, o as TResolve, j as TSchemaTranslate, m as TUnionTupleContainer, k as UnboxedTObjectSchema, n as UnionTupleTResolve } from '../../schema.types-BmSJeE9l.mjs';
 import '@forklaunch/common';
 import 'openapi3-ts/oas31';
 import '@sinclair/typebox/compiler';

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

@@ -1,6 +1,6 @@
 export * from '@sinclair/typebox';
-import { T as TypeboxSchemaValidator } from '../../schema.types-C3S1yoja.js';
-export { i as SafeTObject, f as TCatchall, l as TIdiomaticSchema, h as TObjectShape, g as TOuterArray, o as TResolve, j as TSchemaTranslate, m as TUnionTupleContainer, k as UnboxedTObjectSchema, n as UnionTupleTResolve } from '../../schema.types-C3S1yoja.js';
+import { T as TypeboxSchemaValidator } from '../../schema.types-BmSJeE9l.js';
+export { i as SafeTObject, f as TCatchall, l as TIdiomaticSchema, h as TObjectShape, g as TOuterArray, o as TResolve, j as TSchemaTranslate, m as TUnionTupleContainer, k as UnboxedTObjectSchema, n as UnionTupleTResolve } from '../../schema.types-BmSJeE9l.js';
 import '@forklaunch/common';
 import 'openapi3-ts/oas31';
 import '@sinclair/typebox/compiler';

package/lib/src/typebox/index.js

@@ -294,12 +294,12 @@ var TypeboxSchemaValidator = class {
    * @returns {TResolve<T>} The resolved schema.
    */
   schemify(schema) {
-    if (import_typebox.KindGuard.IsSchema(schema) || schema instanceof import_compiler.TypeCheck) {
-      return schema;
-    }
     if (typeof schema === "string" || typeof schema === "number" || typeof schema === "boolean") {
       return import_typebox.Type.Literal(schema);
     }
+    if (import_typebox.KindGuard.IsSchema(schema) || schema instanceof import_compiler.TypeCheck) {
+      return schema;
+    }
     const newSchema = {};
     Object.getOwnPropertyNames(schema).forEach((key) => {
       if (import_typebox.KindGuard.IsSchema(schema[key])) {

package/lib/src/typebox/index.mjs

@@ -245,12 +245,12 @@ var TypeboxSchemaValidator = class {
    * @returns {TResolve<T>} The resolved schema.
    */
   schemify(schema) {
-    if (KindGuard.IsSchema(schema) || schema instanceof TypeCheck) {
-      return schema;
-    }
     if (typeof schema === "string" || typeof schema === "number" || typeof schema === "boolean") {
       return Type.Literal(schema);
     }
+    if (KindGuard.IsSchema(schema) || schema instanceof TypeCheck) {
+      return schema;
+    }
     const newSchema = {};
     Object.getOwnPropertyNames(schema).forEach((key) => {
       if (KindGuard.IsSchema(schema[key])) {

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

@@ -1,6 +1,6 @@
 export { ZodAny, ZodArray, ZodBigInt, ZodBoolean, ZodDate, ZodEffects, ZodEnum, ZodFunction, ZodLiteral, ZodNever, ZodNull, ZodNumber, ZodObject, ZodOptional, ZodPipeline, ZodPromise, ZodRawShape, ZodRecord, ZodString, ZodSymbol, ZodTuple, ZodType, ZodTypeAny, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid } from 'zod/v3';
-import { Z as ZodSchemaValidator } from '../../schema.types-C3S1yoja.mjs';
-export { w as TupleZodResolve, t as UnboxedZodObjectSchema, y as UnionZodResolve, p as ZodCatchall, u as ZodIdiomaticSchema, r as ZodObjectShape, q as ZodOuterArray, B as ZodRecordKey, z as ZodResolve, s as ZodSchemaTranslate, v as ZodTupleContainer, x as ZodUnionContainer } from '../../schema.types-C3S1yoja.mjs';
+import { Z as ZodSchemaValidator } from '../../schema.types-BmSJeE9l.mjs';
+export { w as TupleZodResolve, t as UnboxedZodObjectSchema, y as UnionZodResolve, p as ZodCatchall, u as ZodIdiomaticSchema, r as ZodObjectShape, q as ZodOuterArray, B as ZodRecordKey, z as ZodResolve, s as ZodSchemaTranslate, v as ZodTupleContainer, x as ZodUnionContainer } from '../../schema.types-BmSJeE9l.mjs';
 import '@forklaunch/common';
 import 'openapi3-ts/oas31';
 import '@sinclair/typebox';

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

@@ -1,6 +1,6 @@
 export { ZodAny, ZodArray, ZodBigInt, ZodBoolean, ZodDate, ZodEffects, ZodEnum, ZodFunction, ZodLiteral, ZodNever, ZodNull, ZodNumber, ZodObject, ZodOptional, ZodPipeline, ZodPromise, ZodRawShape, ZodRecord, ZodString, ZodSymbol, ZodTuple, ZodType, ZodTypeAny, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid } from 'zod/v3';
-import { Z as ZodSchemaValidator } from '../../schema.types-C3S1yoja.js';
-export { w as TupleZodResolve, t as UnboxedZodObjectSchema, y as UnionZodResolve, p as ZodCatchall, u as ZodIdiomaticSchema, r as ZodObjectShape, q as ZodOuterArray, B as ZodRecordKey, z as ZodResolve, s as ZodSchemaTranslate, v as ZodTupleContainer, x as ZodUnionContainer } from '../../schema.types-C3S1yoja.js';
+import { Z as ZodSchemaValidator } from '../../schema.types-BmSJeE9l.js';
+export { w as TupleZodResolve, t as UnboxedZodObjectSchema, y as UnionZodResolve, p as ZodCatchall, u as ZodIdiomaticSchema, r as ZodObjectShape, q as ZodOuterArray, B as ZodRecordKey, z as ZodResolve, s as ZodSchemaTranslate, v as ZodTupleContainer, x as ZodUnionContainer } from '../../schema.types-BmSJeE9l.js';
 import '@forklaunch/common';
 import 'openapi3-ts/oas31';
 import '@sinclair/typebox';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forklaunch/validator",
-  "version": "0.7.7",
+  "version": "0.8.0",
   "description": "Schema validator for ForkLaunch components.",
   "homepage": "https://github.com/forklaunch/forklaunch-js#readme",
   "bugs": {
@@ -58,27 +58,27 @@
     "lib/**"
   ],
   "dependencies": {
-    "@sinclair/typebox": "^0.34.37",
+    "@sinclair/typebox": "^0.34.38",
     "ts-deepmerge": "^7.0.3",
-    "zod": "^4.0.5",
-    "@forklaunch/common": "0.4.5"
+    "zod": "^4.0.14",
+    "@forklaunch/common": "0.4.6"
   },
   "devDependencies": {
-    "@eslint/js": "^9.31.0",
+    "@eslint/js": "^9.32.0",
     "@types/jest": "^30.0.0",
-    "@types/node": "^24.0.13",
-    "@typescript/native-preview": "7.0.0-dev.20250712.1",
+    "@types/node": "^24.1.0",
+    "@typescript/native-preview": "7.0.0-dev.20250802.1",
     "@vitest/coverage-v8": "^3.2.4",
-    "eslint-config-prettier": "^10.1.5",
-    "eslint-plugin-prettier": "^5.5.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.3",
     "globals": "^16.3.0",
-    "jest": "^30.0.4",
+    "jest": "^30.0.5",
     "openapi3-ts": "^4.5.0",
     "ts-jest": "^29.4.0",
     "ts-node": "^10.9.2",
     "tsup": "^8.5.0",
-    "typedoc": "^0.28.7",
-    "typescript-eslint": "^8.36.0"
+    "typedoc": "^0.28.9",
+    "typescript-eslint": "^8.38.0"
   },
   "scripts": {
     "build": "tsgo --noEmit && tsup index.ts src/typebox/index.ts src/zod/index.ts __test__/utils/mockSchemaValidator.ts shims/zod-v3-openapi/zod-extensions.ts --format cjs,esm --no-splitting --tsconfig tsconfig.json --outDir lib --dts --clean",