@akashjs/runtime 0.2.2 → 0.2.7

package/dist/index.d.cts

@@ -1,17 +1,60 @@
-import { R as ReadonlySignal, S as Signal } from './signals-C7XfOHHR.cjs';
-export { c as computed, e as effect, o as on, s as signal, u as untrack } from './signals-C7XfOHHR.cjs';
-import { I as InjectionKey } from './context-2uQ6fuxu.cjs';
-export { b as batch, c as createContext, f as flushSync, g as getCurrentScope, i as inject, p as provide, r as runInScope } from './context-2uQ6fuxu.cjs';
-import { A as AkashNode, C as Component } from './component-C1WnFcRp.cjs';
-export { a as ComponentContext, R as Ref, _ as __getter, d as defineComponent, o as onError, b as onMount, c as onUnmount, r as ref } from './component-C1WnFcRp.cjs';
+export { R as ReadonlySignal, S as Signal, c as computed, e as effect, o as on, s as signal, u as untrack } from './signals-DionyGGY.cjs';
+export { b as batch, f as flushSync } from './scheduler-CKi1esN-.cjs';
+export { C as Component, a as ComponentContext, R as Ref, _ as __getter, d as defineComponent, o as onError, b as onMount, c as onUnmount, r as ref } from './component-CxlupKuc.cjs';
+export { I as InjectionKey, c as createContext, g as getCurrentScope, i as inject, p as provide, r as runInScope } from './context-Cwt7QCpk.cjs';
 export { For, Show, bindProperty, bindText, bindVisible, cloneTemplate, createElement, createText, insert, nodeToDOM, renderConditional, renderList, setProperty } from './core.cjs';
+import { A as AkashNode } from './types-DjZCk1xT.cjs';
+export { ErrorBoundary, ErrorBoundaryProps } from './error-boundary.cjs';
+export { Suspense, SuspenseProps, getSuspenseContext, registerPending } from './suspense.cjs';
+export { HYDRATE_ATTR, HydrateOptions, ProgressiveHydrateOptions, claimElement, claimText, findHydrationBoundaries, hydrate, isHydrationActive, progressiveHydrate } from './hydration.cjs';
 export { SSRElement, SSRNode, SSRRaw, SSRText, isServerRendering, nodeToHtml, renderNodes, renderToStream, renderToString, renderToStringSync, ssrElement, ssrRaw, ssrText } from './ssr.cjs';
 export { Store, StoreDefinition, StorePlugin, __getStoreInstances, clearStores, configureStores, defineStore } from './store.cjs';
-export { LWWEntry, LWWRegister, PeerInfo, SyncDoc, SyncOp, SyncOptions, SyncTransport, createLocalTransport, createSync, createWebSocketTransport } from './sync.cjs';
+export { Transition, TransitionClasses, TransitionProps, enterTransition, exitTransition, generateTransitionCSS, getTransitionClasses } from './transition.cjs';
+export { HeadConfig, LinkTag, MetaTag, ScriptTag, collectSSRHead, renderHeadToString, useHead } from './head.cjs';
+export { AppInstance, Plugin, PluginContext, createApp, definePlugin } from './plugin.cjs';
+export { useCounter, useDebounce, useInterval, usePrevious, useThrottle, useTimeout, useToggle } from './composables.cjs';
+export { Breakpoints, GeolocationState, useBreakpoint, useClickOutside, useClipboard, useGeolocation, useMediaQuery, useOnline, useStorage, useWindowSize } from './browser.cjs';
+export { Portal, PortalProps } from './portal.cjs';
+export { Toast, ToastOptions, ToastPosition, ToastType, Toaster, ToasterOptions, createToaster } from './toast.cjs';
+export { Theme, ThemeConfig, ThemeVariables, useTheme } from './theme.cjs';
+export { VirtualFor, VirtualForProps, VirtualRange, calculateRange, useVirtualList } from './virtual-list.cjs';
+export { AsyncComponentLoader, AsyncComponentOptions, defineAsyncComponent } from './async-component.cjs';
+export { ReconcileOp, countOps, longestIncreasingSubsequence, reconcileKeys } from './reconcile.cjs';
+export { LeakWarning, checkForLeaks, disableLeakDetection, enableLeakDetection, getActiveEffects, getLeakDetectionStats, isLeakDetectionEnabled, reportLeaks, trackEffect, untrackEffect } from './leak-detector.cjs';
+export { PerfEntry, PerfProfile, PerfSummary, createTimer, formatProfile, getProfileSummary, isProfiling, measureAsync, measureSync, recordPerfEntry, startProfiling, stopProfiling } from './perf.cjs';
+export { AriaLive, FocusTrap, FocusTrapOptions, KeyBinding, KeyboardManager, useAnnounce, useFocusTrap, useKeyboard } from './a11y.cjs';
+export { Image, ImageProps } from './image.cjs';
+export { InfiniteScroll, InfiniteScrollOptions, useInfiniteScroll } from './infinite-scroll.cjs';
+export { applyStyles, css, cx } from './css.cjs';
+export { ColumnDef, DataTable, DataTableOptions, SortDirection, SortState, createDataTable } from './data-table.cjs';
+export { OpenGraphData, SEOConfig, SitemapEntry, StructuredData, TwitterCardData, generateSitemap, useOpenGraph, useSEO, useStructuredData, useTwitterCard } from './seo.cjs';
+export { LWWEntry, LWWRegister, PeerInfo, SyncConflict, SyncDoc, SyncOp, SyncOptions, SyncTransport, createLocalTransport, createSync, createWebSocketTransport, useCursor, useTypingIndicator } from './sync.cjs';
 export { ConflictStrategy, OfflineStore, OfflineStoreOptions, createOfflineStore } from './offline.cjs';
+export { PipeFn, capitalize, chain, currency, date, definePipe, json, lowercase, number, percent, pipe, plural, relativeTime, titleCase, trim, truncate, uppercase } from './pipes.cjs';
+export { Directive, DirectiveBinding, DirectiveHooks, applyDirective, defineDirective, directiveFromFn, removeDirectives, updateDirective, vAutoFocus, vClickOutside, vIntersect, vLongPress, vResize } from './directive.cjs';
 export { CacheRoute, CacheStrategy, SWOptions, SWRegistration, generateSWScript, registerServiceWorker, subscribePush } from './pwa.cjs';
+export { CustomElementOptions, defineCustomElement, toCustomElement } from './web-component.cjs';
+export { PrerenderOptions, PrerenderResult, discoverStaticRoutes, generatePaths, prerender, sitemapFromResults, urlToFilePath } from './ssg.cjs';
+export { Switch, SwitchProps, match, renderSwitch } from './switch.cjs';
+export { Injector, ProviderDef, ProviderRegistration, clearProviders, createInjector, defineProvider, injectProvider } from './di.cjs';
 export { AnimationControl, AnimationOptions, AnimationState, SpringOptions, StaggerOptions, animate, animateGroup, animateSequence, animateSpring, animateStagger, defineStates, keyframes } from './animate.cjs';
+export { DeferOptions, DeferTrigger, defer } from './defer.cjs';
+export { ViewTransition, ViewTransitionOptions, assignTransitionName, startViewTransition, supportsViewTransitions, viewTransitionCSS } from './view-transition.cjs';
+export { QueryStateOptions, clearQueryState, getQueryParams, removeQueryState, resetQueryState, useQueryState, useQueryStates } from './query-state.cjs';
+export { EasingFn, Interpolator, TweenedOptions, TweenedSignal, easings, tweened } from './tweened.cjs';
+export { FlipController, FlipOptions, createFlip, flip } from './flip.cjs';
+export { Await, AwaitProps, awaitSignal } from './await-block.cjs';
+export { EventModifiers, bindClass, bindClasses, bindDimensions, bindElement, bindGroup, bindGroupItem, bindScroll, bindStyle, bindStyles, onEvent, withModifiers } from './event-modifiers.cjs';
+export { FormAction, InspectOptions, SnapshotConfig, Snippet, defineFormAction, defineSnippet, enableSnapshots, inspect } from './snippets.cjs';
+export { WatchCallback, WatchOptions, WatchSource, watch, watchDebounced, watchOnce } from './watch.cjs';
+export { DeepSignal, deepSignal, isDeepSignal, toRaw } from './deep-signal.cjs';
 export { Machine, MachineConfig, MachineContext, StateConfig, TransitionConfig, createMachine } from './machine.cjs';
+export { EventBus, EventHandler, EventMap, createEventBus, globalEventBus } from './event-bus.cjs';
+export { CSPConfig, SanitizeOptions, SecurityHeadersConfig, createCSRFInterceptor, createRateLimiter, createSafeHTML, deepFreeze, escapeHtml, generateCSP, generateCSRFToken, generateSRI, generateSecurityHeaders, getCSPHeaderName, safeMerge, sanitize, sanitizeURL } from './security.cjs';
+export { APIInfo, APIStability, CompatibilityResult, DeprecationInfo, checkCompatibility, deprecated, deprecatedValue, getAPIsByStability, getDeprecationInfo, getRegisteredAPIs, isDeprecated, registerAPI, resetDeprecationWarnings, setDeprecationWarnings, setWarningHandler } from './deprecation.cjs';
+export { ErrorDef, akashError, formatError, getAllErrorCodes, getErrorDef } from './errors.cjs';
+export { DevToolsAPI, DevToolsOptions, installDevtools } from './devtools.cjs';
+export { enhanceError, installErrorHints } from './error-hints.cjs';
 
 /**
  * Slot helpers for content projection.
@@ -71,3148 +114,4 @@ declare function hasSlot(slot: SlotFn | Slots | undefined, name?: string): boole
  */
 declare function createSlots<T extends Record<string, unknown>>(props: T, slotNames?: (keyof T)[]): Slots;
 
