/**
 * vapor-chamber - Vue Vapor integration
 *
 * v1.3.0 — Vue 3.6.0-beta.12 alignment: error recovery (component context,
 *           fallthrough props, render effects restored after setup errors);
 *           VDOM slots interop normalization; no code changes needed here.
 * v1.1.0 — Vue 3.6.0-beta.10 alignment: defineVaporCustomElement, defineVaporComponent,
 *           defineVaporAsyncComponent detection; improved hydration interop.
 * v0.4.1 — Added: useCommandGroup (namespace isolation), useCommandError (error boundary).
 * v0.4.0 — Vue 3.6 Vapor alignment: onScopeDispose, Vapor detection,
 *           defineVaporCommand, createVaporChamberApp.
 * v0.3.0 — Fixed: signal shim, resetCommandBus, auto-cleanup on Vue unmount.
 */
import { type CommandBus, type AsyncCommandBus, type Command, type CommandResult, type CommandMap, type TargetOf, type PayloadOf, type ResultOf, type Handler, type Plugin, type RegisterOptions, type Listener } from './command-bus';
import { configureSignal, signal } from './signal';
import type { Signal } from './signal';
export type { Signal, CreateSignal } from './signal';
export { configureSignal };
export { signal };
/**
 * Wait for Vue detection to complete. Call this in app setup if you need
 * to guarantee Vue APIs are available before the first signal() call.
 *
 * @example
 * import { waitForVueDetection, signal } from 'vapor-chamber';
 * await waitForVueDetection();
 * const count = signal(0); // guaranteed to use Vue ref() if available
 */
export declare function waitForVueDetection(): Promise<void>;
/**
 * Returns true if Vue 3.6+ with Vapor mode support is detected.
 */
export declare function isVaporAvailable(): boolean;
/** @internal — for chamber-vapor.ts use only */
export declare function getVaporAppFn(): any;
/** @internal — for chamber-vapor.ts use only */
export declare function getVaporInteropRef(): any;
/** @internal — for chamber-vapor.ts use only */
export declare function getDefineVaporCustomElementFn(): any;
/** @internal — for chamber-vapor.ts use only */
export declare function getDefineVaporComponentFn(): any;
/** @internal — for chamber-vapor.ts use only */
export declare function getDefineVaporAsyncComponentFn(): any;
/** @internal — Vue's DEEP ref(), for the vapor-chamber/reactive companion only.
 *  Returns null until Vue detection completes (or if Vue is absent). */
export declare function getVueDeepRefFn(): (<T>(v: T) => {
    value: T;
}) | null;
/**
 * GlobalCommands — module-augmentation hook that types the SHARED bus
 * (pinia-style). Augment it once in your app and every `useCommand()` /
 * `getCommandBus()` call site gets typed dispatch/register with autocomplete
 * and compile errors:
 *
 * @example
 * declare module 'vapor-chamber' {
 *   interface GlobalCommands {
 *     cartAdd: { target: Product; payload: { qty: number }; result: Cart };
 *     cartClear: { target: null; result: Cart };
 *   }
 * }
 *
 * Unaugmented, everything stays exactly as loose as before (string actions,
 * `any` targets). Schema users: derive the entries with `CommandsOf<S>` from
 * './schema' instead of writing them by hand.
 */
export interface GlobalCommands {
}
/**
 * The CommandMap the shared bus is typed with: `GlobalCommands` when augmented,
 * the loose default `CommandMap` otherwise. Wrapped in a mapped type because
 * interfaces have no implicit index signature and would fail the CommandMap
 * constraint.
 */
export type SharedCommandMap = [keyof GlobalCommands] extends [never] ? CommandMap : {
    [K in keyof GlobalCommands]: GlobalCommands[K];
};
/**
 * Get the shared bus. Typed with {@link SharedCommandMap} — augment
 * {@link GlobalCommands} to make every call site typed. Pass an explicit map
 * to override per call site (`getCommandBus<CommandMap>()` opts back out).
 */
export declare function getCommandBus<M extends CommandMap = SharedCommandMap>(): CommandBus<M>;
/**
 * Replace the shared bus instance.
 *
 * SSR WARNING: the shared bus is a module global — one per Node process, not
 * per request. The set-render-reset pattern (see ssr.ts) is only safe when
 * requests render strictly one at a time. Under CONCURRENT SSR renders,
 * interleaved requests stomp each other's bus: handlers and state leak across
 * requests. For concurrent servers, don't use the shared bus on the server —
 * create a bus per request and pass it explicitly (every composable and plugin
 * accepts a `bus` option / argument).
 *
 * Accepts either bus flavor — the composables' dispatch path already handles
 * thenable results (`runDispatch` awaits them), so an AsyncCommandBus works at
 * runtime; previously callers had to cast. `getCommandBus()`'s static type
 * stays `CommandBus` for compatibility.
 */
