/**
 * vae 数据验证。
 *
 * @packageDocumentation
 */

declare function array<T extends Nullable<unknown[]> = unknown[]>(element: VaeArraySchemaElementOf<T>, message?: VaeLocaleMessage): VaeArraySchema<T>;

declare function array<T extends Nullable<unknown[]> = unknown[]>(schema: (schema: VaeArraySchema<T>) => VaeArraySchema<T>, message?: VaeLocaleMessage): VaeArraySchema<T>;

declare function array<T extends Nullable<unknown[]> = unknown[]>(message?: VaeLocaleMessage): VaeArraySchema<T>;

declare function boolean<T extends Nullable<boolean> = boolean>(schema: (schema: VaeBooleanSchema<T>) => VaeBooleanSchema<T>, message?: VaeLocaleMessage): VaeBooleanSchema<T>;

declare function boolean<T extends Nullable<boolean> = boolean>(message?: VaeLocaleMessage): VaeBooleanSchema<T>;

declare type Builtin = Primitive_2 | Function | Date | Error | RegExp;

declare function date<T extends Nullable<Date> = Date>(schema: (schema: VaeDateSchema<T>) => VaeDateSchema<T>, message?: VaeLocaleMessage): VaeDateSchema<T>;

declare function date<T extends Nullable<Date> = Date>(message?: VaeLocaleMessage): VaeDateSchema<T>;

declare type DotPath<T> = object extends T ? string : T extends any[] ? '0' | SubKeys<T, 0> : T extends readonly any[] ? Extract<keyof T, `${number}`> | SubKeys<T, Extract<keyof T, `${number}`>> : T extends object ? Extract<keyof T, string> | SubKeys<T, Extract<keyof T, string>> : never;

declare type DotPathValue<T, Path extends string> = Path extends '0' ? T[0] : Path extends keyof T ? T[Path] : Path extends `${infer K}.${infer R}` ? K extends '0' ? DotPathValue<T[0], R> : K extends keyof T ? DotPathValue<T[K], R> : unknown : unknown;

declare type DotPathWithRoot<T> = DotPath<T> | '.';

declare type DotPathWithRootValue<T, Path extends string> = Path extends '.' ? T : DotPathValue<T, Path>;

/**
 * 判断 `T` 是否是 `any` 类型。
 *
 * @public
 * @see https://stackoverflow.com/a/49928360
 * @example
 * ```typescript
 * type X = IsAny<any>
 * // => true
 * ```
 */
declare type IsAny<T> = 0 extends 1 & T ? true : false;

declare type Nullable<T> = T | null | undefined;

declare function number<T extends Nullable<number> = number>(schema: (schema: VaeNumberSchema<T>) => VaeNumberSchema<T>, message?: VaeLocaleMessage): VaeNumberSchema<T>;

declare function number<T extends Nullable<number> = number>(message?: VaeLocaleMessage): VaeNumberSchema<T>;

declare function object<T0 extends Record<any, Nullable<any>> = Record<any, any>, T extends NonNullable<T0> = NonNullable<T0>>(shape: VaeObjectSchemaShapeOf<T>, message?: VaeLocaleMessage): VaeObjectSchema<IsAny<keyof T0> extends true ? T : T0>;

declare function object<T extends Nullable<Record<any, any>> = Record<any, any>>(schema: (schema: VaeObjectSchema<T>) => VaeObjectSchema<T>, message?: VaeLocaleMessage): VaeObjectSchema<T>;

declare function object<T extends Nullable<Record<any, any>> = Record<any, any>>(message?: VaeLocaleMessage): VaeObjectSchema<T>;

/** Essentials */
declare type Primitive_2 = string | number | boolean | bigint | symbol | undefined | null;

/** Mark some properties as required, leaving others unchanged */
declare type RequiredBy<T, RK extends keyof T> = Exclude<T, RK> & Required<Pick<T, RK>>;

