@willaimg/yatsp 4.3.6

package/v3/types.d.ts

@@ -0,0 +1,1034 @@
+import { type IssueData, type StringValidation, type YatspCustomIssue, YatspError, type YatspErrorMap } from "./YatspError.js";
+import type { enumUtil } from "./helpers/enumUtil.js";
+import { errorUtil } from "./helpers/errorUtil.js";
+import { type AsyncParseReturnType, INVALID, type ParseContext, type ParseInput, type ParseParams, type ParseReturnType, ParseStatus, type SyncParseReturnType } from "./helpers/parseUtil.js";
+import type { partialUtil } from "./helpers/partialUtil.js";
+import type { Primitive } from "./helpers/typeAliases.js";
+import { util, type objectUtil } from "./helpers/util.js";
+import type { StandardSchemaV1 } from "./standard-schema.js";
+export interface RefinementCtx {
+    addIssue: (arg: IssueData) => void;
+    path: (string | number)[];
+}
+export type YatspRawShape = {
+    [k: string]: YatspTypeAny;
+};
+export type YatspTypeAny = YatspType<any, any, any>;
+export type TypeOf<T extends YatspType<any, any, any>> = T["_output"];
+export type input<T extends YatspType<any, any, any>> = T["_input"];
+export type output<T extends YatspType<any, any, any>> = T["_output"];
+export type { TypeOf as infer };
+export type CustomErrorParams = Partial<util.Omit<YatspCustomIssue, "code">>;
+export interface YatspTypeDef {
+    errorMap?: YatspErrorMap | undefined;
+    description?: string | undefined;
+}
+export type RawCreateParams = {
+    errorMap?: YatspErrorMap | undefined;
+    invalid_type_error?: string | undefined;
+    required_error?: string | undefined;
+    message?: string | undefined;
+    description?: string | undefined;
+} | undefined;
+export type ProcessedCreateParams = {
+    errorMap?: YatspErrorMap | undefined;
+    description?: string | undefined;
+};
+export type SafeParseSuccess<Output> = {
+    success: true;
+    data: Output;
+    error?: never;
+};
+export type SafeParseError<Input> = {
+    success: false;
+    error: YatspError<Input>;
+    data?: never;
+};
+export type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
+export declare abstract class YatspType<Output = any, Def extends YatspTypeDef = YatspTypeDef, Input = Output> {
+    readonly _type: Output;
+    readonly _output: Output;
+    readonly _input: Input;
+    readonly _def: Def;
+    get description(): string | undefined;
+    "~standard": StandardSchemaV1.Props<Input, Output>;
+    abstract _parse(input: ParseInput): ParseReturnType<Output>;
+    _getType(input: ParseInput): string;
+    _getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;
+    _processInputParams(input: ParseInput): {
+        status: ParseStatus;
+        ctx: ParseContext;
+    };
+    _parseSync(input: ParseInput): SyncParseReturnType<Output>;
+    _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
+    parse(data: unknown, params?: util.InexactPartial<ParseParams>): Output;
+    safeParse(data: unknown, params?: util.InexactPartial<ParseParams>): SafeParseReturnType<Input, Output>;
+    "~validate"(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;
+    parseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<Output>;
+    safeParseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
+    /** Alias of safeParseAsync */
+    spa: (data: unknown, params?: util.InexactPartial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
+    refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): YatspEffects<this, RefinedOutput, Input>;
+    refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): YatspEffects<this, Output, Input>;
+    refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): YatspEffects<this, RefinedOutput, Input>;
+    refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): YatspEffects<this, Output, Input>;
+    _refinement(refinement: RefinementEffect<Output>["refinement"]): YatspEffects<this, Output, Input>;
+    superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): YatspEffects<this, RefinedOutput, Input>;
+    superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): YatspEffects<this, Output, Input>;
+    superRefine(refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): YatspEffects<this, Output, Input>;
+    constructor(def: Def);
+    optional(): YatspOptional<this>;
+    nullable(): YatspNullable<this>;
+    nullish(): YatspOptional<YatspNullable<this>>;
+    array(): YatspArray<this>;
+    promise(): YatspPromise<this>;
+    or<T extends YatspTypeAny>(option: T): YatspUnion<[this, T]>;
+    and<T extends YatspTypeAny>(incoming: T): YatspIntersection<this, T>;
+    transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): YatspEffects<this, NewOut>;
+    default(def: util.noUndefined<Input>): YatspDefault<this>;
+    default(def: () => util.noUndefined<Input>): YatspDefault<this>;
+    brand<B extends string | number | symbol>(brand?: B): YatspBranded<this, B>;
+    catch(def: Output): YatspCatch<this>;
+    catch(def: (ctx: {
+        error: YatspError;
+        input: Input;
+    }) => Output): YatspCatch<this>;
+    describe(description: string): this;
+    pipe<T extends YatspTypeAny>(target: T): YatspPipeline<this, T>;
+    readonly(): YatspReadonly<this>;
+    isOptional(): boolean;
+    isNullable(): boolean;
+}
+export type IpVersion = "v4" | "v6";
+export type YatspStringCheck = {
+    kind: "min";
+    value: number;
+    message?: string | undefined;
+} | {
+    kind: "max";
+    value: number;
+    message?: string | undefined;
+} | {
+    kind: "length";
+    value: number;
+    message?: string | undefined;
+} | {
+    kind: "email";
+    message?: string | undefined;
+} | {
+    kind: "url";
+    message?: string | undefined;
+} | {
+    kind: "emoji";
+    message?: string | undefined;
+} | {
+    kind: "uuid";
+    message?: string | undefined;
+} | {
+    kind: "nanoid";
+    message?: string | undefined;
+} | {
+    kind: "cuid";
+    message?: string | undefined;
+} | {
+    kind: "includes";
+    value: string;
+    position?: number | undefined;
+    message?: string | undefined;
+} | {
+    kind: "cuid2";
+    message?: string | undefined;
+} | {
+    kind: "ulid";
+    message?: string | undefined;
+} | {
+    kind: "startsWith";
+    value: string;
+    message?: string | undefined;
+} | {
+    kind: "endsWith";
+    value: string;
+    message?: string | undefined;
+} | {
+    kind: "regex";
+    regex: RegExp;
+    message?: string | undefined;
+} | {
+    kind: "trim";
+    message?: string | undefined;
+} | {
+    kind: "toLowerCase";
+    message?: string | undefined;
+} | {
+    kind: "toUpperCase";
+    message?: string | undefined;
+} | {
+    kind: "jwt";
+    alg?: string;
+    message?: string | undefined;
+} | {
+    kind: "datetime";
+    offset: boolean;
+    local: boolean;
+    precision: number | null;
+    message?: string | undefined;
+} | {
+    kind: "date";
+    message?: string | undefined;
+} | {
+    kind: "time";
+    precision: number | null;
+    message?: string | undefined;
+} | {
+    kind: "duration";
+    message?: string | undefined;
+} | {
+    kind: "ip";
+    version?: IpVersion | undefined;
+    message?: string | undefined;
+} | {
+    kind: "cidr";
+    version?: IpVersion | undefined;
+    message?: string | undefined;
+} | {
+    kind: "base64";
+    message?: string | undefined;
+} | {
+    kind: "base64url";
+    message?: string | undefined;
+};
+export interface YatspStringDef extends YatspTypeDef {
+    checks: YatspStringCheck[];
+    typeName: YatspFirstPartyTypeKind.YatspString;
+    coerce: boolean;
+}
+export declare function datetimeRegex(args: {
+    precision?: number | null;
+    offset?: boolean;
+    local?: boolean;
+}): RegExp;
+export declare class YatspString extends YatspType<string, YatspStringDef, string> {
+    _parse(input: ParseInput): ParseReturnType<string>;
+    protected _regex(regex: RegExp, validation: StringValidation, message?: errorUtil.ErrMessage): YatspEffects<this, string, string>;
+    _addCheck(check: YatspStringCheck): YatspString;
+    email(message?: errorUtil.ErrMessage): YatspString;
+    url(message?: errorUtil.ErrMessage): YatspString;
+    emoji(message?: errorUtil.ErrMessage): YatspString;
+    uuid(message?: errorUtil.ErrMessage): YatspString;
+    nanoid(message?: errorUtil.ErrMessage): YatspString;
+    cuid(message?: errorUtil.ErrMessage): YatspString;
+    cuid2(message?: errorUtil.ErrMessage): YatspString;
+    ulid(message?: errorUtil.ErrMessage): YatspString;
+    base64(message?: errorUtil.ErrMessage): YatspString;
+    base64url(message?: errorUtil.ErrMessage): YatspString;
+    jwt(options?: {
+        alg?: string;
+        message?: string | undefined;
+    }): YatspString;
+    ip(options?: string | {
+        version?: IpVersion;
+        message?: string | undefined;
+    }): YatspString;
+    cidr(options?: string | {
+        version?: IpVersion;
+        message?: string | undefined;
+    }): YatspString;
+    datetime(options?: string | {
+        message?: string | undefined;
+        precision?: number | null;
+        offset?: boolean;
+        local?: boolean;
+    }): YatspString;
+    date(message?: string): YatspString;
+    time(options?: string | {
+        message?: string | undefined;
+        precision?: number | null;
+    }): YatspString;
+    duration(message?: errorUtil.ErrMessage): YatspString;
+    regex(regex: RegExp, message?: errorUtil.ErrMessage): YatspString;
+    includes(value: string, options?: {
+        message?: string;
+        position?: number;
+    }): YatspString;
+    startsWith(value: string, message?: errorUtil.ErrMessage): YatspString;
+    endsWith(value: string, message?: errorUtil.ErrMessage): YatspString;
+    min(minLength: number, message?: errorUtil.ErrMessage): YatspString;
+    max(maxLength: number, message?: errorUtil.ErrMessage): YatspString;
+    length(len: number, message?: errorUtil.ErrMessage): YatspString;
+    /**
+     * Equivalent to `.min(1)`
+     */
+    nonempty(message?: errorUtil.ErrMessage): YatspString;
+    trim(): YatspString;
+    toLowerCase(): YatspString;
+    toUpperCase(): YatspString;
+    get isDatetime(): boolean;
+    get isDate(): boolean;
+    get isTime(): boolean;
+    get isDuration(): boolean;
+    get isEmail(): boolean;
+    get isURL(): boolean;
+    get isEmoji(): boolean;
+    get isUUID(): boolean;
+    get isNANOID(): boolean;
+    get isCUID(): boolean;
+    get isCUID2(): boolean;
+    get isULID(): boolean;
+    get isIP(): boolean;
+    get isCIDR(): boolean;
+    get isBase64(): boolean;
+    get isBase64url(): boolean;
+    get minLength(): number | null;
+    get maxLength(): number | null;
+    static create: (params?: RawCreateParams & {
+        coerce?: true;
+    }) => YatspString;
+}
+export type YatspNumberCheck = {
+    kind: "min";
+    value: number;
+    inclusive: boolean;
+    message?: string | undefined;
+} | {
+    kind: "max";
+    value: number;
+    inclusive: boolean;
+    message?: string | undefined;
+} | {
+    kind: "int";
+    message?: string | undefined;
+} | {
+    kind: "multipleOf";
+    value: number;
+    message?: string | undefined;
+} | {
+    kind: "finite";
+    message?: string | undefined;
+};
+export interface YatspNumberDef extends YatspTypeDef {
+    checks: YatspNumberCheck[];
+    typeName: YatspFirstPartyTypeKind.YatspNumber;
+    coerce: boolean;
+}
+export declare class YatspNumber extends YatspType<number, YatspNumberDef, number> {
+    _parse(input: ParseInput): ParseReturnType<number>;
+    static create: (params?: RawCreateParams & {
+        coerce?: boolean;
+    }) => YatspNumber;
+    gte(value: number, message?: errorUtil.ErrMessage): YatspNumber;
+    min: (value: number, message?: errorUtil.ErrMessage) => YatspNumber;
+    gt(value: number, message?: errorUtil.ErrMessage): YatspNumber;
+    lte(value: number, message?: errorUtil.ErrMessage): YatspNumber;
+    max: (value: number, message?: errorUtil.ErrMessage) => YatspNumber;
+    lt(value: number, message?: errorUtil.ErrMessage): YatspNumber;
+    protected setLimit(kind: "min" | "max", value: number, inclusive: boolean, message?: string): YatspNumber;
+    _addCheck(check: YatspNumberCheck): YatspNumber;
+    int(message?: errorUtil.ErrMessage): YatspNumber;
+    positive(message?: errorUtil.ErrMessage): YatspNumber;
+    negative(message?: errorUtil.ErrMessage): YatspNumber;
+    nonpositive(message?: errorUtil.ErrMessage): YatspNumber;
+    nonnegative(message?: errorUtil.ErrMessage): YatspNumber;
+    multipleOf(value: number, message?: errorUtil.ErrMessage): YatspNumber;
+    step: (value: number, message?: errorUtil.ErrMessage) => YatspNumber;
+    finite(message?: errorUtil.ErrMessage): YatspNumber;
+    safe(message?: errorUtil.ErrMessage): YatspNumber;
+    get minValue(): number | null;
+    get maxValue(): number | null;
+    get isInt(): boolean;
+    get isFinite(): boolean;
+}
+export type YatspBigIntCheck = {
+    kind: "min";
+    value: bigint;
+    inclusive: boolean;
+    message?: string | undefined;
+} | {
+    kind: "max";
+    value: bigint;
+    inclusive: boolean;
+    message?: string | undefined;
+} | {
+    kind: "multipleOf";
+    value: bigint;
+    message?: string | undefined;
+};
+export interface YatspBigIntDef extends YatspTypeDef {
+    checks: YatspBigIntCheck[];
+    typeName: YatspFirstPartyTypeKind.YatspBigInt;
+    coerce: boolean;
+}
+export declare class YatspBigInt extends YatspType<bigint, YatspBigIntDef, bigint> {
+    _parse(input: ParseInput): ParseReturnType<bigint>;
+    _getInvalidInput(input: ParseInput): INVALID;
+    static create: (params?: RawCreateParams & {
+        coerce?: boolean;
+    }) => YatspBigInt;
+    gte(value: bigint, message?: errorUtil.ErrMessage): YatspBigInt;
+    min: (value: bigint, message?: errorUtil.ErrMessage) => YatspBigInt;
+    gt(value: bigint, message?: errorUtil.ErrMessage): YatspBigInt;
+    lte(value: bigint, message?: errorUtil.ErrMessage): YatspBigInt;
+    max: (value: bigint, message?: errorUtil.ErrMessage) => YatspBigInt;
+    lt(value: bigint, message?: errorUtil.ErrMessage): YatspBigInt;
+    protected setLimit(kind: "min" | "max", value: bigint, inclusive: boolean, message?: string): YatspBigInt;
+    _addCheck(check: YatspBigIntCheck): YatspBigInt;
+    positive(message?: errorUtil.ErrMessage): YatspBigInt;
+    negative(message?: errorUtil.ErrMessage): YatspBigInt;
+    nonpositive(message?: errorUtil.ErrMessage): YatspBigInt;
+    nonnegative(message?: errorUtil.ErrMessage): YatspBigInt;
+    multipleOf(value: bigint, message?: errorUtil.ErrMessage): YatspBigInt;
+    get minValue(): bigint | null;
+    get maxValue(): bigint | null;
+}
+export interface YatspBooleanDef extends YatspTypeDef {
+    typeName: YatspFirstPartyTypeKind.YatspBoolean;
+    coerce: boolean;
+}
+export declare class YatspBoolean extends YatspType<boolean, YatspBooleanDef, boolean> {
+    _parse(input: ParseInput): ParseReturnType<boolean>;
+    static create: (params?: RawCreateParams & {
+        coerce?: boolean;
+    }) => YatspBoolean;
+}
+export type YatspDateCheck = {
+    kind: "min";
+    value: number;
+    message?: string | undefined;
+} | {
+    kind: "max";
+    value: number;
+    message?: string | undefined;
+};
+export interface YatspDateDef extends YatspTypeDef {
+    checks: YatspDateCheck[];
+    coerce: boolean;
+    typeName: YatspFirstPartyTypeKind.YatspDate;
+}
+export declare class YatspDate extends YatspType<Date, YatspDateDef, Date> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    _addCheck(check: YatspDateCheck): YatspDate;
+    min(minDate: Date, message?: errorUtil.ErrMessage): YatspDate;
+    max(maxDate: Date, message?: errorUtil.ErrMessage): YatspDate;
+    get minDate(): Date | null;
+    get maxDate(): Date | null;
+    static create: (params?: RawCreateParams & {
+        coerce?: boolean;
+    }) => YatspDate;
+}
+export interface YatspSymbolDef extends YatspTypeDef {
+    typeName: YatspFirstPartyTypeKind.YatspSymbol;
+}
+export declare class YatspSymbol extends YatspType<symbol, YatspSymbolDef, symbol> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: (params?: RawCreateParams) => YatspSymbol;
+}
+export interface YatspUndefinedDef extends YatspTypeDef {
+    typeName: YatspFirstPartyTypeKind.YatspUndefined;
+}
+export declare class YatspUndefined extends YatspType<undefined, YatspUndefinedDef, undefined> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    params?: RawCreateParams;
+    static create: (params?: RawCreateParams) => YatspUndefined;
+}
+export interface YatspNullDef extends YatspTypeDef {
+    typeName: YatspFirstPartyTypeKind.YatspNull;
+}
+export declare class YatspNull extends YatspType<null, YatspNullDef, null> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: (params?: RawCreateParams) => YatspNull;
+}
+export interface YatspAnyDef extends YatspTypeDef {
+    typeName: YatspFirstPartyTypeKind.YatspAny;
+}
+export declare class YatspAny extends YatspType<any, YatspAnyDef, any> {
+    _any: true;
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: (params?: RawCreateParams) => YatspAny;
+}
+export interface YatspUnknownDef extends YatspTypeDef {
+    typeName: YatspFirstPartyTypeKind.YatspUnknown;
+}
+export declare class YatspUnknown extends YatspType<unknown, YatspUnknownDef, unknown> {
+    _unknown: true;
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: (params?: RawCreateParams) => YatspUnknown;
+}
+export interface YatspNeverDef extends YatspTypeDef {
+    typeName: YatspFirstPartyTypeKind.YatspNever;
+}
+export declare class YatspNever extends YatspType<never, YatspNeverDef, never> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: (params?: RawCreateParams) => YatspNever;
+}
+export interface YatspVoidDef extends YatspTypeDef {
+    typeName: YatspFirstPartyTypeKind.YatspVoid;
+}
+export declare class YatspVoid extends YatspType<void, YatspVoidDef, void> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: (params?: RawCreateParams) => YatspVoid;
+}
+export interface YatspArrayDef<T extends YatspTypeAny = YatspTypeAny> extends YatspTypeDef {
+    type: T;
+    typeName: YatspFirstPartyTypeKind.YatspArray;
+    exactLength: {
+        value: number;
+        message?: string | undefined;
+    } | null;
+    minLength: {
+        value: number;
+        message?: string | undefined;
+    } | null;
+    maxLength: {
+        value: number;
+        message?: string | undefined;
+    } | null;
+}
+export type ArrayCardinality = "many" | "atleastone";
+export type arrayOutputType<T extends YatspTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];
+export declare class YatspArray<T extends YatspTypeAny, Cardinality extends ArrayCardinality = "many"> extends YatspType<arrayOutputType<T, Cardinality>, YatspArrayDef<T>, Cardinality extends "atleastone" ? [T["_input"], ...T["_input"][]] : T["_input"][]> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    get element(): T;
+    min(minLength: number, message?: errorUtil.ErrMessage): this;
+    max(maxLength: number, message?: errorUtil.ErrMessage): this;
+    length(len: number, message?: errorUtil.ErrMessage): this;
+    nonempty(message?: errorUtil.ErrMessage): YatspArray<T, "atleastone">;
+    static create: <El extends YatspTypeAny>(schema: El, params?: RawCreateParams) => YatspArray<El>;
+}
+export type YatspNonEmptyArray<T extends YatspTypeAny> = YatspArray<T, "atleastone">;
+export type UnknownKeysParam = "passthrough" | "strict" | "strip";
+export interface YatspObjectDef<T extends YatspRawShape = YatspRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends YatspTypeAny = YatspTypeAny> extends YatspTypeDef {
+    typeName: YatspFirstPartyTypeKind.YatspObject;
+    shape: () => T;
+    catchall: Catchall;
+    unknownKeys: UnknownKeys;
+}
+export type mergeTypes<A, B> = {
+    [k in keyof A | keyof B]: k extends keyof B ? B[k] : k extends keyof A ? A[k] : never;
+};
+export type objectOutputType<Shape extends YatspRawShape, Catchall extends YatspTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
+export type baseObjectOutputType<Shape extends YatspRawShape> = {
+    [k in keyof Shape]: Shape[k]["_output"];
+};
+export type objectInputType<Shape extends YatspRawShape, Catchall extends YatspTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
+export type baseObjectInputType<Shape extends YatspRawShape> = objectUtil.addQuestionMarks<{
+    [k in keyof Shape]: Shape[k]["_input"];
+}>;
+export type CatchallOutput<T extends YatspType> = YatspType extends T ? unknown : {
+    [k: string]: T["_output"];
+};
+export type CatchallInput<T extends YatspType> = YatspType extends T ? unknown : {
+    [k: string]: T["_input"];
+};
+export type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
+    [k: string]: unknown;
+} : unknown;
+export type deoptional<T extends YatspTypeAny> = T extends YatspOptional<infer U> ? deoptional<U> : T extends YatspNullable<infer U> ? YatspNullable<deoptional<U>> : T;
+export type SomeYatspObject = YatspObject<YatspRawShape, UnknownKeysParam, YatspTypeAny>;
+export type noUnrecognized<Obj extends object, Shape extends object> = {
+    [k in keyof Obj]: k extends keyof Shape ? Obj[k] : never;
+};
+export declare class YatspObject<T extends YatspRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends YatspTypeAny = YatspTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>> extends YatspType<Output, YatspObjectDef<T, UnknownKeys, Catchall>, Input> {
+    _cached: {
+        shape: T;
+        keys: string[];
+    } | null;
+    _getCached(): {
+        shape: T;
+        keys: string[];
+    };
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    get shape(): T;
+    strict(message?: errorUtil.ErrMessage): YatspObject<T, "strict", Catchall>;
+    strip(): YatspObject<T, "strip", Catchall>;
+    passthrough(): YatspObject<T, "passthrough", Catchall>;
+    /**
+     * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
+     * If you want to pass through unknown properties, use `.passthrough()` instead.
+     */
+    nonstrict: () => YatspObject<T, "passthrough", Catchall>;
+    extend<Augmentation extends YatspRawShape>(augmentation: Augmentation): YatspObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
+    /**
+     * @deprecated Use `.extend` instead
+     *  */
+    augment: <Augmentation extends YatspRawShape>(augmentation: Augmentation) => YatspObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
+    /**
+     * Prior to yatsp@1.0.12 there was a bug in the
+     * inferred type of merged objects. Please
+     * upgrade if you are experiencing issues.
+     */
+    merge<Incoming extends AnyYatspObject, Augmentation extends Incoming["shape"]>(merging: Incoming): YatspObject<objectUtil.extendShape<T, Augmentation>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;
+    setKey<Key extends string, Schema extends YatspTypeAny>(key: Key, schema: Schema): YatspObject<T & {
+        [k in Key]: Schema;
+    }, UnknownKeys, Catchall>;
+    catchall<Index extends YatspTypeAny>(index: Index): YatspObject<T, UnknownKeys, Index>;
+    pick<Mask extends util.Exactly<{
+        [k in keyof T]?: true;
+    }, Mask>>(mask: Mask): YatspObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
+    omit<Mask extends util.Exactly<{
+        [k in keyof T]?: true;
+    }, Mask>>(mask: Mask): YatspObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
+    /**
+     * @deprecated
+     */
+    deepPartial(): partialUtil.DeepPartial<this>;
+    partial(): YatspObject<{
+        [k in keyof T]: YatspOptional<T[k]>;
+    }, UnknownKeys, Catchall>;
+    partial<Mask extends util.Exactly<{
+        [k in keyof T]?: true;
+    }, Mask>>(mask: Mask): YatspObject<objectUtil.noNever<{
+        [k in keyof T]: k extends keyof Mask ? YatspOptional<T[k]> : T[k];
+    }>, UnknownKeys, Catchall>;
+    required(): YatspObject<{
+        [k in keyof T]: deoptional<T[k]>;
+    }, UnknownKeys, Catchall>;
+    required<Mask extends util.Exactly<{
+        [k in keyof T]?: true;
+    }, Mask>>(mask: Mask): YatspObject<objectUtil.noNever<{
+        [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];
+    }>, UnknownKeys, Catchall>;
+    keyof(): YatspEnum<enumUtil.UnionToTupleString<keyof T>>;
+    static create: <Shape extends YatspRawShape>(shape: Shape, params?: RawCreateParams) => YatspObject<Shape, "strip", YatspTypeAny, objectOutputType<Shape, YatspTypeAny, "strip">, objectInputType<Shape, YatspTypeAny, "strip">>;
+    static strictCreate: <Shape extends YatspRawShape>(shape: Shape, params?: RawCreateParams) => YatspObject<Shape, "strict">;
+    static lazycreate: <Shape extends YatspRawShape>(shape: () => Shape, params?: RawCreateParams) => YatspObject<Shape, "strip">;
+}
+export type AnyYatspObject = YatspObject<any, any, any>;
+export type YatspUnionOptions = Readonly<[YatspTypeAny, ...YatspTypeAny[]]>;
+export interface YatspUnionDef<T extends YatspUnionOptions = Readonly<[YatspTypeAny, YatspTypeAny, ...YatspTypeAny[]]>> extends YatspTypeDef {
+    options: T;
+    typeName: YatspFirstPartyTypeKind.YatspUnion;
+}
+export declare class YatspUnion<T extends YatspUnionOptions> extends YatspType<T[number]["_output"], YatspUnionDef<T>, T[number]["_input"]> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    get options(): T;
+    static create: <Options extends Readonly<[YatspTypeAny, YatspTypeAny, ...YatspTypeAny[]]>>(types: Options, params?: RawCreateParams) => YatspUnion<Options>;
+}
+export type YatspDiscriminatedUnionOption<Discriminator extends string> = YatspObject<{
+    [key in Discriminator]: YatspTypeAny;
+} & YatspRawShape, UnknownKeysParam, YatspTypeAny>;
+export interface YatspDiscriminatedUnionDef<Discriminator extends string, Options extends readonly YatspDiscriminatedUnionOption<string>[] = YatspDiscriminatedUnionOption<string>[]> extends YatspTypeDef {
+    discriminator: Discriminator;
+    options: Options;
+    optionsMap: Map<Primitive, YatspDiscriminatedUnionOption<any>>;
+    typeName: YatspFirstPartyTypeKind.YatspDiscriminatedUnion;
+}
+export declare class YatspDiscriminatedUnion<Discriminator extends string, Options extends readonly YatspDiscriminatedUnionOption<Discriminator>[]> extends YatspType<output<Options[number]>, YatspDiscriminatedUnionDef<Discriminator, Options>, input<Options[number]>> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    get discriminator(): Discriminator;
+    get options(): Options;
+    get optionsMap(): Map<Primitive, YatspDiscriminatedUnionOption<any>>;
+    /**
+     * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
+     * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
+     * have a different value for each object in the union.
+     * @param discriminator the name of the discriminator property
+     * @param types an array of object schemas
+     * @param params
+     */
+    static create<Discriminator extends string, Types extends readonly [
+        YatspDiscriminatedUnionOption<Discriminator>,
+        ...YatspDiscriminatedUnionOption<Discriminator>[]
+    ]>(discriminator: Discriminator, options: Types, params?: RawCreateParams): YatspDiscriminatedUnion<Discriminator, Types>;
+}
+export interface YatspIntersectionDef<T extends YatspTypeAny = YatspTypeAny, U extends YatspTypeAny = YatspTypeAny> extends YatspTypeDef {
+    left: T;
+    right: U;
+    typeName: YatspFirstPartyTypeKind.YatspIntersection;
+}
+export declare class YatspIntersection<T extends YatspTypeAny, U extends YatspTypeAny> extends YatspType<T["_output"] & U["_output"], YatspIntersectionDef<T, U>, T["_input"] & U["_input"]> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: <TSchema extends YatspTypeAny, USchema extends YatspTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => YatspIntersection<TSchema, USchema>;
+}
+export type YatspTupleItems = [YatspTypeAny, ...YatspTypeAny[]];
+export type AssertArray<T> = T extends any[] ? T : never;
+export type OutputTypeOfTuple<T extends YatspTupleItems | []> = AssertArray<{
+    [k in keyof T]: T[k] extends YatspType<any, any, any> ? T[k]["_output"] : never;
+}>;
+export type OutputTypeOfTupleWithRest<T extends YatspTupleItems | [], Rest extends YatspTypeAny | null = null> = Rest extends YatspTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;
+export type InputTypeOfTuple<T extends YatspTupleItems | []> = AssertArray<{
+    [k in keyof T]: T[k] extends YatspType<any, any, any> ? T[k]["_input"] : never;
+}>;
+export type InputTypeOfTupleWithRest<T extends YatspTupleItems | [], Rest extends YatspTypeAny | null = null> = Rest extends YatspTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;
+export interface YatspTupleDef<T extends YatspTupleItems | [] = YatspTupleItems, Rest extends YatspTypeAny | null = null> extends YatspTypeDef {
+    items: T;
+    rest: Rest;
+    typeName: YatspFirstPartyTypeKind.YatspTuple;
+}
+export type AnyYatspTuple = YatspTuple<[YatspTypeAny, ...YatspTypeAny[]] | [], YatspTypeAny | null>;
+export declare class YatspTuple<T extends YatspTupleItems | [] = YatspTupleItems, Rest extends YatspTypeAny | null = null> extends YatspType<OutputTypeOfTupleWithRest<T, Rest>, YatspTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    get items(): T;
+    rest<RestSchema extends YatspTypeAny>(rest: RestSchema): YatspTuple<T, RestSchema>;
+    static create: <Items extends [YatspTypeAny, ...YatspTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => YatspTuple<Items, null>;
+}
+export interface YatspRecordDef<Key extends KeySchema = YatspString, Value extends YatspTypeAny = YatspTypeAny> extends YatspTypeDef {
+    valueType: Value;
+    keyType: Key;
+    typeName: YatspFirstPartyTypeKind.YatspRecord;
+}
+export type KeySchema = YatspType<string | number | symbol, any, any>;
+export type RecordType<K extends string | number | symbol, V> = [string] extends [K] ? Record<K, V> : [number] extends [K] ? Record<K, V> : [symbol] extends [K] ? Record<K, V> : [BRAND<string | number | symbol>] extends [K] ? Record<K, V> : Partial<Record<K, V>>;
+export declare class YatspRecord<Key extends KeySchema = YatspString, Value extends YatspTypeAny = YatspTypeAny> extends YatspType<RecordType<Key["_output"], Value["_output"]>, YatspRecordDef<Key, Value>, RecordType<Key["_input"], Value["_input"]>> {
+    get keySchema(): Key;
+    get valueSchema(): Value;
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    get element(): Value;
+    static create<Value extends YatspTypeAny>(valueType: Value, params?: RawCreateParams): YatspRecord<YatspString, Value>;
+    static create<Keys extends KeySchema, Value extends YatspTypeAny>(keySchema: Keys, valueType: Value, params?: RawCreateParams): YatspRecord<Keys, Value>;
+}
+export interface YatspMapDef<Key extends YatspTypeAny = YatspTypeAny, Value extends YatspTypeAny = YatspTypeAny> extends YatspTypeDef {
+    valueType: Value;
+    keyType: Key;
+    typeName: YatspFirstPartyTypeKind.YatspMap;
+}
+export declare class YatspMap<Key extends YatspTypeAny = YatspTypeAny, Value extends YatspTypeAny = YatspTypeAny> extends YatspType<Map<Key["_output"], Value["_output"]>, YatspMapDef<Key, Value>, Map<Key["_input"], Value["_input"]>> {
+    get keySchema(): Key;
+    get valueSchema(): Value;
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: <KeySchema extends YatspTypeAny = YatspTypeAny, ValueSchema extends YatspTypeAny = YatspTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => YatspMap<KeySchema, ValueSchema>;
+}
+export interface YatspSetDef<Value extends YatspTypeAny = YatspTypeAny> extends YatspTypeDef {
+    valueType: Value;
+    typeName: YatspFirstPartyTypeKind.YatspSet;
+    minSize: {
+        value: number;
+        message?: string | undefined;
+    } | null;
+    maxSize: {
+        value: number;
+        message?: string | undefined;
+    } | null;
+}
+export declare class YatspSet<Value extends YatspTypeAny = YatspTypeAny> extends YatspType<Set<Value["_output"]>, YatspSetDef<Value>, Set<Value["_input"]>> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    min(minSize: number, message?: errorUtil.ErrMessage): this;
+    max(maxSize: number, message?: errorUtil.ErrMessage): this;
+    size(size: number, message?: errorUtil.ErrMessage): this;
+    nonempty(message?: errorUtil.ErrMessage): YatspSet<Value>;
+    static create: <ValueSchema extends YatspTypeAny = YatspTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => YatspSet<ValueSchema>;
+}
+export interface YatspFunctionDef<Args extends YatspTuple<any, any> = YatspTuple<any, any>, Returns extends YatspTypeAny = YatspTypeAny> extends YatspTypeDef {
+    args: Args;
+    returns: Returns;
+    typeName: YatspFirstPartyTypeKind.YatspFunction;
+}
+export type OuterTypeOfFunction<Args extends YatspTuple<any, any>, Returns extends YatspTypeAny> = Args["_input"] extends Array<any> ? (...args: Args["_input"]) => Returns["_output"] : never;
+export type InnerTypeOfFunction<Args extends YatspTuple<any, any>, Returns extends YatspTypeAny> = Args["_output"] extends Array<any> ? (...args: Args["_output"]) => Returns["_input"] : never;
+export declare class YatspFunction<Args extends YatspTuple<any, any>, Returns extends YatspTypeAny> extends YatspType<OuterTypeOfFunction<Args, Returns>, YatspFunctionDef<Args, Returns>, InnerTypeOfFunction<Args, Returns>> {
+    _parse(input: ParseInput): ParseReturnType<any>;
+    parameters(): Args;
+    returnType(): Returns;
+    args<Items extends Parameters<(typeof YatspTuple)["create"]>[0]>(...items: Items): YatspFunction<YatspTuple<Items, YatspUnknown>, Returns>;
+    returns<NewReturnType extends YatspType<any, any, any>>(returnType: NewReturnType): YatspFunction<Args, NewReturnType>;
+    implement<F extends InnerTypeOfFunction<Args, Returns>>(func: F): ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
+    strictImplement(func: InnerTypeOfFunction<Args, Returns>): InnerTypeOfFunction<Args, Returns>;
+    validate: <F extends InnerTypeOfFunction<Args, Returns>>(func: F) => ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
+    static create(): YatspFunction<YatspTuple<[], YatspUnknown>, YatspUnknown>;
+    static create<T extends AnyYatspTuple = YatspTuple<[], YatspUnknown>>(args: T): YatspFunction<T, YatspUnknown>;
+    static create<T extends AnyYatspTuple, U extends YatspTypeAny>(args: T, returns: U): YatspFunction<T, U>;
+    static create<T extends AnyYatspTuple = YatspTuple<[], YatspUnknown>, U extends YatspTypeAny = YatspUnknown>(args: T, returns: U, params?: RawCreateParams): YatspFunction<T, U>;
+}
+export interface YatspLazyDef<T extends YatspTypeAny = YatspTypeAny> extends YatspTypeDef {
+    getter: () => T;
+    typeName: YatspFirstPartyTypeKind.YatspLazy;
+}
+export declare class YatspLazy<T extends YatspTypeAny> extends YatspType<output<T>, YatspLazyDef<T>, input<T>> {
+    get schema(): T;
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: <Inner extends YatspTypeAny>(getter: () => Inner, params?: RawCreateParams) => YatspLazy<Inner>;
+}
+export interface YatspLiteralDef<T = any> extends YatspTypeDef {
+    value: T;
+    typeName: YatspFirstPartyTypeKind.YatspLiteral;
+}
+export declare class YatspLiteral<T> extends YatspType<T, YatspLiteralDef<T>, T> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    get value(): T;
+    static create: <Value extends Primitive>(value: Value, params?: RawCreateParams) => YatspLiteral<Value>;
+}
+export type ArrayKeys = keyof any[];
+export type Indices<T> = Exclude<keyof T, ArrayKeys>;
+export type EnumValues<T extends string = string> = readonly [T, ...T[]];
+export type Values<T extends EnumValues> = {
+    [k in T[number]]: k;
+};
+export interface YatspEnumDef<T extends EnumValues = EnumValues> extends YatspTypeDef {
+    values: T;
+    typeName: YatspFirstPartyTypeKind.YatspEnum;
+}
+export type Writeable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
+export type typecast<A, T> = A extends T ? A : never;
+declare function createYatspEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): YatspEnum<Writeable<T>>;
+declare function createYatspEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): YatspEnum<T>;
+export declare class YatspEnum<T extends [string, ...string[]]> extends YatspType<T[number], YatspEnumDef<T>, T[number]> {
+    _cache: Set<T[number]> | undefined;
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    get options(): T;
+    get enum(): Values<T>;
+    get Values(): Values<T>;
+    get Enum(): Values<T>;
+    extract<ToExtract extends readonly [T[number], ...T[number][]]>(values: ToExtract, newDef?: RawCreateParams): YatspEnum<Writeable<ToExtract>>;
+    exclude<ToExclude extends readonly [T[number], ...T[number][]]>(values: ToExclude, newDef?: RawCreateParams): YatspEnum<typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [string, ...string[]]>>;
+    static create: typeof createYatspEnum;
+}
+export interface YatspNativeEnumDef<T extends EnumLike = EnumLike> extends YatspTypeDef {
+    values: T;
+    typeName: YatspFirstPartyTypeKind.YatspNativeEnum;
+}
+export type EnumLike = {
+    [k: string]: string | number;
+    [nu: number]: string;
+};
+export declare class YatspNativeEnum<T extends EnumLike> extends YatspType<T[keyof T], YatspNativeEnumDef<T>, T[keyof T]> {
+    _cache: Set<T[keyof T]> | undefined;
+    _parse(input: ParseInput): ParseReturnType<T[keyof T]>;
+    get enum(): T;
+    static create: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => YatspNativeEnum<Elements>;
+}
+export interface YatspPromiseDef<T extends YatspTypeAny = YatspTypeAny> extends YatspTypeDef {
+    type: T;
+    typeName: YatspFirstPartyTypeKind.YatspPromise;
+}
+export declare class YatspPromise<T extends YatspTypeAny> extends YatspType<Promise<T["_output"]>, YatspPromiseDef<T>, Promise<T["_input"]>> {
+    unwrap(): T;
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: <Inner extends YatspTypeAny>(schema: Inner, params?: RawCreateParams) => YatspPromise<Inner>;
+}
+export type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;
+export type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void | Promise<void>;
+export type RefinementEffect<T> = {
+    type: "refinement";
+    refinement: (arg: T, ctx: RefinementCtx) => any;
+};
+export type TransformEffect<T> = {
+    type: "transform";
+    transform: (arg: T, ctx: RefinementCtx) => any;
+};
+export type PreprocessEffect<T> = {
+    type: "preprocess";
+    transform: (arg: T, ctx: RefinementCtx) => any;
+};
+export type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
+export interface YatspEffectsDef<T extends YatspTypeAny = YatspTypeAny> extends YatspTypeDef {
+    schema: T;
+    typeName: YatspFirstPartyTypeKind.YatspEffects;
+    effect: Effect<any>;
+}
+export declare class YatspEffects<T extends YatspTypeAny, Output = output<T>, Input = input<T>> extends YatspType<Output, YatspEffectsDef<T>, Input> {
+    innerType(): T;
+    sourceType(): T;
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: <I extends YatspTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => YatspEffects<I, I["_output"]>;
+    static createWithPreprocess: <I extends YatspTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => YatspEffects<I, I["_output"], unknown>;
+}
+export { YatspEffects as YatspTransformer };
+export interface YatspOptionalDef<T extends YatspTypeAny = YatspTypeAny> extends YatspTypeDef {
+    innerType: T;
+    typeName: YatspFirstPartyTypeKind.YatspOptional;
+}
+export type YatspOptionalType<T extends YatspTypeAny> = YatspOptional<T>;
+export declare class YatspOptional<T extends YatspTypeAny> extends YatspType<T["_output"] | undefined, YatspOptionalDef<T>, T["_input"] | undefined> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    unwrap(): T;
+    static create: <Inner extends YatspTypeAny>(type: Inner, params?: RawCreateParams) => YatspOptional<Inner>;
+}
+export interface YatspNullableDef<T extends YatspTypeAny = YatspTypeAny> extends YatspTypeDef {
+    innerType: T;
+    typeName: YatspFirstPartyTypeKind.YatspNullable;
+}
+export type YatspNullableType<T extends YatspTypeAny> = YatspNullable<T>;
+export declare class YatspNullable<T extends YatspTypeAny> extends YatspType<T["_output"] | null, YatspNullableDef<T>, T["_input"] | null> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    unwrap(): T;
+    static create: <Inner extends YatspTypeAny>(type: Inner, params?: RawCreateParams) => YatspNullable<Inner>;
+}
+export interface YatspDefaultDef<T extends YatspTypeAny = YatspTypeAny> extends YatspTypeDef {
+    innerType: T;
+    defaultValue: () => util.noUndefined<T["_input"]>;
+    typeName: YatspFirstPartyTypeKind.YatspDefault;
+}
+export declare class YatspDefault<T extends YatspTypeAny> extends YatspType<util.noUndefined<T["_output"]>, YatspDefaultDef<T>, T["_input"] | undefined> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    removeDefault(): T;
+    static create: <Inner extends YatspTypeAny>(type: Inner, params: RawCreateParams & {
+        default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);
+    }) => YatspDefault<Inner>;
+}
+export interface YatspCatchDef<T extends YatspTypeAny = YatspTypeAny> extends YatspTypeDef {
+    innerType: T;
+    catchValue: (ctx: {
+        error: YatspError;
+        input: unknown;
+    }) => T["_input"];
+    typeName: YatspFirstPartyTypeKind.YatspCatch;
+}
+export declare class YatspCatch<T extends YatspTypeAny> extends YatspType<T["_output"], YatspCatchDef<T>, unknown> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    removeCatch(): T;
+    static create: <Inner extends YatspTypeAny>(type: Inner, params: RawCreateParams & {
+        catch: Inner["_output"] | (() => Inner["_output"]);
+    }) => YatspCatch<Inner>;
+}
+export interface YatspNaNDef extends YatspTypeDef {
+    typeName: YatspFirstPartyTypeKind.YatspNaN;
+}
+export declare class YatspNaN extends YatspType<number, YatspNaNDef, number> {
+    _parse(input: ParseInput): ParseReturnType<any>;
+    static create: (params?: RawCreateParams) => YatspNaN;
+}
+export interface YatspBrandedDef<T extends YatspTypeAny> extends YatspTypeDef {
+    type: T;
+    typeName: YatspFirstPartyTypeKind.YatspBranded;
+}
+export declare const BRAND: unique symbol;
+export type BRAND<T extends string | number | symbol> = {
+    [BRAND]: {
+        [k in T]: true;
+    };
+};
+export declare class YatspBranded<T extends YatspTypeAny, B extends string | number | symbol> extends YatspType<T["_output"] & BRAND<B>, YatspBrandedDef<T>, T["_input"]> {
+    _parse(input: ParseInput): ParseReturnType<any>;
+    unwrap(): T;
+}
+export interface YatspPipelineDef<A extends YatspTypeAny, B extends YatspTypeAny> extends YatspTypeDef {
+    in: A;
+    out: B;
+    typeName: YatspFirstPartyTypeKind.YatspPipeline;
+}
+export declare class YatspPipeline<A extends YatspTypeAny, B extends YatspTypeAny> extends YatspType<B["_output"], YatspPipelineDef<A, B>, A["_input"]> {
+    _parse(input: ParseInput): ParseReturnType<any>;
+    static create<ASchema extends YatspTypeAny, BSchema extends YatspTypeAny>(a: ASchema, b: BSchema): YatspPipeline<ASchema, BSchema>;
+}
+type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+    readonly [Symbol.toStringTag]: string;
+} | Date | Error | Generator | Promise<unknown> | RegExp;
+type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
+export interface YatspReadonlyDef<T extends YatspTypeAny = YatspTypeAny> extends YatspTypeDef {
+    innerType: T;
+    typeName: YatspFirstPartyTypeKind.YatspReadonly;
+}
+export declare class YatspReadonly<T extends YatspTypeAny> extends YatspType<MakeReadonly<T["_output"]>, YatspReadonlyDef<T>, MakeReadonly<T["_input"]>> {
+    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    static create: <Inner extends YatspTypeAny>(type: Inner, params?: RawCreateParams) => YatspReadonly<Inner>;
+    unwrap(): T;
+}
+type CustomParams = CustomErrorParams & {
+    fatal?: boolean;
+};
+export declare function custom<T>(check?: (data: any) => any, _params?: string | CustomParams | ((input: any) => CustomParams), 
+/**
+ * @deprecated
+ *
+ * Pass `fatal` into the params object instead:
+ *
+ * ```ts
+ * z.string().custom((val) => val.length > 5, { fatal: false })
+ * ```
+ *
+ */
+fatal?: boolean): YatspType<T, YatspTypeDef, T>;
+export { YatspType as Schema, YatspType as YatspSchema };
+export declare const late: {
+    object: <Shape extends YatspRawShape>(shape: () => Shape, params?: RawCreateParams) => YatspObject<Shape, "strip">;
+};
+export declare enum YatspFirstPartyTypeKind {
+    YatspString = "YatspString",
+    YatspNumber = "YatspNumber",
+    YatspNaN = "YatspNaN",
+    YatspBigInt = "YatspBigInt",
+    YatspBoolean = "YatspBoolean",
+    YatspDate = "YatspDate",
+    YatspSymbol = "YatspSymbol",
+    YatspUndefined = "YatspUndefined",
+    YatspNull = "YatspNull",
+    YatspAny = "YatspAny",
+    YatspUnknown = "YatspUnknown",
+    YatspNever = "YatspNever",
+    YatspVoid = "YatspVoid",
+    YatspArray = "YatspArray",
+    YatspObject = "YatspObject",
+    YatspUnion = "YatspUnion",
+    YatspDiscriminatedUnion = "YatspDiscriminatedUnion",
+    YatspIntersection = "YatspIntersection",
+    YatspTuple = "YatspTuple",
+    YatspRecord = "YatspRecord",
+    YatspMap = "YatspMap",
+    YatspSet = "YatspSet",
+    YatspFunction = "YatspFunction",
+    YatspLazy = "YatspLazy",
+    YatspLiteral = "YatspLiteral",
+    YatspEnum = "YatspEnum",
+    YatspEffects = "YatspEffects",
+    YatspNativeEnum = "YatspNativeEnum",
+    YatspOptional = "YatspOptional",
+    YatspNullable = "YatspNullable",
+    YatspDefault = "YatspDefault",
+    YatspCatch = "YatspCatch",
+    YatspPromise = "YatspPromise",
+    YatspBranded = "YatspBranded",
+    YatspPipeline = "YatspPipeline",
+    YatspReadonly = "YatspReadonly"
+}
+export type YatspFirstPartySchemaTypes = YatspString | YatspNumber | YatspNaN | YatspBigInt | YatspBoolean | YatspDate | YatspUndefined | YatspNull | YatspAny | YatspUnknown | YatspNever | YatspVoid | YatspArray<any, any> | YatspObject<any, any, any> | YatspUnion<any> | YatspDiscriminatedUnion<any, any> | YatspIntersection<any, any> | YatspTuple<any, any> | YatspRecord<any, any> | YatspMap<any> | YatspSet<any> | YatspFunction<any, any> | YatspLazy<any> | YatspLiteral<any> | YatspEnum<any> | YatspEffects<any, any, any> | YatspNativeEnum<any> | YatspOptional<any> | YatspNullable<any> | YatspDefault<any> | YatspCatch<any> | YatspPromise<any> | YatspBranded<any, any> | YatspPipeline<any, any> | YatspReadonly<any> | YatspSymbol;
+declare abstract class Class {
+    constructor(..._: any[]);
+}
+declare const instanceOfType: <T extends typeof Class>(cls: T, params?: CustomParams) => YatspType<InstanceType<T>, YatspTypeDef, InstanceType<T>>;
+declare const stringType: (params?: RawCreateParams & {
+    coerce?: true;
+}) => YatspString;
+declare const numberType: (params?: RawCreateParams & {
+    coerce?: boolean;
+}) => YatspNumber;
+declare const nanType: (params?: RawCreateParams) => YatspNaN;
+declare const bigIntType: (params?: RawCreateParams & {
+    coerce?: boolean;
+}) => YatspBigInt;
+declare const booleanType: (params?: RawCreateParams & {
+    coerce?: boolean;
+}) => YatspBoolean;
+declare const dateType: (params?: RawCreateParams & {
+    coerce?: boolean;
+}) => YatspDate;
+declare const symbolType: (params?: RawCreateParams) => YatspSymbol;
+declare const undefinedType: (params?: RawCreateParams) => YatspUndefined;
+declare const nullType: (params?: RawCreateParams) => YatspNull;
+declare const anyType: (params?: RawCreateParams) => YatspAny;
+declare const unknownType: (params?: RawCreateParams) => YatspUnknown;
+declare const neverType: (params?: RawCreateParams) => YatspNever;
+declare const voidType: (params?: RawCreateParams) => YatspVoid;
+declare const arrayType: <El extends YatspTypeAny>(schema: El, params?: RawCreateParams) => YatspArray<El>;
+declare const objectType: <Shape extends YatspRawShape>(shape: Shape, params?: RawCreateParams) => YatspObject<Shape, "strip", YatspTypeAny, objectOutputType<Shape, YatspTypeAny, "strip">, objectInputType<Shape, YatspTypeAny, "strip">>;
+declare const strictObjectType: <Shape extends YatspRawShape>(shape: Shape, params?: RawCreateParams) => YatspObject<Shape, "strict">;
+declare const unionType: <Options extends Readonly<[YatspTypeAny, YatspTypeAny, ...YatspTypeAny[]]>>(types: Options, params?: RawCreateParams) => YatspUnion<Options>;
+declare const discriminatedUnionType: typeof YatspDiscriminatedUnion.create;
+declare const intersectionType: <TSchema extends YatspTypeAny, USchema extends YatspTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => YatspIntersection<TSchema, USchema>;
+declare const tupleType: <Items extends [YatspTypeAny, ...YatspTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => YatspTuple<Items, null>;
+declare const recordType: typeof YatspRecord.create;
+declare const mapType: <KeySchema extends YatspTypeAny = YatspTypeAny, ValueSchema extends YatspTypeAny = YatspTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => YatspMap<KeySchema, ValueSchema>;
+declare const setType: <ValueSchema extends YatspTypeAny = YatspTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => YatspSet<ValueSchema>;
+declare const functionType: typeof YatspFunction.create;
+declare const lazyType: <Inner extends YatspTypeAny>(getter: () => Inner, params?: RawCreateParams) => YatspLazy<Inner>;
+declare const literalType: <Value extends Primitive>(value: Value, params?: RawCreateParams) => YatspLiteral<Value>;
+declare const enumType: typeof createYatspEnum;
+declare const nativeEnumType: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => YatspNativeEnum<Elements>;
+declare const promiseType: <Inner extends YatspTypeAny>(schema: Inner, params?: RawCreateParams) => YatspPromise<Inner>;
+declare const effectsType: <I extends YatspTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => YatspEffects<I, I["_output"]>;
+declare const optionalType: <Inner extends YatspTypeAny>(type: Inner, params?: RawCreateParams) => YatspOptional<Inner>;
+declare const nullableType: <Inner extends YatspTypeAny>(type: Inner, params?: RawCreateParams) => YatspNullable<Inner>;
+declare const preprocessType: <I extends YatspTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => YatspEffects<I, I["_output"], unknown>;
+declare const pipelineType: typeof YatspPipeline.create;
+declare const ostring: () => YatspOptional<YatspString>;
+declare const onumber: () => YatspOptional<YatspNumber>;
+declare const oboolean: () => YatspOptional<YatspBoolean>;
+export declare const coerce: {
+    string: (typeof YatspString)["create"];
+    number: (typeof YatspNumber)["create"];
+    boolean: (typeof YatspBoolean)["create"];
+    bigint: (typeof YatspBigInt)["create"];
+    date: (typeof YatspDate)["create"];
+};
+export { anyType as any, arrayType as array, bigIntType as bigint, booleanType as boolean, dateType as date, discriminatedUnionType as discriminatedUnion, effectsType as effect, enumType as enum, functionType as function, instanceOfType as instanceof, intersectionType as intersection, lazyType as lazy, literalType as literal, mapType as map, nanType as nan, nativeEnumType as nativeEnum, neverType as never, nullType as null, nullableType as nullable, numberType as number, objectType as object, oboolean, onumber, optionalType as optional, ostring, pipelineType as pipeline, preprocessType as preprocess, promiseType as promise, recordType as record, setType as set, strictObjectType as strictObject, stringType as string, symbolType as symbol, effectsType as transformer, tupleType as tuple, undefinedType as undefined, unionType as union, unknownType as unknown, voidType as void, };
+export declare const NEVER: never;