type Map<Input = any, Output = any> = (result: Input, index: number, source: string) => Output;
/** The result of a parsing action */
export type ParserState<Result = any> = {
    /** The intial source value being parsed */
    source: string;
    /** Offset (in chars - not glyphs) where the last result was found */
    index: number;
    /** The result of the last succedeed parsing action */
    result: Result;
    /** Wether the parser produced an error */
    isError: false;
    /** The error produced by the parser */
    error: null;
};
/** The error reporting state of a parsing action */
export type ParserError<Result = any, Error = any> = {
    /** The intial source value being parsed */
    source: string;
    /** Offset (in chars - not glyphs) where the last result was found */
    index: number;
    /** The result of the last succedeed parsing action */
    result: Result;
    /** Wether the parser produced an error */
    isError: true;
    /** The error produced by the parser */
    error: Error;
};
export type ParserOutput<Result = any, Error = any> = ParserState<Result> | ParserError<Result, Error>;
export type ParserStateHandler<OutResult = any, OutError = any, InResult = any> = (state: ParserState<InResult>) => ParserOutput<OutResult, OutError>;
export type ParserErrorHandler<OutError = any, InError = any> = (state: ParserError<InError>) => ParserError<OutError>;
export type ParserHandler<OutResult = any, OutError = any, InResult = any, InError = any> = (state: ParserOutput<InResult, InError>) => ParserOutput<OutResult, OutError>;
export type SourceParser<Result = any, Error = any> = (source: string) => ParserOutput<Result, Error>;
export type Parser<OutResult = any, OutError = any, InResult = any, InError = any> = ParserHandler<OutResult, OutError, InResult, InError> & SourceParser<OutResult, OutError> & {
    /** Wether the parse operates at binary level */
    readonly isBinary: false;
    /**
     * Map the result of the parser into another result
     * @param callback a callback that produces a new result from the precedent
     * @return a new parser function which produces a new typed action
     */
    map<T>(callback: Map<OutResult, T>): Parser<T, OutError, InResult, InError>;
    /**
     * Map the error of the parser into another error. This method is the
     * equivalent of map but it will be performed only for error states
     * @param callback a callback that produces a new error from the precedent
     * @return a new parser function which produces a new typed error
     */
    error<E>(callback: Map<OutError, E>): Parser<OutResult, E, InResult, InError>;
    /**
     * Chain this parser to another parser. The callback function will
     * choose each time which parser will be chained depending on the
     * current parser state. This method is similar to a flatMap operation,
     * where the returned parser is used to produce a new updated state.
     * @param callback the function which decide which parser to employ
     *                  after the current one
     * @return a new chained parser
     */
    chain<OR, OE>(callback: Map<OutResult, Parser<OR, OE, OutResult, OutError>>): Parser<OR, OE, OutResult, OutError>;
};
type BinMap<Input = any, Output = any> = (result: Input, index: number, source: DataView) => Output;
/** The result of a binary parsing action */
export type BinaryParserState<Result = any> = {
    /** The intial source value being parsed */
    source: DataView;
    /** Offset (in bits - not bytes) where the last result was found */
    index: number;
    /** The result of the last succedeed parsing action */
    result: Result;
    /** Wether the parser produced an error */
    isError: false;
    /** The error produced by the parser */
    error: null;
};
/** The error reporting state of a binary parsing action */
export type BinaryParserError<Result = any, Error = any> = {
    /** The intial source value being parsed */
    source: DataView;
    /** Offset (in bits - not bytes) where the last result was found */
    index: number;
    /** The result of the last succedeed parsing action */
    result: Result;
    /** Wether the parser produced an error */
    isError: true;
    /** The error produced by the parser */
    error: Error;
};
export type BinaryParserOutput<Result = any, Error = any> = BinaryParserState<Result> | BinaryParserError<Result, Error>;
export type BinaryParserStateHandler<OutResult = any, OutError = any, InResult = any> = (state: BinaryParserState<InResult>) => BinaryParserOutput<OutResult, OutError>;
export type BinaryParserErrorHandler<OutError = any, InError = any> = (state: BinaryParserError<InError>) => BinaryParserError<OutError>;
export type BinaryParserHandler<OutResult = any, OutError = any, InResult = any, InError = any> = (state: BinaryParserOutput<InResult, InError>) => BinaryParserOutput<OutResult, OutError>;
export type BinarySourceParser<Result = any, Error = any> = (source: string) => BinaryParserOutput<Result, Error>;
export type BinaryParser<OutResult = any, OutError = any, InResult = any, InError = any> = BinaryParserHandler<OutResult, OutError, InResult, InError> & BinarySourceParser<OutResult, OutError> & {
    /** Wether the parse operates at binary level */
    readonly isBinary: true;
    /**
     * Map the result of the binary parser into another result
     * @param callback a callback that produces a new result from the precedent
     * @return a new binary parser function which produces a new typed action
     */
    map<T>(callback: BinMap<OutResult, T>): BinaryParser<T, OutError, InResult, InError>;
    /**
     * Map the error of the binaryparser into another error. This method is the
     * equivalent of map but it will be performed only for error states
     * @param callback a callback that produces a new error from the precedent
     * @return a new binaryparser function which produces a new typed error
     */
    error<E>(callback: BinMap<OutError, E>): BinaryParser<OutResult, E, InResult, InError>;
    /**
     * Chain this binary parser to another parser. The callback function will
     * choose each time which binary parser will be chained depending on the
     * current binary parser state. This method is similar to a flatMap operation,
     * where the returned binary parser is used to produce a new updated state.
     * @param callback the function which decide which binary parser to employ
     *                  after the current one
     * @return a new chained binary parser
     */
    chain<OR, OE>(callback: BinMap<OutResult, BinaryParser<OR, OE, OutResult, OutError>>): BinaryParser<OR, OE, OutResult, OutError>;
};
export declare namespace state {
    function ok<Input, Output>(state: ParserState<Input>, result: Output, index?: number): ParserState<Output>;
    function ok<Input, Output>(state: BinaryParserState<Input>, result: Output, index?: number): BinaryParserState<Output>;
    function error<Input, Output>(state: ParserOutput<Input, any>, error: Output): ParserError<Input, Output>;
    function error<Input, Output>(state: BinaryParserOutput<Input, any>, error: Output): BinaryParserError<Input, Output>;
}
/**
 * Create a parser out of a production function
 * @param handler the production function which can return a state or an error
 * @param error the function which will catch and elaborates errors produced by precedent operations
 * @returns a compiled perser
 */