/** Like Required but recursive */
declare type RequiredDeep<T> = T extends Builtin
? NonNullable<T>
: T extends Map<infer K, infer V>
? Map<RequiredDeep<K>, RequiredDeep<V>>
: T extends ReadonlyMap<infer K, infer V>
? ReadonlyMap<RequiredDeep<K>, RequiredDeep<V>>
: T extends WeakMap<infer K, infer V>
? WeakMap<RequiredDeep<K>, RequiredDeep<V>>
: T extends Set<infer U>
? Set<RequiredDeep<U>>
: T extends ReadonlySet<infer U>
? ReadonlySet<RequiredDeep<U>>
: T extends WeakSet<infer U>
? WeakSet<RequiredDeep<U>>
: T extends Promise<infer U>
? Promise<RequiredDeep<U>>
: T extends {}
? {
    [K in keyof T]-?: RequiredDeep<T[K]>;
}
: NonNullable<T>;

declare const schemaBuilders: {
    string: typeof string;
    number: typeof number;
    date: typeof date;
    boolean: typeof boolean;
    object: typeof object;
    array: typeof array;
};

declare function string<T extends Nullable<string> = string>(schema: (schema: VaeStringSchema<T>) => VaeStringSchema<T>, message?: VaeLocaleMessage): VaeStringSchema<T>;

declare function string<T extends Nullable<string> = string>(message?: VaeLocaleMessage): VaeStringSchema<T>;

declare type SubKeys<T, K extends string | number> = K extends keyof T ? `${K}.${DotPath<T[K]>}` : never;

export declare const v: {
    create: <R, F extends (_: typeof schemaBuilders) => R = (_: typeof schemaBuilders) => R>(cb: F) => R;
    localeBuilder: typeof VaeLocaleBuilder;
    setLocale: (locale: VaeLocaleShape) => void;
    string: typeof string;
    number: typeof number;
    date: typeof date;
    boolean: typeof boolean;
    object: typeof object;
    array: typeof array;
};

export declare interface VaeArrayOfSchemaBuilder<O extends Record<any, any>> {
    <K extends DotPathWithRoot<O>, T extends DotPathWithRootValue<O, K> & unknown[]>(key: K, element: VaeArraySchemaElementOf<T>, message?: VaeLocaleMessage): VaeArraySchema<T>;
    <K extends DotPathWithRoot<O>, T extends DotPathWithRootValue<O, K> & unknown[]>(key: K, schema: (schema: VaeArraySchema<T>) => VaeArraySchema<T>, message?: VaeLocaleMessage): VaeArraySchema<T>;
    <K extends DotPathWithRoot<O>, T extends DotPathWithRootValue<O, K> & unknown[]>(key: K, message?: VaeLocaleMessage): VaeArraySchema<T>;
}

export declare class VaeArraySchema<T0 extends Nullable<any[]> = any[], T extends NonNullable<T0> = NonNullable<T0>> extends VaeSchema<T0> {
    constructor(element?: VaeArraySchemaElementOf<T>, message?: VaeLocaleMessage);
    /**
     * 数组元素定义
     */
    element(element: VaeArraySchemaElementOf<T>): this;
    /**
     * 数组非空，即长度应大于 0
     */
    nonempty(message?: VaeLocaleMessage): this;
    /**
     * 数组最小长度
     */
    min(value: number, message?: VaeLocaleMessage): this;
    /**
     * 数组最大长度
     */
    max(value: number, message?: VaeLocaleMessage): this;
    /**
     * 数组固定长度
     */
    length(value: number, message?: VaeLocaleMessage): this;
    /**
     * 当设置了必填时，将空数组视为已填
     */
    emptyable(): this;
}

export declare interface VaeArraySchemaBuilder {
    <T extends Nullable<unknown[]> = unknown[]>(element: VaeArraySchemaElementOf<T>, message?: VaeLocaleMessage): VaeArraySchema<T>;
    <T extends Nullable<unknown[]> = unknown[]>(schema: (schema: VaeArraySchema<T>) => VaeArraySchema<T>, message?: VaeLocaleMessage): VaeArraySchema<T>;
    <T extends Nullable<unknown[]> = unknown[]>(message?: VaeLocaleMessage): VaeArraySchema<T>;
}

export declare type VaeArraySchemaElementOf<T> = T extends Array<infer X> ? VaeSchemaOf<X> : never;

