export { computed, effect, signal } from 'alien-signals';

/** List of valid HTML DOM swap methods. */
declare const SWAP_METHODS: readonly ["innerHTML", "outerHTML", "beforebegin", "afterbegin", "beforeend", "afterend", "delete"];
/** Represents a valid DOM swap method string. */
type SwapMethod = (typeof SWAP_METHODS)[number];
/** Modifiers naming a host for the listener other than the element itself. */
declare const LISTEN_TARGETS: readonly ["window", "document", "root"];
type ListenTarget = (typeof LISTEN_TARGETS)[number];

/** Receives the store roots that changed in one batch of user edits. */
type EditListener = (roots: ReadonlySet<string>) => void;
interface StoreStatus {
    loading: false | 'push' | 'pull';
    error: string | null;
    lastSync: number;
    dirty: Record<string, boolean>;
}
/**
 * A store's standing sync policy. Seeded at init, applied to every push and pull.
 *
 * `indicator` is deliberately absent: it belongs to the trigger, not the store. A
 * store has many triggers, and `resolveIndicators` takes a single value, so a
 * policy-level indicator would silently override every trigger's `rz-indicator`.
 */
interface SyncPolicy extends Omit<SyncRequest, 'url' | 'indicator'> {
    /** Endpoint for push and pull. */
    url: string;
}
interface StoreRequestOptions {
    url?: string;
    /** `triggerEl` is omitted: the top-level field is its only home. */
    overrides?: Omit<SyncRequest, 'triggerEl'>;
    nestedPath?: string;
    triggerEl?: Element;
}
/**
 * The central manager for all reactive stores and their network logic.
 * Instantiated once per RouseApp to ensure isolation.
 */
declare class StoreManager {
    private app;
    private _stores;
    private _pendingFlush;
    private _isPatching;
    constructor(app: RouseApp);
    private _setConfig;
    private _register;
    private _getStore;
    /**
     * Advances the `lastGood` baseline to `source`, whole or at a single root,
     * and reconciles the dirty flags that move with it.
     */
    private _updateLastGood;
    /**
     * Recomputes dirty flags against `lastGood`. The only writer of `status.dirty`.
     * Without `roots`, walks every root in the data or the baseline, so a root
     * deleted locally still reads dirty.
     */
    private _reconcileDirty;
    private _dispatchPatchEvent;
    /**
     * Internal unified request handler for push and pull operations.
     */
    private _request;
    /**
     * Sends the request and applies the outcome to the store: rolls back a failed push,
     * otherwise reconciles the response. Tracks the request so a superseded one leaves
     * `loading` alone when it settles.
     */
    private _sendAndApply;
    private _applyServerResponse;
    /**
     * Applies the payload to the store as a JSON Merge Patch, whole or at
     * `nestedPath`. A path absent from the payload writes nothing; a `null` at the
     * path removes the slice.
     */
    private _patchPayload;
    /**
     * Runs a framework write with dirty tracking suppressed, then reconciles the
     * dirty flags against the baseline. Every framework mutation of store data
     * goes through here, so the reconcile cannot be forgotten.
     */
    private _withPatchGuard;
    /**
     * Patches the store's data, then makes it the new baseline: both restore targets
     * (`reset()` and rollback) and the dirty flags are refreshed to match.
     */
    private _adoptState;
    /** Writes `value` into the store's data, whole or at `path`, as a framework write. */
    private _writeSlice;
    private _maybeRollback;
    /**
     * Queues a store for end-of-microtask reconciliation, coalescing a batch of
     * synchronous writes into one dirty recompute and one round of notifications.
     */
    private _scheduleFlush;
    /**
     * Listens for user-driven mutations to the store. Returns a cleanup function.
     *
     * The store must already exist. Stores declared in markup using `<script data-rz-store>`
     * are registered during `start()`, so subscribe after that call rather than before it.
     */
    onEdit(storeName: string, callback: EditListener): VoidFn;
    /**
     * Retrieves the source `<script data-rz-store>` element for a registered store.
     */
    elementFor(storeName: string): Element | undefined;
    /**
     * Returns an iterable object containing every `<script data-rz-store>` element
     * registered in the store manager.
     */
    elements(): Iterable<Element>;
    /**
     * Registers a new store and returns its reactive proxy.
     */
    create<T extends object = any>(storeName: string, state: T, config?: Partial<SyncPolicy>, el?: Element): T;
    /**
     * Replaces the store's data, then clears dirty flags and refreshes both
     * snapshots: the one `reset()` restores to, and the last-good state a failed push
     * rolls back to. To change the store's sync configuration, use `config()`.
     */
    update<T extends object = any>(storeName: string, state: object): T;
    /**
     * Writes a payload into a store as a JSON Merge Patch, the way a fetch response
     * routed by `data-rz-target="@store"` does. Fires the same events a push or pull
     * fires, so a listener sees one shape whatever produced the payload.
     *
     * @returns `false` if the store does not exist or a listener canceled the patch.
     */
    deposit(storeName: string, payload: object, options?: {
        response?: RouseResponse;
    }): boolean;
    /**
     * Returns the reactive proxy for a store, or `undefined`.
     */
    get<T extends object = any>(storeName: string): T | undefined;
    /**
     * Returns a deep-cloned non-reactive copy of the store's current data.
     */
    snapshot<T = any>(storeName: string): T | undefined;
    /**
     * Returns a copy of the last synced state: what a push or pull last confirmed,
     * or what `commit()`, `update()`, or `deposit()` last asserted. This is the
     * reference point for unsaved changes and the target a failed push rolls back
     * to. Non-reactive, like `snapshot()`.
     */
    baseline<T = any>(storeName: string): T | undefined;
    /**
     * Returns `true` if a store with the provided name exists.
     */
    has(storeName: string): boolean;
    /**
     * Returns the status object for a store, or `undefined`. Available store
     * status properties are `loading`, `error`, `lastSync`, and `dirty`.
     */
    status(storeName: string): StoreStatus | undefined;
    /**
     * Returns `true` when the store has unsaved changes. Pass a dot path to ask
     * about a single field or branch instead of the whole store.
     *
     * Without a path the answer comes from the store's status, which updates a
     * microtask after an edit. With a path the comparison runs on the spot.
     */
    isDirty(storeName: string, path?: string): boolean;
    /**
     * Patches `SyncPolicy` for a store. Warns if the store is missing.
     */
    config(storeName: string, config: Partial<SyncPolicy>): void;
    /**
     * Triggers a manual store push with optional request overrides.
     */
    push(storeName: string, config?: StoreRequestOptions): Promise<void>;
    /**
     * Pulls fresh store data from the server, unless a push is currently in flight.
     */
    pull(storeName: string, config?: StoreRequestOptions): Promise<void>;
    /**
     * Restores the store to its initial state, and makes that the new baseline,
     * so nothing reads as dirty afterward.
     *
     * To restore the last state the server confirmed instead, use `revert()`.
     */
    reset(storeName: string): void;
    /**
     * Discards unsaved changes, restoring the store to the last synced state, which
     * `baseline()` returns. Pass a dot path to revert a single field or branch
     * instead of the whole store. Returns `true` if anything changed.
     *
     * To restore the state the store started with, use `reset()`.
     */
    revert(storeName: string, path?: string): boolean;
    /**
     * Marks the store's current data as the new baseline, so nothing reads as dirty.
     * Does not send anything to the server. Use it when state reached the server by
     * some means Rouse did not perform, such as a native form submit or a socket
     * acknowledgement.
     */
    commit(storeName: string): void;
    /**
     * Drops all per-store state from the manager. Existing references to the proxy
     * keep working but desync. Intended for tear-down of dynamically-created stores.
     */
    remove(storeName: string): void;
}

