import { Mode, ModeValue } from "./parser.cjs";

//#region src/internal/mode-dispatch.d.ts

/**
 * Dispatches to sync or async implementation based on mode.
 *
 * This function encapsulates the necessary type assertions when branching
 * on runtime mode values. TypeScript cannot narrow `ModeValue<M, T>` based
 * on `mode === "async"` checks, so we must use type assertions.
 *
 * @param mode The execution mode.
 * @param syncFn Function to call for sync execution.
 * @param asyncFn Function to call for async execution.
 * @returns The result with correct mode wrapping.
 * @since 0.10.0
 */
declare function dispatchByMode<M extends Mode, T>(mode: M, syncFn: () => T, asyncFn: () => Promise<T>): ModeValue<M, T>;
/**
 * Wraps a value so it matches the parser execution mode.
 *
 * @param mode The execution mode.
 * @param value The value to wrap.
 * @returns The wrapped value with correct mode semantics.
 * @since 1.0.0
 */
declare function wrapForMode<T>(mode: "sync", value: T | Promise<T>): T;
declare function wrapForMode<T>(mode: "async", value: T | Promise<T>): Promise<T>;
declare function wrapForMode<M extends Mode, T>(mode: M, value: T | Promise<T>): ModeValue<M, T>;
/**
 * Maps a mode-wrapped value while preserving its execution mode.
 *
 * @param mode The execution mode.
 * @param value The mode-wrapped value to transform.
 * @param mapFn Mapping function applied to the unwrapped value.
 * @returns The mapped value with correct mode wrapping.
 * @since 1.0.0
 */
declare function mapModeValue<M extends Mode, T, U>(mode: M, value: ModeValue<M, T>, mapFn: (value: T) => U): ModeValue<M, U>;
/**
 * Dispatches iterable to sync or async implementation based on mode.
 *
 * @param mode The execution mode.
 * @param syncFn Function returning sync iterable.
 * @param asyncFn Function returning async iterable.
 * @returns The iterable with correct mode wrapping.
 * @internal
 * @since 0.10.0
 */
//#endregion
export { dispatchByMode, mapModeValue, wrapForMode };