export declare function parser<OutResult = any, OutError = any, InResult = any, InError = any>(handler: ParserStateHandler<OutResult, OutError, InResult>, error?: ParserErrorHandler<OutError, InError>): Parser<OutResult, OutError, InResult, InError>;
type Binariable = string | number[] | DataView | ArrayBuffer | ArrayBufferLike;
/**
 * Create a binary parser out of a production function
 * @param handler the production function which can return a binary state or an error
 * @param error the function which will catch and elaborates errors produced by precedent operations
 * @returns a compiled perser
 */
export declare function binary<OutResult = any, OutError = any, InResult = any, InError = any>(handler: BinaryParserStateHandler<OutResult, OutError, InResult>, error?: BinaryParserErrorHandler<OutError, InError>): BinaryParser<OutResult, OutError, InResult, InError>;
/**
 * Create a parser which check if the current state
 * matches the given regular expression. The expression
 * will be matched just at the start of the current state
 * @param expression the regular expression to match
 * @return a parser which check if the current state starts with the
 *          given regular expression
 */
export declare function match(expression: RegExp): Parser<string, string>;
/**
 * Create a parser which check if the current state
 * matches the given regular expression. The expression
 * will be matched just at the start of the current state.
 * The `matcher` function will be responsible to extract
 * the parser state out of the regex match result
 * @param expression the regular expression to match
 * @param matcher the function which extracts the parser state
 * @return a parser which check if the current state starts with the
 *          given regular expression
 */
export declare function match<T = string>(expression: RegExp, matcher: (match: RegExpMatchArray) => T): Parser<T, string>;
/**
 * Create a parser which check if the current state
 * starts with the given string expression. It is possible
 * to ignore case during the comparison.
 * @param expression the string expression to match
 * @param ignoreCase wheter to ignore case during the comparison (default: `false`)
 * @return a parser which check if the current state starts with the
 *          given string
 */
export declare function match<T extends string>(expression: T, ignoreCase?: false | undefined): Parser<T, string>;
/**
 * Create a parser which check if the current state
 * starts with the given string expression. It is possible
 * to ignore case during the comparison.
 * @param expression the string expression to match
 * @param ignoreCase wheter to ignore case during the comparison (default: `false`)
 * @return a parser which check if the current state starts with the
 *          given string
 */
export declare function match(expression: string, ignoreCase?: boolean): Parser<string, string>;
/** A parser which check for any letter in the range a-z (case insnsitive) */
export declare const letters: Parser<string, string, any, any>;
/** A parser which check for any digit in the range 0-9 */
export declare const digits: Parser<string, string, any, any>;
/** A parser which check for any white space */
export declare const spaces: Parser<string, string, any, any>;
/** A parser which check the end of the input */
export declare const eof: Parser<any, string, any, any>;
/** A parser which check the end of the input */
export declare const eoi: Parser<any, string, any, any>;
/** A parser which check the end of the input */
export declare const end: Parser<any, string, any, any>;
type SequenceOfParsersResult<Parsers extends Parser[]> = Parsers extends [] ? [] : Parsers extends [Parser<infer OR>] ? [OR] : Parsers extends [Parser<infer OR1, infer OE1>, ...infer Rest1] ? Rest1 extends [Parser<infer OR2, any, OR1, OE1>, ...infer Rest2] ? Rest2 extends Parser[] ? [OR1, OR2, ...SequenceOfParsersResult<Rest2>] : never : never : Parser extends Parser<infer OR>[] ? OR[] : never;
type SequenceOfParsersError<Parsers extends Parser[]> = Parsers extends [] ? never : Parsers extends [Parser<any, infer OE>] ? OE : Parsers extends [Parser<infer OR1, infer OE1>, ...infer Rest1] ? Rest1 extends [Parser<any, infer OE2, OR1, OE1>, ...infer Rest2] ? Rest2 extends Parser[] ? OE1 | OE2 | SequenceOfParsersError<Rest2> : never : never : Parser extends Parser<any, infer OE>[] ? OE : never;
type SequenceOfParsers<Parsers extends Parser[]> = SequenceOfParsersResult<Parsers> extends never ? never : SequenceOfParsersError<Parsers> extends never ? never : Parser<SequenceOfParsersResult<Parsers>, SequenceOfParsersError<Parsers>, any, any>;
/**
 * Create a parser which check the concatenation in
 * sequence of the given parsers
 * @param parsers an array of parsers to concatenate
 * @return a parser that is the concatenation in a sequence
 *          of the given parsers
 */
