lib0 0.2.112 → 0.2.115-0

package/dist/schema.d.ts

@@ -1,7 +1,24 @@
 /**
  * @template T
+ * @implements {traits.EqualityTrait}
  */
-export class $Schema<T> {
+export class Schema<T> implements traits.EqualityTrait {
+    /**
+     * If true, the more things are added to the shape the more objects this schema will accept (e.g.
+     * union). By default, the more objects are added, the the fewer objects this schema will accept.
+     * @protected
+     */
+    protected static _dilutes: boolean;
+    /**
+     * @param {Schema<any>} other
+     */
+    extends(other: Schema<any>): boolean;
+    /**
+     * Overwrite this when necessary. By default, we only check the `shape` property which every shape
+     * should have.
+     * @param {Schema<any>} other
+     */
+    equals(other: Schema<any>): boolean;
     /**
      * Use `schema.validate(obj)` with a typed parameter that is already of typed to be an instance of
      * Schema. Validate will check the structure of the parameter and return true iff the instance
@@ -15,17 +32,18 @@ export class $Schema<T> {
      * Similar to validate, but this method accepts untyped parameters.
      *
      * @param {any} _o
+     * @param {ValidationError} [_err]
      * @return {_o is T}
      */
-    check(_o: any): _o is T;
+    check(_o: any, _err?: ValidationError): _o is T;
     /**
-     * @type {$Schema<T?>}
+     * @type {Schema<T?>}
      */
-    get nullable(): $Schema<T | null>;
+    get nullable(): Schema<T | null>;
     /**
-     * @type {$Optional<$Schema<T>>}
+     * @type {$Optional<Schema<T>>}
      */
-    get optional(): $Optional<$Schema<T>>;
+    get optional(): $Optional<Schema<T>>;
     /**
      * Cast a variable to a specific type. Returns the casted value, or throws an exception otherwise.
      * Use this if you know that the type is of a specific type and you just want to convince the type
@@ -34,16 +52,23 @@ export class $Schema<T> {
      * **Do not rely on these error messages!**
      * Performs an assertion check only if not in a production environment.
      *
-     * @param {any} o
-     * @return {o extends T ? T : never}
+     * @template OO
+     * @param {OO} o
+     * @return {Extract<OO, T> extends never ? T : (OO extends Array<never> ? T : Extract<OO,T>)}
      */
-    cast(o: any): any extends T ? T : never;
+    cast<OO>(o: OO): Extract<OO, T> extends never ? T : (OO extends Array<never> ? T : Extract<OO, T>);
     /**
+     * EXPECTO PATRONUM!! 🪄
+     * This function protects against type errors. Though it may not work in the real world.
+     *
+     * "After all this time?"
+     * "Always." - Snape, talking about type safety
+     *
      * Ensures that a variable is a a specific type. Returns the value, or throws an exception if the assertion check failed.
      * Use this if you know that the type is of a specific type and you just want to convince the type
      * system.
      *
-     * Can be useful when defining lambdas: `s.lambda(s.$number, s.$void).ensure((n) => n + 1)`
+     * Can be useful when defining lambdas: `s.lambda(s.$number, s.$void).expect((n) => n + 1)`
      *
      * **Do not rely on these error messages!**
      * Performs an assertion check if not in a production environment.
@@ -51,150 +76,261 @@ export class $Schema<T> {
      * @param {T} o
      * @return {o extends T ? T : never}
      */
-    ensure(o: T): T extends T ? T : never;
-    get [schemaSymbol](): boolean;
+    expect(o: T): T extends T ? T : never;
+    [schemaSymbol](): boolean;
+    /**
+     * @param {object} other
+     */
+    [traits.EqualityTraitSymbol](other: object): boolean;
 }
+/**
+ * @template {(new (...args:any[]) => any) | ((...args:any[]) => any)} Constr
+ * @typedef {Constr extends ((...args:any[]) => infer T) ? T : (Constr extends (new (...args:any[]) => any) ? InstanceType<Constr> : never)} Instance
+ */
 /**
  * @template {(new (...args:any[]) => any) | ((...args:any[]) => any)} C
- * @extends {$Schema<C extends ((...args:any[]) => infer T) ? T : (C extends (new (...args:any[]) => any) ? InstanceType<C> : never)>}
+ * @extends {Schema<Instance<C>>}
  */
-export class $ConstructedBy<C extends (new (...args: any[]) => any) | ((...args: any[]) => any)> extends $Schema<C extends (...args: any[]) => infer T ? T : C extends new (...args: any[]) => any ? InstanceType<C> : never> {
+export class $ConstructedBy<C extends (new (...args: any[]) => any) | ((...args: any[]) => any)> extends Schema<Instance<C>> {
     /**
      * @param {C} c
+     * @param {((o:Instance<C>)=>boolean)|null} check
      */
-    constructor(c: C);
-    v: C;
+    constructor(c: C, check: ((o: Instance<C>) => boolean) | null);
+    shape: C;
+    _c: ((o: Instance<C>) => boolean) | null;
     /**
      * @param {any} o
+     * @param {ValidationError} [err]
      * @return {o is C extends ((...args:any[]) => infer T) ? T : (C extends (new (...args:any[]) => any) ? InstanceType<C> : never)} o
      */
-    check(o: any): o is C extends ((...args: any[]) => infer T_1) ? T_1 : (C extends (new (...args: any[]) => any) ? InstanceType<C> : never);
+    check(o: any, err?: ValidationError): o is C extends ((...args: any[]) => infer T) ? T : (C extends (new (...args: any[]) => any) ? InstanceType<C> : never);
+}
+export function $constructedBy<C extends (new (...args: any[]) => any) | ((...args: any[]) => any)>(c: C, check?: ((o: Instance<C>) => boolean) | null): CastToSchema<$ConstructedBy<C>>;
+export const $$constructedBy: Schema<$ConstructedBy<(new (...args: any[]) => any) | ((...args: any[]) => any)>>;
+/**
+ * Check custom properties on any object. You may want to overwrite the generated Schema<any>.
+ *
+ * @extends {Schema<any>}
+ */
+export class $Custom extends Schema<any> {
+    /**
+     * @param {(o:any) => boolean} check
+     */
+    constructor(check: (o: any) => boolean);
+    /**
+     * @type {(o:any) => boolean}
+     */
+    shape: (o: any) => boolean;
+    /**
+     * @param {any} o
+     * @param {ValidationError} err
+     * @return {o is any}
+     */
+    check(o: any, err: ValidationError): o is any;
 }
-export function constructedBy<C extends (new (...args: any[]) => any) | ((...args: any[]) => any)>(c: C): CastToSchema<$ConstructedBy<C>>;
+export function $custom(check: (o: any) => boolean): Schema<any>;
+export const $$custom: Schema<$Custom>;
 /**
  * @template {LiteralType} T
- * @extends {$Schema<T>}
+ * @extends {Schema<T>}
  */
-export class $Literal<T extends LiteralType> extends $Schema<T> {
+export class $Literal<T extends LiteralType> extends Schema<T> {
     /**
      * @param {Array<T>} literals
      */
     constructor(literals: Array<T>);
-    v: T[];
+    shape: T[];
 }
-export function literal<T extends LiteralType[]>(...literals: T): CastToSchema<$Literal<T[number]>>;
+export function $literal<T extends LiteralType[]>(...literals: T): CastToSchema<$Literal<T[number]>>;
+export const $$literal: Schema<$Literal<LiteralType>>;
 /**
- * @template {{ [key: string|symbol|number]: $Schema<any> }} S
- * @typedef {{ [Key in keyof S as S[Key] extends $Optional<$Schema<any>> ? Key : never]?: S[Key] extends $Optional<$Schema<infer Type>> ? Type : never } & { [Key in keyof S as S[Key] extends $Optional<$Schema<any>> ? never : Key]: S[Key] extends $Schema<infer Type> ? Type : never }} $ObjectToType
+ * @template {Array<string|Schema<string|number>>} T
+ * @extends {Schema<CastStringTemplateArgsToTemplate<T>>}
  */
+export class $StringTemplate<T extends Array<string | Schema<string | number>>> extends Schema<CastStringTemplateArgsToTemplate<T>> {
+    /**
+     * @param {T} shape
+     */
+    constructor(shape: T);
+    shape: T;
+    _r: RegExp;
+}
+export function $stringTemplate<T extends Array<string | Schema<string | number>>>(...literals: T): CastToSchema<$StringTemplate<T>>;
+export const $$stringTemplate: Schema<$StringTemplate<(string | Schema<string | number>)[]>>;
+export const $$optional: Schema<$Optional<Schema<any>>>;
 /**
- * @template {{[key:string|symbol|number]: $Schema<any>}} S
- * @extends {$Schema<$ObjectToType<S>>}
+ * @type {Schema<never>}
+ */
+export const $never: Schema<never>;
+export const $$never: Schema<$Never>;
+/**
+ * @template {{ [key: string|symbol|number]: Schema<any> }} S
+ * @typedef {{ [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? Key : never]?: S[Key] extends $Optional<Schema<infer Type>> ? Type : never } & { [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? never : Key]: S[Key] extends Schema<infer Type> ? Type : never }} $ObjectToType
+ */
+/**
+ * @template {{[key:string|symbol|number]: Schema<any>}} S
+ * @extends {Schema<$ObjectToType<S>>}
  */
 export class $Object<S extends {
-    [key: string | symbol | number]: $Schema<any>;
-}> extends $Schema<$ObjectToType<S>> {
+    [key: string | symbol | number]: Schema<any>;
+}> extends Schema<$ObjectToType<S>> {
+    /**
+     * @param {S} shape
+     * @param {boolean} partial
+     */
+    constructor(shape: S, partial?: boolean);
+    /**
+     * @type {S}
+     */
+    shape: S;
+    _isPartial: boolean;
+    /**
+     * @type {Schema<Partial<$ObjectToType<S>>>}
+     */
+    get partial(): Schema<Partial<$ObjectToType<S>>>;
     /**
-     * @param {S} v
+     * @param {any} o
+     * @param {ValidationError} err
+     * @return {o is $ObjectToType<S>}
      */
-    constructor(v: S);
-    v: S;
+    check(o: any, err: ValidationError): o is $ObjectToType<S>;
 }
-export function object<S extends {
-    [key: string | symbol | number]: $Schema<any>;
-}>(def: S): $Schema<{ [Key in keyof S as S[Key] extends $Optional<$Schema<any>> ? Key : never]?: S[Key] extends $Optional<$Schema<infer Type>> ? Type : never; } & { [Key in keyof S as S[Key] extends $Optional<$Schema<any>> ? never : Key]: S[Key] extends $Schema<infer Type> ? Type : never; }>;
+export function $object<S extends {
+    [key: string | symbol | number]: Schema<any>;
+}>(def: S): _ObjectDefToSchema<S> extends Schema<infer S_1> ? Schema<S_1> : never;
+export const $$object: Schema<$Object<{
+    [key: string]: Schema<any>;
+    [key: number]: Schema<any>;
+    [key: symbol]: Schema<any>;
+}>>;
+/**
+ * @type {Schema<{[key:string]: any}>}
+ */
+export const $objectAny: Schema<{
+    [key: string]: any;
+}>;
 /**
- * @template {$Schema<string|number|symbol>} Keys
- * @template {$Schema<any>} Values
- * @extends {$Schema<Record<Keys extends $Schema<infer K> ? K : never,Values extends $Schema<infer T> ? T : never>>}
+ * @template {Schema<string|number|symbol>} Keys
+ * @template {Schema<any>} Values
+ * @extends {Schema<{ [key in Unwrap<Keys>]: Unwrap<Values> }>}
  */
-export class $Record<Keys extends $Schema<string | number | symbol>, Values extends $Schema<any>> extends $Schema<Record<Keys extends $Schema<infer K> ? K : never, Values extends $Schema<infer T> ? T : never>> {
+export class $Record<Keys extends Schema<string | number | symbol>, Values extends Schema<any>> extends Schema<{ [key in Unwrap<Keys>]: Unwrap<Values>; }> {
     /**
      * @param {Keys} keys
      * @param {Values} values
      */
     constructor(keys: Keys, values: Values);
-    keys: Keys;
-    values: Values;
+    shape: {
+        keys: Keys;
+        values: Values;
+    };
     /**
      * @param {any} o
-     * @return {o is Record<Keys extends $Schema<infer K> ? K : never,Values extends $Schema<infer T> ? T : never>}
+     * @param {ValidationError} err
+     * @return {o is { [key in Unwrap<Keys>]: Unwrap<Values> }}
      */
-    check(o: any): o is Record<Keys extends $Schema<infer K_1> ? K_1 : never, Values extends $Schema<infer T_1> ? T_1 : never>;
+    check(o: any, err: ValidationError): o is { [key_1 in Unwrap<Keys>]: Unwrap<Values>; };
 }
-export function record<Keys extends $Schema<string | number | symbol>, Values extends $Schema<any>>(keys: Keys, values: Values): CastToSchema<$Record<Keys, Values>>;
+export function $record<Keys extends Schema<string | number | symbol>, Values extends Schema<any>>(keys: Keys, values: Values): CastToSchema<$Record<Keys, Values>>;
+export const $$record: Schema<$Record<Schema<string | number | symbol>, Schema<any>>>;
 /**
- * @template {$Schema<any>[]} S
- * @extends {$Schema<{ [Key in keyof S]: S[Key] extends $Schema<infer Type> ? Type : never }>}
+ * @template {Schema<any>[]} S
+ * @extends {Schema<{ [Key in keyof S]: S[Key] extends Schema<infer Type> ? Type : never }>}
  */
-export class $Tuple<S extends $Schema<any>[]> extends $Schema<{ [Key in keyof S]: S[Key] extends $Schema<infer Type> ? Type : never; }> {
+export class $Tuple<S extends Schema<any>[]> extends Schema<{ [Key in keyof S]: S[Key] extends Schema<infer Type> ? Type : never; }> {
     /**
-     * @param {S} v
+     * @param {S} shape
      */
-    constructor(v: S);
-    v: S;
+    constructor(shape: S);
+    shape: S;
     /**
      * @param {any} o
-     * @return {o is { [K in keyof S]: S[K] extends $Schema<infer Type> ? Type : never }}
+     * @param {ValidationError} err
+     * @return {o is { [K in keyof S]: S[K] extends Schema<infer Type> ? Type : never }}
      */
-    check(o: any): o is { [K in keyof S]: S[K] extends $Schema<infer Type_1> ? Type_1 : never; };
+    check(o: any, err: ValidationError): o is { [K in keyof S]: S[K] extends Schema<infer Type> ? Type : never; };
 }
-export function tuple<T extends Array<$Schema<any>>>(...def: T): CastToSchema<$Tuple<T>>;
+export function $tuple<T extends Array<Schema<any>>>(...def: T): CastToSchema<$Tuple<T>>;
+export const $$tuple: Schema<$Tuple<Schema<any>[]>>;
 /**
- * @template {$Schema<any>} S
- * @extends {$Schema<Array<S extends $Schema<infer T> ? T : never>>}
+ * @template {Schema<any>} S
+ * @extends {Schema<Array<S extends Schema<infer T> ? T : never>>}
  */
-export class $Array<S extends $Schema<any>> extends $Schema<(S extends $Schema<infer T> ? T : never)[]> {
+export class $Array<S extends Schema<any>> extends Schema<(S extends Schema<infer T> ? T : never)[]> {
     /**
      * @param {Array<S>} v
      */
     constructor(v: Array<S>);
     /**
-     * @type {$Schema<S extends $Schema<infer T> ? T : never>}
+     * @type {Schema<S extends Schema<infer T> ? T : never>}
      */
-    v: $Schema<S extends $Schema<infer T_1> ? T_1 : never>;
+    shape: Schema<S extends Schema<infer T_1> ? T_1 : never>;
     /**
      * @param {any} o
-     * @return {o is Array<S extends $Schema<infer T> ? T : never>} o
+     * @param {ValidationError} [err]
+     * @return {o is Array<S extends Schema<infer T> ? T : never>} o
      */
-    check(o: any): o is Array<S extends $Schema<infer T_1> ? T_1 : never>;
+    check(o: any, err?: ValidationError): o is Array<S extends Schema<infer T_1> ? T_1 : never>;
 }
-export function array<T extends Array<$Schema<any>>>(...def: T): $Schema<Array<T extends Array<$Schema<infer S>> ? S : never>>;
+export function $array<T extends Array<Schema<any>>>(...def: T): Schema<Array<T extends Array<Schema<infer S>> ? S : never>>;
+export const $$array: Schema<$Array<Schema<any>>>;
+/**
+ * @type {Schema<Array<any>>}
+ */
+export const $arrayAny: Schema<Array<any>>;
 /**
  * @template T
- * @extends {$Schema<T>}
+ * @extends {Schema<T>}
  */
-export class $InstanceOf<T> extends $Schema<T> {
+export class $InstanceOf<T> extends Schema<T> {
     /**
      * @param {new (...args:any) => T} constructor
+     * @param {((o:T) => boolean)|null} check
      */
-    constructor(constructor: new (...args: any) => T);
-    v: new (...args: any) => T;
+    constructor(constructor: new (...args: any) => T, check: ((o: T) => boolean) | null);
+    shape: new (...args: any) => T;
+    _c: ((o: T) => boolean) | null;
+    /**
+     * @param {any} o
+     * @param {ValidationError} err
+     * @return {o is T}
+     */
+    check(o: any, err: ValidationError): o is T;
 }
-export function instance<T>(c: new (...args: any) => T): $Schema<T>;
+export function $instanceOf<T>(c: new (...args: any) => T, check?: ((o: T) => boolean) | null): Schema<T>;
+export const $$instanceOf: Schema<$InstanceOf<unknown>>;
+export const $$schema: Schema<Schema<unknown>>;
 /**
- * @template {$Schema<any>[]} Args
+ * @template {Schema<any>[]} Args
  * @typedef {(...args:UnwrapArray<TuplePop<Args>>)=>Unwrap<TupleLast<Args>>} _LArgsToLambdaDef
  */
 /**
- * @template {Array<$Schema<any>>} Args
- * @extends {$Schema<_LArgsToLambdaDef<Args>>}
+ * @template {Array<Schema<any>>} Args
+ * @extends {Schema<_LArgsToLambdaDef<Args>>}
  */
-export class $Lambda<Args extends Array<$Schema<any>>> extends $Schema<_LArgsToLambdaDef<Args>> {
+export class $Lambda<Args extends Array<Schema<any>>> extends Schema<_LArgsToLambdaDef<Args>> {
     /**
      * @param {Args} args
      */
     constructor(args: Args);
     len: number;
-    args: $Schema<any[]>;
-    res: $Schema<any>;
+    args: Schema<any[]>;
+    res: Schema<any>;
+    /**
+     * @param {any} f
+     * @param {ValidationError} err
+     * @return {f is _LArgsToLambdaDef<Args>}
+     */
+    check(f: any, err: ValidationError): f is _LArgsToLambdaDef<Args>;
 }
-export function lambda<Args extends $Schema<any>[]>(...args: Args): $Schema<(...args: UnwrapArray<TuplePop<Args>>) => Unwrap<TupleLast<Args>>>;
+export function $lambda<Args extends Schema<any>[]>(...args: Args): Schema<(...args: UnwrapArray<TuplePop<Args>>) => Unwrap<TupleLast<Args>>>;
+export const $$lambda: Schema<$Lambda<Schema<any>[]>>;
 /**
- * @template {Array<$Schema<any>>} T
- * @extends {$Schema<Intersect<UnwrapArray<T>>>}
+ * @template {Array<Schema<any>>} T
+ * @extends {Schema<Intersect<UnwrapArray<T>>>}
  */
-export class $Intersection<T extends Array<$Schema<any>>> extends $Schema<Intersect<UnwrapArray<T>>> {
+export class $Intersection<T extends Array<Schema<any>>> extends Schema<Intersect<UnwrapArray<T>>> {
     /**
      * @param {T} v
      */
@@ -202,73 +338,143 @@ export class $Intersection<T extends Array<$Schema<any>>> extends $Schema<Inters
     /**
      * @type {T}
      */
-    v: T;
+    shape: T;
 }
-export function intersect<T extends $Schema<any>[]>(...def: T): CastToSchema<$Intersection<T>>;
+export function $intersect<T extends Schema<any>[]>(...def: T): CastToSchema<$Intersection<T>>;
+export const $$intersect: Schema<$Intersection<Schema<any>[]>>;
 /**
  * @template S
- * @extends {$Schema<S>}
+ * @extends {Schema<S>}
  */
-export class $Union<S> extends $Schema<S> {
-    static schema: $Schema<$Union<unknown>>;
+export class $Union<S> extends Schema<S> {
     /**
-     * @param {Array<$Schema<S>>} v
+     * @param {Array<Schema<S>>} v
      */
-    constructor(v: Array<$Schema<S>>);
-    v: $Schema<S>[];
+    constructor(v: Array<Schema<S>>);
+    shape: Schema<S>[];
 }
-export function union<T extends Array<$Schema<any>>>(...def: T): CastToSchema<$Union<T extends [] ? never : (T extends Array<$Schema<infer S>> ? S : never)>>;
+export function $union<T extends Array<Schema<any>>>(...schemas: T): CastToSchema<$Union<T extends [] ? never : (T extends Array<Schema<infer S>> ? S : never)>>;
+export const $$union: Schema<$Union<any>>;
+/**
+ * @type {Schema<any>}
+ */
+export const $any: Schema<any>;
+export const $$any: Schema<Schema<any>>;
+/**
+ * @type {Schema<bigint>}
+ */
+export const $bigint: Schema<bigint>;
+export const $$bigint: Schema<Schema<bigint>>;
+/**
+ * @type {Schema<Symbol>}
+ */
+export const $symbol: Schema<Symbol>;
+export const $$symbol: Schema<Schema<Symbol>>;
+/**
+ * @type {Schema<number>}
+ */
+export const $number: Schema<number>;
+export const $$number: Schema<Schema<number>>;
+/**
+ * @type {Schema<string>}
+ */
+export const $string: Schema<string>;
+export const $$string: Schema<Schema<string>>;
+/**
+ * @type {Schema<boolean>}
+ */
+export const $boolean: Schema<boolean>;
+export const $$boolean: Schema<Schema<boolean>>;
+/**
+ * @type {Schema<undefined>}
+ */
+export const $undefined: Schema<undefined>;
+export const $$undefined: Schema<Schema<undefined>>;
 /**
- * @type {$Schema<any>}
+ * @type {Schema<void>}
  */
-export const any: $Schema<any>;
+export const $void: Schema<void>;
+export const $$void: Schema<Schema<void>>;
+export const $null: Schema<null>;
+export const $$null: Schema<Schema<null>>;
 /**
- * @type {$Schema<bigint>}
+ * @type {Schema<number|string|null|boolean>}
  */
-export const bigint: $Schema<bigint>;
+export const $primitive: Schema<number | string | null | boolean>;
 /**
- * @type {$Schema<Symbol>}
+ * @typedef {JSON[]} JSONArray
  */
-export const symbol: $Schema<Symbol>;
 /**
- * @type {$Schema<number>}
+ * @typedef {Unwrap<$primitive>|JSONArray|{ [key:string]:JSON }} JSON
  */
-export const number: $Schema<number>;
 /**
- * @type {$Schema<string>}
+ * @type {Schema<null|number|string|boolean|JSON[]|{[key:string]:JSON}>}
  */
-export const string: $Schema<string>;
+export const $json: Schema<null | number | string | boolean | JSON[] | {
+    [key: string]: JSON;
+}>;
 /**
  * Assert that a variable is of this specific type.
  * The assertion check is only performed in non-production environments.
  *
- * @type {<T>(o:any,schema:$Schema<T>) => asserts o is T}
+ * @type {<T>(o:any,schema:Schema<T>) => asserts o is T}
  */
-export const assert: <T>(o: any, schema: $Schema<T>) => asserts o is T;
+export const assert: <T>(o: any, schema: Schema<T>) => asserts o is T;
 export type LiteralType = string | number | bigint | boolean | null | undefined;
 export type AnyObject = {
     [k: string | number | symbol]: any;
 };
-export type Unwrap<T> = T extends $Schema<infer X> ? X : T;
-export type UnwrapArray<T extends readonly unknown[]> = T extends readonly [$Schema<infer First>, ...infer Rest] ? [First, ...UnwrapArray<Rest>] : [];
-export type CastToSchema<T> = T extends $Schema<infer S> ? $Schema<S> : never;
+export type Unwrap<T> = T extends Schema<infer X> ? X : T;
+export type TypeOf<T> = T extends Schema<infer X> ? X : T;
+export type UnwrapArray<T extends readonly unknown[]> = T extends readonly [Schema<infer First>, ...infer Rest] ? [First, ...UnwrapArray<Rest>] : [];
+export type CastToSchema<T> = T extends Schema<infer S> ? Schema<S> : never;
 export type TupleLast<Arr extends unknown[]> = Arr extends [...unknown[], infer L] ? L : never;
 export type TuplePop<Arr extends unknown[]> = Arr extends [...infer Fs, unknown] ? Fs : never;
 export type Intersect<T extends readonly unknown[]> = T extends [] ? {} : T extends [infer First] ? First : T extends [infer First, ...infer Rest] ? First & Intersect<Rest> : never;
+export type Instance<Constr extends (new (...args: any[]) => any) | ((...args: any[]) => any)> = Constr extends ((...args: any[]) => infer T) ? T : (Constr extends (new (...args: any[]) => any) ? InstanceType<Constr> : never);
+export type CastStringTemplateArgsToTemplate<Ts extends Array<string | Schema<string | number>>> = Ts extends [] ? `` : (Ts extends [infer T] ? (Unwrap<T> extends (string | number) ? Unwrap<T> : never) : (Ts extends [infer T1, ...infer Rest] ? `${Unwrap<T1> extends (string | number) ? Unwrap<T1> : never}${Rest extends Array<string | Schema<string | number>> ? CastStringTemplateArgsToTemplate<Rest> : never}` : never));
 export type $ObjectToType<S extends {
-    [key: string | symbol | number]: $Schema<any>;
-}> = { [Key in keyof S as S[Key] extends $Optional<$Schema<any>> ? Key : never]?: S[Key] extends $Optional<$Schema<infer Type>> ? Type : never; } & { [Key in keyof S as S[Key] extends $Optional<$Schema<any>> ? never : Key]: S[Key] extends $Schema<infer Type> ? Type : never; };
-export type _LArgsToLambdaDef<Args extends $Schema<any>[]> = (...args: UnwrapArray<TuplePop<Args>>) => Unwrap<TupleLast<Args>>;
+    [key: string | symbol | number]: Schema<any>;
+}> = { [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? Key : never]?: S[Key] extends $Optional<Schema<infer Type>> ? Type : never; } & { [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? never : Key]: S[Key] extends Schema<infer Type> ? Type : never; };
+export type _ObjectDefToSchema<S extends {
+    [key: string | symbol | number]: Schema<any>;
+}> = Schema<{ [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? Key : never]?: S[Key] extends $Optional<Schema<infer Type>> ? Type : never; } & { [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? never : Key]: S[Key] extends Schema<infer Type> ? Type : never; }>;
+export type _LArgsToLambdaDef<Args extends Schema<any>[]> = (...args: UnwrapArray<TuplePop<Args>>) => Unwrap<TupleLast<Args>>;
+export type JSONArray = JSON[];
+export type JSON = Unwrap<Schema<string | number | boolean | null>> | JSONArray | {
+    [key: string]: JSON;
+};
+import * as traits from './traits.js';
+declare class ValidationError {
+    /**
+     * Reverse errors
+     * @type {Array<{ path: string?, expected: string, has: string, message: string? }>}
+     */
+    _rerrs: Array<{
+        path: string | null;
+        expected: string;
+        has: string;
+        message: string | null;
+    }>;
+    /**
+     * @param {string?} path
+     * @param {string} expected
+     * @param {string} has
+     * @param {string?} message
+     */
+    extend(path: string | null, expected: string, has: string, message?: string | null): void;
+    toString(): string;
+}
 /**
- * @template {$Schema<any>} S
- * @extends $Schema<Unwrap<S>|undefined>
+ * @template {Schema<any>} S
+ * @extends Schema<Unwrap<S>|undefined>
  */
-declare class $Optional<S extends $Schema<any>> extends $Schema<Unwrap<S> | undefined> {
+declare class $Optional<S extends Schema<any>> extends Schema<Unwrap<S> | undefined> {
     /**
-     * @param {S} s
+     * @param {S} shape
      */
-    constructor(s: S);
-    s: S;
+    constructor(shape: S);
+    shape: S;
     get [isOptionalSymbol](): boolean;
 }
 /**
@@ -279,15 +485,19 @@ declare class $Optional<S extends $Schema<any>> extends $Schema<Unwrap<S> | unde
  */
 /**
  * @template T
- * @typedef {T extends $Schema<infer X> ? X : T} Unwrap
+ * @typedef {T extends Schema<infer X> ? X : T} Unwrap
+ */
+/**
+ * @template T
+ * @typedef {T extends Schema<infer X> ? X : T} TypeOf
  */
 /**
  * @template {readonly unknown[]} T
- * @typedef {T extends readonly [$Schema<infer First>, ...infer Rest] ? [First, ...UnwrapArray<Rest>] : [] } UnwrapArray
+ * @typedef {T extends readonly [Schema<infer First>, ...infer Rest] ? [First, ...UnwrapArray<Rest>] : [] } UnwrapArray
  */
 /**
  * @template T
- * @typedef {T extends $Schema<infer S> ? $Schema<S> : never} CastToSchema
+ * @typedef {T extends Schema<infer S> ? Schema<S> : never} CastToSchema
  */
 /**
  * @template {unknown[]} Arr
@@ -310,17 +520,11 @@ declare class $Optional<S extends $Schema<any>> extends $Schema<Unwrap<S> | unde
  */
 declare const schemaSymbol: unique symbol;
 /**
- * @type {$Schema<null>}
+ * @extends Schema<never>
  */
-declare const null_: $Schema<null>;
-/**
- * @type {$Schema<void>}
- */
-declare const void_: $Schema<void>;
-/**
- * @type {$Schema<undefined>}
- */
-declare const undefined_: $Schema<undefined>;
+declare class $Never extends Schema<never> {
+    constructor();
+}
 declare const isOptionalSymbol: unique symbol;
-export { null_ as null, _null as null, void_ as void, _void as void, undefined_ as undefined };
+export {};
 //# sourceMappingURL=schema.d.ts.map