import { type DecodeContext, type RTError, Type } from './type.js';
import { type Result } from './utils.js';
export declare class ConstantType<T> extends Type<T> {
    value: T;
    constructor(value: T);
    print(): string;
    decode(u: unknown, _opts: DecodeContext): import("./utils.js").Err<RTError> | import("./utils.js").Ok<T>;
    validate(v: T, opts: DecodeContext): Promise<Result<T, RTError>>;
    validateSync(v: T, opts: DecodeContext): Result<T, RTError>;
}
export declare const undefinedValue: ConstantType<undefined>;
export declare const nullValue: ConstantType<null>;
export declare const trueValue: ConstantType<true>;
export declare const falseValue: ConstantType<false>;
export declare class StringType extends Type<string> {
    print(): string;
    decode(u: unknown, opts: DecodeContext): Result<string, RTError>;
    validate(v: string, opts: DecodeContext): Promise<Result<string, RTError>>;
    validateSync(v: string, opts: DecodeContext): Result<string, RTError>;
    in(...list: string[]): this;
    length(minLen: number, maxLen?: number): this;
    minLength(len: number): this;
    maxLength(len: number): this;
    matches(pattern: RegExp): this;
    email(): this;
}
export declare const string: StringType;
export declare class NumberType extends Type<number> {
    print(): string;
    decode(u: unknown, opts: DecodeContext): Result<number, RTError>;
    validate(v: number, opts: DecodeContext): Promise<Result<number, RTError>>;
    validateSync(v: number, opts: DecodeContext): Result<number, RTError>;
    in(...list: number[]): this;
    integer(): this;
    min(min: number): this;
    max(max: number): this;
    between(min: number, max: number): this;
}
export declare const number: NumberType;
export declare class IntegerType extends NumberType {
    print(): string;
    decode(u: unknown, opts: DecodeContext): import("./utils.js").Err<RTError> | import("./utils.js").Ok<number>;
}
export declare const integer: IntegerType;
export declare const id: IntegerType;
export declare class BooleanType extends Type<boolean> {
    print(): string;
    decode(u: unknown, opts: DecodeContext): Result<boolean, RTError>;
    validate(v: boolean, opts: DecodeContext): Promise<Result<boolean, RTError>>;
    validateSync(v: boolean, opts: DecodeContext): Result<boolean, RTError>;
    true(): this;
    false(): this;
}
export declare const boolean: BooleanType;
export declare class DateType extends Type<Date> {
    print(): string;
    decode(u: unknown, opts: DecodeContext): Result<Date, RTError>;
    validate(v: Date, opts: DecodeContext): Promise<Result<Date, RTError>>;
    validateSync(v: Date, opts: DecodeContext): Result<Date, RTError>;
}
export declare const date: DateType;
export declare class AnyType extends Type<any> {
    print(): string;
    decode(u: unknown, _opts: DecodeContext): Result<any, RTError>;
    validate(v: any, opts: DecodeContext): Promise<Result<any, RTError>>;
    validateSync(v: any, opts: DecodeContext): Result<any, RTError>;
}
export declare const any: AnyType;
export declare class UnknownType extends Type<unknown> {
    print(): string;
    decode(u: unknown, _opts: DecodeContext): import("./utils.js").Ok<unknown>;
    validate(v: unknown, opts: DecodeContext): Promise<Result<unknown, RTError>>;
    validateSync(v: unknown, opts: DecodeContext): Result<unknown, RTError>;
}
export declare const unknown: UnknownType;
export declare class DefinedType extends Type<{}> {
    print(): string;
    decode(u: unknown, _opts: DecodeContext): import("./utils.js").Err<RTError> | import("./utils.js").Ok<{}>;
    validate(v: {}, opts: DecodeContext): Promise<Result<{}, RTError>>;
    validateSync(v: {}, opts: DecodeContext): Result<{}, RTError>;
}
export declare const defined: DefinedType;
export declare class UnknownObjectType extends Type<object> {
    print(): string;
    decode(u: unknown, _opts: DecodeContext): import("./utils.js").Err<RTError> | import("./utils.js").Ok<object>;
    validate(v: object, opts: DecodeContext): Promise<Result<object, RTError>>;
    validateSync(v: object, opts: DecodeContext): Result<object, RTError>;
}
export declare const unknownObject: UnknownObjectType;
export declare class BigIntType extends Type<bigint> {
    print(): string;
    decode(u: unknown, opts: DecodeContext): Result<bigint, RTError>;
    validate(v: bigint, opts: DecodeContext): Promise<Result<bigint, RTError>>;
    validateSync(v: bigint, opts: DecodeContext): Result<bigint, RTError>;
    min(min: bigint): this;
    max(max: bigint): this;
    between(min: bigint, max: bigint): this;
    positive(): this;
    negative(): this;
    nonNegative(): this;
}
export declare const bigint: BigIntType;
export declare class SymbolType extends Type<symbol> {
    print(): string;
    decode(u: unknown, _opts: DecodeContext): import("./utils.js").Err<RTError> | import("./utils.js").Ok<symbol>;
    validate(v: symbol, opts: DecodeContext): Promise<Result<symbol, RTError>>;
    validateSync(v: symbol, opts: DecodeContext): Result<symbol, RTError>;
}
export declare const symbol: SymbolType;
export declare class VoidType extends Type<void> {
    print(): string;
    decode(u: unknown, _opts: DecodeContext): import("./utils.js").Err<RTError> | import("./utils.js").Ok<undefined>;
    validate(v: undefined, opts: DecodeContext): Promise<Result<void, RTError>>;
    validateSync(v: undefined, opts: DecodeContext): Result<void, RTError>;
}
export declare const voidType: VoidType;
export declare class NeverType extends Type<never> {
    print(): string;
    decode(_u: unknown, _opts: DecodeContext): Result<never, RTError>;
    validate(_v: never, _opts: DecodeContext): Promise<Result<never, RTError>>;
    validateSync(_v: never, _opts: DecodeContext): Result<never, RTError>;
}
export declare const never: NeverType;
type Scalar = boolean | number | string;
export declare class LiteralType<T extends ReadonlyArray<Scalar>> extends Type<T[number]> {
    values: T;
    constructor(values: T);
    print(): string;
    decode(u: unknown, _opts: DecodeContext): import("./utils.js").Err<RTError> | import("./utils.js").Ok<T[number]>;
    validate(v: T[number], opts: DecodeContext): Promise<Result<T[number], RTError>>;
    validateSync(v: T[number], opts: DecodeContext): Result<T[number], RTError>;
    in(...list: T[number][]): this;
}
export declare function literal<const T extends ReadonlyArray<Scalar>>(...values: T): LiteralType<T>;
export {};