/** Detail for `rz:app:start`, `rz:app:ready`, and `rz:app:destroy`. */
interface AppEventDetail {
    /** The app instance the event fired from. */
    app: RouseApp;
}
/** Detail for `rz:scope:init`. */
interface ScopeInitDetail {
    /** The context passed into the scope's setup function. */
    context: ScopeCtx;
    /** The scope object the setup function returned. */
    instance: Scope;
}
/** Detail for `rz:scope:connect` and `rz:scope:disconnect`. */
interface ScopeLifecycleDetail {
    /** The scope whose bindings were attached (connect) or detached (disconnect). */
    instance: Scope;
}
/** Detail for `rz:fetch:config`. */
interface FetchConfigDetail {
    /**
     * The final unified request config. Mutable in place by listeners; replacing the object
     * has no effect on the request. Carries `method` but not the resolved `url`.
     */
    config: FetchRequest;
    /** The resolved request URL actually fetched. Surfaced here because `config` does not carry it. */
    url: string;
    /** The resolved HTTP method. Also present on `config`; duplicated here for convenience. */
    method: string;
}
/**
 * Detail for `rz:fetch:start`, `rz:fetch:abort`, and `rz:fetch:end`. The config
 * detail minus the request-identifying fields, which only `:config` carries.
 */
type FetchLifecycleDetail = Omit<FetchConfigDetail, 'url' | 'method'>;
/** Detail for `rz:fetch:success`: the full response object. */
type FetchSuccessDetail = RouseResponse;
/** Detail for `rz:fetch:success:json`: response with a parsed-JSON body (object/array). */
type FetchSuccessJsonDetail = RouseResponse<Record<string, any> | any[]>;
/** Detail for `rz:fetch:success:html`: response with an HTML/text body. */
type FetchSuccessHtmlDetail = RouseResponse<string>;
/** Detail for `rz:fetch:success:file`: response with a binary body (Blob/ArrayBuffer). */
type FetchSuccessFileDetail = RouseResponse<Blob | ArrayBuffer>;
/** Detail for `rz:fetch:error`: the full response object. */
type FetchErrorDetail = RouseResponse;
/** Detail for `rz:fetch:error:json`: error response with a parsed-JSON body (object/array). */
type FetchErrorJsonDetail = RouseResponse<Record<string, any> | any[]>;
/** Detail for `rz:fetch:error:html`: error response with an HTML/text body. */
type FetchErrorHtmlDetail = RouseResponse<string>;
/** Detail for `rz:fetch:error:file`: error response with a binary body (Blob/ArrayBuffer). */
type FetchErrorFileDetail = RouseResponse<Blob | ArrayBuffer>;
/** Detail for `rz:push:config` and `rz:pull:config`; cancelable. Listeners can mutate `config`. */
interface PushPullConfigDetail {
    /** Name of the store being synced. */
    storeName: string;
    /**
     * The final unified request config. Mutable in place by listeners; replacing the object
     * has no effect on the request. Carries `method` but not the resolved `url`.
     */
    config: FetchRequest;
    /** The resolved request URL. */
    url: string;
    /** The resolved HTTP method. */
    method: string;
}
/**
 * Detail for `rz:push`/`rz:pull` `:start`, `:abort`, and `:end`. The config detail
 * minus the request-identifying fields, which only `:config` carries.
 */