export declare function setCommandBus(bus: CommandBus | AsyncCommandBus): void;
/**
 * Reset the shared bus to null. Useful in test teardown to prevent
 * handler/hook leaks between test files.
 */
export declare function resetCommandBus(): void;
/**
 * Try to register a cleanup function on the nearest Vue scope/component.
 *
 * Uses `getCurrentScope()` (Vue 3.2+) to check whether a reactive scope is
 * active before calling `onScopeDispose`. This replaces the earlier try/catch
 * pattern — no exception-as-control-flow, no `onUnmounted` fallback needed.
 *
 * In Vue 3.5+ (the minimum peer dep), every component `setup()` — including
 * Vapor components — is wrapped in an effect scope, so `getCurrentScope()`
 * inside setup always returns something. The `onUnmounted` fallback is
 * unreachable under Vue 3.5+ and has been removed.
 *
 * Vue 3.6.0-beta.13 (runtime-vapor: only create lifecycle update jobs when
 * needed): lifecycle update jobs are now created lazily — only when a component
 * actually has reactive state that can trigger updates. Registering
 * `onScopeDispose` via this function no longer causes a lifecycle update job
 * to be allocated for every vapor-chamber composable call. Components that use
 * vapor-chamber composables solely for dispatch (no reactive signals consumed
 * in the template) incur zero update-job overhead.
 *
 * No-ops entirely when called outside any Vue scope (e.g. module init time,
 * plain async callbacks). Caller is responsible for calling `dispose()` in
 * those cases.
 */
export declare function tryAutoCleanup(disposeFn: () => void): void;
/**
 * Register KeepAlive lifecycle hooks to pause/resume bus subscriptions.
 *
 * When a component is deactivated by KeepAlive, `onPause` is called.
 * When reactivated, `onResume` is called. No-ops if not inside a
 * KeepAlive-wrapped component or if Vue is not available.
 *
 * `getCurrentInstance()` is the correct guard: `onActivated`/`onDeactivated`
 * throw when called outside a component setup context, so the upfront check
 * replaces the earlier two try/catch blocks.
 *
 * @internal — used by composables that manage bus subscriptions.
 */
export declare function tryKeepAliveHooks(onPause: () => void, onResume: () => void): void;
/** @internal */
export declare function runDispatch(busCall: () => any, loading: Signal<boolean>, lastError: Signal<Error | null>, onSuccess?: (value: any) => void): CommandResult | Promise<CommandResult>;
/**
 * useCommand — reactive command dispatch with optional bus subscriptions.
 *
 * Returns `dispatch` + reactive `loading` / `lastError`, plus `register` / `on` /
 * `emit` for managing handlers and listeners with auto-cleanup on scope disposal
 * (`onScopeDispose`). Vapor-safe — works in `<script setup vapor>` and VDOM alike,
 * with no `getCurrentInstance()` dependency. For fire-and-forget with zero reactive
 * overhead, use `defineVaporCommand()` instead.
 *
 * (Absorbed the former `useVaporCommand` — the Vapor-safety distinction was obsolete;
 * this is now the single command composable.)
 *
 * @example
 * const { dispatch, register, on, loading, lastError } = useCommand();
 * register('cartAdd', (cmd) => addToCart(cmd.target));
 * dispatch('cartAdd', { id: product.id });
 */
