import { ParseParams, MakeErrorData } from '../parser';
import { ZodArray, ZodTransformer, ZodError } from '../index';
import { ZodOptionalType } from './optional';
import { ZodNullableType } from './nullable';
import { ZodCustomIssue } from '../ZodError';
export declare enum ZodTypes {
    string = "string",
    number = "number",
    bigint = "bigint",
    boolean = "boolean",
    date = "date",
    undefined = "undefined",
    null = "null",
    array = "array",
    object = "object",
    union = "union",
    intersection = "intersection",
    tuple = "tuple",
    record = "record",
    function = "function",
    lazy = "lazy",
    literal = "literal",
    enum = "enum",
    nativeEnum = "nativeEnum",
    promise = "promise",
    any = "any",
    unknown = "unknown",
    never = "never",
    void = "void",
    transformer = "transformer",
    optional = "optional",
    nullable = "nullable"
}
export declare type ZodTypeAny = ZodType<any, any>;
export declare type ZodRawShape = {
    [k: string]: ZodTypeAny;
};
export declare const inputSchema: (schema: ZodType<any, ZodTypeDef, any>) => ZodType<any, ZodTypeDef, any>;
export declare const outputSchema: (schema: ZodType<any, ZodTypeDef, any>) => ZodType<any, ZodTypeDef, any>;
declare type InternalCheck<T> = {
    check: (arg: T, ctx: {
        addIssue: (arg: MakeErrorData) => void;
    }) => any;
};
export interface ZodTypeDef {
    t: ZodTypes;
    checks?: InternalCheck<any>[];
    accepts?: ZodType<any, any>;
}
export declare type TypeOf<T extends ZodType<any>> = T['_output'];
export declare type input<T extends ZodType<any>> = T['_input'];
export declare type output<T extends ZodType<any>> = T['_output'];
export declare type infer<T extends ZodType<any>> = T['_output'];
export declare abstract class ZodType<Output, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
    readonly _type: Output;
    readonly _output: Output;
    readonly _def: Def;
    readonly _input: Input;
    parse: (x: unknown, params?: ParseParams) => Output;
    safeParse: (x: unknown, params?: ParseParams) => {
        success: true;
        data: Output;
    } | {
        success: false;
        error: ZodError;
    };
    parseAsync: (x: unknown, params?: ParseParams) => Promise<Output>;
    safeParseAsync: (x: unknown, params?: ParseParams) => Promise<{
        success: true;
        data: Output;
    } | {
        success: false;
        error: ZodError;
    }>;
    spa: (x: unknown, params?: ParseParams | undefined) => Promise<{
        success: true;
        data: Output;
    } | {
        success: false;
        error: ZodError;
    }>;
    is(u: Input): u is Input;
    check(u: unknown): u is Input;
    refine: <Func extends (arg: Output) => any>(check: Func, message?: string | Partial<Pick<ZodCustomIssue, "path" | "message" | "params">> | ((arg: Output) => Partial<Pick<ZodCustomIssue, "path" | "message" | "params">>)) => this;
    refinement: (check: (arg: Output) => any, refinementData: (Pick<import("..").ZodInvalidTypeIssue, "code" | "expected" | "received" | "message"> & {
        path?: (string | number)[] | undefined;
    }) | (Pick<import("..").ZodNonEmptyArrayIsEmptyIssue, "code" | "message"> & {
        path?: (string | number)[] | undefined;
    }) | (Pick<import("..").ZodUnrecognizedKeysIssue, "code" | "message" | "keys"> & {
        path?: (string | number)[] | undefined;
    }) | (Pick<import("..").ZodInvalidUnionIssue, "code" | "message" | "unionErrors"> & {
        path?: (string | number)[] | undefined;
    }) | (Pick<import("..").ZodInvalidLiteralValueIssue, "code" | "expected" | "message"> & {
        path?: (string | number)[] | undefined;
    }) | (Pick<import("..").ZodInvalidEnumValueIssue, "code" | "message" | "options"> & {
        path?: (string | number)[] | undefined;
    }) | (Pick<import("..").ZodInvalidArgumentsIssue, "code" | "message" | "argumentsError"> & {
        path?: (string | number)[] | undefined;
    }) | (Pick<import("..").ZodInvalidReturnTypeIssue, "code" | "message" | "returnTypeError"> & {
        path?: (string | number)[] | undefined;
    }) | (Pick<import("..").ZodInvalidDateIssue, "code" | "message"> & {
        path?: (string | number)[] | undefined;
    }) | (Pick<import("..").ZodInvalidStringIssue, "code" | "message" | "validation"> & {
        path?: (string | number)[] | undefined;
    }) | (Pick<import("..").ZodTooSmallIssue, "code" | "message" | "minimum" | "inclusive" | "type"> & {
        path?: (string | number)[] | undefined;
    }) | (Pick<import("..").ZodTooBigIssue, "code" | "message" | "inclusive" | "type" | "maximum"> & {
        path?: (string | number)[] | undefined;
    }) | (Pick<import("..").ZodInvalidIntersectionTypesIssue, "code" | "message"> & {
        path?: (string | number)[] | undefined;
    }) | (Pick<ZodCustomIssue, "code" | "message" | "params"> & {
        path?: (string | number)[] | undefined;
    }) | ((arg: Output) => MakeErrorData)) => this;
    _refinement: (refinement: InternalCheck<Output>['check']) => this;
    constructor(def: Def);
    abstract toJSON: () => object;
    optional: () => ZodOptionalType<this>;
    or: () => ZodOptionalType<this>;
    nullable: () => ZodNullableType<this>;
    array: () => ZodArray<this>;
    transform<This extends this, U extends ZodType<any>, Tx extends (arg: This['_output']) => U['_input'] | Promise<U['_input']>>(input: U, transformer: Tx): ZodTransformer<This, U>;
    transform<This extends this, Tx extends (arg: This['_output']) => This['_input'] | Promise<This['_input']>>(transformer: Tx): ZodTransformer<This, This>;
    default: <T extends Output = Output, Opt extends ReturnType<this['optional']> = ReturnType<this['optional']>>(def: T) => ZodTransformer<Opt, this>;
    isOptional: () => boolean;
    isNullable: () => boolean;
}
export {};