/**
 *
 */
export declare type Failure<I> = Readonly<{
    type: 'failure';
    reason: string;
    value: I;
}>;
export declare type Success<O> = Readonly<{
    type: 'success';
    value: O;
}>;
export declare type Result<O, I = any> = Failure<I> | Success<O>;
export declare type Parser<O, I = any> = (value: I) => Result<O, I>;
export declare type SuccessType<T> = T extends Result<unknown, infer U> ? Success<U> : never;
export declare type FailureType<T> = T extends Result<infer U, unknown> ? Failure<U> : never;
export declare type ResultType<T> = T extends Parser<infer O, infer I> ? Result<O, I> : never;
export declare type ParserType<T> = T extends Parser<infer U, unknown> ? U : never;
export declare function optional<O, I = any>(validator: Parser<O, I>): Parser<(null | O), I>;
export declare function voidable<O, I = any>(validator: Parser<O, I>): Parser<(undefined | O), I>;
export declare function isString<I = any>(value: I): Result<string, I>;
export declare function isNumber<I = any>(value: I): Result<number, I>;
export declare function isUndefined<I = any>(value: I): Result<undefined, I>;
export declare function isBoolean<I = any>(value: I): Result<boolean, I>;
export declare function isAnyValue<I = any>(value: I): Success<any>;
export declare function isObject<I = any>(value: I): Result<{
    [key: string]: any;
}, I>;
export declare function isArray<O, I = any>(value: I): Result<O[], I>;
export declare function objectOf<T extends {
    [key: string]: any;
}, I = any>(validators: {
    [K in keyof T]: Parser<T[K], I>;
}): Parser<T, I>;
export declare function indexedObjectOf<I, T>(parser: Parser<T, any>): Parser<{
    [key: string]: T;
}, I>;
export declare function mapParser<A, B, I = any>(validator: Parser<A, I>, next: (value: A) => Result<B, I>): Parser<B, I>;
export declare function mapFailure<A, B, I = any>(result: Result<A, I>, next: (failure: Failure<I>) => B): (B | Success<A>);
export declare function mapSuccess<A, B, I = any>(result: Result<A, I>, next: (value: A) => B): (B | Failure<I>);
export declare function mapResult<A, B, C, I = any>(result: Result<A, I>, success: (value: A) => B, failure: (failure: Failure<I>) => C): (B | C);
export declare function arrayOf<O, I = any>(validator: Parser<O, I>): Parser<O[], I>;
export declare function oneOf<O, I, V extends Array<Parser<any, any>>>(parser: Parser<O, I>, ...parsers: V): Parser<(ParserType<V[number]> | O), I>;
export declare function isExactly<S extends (string | number | boolean), I = any>(option: S): Parser<S, I>;
export declare function success<T>(value: T): Success<T>;
export declare function failure<T>(value: T, reason: string): Failure<T>;
export declare function isSuccess<O, I = any>(result: Result<O, I>): result is Success<O>;
export declare function isFailure<O, I = any>(result: Result<O, I>): result is Failure<I>;
//# sourceMappingURL=parse.d.ts.map