import type { Combinator, GatedArm } from '../types.ts';
type ArmParser<T> = T extends GatedArm<infer U> ? Combinator<U> : T extends Combinator<infer U> ? Combinator<U> : never;
type UnionArms<T extends (Combinator<unknown> | GatedArm<unknown>)[]> = {
    [K in keyof T]: ArmParser<T[K]>;
}[number] extends Combinator<infer U> ? U : never;
export declare function choice<T extends [Combinator<unknown> | GatedArm<unknown>, ...(Combinator<unknown> | GatedArm<unknown>)[]]>(...args: T): Combinator<UnionArms<T>>;
/**
 * Peel wrappers that neither consume input nor skip trivia before their inner
 * sequence -- `node`, `parser`/`grammar`, `transform`, `label` -- down to the core
 * `sequence` and return its FIRST term (the candidate shared prefix), or null when
 * the arm is not a wrapped-or-bare sequence with >=2 terms. Because none of these
 * wrappers advance the position before the sequence's first term, the term is parsed
 * at the arm's entry position in every arm, so the once-recognized prefix can be
 * replayed there. `attempt`/`optional`/`many`/`choice`/etc. are NOT peeled, so such
 * arms are conservatively excluded.
 */
export declare function leadingTermOfArm(arm: Combinator<unknown>): Combinator<unknown> | null;
/** Walk transform wrappers to find an inner literal's string value. */
export declare function getCoreLiteralValue(p: Combinator<unknown>): string | null;
/** Walk transform wrappers to find an inner regex's source/flags. */
export declare function getCoreRegexDef(p: Combinator<unknown>): {
    source: string;
    flags: string;
} | null;
export {};
//# sourceMappingURL=choice.d.ts.map