import type { Combinator, DispatchMatcherCase } from '../types.ts';
export type DispatchWhen<T> = {
    readonly kind: 'when';
    readonly keys: readonly string[];
    readonly parser: Combinator<T>;
    readonly caseInsensitive: boolean;
    readonly usesRouted?: boolean;
};
export type DispatchWhenMatcher<T> = {
    readonly kind: 'whenMatcher';
    readonly matcher: DispatchStringMatcher;
    readonly parser: Combinator<T>;
    readonly caseInsensitive: boolean;
    readonly usesRouted?: boolean;
};
export type DispatchStringMatcher = {
    readonly kind: 'startsWith';
    readonly value: string;
} | {
    readonly kind: 'endsWith';
    readonly value: string;
} | {
    readonly kind: 'matches';
    readonly value: string;
    readonly flags: string;
};
export type DispatchOtherwise<T> = {
    readonly kind: 'otherwise';
    readonly parser: Combinator<T>;
    readonly usesRouted?: boolean;
};
export type DispatchArm<T = unknown> = DispatchWhen<T> | DispatchWhenMatcher<T> | DispatchOtherwise<T>;
export type DispatchWhenOptions = {
    caseInsensitive?: boolean;
};
export type DispatchWhenFactory = <T>(key: string | readonly string[], parser: Combinator<T>) => DispatchWhen<T>;
export type DispatchWhenKey = string | readonly string[];
export type DispatchWhenSelector = DispatchWhenKey | DispatchStringMatcher;
type ArmValue<T> = T extends DispatchWhen<infer U> ? U : T extends DispatchWhenMatcher<infer U> ? U : T extends DispatchOtherwise<infer U> ? U : never;
type UnionArms<T extends readonly DispatchArm<unknown>[]> = {
    [K in keyof T]: ArmValue<T[K]>;
}[number];
export declare function parserUsesRouted(parser: Combinator<unknown>, seen?: Set<Combinator<unknown>>): boolean;
export declare function branchUsesRouted(branch: {
    parser: Combinator<unknown>;
    usesRouted?: boolean | undefined;
}): boolean;
export declare function asciiFoldKey(key: string): string;
export declare function matchesDispatchMatcher(value: string, matcher: DispatchMatcherCase): boolean;
export declare function startsWith(prefix: string): DispatchStringMatcher;
export declare function endsWith(suffix: string): DispatchStringMatcher;
export declare function matches(pattern: RegExp): DispatchStringMatcher;
export declare function when<T>(key: DispatchWhenKey, parser: Combinator<T>, opts?: DispatchWhenOptions): DispatchWhen<T>;
export declare function when<T>(matcher: DispatchStringMatcher, parser: Combinator<T>, opts?: DispatchWhenOptions): DispatchWhenMatcher<T>;
export declare function makeWhen(opts?: DispatchWhenOptions): DispatchWhenFactory;
export declare function otherwise<T>(parser: Combinator<T>): DispatchOtherwise<T>;
/**
 * Reuse the token the enclosing `dispatch()` already consumed to select this branch,
 * instead of re-recognizing it.
 *
 * With no argument this is dispatch-only: outside a dispatch branch (or at a position
 * other than the selector's) it fails with `expected: ['routed()']`.
 *
 * `routed(fallback)` makes the SAME production usable in both contexts: inside a
 * dispatch branch it reuses the routed token; anywhere else it parses `fallback` in
 * place. That is what collapses a `Routed<X>` twin production into its original —
 * `sequence(routed(Name), Prelude, ';')` replaces the pair
 * `sequence(Name, Prelude, ';')` / `sequence(routed(), Prelude, ';')`, which
 * otherwise differ by exactly one element and duplicate a whole production (and a
 * whole compiled emission) for a one-token difference.
 *
 * A `routed()` in a dispatch SELECTOR is still an error with or without a fallback:
 * the selector is what produces the routed token, so reading it there is misuse.
 */
export declare function routed<T = string>(fallback?: Combinator<T>): Combinator<T>;
export declare function dispatch<S extends string, T extends readonly DispatchArm<unknown>[]>(selector: Combinator<S>, ...arms: T): Combinator<[S, UnionArms<T>]>;
export {};
//# sourceMappingURL=dispatch.d.ts.map