type PushPullLifecycleDetail = Omit<PushPullConfigDetail, 'url' | 'method'>;
/** Detail for `rz:push`/`rz:pull` `:success` and `:error`: the full response, plus the store name. */
interface PushPullResultDetail {
    /** Name of the store being synced. */
    storeName: string;
    /** The full response object that settled the request. */
    result: RouseResponse;
}
/** Shared fields present on every `rz:store:patch:*` event detail. */
interface BaseStorePatch {
    /** Name of the store being patched. */
    storeName: string;
    /** Network operation that produced the payload. */
    operation: 'push' | 'pull' | 'fetch';
    /** Dot-path of the targeted slice, when only part of the store was patched. */
    nestedPath?: string;
}
/** Detail for `rz:store:patch`. */
interface StorePatchDetail extends BaseStorePatch {
    /** The store's local data after the successful patch. */
    data: any;
    /** The response that drove the patch. */
    response?: RouseResponse;
    /** The server payload applied to the store, when provided. */
    payload?: any;
}
/** Detail for `rz:store:patch:before`. */
interface StorePatchBeforeDetail extends BaseStorePatch {
    /** The store's current local data, about to be patched. */
    data: any;
    /** The server payload about to be applied, when provided. */
    payload?: any;
}
/** Detail for `rz:store:patch:skipped`. */
interface StorePatchSkippedDetail extends BaseStorePatch {
    /** The local slice with unsaved edits that was kept. */
    localData: any;
    /** The incoming server slice that was not applied. */
    serverData: any;
    /** The response carrying the server data. */
    response: RouseResponse;
}
/** Detail for `rz:store:patch:rollback`. */
interface StorePatchRollbackDetail extends BaseStorePatch {
    /** The store's local data after the rollback (now equal to the last-good snapshot). */
    data: any;
    /** The last-good snapshot the state was reverted to. */
    rolledBackTo: any;
    /** The push error that triggered the rollback. */
    error: unknown;
}
/** Detail for `rz:dom:swap:before` and `rz:dom:swap`. */
interface DomSwapDetail {
    /** The element being mutated. */
    target: Element;
    /** The swap method used to apply the payload. */
    method: SwapMethod;
    /** The HTML string to insert. Mutable by `rz:dom:swap:before` listeners. */
    payload: string;
    /** Whether the swap originated from a fetch response or a programmatic `swap()` call. */
    source: 'fetch' | 'programmatic';
}
/** Maps every lifecycle event name to the shape of `event.detail`. */
interface LifecycleEventMap {
    /** Fires when the app starts, before the initial directive scan. */
    'rz:app:start': AppEventDetail;
    /** Fires after the initial scan completes and the app is ready. */
    'rz:app:ready': AppEventDetail;
    /** Fires when the app instance is destroyed. */
    'rz:app:destroy': AppEventDetail;
    /** Fires after the setup function runs, before bindings attach. */
    'rz:scope:init': ScopeInitDetail;
    /** Fires when scope bindings are attached. */
    'rz:scope:connect': ScopeLifecycleDetail;
    /** Fires when scope bindings are detached. */
    'rz:scope:disconnect': ScopeLifecycleDetail;
    /** Fires when the scope is torn down. */
    'rz:scope:destroy': undefined;
    /** Fires before the request is sent; cancelable. Listeners can mutate `config`. */
    'rz:fetch:config': FetchConfigDetail;
    /** Fires when the fetch starts, after config. */
    'rz:fetch:start': FetchLifecycleDetail;
    /** Fires if the fetch is aborted. */
    'rz:fetch:abort': FetchLifecycleDetail;
    /** Fires when the request settles, after success or error. */
    'rz:fetch:end': FetchLifecycleDetail;
    /** Fires when the request completes with an OK status. */
    'rz:fetch:success': FetchSuccessDetail;
    /** Fires after `rz:fetch:success` when the body is parsed JSON (object/array). */
    'rz:fetch:success:json': FetchSuccessJsonDetail;
    /** Fires after `rz:fetch:success` when the body is HTML/text. */
    'rz:fetch:success:html': FetchSuccessHtmlDetail;
    /** Fires after `rz:fetch:success` when the body is a Blob/ArrayBuffer. */
    'rz:fetch:success:file': FetchSuccessFileDetail;
    /** Fires when the request fails (non-OK status, network error, or cancellation). */
    'rz:fetch:error': FetchErrorDetail;
    /** Fires after `rz:fetch:error` when the body is parsed JSON (object/array). */
    'rz:fetch:error:json': FetchErrorJsonDetail;
    /** Fires after `rz:fetch:error` when the body is HTML/text. */
    'rz:fetch:error:html': FetchErrorHtmlDetail;
    /** Fires after `rz:fetch:error` when the body is a Blob/ArrayBuffer. */
    'rz:fetch:error:file': FetchErrorFileDetail;
    /** Fires before a push is sent; cancelable. Listeners can mutate `config`. */
    'rz:push:config': PushPullConfigDetail;
    /** Fires when the push starts, after config. */
    'rz:push:start': PushPullLifecycleDetail;
    /** Fires if the push is aborted (overlapping programmatic pushes sharing an abortKey). */
    'rz:push:abort': PushPullLifecycleDetail;
    /** Fires when the push completes with an OK status. */
    'rz:push:success': PushPullResultDetail;
    /** Fires when the push fails (non-OK status or network error). */
    'rz:push:error': PushPullResultDetail;
    /** Fires when the push settles, after success/error/abort. */
    'rz:push:end': PushPullLifecycleDetail;
    /** Fires before a pull is sent; cancelable. Listeners can mutate `config`. */
    'rz:pull:config': PushPullConfigDetail;
    /** Fires when the pull starts, after config. */
    'rz:pull:start': PushPullLifecycleDetail;
    /** Fires if the pull is aborted (overlapping programmatic pulls sharing an abortKey). */
    'rz:pull:abort': PushPullLifecycleDetail;
    /** Fires when the pull completes with an OK status. */
    'rz:pull:success': PushPullResultDetail;
    /** Fires when the pull fails (non-OK status or network error). */
    'rz:pull:error': PushPullResultDetail;
    /** Fires when the pull settles, after success/error/abort. */
    'rz:pull:end': PushPullLifecycleDetail;
    /** Fires before a payload is applied to the local store; cancelable, and `payload` is mutable. Check `detail.operation` for what produced it. */
    'rz:store:patch:before': StorePatchBeforeDetail;
    /** Fires after a payload has been applied to the local store. Check `detail.operation` for what produced it. */
    'rz:store:patch': StorePatchDetail;
    /** Fires when the response carries server data but the store was edited while the request was in flight, so the server data is not applied and the local edit is kept. Push and pull only. */
    'rz:store:patch:skipped': StorePatchSkippedDetail;
    /** Fires after `rz:push:error` when local state is reverted to the last-good snapshot. */
    'rz:store:patch:rollback': StorePatchRollbackDetail;
    /** Fires before the swap executes; cancelable. Listeners can mutate `payload`. */
    'rz:dom:swap:before': DomSwapDetail;
    /** Fires after the swap has been applied to the DOM. */
    'rz:dom:swap': DomSwapDetail;
}
/** Union of every lifecycle event name the framework can dispatch. */
type LifecycleEvent = keyof LifecycleEventMap;
/** Any value that a reactive directive can bind to. Objects are used for conditional class/style maps; primitives for direct output. */
type BindableValue = string | string[] | number | boolean | null | undefined | Record<string, boolean> | Record<string, string>;
/** A no-argument, no-return function. */
type VoidFn = () => void;
/** The object returned by a setup function. Includes standard lifecycle hooks and custom state/methods. */
type Scope = Record<string, any> & {
    /** Lifecycle hook, run when the scope connects (bindings attached). */
    connect?: () => void;
    /** Lifecycle hook, run when the scope disconnects (bindings detached). */
    disconnect?: () => void;
};
/**
 * The canonical, resolved representation of a trigger's modifiers.
 *
 * The HTML grammar (`click|debounce-300ms.once`) is its serialized form, produced by
 * `parseTriggers`. Consumers read fields from this object rather than scanning tokens.
 */