export declare interface VaeBooleanOfSchemaBuilder<O extends Record<any, any>> {
    <K extends DotPathWithRoot<O>, T extends DotPathWithRootValue<O, K> & boolean>(key: K, schema: (schema: VaeBooleanSchema<T>) => VaeBooleanSchema<T>, message?: VaeLocaleMessage): VaeBooleanSchema<T>;
    <K extends DotPathWithRoot<O>, T extends DotPathWithRootValue<O, K> & boolean>(key: K, message?: VaeLocaleMessage): VaeBooleanSchema<T>;
}

export declare class VaeBooleanSchema<T0 extends Nullable<boolean> = boolean> extends VaeSchema<T0> {
    constructor(message?: VaeLocaleMessage);
    /**
     * 应为 true
     */
    true(message?: VaeLocaleMessage): this;
    /**
     * 应为 false
     */
    false(message?: VaeLocaleMessage): this;
}

export declare interface VaeBooleanSchemaBuilder {
    <T extends Nullable<boolean> = boolean>(schema: (schema: VaeBooleanSchema<T>) => VaeBooleanSchema<T>, message?: VaeLocaleMessage): VaeBooleanSchema<T>;
    <T extends Nullable<boolean> = boolean>(message?: VaeLocaleMessage): VaeBooleanSchema<T>;
}

export declare interface VaeDateOfSchemaBuilder<O extends Record<any, any>> {
    <K extends DotPathWithRoot<O>, T extends DotPathWithRootValue<O, K> & Date>(key: K, schema: (schema: VaeDateSchema<T>) => VaeDateSchema<T>, message?: VaeLocaleMessage): VaeDateSchema<T>;
    <K extends DotPathWithRoot<O>, T extends DotPathWithRootValue<O, K> & Date>(key: K, message?: VaeLocaleMessage): VaeDateSchema<T>;
}

export declare class VaeDateSchema<T0 extends Nullable<Date> = Date> extends VaeSchema<T0> {
    constructor(message?: VaeLocaleMessage);
    /**
     * 最小日期
     */
    min(value: Date | string | number, message?: VaeLocaleMessage): this;
    /**
     * 最大日期
     */
    max(value: Date | string | number, message?: VaeLocaleMessage): this;
}

export declare interface VaeDateSchemaBuilder {
    <T extends Nullable<Date> = Date>(schema: (schema: VaeDateSchema<T>) => VaeDateSchema<T>, message?: VaeLocaleMessage): VaeDateSchema<T>;
    <T extends Nullable<Date> = Date>(message?: VaeLocaleMessage): VaeDateSchema<T>;
}

export declare class VaeError extends Error {
    issues: VaeIssue[];
    name: string;
    constructor(issues: VaeIssue[]);
    /**
     * 从问题里导出信息
     */
    static messageFromIssues(issues: VaeIssue[]): string;
}

export declare interface VaeErrorIssue {
    path: Array<string | number>;
    message: string;
}

export declare type VaeIssue = {
    /**
     * issue 产生的路径
     */
    path: VaeSchemaPath;
    /**
     * issue 信息
     */
    message: string;
};

export declare const VaeLocale: {
    $set: (locale: VaeLocaleShape) => void;
    base: Record<'required' | 'enum' | 'custom', VaeLocaleMessage>;
    string: Record<'type' | 'min' | 'max' | 'length' | 'email' | 'url' | 'regex' | 'includes' | 'startsWith' | 'endsWith' | 'phoneNumber' | 'idCardNumber' | 'cuid' | 'cuid2', VaeLocaleMessage>;
    object: Record<'type' | 'requiredFieldsAtLeastOne', VaeLocaleMessage>;
    number: Record<'type' | 'min' | 'max' | 'lessThan' | 'moreThan' | 'integer' | 'positive' | 'nonpositive' | 'negative' | 'nonnegative' | 'positiveInteger', VaeLocaleMessage>;
    boolean: Record<'type' | 'true' | 'false', VaeLocaleMessage>;
    array: Record<'type' | 'nonempty' | 'min' | 'max' | 'length', VaeLocaleMessage>;
    date: Record<'type' | 'min' | 'max', VaeLocaleMessage>;
};

