/**
 * Symbol to return when a custom {@link Dispatcher.addRoute} matcher cannot match a segment.
 */
export declare const MATCH_FAILED: unique symbol;
/**
 * Special {@link Dispatcher.addRoute} matcher that matches the rest of the segments as an array of strings.
 */
export declare const MATCH_REST: unique symbol;
type Matcher = string | ((segment: string) => any) | typeof MATCH_REST;
type ExtractParamType<M> = M extends string ? never : (M extends ((segment: string) => infer R) ? Exclude<R, typeof MATCH_FAILED> : (M extends typeof MATCH_REST ? string[] : never));
type ParamsFromMatchers<T extends Matcher[]> = T extends [infer M1, ...infer Rest] ? (M1 extends Matcher ? (ExtractParamType<M1> extends never ? ParamsFromMatchers<Rest extends Matcher[] ? Rest : []> : [ExtractParamType<M1>, ...ParamsFromMatchers<Rest extends Matcher[] ? Rest : []>]) : never) : [];
/**
 * Simple route matcher and dispatcher.
 *
 * Example usage:
 *
 * ```ts
 * import * as route from 'aberdeen/route';
 * import { Dispatcher, MATCH_REST } from 'aberdeen/dispatcher';
 *
 * const dispatcher = new Dispatcher();
 *
 * dispatcher.addRoute("user", Number, "stream", String, (id, stream) => {
 *    console.log(`User ${id}, stream ${stream}`);
 * });
 *
 * dispatcher.dispatch(["user", "42", "stream", "music"]);
 * // Logs: User 42, stream music
 *
 * dispatcher.addRoute("search", MATCH_REST, (terms: string[]) => {
 *     console.log("Search terms:", terms);
 * });
 *
 * dispatcher.dispatch(["search", "classical", "piano"]);
 * // Logs: Search terms: [ 'classical', 'piano' ]
 * ```
 */
export declare class Dispatcher {
    private routes;
    /**
     * Add a route with matchers and a handler function.
     * @param args An array of matchers followed by a handler function. Each matcher can be:
     * - A string: matches exactly that string.
     * - A function: takes a string segment and returns a value (of any type) if it matches, or {@link MATCH_FAILED} if it doesn't match. The return value (if not `MATCH_FAILED` and not `NaN`) is passed as a parameter to the handler function. The standard JavaScript functions `Number` and `String` can be used to match numeric and string segments respectively.
     * - The special {@link MATCH_REST} symbol: matches the rest of the segments as an array of strings. Only one `MATCH_REST` is allowed.
     * @template T - Array of matcher types.
     * @template H - Handler function type, inferred from the matchers.
     */
    addRoute<T extends Matcher[], H extends (...args: ParamsFromMatchers<T>) => void>(...args: [...T, H]): void;
    /**
     * Dispatches the given segments to the first route handler that matches.
     * @param segments Array of string segments to match against the added routes. When using this class with the Aberdeen `route` module, one would typically pass `route.current.p`.
     * @returns True if a matching route was found and handled, false otherwise.
     */
    dispatch(segments: string[]): boolean;
}
export {};