interface TriggerOptions {
    /** Remove the listener after it fires. Events rejected by a filter don't count. */
    once?: boolean;
    /** Listen during the capture phase. */
    capture?: boolean;
    /** Attach as a passive listener. */
    passive?: boolean;
    /** Attach the listener elsewhere. Filters and trigger sources still act on the element. */
    listenOn?: ListenTarget;
    /** Fire only for events originating outside the element. Listens on `document`. */
    outside?: boolean;
    /** Fire only when the element is the event target, not a descendant. */
    self?: boolean;
    /** Allow unrequested system modifiers to be held. */
    loose?: boolean;
    /** `KeyboardEvent.key` value(s) to match, compared case-insensitively. */
    key?: string | string[];
    /** Require the Control key. */
    ctrl?: boolean;
    /** Require the Alt key. */
    alt?: boolean;
    /** Require the Shift key. */
    shift?: boolean;
    /** Require the Meta key. */
    meta?: boolean;
    /** Call `preventDefault()` before the action runs. */
    prevent?: boolean;
    /** Call `stopPropagation()` before the action runs. */
    stop?: boolean;
    /** Call `stopImmediatePropagation()` before the action runs. */
    stopImmediate?: boolean;
    /** Debounce the action. `true` uses the default wait. */
    debounce?: number | string | true;
    /** Throttle the action. `true` uses the default wait. */
    throttle?: number | string | true;
    /** Run on the leading edge of the timing window. */
    leading?: boolean;
    /** Run on the trailing edge of the timing window. */
    trailing?: boolean;
    /** Delay or period for the `timeout` and `interval` trigger sources. */
    wait?: number | string;
    /** Media query for the `media` trigger source. */
    query?: string;
}
/**
 * The event type a name yields: a lifecycle event's typed detail, a native event's
 * own type, or `CustomEvent<any>` for names the DOM doesn't define.
 */