export declare class VaeLocaleBuilder {
    static zhCN(options: {
        getLabel: (payload: VaeLocaleMessagePayload) => string;
    }): VaeLocaleShape;
}

export declare type VaeLocaleMessage = string | ((payload: VaeLocaleMessagePayload) => string);

export declare type VaeLocaleMessagePayload = {
    /**
     * 标签
     */
    label?: string | (() => string);
    /**
     * 路径
     */
    path: VaeSchemaPath;
    /**
     * 值
     */
    value: any;
    /**
     * 参数
     */
    params: Record<string, any>;
};

export declare type VaeLocaleShape = {
    base: Record<'required' | 'enum' | 'custom', VaeLocaleMessage>;
    string: Record<'type' | 'min' | 'max' | 'length' | 'email' | 'url' | 'regex' | 'includes' | 'startsWith' | 'endsWith' | 'phoneNumber' | 'idCardNumber' | 'cuid' | 'cuid2', VaeLocaleMessage>;
    object: Record<'type' | 'requiredFieldsAtLeastOne', VaeLocaleMessage>;
    number: Record<'type' | 'min' | 'max' | 'lessThan' | 'moreThan' | 'integer' | 'positive' | 'nonpositive' | 'negative' | 'nonnegative' | 'positiveInteger', VaeLocaleMessage>;
    boolean: Record<'type' | 'true' | 'false', VaeLocaleMessage>;
    array: Record<'type' | 'nonempty' | 'min' | 'max' | 'length', VaeLocaleMessage>;
    date: Record<'type' | 'min' | 'max', VaeLocaleMessage>;
};

export declare interface VaeNumberOfSchemaBuilder<O extends Record<any, any>> {
    <K extends DotPathWithRoot<O>, T extends DotPathWithRootValue<O, K> & number>(key: K, schema: (schema: VaeNumberSchema<T>) => VaeNumberSchema<T>, message?: VaeLocaleMessage): VaeNumberSchema<T>;
    <K extends DotPathWithRoot<O>, T extends DotPathWithRootValue<O, K> & number>(key: K, message?: VaeLocaleMessage): VaeNumberSchema<T>;
}

export declare class VaeNumberSchema<T0 extends Nullable<number> = number> extends VaeSchema<T0> {
    constructor(message?: VaeLocaleMessage);
    /**
     * 最小值
     */
    min(value: number, message?: VaeLocaleMessage): this;
    /**
     * 最大值
     */
    max(value: number, message?: VaeLocaleMessage): this;
    /**
     * 小于
     */
    lessThan(value: number, message?: VaeLocaleMessage): this;
    /**
     * 大于
     */
    moreThan(value: number, message?: VaeLocaleMessage): this;
    /**
     * 整数，即 -100, -1, 0, 1, 2, 100, ...
     */
    integer(message?: VaeLocaleMessage): this;
    /**
     * 正数，即 0.01, 0.1, 1, 2, 3, ...
     */
    positive(message?: VaeLocaleMessage): this;
    /**
     * 非正数，即 0, -0.01, -1, -100, ...
     */
    nonpositive(message?: VaeLocaleMessage): this;
    /**
     * 负数，即 -0.01, -1, -100, ...
     */
    negative(message?: VaeLocaleMessage): this;
    /**
     * 非负数，即 0, 0.01, 0.1, 1, 2.1, 100, ...
     */
    nonnegative(message?: VaeLocaleMessage): this;
    /**
     * 正整数，即 1, 2, 3, 4, 5, ...
     */
    positiveInteger(message?: VaeLocaleMessage): this;
    /**
     * ID，即正整数，即 1, 2, 3, 4, 5, ...
     */
    id(message?: VaeLocaleMessage): this;
}

export declare interface VaeNumberSchemaBuilder {
    <T extends Nullable<number> = number>(schema: (schema: VaeNumberSchema<T>) => VaeNumberSchema<T>, message?: VaeLocaleMessage): VaeNumberSchema<T>;
    <T extends Nullable<number> = number>(message?: VaeLocaleMessage): VaeNumberSchema<T>;
}

