import type { ParjserDebugFunction } from "./parser";
import type { FailureInfo, ParjsResult } from "./result";
import type { ParsingState, UserState } from "./state";
import type { ImplicitParjser } from "./wrap-implicit";
/** A combinator or operator that takes a source parser that returns a new parser based on it. */
export interface ParjsCombinator<TFrom, TTo> {
    (from: ImplicitParjser<TFrom>): Parjser<TTo>;
}
/** A projection on the parser result and the parser state. */
export interface ParjsProjection<T, TOut> {
    (value: T, userState: UserState): TOut;
}
/**
 * A predicate on the parser result and the user state. This function must return `true` if the
 * input fulfills the predicate, or failure information object if it does not. Returning things
 * other than `true` will make it behave like a failure.
 */
export type ParjsValidator<T> = ParjsProjection<T, Partial<FailureInfo> | true>;
/**
 * Interface for parsers that produce result values of type {T}
 *
 * @group functional
 */
export interface Parjser<out T> {
    apply(ps: ParsingState): void;
    readonly expecting: string;
    /**
     * Exposes the display name of the parser. Userful when debugging.
     *
     * @group informational
     */
    readonly type: string;
    /**
     * Applies `this` on the given input string.
     *
     * @param input The input string.
     * @param initialState An object containing properties that are merged with this parse
     *   invocation's user state.
     * @group action
     */
    parse(input: string, initialState?: UserState): ParjsResult<T>;
    /**
     * The chaining or piping operator. Applies a sequence of combinators to this parser, feeding
     * the result of one into the input of the next.
     *
     * @param cmb1 The single combinator to apply.
     */
    pipe<const T1>(cmb1: ParjsCombinator<T, T1>): Parjser<T1>;
    /**
     * The chaining or piping operator. Applies a sequence of combinators to this parser, feeding
     * the result of one into the input of the next.
     *
     * @param cmb1 The first combinator to apply.
     * @param cmb2 The second combinator to apply.
     */
    pipe<const T1, const T2>(cmb1: ParjsCombinator<T, T1>, cmb2: ParjsCombinator<T1, T2>): Parjser<T2>;
    /**
     * The chaining or piping operator. Applies a sequence of combinators to this parser, feeding
     * the result of one into the input of the next.
     *
     * @param cmb1 The first combinator to apply.
     * @param cmb2 The second combinator to apply.
     * @param cmb3 The third combinator to apply.
     */
    pipe<const T1, const T2, const T3>(cmb1: ParjsCombinator<T, T1>, cmb2: ParjsCombinator<T1, T2>, cmb3: ParjsCombinator<T2, T3>): Parjser<T3>;
    /**
     * The chaining or piping operator. Applies a sequence of combinators to this parser, feeding
     * the result of one into the input of the next.
     *
     * @param cmb1 The first combinator to apply.
     * @param cmb2 The second combinator to apply.
     * @param cmb3 The third combinator to apply.
     * @param cmb4 The fourth combinator to apply.
     */
    pipe<const T1, const T2, const T3, const T4>(cmb1: ParjsCombinator<T, T1>, cmb2: ParjsCombinator<T1, T2>, cmb3: ParjsCombinator<T2, T3>, cmb4: ParjsCombinator<T3, T4>): Parjser<T4>;
    /**
     * The chaining or piping operator. Applies a sequence of combinators to this parser, feeding
     * the result of one into the input of the next.
     *
     * @param cmb1 The first combinator to apply.
     * @param cmb2 The second combinator to apply.
     * @param cmb3 The third combinator to apply.
     * @param cmb4 The fourth combinator to apply.
     * @param cmb5 The fifth combinator to apply.
     */
    pipe<const T1, const T2, const T3, const T4, const T5>(cmb1: ParjsCombinator<T, T1>, cmb2: ParjsCombinator<T1, T2>, cmb3: ParjsCombinator<T2, T3>, cmb4: ParjsCombinator<T3, T4>, cmb5: ParjsCombinator<T4, T5>): Parjser<T5>;
    /**
     * The chaining or piping operator. Applies a sequence of combinators to this parser, feeding
     * the result of one into the input of the next.
     *
     * @param cmb1 The first combinator to apply.
     * @param cmb2 The second combinator to apply.
     * @param cmb3 The third combinator to apply.
     * @param cmb4 The fourth combinator to apply.
     * @param cmb5 The fifth combinator to apply.
     * @param cmb6 The sixth combinator to apply.
     */
    pipe<const T1, const T2, const T3, const T4, const T5, const T6>(cmb1: ParjsCombinator<T, T1>, cmb2: ParjsCombinator<T1, T2>, cmb3: ParjsCombinator<T2, T3>, cmb4: ParjsCombinator<T3, T4>, cmb5: ParjsCombinator<T4, T5>, cmb6: ParjsCombinator<T5, T6>): Parjser<T6>;
    /**
     * Returns a copy of this, but with the given default error message.
     *
     * @param message Description of the input.
     */
    expects(message: string): Parjser<T>;
    /**
     * Returns this parser unchanged, but logs the result of the parse to the console. This is
     * useful for debugging.
     */
    debug(fn?: ParjserDebugFunction): Parjser<T>;
}
//# sourceMappingURL=parjser.d.ts.map