@vertz/ui 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,700 @@
+/** A single child value: DOM node, string, number, null, undefined, or nested array. */
+type ChildValue = Node | string | number | null | undefined | ChildValue[];
+/** A function that returns children (slot accessor). */
+type ChildrenAccessor = () => ChildValue;
+/**
+* Resolve a raw child value into a flat array of DOM nodes.
+* Strings and numbers are converted to Text nodes.
+* Null and undefined are filtered out.
+* Arrays are flattened recursively.
+*/
+declare function resolveChildren(value: ChildValue): Node[];
+/**
+* Create a children resolver from a children accessor.
+* Returns a function that, when called, resolves the children
+* to a flat array of DOM nodes.
+*/
+declare function children(accessor: ChildrenAccessor): () => Node[];
+/** A context object created by `createContext`. */
+interface Context<T> {
+	/** Provide a value to all `useContext` calls within the scope. */
+	Provider: (value: T, fn: () => void) => void;
+	/** @internal — current value stack */
+	_stack: T[];
+	/** @internal — default value */
+	_default: T | undefined;
+}
+/**
+* Create a context with an optional default value.
+* Returns an object with a `Provider` function.
+*/
+declare function createContext<T>(defaultValue?: T): Context<T>;
+/**
+* Retrieve the current value from the nearest Provider.
+* Checks the synchronous call stack first, then falls back to
+* the captured context scope (for async callbacks like watch/effect).
+* Returns the default value if no Provider is active.
+*/
+declare function useContext<T>(ctx: Context<T>): T | undefined;
+/** Props for the ErrorBoundary component. */
+interface ErrorBoundaryProps {
+	/** Function that returns the children to render. */
+	children: () => Node;
+	/** Fallback renderer that receives the caught error and a retry function. */
+	fallback: (error: Error, retry: () => void) => Node;
+}
+/**
+* ErrorBoundary component.
+* Catches errors thrown by `children()` and renders `fallback` instead.
+* The fallback receives the error and a retry function to re-attempt rendering.
+*
+* When retry is called, children() is re-invoked. If it succeeds, the fallback
+* node in the DOM is replaced with the new children result.
+*
+* Also registers an async error handler so that nested Suspense components
+* can propagate async errors to this boundary.
+*/
+declare function ErrorBoundary(props: ErrorBoundaryProps): Node;
+/**
+* Runs callback once on mount. Never re-executes.
+* Supports `onCleanup` inside for teardown on unmount.
+*/
+declare function onMount(callback: () => void): void;
+/**
+* Watches a dependency accessor and runs callback whenever it changes.
+* Always takes TWO arguments: a dependency accessor and a callback.
+* Runs callback immediately with current value.
+* Before each re-run, any `onCleanup` from previous run executes first.
+*/
+declare function watch<T>(dep: () => T, callback: (value: T) => void): void;
+/** A ref container for DOM element access. */
+interface Ref<T> {
+	current: T | undefined;
+}
+/**
+* Create a ref for accessing a DOM element after mount.
+* Returns `{ current: undefined }` initially; after mount,
+* `ref.current` will hold the DOM element.
+*/
+declare function ref<T>(): Ref<T>;
+/** Props for the Suspense component. */
+interface SuspenseProps {
+	/** Function that returns the children to render (may throw a Promise). */
+	children: () => Node;
+	/** Fallback renderer shown while children are pending. */
+	fallback: () => Node;
+}
+/**
+* Suspense component for async boundaries.
+* Renders children synchronously if possible.
+* If children throw a Promise, renders the fallback and waits for resolution,
+* then replaces the fallback with the children result.
+* If children throw a non-Promise error, it is re-thrown (use ErrorBoundary for error handling).
+*
+* For async errors (promise rejection or retry failure), the error is propagated
+* to the nearest ErrorBoundary. If no ErrorBoundary exists, the error is surfaced
+* globally via queueMicrotask to avoid silent swallowing.
+*/
+declare function Suspense(props: SuspenseProps): Node;
+/** A style entry in the array: either a shorthand string or an object for nested selectors. */
+type StyleEntry = string | Record<string, string[]>;
+/** Input to css(): a record of named style blocks. */
+type CSSInput = Record<string, StyleEntry[]>;
+/** Output of css(): a record of block names to class names, plus extracted CSS. */
+interface CSSOutput {
+	/** Map of block name → generated class name. */
+	classNames: Record<string, string>;
+	/** The extracted CSS string. */
+	css: string;
+}
+/**
+* Process a css() call and produce class names + extracted CSS.
+*
+* In production, the compiler replaces css() calls at build time.
+* This runtime implementation is used for:
+* - Development mode
+* - Testing
+* - SSR fallback
+*
+* @param input - Named style blocks.
+* @param filePath - Source file path for deterministic hashing.
+* @returns Class names map and extracted CSS.
+*/
+declare function css(input: CSSInput, filePath?: string): CSSOutput;
+/** Input to globalCss(): selector → property-value map. */
+type GlobalCSSInput = Record<string, Record<string, string>>;
+/** Output of globalCss(): extracted CSS string. */
+interface GlobalCSSOutput {
+	/** The extracted global CSS string. */
+	css: string;
+}
+/**
+* Process a globalCss() call and produce global CSS rules.
+*
+* Properties use camelCase and are converted to kebab-case.
+* CSS custom properties (--*) are passed through as-is.
+*
+* @param input - Selector-to-properties map.
+* @returns Extracted CSS.
+*/
+declare function globalCss(input: GlobalCSSInput): GlobalCSSOutput;
+/**
+* Convert an array of shorthand strings into a CSS properties object
+* suitable for inline styles.
+*
+* Note: Pseudo-states are not supported in inline styles and will
+* cause an error. Use css() for pseudo-states.
+*
+* @param entries - Array of shorthand strings.
+* @returns A Record of CSS property → value pairs (kebab-case keys).
+*/
+declare function s(entries: string[]): Record<string, string>;
+/** Color tokens: a map of color names to their raw/contextual values. */
+type ColorTokens = Record<string, Record<string, string>>;
+/** Spacing tokens: a flat map of names to CSS values. */
+type SpacingTokens = Record<string, string>;
+/** Input to defineTheme(). */
+interface ThemeInput {
+	/** Color design tokens (raw shades and contextual variants). */
+	colors: ColorTokens;
+	/** Spacing scale tokens. */
+	spacing?: SpacingTokens;
+}
+/** The structured theme object returned by defineTheme(). */
+interface Theme {
+	/** Color design tokens. */
+	colors: ColorTokens;
+	/** Spacing scale tokens. */
+	spacing?: SpacingTokens;
+}
+/** Output of compileTheme(). */
+interface CompiledTheme {
+	/** The generated CSS string with :root and [data-theme] blocks. */
+	css: string;
+	/** Flat list of token dot-paths (e.g., 'primary.500', 'background'). */
+	tokens: string[];
+}
+/**
+* Define a theme with raw and contextual design tokens.
+*
+* @param input - Theme token definitions.
+* @returns A structured theme object.
+*/
+declare function defineTheme(input: ThemeInput): Theme;
+/**
+* Compile a theme into CSS custom properties.
+*
+* Generates:
+* - `:root { ... }` block with default/raw token values
+* - `[data-theme="dark"] { ... }` block with dark overrides (if any)
+*
+* @param theme - A theme object from defineTheme().
+* @returns Compiled CSS and token list.
+*/
+declare function compileTheme(theme: Theme): CompiledTheme;
+/**
+* ThemeProvider — Sets `data-theme` attribute for contextual token switching.
+*
+* Creates a wrapper div element with the appropriate `data-theme` attribute
+* so that contextual CSS custom properties (generated by compileTheme) resolve
+* to the correct variant values.
+*
+* Usage:
+* ```ts
+* ThemeProvider({ theme: 'dark', children: [myApp] });
+* ```
+*/
+/** A child node: either a DOM Node or a string (text content). */
+type ThemeChild = Node | string;
+/** Props for ThemeProvider. */
+interface ThemeProviderProps {
+	/** The theme variant name (e.g., 'light', 'dark'). Defaults to 'light'. */
+	theme?: string;
+	/** Child elements to render inside the provider. */
+	children: ThemeChild[];
+}
+/**
+* Create a wrapper div with `data-theme` attribute for theme switching.
+*
+* @param props - Theme and children.
+* @returns A div element with `data-theme` set and children appended.
+*/
+declare function ThemeProvider(props: ThemeProviderProps): HTMLDivElement;
+/** A record of variant names to their possible values (each value maps to style entries). */
+type VariantDefinitions = Record<string, Record<string, StyleEntry[]>>;
+/** Extract the variant props type from a variant definitions object. */
+type VariantProps<V extends VariantDefinitions> = { [K in keyof V]? : keyof V[K] };
+/** A compound variant rule: matches when all specified variant values are active. */
+type CompoundVariant<V extends VariantDefinitions> = { [K in keyof V]? : keyof V[K] } & {
+	styles: StyleEntry[];
+};
+/** Configuration for the variants() function. */
+interface VariantsConfig<V extends VariantDefinitions> {
+	/** Base styles applied to all variants. */
+	base: StyleEntry[];
+	/** Variant definitions: each key is a variant name, each value is a map of option to styles. */
+	variants: V;
+	/** Default variant values used when no override is provided. */
+	defaultVariants?: { [K in keyof V]? : keyof V[K] };
+	/** Compound variants: styles applied when multiple variant values match simultaneously. */
+	compoundVariants?: CompoundVariant<V>[];
+}
+/** The function returned by variants(). Takes optional variant props and returns a className string. */
+interface VariantFunction<V extends VariantDefinitions> {
+	(props?: VariantProps<V>): string;
+	/** The extracted CSS for all variant combinations. */
+	css: string;
+}
+/**
+* Create a typed variant function from a config object.
+*
+* @param config - Variant configuration (base, variants, defaultVariants, compoundVariants).
+* @returns A function that accepts variant props and returns a className string.
+*/
+declare function variants<V extends VariantDefinitions>(config: VariantsConfig<V>): VariantFunction<V>;
+/**
+* A reactive signal that holds a value and notifies subscribers on change.
+*/
+interface Signal<T> {
+	/** Get the current value and subscribe to changes (when inside a tracking context). */
+	get value(): T;
+	/** Set the current value and notify subscribers if changed. */
+	set value(newValue: T);
+	/** Read the current value without subscribing (no tracking). */
+	peek(): T;
+	/** Manually notify all subscribers (useful after mutating the value in place). */
+	notify(): void;
+}
+/**
+* A read-only reactive value derived from other signals.
+*/
+interface ReadonlySignal<T> {
+	/** Get the current value and subscribe to changes. */
+	readonly value: T;
+	/** Read the current value without subscribing. */
+	peek(): T;
+}
+/**
+* A computed signal — lazily evaluated, cached, and automatically re-computed
+* when dependencies change.
+*/
+interface Computed<T> extends ReadonlySignal<T> {
+	/** Get the current value, re-computing if dirty. Subscribes in tracking context. */
+	readonly value: T;
+	/** Read the current value without subscribing. */
+	peek(): T;
+}
+/** Dispose function returned by effect(). */
+type DisposeFn = () => void;
+/**
+* Minimal schema interface compatible with @vertz/schema.
+* Any object with a `parse(data: unknown): T` method satisfies this.
+*/
+interface FormSchema<T> {
+	parse(data: unknown): T;
+}
+/** Result of a validation attempt. */
+type ValidationResult<T> = {
+	success: true;
+	data: T;
+	errors: Record<string, never>;
+} | {
+	success: false;
+	data: undefined;
+	errors: Record<string, string>;
+};
+/**
+* Validate data against a schema.
+*
+* - On success, returns `{ success: true, data, errors: {} }`.
+* - On failure, extracts field errors from `error.fieldErrors` if present,
+*   otherwise falls back to a generic `_form` error.
+*/
+declare function validate<T>(schema: FormSchema<T>, data: unknown): ValidationResult<T>;
+/**
+* An SDK method with endpoint metadata attached.
+* Generated SDK methods expose `.url` and `.method` for progressive enhancement.
+*/
+interface SdkMethod<
+	TBody,
+	TResult
+> {
+	(body: TBody): Promise<TResult>;
+	url: string;
+	method: string;
+}
+/** Options for creating a form instance. */
+interface FormOptions<TBody> {
+	/** Explicit schema for client-side validation before submission. */
+	schema: FormSchema<TBody>;
+}
+/** Callbacks for form submission. Both are optional per spec. */
+interface SubmitCallbacks<TResult> {
+	onSuccess?: (result: TResult) => void;
+	onError?: (errors: Record<string, string>) => void;
+}
+/** A form instance bound to an SDK method. */
+interface FormInstance<
+	TBody,
+	TResult
+> {
+	/** Returns `{ action, method }` for progressive enhancement in HTML forms. */
+	attrs(): {
+		action: string;
+		method: string;
+	};
+	/** Reactive signal indicating whether a submission is in progress. */
+	submitting: Signal<boolean>;
+	/**
+	* Returns an event handler that extracts FormData, validates, and submits.
+	* Assignable to onSubmit: `onSubmit={userForm.handleSubmit({ onSuccess })}`.
+	*
+	* Can also be called directly with FormData for non-DOM usage:
+	* `userForm.handleSubmit({ onSuccess })(formData)`.
+	*/
+	handleSubmit(callbacks?: SubmitCallbacks<TResult>): (formDataOrEvent: FormData | Event) => Promise<void>;
+	/** Returns the error message for a field reactively, or undefined if no error. Type-safe field names. */
+	error(field: keyof TBody & string): string | undefined;
+}
+/**
+* Create a form instance bound to an SDK method with schema validation.
+*
+* The form provides:
+* - `attrs()` for progressive enhancement (returns action/method from SDK metadata)
+* - `handleSubmit()` returns an event handler for FormData extraction, validation, and SDK submission
+* - `error()` for reactive field-level error access
+* - `submitting` signal for loading state
+*/
+declare function form<
+	TBody,
+	TResult
+>(sdkMethod: SdkMethod<TBody, TResult>, options: FormOptions<TBody>): FormInstance<TBody, TResult>;
+/** Options for formDataToObject conversion. */
+interface FormDataOptions {
+	/** When true, coerces numeric strings to numbers and "true"/"false" to booleans. */
+	coerce?: boolean;
+}
+/**
+* Convert FormData to a plain object.
+*
+* - File entries are skipped (only string values are included).
+* - Duplicate keys use the last value.
+* - When `coerce` is true, numeric strings become numbers and
+*   "true"/"false" become booleans.
+*/
+declare function formDataToObject(formData: FormData, options?: FormDataOptions): Record<string, unknown>;
+/** A function returning a dynamic import of a component module. */
+type ComponentLoader = () => Promise<{
+	default: ComponentFunction;
+}>;
+/** A component function that takes props and an element to mount into. */
+type ComponentFunction = (props: Record<string, unknown>, el: Element) => void;
+/** Maps component IDs to their dynamic import loaders. */
+type ComponentRegistry = Record<string, ComponentLoader>;
+/**
+* Client entry point for atomic per-component hydration.
+*
+* Scans the DOM for elements with `data-v-id` markers placed by the SSR pass,
+* deserializes their props, and applies the appropriate hydration strategy.
+*
+* Components without `data-v-id` markers are static and ship zero JS.
+*
+* Elements that have already been hydrated (marked with `data-v-hydrated`)
+* are skipped to prevent double hydration when `hydrate()` is called
+* multiple times on the same page.
+*/
+declare function hydrate(registry: ComponentRegistry): void;
+/**
+* Hydration strategies determine WHEN a component gets hydrated.
+*
+* - eager: immediately on page load
+* - lazy (default): when element becomes visible (IntersectionObserver, 200px rootMargin)
+* - interaction: on first user event (click, focus, pointerenter)
+* - idle: during browser idle time (requestIdleCallback, falls back to setTimeout)
+* - media(query): when a CSS media query matches
+* - visible: when element enters the viewport (IntersectionObserver, no rootMargin)
+*/
+/** Eager -- hydrate immediately on page load. */
+declare function eagerStrategy(el: Element, hydrateFn: () => void): void;
+/** Lazy (default) -- hydrate when element becomes visible via IntersectionObserver with 200px rootMargin. */
+declare function lazyStrategy(el: Element, hydrateFn: () => void): void;
+/** Interaction -- hydrate on first user event (click, focus, pointerenter). */
+declare function interactionStrategy(el: Element, hydrateFn: () => void): void;
+/** Idle -- hydrate during browser idle time via requestIdleCallback. Falls back to setTimeout(fn, 0). */
+declare function idleStrategy(el: Element, hydrateFn: () => void): void;
+/**
+* Media -- hydrate when a CSS media query matches.
+* Returns a strategy function bound to the given query string.
+*/
+declare function mediaStrategy(query: string): (el: Element, hydrateFn: () => void) => void;
+/** Visible -- hydrate when element enters the viewport via IntersectionObserver (no rootMargin). */
+declare function visibleStrategy(el: Element, hydrateFn: () => void): void;
+/**
+* Interface for cache stores used by query().
+* Consumers can provide custom implementations (e.g. LRU, persistent storage).
+*/
+interface CacheStore<T = unknown> {
+	get(key: string): T | undefined;
+	set(key: string, value: T): void;
+	delete(key: string): void;
+}
+/** Options for query(). */
+interface QueryOptions<T> {
+	/** Pre-populated data — skips the initial fetch when provided. */
+	initialData?: T;
+	/** Debounce re-fetches triggered by reactive dependency changes (ms). */
+	debounce?: number;
+	/** When false, the query will not fetch. Defaults to true. */
+	enabled?: boolean;
+	/** Explicit cache key. When omitted, derived from the thunk. */
+	key?: string;
+	/** Custom cache store. Defaults to a shared in-memory Map. */
+	cache?: CacheStore<T>;
+}
+/** The reactive object returned by query(). */
+interface QueryResult<T> {
+	/** The fetched data, or undefined while loading. */
+	readonly data: ReadonlySignal<T | undefined>;
+	/** True while a fetch is in progress. */
+	readonly loading: ReadonlySignal<boolean>;
+	/** The error from the latest failed fetch, or undefined. */
+	readonly error: ReadonlySignal<unknown>;
+	/** Manually trigger a refetch (clears cache for this key). */
+	refetch: () => void;
+	/** Alias for refetch — revalidate the cached data. */
+	revalidate: () => void;
+	/** Dispose the query — stops the reactive effect and cleans up inflight state. */
+	dispose: () => void;
+}
+/**
+* Create a reactive data-fetching query.
+*
+* The thunk is wrapped in an effect so that when reactive dependencies
+* used *before* the async call change, the query automatically re-fetches.
+*
+* @param thunk - An async function that returns the data.
+* @param options - Optional configuration.
+* @returns A QueryResult with reactive signals for data, loading, and error.
+*/
+declare function query<T>(thunk: () => Promise<T>, options?: QueryOptions<T>): QueryResult<T>;
+/**
+* Template literal type utility that extracts route parameter names from a path pattern.
+*
+* Examples:
+* - `'/users/:id'` -> `{ id: string }`
+* - `'/users/:id/posts/:postId'` -> `{ id: string; postId: string }`
+* - `'/files/*'` -> `{ '*': string }`
+* - `'/users'` -> `Record<string, never>`
+*/
+/** Extract param names from a single segment. */
+type ExtractSegmentParam<S extends string> = S extends `:${infer Param}` ? Param : never;
+/** Recursively extract params from path segments separated by '/'. */
+type ExtractParamsFromSegments<T extends string> = T extends `${infer Segment}/${infer Rest}` ? ExtractSegmentParam<Segment> | ExtractParamsFromSegments<Rest> : ExtractSegmentParam<T>;
+/** Check if a path contains a wildcard '*' at the end. */
+type HasWildcard<T extends string> = T extends `${string}*` ? true : false;
+/** Remove trailing wildcard for param extraction. */
+type WithoutWildcard<T extends string> = T extends `${infer Before}*` ? Before : T;
+/**
+* Extract typed params from a route path pattern.
+* `:param` segments become `{ param: string }`.
+* A trailing `*` becomes `{ '*': string }`.
+*/
+type ExtractParams<T extends string> = [ExtractParamsFromSegments<WithoutWildcard<T>>] extends [never] ? HasWildcard<T> extends true ? {
+	"*": string;
+} : Record<string, never> : HasWildcard<T> extends true ? { [K in ExtractParamsFromSegments<WithoutWildcard<T>>] : string } & {
+	"*": string;
+} : { [K in ExtractParamsFromSegments<WithoutWildcard<T>>] : string };
+/** Simple schema interface for search param parsing. */
+interface SearchParamSchema<T> {
+	parse(data: unknown): T;
+}
+/** A route configuration for a single path. */
+interface RouteConfig<
+	TPath extends string = string,
+	TLoaderData = unknown,
+	TSearch = unknown
+> {
+	/** Component factory (lazy for code splitting). */
+	component: () => Node | Promise<{
+		default: () => Node;
+	}>;
+	/** Optional loader that runs before render. */
+	loader?: (ctx: {
+		params: ExtractParams<TPath>;
+		signal: AbortSignal;
+	}) => Promise<TLoaderData> | TLoaderData;
+	/** Optional error component rendered when loader throws. */
+	errorComponent?: (error: Error) => Node;
+	/** Optional search params schema for validation/coercion. */
+	searchParams?: SearchParamSchema<TSearch>;
+	/** Nested child routes. */
+	children?: RouteDefinitionMap;
+}
+/** A map of path patterns to route configs (user input format). */
+interface RouteDefinitionMap {
+	[pattern: string]: RouteConfig;
+}
+/** Internal compiled route. */
+interface CompiledRoute {
+	/** The original path pattern. */
+	pattern: string;
+	/** The route config. */
+	component: RouteConfig["component"];
+	loader?: (ctx: {
+		params: Record<string, string>;
+		signal: AbortSignal;
+	}) => Promise<unknown> | unknown;
+	errorComponent?: RouteConfig["errorComponent"];
+	searchParams?: RouteConfig["searchParams"];
+	/** Compiled children. */
+	children?: CompiledRoute[];
+}
+/** A single matched route entry in the matched chain. */
+interface MatchedRoute {
+	route: CompiledRoute;
+	params: Record<string, string>;
+}
+/** Result of matching a URL against the route tree. */
+interface RouteMatch {
+	/** All params extracted from the full URL path. */
+	params: Record<string, string>;
+	/** The leaf route config that matched. */
+	route: CompiledRoute;
+	/** The chain of matched routes from root to leaf (for nested layouts). */
+	matched: MatchedRoute[];
+	/** URLSearchParams from the URL. */
+	searchParams: URLSearchParams;
+	/** Parsed/coerced search params if schema is defined. */
+	search: Record<string, unknown>;
+}
+/**
+* Type utility to extract loader return type from a route config.
+*/
+type LoaderData<T> = T extends {
+	loader: (...args: never[]) => Promise<infer R>;
+} ? R : T extends {
+	loader: (...args: never[]) => infer R;
+} ? R : never;
+/**
+* Define routes from a configuration map.
+* Returns an array of compiled routes preserving definition order.
+*/
+declare function defineRoutes(map: RouteDefinitionMap): CompiledRoute[];
+/** Props for the Link component. */
+interface LinkProps {
+	/** The target URL path. */
+	href: string;
+	/** Text or content for the link. */
+	children: string;
+	/** Class applied when the link's href matches the current path. */
+	activeClass?: string;
+	/** Static class name for the anchor element. */
+	className?: string;
+}
+/**
+* Create a Link component factory bound to the router's state.
+*
+* @param currentPath - Reactive signal of the current URL path
+* @param navigate - Navigation function from the router
+* @returns A Link component function
+*/
+declare function createLink(currentPath: ReadonlySignal<string>, navigate: (url: string) => void): (props: LinkProps) => HTMLAnchorElement;
+/** Options for router.navigate(). */
+interface NavigateOptions {
+	/** Use history.replaceState instead of pushState. */
+	replace?: boolean;
+}
+/** The router instance returned by createRouter. */
+interface Router {
+	/** Current matched route (reactive signal). */
+	current: Signal<RouteMatch | null>;
+	/** Loader data from the current route's loaders (reactive signal). */
+	loaderData: Signal<unknown[]>;
+	/** Loader error if any loader threw (reactive signal). */
+	loaderError: Signal<Error | null>;
+	/** Parsed search params from the current route (reactive signal). */
+	searchParams: Signal<Record<string, unknown>>;
+	/** Navigate to a new URL path. */
+	navigate: (url: string, options?: NavigateOptions) => Promise<void>;
+	/** Re-run all loaders for the current route. */
+	revalidate: () => Promise<void>;
+	/** Remove popstate listener and clean up the router. */
+	dispose: () => void;
+}
+/**
+* Create a router instance.
+*
+* @param routes - Compiled route list from defineRoutes()
+* @param initialUrl - The initial URL to match (optional; auto-detects from window.location or __SSR_URL__)
+* @returns Router instance with reactive state and navigation methods
+*/
+declare function createRouter(routes: CompiledRoute[], initialUrl?: string): Router;
+/** Context value for the Outlet. */
+interface OutletContext {
+	/** The child component factory to render, or undefined if no child. */
+	childComponent: (() => Node) | undefined;
+	/** The nesting depth (for debugging/tracking). */
+	depth: number;
+}
+/**
+* Create an Outlet component bound to a specific outlet context.
+*
+* @param outletCtx - The context that holds the child component
+* @returns An Outlet component function
+*/
+declare function createOutlet(outletCtx: Context<OutletContext>): () => Node;
+/**
+* Parse URLSearchParams into a typed object, optionally through a schema.
+*
+* @param urlParams - The raw URLSearchParams
+* @param schema - Optional schema with a `parse` method for validation/coercion
+* @returns Parsed search params object
+*/
+declare function parseSearchParams<T = Record<string, string>>(urlParams: URLSearchParams, schema?: SearchParamSchema<T>): T;
+/**
+* Read the current search params from a reactive signal.
+* Intended to be called inside a reactive context (effect/computed).
+*
+* @param searchSignal - Signal holding the current parsed search params
+* @returns The current search params value
+*/
+declare function useSearchParams<T>(searchSignal: ReadonlySignal<T>): T;
+/**
+* Error thrown when `onCleanup()` is called outside a disposal scope.
+* Similar to React's invalid hook call error — fail-fast so developers
+* know their cleanup callback was not registered.
+*/
+declare class DisposalScopeError extends Error {
+	constructor();
+}
+/**
+* Register a cleanup function with the current disposal scope.
+* Throws `DisposalScopeError` if no scope is active — fail-fast
+* so developers know their cleanup callback was not registered.
+*/
+declare function onCleanup(fn: DisposeFn): void;
+/**
+* Group multiple signal writes into a single update flush.
+* Nested batches are supported — only the outermost batch triggers the flush.
+*/
+declare function batch(fn: () => void): void;
+/**
+* Create a reactive signal with an initial value.
+*/
+declare function signal<T>(initial: T): Signal<T>;
+/**
+* Create a computed (derived) reactive value.
+* The function is lazily evaluated and cached.
+*/
+declare function computed<T>(fn: () => T): Computed<T>;
+/**
+* Create a reactive effect that re-runs whenever its dependencies change.
+* Returns a dispose function to stop the effect.
+*/
+declare function effect(fn: () => void): DisposeFn;
+/**
+* Execute a function without tracking any signal reads.
+* Useful for reading signals without creating subscriptions.
+*/
+declare function untrack<T>(fn: () => T): T;
+export { watch, visibleStrategy, variants, validate, useSearchParams, useContext, untrack, signal, s, resolveChildren, ref, query, parseSearchParams, onMount, onCleanup, mediaStrategy, lazyStrategy, interactionStrategy, idleStrategy, hydrate, globalCss, formDataToObject, form, effect, eagerStrategy, defineTheme, defineRoutes, css, createRouter, createOutlet, createLink, createContext, computed, compileTheme, children, batch, VariantsConfig, VariantProps, VariantFunction, ValidationResult, ThemeProviderProps, ThemeProvider, ThemeInput, Theme, SuspenseProps, Suspense, SubmitCallbacks, StyleEntry, Signal, SearchParamSchema, SdkMethod, Router, RouteMatch, RouteDefinitionMap, RouteConfig, Ref, ReadonlySignal, QueryResult, QueryOptions, OutletContext, NavigateOptions, MatchedRoute, LoaderData, LinkProps, GlobalCSSOutput, GlobalCSSInput, FormSchema, FormOptions, FormInstance, FormDataOptions, ExtractParams, ErrorBoundaryProps, ErrorBoundary, DisposeFn, DisposalScopeError, Context, Computed, ComponentRegistry, ComponentLoader, ComponentFunction, CompiledTheme, CompiledRoute, ChildrenAccessor, ChildValue, CacheStore, CSSOutput, CSSInput };