@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 } from './types';
import type { TypeSystem } from '../system/TypeSystem';
import type { TypeAlias } from '../system/TypeAlias';
import type { TypeOfAlias } from '../system/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.ObjectFieldType<K extends string ? K : never, O[K]>;
}>;
export declare class TypeBuilder {
    system?: TypeSystem | undefined;
    constructor(system?: TypeSystem | 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 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.ConstSchema>) => 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.ConstSchema>) => 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.ArraySchema>) => classes.ArrType<T extends Type ? T : classes.AnyType>;
    readonly tuple: <F extends Type[]>(...types: F) => classes.TupType<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<V>(value: schema.Narrow<V>, options?: schema.Optional<schema.ConstSchema>): classes.ConType<string extends V ? never : number extends V ? never : boolean extends V ? never : any[] extends V ? never : V>;
    Boolean(options?: schema.Optional<schema.BooleanSchema>): classes.BoolType;
    Number(options?: schema.Optional<schema.NumberSchema>): classes.NumType;
    String(options?: schema.Optional<schema.StringSchema>): classes.StrType;
    Binary<T extends Type>(type: T, options?: schema.Optional<schema.BinarySchema>): classes.BinType<T>;
    Array<T extends Type>(type: T, options?: schema.Optional<schema.ArraySchema>): classes.ArrType<T>;
    Tuple<F extends Type[]>(...types: F): classes.TupType<F>;
    Object<F extends classes.ObjectFieldType<any, any>[]>(...fields: F): classes.ObjType<F>;
    prop<K extends string, V extends Type>(key: K, value: V): classes.ObjectFieldType<K, V>;
    propOpt<K extends string, V extends Type>(key: K, value: V): classes.ObjectOptionalFieldType<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 | TypeAlias<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.FunctionSchema>): classes.FnType<Req, Res, Ctx>;
    Function$<Req extends Type, Res extends Type, Ctx = unknown>(req: Req, res: Res, options?: schema.Optional<schema.FunctionStreamingSchema>): classes.FnRxType<Req, Res, Ctx>;
    import(node: schema.Schema): Type;
    from(value: unknown): Type;
}
export {};