export declare interface VaeObjectOfSchemaBuilder<O extends Record<any, any>> {
    <K extends DotPathWithRoot<O>, T extends DotPathWithRootValue<O, K> & {}>(key: K, shape: VaeObjectSchemaShapeOf<T>, message?: VaeLocaleMessage): VaeObjectSchema<T>;
    <K extends DotPathWithRoot<O>, T extends DotPathWithRootValue<O, K> & {}>(key: K, schema: (schema: VaeObjectSchema<T>) => VaeObjectSchema<T>, message?: VaeLocaleMessage): VaeObjectSchema<T>;
    <K extends DotPathWithRoot<O>, T extends DotPathWithRootValue<O, K> & {}>(key: K, message?: VaeLocaleMessage): VaeObjectSchema<T>;
}

export declare class VaeObjectSchema<T0 extends Nullable<Record<any, any>> = Record<any, any>, T extends NonNullable<T0> = NonNullable<T0>> extends VaeSchema<T0> {
    constructor(shape?: VaeObjectSchemaShapeOf<T>, message?: VaeLocaleMessage);
    /**
     * 对象定义
     */
    shape(shape: VaeObjectSchemaShapeOf<T>): this;
    /**
     * 原地挑选给定字段
     */
    pickFields<K extends keyof T>(keys: K[]): VaeObjectSchema<Pick<T, K>>;
    /**
     * 原地剔除给定字段
     */
    omitFields<K extends keyof T>(keys: K[]): VaeObjectSchema<Omit<T, K>>;
    /**
     * 原地将给定字段设为可选
     */
    optionalFields<K extends keyof T>(keys: K[]): this;
    /**
     * 原地将所有字段设为可选
     */
    optionalFields(): this;
    /**
     * 原地将给定字段设为必填
     */
    requiredFields<K extends keyof T>(keys: K[]): this;
    /**
     * 原地将所有字段设为必填
     */
    requiredFields(): this;
    /**
     * 返回给定字段的定义
     */
    shapeOfFields<K extends keyof T>(keys: K[]): VaeObjectSchemaShapeOf<Pick<T, K>>;
    /**
     * 返回全部字段的定义
     */
    shapeOfFields(): VaeObjectSchemaShapeOf<T>;
    /**
     * 给定字段中至少有一个必填
     */
    requiredFieldsAtLeastOne<K extends keyof T>(keys: K[], message?: VaeLocaleMessage): this;
}

export declare interface VaeObjectSchemaBuilder {
    <T0 extends Record<any, Nullable<any>> = Record<any, any>, T extends NonNullable<T0> = NonNullable<T0>>(shape: VaeObjectSchemaShapeOf<T>, message?: VaeLocaleMessage): VaeObjectSchema<IsAny<keyof T0> extends true ? T : T0>;
    <T extends Nullable<Record<any, any>> = Record<any, any>>(schema: (schema: VaeObjectSchema<T>) => VaeObjectSchema<T>, message?: VaeLocaleMessage): VaeObjectSchema<T>;
    <T extends Nullable<Record<any, any>> = Record<any, any>>(message?: VaeLocaleMessage): VaeObjectSchema<T>;
}

export declare type VaeObjectSchemaShapeOf<T> = {
    [K in keyof T]-?: VaeSchemaOf<T[K]>;
};

