export type Token = {
    pattern: string | RegExp;
    name: string;
    source: string;
    test: (v: string) => boolean;
};
/**
 * Result tuple for a Grammar:
 *   Success: [value, null]
 *   Failure: [position, expectedToken]
 */
export type GrammarResult<T> = [T, null] | [number, Token];
/**
 * Grammar is a function from parsing Context to GrammarResult<T>.
 */
export type Grammar<T> = (ctx: Context) => GrammarResult<T>;
/**
 * Parsing context shared across grammar invocations.
 */
interface Context {
    input: string;
    tokens: string[];
    pos: number;
    skipRule: Grammar<unknown> | null;
}
/** Utility: extract the value type from a Grammar */
export type UnwrapGrammar<G> = G extends Grammar<infer V> ? V : never;
/** Utility: tuple value types -> union */
type UnionOf<R extends readonly Grammar<any>[]> = {
    [K in keyof R]: UnwrapGrammar<R[K]>;
}[number];
/** Create a token definition */
export declare function createToken(pattern: string | RegExp, name?: string): Token;
export declare const EOF: Token;
export declare const UNEXPECTED: Token;
export declare const INFINITE_LOOP: Token;
/**
 * Sequence (AND) combinator.
 * When no transform is provided the resulting value is a tuple whose
 * element types correspond to each rule's produced value.
 */
export declare function and<R extends readonly Grammar<any>[]>(rules: [...R]): Grammar<{
    [K in keyof R]: UnwrapGrammar<R[K]>;
}>;
export declare function and<R extends readonly Grammar<any>[], T>(rules: [...R], transform: (values: {
    [K in keyof R]: UnwrapGrammar<R[K]>;
}) => T): Grammar<T>;
/**
 * Consume a specific token (forward).
 */
export declare function consume<T>(token: Token, transform: (v: string) => T): Grammar<T>;
export declare function consume(token: Token): Grammar<string>;
/**
 * Consume a specific token looking behind current position (backwards).
 * On success moves one position back.
 */
export declare function consumeBehind<T>(token: Token, transform: (v: string) => T): Grammar<T>;
export declare function consumeBehind(token: Token): Grammar<string>;
/**
 * Consume and collect raw string chunks until a sentinel token or rule
 * is reached. The sentinel token / rule is NOT consumed (lookahead).
 * - If sentinel is EOF, all remaining chunks are gathered.
 * - If sentinel is a Grammar, success when that parser matches at the
 *   current position (without consuming).
 * - If sentinel is a Token, success when that token matches; failure
 *   when EOF is reached before that token is found.
 */
export declare function consumeUntil<T>(target: Token | Grammar<any>, transform: (vs: string[]) => T): Grammar<T>;
export declare function consumeUntil(target: Token | Grammar<any>): Grammar<string[]>;
/**
 * OR combinator.
 * Produces a union of the rule value types (or transform output).
 */
export declare function or<R extends readonly Grammar<any>[]>(rules: [...R]): Grammar<UnionOf<R>>;
export declare function or<R extends readonly Grammar<any>[], T>(rules: [...R], transform: (value: UnionOf<R>) => T): Grammar<T>;
/**
 * zeroOrMany combinator.
 */
export declare function zeroOrMany<V, T>(rule: Grammar<V>, transform: (vs: V[]) => T, until?: Grammar<any>): Grammar<T>;
export declare function zeroOrMany<V>(rule: Grammar<V>, transform?: undefined, until?: Grammar<any>): Grammar<V[]>;
/**
 * zeroOrMany with separator.
 */
export declare function zeroOrManySep<V, T>(rule: Grammar<V>, sep: Grammar<any>, transform: (vs: V[]) => T, until?: Grammar<any>): Grammar<T>;
export declare function zeroOrManySep<V>(rule: Grammar<V>, sep: Grammar<any>, transform?: undefined, until?: Grammar<any>): Grammar<V[]>;
/**
 * oneOrMany combinator.
 */
export declare function oneOrMany<V, T>(rule: Grammar<V>, transform: (vs: V[]) => T, until?: Grammar<any>): Grammar<T>;
export declare function oneOrMany<V>(rule: Grammar<V>, transform?: undefined, until?: Grammar<any>): Grammar<V[]>;
/**
 * oneOrMany with separator.
 */
export declare function oneOrManySep<V, T>(rule: Grammar<V>, sep: Grammar<any>, transform: (vs: V[]) => T, until?: Grammar<any>): Grammar<T>;
export declare function oneOrManySep<V>(rule: Grammar<V>, sep: Grammar<any>, transform?: undefined, until?: Grammar<any>): Grammar<V[]>;
/**
 * zeroOrOne combinator.
 */
export declare function zeroOrOne<V, T>(rule: Grammar<V>, transform: (v: V | undefined) => T): Grammar<T | undefined>;
export declare function zeroOrOne<V>(rule: Grammar<V>, transform?: undefined): Grammar<V | undefined>;
/**
 * Peek (lookahead) - value is preserved, position is restored.
 */
export declare function peek<V>(rule: Grammar<V>): Grammar<V>;
/**
 * Negative lookahead. Succeeds when inner rule fails.
 * Always produces null as its value.
 */
export declare function not(rule: Grammar<any>): Grammar<null>;
/**
 * Apply a temporary skip rule inside another rule.
 */
export declare function skipIn<V>(skip: Grammar<any> | null, rule: Grammar<V>): Grammar<V>;
/**
 * Wrap a raw rule accessor (for potential lazy evaluation) while preserving its exact Grammar type.
 * Using a higher-kinded generic inference based on the function's own return type
 * avoids collapsing the inner value type to 'any' when the rawRules object
 * becomes contextually typed.
 */
export declare function rule<V>(r: () => Grammar<V>): Grammar<V>;
/**
 * Overload 1 (broad) - keeps precise return types of each rule without prematurely widening.
 */
export declare function createParser<T>(tokens: Token[], rawRules: T, skipFactory?: () => Grammar<any>): <K extends keyof T>(key: K, input: string) => T[K] extends () => Grammar<infer V> ? V : never;
export {};
//# sourceMappingURL=nanolex.d.ts.map