import * as v from '@badrap/valita';
export * from '@badrap/valita';
/**
 * 'strip' allows unknown properties and removes unknown properties.
 * 'strict' errors if there are unknown properties.
 * 'passthrough' allows unknown properties.
 */
export type ParseOptionsMode = 'passthrough' | 'strict' | 'strip';
export declare function parse<T>(value: unknown, schema: v.Type<T>, mode?: ParseOptionsMode): T;
export declare function is<T>(value: unknown, schema: v.Type<T>, mode?: ParseOptionsMode): value is T;
export declare function assert<T>(value: unknown, schema: v.Type<T>, mode?: ParseOptionsMode): asserts value is T;
type Result<T> = {
    ok: true;
    value: T;
} | {
    ok: false;
    error: string;
};
export declare function test<T>(value: unknown, schema: v.Type<T>, mode?: ParseOptionsMode): Result<T>;
/**
 * Similar to {@link test} but works for AbstractTypes such as Optional.
 * This is for advanced usage. Prefer {@link test} unless you really need
 * to operate directly on an Optional field.
 */
export declare function testOptional<T>(value: unknown, schema: v.Type<T> | v.Optional<T>, mode?: ParseOptionsMode): Result<T | undefined>;
/**
 * Shallowly marks the schema as readonly.
 */
export declare function readonly<T extends v.Type>(t: T): v.Type<Readonly<v.Infer<T>>>;
export declare function readonlyObject<T extends Record<string, v.Type | v.Optional>>(t: T): v.ObjectType<Readonly<T>, undefined>;
export declare function readonlyArray<T extends v.Type>(t: T): v.Type<readonly v.Infer<T>[]>;
export declare function readonlyRecord<T extends v.Type>(t: T): v.Type<Readonly<Record<string, v.Infer<T>>>>;
declare const AbstractType: any;
export declare function instanceOfAbstractType<T = unknown>(obj: unknown): obj is v.Type<T> | v.Optional<T>;
type ObjectShape = Record<string, typeof AbstractType>;
/**
 * Similar to `ObjectType.partial()` except it recurses into nested objects.
 * Rest types are not supported.
 */
export declare function deepPartial<Shape extends ObjectShape>(s: v.ObjectType<Shape, undefined>): v.ObjectType<{ [K in keyof Shape]: v.Optional<v.Infer<Shape[K]>>; }, undefined>;
type Literal = string | number | bigint | boolean;
export declare function literalUnion<T extends [...Literal[]]>(...literals: T): v.Type<T[number]>;
//# sourceMappingURL=valita.d.ts.map