export declare abstract class VaeSchema<T0 extends any = any, T extends NonNullable<T0> = NonNullable<T0>> {
    protected _options: RequiredBy<VaeSchemaOptions<T, any>, 'processors'>;
    constructor(options: VaeSchemaOptions<T, any>);
    /**
     * 选项
     */
    get options(): RequiredBy<VaeSchemaOptions<T, any>, "processors">;
    /**
     * 设置元信息
     */
    meta(metadata: VaeSchemaMetadata): this;
    /**
     * 新增检测
     */
    check(payload: VaeSchemaCheckPayload<T>): this;
    /**
     * 新增转换
     */
    transform(payload: VaeSchemaTransformPayload<T>): this;
    /**
     * 设置标签，可以同时设置元信息
     */
    label(label: string | (() => string), metadata?: VaeSchemaMetadata): this;
    /**
     * 设置默认值
     */
    default(value: T | (() => T)): this;
    /**
     * 设为必填
     */
    required(message?: VaeLocaleMessage): this;
    /**
     * 设为必填
     */
    required(isRequired: boolean, message?: VaeLocaleMessage): this;
    /**
     * 设为可选
     */
    optional(): this;
    /**
     * 设置枚举
     */
    enum(value: T[] | Record<any, T>, message?: VaeLocaleMessage): this;
    /**
     * 自定义检测
     */
    custom(fn: (value: T) => boolean | void, messageOrOptions?: VaeLocaleMessage | {
        message?: VaeLocaleMessage;
        path?: DotPath<T>;
        tag?: string;
    }): this;
    /**
     * 在运行时动态修改模式
     */
    runtime(fn: VaeSchemaRuntimeFn<T, this>): this;
    /**
     * 克隆
     */
    clone(): this;
    /**
     * 获取给定多个路径的模式
     */
    reach<P extends DotPath<T>>(paths: P[], ctx?: VaeSchemaReachContext, curPath?: VaeSchemaPath): {
        [K in P]: VaeSchemaOf<DotPathValue<T, K>>;
    };
    /**
     * 获取给定路径的模式
     */
    reach<P extends DotPath<T>>(path: P, ctx?: VaeSchemaReachContext, curPath?: VaeSchemaPath): VaeSchemaOf<DotPathValue<T, P>>;
    /**
     * 解析数据并返回解析结果
     */
    parse(data: T0, options?: VaeSchemaParseOptions): VaeSchemaParseResult<T0>;
    /**
     * 解析数据，当解析失败时抛出错误，当解析成功时返回结果
     */
    parseOrThrow(data: T0, options?: VaeSchemaParseOptions): T0;
    /**
     * 根据当前模式强制转换给定数据
     */
    cast(data: any, options?: VaeSchemaCastOptions): any;
}

export declare class VaeSchemaBuilder<X extends Nullable<Record<any, any>> = Nullable<Record<any, any>>, O extends RequiredDeep<X> = RequiredDeep<X>> {
    string: VaeStringSchemaBuilder;
    stringOf: VaeStringOfSchemaBuilder<O>;
    number: VaeNumberSchemaBuilder;
    numberOf: VaeNumberOfSchemaBuilder<O>;
    date: VaeDateSchemaBuilder;
    dateOf: VaeDateOfSchemaBuilder<O>;
    boolean: VaeBooleanSchemaBuilder;
    booleanOf: VaeBooleanOfSchemaBuilder<O>;
    object: VaeObjectSchemaBuilder;
    objectOf: VaeObjectOfSchemaBuilder<O>;
    array: VaeArraySchemaBuilder;
    arrayOf: VaeArrayOfSchemaBuilder<O>;
}

export declare type VaeSchemaCastOptions = {
    /**
     * 是否保留未知属性
     *
     * @default false
     */
    preserveUnknownKeys?: boolean;
};

export declare type VaeSchemaCheckPayload<T> = {
    fn: ((value: T) => boolean | void) | VaeSchema;
    message: VaeLocaleMessage;
    messageParams?: Record<string, any>;
    path?: VaeSchemaPath;
    tag?: string;
};

export declare interface VaeSchemaCustomMetadata {
}

export declare type VaeSchemaMetadata = keyof VaeSchemaCustomMetadata extends never ? Record<any, any> : VaeSchemaCustomMetadata;

export declare type VaeSchemaOf<T0, T extends NonNullable<T0> = NonNullable<T0>> = [
T
] extends [string] ? VaeStringSchema<T0> : [T] extends [number] ? VaeNumberSchema<T0> : [T] extends [boolean] ? VaeBooleanSchema<T0> : [T] extends [Date] ? VaeDateSchema<T0> : T extends any[] ? VaeArraySchema<T0> : VaeObjectSchema<T0>;

export declare type VaeSchemaOptions<T, S> = {
    type: VaeSchemaType;
    label?: string | (() => string);
    default?: T | (() => T);
    required?: boolean;
    requiredMessage?: VaeLocaleMessage;
    objectKeys?: string[];
    stringTrim?: boolean;
    stringEmptyable?: boolean;
    arrayEmptyable?: boolean;
    processors?: Array<VaeSchemaCheckPayload<T> | VaeSchemaTransformPayload<T>>;
    runtime?: VaeSchemaRuntimeFn<T, S>;
    metadata?: VaeSchemaMetadata;
};