export declare function useCommand(): {
    dispatch: <A extends keyof SharedCommandMap & string>(action: A, target: TargetOf<SharedCommandMap, A>, payload?: PayloadOf<SharedCommandMap, A>) => CommandResult<ResultOf<SharedCommandMap, A>> | Promise<CommandResult<ResultOf<SharedCommandMap, A>>>;
    register: <A extends keyof SharedCommandMap & string>(action: A, handler: (cmd: Command<A, TargetOf<SharedCommandMap, A>, PayloadOf<SharedCommandMap, A>>) => ResultOf<SharedCommandMap, A> | Promise<ResultOf<SharedCommandMap, A>>, opts?: RegisterOptions) => () => void;
    on: (pattern: string, listener: (cmd: Command, result: CommandResult) => void) => () => void;
    emit: (event: string, data?: any) => void;
    loading: Signal<boolean>;
    lastError: Signal<Error | null>;
    dispose: () => void;
};
export type UseSharedCommandStateOptions = {
    /**
     * How many recent errors to retain in `errors`. The list is kept
     * newest-last; older entries drop off. Default: 10.
     */
    errorCap?: number;
    /**
     * Bus to attach to. Defaults to the shared instance from `getCommandBus()`,
     * which matches the single-bus pattern most apps use. Pass an explicit bus
     * to scope shared state to a feature group / island.
     */
    bus?: CommandBus;
};
/**
 * useSharedCommandState — one set of reactive signals shared across every
 * caller, instead of two signals (`loading`, `lastError`) per call.
 *
 * Designed for component-heavy pages where many components need to react to
 * "is *anything* in flight?" or "what was the last error?". Replaces
 * `N × useCommand()` allocations with a single shared state per bus.
 *
 * Memory math: 50 components × 2 signals each = 100 signal nodes today.
 * With shared state: ~5 signal nodes total + a counter, regardless of
 * subscriber count.
 *
 * @example
 * // Components using this share isAnyLoading, errors, etc.
 * const { dispatch, isAnyLoading, lastError } = useSharedCommandState();
 * await dispatch('cartAdd', product);
 *
 * @example
 * // Disable an entire toolbar while any command is in flight.
 * const { isAnyLoading } = useSharedCommandState();
 * <Button :disabled="isAnyLoading.value">Save</Button>
 *
 * Auto-cleanup on Vue scope/component disposal via tryAutoCleanup.
 */
export declare function useSharedCommandState(options?: UseSharedCommandStateOptions): {
    dispatch: (action: string, target: any, payload?: any, opts?: {
        signal?: AbortSignal;
    }) => CommandResult | Promise<CommandResult>;
    /** Number of dispatches currently in flight across all subscribers. */
    inFlight: Signal<number>;
    /** True when `inFlight > 0`. Bind to button `disabled` etc. */
    isAnyLoading: Signal<boolean>;
    /** Most recent error (across all subscribers). */
    lastError: Signal<Error | null>;
    /** Ring buffer of recent errors, newest last, capped at `errorCap`. */
    errors: Signal<Error[]>;
    /** Current size of the `errors` buffer. */
    errorCount: Signal<number>;
    /** Wipe accumulated errors. */
    clear: () => void;
    /** Manually unhook. Most callers don't need this — `tryAutoCleanup`
     *  hooks Vue's scope/unmount lifecycle. */
    dispose: () => void;
};
export type UseCommandStateOptions = {
    /**
     * When true, multiple synchronous dispatches within the same microtask are
     * accumulated and the signal is written once via `queueMicrotask`. Pairs with
     * Vue 3.6.0-beta.12's v-for source coalescing: our side defers the signal
     * write, Vue's runtime coalesces the resulting DOM update into one pass.
     *
     * Vue 3.6.0-beta.13: v-for consumers of coalesced state benefit from two
     * additional runtime optimizations — specialized v-for block operations
     * (runtime-vapor: specialize v-for block operations) and reduced v-if branch
     * scope overhead (runtime-vapor: reduce v-if branch scope overhead). Signal
     * writes flushed here land into a faster Vapor runtime patch path.
     *
     * Trade-off: 1 microtask of signal latency. Use for arrays consumed by v-for
     * that receive rapid bulk updates (batch dispatch, form field arrays, scroll
     * position lists). Default: false (immediate write per dispatch).
     */
    coalesce?: boolean;
};
/**
 * useCommandState - create reactive state that updates via commands.
 *
 * Auto-cleanup on Vue component unmount or scope disposal.
 *
 * @example
 * // Immediate mode (default):
 * const { state } = useCommandState([], { cartAdd: (s, cmd) => [...s, cmd.target] });
 *
 * @example
 * // Coalesced mode — batch writes for v-for lists:
 * const { state } = useCommandState([], { cartAdd: (s, cmd) => [...s, cmd.target] }, { coalesce: true });
 */
