import { Token, TokenType, Items, Item } from './tokens.js';
import { Pos } from './position.js';
import { List, ArrayList } from './list.js';
export type ItemContext = string | null;
export type ItemList = List<Item, ItemContext>;
export type PatternResult<T> = [T, ItemList] | null;
export type Pattern<T> = (i: ItemList) => PatternResult<T>;
export type PatternTypeArg<P> = P extends Pattern<infer T> ? T : never;
export declare function match<T, F>(p: Pattern<T>, items: Items, failure: F, context: ItemContext): T | F;
export declare const noItems: (c: ItemContext) => ArrayList<never, ItemContext>;
export declare const fail: Pattern<never>;
export declare function succeed<T>(t: T): Pattern<T>;
export declare const discard: Pattern<void>;
export declare const rest: Pattern<Items>;
export declare const end: Pattern<void>;
export declare const pos: Pattern<Pos>;
export declare const newline: Pattern<Item>;
export declare function skipSpace(i: ItemList): ItemList;
export declare function collectSpace(i: ItemList, acc: Array<Item>): ItemList;
export declare function withoutSpace<T>(p: Pattern<T>): Pattern<T>;
export declare function not(p: Pattern<any>, v?: undefined): Pattern<undefined>;
export declare function follows(p: Pattern<any>): Pattern<undefined>;
export declare function seq(...patterns: Pattern<any>[]): Pattern<any>;
export declare function seqTuple<Patterns extends [...Pattern<any>[]]>(...patterns: Patterns): Pattern<{
    [I in keyof Patterns]: PatternTypeArg<Patterns[I]>;
} & {
    length: Patterns['length'];
}>;
export declare function alt<T>(...alts: Pattern<T>[]): Pattern<T>;
export declare function scope<T>(pf: (scope: T) => Pattern<any>): Pattern<T>;
export declare function value<T>(pf: (scope: {
    value: T;
}) => Pattern<any>): Pattern<T>;
export declare function bind<T, K extends keyof T>(target: T, key: K, pattern: Pattern<T[K]>): Pattern<T[K]>;
export declare function exec(thunk: (i: ItemList) => void): Pattern<void>;
export declare function map<T, R>(p: Pattern<T>, f: (t: T) => R): Pattern<R>;
export declare function mapm<T, R>(p: Pattern<T>, f: (t: T) => Pattern<R>): Pattern<R>;
export interface ItemOptions {
    skipSpace?: boolean;
    advance?: boolean;
}
export interface GroupOptions extends ItemOptions {
}
export interface TokenOptions extends ItemOptions {
    tokenType?: TokenType;
}
export declare function group<T>(opener: string, items: Pattern<T>, options?: GroupOptions): Pattern<T>;
export declare function atomString<T extends string>(text: T, options?: TokenOptions): Pattern<T>;
export declare function atom(text?: string, options?: TokenOptions): Pattern<Token>;
export declare function anything(options?: ItemOptions): Pattern<Item>;
export declare function upTo(p: Pattern<any>): Pattern<Items>;
export declare function separatedBy<T>(itemPattern: Pattern<T>, separator: Pattern<any>): Pattern<T[]>;
export declare function separatedOrTerminatedBy<T>(itemPattern: Pattern<T>, separator: Pattern<any>): Pattern<T[]>;
export interface RepeatOptions {
    min?: number;
    max?: number;
    separator?: Pattern<any>;
}
export declare function repeat<T>(p: Pattern<T>, options?: RepeatOptions): Pattern<T[]>;
export declare function option<T>(p: Pattern<T>): Pattern<T[]>;
export declare function replace<T>(items: Items, outerContext: ItemContext, p: Pattern<T>, f: (t: T, start: Pos, end: Pos) => Items, end?: Pos): Items;