@jsonjoy.com/json-type/lib/type/TypeBuilder.d.ts

High-performance JSON Pointer implementation

import * as schema from '../schema';
import * as classes from './classes';
import type { Type, TypeOfAlias } from './types';
type UnionToIntersection<U> = (U extends never ? never : (arg: U) => never) extends (arg: infer I) => void ? I : never;
type UnionToTuple<T> = UnionToIntersection<T extends never ? never : (t: T) => T> extends (_: never) => infer W ? [...UnionToTuple<Exclude<T, W>>, W] : [];
type ObjValueTuple<T, KS extends any[] = UnionToTuple<keyof T>, R extends any[] = []> = KS extends [
    infer K,
    ...infer KT
] ? ObjValueTuple<T, KT, [...R, T[K & keyof T]]> : R;
type RecordToFields<O extends Record<string, Type>> = ObjValueTuple<{
    [K in keyof O]: classes.KeyType<K extends string ? K : never, O[K]>;
}>;
export declare class TypeBuilder {
    system?: classes.ModuleType | undefined;
    constructor(system?: classes.ModuleType | undefined);
    get any(): classes.AnyType;
    get undef(): classes.ConType<undefined>;
    get nil(): classes.ConType<null>;
    get bool(): classes.BoolType;
    get num(): classes.NumType;
    get str(): classes.StrType;
    get bin(): classes.BinType<classes.AnyType>;
    get arr(): classes.ArrType<classes.AnyType, [], []>;
    get obj(): classes.ObjType<[]>;
    get map(): classes.MapType<classes.AnyType>;
    get fn(): classes.FnType<classes.ConType<undefined>, classes.ConType<undefined>, unknown>;
    get fn$(): classes.FnRxType<classes.ConType<undefined>, classes.ConType<undefined>, unknown>;
    readonly or: <F extends Type[]>(...types: F) => classes.OrType<F>;
    readonly undefined: () => classes.ConType<undefined>;
    readonly null: () => classes.ConType<null>;
    readonly boolean: () => classes.BoolType;
    readonly number: () => classes.NumType;
    readonly string: () => classes.StrType;
    readonly binary: () => classes.BinType<classes.AnyType>;
    readonly con: <V>(value: schema.Narrow<V>, options?: schema.Optional<schema.ConSchema>) => classes.ConType<string extends V ? never : number extends V ? never : boolean extends V ? never : any[] extends V ? never : V>;
    readonly literal: <V>(value: schema.Narrow<V>, options?: schema.Optional<schema.ConSchema>) => classes.ConType<string extends V ? never : number extends V ? never : boolean extends V ? never : any[] extends V ? never : V>;
    readonly array: <T>(type?: T, options?: schema.Optional<schema.ArrSchema>) => classes.ArrType<T extends Type ? T : classes.AnyType, [], []>;
    readonly tuple: <F extends Type[]>(...types: F) => classes.ArrType<undefined, F, []>;
    /**
     * Creates an object type with the specified properties. This is a shorthand for
     * `t.Object(t.prop(key, value), ...)`.
     *
     * Importantly, this method does not allow to specify object field order,
     * so the order of properties in the resulting type is not guaranteed.
     *
     * Example:
     *
     * ```ts
     * t.object({
     *   id: t.str,
     *   name: t.string(),
     *   age: t.num,
     *   verified: t.bool,
     * });
     * ```
     *
     * @param record A mapping of property names to types.
     * @returns An object type.
     */
    readonly object: <R extends Record<string, Type>>(record: R) => classes.ObjType<RecordToFields<R>>;
    /**
     * Creates a type that represents a value that may be present or absent. The
     * value is `undefined` if absent. This is a shorthand for `t.Or(type, t.undef)`.
     */
    readonly maybe: <T extends Type>(type: T) => classes.OrType<[T, classes.ConType<undefined>]>;
    /**
     * Creates a union type from a list of values. This is a shorthand for
     * `t.Or(t.Const(value1), t.Const(value2), ...)`. For example, the below
     * are equivalent:
     *
     * ```ts
     * t.enum('red', 'green', 'blue');
     * t.Or(t.Const('red'), t.Const('green'), t.Const('blue'));
     * ```
     *
     * @param values The values to include in the union.
     * @returns A union type representing the values.
     */
    readonly enum: <const T extends (string | number | boolean | null)[]>(...values: T) => classes.OrType<{ [K in keyof T]: classes.ConType<schema.Narrow<T[K]>>; }>;
    Any(options?: schema.Optional<schema.AnySchema>): classes.AnyType;
    Const<const V>(value: schema.Narrow<V>, options?: schema.Optional<schema.ConSchema>): classes.ConType<string extends V ? never : number extends V ? never : boolean extends V ? never : any[] extends V ? never : V>;
    Boolean(options?: schema.Optional<schema.BoolSchema>): classes.BoolType;
    Number(options?: schema.Optional<schema.NumSchema>): classes.NumType;
    String(options?: schema.Optional<schema.StrSchema>): classes.StrType;
    Binary<T extends Type>(type: T, options?: schema.Optional<schema.BinSchema>): classes.BinType<T>;
    Array<T extends Type>(type: T, options?: schema.Optional<schema.ArrSchema>): classes.ArrType<T, [], []>;
    Tuple<const Head extends Type[], Item extends Type | void = undefined, const Tail extends Type[] = []>(head: Head, item?: Item, tail?: Tail, options?: schema.Optional<schema.ArrSchema>): classes.ArrType<Item, Head, Tail>;
    Object<F extends (classes.KeyType<any, any> | classes.KeyOptType<any, any>)[]>(...keys: F): classes.ObjType<F>;
    Key<K extends string, V extends Type>(key: K, value: V): classes.KeyType<K, V>;
    KeyOpt<K extends string, V extends Type>(key: K, value: V): classes.KeyOptType<K, V>;
    Map<T extends Type>(val: T, key?: Type, options?: schema.Optional<schema.MapSchema>): classes.MapType<T>;
    Or<F extends Type[]>(...types: F): classes.OrType<F>;
    Ref<T extends Type | classes.AliasType<any, any>>(ref: string): classes.RefType<TypeOfAlias<T>>;
    Function<Req extends Type, Res extends Type, Ctx = unknown>(req: Req, res: Res, options?: schema.Optional<schema.FnSchema>): classes.FnType<Req, Res, Ctx>;
    Function$<Req extends Type, Res extends Type, Ctx = unknown>(req: Req, res: Res, options?: schema.Optional<schema.FnRxSchema>): classes.FnRxType<Req, Res, Ctx>;
    import(node: schema.Schema): Type;
    from(value: unknown): Type;
}
export {};