export declare function sequence<Parsers extends Parser[]>(parsers: Parsers): SequenceOfParsers<Parsers>;
/**
 * Create a parser which check the concatenation in
 * sequence of the given parsers
 * @param parsers parsers to concatenate
 * @return a parser that is the concatenation in a sequence
 *          of the given parsers
 */
export declare function sequence<Parsers extends Parser[]>(...parsers: Parsers): SequenceOfParsers<Parsers>;
type OneOf<Args extends any[]> = Args extends [] ? never : Args extends [infer X] ? X : Args extends [infer X, ...infer Rest] ? X | OneOf<Rest> : Args extends (infer X)[] ? X : never;
type ParserOneOf<Parsers extends Parser[]> = SequenceOfParsersResult<Parsers> extends never ? never : SequenceOfParsersError<Parsers> extends never ? never : Parser<OneOf<SequenceOfParsersResult<Parsers>>, SequenceOfParsersError<Parsers>, any, any>;
/**
 * Create a parser which returns the first success state
 * from any given parsers.
 * @param parsers an array of parsers to test
 * @return a parser which test the given parsers
 */
export declare function oneOf<Parsers extends Parser[]>(parsers: Parsers): ParserOneOf<Parsers>;
/**
 * Create a parser which returns the first success state
 * from any given parsers.
 * @param parsers parsers to test
 * @return a parser which test the given parsers
 */
export declare function oneOf<Parsers extends Parser[]>(...parsers: Parsers): ParserOneOf<Parsers>;
type ManyOf<P> = P extends Parser<infer OR, infer OE, infer IR, infer IE> ? Parser<OR[], OE, IR, IE> : never;
/**
 * Create a parser which tries to match the given parser
 * as many times as possible
 * @param parser the parser to test
 * @returns a parser which tries to match the given parser
 *              as many times as possible
 */
export declare function many<P extends Parser>(parser: P): ManyOf<P>;
/**
 * Create a parser which match at least one time,
 * then as many times as possible, the given parser
 * @param parser the parser to test
 * @returns a parser which match at least one time,
 *          then as many times as possible, the given parser
 */
export declare function oneOrMore<P extends Parser>(parser: P): ManyOf<P>;
/**
 * Create a parser which match the given parser
 * the given number of times
 * @param parser the parser to test
 * @param times how many exact times the parser must match
 * @returns a parser which match the given parser
 *          the given number of times
 */
export declare function times<P extends Parser>(parser: P, times: number): ManyOf<P>;
/**
 * Create a parser which check the following syntax:
 * `wrapper content wrapper` from the given parsers.
 * The resultant parser will consider only the output of the
 * content parser.\
 * For example, to parse a string you can use `between(match('"'), contentParser)`
 * @param wrapper the wrapper parser to match before and after the content
 * @param content the parser responsible to match the content
 * @return a parser which consider only the wrapped content
 */
export declare function between<OR = any, OE = any, IR = any, IE = any>(wrapper: Parser<OR, OE, IR, IE>, content: Parser<IR, IE, OR, OE>): Parser<OR, OE, IR, IE>;
/**
 * Create a parser which check the following syntax:
 * `left content rigth` from the given parsers.
 * The resultant parser will consider only the output of the
 * content parser.\
 * For example, to parse an array you can use `between(match('['), valueParser, match(']'))`
 * @param left the parser to match before the content
 * @param content the parser responsible to match the content
 * @param right the parser to match after the content
 * @return a parser which consider only the wrapped content
 */
export declare function between<OR1 = any, OE1 = any, IR1 = any, IE1 = any, OR2 = any, OE2 = any, OR3 = any, OE3 = any>(left: Parser<OR1, OE1, IR1, IE1>, content: Parser<OR2, OE2, OR1, OE1>, right: Parser<OR3, OE3, OR2, OE2>): Parser<OR3, OE3, OR2, OE2>;
/**
 * Generate an high-order function which creates a
 * between expression for a parser. This function
 * returns another function which takes the content
 * parser as argument and generate a parser which will
 * match the following syntax: `wrapper content wrapper`.
 * The resultant parser will consider only the output of the
 * content parser.\
 * For example, to parse a string you can use
 * ```js
 * const contentParser = letters; // or whatever
 * const betweenQuotes = parsebetween(match('"'));
 * const stringParser = betweenQuotes(contentParser);
 * ```
 * @param wrapper the wrapper parser to match before and after the content
 * @return an high-order function which generate a between parser expression
 */