-interface ErrorBoundaryProps {
-    /** Render function called when an error is caught */
-    fallback: (error: Error, retry: () => void) => AkashNode;
-}
-/**
- * ErrorBoundary component.
- *
- * Catches errors from descendant components and renders a fallback.
- * The fallback receives the error and a `retry` function that re-renders
- * the children.
- */
-declare const ErrorBoundary: Component<ErrorBoundaryProps>;
-
-interface SuspenseContext {
-    /** Register a pending promise */
-    addPending(promise: Promise<unknown>): void;
-    /** Check if all pending work is resolved */
-    isResolved: () => boolean;
-}
-/**
- * Get the current Suspense context (if inside a <Suspense> boundary).
- * Used by async components and createResource to register pending work.
- */
-declare function getSuspenseContext(): SuspenseContext | null;
-/**
- * Register a promise with the nearest Suspense boundary.
- * If there is no Suspense boundary, the promise is ignored
- * (component renders without waiting).
- */
-declare function registerPending(promise: Promise<unknown>): void;
-interface SuspenseProps {
-    /** Fallback UI shown while children are loading */
-    fallback: () => AkashNode;
-}
-/**
- * <Suspense> component.
- *
- * ```html
- * <Suspense fallback={() => <Spinner />}>
- *   <AsyncComponent />
- * </Suspense>
- * ```
- */
-declare const Suspense: Component<SuspenseProps>;
-
-/**
- * Client-side hydration.
- *
- * After SSR delivers HTML, the client needs to "hydrate" —
- * walk the existing DOM, attach signal effects, and make it interactive.
- * No new DOM nodes are created during hydration.
- *
- * Supports progressive hydration via IntersectionObserver:
- * components hydrate lazily when they enter the viewport.
- */
-
-/** Check if we're currently hydrating (vs. fresh rendering) */
-declare function isHydrationActive(): boolean;
-interface HydrateOptions {
-    /** The root DOM element (rendered by SSR) */
-    container: HTMLElement;
-    /** The root component to hydrate */
-    component: Component<any>;
-    /** Props to pass to the root component */
-    props?: Record<string, unknown>;
-}
-/**
- * Hydrate a server-rendered DOM tree.
- *
- * Walks the existing DOM instead of creating new nodes,
- * attaching signal effects to existing elements.
- *
- * ```ts
- * import { hydrate } from '@akashjs/runtime';
- * import App from './App.akash';
- *
- * hydrate({
- *   container: document.getElementById('app')!,
- *   component: App,
- *   props: { title: 'Home' },
- * });
- * ```
- */
-declare function hydrate(options: HydrateOptions): () => void;
-/**
- * Claim the next DOM node during hydration.
- * Instead of creating a new element, returns the existing one.
- */
-declare function claimElement(tag: string): HTMLElement | null;
-/**
- * Claim the next text node during hydration.
- */
-declare function claimText(): Text | null;
-interface ProgressiveHydrateOptions {
-    /** CSS selector or element to observe */
-    target: HTMLElement;
-    /** Component to hydrate when visible */
-    component: Component<any>;
-    /** Props */
-    props?: Record<string, unknown>;
-    /** IntersectionObserver root margin (default: '200px') */
-    rootMargin?: string;
-}
-/**
- * Hydrate a component lazily when it enters the viewport.
- *
- * Uses IntersectionObserver to detect when the SSR placeholder
- * becomes visible, then runs full hydration.
- *
- * ```ts
- * progressiveHydrate({
- *   target: document.querySelector('[data-hydrate="comments"]')!,
- *   component: Comments,
- *   props: { postId: 123 },
- * });
- * ```
- */
-declare function progressiveHydrate(options: ProgressiveHydrateOptions): () => void;
-/** Data attribute used to mark hydration boundaries in SSR HTML */
-declare const HYDRATE_ATTR = "data-akash-hydrate";
-/**
- * Find all hydration boundaries in the document.
- */
-declare function findHydrationBoundaries(root?: HTMLElement): HTMLElement[];
-
-/**
- * Transition/Animation system.
- *
- * Provides CSS-based enter/exit transitions for elements.
- * Works with <Transition> component or programmatic API.
- *
- * Class naming convention (matches Vue/Svelte):
- * - `{name}-enter-from`  — initial enter state
- * - `{name}-enter-active` — active enter transition
- * - `{name}-enter-to`    — final enter state
- * - `{name}-exit-from`   — initial exit state
- * - `{name}-exit-active`  — active exit transition
- * - `{name}-exit-to`     — final exit state
- */
-interface TransitionProps {
-    /** Transition name (used as CSS class prefix) */
-    name?: string;
-    /** Duration in ms (overrides CSS transition duration) */
-    duration?: number;
-    /** Whether the content is shown */
-    when: boolean;
-    /** CSS transition mode */
-    mode?: 'in-out' | 'out-in';
-    /** Callback when enter transition starts */
-    onEnter?: (el: HTMLElement) => void;
-    /** Callback when enter transition completes */
-    onAfterEnter?: (el: HTMLElement) => void;
-    /** Callback when exit transition starts */
-    onExit?: (el: HTMLElement) => void;
-    /** Callback when exit transition completes */
-    onAfterExit?: (el: HTMLElement) => void;
-}
-interface TransitionClasses {
-    enterFrom: string;
-    enterActive: string;
-    enterTo: string;
-    exitFrom: string;
-    exitActive: string;
-    exitTo: string;
-}
-/**
- * Get the transition CSS class names for a given transition name.
- */
-declare function getTransitionClasses(name: string): TransitionClasses;
-/**
- * Run an enter transition on an element.
- * Returns a promise that resolves when the transition completes.
- */
-declare function enterTransition(el: HTMLElement, classes: TransitionClasses, duration?: number): Promise<void>;
-/**
- * Run an exit transition on an element.
- * Returns a promise that resolves when the transition completes.
- */
-declare function exitTransition(el: HTMLElement, classes: TransitionClasses, duration?: number): Promise<void>;
-/**
- * <Transition> component.
- *
- * Applies CSS enter/exit transitions when `when` changes.
- *
- * ```html
- * <Transition name="fade" when={isVisible()}>
- *   <div>Content</div>
- * </Transition>
- * ```
- *
- * CSS:
- * ```css
- * .fade-enter-active, .fade-exit-active {
- *   transition: opacity 0.3s;
- * }
- * .fade-enter-from, .fade-exit-to {
- *   opacity: 0;
- * }
- * ```
- */
-declare const Transition: Component<TransitionProps>;
-/**
- * Generate CSS for common transition presets.
- * Inject this into your app's styles or use the CLI to generate it.
- */
-declare function generateTransitionCSS(name: string, options?: {
-    property?: string;
-    duration?: string;
-    easing?: string;
-}): string;
-
-/**
- * Document head management.
- *
- * Provides Title, Meta, and Head components for managing
- * <head> content declaratively. SSR-compatible — on the server,
- * collects tags; on the client, directly mutates the DOM.
- *
- * ```ts
- * // In any component:
- * useHead({
- *   title: 'My Page',
- *   meta: [
- *     { name: 'description', content: 'Page description' },
- *     { property: 'og:title', content: 'My Page' },
- *   ],
- *   link: [
- *     { rel: 'canonical', href: 'https://example.com/page' },
- *   ],
- * });
- * ```
- */
-interface HeadConfig {
-    /** Document title */
-    title?: string;
-    /** Title template — use %s as placeholder */
-    titleTemplate?: string;
-    /** Meta tags */
-    meta?: MetaTag[];
-    /** Link tags */
-    link?: LinkTag[];
-    /** Script tags */
-    script?: ScriptTag[];
-    /** HTML attributes */
-    htmlAttrs?: Record<string, string>;
-    /** Body attributes */
-    bodyAttrs?: Record<string, string>;
-}
-interface MetaTag {
-    name?: string;
-    property?: string;
-    httpEquiv?: string;
-    content: string;
-}
-interface LinkTag {
-    rel: string;
-    href: string;
-    type?: string;
-    crossorigin?: string;
-}
-interface ScriptTag {
-    src?: string;
-    type?: string;
-    async?: boolean;
-    defer?: boolean;
-    innerHTML?: string;
-}
-/** @internal — collect head tags during SSR */
-declare function collectSSRHead(): HeadConfig[];
-/** Render collected head tags to HTML string (for SSR) */
-declare function renderHeadToString(configs: HeadConfig[]): string;
-/**
- * Declaratively manage document head tags.
- * Call inside defineComponent() setup.
- *
- * Tags are automatically cleaned up when the component unmounts.
- * Reactive values (signals) in the config trigger updates.
- */
-declare function useHead(config: HeadConfig | (() => HeadConfig)): void;
-
-/**
- * Plugin system.
- *
- * Allows third-party extensions to hook into the AkashJS lifecycle.
- * Plugins can provide context values, add global error handlers,
- * register stores, and run setup code.
- *
- * ```ts
- * const authPlugin = definePlugin({
- *   name: 'auth',
- *   setup(app) {
- *     const store = defineStore('auth', { ... })();
- *     app.provide(AuthContext, store);
- *     app.onError((err) => { if (err.status === 401) logout(); });
- *   },
- * });
- *
- * const app = createApp(App);
- * app.use(authPlugin);
- * app.mount('#app');
- * ```
- */
-
-interface PluginContext {
-    /** Provide a value to all components */
-    provide<T>(key: InjectionKey<T>, value: T): void;
-    /** Register a global error handler */
-    onError(handler: (error: Error) => void): void;
-    /** Register a hook that runs before each component mount */
-    onBeforeMount(hook: () => void): void;
-    /** Access the app config */
-    config: Record<string, unknown>;
-}
-interface Plugin {
-    /** Plugin name (for debugging) */
-    name: string;
-    /** Setup function called when the plugin is installed */
-    setup: (ctx: PluginContext) => void | Promise<void>;
-}
-interface AppInstance {
-    /** Install a plugin */
-    use(plugin: Plugin): AppInstance;
-    /** Set a config value */
-    config(key: string, value: unknown): AppInstance;
-    /** Mount the app to a DOM element */
-    mount(selector: string | HTMLElement): void;
-    /** Unmount the app */
-    unmount(): void;
-}
-/**
- * Define a framework plugin.
- */
-declare function definePlugin(plugin: Plugin): Plugin;
-/**
- * Create an application instance with plugin support.
- *
- * ```ts
- * const app = createApp(App);
- * app.use(authPlugin);
- * app.use(i18nPlugin);
- * app.mount('#app');
- * ```
- */
-declare function createApp<P extends Record<string, unknown>>(rootComponent: Component<P>, rootProps?: P): AppInstance;
-
-/**
- * Reactive composables — signal-based utility functions.
- *
- * Timers, debounce, throttle, and other commonly needed
- * reactive primitives that every app uses.
- */
-
-/**
- * Create a reactive interval that ticks at a given rate.
- *
- * ```ts
- * const { count, pause, resume, reset } = useInterval(1000);
- * count(); // increments every second
- * ```
- */
-declare function useInterval(ms: number, options?: {
-    immediate?: boolean;
-}): {
-    count: ReadonlySignal<number>;
-    isActive: ReadonlySignal<boolean>;
-    pause(): void;
-    resume(): void;
-    reset(): void;
-    dispose(): void;
-};
-/**
- * Reactive timeout that exposes ready state.
- *
- * ```ts
- * const { ready, restart } = useTimeout(3000);
- * ready(); // false, then true after 3s
- * ```
- */
-declare function useTimeout(ms: number): {
-    ready: ReadonlySignal<boolean>;
-    restart(): void;
-    dispose(): void;
-};
-/**
- * Debounce a signal value. The output updates only after the input
- * stops changing for the given delay.
- *
- * ```ts
- * const search = signal('');
- * const debouncedSearch = useDebounce(search, 300);
- * // debouncedSearch() updates 300ms after last search.set()
- * ```
- */
-declare function useDebounce<T>(source: () => T, delay: number): ReadonlySignal<T>;
-/**
- * Throttle a signal value. The output updates at most once per interval.
- *
- * ```ts
- * const scrollY = signal(0);
- * const throttled = useThrottle(scrollY, 100);
- * ```
- */
-declare function useThrottle<T>(source: () => T, interval: number): ReadonlySignal<T>;
-/**
- * Simple reactive counter with inc/dec/set/reset.
- *
- * ```ts
- * const { count, inc, dec, set, reset } = useCounter(0);
- * ```
- */
-declare function useCounter(initial?: number, options?: {
-    min?: number;
-    max?: number;
-}): {
-    count: ReadonlySignal<number>;
-    inc(delta?: number): void;
-    dec(delta?: number): void;
-    set(value: number): void;
-    reset(): void;
-};
-/**
- * Reactive boolean toggle.
- *
- * ```ts
- * const { value, toggle, setTrue, setFalse } = useToggle(false);
- * ```
- */
-declare function useToggle(initial?: boolean): {
-    value: ReadonlySignal<boolean>;
-    toggle(): void;
-    setTrue(): void;
-    setFalse(): void;
-};
-/**
- * Track the previous value of a signal.
- *
- * ```ts
- * const count = signal(0);
- * const prev = usePrevious(count);
- * count.set(1);
- * prev(); // 0
- * ```
- */
-declare function usePrevious<T>(source: () => T): ReadonlySignal<T | undefined>;
-
-/**
- * Browser API composables.
- *
- * Signal-based wrappers for common browser APIs.
- * All composables are SSR-safe — they return fallback values
- * when `window` is not available.
- */
-
-/**
- * Reactive media query matcher.
- *
- * ```ts
- * const isMobile = useMediaQuery('(max-width: 768px)');
- * isMobile(); // true/false, updates on resize
- * ```
- */
-declare function useMediaQuery(query: string): ReadonlySignal<boolean>;
-interface Breakpoints {
-    [name: string]: number;
-}
-/**
- * Reactive breakpoint tracker (Tailwind-style).
- *
- * ```ts
- * const bp = useBreakpoint();
- * bp.current();  // 'md'
- * bp.gte('lg');  // false
- * bp.lt('sm');   // false
- * ```
- */
-declare function useBreakpoint(breakpoints?: Breakpoints): {
-    current: () => string;
-    gte: (name: string) => boolean;
-    lt: (name: string) => boolean;
-    width: ReadonlySignal<number>;
-};
-/**
- * Signal backed by localStorage or sessionStorage.
- * Persists across page refreshes.
- *
- * ```ts
- * const name = useStorage('user-name', 'Guest');
- * name();       // reads from localStorage or 'Guest'
- * name.set('Alice'); // writes to localStorage
- * ```
- */
-declare function useStorage<T>(key: string, initialValue: T, storage?: 'local' | 'session'): Signal<T>;
-/**
- * Reactive clipboard access.
- *
- * ```ts
- * const { text, copy, copied } = useClipboard();
- * await copy('Hello');
- * copied(); // true for 2 seconds
- * ```
- */
-declare function useClipboard(options?: {
-    timeout?: number;
-}): {
-    text: ReadonlySignal<string>;
-    copied: ReadonlySignal<boolean>;
-    copy: (value: string) => Promise<void>;
-};
-/**
- * Reactive online/offline status.
- *
- * ```ts
- * const online = useOnline();
- * online(); // true/false
- * ```
- */
-declare function useOnline(): ReadonlySignal<boolean>;
-interface GeolocationState {
-    latitude: number | null;
-    longitude: number | null;
-    accuracy: number | null;
-    error: GeolocationPositionError | null;
-    loading: boolean;
-}
-/**
- * Reactive geolocation.
- *
- * ```ts
- * const geo = useGeolocation();
- * geo().latitude;  // number | null
- * geo().loading;   // boolean
- * ```
- */
-declare function useGeolocation(options?: PositionOptions): ReadonlySignal<GeolocationState>;
-/**
- * Reactive window dimensions.
- */
-declare function useWindowSize(): {
-    width: ReadonlySignal<number>;
-    height: ReadonlySignal<number>;
-};
-/**
- * Detect clicks outside an element. Essential for closing
- * dropdowns, modals, popovers, and context menus.
- *
- * ```ts
- * const dropdown = document.querySelector('.dropdown')!;
- * const dispose = useClickOutside(dropdown, () => {
- *   closeDropdown();
- * });
- *
- * // With options:
- * useClickOutside(dropdown, onClose, {
- *   events: ['mousedown', 'touchstart'],
- *   ignore: ['.trigger-button'],
- * });
- * ```
- */
-declare function useClickOutside(target: HTMLElement | (() => HTMLElement | null), handler: (event: Event) => void, options?: {
-    /** Events to listen for (default: ['pointerdown']) */
-    events?: string[];
-    /** Selectors or elements to ignore (clicks on these won't trigger) */
-    ignore?: (string | HTMLElement)[];
-    /** Whether the listener is active (default: true) */
-    active?: boolean;
-}): () => void;
-
-/**
- * <Portal> component.
- *
- * Renders children into a different DOM node, outside the
- * component tree. Essential for modals, tooltips, toasts,
- * dropdowns, and overlays.
- *
- * ```html
- * <Portal target="body">
- *   <div class="modal">Modal content</div>
- * </Portal>
- *
- * <Portal target="#tooltip-container">
- *   <Tooltip />
- * </Portal>
- * ```
- */
-interface PortalProps {
-    /** CSS selector or HTMLElement to render into (default: document.body) */
-    target?: string | HTMLElement;
-}
-/**
- * <Portal> — render children into a different DOM location.
- */
-declare const Portal: Component<PortalProps>;
-
-/**
- * Toast notification system.
- *
- * Signal-based toast queue with auto-dismiss, stacking, and positions.
- *
- * ```ts
- * const toast = createToaster();
- * toast.success('Saved!');
- * toast.error('Something went wrong');
- * toast.info('Tip: try dark mode', { duration: 5000 });
- * toast.toasts(); // reactive list of active toasts
- * ```
- */
-
-type ToastType = 'success' | 'error' | 'info' | 'warning';
-type ToastPosition = 'top-right' | 'top-left' | 'top-center' | 'bottom-right' | 'bottom-left' | 'bottom-center';
-interface Toast {
-    id: string;
-    type: ToastType;
-    message: string;
-    duration: number;
-    dismissible: boolean;
-    createdAt: number;
-}
-interface ToastOptions {
-    /** Duration in ms (default: 3000, 0 = no auto-dismiss) */
-    duration?: number;
-    /** Whether the toast can be manually dismissed (default: true) */
-    dismissible?: boolean;
-}
-interface ToasterOptions {
-    /** Max visible toasts (default: 5) */
-    maxVisible?: number;
-    /** Default duration in ms (default: 3000) */
-    defaultDuration?: number;
-    /** Position (default: 'top-right') */
-    position?: ToastPosition;
-}
-interface Toaster {
-    /** Active toasts (reactive signal) */
-    toasts: ReadonlySignal<Toast[]>;
-    /** Position setting */
-    position: ToastPosition;
-    /** Show a success toast */
-    success(message: string, options?: ToastOptions): string;
-    /** Show an error toast */
-    error(message: string, options?: ToastOptions): string;
-    /** Show an info toast */
-    info(message: string, options?: ToastOptions): string;
-    /** Show a warning toast */
-    warning(message: string, options?: ToastOptions): string;
-    /** Show a toast with custom type */
-    add(type: ToastType, message: string, options?: ToastOptions): string;
-    /** Dismiss a specific toast */
-    dismiss(id: string): void;
-    /** Dismiss all toasts */
-    dismissAll(): void;
-}
-/**
- * Create a toast notification manager.
- */
-declare function createToaster(options?: ToasterOptions): Toaster;
-
-/**
- * Theme / dark mode system.
- *
- * Signal-based theme management with system preference detection,
- * CSS variable injection, and localStorage persistence.
- *
- * ```ts
- * const theme = useTheme({
- *   themes: {
- *     light: { '--bg': '#fff', '--text': '#111' },
- *     dark: { '--bg': '#111', '--text': '#eee' },
- *   },
- * });
- *
- * theme.current();    // 'light' or 'dark'
- * theme.toggle();     // switch between light/dark
- * theme.set('dark');  // set explicitly
- * theme.isDark();     // boolean
- * ```
- */
-
-type ThemeVariables = Record<string, string>;
-interface ThemeConfig {
-    /** Theme definitions (name → CSS variables) */
-    themes?: Record<string, ThemeVariables>;
-    /** Default theme name (default: auto-detect from system) */
-    defaultTheme?: string;
-    /** localStorage key for persistence (default: 'akash-theme') */
-    storageKey?: string;
-    /** CSS attribute to set on <html> (default: 'data-theme') */
-    attribute?: string;
-    /** Whether to sync with system preference (default: true) */
-    syncSystem?: boolean;
-}
-interface Theme {
-    /** Current theme name (reactive) */
-    current: ReadonlySignal<string>;
-    /** Whether dark mode is active */
-    isDark: ReadonlySignal<boolean>;
-    /** Set a specific theme */
-    set(theme: string): void;
-    /** Toggle between light and dark */
-    toggle(): void;
-    /** Set the system preference strategy */
-    setSystem(): void;
-    /** Available theme names */
-    themes: string[];
-}
-/**
- * Create a theme manager with system preference detection and persistence.
- */
-declare function useTheme(config?: ThemeConfig): Theme;
-
-interface VirtualForProps<T> {
-    /** Array of items */
-    each: T[];
-    /** Key function for reconciliation */
-    key: (item: T) => unknown;
-    /** Fixed height per item in pixels */
-    itemHeight: number;
-    /** Container height in pixels (default: auto-detect from parent) */
-    containerHeight?: number;
-    /** Number of extra items to render above/below viewport */
-    overscan?: number;
-    /** Render function for each item */
-    children: (item: T, index: number) => AkashNode;
-}
-interface VirtualRange {
-    /** First visible index */
-    start: number;
-    /** Last visible index (exclusive) */
-    end: number;
-    /** Total content height in pixels */
-    totalHeight: number;
-    /** Offset of the first rendered item */
-    offsetTop: number;
-}
-/**
- * Calculate the visible range given scroll position and dimensions.
- */
-declare function calculateRange(scrollTopOrOpts: number | {
-    scrollTop: number;
-    containerHeight: number;
-    itemHeight: number;
-    totalItems: number;
-    overscan?: number;
-}, containerHeight?: number, itemHeight?: number, totalItems?: number, overscan?: number): VirtualRange;
-/**
- * Low-level virtual list composable for custom implementations.
- *
- * ```ts
- * const { containerRef, range, visibleItems } = useVirtualList({
- *   items: () => allItems(),
- *   itemHeight: 40,
- *   overscan: 5,
- * });
- * ```
- */
-declare function useVirtualList<T>(options: {
-    items: () => T[];
-    itemHeight: number;
-    containerHeight?: number;
-    overscan?: number;
-}): {
-    range: ReadonlySignal<VirtualRange>;
-    visibleItems: ReadonlySignal<{
-        item: T;
-        index: number;
-    }[]>;
-    onScroll: (e: Event) => void;
-    setContainerHeight: (height: number) => void;
-    scrollTop: ReadonlySignal<number>;
-};
-declare const VirtualFor: Component<VirtualForProps<any>>;
-
-/**
- * defineAsyncComponent — lazy component loading.
- *
- * Wraps a dynamic import() into a component that shows a loading
- * state while the chunk downloads, an error state if it fails,
- * and the real component once resolved.
- *
- * ```ts
- * const LazyChart = defineAsyncComponent(() => import('./Chart.akash'));
- *
- * // With loading/error:
- * const LazyChart = defineAsyncComponent({
- *   loader: () => import('./Chart.akash'),
- *   loading: () => <Spinner />,
- *   error: (err) => <p>Failed: {err.message}</p>,
- *   timeout: 10000,
- * });
- * ```
- */
-
-type AsyncComponentLoader<P extends Record<string, unknown> = any> = () => Promise<{
-    default: Component<P>;
-}>;
-interface AsyncComponentOptions<P extends Record<string, unknown> = any> {
-    /** The async loader function (dynamic import) */
-    loader: AsyncComponentLoader<P>;
-    /** Component to show while loading */
-    loading?: () => AkashNode;
-    /** Component to show on error */
-    error?: (error: Error) => AkashNode;
-    /** Timeout in ms — show error after this (default: none) */
-    timeout?: number;
-    /** Delay in ms before showing loading state (default: 200) */
-    delay?: number;
-}
-/**
- * Define a component that loads asynchronously via dynamic import.
- */
-declare function defineAsyncComponent<P extends Record<string, unknown> = any>(loaderOrOptions: AsyncComponentLoader<P> | AsyncComponentOptions<P>): Component<P>;
-
-/**
- * List reconciliation with Longest Increasing Subsequence (LIS).
- *
- * When a keyed list updates, we need to determine the minimal set of
- * DOM operations (inserts, moves, removes). The LIS of the new key
- * positions tells us which nodes are already in the correct relative
- * order and don't need to move.
- *
- * This is the same algorithm used by Vue 3, Solid, and Inferno.
- */
-/**
- * Find the Longest Increasing Subsequence of indices.
- * Returns the indices into the input array that form the LIS.
- *
- * Time: O(n log n), Space: O(n)
- */
-declare function longestIncreasingSubsequence(arr: number[]): number[];
-/**
- * Reconcile two keyed lists and return the minimal DOM operations.
- *
- * @param oldKeys - Keys of the current DOM list
- * @param newKeys - Keys of the new data list
- * @returns Operations to transform old into new
- */
-interface ReconcileOp {
-    type: 'insert' | 'move' | 'remove';
-    /** Index in the NEW array (for insert/move) */
-    newIndex?: number;
-    /** Index in the OLD array (for remove/move source) */
-    oldIndex?: number;
-}
-declare function reconcileKeys(oldKeys: unknown[], newKeys: unknown[]): ReconcileOp[];
-/**
- * Count the minimum number of DOM operations needed.
- */
-declare function countOps(oldKeys: unknown[], newKeys: unknown[]): {
-    inserts: number;
-    moves: number;
-    removes: number;
-};
-
-/**
- * Effect disposal and leak detection (dev mode).
- *
- * In development, tracks all created effects and verifies they
- * get properly cleaned up when components unmount. Logs warnings
- * for leaked effects that were never disposed.
- */
-interface EffectRecord {
-    id: number;
-    createdAt: number;
-    stackTrace: string | null;
-    componentName: string | null;
-    disposed: boolean;
-}
-/**
- * Enable leak detection. Call once at app startup in dev mode.
- *
- * ```ts
- * if (import.meta.env.DEV) {
- *   enableLeakDetection();
- * }
- * ```
- */
-declare function enableLeakDetection(): void;
-/**
- * Disable leak detection.
- */
-declare function disableLeakDetection(): void;
-/**
- * Check if leak detection is enabled.
- */
-declare function isLeakDetectionEnabled(): boolean;
-/**
- * Register an effect for tracking. Called internally by effect().
- * Returns an ID for later disposal tracking.
- */
-declare function trackEffect(componentName?: string): number;
-/**
- * Mark an effect as disposed. Called internally by effect dispose function.
- */
-declare function untrackEffect(id: number): void;
-/**
- * Get all currently active (undisposed) effects.
- */
-declare function getActiveEffects(): EffectRecord[];
-/**
- * Check for leaked effects and return warnings.
- * An effect is considered leaked if it's been active for longer
- * than the given threshold without being disposed.
- */
-declare function checkForLeaks(thresholdMs?: number): LeakWarning[];
-/**
- * Log leak warnings to the console.
- */
-declare function reportLeaks(thresholdMs?: number): void;
-/**
- * Get a summary of effect tracking state.
- */
-declare function getLeakDetectionStats(): {
-    enabled: boolean;
-    activeCount: number;
-    totalTracked: number;
-};
-interface LeakWarning {
-    effectId: number;
-    age: number;
-    componentName: string | null;
-    stackTrace: string | null;
-}
-
-/**
- * Performance profiling utilities.
- *
- * Measure component render times, signal propagation, and
- * effect execution for performance debugging.
- *
- * ```ts
- * import { startProfiling, stopProfiling, getProfile } from '@akashjs/runtime';
- *
- * startProfiling();
- * // ... do stuff ...
- * stopProfiling();
- * console.table(getProfile().entries);
- * ```
- */
-interface PerfEntry {
-    type: 'render' | 'effect' | 'signal-update' | 'computed';
-    name: string;
-    duration: number;
-    timestamp: number;
-}
-interface PerfProfile {
-    entries: PerfEntry[];
-    totalDuration: number;
-    startTime: number;
-    endTime: number;
-}
-interface PerfSummary {
-    totalRenders: number;
-    totalEffects: number;
-    totalSignalUpdates: number;
-    totalComputedEvals: number;
-    avgRenderTime: number;
-    avgEffectTime: number;
-    slowestRender: PerfEntry | null;
-    slowestEffect: PerfEntry | null;
-}
-/**
- * Start profiling. Clears previous data.
- */
-declare function startProfiling(): void;
-/**
- * Stop profiling.
- */
-declare function stopProfiling(): PerfProfile;
-/**
- * Check if profiling is active.
- */
-declare function isProfiling(): boolean;
-/**
- * Record a performance entry (called internally by the framework).
- */
-declare function recordPerfEntry(type: PerfEntry['type'], name: string, duration: number): void;
-/**
- * Get a summary of the profiling data.
- */
-declare function getProfileSummary(profile: PerfProfile): PerfSummary;
-/**
- * Measure the time to execute a function.
- *
- * ```ts
- * const { result, duration } = measureSync('my-operation', () => expensiveWork());
- * ```
- */
-declare function measureSync<T>(name: string, fn: () => T): {
-    result: T;
-    duration: number;
-};
-/**
- * Measure the time to execute an async function.
- */
-declare function measureAsync<T>(name: string, fn: () => Promise<T>): Promise<{
-    result: T;
-    duration: number;
-}>;
-/**
- * Create a named timer for manual start/stop measurement.
- *
- * ```ts
- * const timer = createTimer('data-fetch');
- * timer.start();
- * await fetch(...);
- * timer.stop(); // records the entry
- * timer.duration; // ms
- * ```
- */
-declare function createTimer(name: string): {
-    start(): void;
-    stop(): void;
-    readonly duration: number;
-};
-/**
- * Format a profile for console output.
- */
-declare function formatProfile(profile: PerfProfile): string;
-
-/**
- * Accessibility composables.
- *
- * Built-in a11y primitives that no other framework ships natively.
- * Focus management, screen reader announcements, and keyboard shortcuts.
- */
-
-interface FocusTrapOptions {
-    /** CSS selector or element to focus initially (default: first focusable) */
-    initialFocus?: string | HTMLElement;
-    /** Return focus to the previously focused element on deactivate */
-    returnFocus?: boolean;
-    /** Escape key deactivates the trap (default: true) */
-    escapeDeactivates?: boolean;
-    /** Allow clicks outside the trap container (default: false) */
-    allowOutsideClick?: boolean;
-    /** Callback when Escape deactivates */
-    onDeactivate?: () => void;
-}
-interface FocusTrap {
-    /** Activate the focus trap */
-    activate(): void;
-    /** Deactivate the focus trap */
-    deactivate(): void;
-    /** Whether the trap is currently active */
-    active: ReadonlySignal<boolean>;
-}
-/**
- * Trap focus inside a container element.
- *
- * ```ts
- * const trap = useFocusTrap(dialogRef, {
- *   initialFocus: '#first-input',
- *   returnFocus: true,
- *   escapeDeactivates: true,
- * });
- * trap.activate();   // on open
- * trap.deactivate(); // on close
- * ```
- */
-declare function useFocusTrap(container: HTMLElement | (() => HTMLElement | null), options?: FocusTrapOptions): FocusTrap;
-type AriaLive = 'polite' | 'assertive' | 'off';
-/**
- * Screen reader announcements via ARIA live regions.
- *
- * ```ts
- * const announce = useAnnounce();
- * announce('Page loaded: Dashboard');
- * announce('Error: Invalid email', 'assertive');
- * ```
- */
-declare function useAnnounce(): (message: string, politeness?: AriaLive) => void;
-interface KeyBinding {
-    /** Key combo: 'mod+k', 'Escape', 'ArrowDown', 'shift+Enter' */
-    key: string;
-    /** Handler function */
-    handler: (e: KeyboardEvent) => void;
-    /** Optional scope (only active when scope is enabled) */
-    scope?: string;
-    /** Description for help dialog */
-    description?: string;
-    /** Prevent default browser behavior (default: true) */
-    preventDefault?: boolean;
-}
-interface KeyboardManager {
-    /** Register a binding */
-    bind(key: string, handler: (e: KeyboardEvent) => void, options?: {
-        scope?: string;
-        description?: string;
-        preventDefault?: boolean;
-    }): () => void;
-    /** Enable a scope */
-    enableScope(scope: string): void;
-    /** Disable a scope */
-    disableScope(scope: string): void;
-    /** Get all bindings (for help dialog) */
-    getBindings(): Array<{
-        key: string;
-        description: string;
-        scope?: string;
-    }>;
-    /** Dispose all bindings */
-    dispose(): void;
-}
-/**
- * Keyboard shortcut manager with scope support.
- *
- * ```ts
- * const kb = useKeyboard();
- * kb.bind('mod+k', () => openSearch(), { description: 'Open search' });
- * kb.bind('Escape', () => close(), { scope: 'modal' });
- * kb.enableScope('modal');
- * ```
- */
-declare function useKeyboard(): KeyboardManager;
-
-/**
- * <Image> component.
- *
- * Optimized image rendering with lazy loading, srcset/sizes,
- * blur placeholder, and error fallback.
- *
- * ```html
- * <Image
- *   src="/photos/hero.jpg"
- *   alt="Hero image"
- *   width={800}
- *   height={600}
- *   placeholder="blur"
- *   blurDataUrl="data:image/jpeg;base64,..."
- *   srcset="/photos/hero-400.jpg 400w, /photos/hero-800.jpg 800w"
- *   sizes="(max-width: 600px) 400px, 800px"
- *   loading="lazy"
- * />
- * ```
- */
-interface ImageProps {
-    /** Image source URL */
-    src: string;
-    /** Alt text (required for accessibility) */
-    alt: string;
-    /** Width in pixels */
-    width?: number;
-    /** Height in pixels */
-    height?: number;
-    /** Loading strategy (default: 'lazy') */
-    loading?: 'lazy' | 'eager';
-    /** Srcset for responsive images */
-    srcset?: string;
-    /** Sizes attribute for responsive images */
-    sizes?: string;
-    /** Placeholder strategy */
-    placeholder?: 'blur' | 'empty';
-    /** Base64 data URL for blur placeholder */
-    blurDataUrl?: string;
-    /** CSS class */
-    class?: string;
-    /** Error fallback image URL */
-    fallbackSrc?: string;
-    /** Callback when image loads */
-    onLoad?: () => void;
-    /** Callback when image fails to load */
-    onError?: (error: Event) => void;
-}
-declare const Image: Component<ImageProps>;
-
-/**
- * Infinite scroll composable.
- *
- * Uses IntersectionObserver to detect when a sentinel element
- * enters the viewport, then triggers loading more data.
- * Pairs with createCursorPagination() from @akashjs/http.
- *
- * ```ts
- * const { sentinel, loading, done } = useInfiniteScroll({
- *   onLoadMore: async () => {
- *     pager.loadMore();
- *     await fetchNextPage();
- *   },
- *   hasMore: () => pager.hasMore(),
- * });
- * // Append sentinel() element at the end of your list
- * ```
- */
-
-interface InfiniteScrollOptions {
-    /** Callback to load more items */
-    onLoadMore: () => Promise<void> | void;
-    /** Whether there are more items to load */
-    hasMore: () => boolean;
-    /** Root margin for the observer (default: '200px') */
-    rootMargin?: string;
-    /** Threshold for the observer (default: 0) */
-    threshold?: number;
-}
-interface InfiniteScroll {
-    /** Sentinel element to place at the end of the list */
-    sentinel: () => HTMLElement;
-    /** Whether a load is in progress */
-    loading: ReadonlySignal<boolean>;
-    /** Whether all items have been loaded */
-    done: ReadonlySignal<boolean>;
-    /** Reset the scroll state */
-    reset(): void;
-    /** Dispose the observer */
-    dispose(): void;
-}
-/**
- * Create an infinite scroll controller.
- */
-declare function useInfiniteScroll(options: InfiniteScrollOptions): InfiniteScroll;
-
-/**
- * CSS utility functions.
- *
- * cx() for class name merging and css() for dynamic style objects.
- * Tiny but used in every component.
- */
-type CxInput = string | boolean | null | undefined | Record<string, boolean> | CxInput[];
-/**
- * Merge class names conditionally. Falsy values are filtered out.
- * Object keys are included when their value is truthy.
- *
- * ```ts
- * cx('btn', isActive && 'btn-active', { 'btn-lg': isLarge })
- * // 'btn btn-active btn-lg'
- *
- * cx('card', undefined, false, null, 'card-primary')
- * // 'card card-primary'
- * ```
- */
-declare function cx(...inputs: CxInput[]): string;
-type CssValue = string | number | null | undefined;
-type CssProperties = Record<string, CssValue>;
-/**
- * Build a CSS style string from an object. Handles camelCase → kebab-case
- * conversion and filters out null/undefined values.
- *
- * ```ts
- * css({ backgroundColor: 'red', fontSize: 14, display: isVisible ? 'block' : 'none' })
- * // 'background-color: red; font-size: 14px; display: block'
- * ```
- */
-declare function css(styles: CssProperties): string;
-/**
- * Apply a style object to an element.
- *
- * ```ts
- * applyStyles(el, { color: 'red', marginTop: 10 });
- * ```
- */
-declare function applyStyles(el: HTMLElement, styles: CssProperties): void;
-
-/**
- * Headless data table.
- *
- * Signal-based table state management with sorting, filtering,
- * column visibility, and pagination integration. No DOM — just logic.
- *
- * ```ts
- * const table = createDataTable({
- *   data: () => users(),
- *   columns: [
- *     { key: 'name', header: 'Name', sortable: true },
- *     { key: 'email', header: 'Email', sortable: true, filterable: true },
- *     { key: 'age', header: 'Age', sortable: true },
- *   ],
- *   pageSize: 20,
- * });
- *
- * table.rows();           // current page of sorted/filtered data
- * table.sort('name');     // toggle sort by column
- * table.filter('search term');
- * table.toggleColumn('age');
- * table.nextPage();
- * ```
- */
-
-interface ColumnDef<T> {
-    /** Key to access the data (dot notation supported) */
-    key: string;
-    /** Display header */
-    header: string;
-    /** Whether this column is sortable (default: false) */
-    sortable?: boolean;
-    /** Whether this column is searchable by the global filter (default: false) */
-    filterable?: boolean;
-    /** Custom sort comparator */
-    compare?: (a: T, b: T) => number;
-    /** Custom cell value accessor */
-    accessor?: (row: T) => unknown;
-    /** Whether column is visible by default (default: true) */
-    visible?: boolean;
-}
-type SortDirection = 'asc' | 'desc' | null;
-interface SortState {
-    column: string | null;
-    direction: SortDirection;
-}
-interface DataTableOptions<T> {
-    /** Reactive data source */
-    data: () => T[];
-    /** Column definitions */
-    columns: ColumnDef<T>[];
-    /** Page size (0 = no pagination) */
-    pageSize?: number;
-    /** Initial sort */
-    initialSort?: SortState;
-}
-interface DataTable<T> {
-    /** Current page of processed (sorted + filtered) rows */
-    rows: ReadonlySignal<T[]>;
-    /** All processed rows (before pagination) */
-    allRows: ReadonlySignal<T[]>;
-    /** Total row count after filtering */
-    totalRows: ReadonlySignal<number>;
-    /** Visible columns */
-    visibleColumns: ReadonlySignal<ColumnDef<T>[]>;
-    /** Current sort state */
-    sortState: ReadonlySignal<SortState>;
-    /** Current filter text */
-    filterText: ReadonlySignal<string>;
-    /** Current page (1-based) */
-    page: ReadonlySignal<number>;
-    /** Total pages */
-    totalPages: ReadonlySignal<number>;
-    /** Toggle or set sort on a column */
-    sort(columnKey: string): void;
-    /** Set the global filter text */
-    filter(text: string): void;
-    /** Toggle column visibility */
-    toggleColumn(columnKey: string): void;
-    /** Show a column */
-    showColumn(columnKey: string): void;
-    /** Hide a column */
-    hideColumn(columnKey: string): void;
-    /** Go to next page */
-    nextPage(): void;
-    /** Go to previous page */
-    prevPage(): void;
-    /** Go to specific page */
-    goToPage(page: number): void;
-    /** Reset all state (sort, filter, page) */
-    reset(): void;
-}
-declare function createDataTable<T extends Record<string, unknown>>(options: DataTableOptions<T>): DataTable<T>;
-
-/**
- * SEO utilities.
- *
- * Structured data (JSON-LD), Open Graph helpers, and canonical URL management.
- * Works with useHead() for SSR-compatible head tag management.
- *
- * ```ts
- * useStructuredData({
- *   '@type': 'Article',
- *   headline: 'My Post',
- *   author: { '@type': 'Person', name: 'Alice' },
- * });
- * ```
- */
-interface StructuredData {
-    '@context'?: string;
-    '@type': string;
-    [key: string]: unknown;
-}
-interface OpenGraphData {
-    title: string;
-    description?: string;
-    image?: string;
-    url?: string;
-    type?: string;
-    siteName?: string;
-    locale?: string;
-}
-interface TwitterCardData {
-    card?: 'summary' | 'summary_large_image' | 'player' | 'app';
-    title: string;
-    description?: string;
-    image?: string;
-    site?: string;
-    creator?: string;
-}
-interface SEOConfig {
-    title: string;
-    description?: string;
-    canonical?: string;
-    robots?: string;
-    openGraph?: OpenGraphData;
-    twitter?: TwitterCardData;
-    structuredData?: StructuredData | StructuredData[];
-}
-/**
- * Inject JSON-LD structured data into the document head.
- * Data is automatically wrapped with @context.
- *
- * ```ts
- * useStructuredData({
- *   '@type': 'WebSite',
- *   name: 'AkashJS',
- *   url: 'https://akashjs.dev',
- * });
- * ```
- */
-declare function useStructuredData(data: StructuredData | StructuredData[]): void;
-/**
- * Set Open Graph meta tags.
- *
- * ```ts
- * useOpenGraph({
- *   title: 'My Page',
- *   description: 'Page description',
- *   image: '/og-image.jpg',
- *   type: 'article',
- * });
- * ```
- */
-declare function useOpenGraph(data: OpenGraphData): void;
-/**
- * Set Twitter Card meta tags.
- *
- * ```ts
- * useTwitterCard({
- *   card: 'summary_large_image',
- *   title: 'My Page',
- *   image: '/twitter-card.jpg',
- * });
- * ```
- */
-declare function useTwitterCard(data: TwitterCardData): void;
-/**
- * Set all SEO-related head tags at once.
- *
- * ```ts
- * useSEO({
- *   title: 'My Page | MySite',
- *   description: 'Page description',
- *   canonical: 'https://mysite.com/page',
- *   openGraph: { title: 'My Page', image: '/og.jpg' },
- *   twitter: { card: 'summary_large_image', title: 'My Page' },
- *   structuredData: { '@type': 'WebPage', name: 'My Page' },
- * });
- * ```
- */
-declare function useSEO(config: SEOConfig): void;
-interface SitemapEntry {
-    url: string;
-    lastmod?: string;
-    changefreq?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
-    priority?: number;
-}
-/**
- * Generate a sitemap.xml string from route entries.
- *
- * ```ts
- * const xml = generateSitemap('https://mysite.com', [
- *   { url: '/', priority: 1.0 },
- *   { url: '/about', changefreq: 'monthly' },
- *   { url: '/blog/hello', lastmod: '2026-03-29' },
- * ]);
- * ```
- */
-declare function generateSitemap(baseUrl: string, entries: SitemapEntry[]): string;
-
-/**
- * Pipes — template transform functions.
- *
- * Pure functions that transform display values. Chainable, memoized,
- * and usable both in templates and in script.
- *
- * ```ts
- * import { pipe, uppercase, date, currency } from '@akashjs/runtime';
- *
- * pipe('hello', uppercase);                    // 'HELLO'
- * pipe(new Date(), date, 'short');             // '3/29/26'
- * pipe(1234.5, currency, 'USD');               // '$1,234.50'
- * pipe('hello world', capitalize, truncate, 5); // 'Hello...'
- * ```
- */
-type PipeFn<TIn = any, TOut = any> = (value: TIn, ...args: any[]) => TOut;
-/**
- * Apply a pipe transform to a value.
- *
- * ```ts
- * pipe('hello', uppercase); // 'HELLO'
- * pipe(1234, currency, 'USD'); // '$1,234.00'
- * ```
- */
-declare function pipe(value: any, transform: Function, ...rest: any[]): any;
-/**
- * Chain multiple pipes together.
- *
- * ```ts
- * const format = chain(trim, capitalize, truncate);
- * format('  hello world  ', 10); // 'Hello w...'
- * ```
- */
-declare function chain<T>(...pipes: PipeFn[]): PipeFn<T, any>;
-/**
- * Define a custom pipe.
- *
- * ```ts
- * const reverse = definePipe<string, string>((value) =>
- *   value.split('').reverse().join('')
- * );
- * pipe('hello', reverse); // 'olleh'
- * ```
- */
-declare function definePipe<TIn, TOut>(fn: PipeFn<TIn, TOut>): PipeFn<TIn, TOut>;
-/** Convert string to uppercase */
-declare const uppercase: PipeFn<string, string>;
-/** Convert string to lowercase */
-declare const lowercase: PipeFn<string, string>;
-/** Capitalize first letter */
-declare const capitalize: PipeFn<string, string>;
-/** Title case — capitalize each word */
-declare const titleCase: PipeFn<string, string>;
-/** Trim whitespace */
-declare const trim: PipeFn<string, string>;
-/**
- * Truncate string to a max length, adding ellipsis.
- *
- * ```ts
- * pipe('Hello World', truncate, 8); // 'Hello...'
- * ```
- */
-declare const truncate: PipeFn<string, string>;
-/**
- * Format a date.
- *
- * ```ts
- * pipe(new Date(), date);             // '3/29/2026'
- * pipe(new Date(), date, 'short');    // '3/29/26'
- * pipe(new Date(), date, 'long');     // 'March 29, 2026'
- * pipe(new Date(), date, 'time');     // '2:30 PM'
- * pipe(new Date(), date, 'iso');      // '2026-03-29T...'
- * ```
- */
-declare const date: PipeFn<Date | string | number, string>;
-/**
- * Format a number as currency.
- *
- * ```ts
- * pipe(1234.5, currency);         // '$1,234.50'
- * pipe(1234.5, currency, 'EUR');  // '€1,234.50'
- * ```
- */
-declare const currency: PipeFn<number, string>;
-/**
- * Format a number with locale formatting.
- *
- * ```ts
- * pipe(1234567.89, number);           // '1,234,567.89'
- * pipe(1234567.89, number, '0-2');    // '1,234,567.89' (0-2 decimal digits)
- * ```
- */
-declare const number: PipeFn<number, string>;
-/**
- * Format a number as a percentage.
- *
- * ```ts
- * pipe(0.85, percent);   // '85%'
- * pipe(0.856, percent);  // '86%'
- * ```
- */
-declare const percent: PipeFn<number, string>;
-/**
- * JSON stringify with formatting.
- *
- * ```ts
- * pipe({ a: 1 }, json);     // '{\n  "a": 1\n}'
- * pipe({ a: 1 }, json, 0);  // '{"a":1}'
- * ```
- */
-declare const json: PipeFn<unknown, string>;
-/**
- * Pluralize a string based on count.
- *
- * ```ts
- * pipe(1, plural, 'item', 'items');  // '1 item'
- * pipe(5, plural, 'item', 'items');  // '5 items'
- * ```
- */
-declare const plural: PipeFn<number, string>;
-/**
- * Relative time formatting.
- *
- * ```ts
- * pipe(Date.now() - 60000, relativeTime);  // '1 minute ago'
- * ```
- */
-declare const relativeTime: PipeFn<Date | number, string>;
-
-/**
- * Custom directive system.
- *
- * Reusable attribute behaviors with lifecycle hooks.
- * Directives attach behavior to elements without components.
- *
- * ```ts
- * const vAutoFocus = defineDirective({
- *   mounted(el) { el.focus(); },
- * });
- *
- * const vTooltip = defineDirective<string>({
- *   mounted(el, { value }) { addTooltip(el, value); },
- *   updated(el, { value }) { updateTooltip(el, value); },
- *   unmounted(el) { removeTooltip(el); },
- * });
- *
- * // Usage:
- * applyDirective(el, vAutoFocus);
- * applyDirective(el, vTooltip, 'Hello tooltip');
- * ```
- */
-interface DirectiveBinding<T = any> {
-    /** Current value passed to the directive */
-    value: T;
-    /** Previous value (on update) */
-    oldValue?: T;
-    /** Argument (e.g., v-on:click → arg = 'click') */
-    arg?: string;
-    /** Modifiers (e.g., v-on.prevent → modifiers.prevent = true) */
-    modifiers?: Record<string, boolean>;
-}
-interface DirectiveHooks<T = any> {
-    /** Called when the element is inserted into the DOM */
-    mounted?: (el: HTMLElement, binding: DirectiveBinding<T>) => void;
-    /** Called when the bound value updates */
-    updated?: (el: HTMLElement, binding: DirectiveBinding<T>) => void;
-    /** Called before the element is removed from the DOM */
-    unmounted?: (el: HTMLElement, binding: DirectiveBinding<T>) => void;
-}
-interface Directive<T = any> {
-    _type: 'directive';
-    hooks: DirectiveHooks<T>;
-}
-/**
- * Define a custom directive.
- *
- * ```ts
- * const vClickOutside = defineDirective<() => void>({
- *   mounted(el, { value: handler }) {
- *     const listener = (e: Event) => {
- *       if (!el.contains(e.target as Node)) handler();
- *     };
- *     document.addEventListener('click', listener);
- *     (el as any).__clickOutside = listener;
- *   },
- *   unmounted(el) {
- *     document.removeEventListener('click', (el as any).__clickOutside);
- *   },
- * });
- * ```
- */
-declare function defineDirective<T = any>(hooks: DirectiveHooks<T>): Directive<T>;
-/**
- * Shorthand: directive from a single function (runs on mount).
- */
-declare function directiveFromFn<T = any>(fn: (el: HTMLElement, binding: DirectiveBinding<T>) => void | (() => void)): Directive<T>;
-/**
- * Apply a directive to an element.
- *
- * ```ts
- * applyDirective(el, vAutoFocus);
- * applyDirective(el, vTooltip, 'Hello');
- * ```
- */
-declare function applyDirective<T>(el: HTMLElement, directive: Directive<T>, value?: T, options?: {
-    arg?: string;
-    modifiers?: Record<string, boolean>;
-}): void;
-/**
- * Update a directive's value on an element.
- */
-declare function updateDirective<T>(el: HTMLElement, directive: Directive<T>, newValue: T): void;
-/**
- * Remove all directives from an element (call on unmount).
- */
-declare function removeDirectives(el: HTMLElement): void;
-/** Auto-focus an element when mounted */
-declare const vAutoFocus: Directive<any>;
-/** Click outside handler */
-declare const vClickOutside: Directive<() => void>;
-/** Long press handler */
-declare const vLongPress: Directive<{
-    handler: () => void;
-    duration?: number;
-}>;
-/** Intersection observer — triggers callback when element enters viewport */
-declare const vIntersect: Directive<(isIntersecting: boolean) => void>;
-/** Resize observer — triggers callback on element resize */
-declare const vResize: Directive<(entry: ResizeObserverEntry) => void>;
-
-/**
- * Web Components output.
- *
- * Compile AkashJS components to native Custom Elements that can
- * be used in any framework or plain HTML.
- *
- * ```ts
- * import { defineCustomElement } from '@akashjs/runtime';
- * import Counter from './Counter.akash';
- *
- * defineCustomElement('my-counter', Counter, {
- *   props: ['initial'],
- *   shadow: true,
- * });
- *
- * // Now usable as: <my-counter initial="5"></my-counter>
- * ```
- */
-
-interface CustomElementOptions {
-    /** Props to observe as attributes */
-    props?: string[];
-    /** Use Shadow DOM (default: true) */
-    shadow?: boolean;
-    /** CSS styles to inject (for shadow DOM) */
-    styles?: string;
-    /** Extend an existing element */
-    extends?: string;
-}
-/**
- * Register an AkashJS component as a Custom Element.
- *
- * ```ts
- * defineCustomElement('my-counter', Counter, {
- *   props: ['initial', 'step'],
- *   shadow: true,
- *   styles: ':host { display: block; }',
- * });
- * ```
- */
-declare function defineCustomElement<P extends Record<string, unknown>>(tagName: string, component: Component<P>, options?: CustomElementOptions): typeof HTMLElement;
-/**
- * Convert an AkashJS component to a Custom Element class without registering.
- * Useful for testing or when you want to register later.
- */
-declare function toCustomElement<P extends Record<string, unknown>>(component: Component<P>, options?: CustomElementOptions): typeof HTMLElement;
-
-/**
- * Static Site Generation (SSG) / Prerendering.
- *
- * Pre-render pages at build time to static HTML files.
- * Combine with hydration for interactive islands.
- *
- * ```ts
- * // In build script or akash build --prerender:
- * await prerender({
- *   routes: ['/', '/about', '/blog/hello'],
- *   render: (url) => renderToString(App, { url }),
- *   outDir: 'dist',
- * });
- * ```
- */
-interface PrerenderOptions {
-    /** Routes to prerender */
-    routes: string[] | (() => Promise<string[]>);
-    /** Render function — returns HTML for a given URL */
-    render: (url: string) => Promise<string> | string;
-    /** Output directory (default: 'dist') */
-    outDir?: string;
-    /** HTML template with {{content}} placeholder */
-    template?: string;
-    /** Callback per rendered page */
-    onPage?: (url: string, html: string) => void;
-    /** Callback on error */
-    onError?: (url: string, error: Error) => void;
-    /** Concurrency limit (default: 5) */
-    concurrency?: number;
-}
-interface PrerenderResult {
-    /** Successfully rendered pages */
-    rendered: Array<{
-        url: string;
-        file: string;
-        size: number;
-    }>;
-    /** Pages that failed to render */
-    errors: Array<{
-        url: string;
-        error: string;
-    }>;
-    /** Total time in ms */
-    duration: number;
-}
-/**
- * Pre-render routes to static HTML files.
- */
-declare function prerender(options: PrerenderOptions): Promise<PrerenderResult>;
-/**
- * Discover routes from the file system for prerendering.
- * Scans src/routes/ and returns all static (non-parameterized) paths.
- */
-declare function discoverStaticRoutes(routeManifest: Array<{
-    path: string;
-}>): string[];
-/**
- * Generate all possible paths for parameterized routes.
- *
- * ```ts
- * const paths = generatePaths('/blog/:slug', [
- *   { slug: 'hello' },
- *   { slug: 'world' },
- * ]);
- * // ['/blog/hello', '/blog/world']
- * ```
- */
-declare function generatePaths(pattern: string, params: Record<string, string>[]): string[];
-/**
- * Convert a URL path to a file path for static output.
- * / → index.html
- * /about → about/index.html
- * /blog/hello → blog/hello/index.html
- */
-declare function urlToFilePath(url: string): string;
-/**
- * Generate a sitemap from prerender results.
- */
-declare function sitemapFromResults(baseUrl: string, results: PrerenderResult): string;
-
-/**
- * Render a switch block. Swaps DOM based on reactive expression value.
- */
-declare function renderSwitch(parent: Node, anchor: Node, expression: () => unknown, cases: Record<string, () => Node>): () => void;
-interface SwitchProps {
-    /** The value to switch on */
-    on: unknown;
-    /** Cases map: value → render function */
-    cases: Record<string, () => AkashNode>;
-    /** Default case */
-    fallback?: () => AkashNode;
-}
-/**
- * <Switch> component — declarative switch/case.
- *
- * ```ts
- * Switch({
- *   on: status(),
- *   cases: {
- *     loading: () => Spinner({}),
- *     error: () => ErrorView({}),
- *     success: () => Content({}),
- *   },
- *   fallback: () => 'Unknown status',
- * });
- * ```
- */
-declare const Switch: Component<SwitchProps>;
-/**
- * Pattern match on a signal value. Returns the result of the matching branch.
- *
- * ```ts
- * const message = match(status(), {
- *   loading: () => 'Loading...',
- *   error: () => 'Something went wrong',
- *   success: () => 'Done!',
- *   _: () => 'Unknown',
- * });
- * ```
- */
-declare function match<T, R>(value: T, cases: Record<string, (value: T) => R> & {
-    _?: (value: T) => R;
-}): R | undefined;
-
-/**
- * Hierarchical Dependency Injection.
- *
- * Extends the basic provide/inject with multi-level injectors,
- * provider factories, tree-shakable providers, and multi-providers.
- *
- * ```ts
- * // Define a provider with factory
- * const ApiService = defineProvider({
- *   factory: () => createHttpClient({ baseUrl: '/api' }),
- * });
- *
- * // Tree-shakable provider (only bundled if injected)
- * const Logger = defineProvider({
- *   factory: () => new ConsoleLogger(),
- *   providedIn: 'root',
- * });
- *
- * // Use in component
- * const api = injectProvider(ApiService);
- * ```
- */
-interface ProviderDef<T> {
-    _type: 'provider';
-    factory: () => T;
-    providedIn?: 'root' | 'component';
-    multi?: boolean;
-    _id: symbol;
-}
-interface Injector {
-    /** Get a provider value */
-    get<T>(provider: ProviderDef<T>): T;
-    /** Check if a provider is registered */
-    has(provider: ProviderDef<unknown>): boolean;
-    /** Create a child injector */
-    createChild(providers?: ProviderRegistration[]): Injector;
-    /** Dispose this injector and all cached instances */
-    dispose(): void;
-}
-interface ProviderRegistration<T = unknown> {
-    provide: ProviderDef<T>;
-    useFactory?: () => T;
-    useValue?: T;
-    useExisting?: ProviderDef<T>;
-    multi?: boolean;
-}
-/**
- * Define a typed provider.
- *
- * ```ts
- * const DatabaseService = defineProvider({
- *   factory: () => new Database(config),
- *   providedIn: 'root', // singleton, tree-shakable
- * });
- * ```
- */
-declare function defineProvider<T>(config: {
-    factory: () => T;
-    providedIn?: 'root' | 'component';
-    multi?: boolean;
-}): ProviderDef<T>;
-/**
- * Create an injector with hierarchical resolution.
- *
- * ```ts
- * const injector = createInjector([
- *   { provide: ApiService, useFactory: () => new MockApi() },
- *   { provide: Logger, useValue: console },
- * ]);
- *
- * const api = injector.get(ApiService);
- * ```
- */
-declare function createInjector(providers?: ProviderRegistration[], parent?: Injector): Injector;
-/**
- * Inject a provider in the current component context.
- *
- * ```ts
- * const api = injectProvider(ApiService);
- * ```
- */
-declare function injectProvider<T>(provider: ProviderDef<T>): T;
-/**
- * Clear root provider instances (useful for testing).
- */
-declare function clearProviders(): void;
-
-/**
- * Deferred loading with triggers.
- *
- * Lazy-load components based on viewport visibility, user interaction,
- * idle time, timer, hover, or custom conditions.
- *
- * ```ts
- * const LazyComments = defer(() => import('./Comments.akash'), {
- *   trigger: 'viewport',
- *   loading: () => <Skeleton variant="text" />,
- * });
- *
- * const LazyChart = defer(() => import('./Chart.akash'), {
- *   trigger: 'idle',
- *   loading: () => <Spinner />,
- * });
- *
- * const LazyDropdown = defer(() => import('./Dropdown.akash'), {
- *   trigger: 'interaction', // loads on hover/focus/click
- * });
- * ```
- */
-
-type DeferTrigger = 'immediate' | 'viewport' | 'interaction' | 'idle' | 'hover' | {
-    type: 'timer';
-    delay: number;
-} | {
-    type: 'custom';
-    condition: () => boolean;
-};
-interface DeferOptions {
-    /** When to start loading (default: 'viewport') */
-    trigger?: DeferTrigger;
-    /** Loading placeholder */
-    loading?: () => AkashNode;
-    /** Error fallback */
-    error?: (err: Error) => AkashNode;
-    /** Prefetch — start loading early but don't render until triggered */
-    prefetch?: boolean;
-    /** Minimum loading time in ms (prevent flash of loading state) */
-    minLoadTime?: number;
-    /** Viewport root margin for 'viewport' trigger */
-    rootMargin?: string;
-}
-/**
- * Create a deferred component that loads based on a trigger.
- */
-declare function defer<P extends Record<string, unknown>>(loader: () => Promise<{
-    default: Component<P>;
-}>, options?: DeferOptions): Component<P>;
-
-/**
- * View Transitions API integration.
- *
- * Wraps the browser's native View Transitions API for smooth
- * page transitions. Falls back gracefully when not supported.
- *
- * ```ts
- * // With router
- * const router = createRouter(routes);
- * enableViewTransitions(router);
- *
- * // Manual
- * await startViewTransition(() => {
- *   updateDOM();
- * });
- * ```
- */
-interface ViewTransitionOptions {
-    /** CSS class to add to the document during transition */
-    className?: string;
-    /** Callback before the transition starts */
-    onBefore?: () => void;
-    /** Callback after the transition completes */
-    onAfter?: () => void;
-    /** Fallback behavior when API is not supported (default: 'instant') */
-    fallback?: 'instant' | 'fade' | 'none';
-}
-interface ViewTransition {
-    /** Promise that resolves when transition animation is complete */
-    finished: Promise<void>;
-    /** Promise that resolves when the DOM update callback has run */
-    updateCallbackDone: Promise<void>;
-    /** Promise that resolves when the transition is ready to animate */
-    ready: Promise<void>;
-    /** Skip the transition animation */
-    skipTransition(): void;
-}
-/**
- * Check if the View Transitions API is supported.
- */
-declare function supportsViewTransitions(): boolean;
-/**
- * Start a view transition with the native API, falling back
- * to instant DOM update when not supported.
- *
- * ```ts
- * await startViewTransition(() => {
- *   container.innerHTML = newContent;
- * });
- * ```
- */
-declare function startViewTransition(updateCallback: () => void | Promise<void>, options?: ViewTransitionOptions): ViewTransition;
-/**
- * Generate CSS for customizing view transitions.
- *
- * ```ts
- * const css = viewTransitionCSS({
- *   duration: '0.3s',
- *   oldAnimation: 'slide-out-left',
- *   newAnimation: 'slide-in-right',
- * });
- * ```
- */
-declare function viewTransitionCSS(config?: {
-    duration?: string;
-    easing?: string;
-    oldAnimation?: string;
-    newAnimation?: string;
-}): string;
-/**
- * Assign a view-transition-name to an element for per-element transitions.
- *
- * ```ts
- * assignTransitionName(headerEl, 'page-header');
- * assignTransitionName(contentEl, 'page-content');
- * ```
- */
-declare function assignTransitionName(el: HTMLElement, name: string): void;
-
-/**
- * URL-synced reactive state.
- *
- * Automatically sync signal values to URL query parameters.
- * Users can share links, use browser back/forward, and state
- * persists across page reloads — all with zero boilerplate.
- *
- * ```ts
- * const search = useQueryState('q', '');
- * const page = useQueryState('page', 1);
- * const tags = useQueryState('tags', ['js']);
- *
- * search.set('akashjs'); // URL → ?q=akashjs&page=1&tags=js
- * // User hits back → signals update automatically
- * ```
- */
-
-interface QueryStateOptions<T> {
-    /** Custom serializer (default: auto-detect from type) */
-    serialize?: (value: T) => string;
-    /** Custom deserializer (default: auto-detect from type) */
-    deserialize?: (raw: string) => T;
-    /** Whether to push or replace history entry (default: 'replace') */
-    history?: 'push' | 'replace';
-    /** Debounce URL updates in ms (default: 0) */
-    debounce?: number;
-    /** Remove param from URL when value equals default */
-    removeDefault?: boolean;
-}
-/**
- * Create a signal synced to a URL query parameter.
- *
- * ```ts
- * const search = useQueryState('q', '');
- * search();            // reads from URL or default
- * search.set('hello'); // updates URL to ?q=hello
- * ```
- */
-declare function useQueryState<T>(key: string, defaultValue: T, options?: QueryStateOptions<T>): Signal<T>;
-type QueryStateSchema = Record<string, {
-    default: unknown;
-    serialize?: (value: any) => string;
-    deserialize?: (raw: string) => any;
-}>;
-type QueryStates<T extends QueryStateSchema> = {
-    [K in keyof T]: Signal<T[K]['default']>;
-};
-/**
- * Create multiple URL-synced signals at once.
- * All updates within a batch result in a single URL change.
- *
- * ```ts
- * const { q, page, sort } = useQueryStates({
- *   q: { default: '' },
- *   page: { default: 1 },
- *   sort: { default: 'name' },
- * });
- * ```
- */
-declare function useQueryStates<T extends QueryStateSchema>(schema: T, options?: {
-    history?: 'push' | 'replace';
-}): QueryStates<T>;
-/**
- * Remove all query state params from the URL.
- */
-declare function clearQueryState(): void;
-/**
- * Get all current query params as a plain object.
- */
-declare function getQueryParams(): Record<string, string>;
-/**
- * Cleanup: remove a specific query state binding.
- */
-declare function removeQueryState(key: string): void;
-/**
- * Cleanup all query state bindings (useful for testing).
- */
-declare function resetQueryState(): void;
-
-/**
- * Tweened values — smooth interpolation between states.
- *
- * Unlike signals that update instantly, tweened values animate
- * smoothly from old to new over a duration.
- *
- * ```ts
- * const progress = tweened(0, { duration: 400 });
- * progress.set(100); // smoothly animates 0 → 100 over 400ms
- * progress();        // intermediate values during animation
- *
- * const color = tweened('#ff0000', { duration: 300, interpolate: lerpColor });
- * ```
- */
-type Interpolator<T> = (from: T, to: T, t: number) => T;
-type EasingFn = (t: number) => number;
-interface TweenedOptions<T> {
-    /** Duration in ms (default: 400) */
-    duration?: number;
-    /** Easing function (default: cubicOut) */
-    easing?: EasingFn;
-    /** Custom interpolation function */
-    interpolate?: Interpolator<T>;
-    /** Delay before animation starts */
-    delay?: number;
-}
-interface TweenedSignal<T> {
-    /** Read current (animated) value */
-    (): T;
-    /** Set new target — animates from current to new */
-    set(value: T, opts?: Partial<TweenedOptions<T>>): Promise<void>;
-    /** Set immediately without animation */
-    setImmediate(value: T): void;
-    /** Current target value */
-    target: () => T;
-}
-declare const easings: {
-    readonly linear: (t: number) => number;
-    readonly cubicIn: (t: number) => number;
-    readonly cubicOut: (t: number) => number;
-    readonly cubicInOut: (t: number) => number;
-    readonly quadIn: (t: number) => number;
-    readonly quadOut: (t: number) => number;
-    readonly quintOut: (t: number) => number;
-    readonly bounceOut: (t: number) => number;
-    readonly elasticOut: (t: number) => number;
-};
-/**
- * Create a tweened signal that animates between values.
- *
- * ```ts
- * const count = tweened(0, { duration: 300, easing: easings.cubicOut });
- * count.set(100); // smoothly goes 0 → 100
- * count();        // current interpolated value
- * ```
- */
-declare function tweened<T>(initialValue: T, options?: TweenedOptions<T>): TweenedSignal<T>;
-
-/**
- * FLIP animations for list reordering.
- *
- * First-Last-Invert-Play: measure element positions before and after
- * a DOM change, then animate from old to new positions.
- *
- * ```ts
- * const flip = createFlip(listContainer, {
- *   duration: 300,
- *   easing: 'cubic-bezier(0.2, 0, 0, 1)',
- * });
- *
- * // Before changing the list:
- * flip.measure();
- * // Change the DOM (reorder, add, remove)
- * items.set(newOrder);
- * // Animate:
- * flip.animate();
- * ```
- */
-interface FlipOptions {
-    /** Animation duration in ms (default: 300) */
-    duration?: number;
-    /** CSS easing (default: 'cubic-bezier(0.2, 0, 0, 1)') */
-    easing?: string;
-    /** Delay in ms */
-    delay?: number;
-    /** Only animate elements matching this selector */
-    selector?: string;
-    /** Key attribute to track elements across reorders (default: 'data-key') */
-    keyAttribute?: string;
-    /** Callback when animation completes */
-    onComplete?: () => void;
-}
-interface FlipController {
-    /** Measure current positions (call BEFORE DOM change) */
-    measure(): void;
-    /** Animate from measured positions to current (call AFTER DOM change) */
-    animate(): Promise<void>;
-    /** Measure and animate in one step using a callback */
-    flip(update: () => void): Promise<void>;
-}
-/**
- * Create a FLIP animation controller for a container.
- *
- * ```ts
- * const flip = createFlip(container);
- * flip.flip(() => {
- *   // reorder DOM elements here
- *   container.appendChild(container.firstChild); // move first to last
- * });
- * ```
- */
-declare function createFlip(container: HTMLElement, options?: FlipOptions): FlipController;
-/**
- * One-shot FLIP animation helper.
- *
- * ```ts
- * await flip(container, () => {
- *   // reorder items
- * }, { duration: 300 });
- * ```
- */
-declare function flip(container: HTMLElement, update: () => void, options?: FlipOptions): Promise<void>;
-
-interface AwaitProps<T> {
-    /** The promise to await */
-    promise: Promise<T>;
-    /** Render while pending */
-    pending?: () => AkashNode;
-    /** Render when resolved */
-    then: (value: T) => AkashNode;
-    /** Render when rejected */
-    catch?: (error: Error) => AkashNode;
-}
-type AwaitState<T> = {
-    status: 'pending';
-} | {
-    status: 'resolved';
-    value: T;
-} | {
-    status: 'rejected';
-    error: Error;
-};
-/**
- * <Await> component — declarative promise handling.
- */
-declare const Await: Component<AwaitProps<any>>;
-/**
- * Functional await block — returns a signal that updates as the promise resolves.
- *
- * ```ts
- * const result = awaitSignal(fetchData());
- * result().status; // 'pending' | 'resolved' | 'rejected'
- * ```
- */
-declare function awaitSignal<T>(promise: Promise<T>): () => AwaitState<T>;
-
-/**
- * Event modifiers and extended bind/class/style directives.
- *
- * Modifiers: onClick|preventDefault|stopPropagation|once|self|capture
- * Extended binds: bind:clientWidth, bind:scrollY, bind:group, bind:this
- * Class directive: class:active={isActive}
- * Style directive: style:color={textColor}
- */
-
-interface EventModifiers {
-    preventDefault?: boolean;
-    stopPropagation?: boolean;
-    stopImmediatePropagation?: boolean;
-    once?: boolean;
-    capture?: boolean;
-    passive?: boolean;
-    self?: boolean;
-}
-/**
- * Wrap an event handler with modifiers.
- *
- * ```ts
- * const handler = withModifiers(onClick, {
- *   preventDefault: true,
- *   stopPropagation: true,
- *   once: true,
- * });
- * el.addEventListener('click', handler);
- * ```
- */
-declare function withModifiers<E extends Event>(handler: (e: E) => void, modifiers: EventModifiers): (e: E) => void;
-/**
- * Attach an event handler with modifiers to an element.
- *
- * ```ts
- * onEvent(el, 'click', handler, { preventDefault: true, once: true });
- * ```
- */
-declare function onEvent<K extends keyof HTMLElementEventMap>(el: HTMLElement, event: K, handler: (e: HTMLElementEventMap[K]) => void, modifiers?: EventModifiers): () => void;
-/**
- * Bind element dimensions to signals (read-only, auto-updating).
- *
- * ```ts
- * const { width, height } = bindDimensions(el);
- * width(); // tracks clientWidth
- * ```
- */
-declare function bindDimensions(el: HTMLElement): {
-    width: ReadonlySignal<number>;
-    height: ReadonlySignal<number>;
-};
-/**
- * Bind scroll position to signals.
- *
- * ```ts
- * const { scrollX, scrollY } = bindScroll(el);
- * // or for window:
- * const { scrollX, scrollY } = bindScroll();
- * ```
- */
-declare function bindScroll(el?: HTMLElement): {
-    scrollX: Signal<number>;
-    scrollY: Signal<number>;
-};
-/**
- * Bind a signal to an element reference (like bind:this in Svelte).
- *
- * ```ts
- * const myRef = bindElement<HTMLInputElement>();
- * // In render: myRef.set(inputEl);
- * myRef()?.focus();
- * ```
- */
-declare function bindElement<T extends HTMLElement = HTMLElement>(): Signal<T | null>;
-/**
- * Bind a group of radio/checkbox inputs to a signal.
- *
- * ```ts
- * const selected = bindGroup<string>('color');
- * // Apply to each radio: bindGroupItem(radioEl, selected, 'red');
- * ```
- */
-declare function bindGroup<T>(name: string): Signal<T | null>;
-declare function bindGroupItem<T>(el: HTMLInputElement, group: Signal<T | null>, value: T): void;
-/**
- * Conditionally apply a CSS class based on a reactive condition.
- *
- * ```ts
- * bindClass(el, 'active', () => isActive());
- * bindClass(el, 'disabled', () => isDisabled());
- * ```
- */
-declare function bindClass(el: HTMLElement, className: string, condition: () => boolean): () => void;
-/**
- * Apply multiple conditional classes at once.
- *
- * ```ts
- * bindClasses(el, {
- *   active: () => isActive(),
- *   disabled: () => isDisabled(),
- *   'text-bold': () => isBold(),
- * });
- * ```
- */
-declare function bindClasses(el: HTMLElement, classes: Record<string, () => boolean>): () => void;
-/**
- * Reactively bind a CSS property to a value.
- *
- * ```ts
- * bindStyle(el, 'color', () => textColor());
- * bindStyle(el, 'font-size', () => `${fontSize()}px`);
- * ```
- */
-declare function bindStyle(el: HTMLElement, property: string, value: () => string | number | null): () => void;
-/**
- * Bind multiple style properties at once.
- *
- * ```ts
- * bindStyles(el, {
- *   color: () => color(),
- *   'font-size': () => `${size()}px`,
- *   opacity: () => isVisible() ? 1 : 0,
- * });
- * ```
- */
-declare function bindStyles(el: HTMLElement, styles: Record<string, () => string | number | null>): () => void;
-
-/**
- * Snippets, $inspect, form actions, and navigation snapshots.
- */
-
-type Snippet<TArgs extends unknown[] = []> = (...args: TArgs) => AkashNode;
-/**
- * Define a reusable template snippet.
- *
- * ```ts
- * const UserBadge = defineSnippet((name: string, role: string) => {
- *   const el = document.createElement('span');
- *   el.textContent = `${name} (${role})`;
- *   el.className = 'badge';
- *   return el;
- * });
- *
- * // Reuse anywhere:
- * container.appendChild(nodeToDOM(UserBadge('Alice', 'admin')));
- * container.appendChild(nodeToDOM(UserBadge('Bob', 'user')));
- * ```
- */
-declare function defineSnippet<TArgs extends unknown[]>(render: (...args: TArgs) => AkashNode): Snippet<TArgs>;
-interface InspectOptions {
-    /** Label prefix for console output */
-    label?: string;
-    /** Log level (default: 'log') */
-    level?: 'log' | 'warn' | 'debug' | 'trace';
-    /** Custom logger */
-    logger?: (label: string, ...values: unknown[]) => void;
-    /** Only log when a condition is true */
-    when?: () => boolean;
-}
-/**
- * Debug helper — logs when reactive values change.
- *
- * ```ts
- * const count = signal(0);
- * const name = signal('Alice');
- *
- * inspect(count, name); // logs: [inspect] 0, 'Alice'
- * count.set(1);         // logs: [inspect] 1, 'Alice'
- *
- * // With label:
- * inspect(count, { label: 'counter' });
- * // logs: [counter] 1
- * ```
- */
-declare function inspect(...args: Array<(() => unknown) | InspectOptions>): () => void;
-interface FormAction<T = unknown> {
-    /** The action URL */
-    url: string;
-    /** Submit method */
-    method: 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    /** Whether a submission is in progress */
-    submitting: ReadonlySignal<boolean>;
-    /** The last result */
-    result: ReadonlySignal<T | null>;
-    /** The last error */
-    error: ReadonlySignal<Error | null>;
-    /** Create an onSubmit handler for a <form> */
-    handle(formData?: Record<string, unknown>): (e: Event) => void;
-    /** Submit programmatically */
-    submit(data: Record<string, unknown>): Promise<T>;
-}
-/**
- * Define a server-side form action with progressive enhancement.
- *
- * ```ts
- * const createPost = defineFormAction<Post>('/api/posts', {
- *   method: 'POST',
- *   onSuccess: (post) => navigate(`/posts/${post.id}`),
- *   onError: (err) => toast.error(err.message),
- * });
- *
- * // In template:
- * <form onSubmit={createPost.handle()}>
- *   <input name="title" />
- *   <button disabled={createPost.submitting()}>Create</button>
- * </form>
- * ```
- */
-declare function defineFormAction<T = unknown>(url: string, options?: {
-    method?: 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    headers?: Record<string, string>;
-    onSuccess?: (result: T) => void;
-    onError?: (error: Error) => void;
-    fetch?: typeof globalThis.fetch;
-}): FormAction<T>;
-interface SnapshotConfig {
-    /** Storage key prefix (default: 'akash-snapshot') */
-    keyPrefix?: string;
-    /** What to capture */
-    capture?: ('scroll' | 'forms')[];
-}
-/**
- * Enable navigation snapshots — preserves scroll position and form
- * state when navigating with back/forward.
- *
- * ```ts
- * enableSnapshots();
- * // Now back/forward restores scroll position and form inputs
- * ```
- */
-declare function enableSnapshots(config?: SnapshotConfig): () => void;
-
-/**
- * watch() — react to signal changes with old/new values.
- *
- * Unlike effect() which just re-runs, watch() gives you the previous
- * and current value so you can react to *what changed*.
- *
- * ```ts
- * const count = signal(0);
- * watch(count, (newVal, oldVal) => {
- *   console.log(`Changed from ${oldVal} to ${newVal}`);
- * });
- *
- * // With options:
- * watch(count, callback, { immediate: true, once: true });
- *
- * // Multiple sources:
- * watch([count, name], ([newCount, newName], [oldCount, oldName]) => { ... });
- * ```
- */
-interface WatchOptions {
-    /** Run callback immediately with current value (default: false) */
-    immediate?: boolean;
-    /** Only fire once, then auto-dispose (default: false) */
-    once?: boolean;
-    /** Debounce callback in ms */
-    debounce?: number;
-    /** Deep comparison for objects (default: false) */
-    deep?: boolean;
-}
-type WatchSource<T> = () => T;
-type WatchCallback<T> = (newValue: T, oldValue: T | undefined) => void;
-type WatchArrayCallback<T extends unknown[]> = (newValues: T, oldValues: (T[number] | undefined)[]) => void;
-/**
- * Watch a reactive source and call back with old + new values.
- *
- * ```ts
- * const dispose = watch(count, (newVal, oldVal) => {
- *   analytics.track('count_changed', { from: oldVal, to: newVal });
- * });
- * ```
- */
-declare function watch<T>(source: WatchSource<T>, callback: WatchCallback<T>, options?: WatchOptions): () => void;
-/**
- * Watch multiple sources.
- */
-declare function watch<T extends unknown[]>(sources: {
-    [K in keyof T]: WatchSource<T[K]>;
-}, callback: WatchArrayCallback<T>, options?: WatchOptions): () => void;
-/**
- * Watch a source once, then auto-dispose.
- *
- * ```ts
- * watchOnce(isReady, (ready) => {
- *   if (ready) initApp();
- * });
- * ```
- */
-declare function watchOnce<T>(source: WatchSource<T>, callback: WatchCallback<T>): () => void;
-/**
- * Watch with built-in debounce.
- *
- * ```ts
- * watchDebounced(searchInput, (query) => {
- *   fetchResults(query);
- * }, 300);
- * ```
- */
-declare function watchDebounced<T>(source: WatchSource<T>, callback: WatchCallback<T>, ms: number): () => void;
-
-/**
- * Deep reactive signals.
- *
- * Unlike regular signals that are shallow, deepSignal() tracks
- * nested property access and triggers updates when any nested
- * property changes.
- *
- * ```ts
- * const state = deepSignal({ user: { name: 'Alice', age: 30 }, items: [1, 2, 3] });
- * state.user.name;           // 'Alice' (tracked)
- * state.user.name = 'Bob';   // triggers reactivity
- * state.items.push(4);       // triggers reactivity
- * ```
- */
-type DeepSignal<T> = T extends object ? {
-    [K in keyof T]: DeepSignal<T[K]>;
-} & {
-    readonly $raw: T;
-    readonly $signal: () => T;
-} : T;
-/**
- * Create a deeply reactive signal. Nested property access is tracked,
- * and setting any nested property triggers updates.
- *
- * ```ts
- * const state = deepSignal({
- *   user: { name: 'Alice', age: 30 },
- *   todos: [{ text: 'Buy milk', done: false }],
- * });
- *
- * effect(() => {
- *   console.log(state.user.name); // re-runs when name changes
- * });
- *
- * state.user.name = 'Bob'; // triggers the effect above
- * ```
- */
-declare function deepSignal<T extends object>(initialValue: T): DeepSignal<T>;
-/**
- * Get the raw (unwrapped) value from a deep signal.
- */
-declare function toRaw<T>(proxy: DeepSignal<T>): T;
-/**
- * Check if a value is a deep signal proxy.
- */
-declare function isDeepSignal(value: unknown): boolean;
-
-/**
- * Event bus — typed pub/sub for cross-component communication.
- *
- * Fire-and-forget events between unrelated components without
- * prop drilling or context coupling.
- *
- * ```ts
- * const bus = createEventBus<{
- *   'user:login': { userId: string };
- *   'cart:updated': { itemCount: number };
- *   'notification': string;
- * }>();
- *
- * // Subscribe
- * bus.on('user:login', ({ userId }) => fetchProfile(userId));
- *
- * // Emit from anywhere
- * bus.emit('user:login', { userId: '123' });
- *
- * // One-time listener
- * bus.once('cart:updated', ({ itemCount }) => showBadge(itemCount));
- * ```
- */
-type EventMap = Record<string, unknown>;
-type EventHandler<T = unknown> = (data: T) => void;
-interface EventBus<T extends EventMap> {
-    /** Subscribe to an event */
-    on<K extends keyof T & string>(event: K, handler: EventHandler<T[K]>): () => void;
-    /** Subscribe once — auto-removes after first call */
-    once<K extends keyof T & string>(event: K, handler: EventHandler<T[K]>): () => void;
-    /** Emit an event to all listeners */
-    emit<K extends keyof T & string>(event: K, data: T[K]): void;
-    /** Remove a specific handler */
-    off<K extends keyof T & string>(event: K, handler: EventHandler<T[K]>): void;
-    /** Remove all handlers for an event (or all events) */
-    clear(event?: keyof T & string): void;
-    /** Get listener count for an event */
-    listenerCount(event: keyof T & string): number;
-    /** Check if an event has listeners */
-    hasListeners(event: keyof T & string): boolean;
-}
-/**
- * Create a typed event bus.
- *
- * ```ts
- * const bus = createEventBus<{
- *   'theme:change': 'light' | 'dark';
- *   'toast': { message: string; type: string };
- * }>();
- * ```
- */
-declare function createEventBus<T extends EventMap = Record<string, unknown>>(): EventBus<T>;
-/**
- * Get the global event bus (created on first call).
- *
- * ```ts
- * import { globalEventBus } from '@akashjs/runtime';
- *
- * // In component A:
- * globalEventBus().emit('notification', 'Hello!');
- *
- * // In component B:
- * globalEventBus().on('notification', (msg) => show(msg));
- * ```
- */
-declare function globalEventBus<T extends EventMap = Record<string, unknown>>(): EventBus<T>;
-
-/**
- * Security module — built-in protection for AkashJS apps.
- *
- * Auto-sanitization, CSP support, prototype pollution prevention,
- * and secure defaults. AkashJS is secure by default.
- */
-interface SanitizeOptions {
-    /** Additional allowed tags */
-    allowTags?: string[];
-    /** Additional allowed attributes */
-    allowAttrs?: string[];
-    /** Allow data-* attributes (default: true) */
-    allowDataAttrs?: boolean;
-    /** Allow aria-* attributes (default: true) */
-    allowAriaAttrs?: boolean;
-    /** Allow style attribute (default: false) */
-    allowStyle?: boolean;
-    /** Custom tag filter */
-    tagFilter?: (tag: string) => boolean;
-    /** Custom attribute filter */
-    attrFilter?: (attr: string, value: string, tag: string) => boolean;
-}
-/**
- * Sanitize HTML string — remove dangerous tags, attributes, and URLs.
- *
- * ```ts
- * const safe = sanitize(userInput);
- * el.innerHTML = safe; // Safe from XSS
- *
- * // With options:
- * const safe = sanitize(html, { allowTags: ['iframe'], allowStyle: true });
- * ```
- */
-declare function sanitize(html: string, options?: SanitizeOptions): string;
-/**
- * Escape HTML entities — prevents XSS in text content.
- */
-declare function escapeHtml(str: string): string;
-/**
- * Create a safe HTML setter that sanitizes automatically.
- *
- * ```ts
- * const setHTML = createSafeHTML(el);
- * setHTML(userContent); // Auto-sanitized
- * ```
- */
-declare function createSafeHTML(el: HTMLElement, options?: SanitizeOptions): (html: string) => void;
-interface CSPConfig {
-    /** Nonce for inline scripts/styles */
-    nonce?: string;
-    /** Report-only mode (default: false) */
-    reportOnly?: boolean;
-    /** Report URI for CSP violations */
-    reportUri?: string;
-    /** Custom directives */
-    directives?: Record<string, string[]>;
-}
-/**
- * Generate a CSP header string.
- *
- * ```ts
- * const csp = generateCSP({
- *   nonce: 'abc123',
- *   directives: {
- *     'script-src': ["'self'"],
- *     'style-src': ["'self'", "'unsafe-inline'"],
- *     'img-src': ["'self'", 'data:', 'https:'],
- *   },
- * });
- * // "script-src 'self' 'nonce-abc123'; style-src 'self' 'unsafe-inline'; ..."
- * ```
- */
-declare function generateCSP(config?: CSPConfig): string;
-/**
- * Get the CSP header name based on config.
- */
-declare function getCSPHeaderName(config?: CSPConfig): string;
-interface SecurityHeadersConfig {
-    /** Content Security Policy (false to disable) */
-    csp?: CSPConfig | false;
-    /** X-Frame-Options (default: 'DENY') */
-    frameOptions?: 'DENY' | 'SAMEORIGIN' | false;
-    /** X-Content-Type-Options (default: 'nosniff') */
-    contentTypeOptions?: boolean;
-    /** X-XSS-Protection (default: '0' — let CSP handle it) */
-    xssProtection?: boolean;
-    /** Strict-Transport-Security */
-    hsts?: {
-        maxAge: number;
-        includeSubDomains?: boolean;
-        preload?: boolean;
-    } | false;
-    /** Referrer-Policy (default: 'strict-origin-when-cross-origin') */
-    referrerPolicy?: string | false;
-    /** Permissions-Policy */
-    permissionsPolicy?: Record<string, string[]> | false;
-    /** Cross-Origin-Opener-Policy */
-    coop?: 'same-origin' | 'same-origin-allow-popups' | 'unsafe-none' | false;
-    /** Cross-Origin-Embedder-Policy */
-    coep?: 'require-corp' | 'credentialless' | 'unsafe-none' | false;
-}
-/**
- * Generate security headers for SSR responses.
- *
- * ```ts
- * const headers = generateSecurityHeaders();
- * // Apply to your server response
- * for (const [name, value] of Object.entries(headers)) {
- *   res.setHeader(name, value);
- * }
- * ```
- */
-declare function generateSecurityHeaders(config?: SecurityHeadersConfig): Record<string, string>;
-/**
- * Safe deep merge that prevents prototype pollution.
- * Will not set __proto__, constructor, or prototype keys.
- *
- * ```ts
- * const result = safeMerge(defaults, userConfig);
- * ```
- */
-declare function safeMerge<T extends Record<string, unknown>>(target: T, ...sources: Partial<T>[]): T;
-/**
- * Freeze an object deeply — prevents any modification.
- */
-declare function deepFreeze<T>(obj: T): Readonly<T>;
-/**
- * Generate SRI hash for a script/style resource.
- * For use in <script integrity="..."> and <link integrity="...">.
- *
- * ```ts
- * // In Node.js build script:
- * const hash = await generateSRI(fileContent);
- * // 'sha384-...'
- * ```
- */
-declare function generateSRI(content: string, algorithm?: 'sha256' | 'sha384' | 'sha512'): Promise<string>;
-/**
- * Generate a CSRF token.
- */
-declare function generateCSRFToken(): string;
-/**
- * Create an HTTP interceptor that attaches CSRF tokens.
- *
- * ```ts
- * const csrf = createCSRFInterceptor();
- * const http = createHttpClient({ interceptors: [csrf.interceptor] });
- * // Token is auto-attached to every mutation request
- * ```
- */
-declare function createCSRFInterceptor(options?: {
-    headerName?: string;
-    cookieName?: string;
-    tokenGenerator?: () => string;
-}): {
-    interceptor: (request: Request, next: (req: Request) => Promise<Response>) => Promise<Response>;
-    token: () => string;
-    refresh(): void;
-};
-/**
- * Validate and sanitize a URL — prevent open redirect attacks.
- *
- * ```ts
- * const safe = sanitizeURL(userInput, { allowedHosts: ['example.com'] });
- * if (safe) window.location.href = safe;
- * ```
- */
-declare function sanitizeURL(url: string, options?: {
-    allowedHosts?: string[];
-    allowedProtocols?: string[];
-    allowRelative?: boolean;
-}): string | null;
-/**
- * Rate limiter for client-side actions (e.g., form submissions).
- *
- * ```ts
- * const limiter = createRateLimiter({ maxAttempts: 5, windowMs: 60000 });
- * if (!limiter.check()) {
- *   toast.error('Too many attempts. Please wait.');
- *   return;
- * }
- * ```
- */
-declare function createRateLimiter(options: {
-    maxAttempts: number;
-    windowMs: number;
-}): {
-    check(): boolean;
-    remaining(): number;
-    reset(): void;
-};
-
-/**
- * Deprecation warnings and API stability markers.
- *
- * Provides runtime warnings when deprecated APIs are used,
- * with migration hints pointing to the replacement.
- *
- * ```ts
- * // Mark an API as deprecated:
- * export const oldName = deprecated(newImplementation, {
- *   name: 'oldName',
- *   replacement: 'newName',
- *   since: '0.2.0',
- *   removeIn: '1.0.0',
- *   message: 'Use newName() instead for better performance.',
- * });
- *
- * // Users see:
- * // [AkashJS] DEPRECATED: oldName() is deprecated since v0.2.0 and will be removed in v1.0.0.
- * //   Use newName() instead for better performance.
- * //   See: https://akash.js.org/migration
- * ```
- */
-type APIStability = 'stable' | 'experimental' | 'deprecated' | 'internal';
-interface DeprecationInfo {
-    /** Name of the deprecated API */
-    name: string;
-    /** Replacement API name */
-    replacement?: string;
-    /** Version when deprecated */
-    since: string;
-    /** Version when it will be removed */
-    removeIn?: string;
-    /** Custom migration message */
-    message?: string;
-    /** Documentation link */
-    link?: string;
-}
-interface APIInfo {
-    /** API name */
-    name: string;
-    /** Stability level */
-    stability: APIStability;
-    /** Version introduced */
-    since: string;
-    /** Deprecation info (if deprecated) */
-    deprecation?: DeprecationInfo;
-}
-/**
- * Enable or disable deprecation warnings globally.
- */
-declare function setDeprecationWarnings(enabled: boolean): void;
-/**
- * Set a custom warning handler (default: console.warn).
- */
-declare function setWarningHandler(handler: ((msg: string) => void) | null): void;
-/**
- * Reset warned-about APIs (useful for testing).
- */
-declare function resetDeprecationWarnings(): void;
-/**
- * Wrap a function so it emits a deprecation warning on first call.
- *
- * ```ts
- * // Old API that still works but warns:
- * export const createStore = deprecated(defineStore, {
- *   name: 'createStore',
- *   replacement: 'defineStore',
- *   since: '0.2.0',
- *   removeIn: '1.0.0',
- * });
- * ```
- */
-declare function deprecated<T extends (...args: any[]) => any>(fn: T, info: DeprecationInfo): T;
-/**
- * Mark a value (non-function) as deprecated.
- * Returns the value but warns on first access.
- */
-declare function deprecatedValue<T>(value: T, info: DeprecationInfo): T;
-/**
- * Register an API with its stability level.
- */
-declare function registerAPI(info: APIInfo): void;
-/**
- * Get all registered APIs.
- */
-declare function getRegisteredAPIs(): APIInfo[];
-/**
- * Get APIs by stability level.
- */
-declare function getAPIsByStability(stability: APIStability): APIInfo[];
-/**
- * Check if an API is deprecated.
- */
-declare function isDeprecated(name: string): boolean;
-/**
- * Get deprecation info for an API.
- */
-declare function getDeprecationInfo(name: string): DeprecationInfo | null;
-interface CompatibilityResult {
-    compatible: boolean;
-    warnings: string[];
-    errors: string[];
-}
-/**
- * Check if package versions are compatible.
- *
- * ```ts
- * const result = checkCompatibility({
- *   '@akashjs/runtime': '0.2.0',
- *   '@akashjs/router': '0.1.0',
- * });
- * if (!result.compatible) {
- *   console.error(result.errors);
- * }
- * ```
- */
-declare function checkCompatibility(packages: Record<string, string>): CompatibilityResult;
-
-/**
- * Error message catalog.
- *
- * Every AkashJS runtime error has a unique code (AK0001, AK0002, etc.),
- * a one-line description, and a link to detailed documentation.
- *
- * Usage:
- *   throw akashError('AK0010', 'provide()');
- */
-interface ErrorDef {
-    /** Error code */
-    code: string;
-    /** Short description */
-    message: string;
-    /** Extended explanation and fix suggestion */
-    hint: string;
-}
-/**
- * Format an AkashJS error with code, message, hint, and doc link.
- */
-declare function formatError(code: string, context?: string): string;
-/**
- * Create and throw an AkashJS error.
- */
-declare function akashError(code: string, context?: string): Error;
-/**
- * Get the error definition for a code.
- */
-declare function getErrorDef(code: string): ErrorDef | undefined;
-/**
- * Get all registered error codes.
- */
-declare function getAllErrorCodes(): string[];
-
-interface StoreSnapshot {
-    $id: string;
-    state: Record<string, unknown>;
-    getters: Record<string, unknown>;
-    actions: string[];
-    subscriberCount: number;
-}
-interface DevToolsAPI {
-    /** List all registered stores */
-    stores(): string[];
-    /** Inspect a specific store by ID */
-    store(id: string): StoreSnapshot | null;
-    /** Get all store snapshots */
-    storeSnapshots(): Record<string, StoreSnapshot>;
-    /** List tracked signals with current values */
-    signals(): Array<{
-        name: string;
-        value: unknown;
-        subscribers: number;
-    }>;
-    /** List tracked effects with run counts */
-    effects(): Array<{
-        name: string;
-        runs: number;
-        isRender: boolean;
-        sources: number;
-    }>;
-    /** Get framework version info */
-    version(): {
-        runtime: string;
-    };
-    /** Pretty-print store state to console */
-    log(storeId?: string): void;
-    /** Record store state history for time-travel */
-    startRecording(storeId: string): void;
-    /** Stop recording and return history */
-    stopRecording(storeId: string): Array<{
-        timestamp: number;
-        state: Record<string, unknown>;
-        action?: string;
-    }>;
-}
-/**
- * Install AkashJS DevTools on the global object.
- * Call this in your app's entry point during development:
- *
- * ```ts
- * import { installDevtools } from '@akashjs/runtime';
- * if (import.meta.env.DEV) installDevtools();
- * ```
- */
-declare function installDevtools(): void;
-
-/**
- * Developer-friendly error hints.
- *
- * Wraps common runtime errors with actionable messages.
- * Only active in development mode.
- */
-/**
- * Enhance an error with a developer hint if one matches.
- */
-declare function enhanceError(error: Error): Error;
-/**
- * Install global error handler that adds hints to unhandled errors.
- * Call once in your app's entry point during development.
- */
-declare function installErrorHints(): void;
-
-export { type APIInfo, type APIStability, AkashNode, type AppInstance, type AriaLive, type AsyncComponentLoader, type AsyncComponentOptions, Await, type AwaitProps, type Breakpoints, type CSPConfig, type ColumnDef, type CompatibilityResult, Component, type CustomElementOptions, type DataTable, type DataTableOptions, type DeepSignal, type DeferOptions, type DeferTrigger, type DeprecationInfo, type DevToolsAPI, type Directive, type DirectiveBinding, type DirectiveHooks, type EasingFn, ErrorBoundary, type ErrorBoundaryProps, type ErrorDef, type EventBus, type EventHandler, type EventMap, type EventModifiers, type FlipController, type FlipOptions, type FocusTrap, type FocusTrapOptions, type FormAction, type GeolocationState, HYDRATE_ATTR, type HeadConfig, type HydrateOptions, Image, type ImageProps, type InfiniteScroll, type InfiniteScrollOptions, InjectionKey, type Injector, type InspectOptions, type Interpolator, type KeyBinding, type KeyboardManager, type LeakWarning, type LinkTag, type MetaTag, type OpenGraphData, type PerfEntry, type PerfProfile, type PerfSummary, type PipeFn, type Plugin, type PluginContext, Portal, type PortalProps, type PrerenderOptions, type PrerenderResult, type ProgressiveHydrateOptions, type ProviderDef, type ProviderRegistration, type QueryStateOptions, ReadonlySignal, type ReconcileOp, type SEOConfig, type SanitizeOptions, type ScriptTag, type SecurityHeadersConfig, Signal, type SitemapEntry, type SlotFn, type Slots, type SnapshotConfig, type Snippet, type SortDirection, type SortState, type StructuredData, Suspense, type SuspenseProps, Switch, type SwitchProps, type Theme, type ThemeConfig, type ThemeVariables, type Toast, type ToastOptions, type ToastPosition, type ToastType, type Toaster, type ToasterOptions, Transition, type TransitionClasses, type TransitionProps, type TweenedOptions, type TweenedSignal, type TwitterCardData, type ViewTransition, type ViewTransitionOptions, VirtualFor, type VirtualForProps, type VirtualRange, type WatchCallback, type WatchOptions, type WatchSource, akashError, applyDirective, applyStyles, assignTransitionName, awaitSignal, bindClass, bindClasses, bindDimensions, bindElement, bindGroup, bindGroupItem, bindScroll, bindStyle, bindStyles, calculateRange, capitalize, chain, checkCompatibility, checkForLeaks, claimElement, claimText, clearProviders, clearQueryState, collectSSRHead, countOps, createApp, createCSRFInterceptor, createDataTable, createEventBus, createFlip, createInjector, createRateLimiter, createSafeHTML, createSlots, createTimer, createToaster, css, currency, cx, date, deepFreeze, deepSignal, defer, defineAsyncComponent, defineCustomElement, defineDirective, defineFormAction, definePipe, definePlugin, defineProvider, defineSnippet, deprecated, deprecatedValue, directiveFromFn, disableLeakDetection, discoverStaticRoutes, easings, enableLeakDetection, enableSnapshots, enhanceError, enterTransition, escapeHtml, exitTransition, findHydrationBoundaries, flip, formatError, formatProfile, generateCSP, generateCSRFToken, generatePaths, generateSRI, generateSecurityHeaders, generateSitemap, generateTransitionCSS, getAPIsByStability, getActiveEffects, getAllErrorCodes, getCSPHeaderName, getDeprecationInfo, getErrorDef, getLeakDetectionStats, getProfileSummary, getQueryParams, getRegisteredAPIs, getSuspenseContext, getTransitionClasses, globalEventBus, hasSlot, hydrate, injectProvider, inspect, installDevtools, installErrorHints, isDeepSignal, isDeprecated, isHydrationActive, isLeakDetectionEnabled, isProfiling, json, longestIncreasingSubsequence, lowercase, match, measureAsync, measureSync, number, onEvent, percent, pipe, plural, prerender, progressiveHydrate, reconcileKeys, recordPerfEntry, registerAPI, registerPending, relativeTime, removeDirectives, removeQueryState, renderHeadToString, renderSlot, renderSwitch, reportLeaks, resetDeprecationWarnings, resetQueryState, safeMerge, sanitize, sanitizeURL, setDeprecationWarnings, setWarningHandler, sitemapFromResults, startProfiling, startViewTransition, stopProfiling, supportsViewTransitions, titleCase, toCustomElement, toRaw, trackEffect, trim, truncate, tweened, untrackEffect, updateDirective, uppercase, urlToFilePath, useAnnounce, useBreakpoint, useClickOutside, useClipboard, useCounter, useDebounce, useFocusTrap, useGeolocation, useHead, useInfiniteScroll, useInterval, useKeyboard, useMediaQuery, useOnline, useOpenGraph, usePrevious, useQueryState, useQueryStates, useSEO, useStorage, useStructuredData, useTheme, useThrottle, useTimeout, useToggle, useTwitterCard, useVirtualList, useWindowSize, vAutoFocus, vClickOutside, vIntersect, vLongPress, vResize, viewTransitionCSS, watch, watchDebounced, watchOnce, withModifiers };
+export { AkashNode, type SlotFn, type Slots, createSlots, hasSlot, renderSlot };