type TriggerEvent<S extends string> = S extends keyof LifecycleEventMap ? CustomEvent<LifecycleEventMap[S]> : S extends keyof HTMLElementEventMap ? HTMLElementEventMap[S] : S extends keyof WindowEventMap ? WindowEventMap[S] : CustomEvent<any>;
/** A listener callback, or an object with `handleEvent`, as `addEventListener` accepts. */
type EventCallback<E> = ((ev: E) => void) | {
    handleEvent(ev: E): void;
};
/**
 * Custom error statuses for non-HTTP failures.
 *
 * - `CANCELED`: User or AbortController canceled the request.
 * - `TIMEOUT`: Request exceeded timeout threshold.
 * - `NETWORK_ERROR`: Fetch failed (offline, DNS, CORS, etc.).
 * - `PARSE_ERROR`: Response body couldn't be parsed.
 * - `INTERNAL_ERROR`: Unexpected error in request engine.
 * - `REDIRECTED`: Cross-origin redirect refused by the fetch engine.
 */
type CustomErrorStatus = 'CANCELED' | 'TIMEOUT' | 'NETWORK_ERROR' | 'PARSE_ERROR' | 'INTERNAL_ERROR' | 'REDIRECTED';
/** HTTP status codes (2xx-5xx) or custom error status. */
type ErrorStatus = CustomErrorStatus | number;
/** Normalized error object. Can include a parsed response body for non-OK HTTP responses (JSON object/array or text/HTML string). */
interface RequestError {
    /** Human-readable description of the failure. */
    message: string;
    /** HTTP status code, or a custom status for non-HTTP failures. */
    status: ErrorStatus;
    /** The underlying thrown value (native `Error`, `DOMException`, etc.) for non-HTTP failures. */
    original?: any;
    /** Parsed error-response body, for inspection. Aliases `result.data`. Mutating it affects what gets routed/rendered. */
    body?: unknown;
    /** Present with a PARSE_ERROR status; describes why the response body couldn't be parsed. */
    parseError?: string;
}
/** Request options shared by `rz-fetch` and store sync (`rz-push`/`rz-pull`). */
interface BaseRequestConfig {
    /** The request URL. */
    url?: string;
    /** CSS selector for elements to receive the rouse request class for the duration of the request. */
    indicator?: string | null;
    /**
     * The element that initiated the request. Set by the declarative path; programmatic
     * requests leave it unset unless the caller supplies one.
     */
    triggerEl?: Element;
    /** Request headers. A `null` value removes the header. Empty strings are sent as-is. */
    headers?: Record<string, string | null>;
    /** Appended to the URL as query-string parameters. */
    params?: Record<string, string | number | boolean | null | undefined | string[] | number[]>;
    /** Skip all registered interceptors for this request. Programmatic only. */
    skipInterceptors?: boolean;
    /** Abort the request after this many milliseconds. */
    timeout?: number;
    /** Requests sharing the same key cancel each other; the last one wins. */
    abortKey?: string | symbol;
}
/** Options for a fetch. */
interface FetchConfig extends BaseRequestConfig {
    /** Request body. Plain objects/arrays are JSON-serialized; a `BodyInit` is sent as-is. */
    body?: BodyInit | Record<string, any> | any[] | null | undefined;
    /** Serialize and send this form's data as the request body. */
    form?: HTMLFormElement;
}
/** The final unified options object for a fetch. */
type FetchRequest = Omit<RequestInit, 'body' | 'headers'> & FetchConfig;
/**
 * The authoring surface for a store push or pull. A push body is the store's own data
 * and a pull carries none, so `body` and `form` are absent by design. `method` is absent
 * too: a push is always `PATCH` (RFC 7396 merge patch), and a pull always `GET`.
 */
type SyncRequest = Omit<RequestInit, 'body' | 'headers' | 'method'> & BaseRequestConfig;
/**
 * The callable fetch surface. The HTTP method comes from `options.method`,
 * defaulting to `GET`.
 */
type RouseFetch = (resource: string, options?: FetchRequest) => Promise<RouseResponse>;
/** The enhanced response object returned by `ctx.fetch` and `request()`. */
interface RouseResponse<T = any> {
    /** Parsed response body, or `null` on error or empty response. */
    data: T | null;
    /** Populated on non-OK responses or network failures; `null` on success. */
    error: RequestError | null;
    /** The raw `Response` object from `fetch`, or `null` for non-HTTP failures. */
    response: Response | null;
    /** Flattened response headers as a plain object, or `null` for non-HTTP failures. */
    headers: Record<string, string> | null;
    /** HTTP status code, or `null` for non-HTTP failures. */
    status: number | null;
    /** The resolved request config that produced this response. */
    config: FetchRequest;
    /** Server-supplied swap target override (`Rouse-Target` header), if present. */
    targetOverride?: string | null;
}
/** Runs before a request is sent. Return a modified config to override request options. */
type RequestInterceptor = (config: FetchRequest) => FetchRequest | Promise<FetchRequest>;
/** Runs after a successful response is received. Return a modified value to override response data. */
type ResponseInterceptor = (data: any, response: Response, config: FetchRequest) => any | Promise<any>;
/** Runs when a request fails. Return a modified error to override what propagates. */
type ErrorInterceptor = (error: RequestError, config: FetchRequest) => RequestError | Promise<RequestError>;
/**
 * A scope setup function. Receives a `ScopeCtx` and returns a `Scope` object
 * whose properties become the scope's reactive state and methods.
 *
 * @template P - The type of the params object.
 * @template E - The Element type.
 */