export declare function parseBetween<OR = any, OE = any, IR = any, IE = any>(wrapper: Parser<OR, OE, IR, IE>): (content: Parser<IR, IE, OR, OE>) => Parser<OR, OE, IR, IE>;
/**
 * Generate an high-order function which creates a
 * between expression for a parser. This function
 * returns another function which takes the content
 * parser as argument and generate a parser which will
 * match the following syntax: `left content right`.
 * The resultant parser will consider only the output of the
 * content parser.\
 * For example, to parse a simple numeric array you can use:
 * ```js
 * const contentParser = sequence(digits, match(',')); // or whatever
 * const betweenBrackets = parsebetween(match('['));
 * const arrayParser = betweenBrackets(contentParser);
 * ```
 * @param left the parser to match before the content
 * @param right the parser to match after the content
 * @return an high-order function which generate a between parser expression
 */
export declare function parseBetween<OR1, OE1 = any, IR1 = any, IE1 = any, OR2 = any, OE2 = any, OR3 = any, OE3 = any>(left: Parser<OR1, OE1, IR1, IE1>, right: Parser<OR3, OE3, OR2, OE2>): (content: Parser<OR2, OE2, OR1, OE1>) => Parser<OR3, OE3, OR2, OE2>;
/**
 * Generate a parser which tries to match one or more
 * times the following syntax: `(content separator)* content`.
 * The resultant parser will consider only the output of
 * the content parser.\
 * For example, to parse a comma-separated list you can use:
 * `separated(match(','), contentPasrer)`.
 * @param separator the parser that matches separator
 * @param content the parser that match the content
 * @returns a parser which generate a separated expression
 */
export declare function separated<OR1 = any, OE1 = any, IE1 = any, OR2 = any, OE2 = any, IE2 = any>(separator: Parser<OR1, OE1, OR2, IE1>, content: Parser<OR2, OE2, OR1, IE2>): Parser<OR2[], OE2, OR1, IE2>;
/**
 * Generate an high-order function which creates a
 * separated expression for a parser. This function
 * returns another function which takes the content
 * parser as argument and generate a parser which will
 * match the following syntax: `(content separator)* content`.
 * The resultant parser will consider only the output of the
 * content parser.\
 * For example, to parse a comma-separated list you can use:
 * ```js
 * const contentParser = letters; // or whatever
 * const commaSeparated = parseSeparated(match(','));
 * const commaSeparatedParser = commaSeparated(contentParser);
 * ```
 * @param separator the parser that matches separator
 * @return an high-order function which generate a between parser expression
 */
export declare function parseSeparated<OR1, OE1, IR1, IE1>(separator: Parser<OR1, OE1, IR1, IE1>): <OR, OE, IE>(content: Parser<OR, OE, OR1, IE>) => Parser<OR[], OE, OR1, IE>;
/**
 * Generate a parser which will use the given thunk lazily.
 * This is helpful if you need to use parsers which depends one
 * on the other:
 * ```js
 * const parserA = lazy(() => sequence([ parserB, digits, parserB ]));
 * const parserB = lazy(() => oneOf([ parserA, digits, letters ]));
 * ```
 * @param thunk the lazy evaluated function which produce a parser
 * @param notCached wether to cache or not the output of the thunk (default: `false --> cached`)
 * @returns a parser which evaluates lazily the given thunk
 */
export declare function lazy<P extends Parser>(thunk: () => P, notCached?: boolean): P;
/**
 * Create a parser which always produces an error state
 * @param message the message of the error state
 * @returns a failure parser
 */
export declare function fail<E>(message: E): Parser<any, E>;
/**
 * Create a parser which always produces a success parser state
 * @param value the result value of the success state
 * @returns a success parser
 */
export declare function success<T>(value: T): Parser<T>;
type ContextualOneOf<P extends Parser> = P extends Parser<infer R> ? R : P extends Parser<infer R> | infer Rest ? Rest extends Parser ? ContextualOneOf<Rest> extends never ? never : R | ContextualOneOf<Rest> : never : never;
type ContextualCB<P extends Parser, R> = () => Generator<P, ContextualOneOf<P> | R, ContextualOneOf<P> | R>;
/**
 * Create a parser which automatically chain the parsers produced
 * by a generator function, yielding their parserd results states.\
 * For example:
 * ```js
 * const declTypeParser = combo.oneOf(
 *  combo.match('VAR '),
 *  combo.match('GLOBAL_VAR ')
 * );
 * const typeParser = combo.oneOf(
 *  combo.match(' INT '),
 *  combo.match(' STRING '),
 *  combo.match(' BOOL ')
 * ).map(v => v.trim().toLowerCase());
 * const stringParser = combo.between(combo.match('"'), combo.letters);
 * const numParser = combo.digits.map(Number);
 * const boolParser = combo.oneOf(combo.match('true'), combo.match('false')).map(v => v === 'true');
 * const parser = combo.contextual(function*() { // Note that we use a generator function here
 *  const declarationType = yield declTypeParser; // yielding parser => returning 'var' | 'global_var'
 *  const varName = yield combo.letters; // returning string
 *  const type = yield typeParser; // returning 'int' | 'string' | 'bool'
 *  let data;
 *  switch (type) {
 *      case 'int': data = yield numParser; break;
 *      case 'string': data = yield stringParser; break;
 *      case 'bool': data = yield boolParser; break;
 *  }
 *  return { varName: varName, data, type: type.trim().toLowerCase(), declarationType: declarationType.trim().toLowerCase() };
 * });
 * parser('VAR theAnswer INT 42'); // { varName: 'theAnswer', data: 42, type: 'int', declarationType: 'var' }
 * parser('GLOBAL_VAR greeting STRING "Hello"'); // { varName: 'greetubg', data: 'Hello', type: 'string', declarationType: 'global_var' }
 * parser('VAR skyIsBlue BOOL true'); // { varName: 'skyIsBlue', data: true, type: 'bool', declarationType: 'var' }
 * ```
 * @param generator the function that generates the parsers to chain
 * @returns a automatically chained parser
 */