export declare function useCommandState<T>(initial: T, handlers: {
    [action: string]: (state: T, cmd: Command) => T;
}, options?: UseCommandStateOptions): {
    state: Signal<T>;
    dispose: () => void;
};
/**
 * @internal — shared core for `useCommandState` (shallow, default) and the
 * opt-in `useDeepCommandState` from `vapor-chamber/reactive` (deep). The only
 * difference between the two is the `createSignal` factory: the core passes the
 * shallow `signal()`; the companion passes a deep `ref()`-backed factory. All
 * dispatch/coalesce/cleanup logic is identical and lives here so the two
 * variants can never drift.
 */
export declare function _createCommandState<T>(initial: T, handlers: {
    [action: string]: (state: T, cmd: Command) => T;
}, options: UseCommandStateOptions, createSignal: <V>(v: V) => Signal<V>): {
    state: Signal<T>;
    dispose: () => void;
};
/**
 * useCommandBus - lightweight composable wrapper around the shared bus.
 * Typed via GlobalCommands augmentation, same as getCommandBus().
 */
export declare function useCommandBus<M extends CommandMap = SharedCommandMap>(): CommandBus<M>;
/**
 * useCommandHistory - undo/redo with reactive state
 *
 * Auto-cleanup on Vue component unmount or scope disposal.
 * Undo executes inverse handlers when registered via register(action, handler, { undo }).
 */
export declare function useCommandHistory(options?: {
    maxSize?: number;
    filter?: (cmd: Command) => boolean;
}): {
    past: Signal<Command[]>;
    future: Signal<Command[]>;
    canUndo: Signal<boolean>;
    canRedo: Signal<boolean>;
    undo: () => Command | undefined;
    redo: () => Command | undefined;
    clear: () => void;
    dispose: () => void;
};
/**
 * useCommandQuery — CQRS read-side composable with reactive state.
 *
 * Wraps bus.query() with reactive `data`, `loading`, and `lastError` signals.
 * query() skips onBefore hooks (no auth gates, no loading spinners for reads)
 * but runs plugins, handlers, and afterHooks.
 *
 * Supports both sync and async buses — if the result is a Promise, loading
 * stays true until it resolves.
 *
 * @example
 * const { query, data, loading, lastError } = useCommandQuery();
 * const result = query('getUser', { id: 42 });
 * // data.value = result.value after query completes
 */
export declare function useCommandQuery(): {
    query: (action: string, target: any, payload?: any) => CommandResult | Promise<CommandResult>;
    data: Signal<any>;
    loading: Signal<boolean>;
    lastError: Signal<Error | null>;
};
/**
 * useCommandGroup — namespace isolation for large apps and multi-team projects.
 *
 * All dispatch/register/on calls are automatically prefixed with the namespace
 * in camelCase. This prevents action name collisions when composing multiple
 * feature modules.
 *
 * @example
 * // Cart feature
 * const cart = useCommandGroup('cart')
 * cart.register('add', handler)    // registers 'cartAdd'
 * cart.dispatch('add', product)    // dispatches 'cartAdd'
 * cart.on('*', listener)           // listens to 'cart*'
 *
 * // Orders feature — completely isolated
 * const orders = useCommandGroup('orders')
 * orders.dispatch('cancel', { id }) // dispatches 'ordersCancel'
 */
export declare function useCommandGroup(namespace: string): {
    dispatch: (action: string, target: any, payload?: any) => CommandResult;
    query: (action: string, target: any, payload?: any) => CommandResult;
    emit: (event: string, data?: any) => void;
    register: (action: string, handler: Handler, opts?: RegisterOptions) => () => void;
    use: (plugin: Plugin) => () => void;
    on: (pattern: string, listener: Listener) => () => void;
    namespace: string;
    dispose: () => void;
};
/**
 * useCommandError — component-scoped error boundary for command failures.
 *
 * Subscribes to the bus and captures all failed command results reactively.
 * Optional filter narrows which actions are tracked.
 *
 * @example
 * const { latestError, errors, clearErrors } = useCommandError()
 *
 * // Only watch cart commands
 * const { latestError } = useCommandError({ filter: cmd => cmd.action.startsWith('cart') })
 */
export declare function useCommandError(options?: {
    filter?: (cmd: Command) => boolean;
    /** Max errors retained — oldest are dropped first (ring buffer). Default: 50. */
    errorCap?: number;
}): {
    errors: Signal<{
        cmd: Command;
        error: Error;
        timestamp: number;
    }[]>;
    latestError: Signal<Error | null>;
    clearErrors: () => void;
    dispose: () => void;
};
//# sourceMappingURL=chamber.d.ts.map