type ScopeSetup<P extends Record<string, any> = Record<string, any>, E extends Element = HTMLElement> = (ctx: ScopeCtx<P, E>) => Scope;
/** Options for `app.on` and `ctx.on`: a trigger's modifiers, plus a caller abort signal. */
type ListenerOptions = TriggerOptions & {
    /** Combined with the app or scope lifetime signal. Aborting removes the listeners. */
    signal?: AbortSignal;
};
/**
 * The overload shape shared by `app.on` and `ctx.on`. Listens on a default
 * target (the app root or the scope host) unless an `EventTarget` is passed
 * first. Modifiers, filters, and timing are passed as options, along with an
 * optional `AbortSignal` combined with the owner's lifetime signal. Returns a
 * teardown function.
 */
type BoundOn = {
    <N extends string>(events: N | N[], callback: EventCallback<TriggerEvent<N>>, options?: ListenerOptions): VoidFn;
    <N extends string>(target: EventTarget, events: N | N[], callback: EventCallback<TriggerEvent<N>>, options?: ListenerOptions): VoidFn;
};
/**
 * The context object passed into every scope setup function.
 *
 * @template P - The type of the params object.
 * @template E - The Element type.
 */
type ScopeCtx<P extends Record<string, any> = Record<string, any>, E extends Element = HTMLElement> = {
    /** Scope parameters injected via inline JSON, <script> id reference, or store reference. */
    params: P;
    /** The `rz-scope` element this scope is mounted on. */
    host: E;
    /** The root element passed to `RouseApp`. */
    appRoot: HTMLElement;
    /** Access to all registered stores. */
    stores: StoreManager;
    /** Aborted when the scope is destroyed. Use to clean up scope-defined subscriptions. */
    term: AbortSignal;
    /** Scoped `fetch` surface. Aborts on scope destroy. */
    fetch: RouseFetch;
    /**
     * Adds an event listener that is auto-removed when the scope is destroyed. Listens
     * on the scope host unless an `EventTarget` is passed first. Modifiers, filters, and
     * timing are passed as options, with an optional `AbortSignal` combined with the
     * scope's own (`term`). The programmatic twin of `rz-on`, with the same trigger
     * sources. Returns a teardown function.
     */
    on: BoundOn;
    /** Scan a newly added DOM subtree for directives and initialize them. */
    scan: (newNode: Element) => void;
};
/**
 * The context passed to handler functions: event handlers, one-way binding
 * formatters, and other scope/store methods.
 *
 * @template P - The type of the params object.
 * @template E - The Element type.
 */
type HandlerCtx<P = Record<string, any>, E extends Element = HTMLElement> = {
    /** Handler parameters injected via inline JSON, <script> id reference, or store reference. */
    params: P;
    /** The element the directive is bound to. */
    el: E;
    /** The triggering DOM event, or a synthetic `CustomEvent` when the handler runs without one (e.g. a function used to compute a one-way binding value). */
    e: Event;
    /** Current `rz-render` loop context. Both fields are `null` outside a render instance, and `item` is `null` for item-less (boolean/number) modes. */
    render: {
        item: unknown;
        index: number | null;
    };
};
/**
 * `HandlerCtx` for handlers bound inside an `rz-render` instance: the loop item
 * is typed, and `render` is guaranteed present (non-null).
 *
 * @template Item - The type of the render item.
 * @template P - The type of the params object.
 * @template E - The Element type.
 */
type RenderHandlerCtx<Item, P = Record<string, any>, E extends Element = HTMLElement> = Omit<HandlerCtx<P, E>, 'render'> & {
    /** Current `rz-render` loop context. */
    render: {
        item: Item;
        index: number;
    };
};

declare class ScopeRegistry {
    private scopes;
    register(name: string, setup: ScopeSetup<any>): void;
    get(name: string): ScopeSetup<any> | undefined;
    has(name: string): boolean;
}

interface RouseConfig {
    /** Element or selector where the app mounts. Defaults to `document.body`. */
    root?: string | HTMLElement;
    /** Prepended to relative URLs in `rz-fetch`, `rz-push`, `rz-pull`, and `{app,ctx}.fetch()`. */
    baseUrl?: string;
    /** Default headers applied to every request. Merged with per-request and directive-level headers; a `null` value removes the header. */
    headers?: Record<string, string | null>;
    /** Standard fetch `credentials` value applied to every request. */
    credentials?: RequestCredentials;
    /** Abort every request after this many milliseconds. A per-request `timeout` overrides it; `0` (the default) means no deadline. */
    timeout?: number;
    /** Default scope activation strategy. Overridden by `rz-wake`. */
    wake?: string;
}
interface ResolvedConfig {
    root: HTMLElement;
    baseUrl: string;
    headers: Record<string, string | null>;
    credentials?: RequestCredentials;
    timeout: number;
    wake: string;
}
/**
 * A Rouse application instance. Holds the root element, the stores, the
 * registered scopes, the network interceptors, and the `fetch` and `on` helpers.
 *
 * Creating an app touches the DOM only to claim the root; no directives are read
 * until `start()`, so stores and scopes can be registered in any order first.
 * A root hosts one app at a time, and the constructor throws rather than attach
 * a second.
 *
 * @example
 * const app = rouse({ root: '#app', baseUrl: '/api' });
 * app.store('cart', { items: [] });
 * app.scope({ counter, cart });
 * app.start();
 */