export declare function contextual<P extends Parser = Parser, R = any>(generator: ContextualCB<P, R>): Parser<R>;
export declare namespace binary {
    /**
     * Create a binary parser which check if the current state
     * starts with the given binary expression
     * @param expression the string expression to match
     * @param expressionOffset the offset where the considered expression starts
     * @param expressionLength the length of considered expression
     * @return a binary parser which check if the current state starts with the given bianry expression
     */
    export function match(expression: Binariable, expressionOffset?: number, expressionLength?: number): BinaryParser<DataView, string>;
    /** A binary parser which consumes a buffer bit by bit */
    export const bit: BinaryParser<0 | 1, string>;
    /** A binary parser which consume a buffer bit by bit, expecting an unsetted bit (0) */
    export const zero: BinaryParser<0, string>;
    /** A binary parser which consume a buffer bit by bit, expecting a setted bit (1) */
    export const one: BinaryParser<1, string>;
    /**
     * Create a binary parser which read an unsigned integer from
     * a fixed number of bits into a {@link Number}. The number of bits must not exceed
     * 32. For integers longer than 32 bits use {@link biguint}
     * @param bits the number of bits to read (1 <= bits <= 32)
     * @param bigEndian wether to read the number in Big Endian or Little Endian mode
     * @returns a binary parser which read an unsigned integer with the given specs
     */
    export function uint(bits: number, bigEndian?: boolean): BinaryParser<number, string>;
    /** A binary parser which reads an unsigned 8-bit (1 byte) integer as {@link Number} */
    export const uint8: BinaryParser<number, string, any, any>;
    /** A binary parser which reads an unsigned 8-bit (1 byte) integer as {@link Number}, Big Endian mode */
    export const uint8BE: BinaryParser<number, string, any, any>;
    /** A binary parser which reads an unsigned 16-bit (2 byte) integer as {@link Number} */
    export const uint16: BinaryParser<number, string, any, any>;
    /** A binary parser which reads an unsigned 16-bit (2 byte) integer as {@link Number}, Big Endian mode */
    export const uint16BE: BinaryParser<number, string, any, any>;
    /** A binary parser which reads an unsigned 24-bit (3 byte) integer as {@link Number} */
    export const uint24: BinaryParser<number, string, any, any>;
    /** A binary parser which reads an unsigned 24-bit (3 byte) integer as {@link Number}, Big Endian mode */
    export const uint24BE: BinaryParser<number, string, any, any>;
    /** A binary parser which reads an unsigned 32-bit (4 byte) integer as {@link Number} */
    export const uint32: BinaryParser<number, string, any, any>;
    /** A binary parser which reads an unsigned 32-bit (4 byte) integer as {@link Number}, BigEndian mode */
    export const uint32BE: BinaryParser<number, string, any, any>;
    /**
     * Create a binary parser which read an unsigned integer from
     * a fixed number of bits into a {@link BigInt}. The number of
     * readable bits is limited by JS environment implementation.
     * @param bits the number of bits to read (bits >= 1)
     * @param bigEndian wether to read the number in Big Endian or Little Endian mode
     * @returns a binary parser which read an unsigned integer with the given specs
     */
    export function biguint(bits: number, bigEndian?: boolean): BinaryParser<bigint, string>;
    /** A binary parser which reads an unsigned 64-bit (8 byte) integer as {@link BigInt} */
    export const uint64: BinaryParser<bigint, string, any, any>;
    /** A binary parser which reads an unsigned 64-bit (8 byte) integer as {@link BigInt}, Big Endian mode */
    export const uint64BE: BinaryParser<bigint, string, any, any>;
    /** A binary parser which reads an unsigned 128-bit (16 byte) integer as {@link BigInt} */
    export const uint128: BinaryParser<bigint, string, any, any>;
    /** A binary parser which reads an unsigned 128-bit (16 byte) integer as {@link BigInt}, Big Endian mode */
    export const uint128BE: BinaryParser<bigint, string, any, any>;
    /** A binary parser which reads an unsigned 256-bit (32 byte) integer as {@link BigInt} */
    export const uint256: BinaryParser<bigint, string, any, any>;
    /** A binary parser which reads an unsigned 256-bit (32 byte) integer as {@link BigInt}, Big Endian mode */
    export const uint256BE: BinaryParser<bigint, string, any, any>;
    /**
     * Create a binary parser which read a signed integer from
     * a fixed number of bits into a {@link Number}. The number of bits must not exceed
     * 32. For integers longer than 32 bits use {@link bigint}
     * @param bits the number of bits to read (1 <= bits <= 32)
     * @param bigEndian wether to read the number in Big Endian or Little Endian mode
     * @returns a binary parser which read a signed integer with the given specs
     */
    export function int(bits: number, bigEndian?: boolean): BinaryParser<number, string>;
    /** A binary parser which reads a signed 8-bit (1 byte) integer as {@link Number} */
    export const int8: BinaryParser<number, string, any, any>;
    /** A binary parser which reads a signed 8-bit (1 byte) integer as {@link Number}, Big Endian mode */
    export const int8BE: BinaryParser<number, string, any, any>;
    /** A binary parser which reads a signed 16-bit (2 byte) integer as {@link Number} */
    export const int16: BinaryParser<number, string, any, any>;
    /** A binary parser which reads a signed 16-bit (2 byte) integer as {@link Number}, Big Endian mode */
    export const int16BE: BinaryParser<number, string, any, any>;
    /** A binary parser which reads a signed 24-bit (3 byte) integer as {@link Number} */
    export const int24: BinaryParser<number, string, any, any>;
    /** A binary parser which reads a signed 24-bit (3 byte) integer as {@link Number}, Big Endian mode */
    export const int24BE: BinaryParser<number, string, any, any>;
    /** A binary parser which reads a signed 32-bit (4 byte) integer as {@link Number} */
    export const int32: BinaryParser<number, string, any, any>;
    /** A binary parser which reads a signed 32-bit (4 byte) integer as {@link Number}, Big Endian mode */
    export const int32BE: BinaryParser<number, string, any, any>;
    /**
     * Create a binary parser which read a signed integer from
     * a fixed number of bits into a {@link BigInt}. The number of
     * readable bits is limited by JS environment implementation.
     * @param bits the number of bits to read (bits >= 1)
     * @param bigEndian wether to read the number in Big Endian or Little Endian mode
     * @returns a binary parser which read a signed integer with the given specs
     */
    export function bigint(bits: number, bigEndian?: boolean): BinaryParser<bigint, string>;
    /** A binary parser which reads an unsigned 64-bit (8 byte) integer as {@link BigInt} */
    export const int64: BinaryParser<bigint, string, any, any>;
    /** A binary parser which reads an unsigned 64-bit (8 byte) integer as {@link BigInt}, Big Endian mode */
    export const int64BE: BinaryParser<bigint, string, any, any>;
    /** A binary parser which reads an unsigned 128-bit (16 byte) integer as {@link BigInt} */
    export const int128: BinaryParser<bigint, string, any, any>;
    /** A binary parser which reads an unsigned 128-bit (16 byte) integer as {@link BigInt}, Big Endian mode */
    export const int128BE: BinaryParser<bigint, string, any, any>;
    /** A binary parser which reads an unsigned 256-bit (32 byte) integer as {@link BigInt} */
    export const int256: BinaryParser<bigint, string, any, any>;
    /** A binary parser which reads an unsigned 256-bit (32 byte) integer as {@link BigInt}, Big Endian mode */
    export const int256BE: BinaryParser<bigint, string, any, any>;
    type SequenceOfParsersResult<Parsers extends BinaryParser[]> = Parsers extends [] ? [] : Parsers extends [BinaryParser<infer OR>] ? [OR] : Parsers extends [BinaryParser<infer OR1, infer OE1>, ...infer Rest1] ? Rest1 extends [BinaryParser<infer OR2, any, OR1, OE1>, ...infer Rest2] ? Rest2 extends BinaryParser[] ? [OR1, OR2, ...SequenceOfParsersResult<Rest2>] : never : never : Parsers extends BinaryParser<infer OR>[] ? OR[] : never;
    type SequenceOfParsersError<Parsers extends BinaryParser[]> = Parsers extends [] ? never : Parsers extends [BinaryParser<any, infer OE>] ? OE : Parsers extends [BinaryParser<infer OR1, infer OE1>, ...infer Rest1] ? Rest1 extends [BinaryParser<any, infer OE2, OR1, OE1>, ...infer Rest2] ? Rest2 extends BinaryParser[] ? OE1 | OE2 | SequenceOfParsersError<Rest2> : never : never : Parsers extends BinaryParser<any, infer OE>[] ? OE : never;
    type SequenceOfParsers<Parsers extends BinaryParser[]> = SequenceOfParsersResult<Parsers> extends never ? never : SequenceOfParsersError<Parsers> extends never ? never : BinaryParser<SequenceOfParsersResult<Parsers>, SequenceOfParsersError<Parsers>, any, any>;
    /**
     * Create a binary parser which check the concatenation in
     * sequence of the given binary parsers
     * @param parsers an array of binary parsers to concatenate
     * @return a binary parser that is the concatenation in a sequence
     *          of the given binary parsers
     */
    export function sequence<Parsers extends BinaryParser[]>(parsers: Parsers): SequenceOfParsers<Parsers>;
    /**
     * Create a binary parser which check the concatenation in
     * sequence of the given binary parsers
     * @param parsers binary parsers to concatenate
     * @return a binary parser that is the concatenation in a sequence
     *          of the given binary parsers
     */
    export function sequence<Parsers extends BinaryParser[]>(...parsers: Parsers): SequenceOfParsers<Parsers>;
    type ParserOneOf<Parsers extends BinaryParser[]> = SequenceOfParsersResult<Parsers> extends never ? never : SequenceOfParsersError<Parsers> extends never ? never : Parser<OneOf<SequenceOfParsersResult<Parsers>>, SequenceOfParsersError<Parsers>, any, any>;
    /**
     * Create a binary parser which returns the first success state
     * from any given binary parsers.
     * @param parsers an array of binary parsers to test
     * @return a binary parser which test the given binary parsers
     */
    export function oneOf<Parsers extends BinaryParser[]>(parsers: Parsers): ParserOneOf<Parsers>;
    /**
     * Create a binary parser which returns the first success state
     * from any given binary parsers.
     * @param parsers binary parsers to test
     * @return a binary parser which test the given binary parsers
     */
    export function oneOf<Parsers extends BinaryParser[]>(...parsers: Parsers): ParserOneOf<Parsers>;
    type ManyOf<P> = P extends BinaryParser<infer OR, infer OE, infer IR, infer IE> ? BinaryParser<OR[], OE, IR, IE> : never;
    /**
     * Create a binary parser which tries to match the given binary parser
     * as many times as possible
     * @param parser the binary parser to test
     * @returns a binary parser which tries to match the given binary parser
     *              as many times as possible
     */
    export function many<P extends BinaryParser>(parser: P): ManyOf<P>;
    /**
     * Create a binary parser which match at least one time,
     * then as many times as possible, the given binary parser
     * @param parser the binary parser to test
     * @returns a binary parser which match at least one time,
     *          then as many times as possible, the given binary parser
     */
    export function oneOrMore<P extends BinaryParser>(parser: P): ManyOf<P>;
    /**
     * Create a binary parser which match the given binary parser
     * the given number of times
     * @param parser the binary parser to test
     * @param times how many exact times the binary parser must match
     * @returns a binary parser which match the given binary parser
     *          the given number of times
     */
    export function times<P extends BinaryParser>(parser: P, times: number): ManyOf<P>;
    /**
     * Create a binary parser which check the following syntax:
     * `wrapper content wrapper` from the given binary parsers.
     * The resultant binary parser will consider only the output of the
     * content binary parser.\
     * For example, to parse a binary string enclosed by the sequence `0110` you can use
     * `between(sequence(zero, one, one, zero), contentParser)`
     * @param wrapper the wrapper binary parser to match before and after the content
     * @param content the binary parser responsible to match the content
     * @return a binary parser which consider only the wrapped content
     */
    export function between<OR = any, OE = any, IR = any, IE = any>(wrapper: BinaryParser<OR, OE, IR, IE>, content: BinaryParser<IR, IE, OR, OE>): BinaryParser<OR, OE, IR, IE>;
    /**
     * Create a binary parser which check the following syntax:
     * `left content rigth` from the given binary parsers.
     * The resultant binary parser will consider only the output of the
     * content binary parser.\
     * For example, to parse a binary string enclosed by the sequence `0110` and `1001` you can use
     * `between(sequence(zero, one, one, zero), contentParser, sequence(one, zero, zero, one))`
     * @param left the binary parser to match before the content
     * @param content the binary parser responsible to match the content
     * @param right the binary parser to match after the content
     * @return a binary parser which consider only the wrapped content
     */
    export function between<OR1 = any, OE1 = any, IR1 = any, IE1 = any, OR2 = any, OE2 = any, OR3 = any, OE3 = any>(left: BinaryParser<OR1, OE1, IR1, IE1>, content: BinaryParser<OR2, OE2, OR1, OE1>, right: BinaryParser<OR3, OE3, OR2, OE2>): BinaryParser<OR3, OE3, OR2, OE2>;
    /**
     * Generate an high-order function which creates a
     * between expression for a binary parser. This function
     * returns another function which takes the content
     * binary parser as argument and generate a binary parser which will
     * match the following syntax: `wrapper content wrapper`.
     * The resultant binary parser will consider only the output of the
     * content binary parser.\
     * For example, to parse content between the sequence `0110` you can use
     * ```js
     * const contentParser = uint8; // or whatever
     * const betweenSequence = parsebetween(sequence(zero, one, one, zero));
     * const myParser = betweenSequence(contentParser);
     * ```
     * @param wrapper the wrapper binary parser to match before and after the content
     * @return an high-order function which generate a binary between parser expression
     */
    export function parseBetween<OR = any, OE = any, IR = any, IE = any>(wrapper: BinaryParser<OR, OE, IR, IE>): (content: BinaryParser<IR, IE, OR, OE>) => BinaryParser<OR, OE, IR, IE>;
    /**
     * Generate an high-order function which creates a
     * between expression for a binary parser. This function
     * returns another function which takes the content
     * binary parser as argument and generate a binary parser which will
     * match the following syntax: `left content right`.
     * The resultant binary parser will consider only the output of the
     * content binary parser.\
     * For example, to parse content between the sequence `0110` and `1001` you can use
     * ```js
     * const contentParser = uint8; // or whatever
     * const betweenSequence = parsebetween(sequence(zero, one, one, zero), sequence(one, zero, zero, one));
     * const myParser = betweenSequence(contentParser);
     * ```
     * @param left the parser to match before the content
     * @param right the parser to match after the content
     * @return an high-order function which generate a between parser expression
     */
    export function parseBetween<OR1, OE1 = any, IR1 = any, IE1 = any, OR2 = any, OE2 = any, OR3 = any, OE3 = any>(left: BinaryParser<OR1, OE1, IR1, IE1>, right: BinaryParser<OR3, OE3, OR2, OE2>): (content: BinaryParser<OR2, OE2, OR1, OE1>) => BinaryParser<OR3, OE3, OR2, OE2>;
    /**
     * Generate a binary parser which tries to match one or more
     * times the following syntax: `(content separator)* content`.
     * The resultant binary parser will consider only the output of
     * the content binary parser.\
     * For example, to a list separated by the sequence `000` you can use:
     * `separated(sequence(zero, zero, zero), contentPasrer)`.
     * @param separator the binary parser that matches separator
     * @param content the binary parser that match the content
     * @returns a binary parser which generate a separated expression
     */
    export function separated<OR1 = any, OE1 = any, IE1 = any, OR2 = any, OE2 = any, IE2 = any>(separator: BinaryParser<OR1, OE1, OR2, IE1>, content: BinaryParser<OR2, OE2, OR1, IE2>): BinaryParser<OR2[], OE2, OR1, IE2>;
    /**
     * Generate an high-order function which creates a
     * separated expression for a binary parser. This function
     * returns another function which takes the content
     * binary parser as argument and generate a binary parser which will
     * match the following syntax: `(content separator)* content`.
     * The resultant binary parser will consider only the output of the
     * content binary parser.\
     * For example, to parse a list which elements are separated by `0` you can use:
     * ```js
     * const contentParser = uint8; // or whatever
     * const zeroSeparated = parseSeparated(zero);
     * const zeroSeparatedParser = zeroSeparated(contentParser);
     * ```
     * @param separator the binary parser that matches separator
     * @return an high-order function which generate a binary between parser expression
     */
    export function parseSeparated<OR1, OE1, IR1, IE1>(separator: BinaryParser<OR1, OE1, IR1, IE1>): <OR, OE, IE>(content: BinaryParser<OR, OE, OR1, IE>) => BinaryParser<OR[], OE, OR1, IE>;
    /**
     * Generate a binary parser which will use the given thunk lazily.
     * This is helpful if you need to use binary parsers which depends one
     * on the other:
     * ```js
     * const parserA = lazy(() => sequence(parserB, zero, zero, parserB));
     * const parserB = lazy(() => oneOf(parserA, sequence(zero, zero, one), sequence(one, one, zero)));
     * ```
     * @param thunk the lazy evaluated function which produce a binary parser
     * @param notCached wether to cache or not the output of the thunk (default: `false --> cached`)
     * @returns a binary parser which evaluates lazily the given thunk
     */
    export function lazy<P extends BinaryParser>(thunk: () => P, notCached?: boolean): P;
    /**
     * Create a binary parser which always produces an error state
     * @param message the message of the error state
     * @returns a failure binary parser
     */
    export function fail<E>(message: E): BinaryParser<any, E>;
    /**
     * Create a binary parser which always produces a success binary parser state
     * @param value the result value of the success state
     * @returns a success binary parser
     */
    export function success<T>(value: T): BinaryParser<T>;
    type ContextualOneOf<P extends BinaryParser> = P extends BinaryParser<infer R> ? R : P extends BinaryParser<infer R> | infer Rest ? Rest extends BinaryParser ? ContextualOneOf<Rest> extends never ? never : R | ContextualOneOf<Rest> : never : never;
    type ContextualCB<P extends BinaryParser, R> = () => Generator<P, ContextualOneOf<P> | R, ContextualOneOf<P> | R>;
    /**
     * Create a binary parser which automatically chain the binary parsers produced
     * by a generator function, yielding their parserd binary results states.\
     * See the non binary version of this function for a tip on the usage.
     * @param generator the function that generates the binary parsers to chain
     * @returns a automatically chained binary parser
     */
    export function contextual<P extends BinaryParser = BinaryParser, R = any>(generator: ContextualCB<P, R>): BinaryParser<R>;
    /**
     * Utility function to convert a string or an array
     * into a buffer. Note that all non-zero characters
     * are considered as a one bit, as well as any non
     * truish numeric values (eg. `0, NaN`).
     * @param value the value to being converted
     * @returns the converted buffer as a {@link DataView}
     */
    export function asBinary(value: string | (boolean | 1 | 0 | '1' | '0')[]): DataView;
    /**
     * Converts a string to a byte array buffer
     * @param value the string to convert
     * @returns the converted buffer as a {@link DataView}
     */
    export function toCharCode(value: string): DataView;
    export {};
}
declare const _default: {
    binary: typeof binary;
    between: typeof between;
    contextual: typeof contextual;
    digits: Parser<string, string, any, any>;
    end: Parser<any, string, any, any>;
    eof: Parser<any, string, any, any>;
    eoi: Parser<any, string, any, any>;
    fail: typeof fail;
    lazy: typeof lazy;
    letters: Parser<string, string, any, any>;
    many: typeof many;
    match: typeof match;
    parseBetween: typeof parseBetween;
    parseSeparated: typeof parseSeparated;
    parser: typeof parser;
    success: typeof success;
    separated: typeof separated;
    sequence: typeof sequence;
    spaces: Parser<string, string, any, any>;
    state: typeof state;
    times: typeof times;
    oneOf: typeof oneOf;
    oneOrMore: typeof oneOrMore;
};
export default _default;