jotai-solid-api 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,861 @@
+import * as React from "react";
+type Cleanup = () => void;
+/**
+ * Read-only reactive getter.
+ *
+ * @example
+ * ```ts
+ * const [count] = createSignal(1)
+ * const value: number = count()
+ * ```
+ */
+export type Accessor<T> = () => T;
+/**
+ * Reactive setter that accepts either a value or updater function.
+ *
+ * @example
+ * ```ts
+ * const [, setCount] = createSignal(1)
+ * setCount((n) => n + 1)
+ * ```
+ */
+export type Setter<T> = (nextValue: T | ((prev: T) => T)) => T;
+/**
+ * Setter shape compatible with Solid's `createSignal` setter.
+ *
+ * @example
+ * ```ts
+ * const set: SolidSetter<number> = (next) => next
+ * ```
+ */
+export type SolidSetter<T> = (nextValue: T | ((prev: T) => T)) => unknown;
+/**
+ * Tuple shape compatible with Solid's signal pair.
+ *
+ * @example
+ * ```ts
+ * const pair: SolidSignal<number> = [() => 1, (next) => next]
+ * ```
+ */
+export type SolidSignal<T> = readonly [Accessor<T>, SolidSetter<T>];
+/**
+ * Async resource lifecycle states.
+ *
+ * @example
+ * ```ts
+ * if (user.state() === "ready") {
+ *   // render user
+ * }
+ * ```
+ */
+export type ResourceState = "unresolved" | "pending" | "ready" | "errored";
+/**
+ * Read function for async resources with state metadata.
+ *
+ * @example
+ * ```ts
+ * const [user] = createResource(fetchUser)
+ * if (user.loading()) return "Loading"
+ * return user()?.name
+ * ```
+ */
+export type ResourceAccessor<T> = Accessor<T | undefined> & {
+    readonly loading: Accessor<boolean>;
+    readonly error: Accessor<unknown>;
+    readonly latest: Accessor<T | undefined>;
+    readonly state: Accessor<ResourceState>;
+};
+/**
+ * Imperative controls returned by {@link createResource}.
+ *
+ * @example
+ * ```ts
+ * const [, controls] = createResource(fetchUsers)
+ * controls.refetch()
+ * ```
+ */
+export type ResourceControls<T> = {
+    mutate: Setter<T | undefined>;
+    refetch: () => void;
+};
+/**
+ * Options for async resources.
+ *
+ * @example
+ * ```ts
+ * const [user] = createResource(fetchUser, { initialValue: cachedUser })
+ * ```
+ */
+export type ResourceOptions<T> = {
+    initialValue?: T;
+};
+/**
+ * Creates a writable signal.
+ *
+ * @param initialValue Initial value stored in the signal.
+ * @returns Tuple of `[getter, setter]`.
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = createSignal(0)
+ * setCount((n) => n + 1)
+ * ```
+ */
+export declare function createSignal<T>(initialValue: T): [Accessor<T>, Setter<T>];
+/**
+ * Alias for {@link createSignal}.
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = signal(0)
+ * ```
+ */
+export declare const signal: typeof createSignal;
+/**
+ * Adapts a Solid-compatible signal pair into this library's strict setter shape.
+ *
+ * @param solidSignal Signal tuple `[get, set]` from Solid or compatible runtimes.
+ * @returns Tuple `[get, set]` where `set` returns the current value.
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = fromSolidSignal(otherSignal)
+ * setCount((n) => n + 1)
+ * ```
+ */
+export declare function fromSolidSignal<T>(solidSignal: SolidSignal<T>): [Accessor<T>, Setter<T>];
+/**
+ * Adapts this library's signal pair to a Solid-compatible tuple shape.
+ *
+ * @param reactiveSignal Tuple `[get, set]` from this library.
+ * @returns Solid-compatible signal tuple.
+ *
+ * @example
+ * ```ts
+ * const solidPair = toSolidSignal(createSignal(0))
+ * ```
+ */
+export declare function toSolidSignal<T>(reactiveSignal: readonly [Accessor<T>, Setter<T>]): SolidSignal<T>;
+/**
+ * Alias for {@link fromSolidSignal}.
+ */
+export declare const fromSignal: typeof fromSolidSignal;
+/**
+ * Alias for {@link toSolidSignal}.
+ */
+export declare const toSignal: typeof toSolidSignal;
+/**
+ * Creates a cached derived accessor.
+ *
+ * @param compute Derivation function. Reads inside this function become dependencies.
+ * @returns Read-only accessor for the derived value.
+ *
+ * @example
+ * ```ts
+ * const total = createMemo(() => items().length)
+ * ```
+ */
+export declare function createMemo<T>(compute: () => T): Accessor<T>;
+/**
+ * Alias for {@link createMemo}.
+ *
+ * @example
+ * ```ts
+ * const total = memo(() => items().length)
+ * ```
+ */
+export declare const memo: typeof createMemo;
+/**
+ * Registers an effect that runs after React commit.
+ *
+ * @param effect Effect callback. Return a cleanup function to dispose previous run resources.
+ *
+ * @example
+ * ```ts
+ * createEffect(() => {
+ *   console.log(count())
+ * })
+ * ```
+ */
+export declare function createEffect(effect: () => void | Cleanup): void;
+/**
+ * Alias for {@link createEffect}.
+ *
+ * @example
+ * ```ts
+ * effect(() => console.log(count()))
+ * ```
+ */
+export declare const effect: typeof createEffect;
+/**
+ * Registers an effect that runs in layout phase.
+ *
+ * @param effect Layout effect callback. Return a cleanup function to dispose previous run resources.
+ *
+ * @example
+ * ```ts
+ * createLayoutEffect(() => {
+ *   measureLayout()
+ * })
+ * ```
+ */
+export declare function createLayoutEffect(effect: () => void | Cleanup): void;
+/**
+ * Alias for {@link createLayoutEffect}.
+ *
+ * @example
+ * ```ts
+ * layoutEffect(() => measure())
+ * ```
+ */
+export declare const layoutEffect: typeof createLayoutEffect;
+/**
+ * Creates a reactive computation for side effects.
+ * Alias of {@link createEffect} for Solid-style API compatibility.
+ *
+ * @param compute Side-effect function.
+ *
+ * @example
+ * ```ts
+ * createComputed(() => {
+ *   syncExternalStore(count())
+ * })
+ * ```
+ */
+export declare function createComputed(compute: () => void | Cleanup): void;
+/**
+ * Alias for {@link createComputed}.
+ *
+ * @example
+ * ```ts
+ * computed(() => sync(count()))
+ * ```
+ */
+export declare const computed: typeof createComputed;
+/**
+ * Runs a callback once on mount and disposes it on unmount if cleanup is returned.
+ *
+ * @param callback Mount callback.
+ *
+ * @example
+ * ```ts
+ * onMount(() => {
+ *   const ws = connect()
+ *   return () => ws.close()
+ * })
+ * ```
+ */
+export declare function onMount(callback: () => void | Cleanup): void;
+/**
+ * Alias for {@link onMount}.
+ *
+ * @example
+ * ```ts
+ * mount(() => console.log("mounted"))
+ * ```
+ */
+export declare const mount: typeof onMount;
+/**
+ * Registers cleanup in setup scope or currently running effect.
+ *
+ * @param cleanup Cleanup callback invoked on re-run or scope disposal.
+ *
+ * @example
+ * ```ts
+ * createEffect(() => {
+ *   const id = setInterval(tick, 1000)
+ *   onCleanup(() => clearInterval(id))
+ * })
+ * ```
+ */
+export declare function onCleanup(cleanup: Cleanup): void;
+/**
+ * Alias for {@link onCleanup}.
+ *
+ * @example
+ * ```ts
+ * cleanup(() => console.log("disposed"))
+ * ```
+ */
+export declare const cleanup: typeof onCleanup;
+/**
+ * Batches reactive notifications and flushes once at the end.
+ *
+ * @param fn Function containing grouped signal/store writes.
+ * @returns Result of `fn()`.
+ *
+ * @example
+ * ```ts
+ * batch(() => {
+ *   setFirst("Ada")
+ *   setLast("Lovelace")
+ * })
+ * ```
+ */
+export declare function batch<T>(fn: () => T): T;
+/**
+ * Executes a function without dependency tracking.
+ *
+ * @param fn Function to execute without capturing dependencies.
+ * @returns Result of `fn()`.
+ *
+ * @example
+ * ```ts
+ * const stable = untrack(() => expensiveSnapshot())
+ * ```
+ */
+export declare function untrack<T>(fn: () => T): T;
+/**
+ * Creates an async resource from a fetcher.
+ *
+ * @param fetcher Async or sync function that resolves the resource value.
+ * @param options Optional resource options such as `initialValue`.
+ * @returns Tuple of `[resourceAccessor, controls]`.
+ *
+ * @example
+ * ```ts
+ * const [users, { refetch }] = createResource(async () => fetchUsers())
+ * refetch()
+ * ```
+ */
+export declare function createResource<T>(fetcher: () => Promise<T> | T, options?: ResourceOptions<T>): [
+    ResourceAccessor<T>,
+    ResourceControls<T>
+];
+/**
+ * Creates an async resource that re-fetches when `source()` changes.
+ *
+ * @param source Source accessor. When this value changes, the resource refetches.
+ * @param fetcher Fetcher receiving source value and refetch metadata.
+ * @param options Optional resource options such as `initialValue`.
+ * @returns Tuple of `[resourceAccessor, controls]`.
+ *
+ * @example
+ * ```ts
+ * const [user] = createResource(id, (value) => fetchUser(value))
+ * ```
+ */
+export declare function createResource<S, T>(source: Accessor<S>, fetcher: (source: S, info: {
+    value: T | undefined;
+    refetching: boolean;
+}) => Promise<T> | T, options?: ResourceOptions<T>): [
+    ResourceAccessor<T>,
+    ResourceControls<T>
+];
+/**
+ * Alias for {@link createResource}.
+ *
+ * @example
+ * ```ts
+ * const [user] = resource(() => fetchUser())
+ * ```
+ */
+export declare const resource: typeof createResource;
+/**
+ * Shortcut for `createResource(fetcher)[0]`.
+ *
+ * @param compute Async or sync function that resolves the value.
+ * @param options Optional resource options such as `initialValue`.
+ * @returns Resource accessor only.
+ *
+ * @example
+ * ```ts
+ * const profile = createAsync(() => fetchProfile())
+ * ```
+ */
+export declare function createAsync<T>(compute: () => Promise<T> | T, options?: ResourceOptions<T>): ResourceAccessor<T>;
+/**
+ * Alias for {@link createAsync}.
+ *
+ * @example
+ * ```ts
+ * const profile = asyncSignal(() => fetchProfile())
+ * ```
+ */
+export declare const asyncSignal: typeof createAsync;
+/**
+ * Reads an accessor value or unwraps a promise in Suspense context.
+ *
+ * @param value Accessor or thenable/promise value.
+ * @returns Current accessor value or resolved promise value.
+ *
+ * @example
+ * ```tsx
+ * const value = use(() => count())
+ * const data = use(fetchPromise)
+ * ```
+ */
+export declare function use<T>(value: Accessor<T>): T;
+export declare function use<T>(value: PromiseLike<T>): T;
+/**
+ * Setter for immutable stores.
+ *
+ * @example
+ * ```ts
+ * setStore({ filter: "active" })
+ * setStore((prev) => ({ count: prev.count + 1 }))
+ * ```
+ */
+export type SetStore<T> = (next: T | Partial<T> | ((prev: T) => T | Partial<T>)) => T;
+/**
+ * Creates an immutable reactive object store.
+ *
+ * @param initialValue Initial object state.
+ * @returns Tuple of `[storeProxy, setStore]`.
+ *
+ * @example
+ * ```ts
+ * const [store, setStore] = createStore({ count: 0 })
+ * setStore({ count: 1 })
+ * ```
+ */
+export declare function createStore<T extends object>(initialValue: T): [T, SetStore<T>];
+/**
+ * Alias for {@link createStore}.
+ *
+ * @example
+ * ```ts
+ * const [state, setState] = store({ count: 0 })
+ * ```
+ */
+export declare const store: typeof createStore;
+/**
+ * Typo-friendly alias for {@link createStore}.
+ *
+ * @example
+ * ```ts
+ * const [state, setState] = sotre({ count: 0 })
+ * ```
+ */
+export declare const sotre: typeof createStore;
+/**
+ * Creates a mutable reactive object.
+ *
+ * @param initialValue Initial object state.
+ * @returns Mutable reactive proxy.
+ *
+ * @example
+ * ```ts
+ * const state = createMutable({ count: 0 })
+ * state.count += 1
+ * ```
+ */
+export declare function createMutable<T extends object>(initialValue: T): T;
+/**
+ * Alias for {@link createMutable}.
+ *
+ * @example
+ * ```ts
+ * const state = mutable({ count: 0 })
+ * ```
+ */
+export declare const mutable: typeof createMutable;
+/**
+ * Alias for {@link createMutable}.
+ *
+ * @param initialValue Initial object state.
+ * @returns Mutable reactive proxy.
+ *
+ * @example
+ * ```ts
+ * const state = createMutableStore({ value: 1 })
+ * ```
+ */
+export declare function createMutableStore<T extends object>(initialValue: T): T;
+/**
+ * Creates a mutable reactive array.
+ *
+ * @param initialValue Initial list values.
+ * @returns Mutable reactive array proxy.
+ *
+ * @example
+ * ```ts
+ * const list = createReactiveArray([1, 2])
+ * list.push(3)
+ * ```
+ */
+export declare function createReactiveArray<T>(initialValue?: T[]): T[];
+/**
+ * Alias for {@link createReactiveArray}.
+ *
+ * @param initialValue Initial list values.
+ * @returns Mutable reactive array proxy.
+ *
+ * @example
+ * ```ts
+ * const list = createArrayStore(["a"])
+ * ```
+ */
+export declare function createArrayStore<T>(initialValue?: T[]): T[];
+/**
+ * Options for keyed array projections.
+ *
+ * @example
+ * ```ts
+ * const rows = createArrayProjection(items, {
+ *   key: (item) => item.id,
+ *   map: (item) => ({ ...item }),
+ * })
+ * ```
+ */
+export type ArrayProjectionOptions<SourceItem, ProjectedItem, Key = unknown> = {
+    key?: (item: SourceItem, index: number) => Key;
+    map: (item: SourceItem, index: number) => ProjectedItem;
+    update?: (projected: ProjectedItem, item: SourceItem, index: number) => void;
+};
+/**
+ * Creates a stable projected array with keyed move/insert/remove updates.
+ *
+ * @param source Source list accessor to project from.
+ * @param options Projection behavior (`key`, `map`, optional `update`).
+ * @returns Stable mutable projected array.
+ *
+ * @example
+ * ```ts
+ * const rows = createArrayProjection(users, {
+ *   key: (u) => u.id,
+ *   map: (u) => ({ id: u.id, name: u.name }),
+ *   update: (row, u) => { row.name = u.name },
+ * })
+ * ```
+ */
+export declare function createArrayProjection<SourceItem, ProjectedItem, Key = unknown>(source: Accessor<readonly SourceItem[] | null | undefined>, options: ArrayProjectionOptions<SourceItem, ProjectedItem, Key>): ProjectedItem[];
+/**
+ * Alias for {@link createArrayProjection}.
+ *
+ * @example
+ * ```ts
+ * const rows = arrayProjection(items, { map: (i) => i })
+ * ```
+ */
+export declare const arrayProjection: typeof createArrayProjection;
+/**
+ * Writable derived signal state returned by {@link createLinkedSignal}.
+ *
+ * @example
+ * ```ts
+ * const selected = createLinkedSignal(() => items()[0]?.id ?? null)
+ * selected.set("abc")
+ * ```
+ */
+export type LinkedSignalState<T> = {
+    readonly value: Accessor<T>;
+    readonly set: Setter<T>;
+    readonly reset: () => T;
+    readonly isOverridden: Accessor<boolean>;
+};
+/**
+ * Creates a writable derived signal that resets when derivation inputs change.
+ *
+ * @param derive Function that computes the default value from reactive dependencies.
+ * @returns Linked signal state with `value`, `set`, `reset`, and `isOverridden`.
+ *
+ * @example
+ * ```ts
+ * const selected = createLinkedSignal(() => items()[0]?.id ?? null)
+ * selected.set("custom")
+ * ```
+ */
+export declare function createLinkedSignal<T>(derive: () => T): LinkedSignalState<T>;
+/**
+ * Alias for {@link createLinkedSignal}.
+ *
+ * @example
+ * ```ts
+ * const selected = linkedSignal(() => "default")
+ * ```
+ */
+export declare const linkedSignal: typeof createLinkedSignal;
+type ProjectionMutator<Source, Target> = (target: Target, source: Source, previousSource: Source) => void;
+/**
+ * Creates a mutable projection with a stable reference.
+ *
+ * @param source Source accessor that drives projection updates.
+ * @param initialize Initializes projection state from the first source value.
+ * @param mutate Applies granular updates to the existing projection object.
+ * @returns Stable mutable projection object.
+ *
+ * @example
+ * ```ts
+ * const projection = createProjection(source, (s) => ({ ...s }), (target, next) => {
+ *   Object.assign(target, next)
+ * })
+ * ```
+ */
+export declare function createProjection<Source, Target extends object>(source: Accessor<Source>, initialize: (source: Source) => Target, mutate: ProjectionMutator<Source, Target>): Target;
+/**
+ * Alias for {@link createProjection}.
+ *
+ * @example
+ * ```ts
+ * const state = projection(source, (s) => ({ ...s }), (t, s) => Object.assign(t, s))
+ * ```
+ */
+export declare const projection: typeof createProjection;
+/**
+ * Re-export of `React.Suspense` for API consistency.
+ *
+ * @example
+ * ```tsx
+ * <Suspense fallback={<p>Loading...</p>}><View /></Suspense>
+ * ```
+ */
+export declare const Suspense: React.ExoticComponent<React.SuspenseProps>;
+/**
+ * Wrapper around `React.lazy` that also accepts direct component loaders.
+ *
+ * @param loader Async loader returning either a module with default export or a component.
+ * @returns Lazy React component suitable for Suspense boundaries.
+ *
+ * @example
+ * ```ts
+ * const Settings = lazy(() => import("./Settings"))
+ * ```
+ */
+export declare function lazy<Props>(loader: () => Promise<{
+    default: React.ComponentType<Props>;
+} | React.ComponentType<Props>>): React.LazyExoticComponent<React.ComponentType<Props>>;
+type SetupResult = (() => React.ReactNode) | React.ReactNode;
+type SetupFn<Props> = (props: Accessor<Readonly<Props>>) => SetupResult;
+type SetupFnNoProps = () => SetupResult;
+/**
+ * Options for wrapped `component(...)` React components.
+ *
+ * @example
+ * ```ts
+ * const View = component(setup, { memo: true, displayName: "View" })
+ * ```
+ */
+export type ComponentOptions<Props> = {
+    memo?: boolean | ((prev: Readonly<Props>, next: Readonly<Props>) => boolean);
+    displayName?: string;
+};
+/**
+ * Public component type returned by {@link component}.
+ *
+ * @example
+ * ```ts
+ * const View: SolidComponent<{ id: string }> = component((props) => () => <p>{props().id}</p>)
+ * ```
+ */
+export type SolidComponent<Props> = React.ComponentType<Props>;
+/**
+ * Wraps a setup function so Solid-style primitives can be used without custom hooks.
+ *
+ * @param setup Setup function that runs once per component instance.
+ * @param options Wrapper options (`memo`, `displayName`).
+ * @returns React function component.
+ *
+ * @example
+ * ```tsx
+ * const Counter = component(() => {
+ *   const [count, setCount] = createSignal(0)
+ *   return () => <button onClick={() => setCount((n) => n + 1)}>{count()}</button>
+ * })
+ * ```
+ */
+export declare function component(setup: SetupFnNoProps, options?: ComponentOptions<Record<string, never>>): SolidComponent<Record<string, never>>;
+export declare function component<Props>(setup: SetupFn<Props>, options?: ComponentOptions<Props>): SolidComponent<Props>;
+/**
+ * Alias for {@link component}.
+ *
+ * @example
+ * ```ts
+ * const View = defineComponent(() => <p>Hello</p>)
+ * ```
+ */
+export declare const defineComponent: typeof component;
+/**
+ * Utility union type accepted by control-flow primitives.
+ *
+ * @example
+ * ```ts
+ * const maybe = () => true
+ * const value: MaybeAccessor<boolean> = maybe
+ * ```
+ */
+export type MaybeAccessor<T> = T | Accessor<T>;
+/**
+ * Props for {@link Show}.
+ *
+ * @example
+ * ```tsx
+ * <Show when={user()} fallback={<p>No user</p>}>{(u) => <p>{u.name}</p>}</Show>
+ * ```
+ */
+export type ShowProps<T> = {
+    /** Condition value (or accessor). Truthy renders children, falsy renders fallback. */
+    when: MaybeAccessor<T | null | undefined | false>;
+    /** Content rendered when `when` is falsy. */
+    fallback?: React.ReactNode;
+    /** Reserved compatibility flag for Solid-style signatures. */
+    keyed?: boolean;
+    /** Render content or render function receiving narrowed truthy value. */
+    children: React.ReactNode | ((value: NonNullable<T>) => React.ReactNode);
+};
+/**
+ * Conditionally renders content when `when` is truthy.
+ *
+ * @param props Show control-flow props.
+ * @returns Matching branch or fallback.
+ *
+ * @example
+ * ```tsx
+ * <Show when={ready()} fallback={<p>Loading</p>}><p>Ready</p></Show>
+ * ```
+ */
+export declare function Show<T>(props: ShowProps<T>): React.ReactNode;
+/**
+ * Props for {@link For}.
+ *
+ * @example
+ * ```tsx
+ * <For each={items()}>{(item) => <li>{item.name}</li>}</For>
+ * ```
+ */
+export type ForProps<T> = {
+    /** Source list (or accessor) to iterate. */
+    each: MaybeAccessor<readonly T[] | null | undefined>;
+    /** Rendered when list is empty. */
+    fallback?: React.ReactNode;
+    /** Item renderer with stable index accessor. */
+    children: (item: T, index: Accessor<number>) => React.ReactNode;
+};
+/**
+ * Renders each item in a list.
+ *
+ * @param props For control-flow props.
+ * @returns Rendered list or fallback.
+ *
+ * @example
+ * ```tsx
+ * <For each={todos()} fallback={<p>Empty</p>}>{(todo) => <p>{todo.title}</p>}</For>
+ * ```
+ */
+export declare function For<T>(props: ForProps<T>): React.ReactNode;
+/**
+ * Props for {@link Index}.
+ *
+ * @example
+ * ```tsx
+ * <Index each={items()}>{(item) => <li>{item().name}</li>}</Index>
+ * ```
+ */
+export type IndexProps<T> = {
+    /** Source list (or accessor) to iterate. */
+    each: MaybeAccessor<readonly T[] | null | undefined>;
+    /** Rendered when list is empty. */
+    fallback?: React.ReactNode;
+    /** Item renderer with accessor per item and index accessor. */
+    children: (item: Accessor<T>, index: Accessor<number>) => React.ReactNode;
+};
+/**
+ * Renders a list where each child receives an item accessor.
+ *
+ * @param props Index control-flow props.
+ * @returns Rendered list or fallback.
+ *
+ * @example
+ * ```tsx
+ * <Index each={rows()}>{(row) => <Row data={row()} />}</Index>
+ * ```
+ */
+export declare function Index<T>(props: IndexProps<T>): React.ReactNode;
+/**
+ * Props for {@link Match} used inside {@link Switch}.
+ *
+ * @example
+ * ```tsx
+ * <Match when={status() === "ready"}><Ready /></Match>
+ * ```
+ */
+export type MatchProps<T> = {
+    /** Match condition (or accessor). First truthy Match is selected by Switch. */
+    when: MaybeAccessor<T | null | undefined | false>;
+    /** Render content or render function receiving narrowed truthy match value. */
+    children: React.ReactNode | ((value: NonNullable<T>) => React.ReactNode);
+};
+/**
+ * Switch branch marker consumed by {@link Switch}.
+ *
+ * @param _props Match branch props consumed by `Switch`.
+ * @returns `null` when rendered standalone.
+ *
+ * @example
+ * ```tsx
+ * <Switch><Match when={ok()}>OK</Match></Switch>
+ * ```
+ */
+export declare function Match<T>(_props: MatchProps<T>): React.ReactElement | null;
+/**
+ * Props for {@link Switch}.
+ *
+ * @example
+ * ```tsx
+ * <Switch fallback={<p>Unknown</p>}>...</Switch>
+ * ```
+ */
+export type SwitchProps = {
+    /** Content rendered when no Match branch is truthy. */
+    fallback?: React.ReactNode;
+    /** Match branches (typically Match components). */
+    children?: React.ReactNode;
+};
+/**
+ * Type guard for accessors.
+ *
+ * @param value Value to check.
+ * @returns `true` when value is an accessor function.
+ *
+ * @example
+ * ```ts
+ * if (isAccessor(value)) {
+ *   console.log(value())
+ * }
+ * ```
+ */
+export declare function isAccessor<T = unknown>(value: unknown): value is Accessor<T>;
+/**
+ * Resolves plain values or accessors into a value.
+ *
+ * @param value Plain value or accessor.
+ * @returns Resolved value.
+ *
+ * @example
+ * ```ts
+ * const enabled = resolveMaybeAccessor(props.enabled)
+ * ```
+ */
+export declare function resolveMaybeAccessor<T>(value: MaybeAccessor<T>): T;
+/**
+ * Alias for {@link resolveMaybeAccessor}.
+ */
+export declare const toValue: typeof resolveMaybeAccessor;
+/**
+ * Creates a keyed selector helper for efficient equality checks.
+ *
+ * @param source Source accessor containing the selected value.
+ * @param equals Optional comparison function. Defaults to `Object.is`.
+ * @returns Function that compares keys to the current source value.
+ *
+ * @example
+ * ```ts
+ * const isSelected = createSelector(selectedId)
+ * const active = isSelected(row.id)
+ * ```
+ */
+export declare function createSelector<T>(source: Accessor<T>, equals?: (left: T, right: T) => boolean): (key: T) => boolean;
+/**
+ * Renders the first truthy {@link Match}, else `fallback`.
+ *
+ * @param props Switch control-flow props.
+ * @returns First matched branch or fallback.
+ *
+ * @example
+ * ```tsx
+ * <Switch fallback={<p>idle</p>}><Match when={loading()}>loading</Match></Switch>
+ * ```
+ */
+export declare function Switch(props: SwitchProps): React.ReactNode;
+export {};
+//# sourceMappingURL=index.d.ts.map