declare class RouseApp {
    readonly root: HTMLElement;
    readonly config: Readonly<ResolvedConfig>;
    stores: StoreManager;
    registry: ScopeRegistry;
    isReady: boolean;
    /**
     * Makes a network request using the app's configuration. Registered interceptors,
     * default headers, and credentials all apply, and a relative URL is resolved against
     * the configured `baseUrl`.
     *
     * Always resolves to a `RouseResponse`, on failure as well as success, so check `error`
     * instead of catching. The body arrives on `data`, parsed by content type: an object or
     * array for JSON, a string for HTML, text, and XML, and a `Blob` for anything else.
     *
     * A response isn't placed in the page unless something names a destination. Pass
     * `triggerEl` to attribute the request to an element, which applies that element's
     * `rz-request` config, fires the `rz:fetch:*` events from it, and routes the response
     * through its `rz-target`: HTML into the DOM, JSON into a store. A server `Rouse-Target`
     * routes either way. Otherwise the response is handled by the caller; the exported `swap`
     * helper can be used to place HTML manually.
     *
     * @param resource - The URL to request, absolute or relative to `baseUrl`.
     * @param options - Request options such as `method`, `body`, `params`, `headers`, and `abortKey`, plus `triggerEl`.
     * @returns The response, carrying parsed `data` on success or a populated `error` on failure.
     *
     * @example
     * const { data, error } = await app.fetch('/api/user');
     */
    fetch: RouseFetch;
    /**
     * Adds an event listener that is auto-removed when the app is destroyed. Listens
     * on `app.root` unless an `EventTarget` is passed first. Modifiers, filters, and
     * timing are passed as options, with an optional `AbortSignal` combined with the
     * app's own. The programmatic twin of `rz-on`, with the same trigger sources.
     * Safe to call before `app.start()`.
     *
     * @returns A teardown closure that removes the listener early.
     *
     * @example
     * app.on('page-visible', refetch);
     * app.on('click', onClick, { debounce: 300 });
     * app.on(window, ['online', 'offline'], sync);
     */
    on: BoundOn;
    _interceptors: {
        request: Set<RequestInterceptor>;
        response: Set<ResponseInterceptor>;
        error: Set<ErrorInterceptor>;
    };
    private _hasStarted;
    private _destroyed;
    private _observer?;
    private _abortController;
    /**
     * Resolves the root, marks it with `data-rouse-app`, and wires the stores, scopes,
     * interceptors, and app-lifetime `AbortController`.
     *
     * @throws If the root cannot be found, or already has an app attached.
     */
    constructor(config?: RouseConfig);
    /**
     * Registers scope setup functions by name. `data-rz-scope="counter"` resolves against
     * the names registered here.
     *
     * Elements are wired as they are scanned, and a name that is not registered before
     * `start()` is skipped with a warning rather than picked up once it arrives.
     *
     * @param nameOrScopes - A scope name, or an object of names mapped to setup functions.
     * @param setup - The setup function. Only needed when the first argument is a name.
     * @returns The app, so calls can be chained.
     * @throws If the registration is not a plain object, or a value is not a function.
     *
     * @example
     * app.scope('counter', counter);
     * // Object shorthand for bulk registration
     * app.scope({ counter, cart });
     */
    scope<P extends Record<string, any>>(name: string, setup: ScopeSetup<P>): this;
    scope(scopes: Record<string, ScopeSetup<any>>): this;
    /**
     * Creates a reactive store and returns its data proxy.
     *
     * A store is one flat object. Data, getters, and methods live side by side.
     * Getters are cached as computeds bound to the proxy and must stay pure. Work
     * that needs cleanup belongs in a scope instead.
     *
     * Only plain, JSON-serializable data is synced. Methods and getters are untouched
     * by snapshots, push bodies, `reset()`, and incoming server state.
     *
     * @template T - Shape of the store's data, getters, and methods.
     * @param name - Unique name. Referenced as `@name` in directives.
     * @param data - Initial state. Made reactive, and kept as the snapshot `reset()` restores.
     * @param config - How the store syncs: URL, push and pull methods, patch action, rollback behavior.
     * @returns The store's reactive proxy.
     * @throws If a store of this name already exists.
     *
     * @example
     * const cart = app.store('cart', {
     *   items: [],
     *   get total() {
     *     return this.items.reduce((sum, item) => sum + item.price, 0);
     *   },
     *   clear() {
     *     this.items = [];
     *   },
     * }, { url: '/api/cart' });
     *
     * cart.items.push(item);
     */
    store<T extends object>(name: string, data: T, config?: Partial<SyncPolicy>): T;
    /**
     * Registers a network interceptor. Interceptors run in FIFO order and are
     * `await`ed sequentially, so async interceptors block subsequent ones in
     * the same phase.
     *
     * @returns A teardown closure that unregisters the interceptor.
     *
     * @example
     * const remove = app.interceptor('request', (config) => {
     *   config.headers = { ...config.headers, Authorization: `Bearer ${token}` };
     *   return config;
     * });
     * // Later, in a scope's `disconnect()`:
     * remove();
     */
    interceptor(phase: 'request', fn: RequestInterceptor): VoidFn;
    interceptor(phase: 'response', fn: ResponseInterceptor): VoidFn;
    interceptor(phase: 'error', fn: ErrorInterceptor): VoidFn;
    /**
     * Triggers a Rouse network request. `options.triggerEl` marks an originating
     * element; without one nothing is read from the DOM and the `rz:fetch:*`
     * events fire from the app root.
     *
     * @param url - The URL to fetch.
     * @param options - Network configuration. `triggerEl` marks an originating element.
     */
    private _fetch;
    /**
     * Brings the app to life: reads the markup under `root`, creates stores, mounts
     * scopes, binds directives, and starts watching for elements added later.
     *
     * Fires `rz:app:start` before reading anything, and `rz:app:ready` on the next
     * animation frame, once the initial bindings have run and `isReady` is true.
     * Calling it a second time, or after `destroy()`, warns and does nothing.
     *
     * @example
     * document.addEventListener('DOMContentLoaded', () => app.start());
     */
    start(): void;
    /**
     * Shuts the app down: stops watching the DOM, unmounts every scope, unbinds
     * every directive, then fires `rz:app:destroy` and aborts the app's signal.
     *
     * This is final. Aborting drops `app.on` listeners and any request still in
     * flight, and `start()` will not run again. Does nothing if the app never
     * started or is already gone.
     */
    destroy(): void;
}
/**
 * Creates a Rouse app instance. The standard entry point; equivalent
 * to `new RouseApp(config)`.
 *
 * @param config - App-wide configuration, fixed once the app exists.
 * @returns A new app, ready for stores and scopes and waiting on `start()`.
 *
 * @example
 * const app = rouse({ root: '#app' });
 * app.scope('counter', counter);
 * app.start();
 */