export declare class VaeSchemaParseContext {
    /**
     * 问题列表
     */
    issues: VaeIssue[];
    /**
     * 新增问题
     */
    addIssue(issue: VaeIssue): void;
}

export declare type VaeSchemaParseOptions = {
    /**
     * 上下文，内部使用
     *
     * @inner
     */
    ctx?: VaeSchemaParseContext;
    /**
     * 当前路径，内部使用
     *
     * @inner
     */
    curPath?: VaeSchemaPath;
    /**
     * 是否提前终止
     *
     * @default false
     */
    abortEarly?: boolean;
    /**
     * 是否保留未知属性
     *
     * @default false
     */
    preserveUnknownKeys?: boolean;
    /**
     * 是否 cast 模式
     *
     * @default false
     */
    cast?: boolean;
};

export declare type VaeSchemaParseResult<T> = {
    success: true;
    data: T;
} | {
    success: false;
    issues: VaeIssue[];
    message: string;
};

export declare type VaeSchemaPath = Array<string | number>;

export declare class VaeSchemaReachContext {
    /**
     * 模式列表
     */
    schemas: Array<{
        path: string;
        schema: VaeSchema;
    }>;
    /**
     * 新增模式
     */
    addSchema(path: string, schema: VaeSchema): void;
}

export declare type VaeSchemaRuntimeFn<T, S> = (payload: {
    value: T;
    schema: S;
}) => any;

export declare type VaeSchemaTransformPayload<T> = (value: T) => T;

export declare type VaeSchemaType = 'string' | 'number' | 'object' | 'date' | 'boolean' | 'array';

export declare interface VaeStringOfSchemaBuilder<O extends Record<any, any>> {
    <K extends DotPathWithRoot<O>, T extends DotPathWithRootValue<O, K> & string>(key: K, schema: (schema: VaeStringSchema<T>) => VaeStringSchema<T>, message?: VaeLocaleMessage): VaeStringSchema<T>;
    <K extends DotPathWithRoot<O>, T extends DotPathWithRootValue<O, K> & string>(key: K, message?: VaeLocaleMessage): VaeStringSchema<T>;
}

export declare class VaeStringSchema<T0 extends Nullable<string> = string> extends VaeSchema<T0> {
    constructor(message?: VaeLocaleMessage);
    /**
     * 最小长度
     */
    min(value: number, message?: VaeLocaleMessage): this;
    /**
     * 最大长度
     */
    max(value: number, message?: VaeLocaleMessage): this;
    /**
     * 固定长度
     */
    length(value: number, message?: VaeLocaleMessage): this;
    /**
     * 邮箱地址
     */
    email(message?: VaeLocaleMessage): this;
    /**
     * 链接
     */
    url(message?: VaeLocaleMessage): this;
    /**
     * 正则
     */
    regex(value: RegExp, message?: VaeLocaleMessage): this;
    /**
     * 包含
     */
    includes(value: string, message?: VaeLocaleMessage): this;
    /**
     * 前缀
     */
    startsWith(value: string, message?: VaeLocaleMessage): this;
    /**
     * 后缀
     */
    endsWith(value: string, message?: VaeLocaleMessage): this;
    /**
     * 手机号码
     */
    phoneNumber(message?: VaeLocaleMessage): this;
    /**
     * 身份证号码
     */
    idCardNumber(message?: VaeLocaleMessage): this;
    /**
     * cuid
     */
    cuid(message?: VaeLocaleMessage): this;
    /**
     * cuid2
     */
    cuid2(message?: VaeLocaleMessage): this;
    /**
     * 去除两侧空字符串
     */
    trim(): this;
    /**
     * 当设置了必填时，将空字符串视为已填
     */
    emptyable(): this;
}

export declare interface VaeStringSchemaBuilder {
    <T extends Nullable<string> = string>(schema: (schema: VaeStringSchema<T>) => VaeStringSchema<T>, message?: VaeLocaleMessage): VaeStringSchema<T>;
    <T extends Nullable<string> = string>(message?: VaeLocaleMessage): VaeStringSchema<T>;
}

export { }