declare function rouse(config?: RouseConfig): RouseApp;

/**
 * Generates a short key, unique for the lifetime of the page. Intended for
 * assigning stable identity to client-created items in keyed lists.
 *
 * Call it once when creating the item and store the result on the item. Never
 * call it during render or inside a getter because every call returns a new key,
 * which defeats keyed reconciliation. Keys are sequential, not random. Don't use
 * them as secrets or persist them as permanent ids.
 *
 * @example
 * const key = createKey(); // 'rz_mbx3k2f81000'
 * todos.items.push({ key, text });
 * // In HTML, use as stable id via `rz-key`
 * <template data-rz-render="items" data-rz-key="key">
 */
declare function createKey(prefix?: string): string;

/**
 * Dispatches a custom event from an element.
 *
 * @param options - Allows overriding cancelable/bubbles
 */
declare function dispatch<N extends string>(el: EventTarget, name: N, detail?: N extends keyof LifecycleEventMap ? LifecycleEventMap[N] : any, options?: CustomEventInit): CustomEvent<N extends keyof LifecycleEventMap ? LifecycleEventMap[N] : any>;

/**
 * Swaps HTML content into a target element, replaces it, or removes it.
 *
 * Fires a cancelable `rz:dom:swap:before` event first; a listener can cancel it to
 * skip the swap, or mutate `detail.payload` to change what gets written. A `rz:dom:swap`
 * event follows. For `outerHTML` and `delete`, both events fire from the target's parent,
 * since the target itself is replaced or removed.
 *
 * @param content - The HTML string to swap in (ignored for `delete`).
 * @param target - The element to swap into, replace, or remove.
 * @param method - How to place the content: `innerHTML`, `outerHTML`, `delete`, or an `insertAdjacentHTML` position such as `beforeend`. The names are case-sensitive; `innerHTML` is both the default and the fallback for an unrecognized value.
 * @param source - Marks the swap as `fetch`-driven or `programmatic` (default); surfaced on both lifecycle events.
 */
declare function swap(content: string, target: Element, method?: SwapMethod, source?: 'fetch' | 'programmatic'): void;

type ReactiveProxy<T> = T;
/**
 * Creates a reactive proxy for the target object.
 *
 * - If passed a raw object, it returns its reactive proxy (creating one if needed).
 * - If passed an existing proxy, it returns it as-is.
 * - If passed a non-proxiable value (primitive, DOM node), it returns it as-is.
 *
 * The returned proxy is deeply reactive but lazy: nested properties are converted to
 * proxies only when accessed.
 *
 * @template T - The type of the target object.
 * @param target - The object to make reactive.
 * @returns The reactive proxy, or the original value if it cannot be proxied.
 *
 * @example
 * const state = reactive({ count: 0 });
 * effect(() => console.log(state.count));
 */
declare function reactive<T extends object>(target: T): ReactiveProxy<T>;

export { type BindableValue, type HandlerCtx, type LifecycleEvent, type RenderHandlerCtx, type RouseConfig, type ScopeCtx, type ScopeSetup, createKey, rouse as default, dispatch, reactive, rouse, swap };