ctrl-fx 0.0.1 → 0.1.1

package/dist/index-fpCmXVEu.d.ts

@@ -0,0 +1,1391 @@
+import { DbName, DbVersion, DbSetupEffect, ObjectStore, DbEffect, DbError } from './db/index.js';
+
+type NodeId = {
+    _tag: 'node_id';
+    value: string;
+    eq(that: NodeId): boolean;
+};
+declare function nodeId(value: string): NodeId;
+
+/** A virtual DOM attribute: a name/value pair set on the real DOM element via
+ * `setAttribute`. */
+interface Attr {
+    readonly name: string;
+    readonly value?: string;
+}
+/** Creates an `Attr`. */
+declare function attr(name: string, value: string): Attr;
+/** A JavaScript property set directly on the DOM element object, as opposed to
+ * an HTML attribute. */
+interface Prop {
+    readonly name: string;
+    readonly value: unknown;
+}
+/** Creates a `Prop`. */
+declare function prop(name: string, value: unknown): Prop;
+type AttrArg = Attr | [string, string] | string;
+type AttrOrNodeIdArgs = [NodeId, ...AttrArg[]] | [...AttrArg[]];
+/** Shorthand for `attr('id', value)`. */
+declare function id(value: string): Attr;
+/** Shorthand for `attr('type', value)`. */
+declare function typeAttr(value: string): Attr;
+/** Converts a map of CSS custom property names to values into a `style`
+ * attribute. */
+declare function cssVars(vars: Record<string, string>): Attr;
+
+/** The success variant of a Result. */
+type Success<A, E> = {
+    _tag: 'success';
+    value: A;
+    /** Transforms the success value, leaving failure unchanged. */
+    map<B>(f: (a: A) => B): Result<B, E>;
+    /** Chains a function that can fail, short-circuiting on existing failure. */
+    andThen<B, EE>(f: (a: A) => Result<B, EE>): Result<B, E | EE>;
+    /** Transforms the error value, leaving success unchanged. */
+    errorMap<EE>(f: (e: E) => EE): Result<A, EE>;
+    /** Returns either the success value or the error value. */
+    merge(): A | E;
+    /** Recovers from failure by applying `f` to the error. */
+    recover<AA, EE>(f: (e: E) => Result<AA, EE>): Result<A | AA, E | EE>;
+    /** Applies `onSuccess` or `onError` and returns a single value. */
+    fold<T>(onSuccess: (a: A) => T, onError: (e: E) => T): T;
+};
+/** The failure variant of a Result. */
+type Failure<A, E> = {
+    _tag: 'failure';
+    error: E;
+    /** Transforms the success value, leaving failure unchanged. */
+    map<B>(f: (a: A) => B): Result<B, E>;
+    /** Chains a function that can fail, short-circuiting on existing failure. */
+    andThen<B, EE>(f: (a: A) => Result<B, EE>): Result<B, E | EE>;
+    /** Transforms the error value, leaving success unchanged. */
+    errorMap<EE>(f: (e: E) => EE): Result<A, EE>;
+    /** Returns either the success value or the error value. */
+    merge(): A | E;
+    /** Recovers from failure by applying `f` to the error. */
+    recover<AA, EE>(f: (e: E) => Result<AA, EE>): Result<A | AA, E | EE>;
+    /** Applies `onSuccess` or `onError` and returns a single value. */
+    fold<T>(onSuccess: (a: A) => T, onError: (e: E) => T): T;
+};
+/** A value that is either a success (`A`) or a failure (`E`). */
+type Result<A, E> = Success<A, E> | Failure<A, E>;
+
+type Method = 'GET' | 'POST' | 'DELETE' | 'PUT' | 'HEAD' | 'OPTIONS';
+type HttpRequest = {
+    readonly uri: string;
+    readonly method: Method;
+    readonly headers: Headers;
+    readonly body?: string;
+};
+type Headers = {
+    [key: string]: string;
+};
+type HttpResponse = {
+    readonly headers: Headers;
+    readonly body: ResponseBody;
+};
+type HttpError = {
+    _type: 'HttpError';
+};
+type RequestError = {
+    _type: 'RequestError';
+    cause: 'RequestAborted' | 'NetworkFailure' | 'UnexpectedError';
+    message: string;
+};
+type DecodingError = {
+    _type: 'DecodingError';
+    message: string;
+};
+declare class Json {
+    private wrapped;
+    constructor(wrapped: any);
+    decodeUnsafe<A>(): A;
+}
+declare class ResponseBody {
+    private data;
+    constructor(data: ArrayBuffer);
+    asString(): string;
+    asBlob(): Blob;
+    asJson(): Result<Json, DecodingError>;
+}
+
+type ClipboardError = {
+    _type: 'ClipboardError';
+    cause: 'NotAllowed' | 'NotSupported' | 'UnexpectedError';
+    message: string;
+};
+
+type ScrollElementError = {
+    _type: 'ScrollElementError';
+    cause: 'ElementNotFound';
+    selector: string;
+};
+
+type Path$1 = {
+    readonly elems: readonly string[];
+    format(): string;
+    matches(that: Path$1): boolean;
+};
+
+interface QueryParam {
+    name: string;
+    value?: string;
+    format: string;
+}
+
+interface Fragment {
+    path: Path$1;
+    queryParams: QueryParam[];
+    format: string;
+}
+
+interface InternalLocation {
+    readonly path: Path$1;
+    readonly queryParams: readonly QueryParam[];
+    readonly fragment?: Fragment;
+}
+
+/** A pair of get/set functions that focus on a field `A` within a structure `S`. */
+type Lens<S, A> = {
+    /** Reads the focused field from `S`. */
+    get: (source: S) => A;
+    /** Returns a new `S` with the focused field replaced. */
+    set: (source: S, value: A) => S;
+};
+
+/** Current value and cursor position of a text input, passed to `onTextInput` handlers. */
+type TextState = {
+    value: string;
+    selectionStart: number | null;
+    selectionEnd: number | null;
+};
+type TextInputListener<State, Event> = {
+    _type: 'textinput';
+    effect: (textState: TextState) => Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+/** Key name and code from a keyboard event, passed to `onKeyDown`/`onKeyUp` handlers. */
+type KeyData = {
+    key: string;
+    code: string;
+};
+type KeyDownListener<State, Event> = {
+    _type: 'keydown';
+    effect: (key: KeyData) => Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+type KeyUpListener<State, Event> = {
+    _type: 'keyup';
+    effect: (key: KeyData) => Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+/** Touch-point coordinates from a touch event, passed to `onTouchStart`/`onTouchMove`/`onTouchEnd` handlers. */
+type TouchData = {
+    clientX: number;
+    clientY: number;
+    pageX: number;
+    pageY: number;
+};
+type TouchStartListener<State, Event> = {
+    _type: 'touchstart';
+    effect: (touches: readonly TouchData[]) => Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+type TouchMoveListener<State, Event> = {
+    _type: 'touchmove';
+    effect: (touches: readonly TouchData[]) => Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+type TouchCancelListener<State, Event> = {
+    _type: 'touchcancel';
+    effect: (touches: readonly TouchData[]) => Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+type TouchEndListener<State, Event> = {
+    _type: 'touchend';
+    effect: (touches: readonly TouchData[]) => Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+/** Options forwarded to `addEventListener`. */
+type EventOptions = {
+    capture?: boolean;
+    passive?: boolean;
+};
+/** Browser event modifiers an event handler can request. Return from a handler to call `preventDefault` or `stopPropagation`. */
+type EventActions = {
+    stopPropagation?: boolean;
+    preventDefault?: boolean;
+};
+/** Return type of event handlers: `void` or an `EventActions` object to modify browser behavior. */
+type EventListenerResult = void | EventActions;
+type BlurListener<State, Event> = {
+    _type: 'blur';
+    effect: Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+/** Current value and checked state of a form element, passed to `onChange` handlers. */
+type ChangeData = {
+    value: string;
+    checked: boolean;
+};
+type ChangeListener<State, Event> = {
+    _type: 'change';
+    effect: (data: ChangeData) => Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+type ClickListener<State, Event> = {
+    _type: 'click';
+    effect: Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+type DblClickListener<State, Event> = {
+    _type: 'dblclick';
+    effect: Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+/** Mouse position and movement delta, passed to `onMouseMove` handlers. */
+type MouseMoveData = {
+    clientX: number;
+    clientY: number;
+    pageX: number;
+    pageY: number;
+    movementX: number;
+    movementY: number;
+};
+type MouseMoveListener<State, Event> = {
+    _type: 'mousemove';
+    effect: (data: MouseMoveData) => Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+/** Scroll deltas from a wheel event, passed to `onWheel` handlers. */
+type WheelData = {
+    deltaX: number;
+    deltaY: number;
+    deltaZ: number;
+    deltaMode: number;
+};
+type WheelListener<State, Event> = {
+    _type: 'wheel';
+    effect: (data: WheelData) => Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+type FocusListener<State, Event> = {
+    _type: 'focus';
+    effect: Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+type MouseEnterListener<State, Event> = {
+    _type: 'mouseenter';
+    effect: Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+type MouseLeaveListener<State, Event> = {
+    _type: 'mouseleave';
+    effect: Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+/** Scroll offset of the element, passed to `onScroll`/`onScrollEnd` handlers. */
+type ScrollData = {
+    scrollTop: number;
+    scrollLeft: number;
+};
+type ScrollListener<State, Event> = {
+    _type: 'scroll';
+    effect: (data: ScrollData) => Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+type ScrollEndListener<State, Event> = {
+    _type: 'scrollend';
+    effect: (data: ScrollData) => Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+type SubmitListener<State, Event> = {
+    _type: 'submit';
+    effect: Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+type CustomEventListener<State, Event> = {
+    _type: 'custom';
+    eventName: string;
+    effect: (detail: unknown) => Effect<State, Event, EventListenerResult>;
+    options: EventOptions;
+};
+type EventListener<State, Event> = BlurListener<State, Event> | ChangeListener<State, Event> | ClickListener<State, Event> | CustomEventListener<State, Event> | SubmitListener<State, Event> | DblClickListener<State, Event> | FocusListener<State, Event> | KeyDownListener<State, Event> | KeyUpListener<State, Event> | MouseEnterListener<State, Event> | MouseLeaveListener<State, Event> | MouseMoveListener<State, Event> | ScrollListener<State, Event> | ScrollEndListener<State, Event> | TextInputListener<State, Event> | TouchCancelListener<State, Event> | TouchEndListener<State, Event> | TouchMoveListener<State, Event> | TouchStartListener<State, Event> | WheelListener<State, Event>;
+/** Wraps `effect` and instructs the runtime to call `event.preventDefault()` after it runs. */
+declare function preventDefault<State, Event>(effect: Effect<State, Event, void>): Effect<State, Event, EventActions>;
+/** Wraps `effect` and instructs the runtime to call `event.stopPropagation()` after it runs. */
+declare function stopPropagation<State, Event>(effect: Effect<State, Event, void>): Effect<State, Event, EventActions>;
+/** Wraps `effect` and instructs the runtime to call both `event.stopPropagation()` and `event.preventDefault()`. */
+declare function stopPropagationAndPreventDefault<State, Event>(effect: Effect<State, Event, void>): Effect<State, Event, EventActions>;
+type ResizeListener<State, Event> = {
+    _type: 'resize';
+    onChange: (dimensions: Dimensions) => Effect<State, Event, void>;
+    options: EventOptions;
+};
+type PopStateListener<State, Event> = {
+    _type: 'popstate';
+    onChange: (location: InternalLocation) => Effect<State, Event, void>;
+    options: EventOptions;
+};
+type LocationChangeListener<State, Event> = {
+    _type: 'locationchange';
+    onChange: (location: InternalLocation) => Effect<State, Event, void>;
+    options: EventOptions;
+};
+type VisibilityChangeListener<State, Event> = {
+    _type: 'visibilitychange';
+    onChange: (state: 'visible' | 'hidden') => Effect<State, Event, void>;
+    options: EventOptions;
+};
+type OnlineListener<State, Event> = {
+    _type: 'online';
+    effect: Effect<State, Event, void>;
+    options: EventOptions;
+};
+type OfflineListener<State, Event> = {
+    _type: 'offline';
+    effect: Effect<State, Event, void>;
+    options: EventOptions;
+};
+type ContainerListener<State, Event> = ResizeListener<State, Event> | PopStateListener<State, Event> | LocationChangeListener<State, Event> | KeyDownListener<State, Event> | KeyUpListener<State, Event> | VisibilityChangeListener<State, Event> | OnlineListener<State, Event> | OfflineListener<State, Event>;
+
+/**
+ * The return type of a view function: a list of virtual DOM nodes plus optional
+ * container-level event listeners. Create one with `nodeGroup(...)` or the `_` shorthand.
+ */
+type NodeGroup<State, Event> = {
+    _type: 'NodeGroup';
+    nodes: Node<State, Event>[];
+    containerListeners: ContainerListener<State, Event>[];
+    /** Runs `effect` whenever the component's container is resized, receiving the new dimensions. */
+    onResize(effect: (dimensions: Dimensions) => Effect<State, Event, void>): NodeGroup<State, Event>;
+    /** Runs `effect` when the browser back/forward buttons are used. */
+    onPopState(effect: (location: InternalLocation) => Effect<State, Event, void>): NodeGroup<State, Event>;
+    /** Runs `effect` on any location change, including `pushState` and `replaceState` as well as `popstate`. */
+    onLocationChange(effect: (location: InternalLocation) => Effect<State, Event, void>): NodeGroup<State, Event>;
+    /** Runs `effect` on document-level keyup events. */
+    onKeyUp(effect: (key: KeyData) => Effect<State, Event, EventListenerResult>, options?: EventOptions): NodeGroup<State, Event>;
+    /** Runs `effect` on document-level keydown events. */
+    onKeyDown(effect: (key: KeyData) => Effect<State, Event, EventListenerResult>, options?: EventOptions): NodeGroup<State, Event>;
+    /** Runs `effect` when the page becomes visible or hidden (e.g. user switches tabs). */
+    onVisibilityChange(effect: (state: 'visible' | 'hidden') => Effect<State, Event, void>): NodeGroup<State, Event>;
+    /** Runs `effect` when the browser comes online. */
+    onOnline(effect: Effect<State, Event, void>): NodeGroup<State, Event>;
+    /** Runs `effect` when the browser goes offline. */
+    onOffline(effect: Effect<State, Event, void>): NodeGroup<State, Event>;
+    renderEffects: Effect<State, Event, void>[];
+    /** Runs `effects` once immediately after the component mounts. Use this for initial data loading or setup that requires the DOM to exist. */
+    onRender(...effects: Effect<State, Event, void>[]): NodeGroup<State, Event>;
+};
+/** A memoized subtree node produced by `view` or `fixedView`. */
+type View<State, Params, Event> = {
+    _type: 'View';
+    nodeId: NodeId;
+    params: Params;
+    nodes: (params: Params) => NodeGroup<State, Event>;
+};
+
+/** A self-contained UI unit with its own state, view, and optional scoped CSS. */
+type Component<State, Params, Event> = {
+    readonly _type: 'Component';
+    readonly params: Params;
+    readonly css?: string | ((params: Params) => string);
+    readonly initialState: (params: Params) => Effect<State, Event, State>;
+    view(state: State, params: Params): NodeGroup<State, Event>;
+};
+type ComponentEventListener<State, Event, ComponentEvent> = (event: ComponentEvent) => Effect<State, Event, void>;
+/** A mounted instance of a Component inside a parent view. */
+type ComponentElement<State, Event, ComponentState, Params, ComponentEvent> = {
+    readonly _type: 'Component';
+    readonly nodeId: NodeId;
+    readonly component: Component<ComponentState, Params, ComponentEvent>;
+    readonly componentEventListeners: readonly ComponentEventListener<State, Event, ComponentEvent>[];
+    /** Registers a listener for events fired by the component. */
+    onEvent(eventListener: ComponentEventListener<State, Event, ComponentEvent>): ComponentElement<State, Event, ComponentState, Params, ComponentEvent>;
+};
+/**
+ * Creates a `Component` — a self-contained UI unit with its own managed state.
+ *
+ * The simple overload `component(view, initialState, css?)` is for components
+ * that do not accept external configuration. The params overload
+ * `component(view, initialStateFactory, params, css?)` is for components that
+ * accept a `Params` value from their parent, which is passed to both `view` and
+ * the initial-state factory on mount.
+ *
+ * The runtime calls `view(state, params)` whenever state changes and diffs the
+ * result against the previous virtual DOM to update the browser.
+ *
+ * @param css Optional scoped CSS string (or a function of params returning one)
+ *   that is injected into a `<style>` element inside the component's shadow root.
+ */
+declare function component<State, Event>(view: (state: State) => Node<State, Event> | NodeGroup<State, Event>, initialState: State | Effect<State, Event, State>, css?: string): Component<State, void, Event>;
+declare function component<State, Params, Event>(view: (state: State, params: Params) => Node<State, Event> | NodeGroup<State, Event>, initialState: (params: Params) => State | Effect<State, Event, State>, params: Params, css?: string | ((params: Params) => string)): Component<State, Params, Event>;
+
+/** Type guard that returns true when `effectOrState` is a plain state value rather than an `Effect`. */
+declare function isState<State>(effectOrState: Effect<State, never, State> | State): effectOrState is State;
+/** Converts a plain view function and initial state into a `Component`. Used internally by `manageApplication`; prefer `component()` from `ctrl-fx/dom` in application code. */
+declare function toComponent<State>(app: (state: State) => Node<State, never> | NodeGroup<State, never>, initialState: State | Effect<State, never, State>): Component<State, void, never>;
+/**
+ * Mounts a ctrl-fx application into the DOM element with id `mountId` and starts the runtime.
+ * Returns a `dispatchEffect` handle for triggering effects from outside the framework
+ * (e.g. from a service worker message).
+ * @param mountId The id of the mount element. Defaults to `'app'`.
+ */
+declare function manageApplication<State>(app: (state: State) => Node<State, never> | NodeGroup<State, never>, initialState: State | Effect<State, never, State>, mountId?: string): {
+    dispatchEffect: (effect: Effect<State, never, void>) => void;
+};
+/** Width and height in pixels, as reported by a resize observer. */
+type Dimensions = {
+    width: number;
+    height: number;
+};
+/** The browser permission state for a feature such as notifications. */
+interface Permission {
+    value: 'default' | 'granted' | 'denied';
+    /** Returns true when the permission has been explicitly granted. */
+    isGranted(): boolean;
+    /** Returns true when the user has not yet been prompted. */
+    isDefault(): boolean;
+    /** Returns true when the permission has been explicitly denied. */
+    isDenied(): boolean;
+}
+/** Constructs a `Permission` value from a raw browser permission string. */
+declare function permission(value: 'default' | 'granted' | 'denied'): Permission;
+/** A branded string containing a UUID v4. */
+type Uuid = string & {
+    __brand: 'Uuid';
+};
+/** Deterministically derives a UUID-shaped string from `input` by hashing it. Useful for generating stable node identifiers from content. */
+declare function uuidFromString(input: string): Uuid;
+
+type Alert = {
+    _type: 'Alert';
+    input: any;
+};
+type Async<State, Event> = {
+    _type: 'Async';
+    input: {
+        effect: Effect<State, Event, void>;
+        delayInMillis: number;
+    };
+};
+type CancelTask = {
+    _type: 'CancelTask';
+    input: TaskId;
+};
+type ClearAppBadge = {
+    _type: 'ClearAppBadge';
+    input: void;
+};
+type ReadClipboard = {
+    _type: 'ReadClipboard';
+    input: void;
+};
+type WriteClipboard = {
+    _type: 'WriteClipboard';
+    input: string;
+};
+type SetAppBadge = {
+    _type: 'SetAppBadge';
+    input: number;
+};
+type SetDocumentTitle = {
+    _type: 'SetDocumentTitle';
+    input: string;
+};
+type Confirm = {
+    _type: 'Confirm';
+    input: string;
+};
+type FireEvent<Event> = {
+    _type: 'FireEvent';
+    input: Event;
+};
+type GenerateUuid = {
+    _type: 'GenerateUuid';
+    input: void;
+};
+type GetNotificationPermission = {
+    _type: 'GetNotificationPermission';
+    input: void;
+};
+type RequestNotificationPermission = {
+    _type: 'RequestNotificationPermission';
+    input: void;
+};
+type GetLocation = {
+    _type: 'GetLocation';
+    input: void;
+};
+type GetState = {
+    _type: 'GetState';
+    input: void;
+};
+type GetTime = {
+    _type: 'GetTime';
+    input: void;
+};
+type GetRandom = {
+    _type: 'GetRandom';
+    input: void;
+};
+type Prompt = {
+    _type: 'Prompt';
+    input: {
+        message: string;
+        default: string | undefined;
+    };
+};
+type Log = {
+    _type: 'Log';
+    input: any;
+};
+type MakeHttpRequest = {
+    _type: 'MakeHttpRequest';
+    input: HttpRequest;
+};
+type OpenDatabase = {
+    _type: 'OpenDatabase';
+    input: {
+        db: DbName;
+        version: DbVersion;
+        setup: (oldVersion: DbVersion) => DbSetupEffect<void>;
+    };
+};
+type RunDbTransaction = {
+    _type: 'RunDbTransaction';
+    input: {
+        db: DbName;
+        objectStores: readonly ObjectStore[];
+        mode: 'readonly' | 'readwrite';
+        effect: DbEffect<void>;
+    };
+};
+type Product<State, Event, A, B> = {
+    _type: 'Product';
+    input: [Effect<State, Event, A>, Effect<State, Event, B>];
+};
+/** A branded string that uniquely identifies a scheduled task. */
+type TaskId = string & {
+    __brand: 'TaskId';
+};
+/** Creates a typed TaskId from a plain string. */
+declare function taskId(id: string): TaskId;
+type ScheduleTask<State, Event> = {
+    _type: 'ScheduleTask';
+    input: {
+        task: Effect<State, Event, void>;
+        initialDelayInMillis: number;
+        repeatIntervalInMillis: number | undefined;
+        taskId: TaskId | undefined;
+    };
+};
+type SetTimeout = {
+    _type: 'SetTimeout';
+    input: number;
+};
+type UpdateState<State> = {
+    _type: 'UpdateState';
+    input: (state: State) => State;
+};
+type StorageTarget = 'local' | 'session';
+type GetStorageItem = {
+    _type: 'GetStorageItem';
+    input: {
+        storage: StorageTarget;
+        key: string;
+    };
+};
+type Go = {
+    _type: 'Go';
+    input: number;
+};
+type PushState = {
+    _type: 'PushState';
+    input: InternalLocation;
+};
+type ReplaceState = {
+    _type: 'ReplaceState';
+    input: InternalLocation;
+};
+type SetStorageItem = {
+    _type: 'SetStorageItem';
+    input: {
+        storage: StorageTarget;
+        key: string;
+        value: string;
+    };
+};
+type RemoveStorageItem = {
+    _type: 'RemoveStorageItem';
+    input: {
+        storage: StorageTarget;
+        key: string;
+    };
+};
+type ClearStorage = {
+    _type: 'ClearStorage';
+    input: {
+        storage: StorageTarget;
+    };
+};
+type ScrollOptions = {
+    top?: number;
+    left?: number;
+    behavior?: 'smooth' | 'instant' | 'auto';
+};
+type ScrollWindow = {
+    _type: 'ScrollWindow';
+    input: ScrollOptions;
+};
+type ScrollElement = {
+    _type: 'ScrollElement';
+    input: {
+        selector: string;
+        options: ScrollOptions;
+    };
+};
+type DownloadInput = {
+    filename: string;
+    content: string;
+    contentType: string;
+};
+type Download = {
+    _type: 'Download';
+    input: DownloadInput;
+};
+type PostBroadcastMessage = {
+    _type: 'PostBroadcastMessage';
+    input: {
+        channel: string;
+        message: unknown;
+    };
+};
+type SubscribeToBroadcastChannel<State, Event> = {
+    _type: 'SubscribeToBroadcastChannel';
+    input: {
+        channel: string;
+        handler: (message: unknown) => Effect<State, Event, void>;
+        taskId: TaskId | undefined;
+    };
+};
+type CustomEffect<In, Out, Custom> = {
+    _type: 'CustomEffect';
+    input: {
+        args: In;
+        f: (args: In) => Out | Promise<Out>;
+        test: (args: In, data: Custom) => {
+            out: Out;
+            data: Custom;
+        };
+    };
+};
+/**
+ * Creates a factory for effects that call an external library function.
+ * Use this when you want to call a library whose logic would be too cumbersome
+ * to reimplement using built-in effects. In production `f` is called directly.
+ * In tests the `test` callback receives the arguments and a queue of scripted
+ * return values (`data`), and must return `{ out, data }` where `data` is the
+ * remaining queue after consuming one entry.
+ *
+ * @param f Production implementation. May return a Promise.
+ * @param test Test-time implementation. Receives the scripted data queue and
+ *   returns `{ out, data }` — `out` is the value to return, `data` is the
+ *   remaining queue. Provide scripted values via `newTestData(queue)`.
+ */
+declare function customEffect<State, Event, In, Out, Custom>(f: (args: In) => Out | Promise<Out>, test: (args: In, data: Custom) => {
+    out: Out;
+    data: Custom;
+}): (args: In) => Effect<State, Event, Out>;
+type Operation<State, Event> = Alert | Async<State, Event> | CancelTask | ClearAppBadge | ClearStorage | Confirm | CustomEffect<unknown, unknown, unknown> | Download | FireEvent<Event> | GetLocation | GetNotificationPermission | RequestNotificationPermission | PostBroadcastMessage | ReadClipboard | WriteClipboard | GenerateUuid | GetState | GetStorageItem | GetTime | GetRandom | Log | MakeHttpRequest | Go | OpenDatabase | Product<State, Event, unknown, unknown> | Prompt | PushState | ReplaceState | RemoveStorageItem | RunDbTransaction | ScheduleTask<State, Event> | ScrollElement | ScrollWindow | SetAppBadge | SetDocumentTitle | SetStorageItem | SetTimeout | SubscribeToBroadcastChannel<State, Event> | UpdateState<State>;
+type Suspend<State, Event, A> = {
+    _type: 'Suspend';
+    operation: Operation<State, Event>;
+    /**
+     * Sequences this effect with another, passing its result to `f` to produce
+     * the next effect. Use this when the second effect depends on the value
+     * produced by the first. For independent sequencing use `and`.
+     */
+    flatMap<B>(f: (a: A) => Effect<State, Event, B>): Effect<State, Event, B>;
+    /**
+     * Sequences this effect and `effect`, discarding this effect's result. Use
+     * this when you want both effects to run but the first result is not needed.
+     * For result-dependent sequencing use `flatMap`.
+     */
+    and<B>(effect: Effect<State, Event, B>): Effect<State, Event, B>;
+    /** Transforms the result of this effect with `f`, without performing any additional effects. */
+    map<B>(f: (a: A) => B): Effect<State, Event, B>;
+    /** Replaces the result of this effect with `b`, discarding the original result. */
+    as<B>(b: B): Effect<State, Event, B>;
+    /** Discards the result, producing `Effect<State, Event, void>`. */
+    void(): Effect<State, Event, void>;
+    /** Passes this effect to `f` and returns the result. Useful for applying a function that takes an effect without breaking a method chain. */
+    apply<B>(f: (effect: Effect<State, Event, A>) => B): B;
+};
+type Return<State, Event, A> = {
+    _type: 'Return';
+    value: A;
+    /** @inheritDoc Suspend.flatMap */
+    flatMap<B>(f: (a: A) => Effect<State, Event, B>): Effect<State, Event, B>;
+    /** @inheritDoc Suspend.and */
+    and<B>(effect: Effect<State, Event, B>): Effect<State, Event, B>;
+    /** @inheritDoc Suspend.map */
+    map<B>(f: (a: A) => B): Effect<State, Event, B>;
+    /** @inheritDoc Suspend.as */
+    as<B>(b: B): Effect<State, Event, B>;
+    /** @inheritDoc Suspend.void */
+    void(): Effect<State, Event, void>;
+    /** @inheritDoc Suspend.apply */
+    apply<B>(f: (effect: Effect<State, Event, A>) => B): B;
+};
+type FlatMap<State, Event, A, B> = {
+    _type: 'FlatMap';
+    effect: Effect<State, Event, A>;
+    next: (a: A) => Effect<State, Event, B>;
+    /** @inheritDoc Suspend.flatMap */
+    flatMap<C>(f: (b: B) => Effect<State, Event, C>): Effect<State, Event, C>;
+    /** @inheritDoc Suspend.and */
+    and<C>(effect: Effect<State, Event, C>): Effect<State, Event, C>;
+    /** @inheritDoc Suspend.map */
+    map<C>(f: (b: B) => C): Effect<State, Event, C>;
+    /** @inheritDoc Suspend.as */
+    as<C>(c: C): Effect<State, Event, C>;
+    /** @inheritDoc Suspend.void */
+    void(): Effect<State, Event, void>;
+    /** @inheritDoc Suspend.apply */
+    apply<C>(f: (effect: Effect<State, Event, B>) => C): C;
+};
+/**
+ * A lazy, pure description of a side effect to be performed by the framework.
+ * An Effect is just a data structure — it does nothing until the framework
+ * interprets it. This means effects can be composed, transformed, and tested
+ * without executing any real side effects.
+ *
+ * `State` is the application state type the effect can read and update.
+ * `Event` is the component event type the effect can fire.
+ * `A` is the value the effect produces when it completes.
+ */
+type Effect<State, Event, A> = Suspend<State, Event, A> | Return<State, Event, A> | FlatMap<State, Event, any, A>;
+/**
+ * Wraps a plain value in an Effect that completes immediately without performing any operations.
+ * Useful as a base case when building effects conditionally, or to lift a
+ * computed value into the Effect chain.
+ */
+declare function pure<State, Event, A>(value: A): Effect<State, Event, A>;
+/** An effect describing a browser alert dialog. */
+declare function alert<State, Event>(message: any): Effect<State, Event, void>;
+/**
+ * An effect describing a browser confirm dialog.
+ * @returns true if confirmed
+ */
+declare function confirm<State, Event>(message: string): Effect<State, Event, boolean>;
+/**
+ * An effect describing a browser prompt dialog.
+ * @returns the entered string, or null if cancelled
+ */
+declare function prompt<State, Event>(message: string, defaultValue?: string): Effect<State, Event, string | null>;
+/** An effect describing a clear of the app badge on the browser/OS icon. */
+declare function clearAppBadge<State, Event>(): Effect<State, Event, void>;
+/** An effect describing a clipboard text read. */
+declare function readClipboard<State, Event>(): Effect<State, Event, Result<string, ClipboardError>>;
+/** An effect describing a clipboard write of `text`. */
+declare function writeClipboard<State, Event>(text: string): Effect<State, Event, Result<void, ClipboardError>>;
+/** An effect describing a `document.title` update. */
+declare function setDocumentTitle<State, Event>(title: string): Effect<State, Event, void>;
+/** An effect describing an app badge count update on the browser/OS icon. */
+declare function setAppBadge<State, Event>(count: number): Effect<State, Event, void>;
+/**
+ * An effect describing fire-and-forget async dispatch of `effect`.
+ * The chain continues without waiting for `effect` to complete.
+ * Use `scheduleTask` instead if you need cancellation or debounce/repeat behaviour.
+ */
+declare function async<State, Event>(effect: Effect<State, Event, void>, delayInMillis?: number): Effect<State, Event, void>;
+/** An effect describing the cancellation of a previously scheduled task. */
+declare function cancelTask<State, Event>(taskId: TaskId): Effect<State, Event, void>;
+/**
+ * An effect describing a typed component event to be delivered to any `onEvent` listener
+ * registered by the parent that mounted this component. Has no effect when
+ * used in a top-level application (which has no parent).
+ */
+declare function fireEvent<State, Event>(event: Event): Effect<State, Event, void>;
+/** An effect describing a UUID v4 generation. */
+declare function generateUuid<State, Event>(): Effect<State, Event, Uuid>;
+/** An effect describing a read of the current time. */
+declare function getTime<State, Event>(): Effect<State, Event, Date>;
+/** An effect describing a random number in [0, 1), equivalent to Math.random(). */
+declare function getRandom<State, Event>(): Effect<State, Event, number>;
+/** An effect describing a console log of `message`. */
+declare function log<State, Event>(message: any): Effect<State, Event, void>;
+/** An effect describing an HTTP request. */
+declare function makeHttpRequest<State, Event>(request: HttpRequest): Effect<State, Event, Result<HttpResponse, RequestError | HttpError>>;
+/** An effect describing a read of the current browser location. */
+declare function getLocation<State, Event>(): Effect<State, Event, InternalLocation>;
+/** An effect describing a read of the current notification permission state. */
+declare function getNotificationPermission<State, Event>(): Effect<State, Event, Permission>;
+/** An effect describing a notification permission request. */
+declare function requestNotificationPermission<State, Event>(): Effect<State, Event, Permission>;
+/**
+ * An effect describing a read of the current application state. Because state updates are
+ * themselves effects sequenced in order, the value produced reflects all
+ * `updateState` effects that appear earlier in the same effect chain.
+ */
+declare function getState<State, Event>(): Effect<State, Event, State>;
+/**
+ * An effect describing two concurrent sub-effects, returning both results as a tuple `[A, B]`.
+ * Both effects share the same initial state snapshot; neither sees state
+ * changes made by the other. Use `flatMap` instead when the second effect
+ * must observe state updates from the first.
+ */
+declare function product<State, Event, A, B>(effectA: Effect<State, Event, A>, effectB: Effect<State, Event, B>): Effect<State, Event, [A, B]>;
+/**
+ * An effect describing the scheduling of `task` to run after `initialDelayInMillis` milliseconds.
+ *
+ * If `taskId` is provided and a task with that id is already pending, the
+ * pending task is cancelled and replaced. This makes `scheduleTask` the
+ * idiomatic way to implement debouncing: use the same `taskId` on
+ * every keystroke and only the final one will fire.
+ *
+ * @param repeatIntervalInMillis If provided, the task repeats on this interval
+ *   indefinitely after the initial delay. Cancel with `cancelTask`.
+ * @param taskId Stable identifier used to cancel-and-reschedule. Create one
+ *   with `taskId('name')` and store it as a module-level constant.
+ * @returns The TaskId of the newly scheduled task.
+ */
+declare function scheduleTask<State, Event>(task: Effect<State, Event, void>, initialDelayInMillis: number, repeatIntervalInMillis: number | undefined, taskId: TaskId | undefined): Effect<State, Event, TaskId>;
+/** An effect describing a delay of `delayInMilliseconds` ms before continuing the chain. */
+declare function setTimeout<State, Event>(delayInMilliseconds: number): Effect<State, Event, void>;
+/** An effect describing a state update via `f`. */
+declare function updateState<State, Event>(f: (state: State) => State): Effect<State, Event, void>;
+/** An effect describing an IndexedDB database open (or create), with `setup` applied for schema migrations. */
+declare function openDatabase<State, Event>(db: DbName, version: DbVersion, setup: (oldVersion: DbVersion) => DbSetupEffect<void>): Effect<State, Event, Result<void, DbError>>;
+/** An effect describing an IndexedDB transaction containing `effect`. */
+declare function runDbTransaction<State, Event>(db: DbName, objectStores: readonly ObjectStore[], mode: 'readonly' | 'readwrite', effect: DbEffect<void>): Effect<State, Event, Result<void, DbError>>;
+/** An effect describing a browser history navigation of `delta` steps. */
+declare function go<State, Event>(delta: number): Effect<State, Event, void>;
+/** An effect describing a `history.pushState` to `location`. */
+declare function pushState<State, Event>(location: InternalLocation | string): Effect<State, Event, void>;
+/** An effect describing a `history.replaceState` with `location`. */
+declare function replaceState<State, Event>(location: InternalLocation | string): Effect<State, Event, void>;
+/** An effect describing a localStorage read for `key`. */
+declare function getLocalStorageItem<State, Event>(key: string): Effect<State, Event, string | null>;
+/** An effect describing a localStorage write of `value` for `key`. */
+declare function setLocalStorageItem<State, Event>(key: string, value: string): Effect<State, Event, void>;
+/** An effect describing the removal of `key` from localStorage. */
+declare function removeLocalStorageItem<State, Event>(key: string): Effect<State, Event, void>;
+/** An effect describing a localStorage clear. */
+declare function clearLocalStorage<State, Event>(): Effect<State, Event, void>;
+/** An effect describing a sessionStorage read for `key`. */
+declare function getSessionStorageItem<State, Event>(key: string): Effect<State, Event, string | null>;
+/** An effect describing a sessionStorage write of `value` for `key`. */
+declare function setSessionStorageItem<State, Event>(key: string, value: string): Effect<State, Event, void>;
+/** An effect describing the removal of `key` from sessionStorage. */
+declare function removeSessionStorageItem<State, Event>(key: string): Effect<State, Event, void>;
+/** An effect describing a sessionStorage clear. */
+declare function clearSessionStorage<State, Event>(): Effect<State, Event, void>;
+/**
+ * Transforms the `Event` type of an effect by mapping each fired event through `f`.
+ * Used when composing components: a child component fires `EventA`, and the
+ * parent needs to convert those into its own `EventB` before wiring them up.
+ * You rarely need to call this directly — `ComponentElement.onEvent` handles it.
+ */
+declare function mapEvent<State, EventA, EventB, R>(effect: Effect<State, EventA, R>, f: (eventA: EventA) => EventB): Effect<State, EventB, R>;
+/**
+ * Adapts an effect written against a sub-state `StateA` so it can run in a
+ * parent context with state `StateB`. The lens provides the `get`/`set`
+ * functions that translate between the two state shapes.
+ * Used when composing components whose effects operate on a slice of a larger state.
+ */
+declare function mapState<StateA, StateB, Event, R>(effect: Effect<StateA, Event, R>, lens: Lens<StateB, StateA>): Effect<StateB, Event, R>;
+/** Returns true if `value` is an Effect. */
+declare function isEffect(value: any): value is Effect<any, any, any>;
+/** An effect describing a window scroll. */
+declare function scrollWindow<State, Event>(options: ScrollOptions): Effect<State, Event, void>;
+/** An effect describing a scroll of the element matching `selector`. */
+declare function scrollElement<State, Event>(selector: string, options: ScrollOptions): Effect<State, Event, Result<void, ScrollElementError>>;
+/** An effect describing a file download. */
+declare function download<State, Event>(filename: string, content: string, contentType?: string): Effect<State, Event, void>;
+/** An effect describing a BroadcastChannel message post. */
+declare function postBroadcastMessage<State, Event>(channel: string, message: unknown): Effect<State, Event, void>;
+/**
+ * An effect describing a BroadcastChannel subscription, with `handler` called for each message received.
+ * @returns a TaskId that can be used to cancel the subscription
+ */
+declare function subscribeToBroadcastChannel<State, Event>(channel: string, handler: (message: unknown) => Effect<State, Event, void>, taskId?: TaskId | undefined): Effect<State, Event, TaskId>;
+/** An Effect that does nothing. */
+declare function noop<State, Event>(): Effect<State, Event, void>;
+/**
+ * Returns all built-in effect constructors with `State` and `Event` pre-applied.
+ * Call this once per module, passing your application's state and event types,
+ * and destructure the effects you need. This removes the need to repeat the
+ * type parameters at every call site.
+ *
+ * ```ts
+ * const { updateState, getTime, scheduleTask } = makeEffects<MyState, MyEvent>()
+ * ```
+ */
+declare function makeEffects<State, Event>(): {
+    alert: (message: any) => Effect<State, Event, void>;
+    confirm: (message: string) => Effect<State, Event, boolean>;
+    prompt: (message: string, defaultValue?: string) => Effect<State, Event, string | null>;
+    cancelTask: (taskId: TaskId) => Effect<State, Event, void>;
+    getLocation: () => Effect<State, Event, InternalLocation>;
+    getNotificationPermission: () => Effect<State, Event, Permission>;
+    requestNotificationPermission: () => Effect<State, Event, Permission>;
+    clearAppBadge: () => Effect<State, Event, void>;
+    readClipboard: () => Effect<State, Event, Result<string, ClipboardError>>;
+    setAppBadge: (count: number) => Effect<State, Event, void>;
+    setDocumentTitle: (title: string) => Effect<State, Event, void>;
+    writeClipboard: (text: string) => Effect<State, Event, Result<void, ClipboardError>>;
+    fireEvent: (event: Event) => Effect<State, Event, void>;
+    getState: () => Effect<State, Event, State>;
+    getTime: () => Effect<State, Event, Date>;
+    getRandom: () => Effect<State, Event, number>;
+    log: (message: any) => Effect<State, Event, void>;
+    makeHttpRequest: (request: HttpRequest) => Effect<State, Event, Result<HttpResponse, HttpError | RequestError>>;
+    scheduleTask: (task: Effect<State, Event, void>, initialDelayInMillis: number, repeatIntervalInMillis: number | undefined, taskId: TaskId | undefined) => Effect<State, Event, TaskId>;
+    setTimeout: (delayInMilliseconds: number) => Effect<State, Event, void>;
+    updateState: (f: (state: State) => State) => Effect<State, Event, void>;
+    pure<A>(a: A): Effect<State, Event, A>;
+    noop: () => Effect<State, Event, void>;
+    generateUuid: () => Effect<State, Event, Uuid>;
+    getJson: (uri: string) => Effect<State, Event, Result<Json, HttpError | RequestError | DecodingError>>;
+    go: (delta: number) => Effect<State, Event, void>;
+    scrollWindow: (options: ScrollOptions) => Effect<State, Event, void>;
+    scrollElement: (selector: string, options: ScrollOptions) => Effect<State, Event, Result<void, ScrollElementError>>;
+    download: (filename: string, content: string, contentType?: string) => Effect<State, Event, void>;
+    postBroadcastMessage: (channel: string, message: unknown) => Effect<State, Event, void>;
+    subscribeToBroadcastChannel: (channel: string, handler: (message: unknown) => Effect<State, Event, void>, taskId?: TaskId | undefined) => Effect<State, Event, TaskId>;
+    pushState: (location: InternalLocation | string) => Effect<State, Event, void>;
+    replaceState: (location: InternalLocation | string) => Effect<State, Event, void>;
+    getLocalStorageItem: (key: string) => Effect<State, Event, string | null>;
+    setLocalStorageItem: (key: string, value: string) => Effect<State, Event, void>;
+    removeLocalStorageItem: (key: string) => Effect<State, Event, void>;
+    clearLocalStorage: () => Effect<State, Event, void>;
+    getSessionStorageItem: (key: string) => Effect<State, Event, string | null>;
+    setSessionStorageItem: (key: string, value: string) => Effect<State, Event, void>;
+    removeSessionStorageItem: (key: string) => Effect<State, Event, void>;
+    clearSessionStorage: () => Effect<State, Event, void>;
+    resultT<A, E>(effect: Effect<State, Event, Result<A, E>>): ResultTransformer<State, Event, A, E>;
+};
+/**
+ * Maps each element of `as` to an effect and runs them in sequence, collecting
+ * all results into an array. Each effect runs after the previous one completes,
+ * so state changes from earlier effects are visible to later ones.
+ */
+declare function traverse<State, Event, A, B>(as: readonly A[], f: (a: A) => Effect<State, Event, B>): Effect<State, Event, readonly B[]>;
+/**
+ * Wraps an `Effect<State, Event, Result<A, E>>` to allow chaining on the
+ * success and error branches without manually unwrapping the `Result` at each
+ * step. Methods like `flatMap` and `errorFlatMap` short-circuit on the other
+ * branch. Call `.value` to get the underlying effect back.
+ */
+declare class ResultTransformer<State, Event, A, E> {
+    /** The underlying wrapped effect. */
+    readonly value: Effect<State, Event, Result<A, E>>;
+    constructor(value: Effect<State, Event, Result<A, E>>);
+    /** Transforms the success value. */
+    map<B>(f: (a: A) => B): ResultTransformer<State, Event, B, E>;
+    /** Replaces the success value with `b`. */
+    as<B>(b: B): ResultTransformer<State, Event, B, E>;
+    /** Discards the success value. */
+    void(): ResultTransformer<State, Event, void, E>;
+    /** Discards the error value. */
+    errorVoid(): ResultTransformer<State, Event, A, void>;
+    /** Chains on success, short-circuits on failure. */
+    flatMap<B>(f: (a: A) => Effect<State, Event, Result<B, E>>): ResultTransformer<State, Event, B, E>;
+    /** Like `flatMap` but `f` returns an unwrapped Effect rather than an Effect of Result. */
+    semiFlatMap<B>(f: (a: A) => Effect<State, Event, B>): ResultTransformer<State, Event, B, E>;
+    /** Sequences on success, short-circuits on failure. */
+    and<B>(effect: Effect<State, Event, Result<B, E>>): ResultTransformer<State, Event, B, E>;
+    /** Unwraps the Result, returning either the success value or the error. */
+    merge(): Effect<State, Event, A | E>;
+    /** Logs the error to the console without changing the Result. */
+    logError(): ResultTransformer<State, Event, A, E>;
+    /** Logs the error and converts it to void. */
+    logAndDropError(): ResultTransformer<State, Event, A, void>;
+    /** Transforms the error value. */
+    errorMap<EE>(f: (error: E) => EE): ResultTransformer<State, Event, A, EE>;
+    /** Chains on failure, short-circuits on success. */
+    errorFlatMap<EE>(f: (error: E) => Effect<State, Event, EE>): ResultTransformer<State, Event, A, EE>;
+}
+/**
+ * Lifts an `Effect<State, Event, Result<A, E>>` into a `ResultTransformer` for
+ * chaining. Equivalent to `new ResultTransformer(effect)`.
+ */
+declare function resultT<State, Event, A, E>(effect: Effect<State, Event, Result<A, E>>): ResultTransformer<State, Event, A, E>;
+
+interface SupportsApply {
+    apply(f: (t: this) => this): this;
+    applyIf(condition: boolean, f: (self: this) => this): this;
+}
+
+type SvgGraphicElement<State, Event> = Circle<State, Event> | Ellipse<State, Event> | Image<State, Event> | Line<State, Event> | Polyline<State, Event> | Polygon<State, Event> | Path<State, Event> | Rect<State, Event> | Use<State, Event>;
+interface Circle<State, Event> extends VoidElement<State, Event, 'svg/circle'> {
+}
+interface Ellipse<State, Event> extends VoidElement<State, Event, 'svg/ellipse'> {
+}
+interface Image<State, Event> extends VoidElement<State, Event, 'svg/image'> {
+}
+interface Line<State, Event> extends VoidElement<State, Event, 'svg/line'> {
+}
+interface Polyline<State, Event> extends VoidElement<State, Event, 'svg/polyline'> {
+}
+interface Polygon<State, Event> extends VoidElement<State, Event, 'svg/polygon'> {
+}
+interface Path<State, Event> extends VoidElement<State, Event, 'svg/path'> {
+}
+interface Rect<State, Event> extends VoidElement<State, Event, 'svg/rect'> {
+}
+interface Use<State, Event> extends VoidElement<State, Event, 'svg/use'> {
+}
+interface Svg<State, Event> extends NonVoidElement<State, Event, 'svg/svg', SvgGraphicElement<State, Event>> {
+}
+
+/**
+ * Base interface for all virtual DOM elements. Provides typed event handler methods that
+ * each return `this`, so calls can be chained: `button_('Save').onClick(save).onFocus(highlight)`.
+ */
+interface BaseElement<State, Event, Tag> extends SupportsApply {
+    readonly _type: 'Element';
+    readonly tag: Tag;
+    readonly nodeId?: NodeId;
+    readonly attrs: readonly Attr[];
+    readonly props: readonly Prop[];
+    readonly eventListeners: readonly EventListener<State, Event>[];
+    onClick(effect: Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onDblClick(effect: Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onFocus(effect: Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onBlur(effect: Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onChange(f: (data: ChangeData) => Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onTextInput(f: (textState: TextState) => Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onKeyDown(effect: (key: KeyData) => Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onKeyUp(effect: (key: KeyData) => Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onMouseEnter(effect: Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onMouseLeave(effect: Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onMouseMove(f: (data: MouseMoveData) => Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onScroll(f: (data: ScrollData) => Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onScrollEnd(f: (data: ScrollData) => Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onWheel(f: (data: WheelData) => Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onTouchStart(effect: (touchData: readonly TouchData[]) => Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onTouchMove(effect: (touchData: readonly TouchData[]) => Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onTouchEnd(effect: (touchData: readonly TouchData[]) => Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onTouchCancel(effect: (touchData: readonly TouchData[]) => Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onEvent(eventName: string, effect: (detail: unknown) => Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    onSubmit(effect: Effect<State, Event, EventListenerResult>, options?: EventOptions): this;
+    prop(name: string, value: unknown): this;
+}
+/** A virtual DOM element that cannot have children (e.g. `br`, `hr`, `img`, `input`). */
+interface VoidElement<State, Event, Tag> extends BaseElement<State, Event, Tag> {
+}
+/** A virtual DOM element with typed children. */
+interface NonVoidElement<State, Event, Tag, Children> extends BaseElement<State, Event, Tag> {
+    readonly children: readonly Children[];
+}
+type ButtonContent<State, Event> = NonVoidInlineElement<State, Event> | string | Svg<State, Event>;
+type Button<State, Event> = NonVoidElement<State, Event, 'button', ButtonContent<State, Event>>;
+type Div<State, Event> = NonVoidElement<State, Event, 'div', FlowContent<State, Event>>;
+type H1<State, Event> = NonVoidElement<State, Event, 'h1', FlowContent<State, Event>>;
+type H2<State, Event> = NonVoidElement<State, Event, 'h2', FlowContent<State, Event>>;
+type H3<State, Event> = NonVoidElement<State, Event, 'h3', FlowContent<State, Event>>;
+type H4<State, Event> = NonVoidElement<State, Event, 'h4', FlowContent<State, Event>>;
+type H5<State, Event> = NonVoidElement<State, Event, 'h5', FlowContent<State, Event>>;
+type H6<State, Event> = NonVoidElement<State, Event, 'h6', FlowContent<State, Event>>;
+type Header<State, Event> = NonVoidElement<State, Event, 'header', FlowContent<State, Event>>;
+type Li<State, Event> = NonVoidElement<State, Event, 'li', FlowContent<State, Event>>;
+type Main<State, Event> = NonVoidElement<State, Event, 'main', FlowContent<State, Event>>;
+type Nav<State, Event> = NonVoidElement<State, Event, 'nav', FlowContent<State, Event>>;
+type Ol<State, Event> = NonVoidElement<State, Event, 'ol', Li<State, Event>>;
+type P<State, Event> = NonVoidElement<State, Event, 'p', FlowContent<State, Event>>;
+type Ul<State, Event> = NonVoidElement<State, Event, 'ul', Li<State, Event>>;
+type Address<State, Event> = NonVoidElement<State, Event, 'address', FlowContent<State, Event>>;
+type Article<State, Event> = NonVoidElement<State, Event, 'article', FlowContent<State, Event>>;
+type Aside<State, Event> = NonVoidElement<State, Event, 'aside', FlowContent<State, Event>>;
+type Blockquote<State, Event> = NonVoidElement<State, Event, 'blockquote', FlowContent<State, Event>>;
+type Dd<State, Event> = NonVoidElement<State, Event, 'dd', FlowContent<State, Event>>;
+type Details<State, Event> = NonVoidElement<State, Event, 'details', FlowContent<State, Event>>;
+type Dt<State, Event> = NonVoidElement<State, Event, 'dt', PhrasingContent<State, Event>>;
+type Dl<State, Event> = NonVoidElement<State, Event, 'dl', Dt<State, Event> | Dd<State, Event>>;
+type Fieldset<State, Event> = NonVoidElement<State, Event, 'fieldset', FlowContent<State, Event>>;
+type Figcaption<State, Event> = NonVoidElement<State, Event, 'figcaption', FlowContent<State, Event>>;
+type Figure<State, Event> = NonVoidElement<State, Event, 'figure', FlowContent<State, Event>>;
+type Footer<State, Event> = NonVoidElement<State, Event, 'footer', FlowContent<State, Event>>;
+type Form<State, Event> = NonVoidElement<State, Event, 'form', FlowContent<State, Event>>;
+type Hr<State, Event> = VoidElement<State, Event, 'hr'>;
+type Pre<State, Event> = NonVoidElement<State, Event, 'pre', PhrasingContent<State, Event>>;
+type Section<State, Event> = NonVoidElement<State, Event, 'section', FlowContent<State, Event>>;
+type Summary<State, Event> = NonVoidElement<State, Event, 'summary', PhrasingContent<State, Event>>;
+type Td<State, Event> = NonVoidElement<State, Event, 'td', FlowContent<State, Event>>;
+type Th<State, Event> = NonVoidElement<State, Event, 'th', FlowContent<State, Event>>;
+type Tr<State, Event> = NonVoidElement<State, Event, 'tr', Th<State, Event> | Td<State, Event>>;
+type Tbody<State, Event> = NonVoidElement<State, Event, 'tbody', Tr<State, Event>>;
+type Tfoot<State, Event> = NonVoidElement<State, Event, 'tfoot', Tr<State, Event>>;
+type Thead<State, Event> = NonVoidElement<State, Event, 'thead', Tr<State, Event>>;
+type Table<State, Event> = NonVoidElement<State, Event, 'table', Thead<State, Event> | Tbody<State, Event> | Tfoot<State, Event> | Tr<State, Event>>;
+type BlockElement<State, Event> = Address<State, Event> | Article<State, Event> | Aside<State, Event> | Blockquote<State, Event> | Button<State, Event> | Dd<State, Event> | Details<State, Event> | Dl<State, Event> | Dt<State, Event> | Div<State, Event> | Fieldset<State, Event> | Figcaption<State, Event> | Figure<State, Event> | Footer<State, Event> | Form<State, Event> | H1<State, Event> | H2<State, Event> | H3<State, Event> | H4<State, Event> | H5<State, Event> | H6<State, Event> | Header<State, Event> | Hr<State, Event> | Li<State, Event> | Main<State, Event> | Nav<State, Event> | Ol<State, Event> | P<State, Event> | Pre<State, Event> | Section<State, Event> | Summary<State, Event> | Table<State, Event> | Tbody<State, Event> | Td<State, Event> | Tfoot<State, Event> | Th<State, Event> | Thead<State, Event> | Tr<State, Event> | Ul<State, Event>;
+type Br<State, Event> = VoidElement<State, Event, 'br'>;
+type Img<State, Event> = VoidElement<State, Event, 'img'>;
+type Input<State, Event> = VoidElement<State, Event, 'input'>;
+type VoidInlineElement<State, Event> = Br<State, Event> | Img<State, Event> | Input<State, Event>;
+type A<State, Event> = NonVoidElement<State, Event, 'a', FlowContent<State, Event>>;
+type Abbr<State, Event> = NonVoidElement<State, Event, 'abbr', PhrasingContent<State, Event>>;
+type B<State, Event> = NonVoidElement<State, Event, 'b', PhrasingContent<State, Event>>;
+type Cite<State, Event> = NonVoidElement<State, Event, 'cite', PhrasingContent<State, Event>>;
+type Code<State, Event> = NonVoidElement<State, Event, 'code', PhrasingContent<State, Event>>;
+type Em<State, Event> = NonVoidElement<State, Event, 'em', PhrasingContent<State, Event>>;
+type I<State, Event> = NonVoidElement<State, Event, 'i', PhrasingContent<State, Event>>;
+type Kbd<State, Event> = NonVoidElement<State, Event, 'kbd', PhrasingContent<State, Event>>;
+type Label<State, Event> = NonVoidElement<State, Event, 'label', PhrasingContent<State, Event>>;
+type Mark<State, Event> = NonVoidElement<State, Event, 'mark', PhrasingContent<State, Event>>;
+type Option<State, Event> = NonVoidElement<State, Event, 'option', string>;
+type Q<State, Event> = NonVoidElement<State, Event, 'q', PhrasingContent<State, Event>>;
+type S<State, Event> = NonVoidElement<State, Event, 's', PhrasingContent<State, Event>>;
+type Select<State, Event> = NonVoidElement<State, Event, 'select', Option<State, Event>>;
+type Small<State, Event> = NonVoidElement<State, Event, 'small', PhrasingContent<State, Event>>;
+type Span<State, Event> = NonVoidElement<State, Event, 'span', PhrasingContent<State, Event>>;
+type Strong<State, Event> = NonVoidElement<State, Event, 'strong', PhrasingContent<State, Event>>;
+type Sub<State, Event> = NonVoidElement<State, Event, 'sub', PhrasingContent<State, Event>>;
+type Sup<State, Event> = NonVoidElement<State, Event, 'sup', PhrasingContent<State, Event>>;
+type Textarea<State, Event> = NonVoidElement<State, Event, 'textarea', string>;
+type Time<State, Event> = NonVoidElement<State, Event, 'time', PhrasingContent<State, Event>>;
+type U<State, Event> = NonVoidElement<State, Event, 'u', PhrasingContent<State, Event>>;
+type NonVoidInlineElement<State, Event> = A<State, Event> | Abbr<State, Event> | B<State, Event> | Cite<State, Event> | Code<State, Event> | Em<State, Event> | I<State, Event> | Kbd<State, Event> | Label<State, Event> | Mark<State, Event> | Option<State, Event> | Q<State, Event> | S<State, Event> | Select<State, Event> | Small<State, Event> | Span<State, Event> | Strong<State, Event> | Sub<State, Event> | Sup<State, Event> | Textarea<State, Event> | Time<State, Event> | U<State, Event>;
+type InlineElement<State, Event> = VoidInlineElement<State, Event> | NonVoidInlineElement<State, Event>;
+type Element<State, Event> = BlockElement<State, Event> | InlineElement<State, Event> | ReplacedElement<State, Event> | SvgGraphicElement<State, Event>;
+type ReplacedElement<State, Event> = Svg<State, Event>;
+
+/** A non-void element with an arbitrary tag name, for custom or non-standard HTML elements. */
+type CustomElement<State, Event> = NonVoidElement<State, Event, string, any>;
+/** Union of all node types valid in block-level (flow) positions. */
+type FlowContent<State, Event> = PhrasingContent<State, Event> | BlockElement<State, Event> | ReplacedElement<State, Event> | SvgGraphicElement<State, Event> | string | View<State, unknown, Event> | ComponentElement<any, any, any, any, any> | CustomElement<State, Event>;
+/** Union of inline elements and plain text nodes. */
+type PhrasingContent<State, Event> = InlineElement<State, Event> | string;
+/** Union of all virtual DOM node types: elements, text, views, and component instances. */
+type Node<State, Event> = Element<State, Event> | string | View<State, unknown, Event> | ComponentElement<any, any, any, any, any> | CustomElement<State, Event>;
+type NonTextNode<State, Event> = Exclude<Node<State, Event>, string>;
+/**
+ * Factory that returns all HTML and SVG element builders with `State` and `Event` pre-applied.
+ *
+ * Each element comes in three forms:
+ * - `div(...attrs)(...children)` — full curried form, accepts attributes then children
+ * - `div_(...children)` — no-attribute shorthand, equivalent to `div()(...)`
+ * - `div__(...attrs)` — no-children shorthand, equivalent to `div(...)()`
+ *
+ * Call `makeDom<State, Event>()` once at the top of your module and destructure the elements you need:
+ * ```ts
+ * const { div_, span_, button } = makeDom<State, Event>()
+ * ```
+ */
+declare function makeDom<State, Event>(): {
+    a_: (...children: readonly FlowContent<State, Event>[]) => A<State, Event>;
+    a__: (...attrs: AttrArg[]) => A<State, Event>;
+    abbr_: (...children: readonly PhrasingContent<State, Event>[]) => Abbr<State, Event>;
+    abbr__: (...attrs: AttrArg[]) => Abbr<State, Event>;
+    address_: (...children: readonly FlowContent<State, Event>[]) => Address<State, Event>;
+    address__: (...attrs: AttrArg[]) => Address<State, Event>;
+    article_: (...children: readonly FlowContent<State, Event>[]) => Article<State, Event>;
+    article__: (...attrs: AttrArg[]) => Article<State, Event>;
+    aside_: (...children: readonly FlowContent<State, Event>[]) => Aside<State, Event>;
+    aside__: (...attrs: AttrArg[]) => Aside<State, Event>;
+    b_: (...children: readonly PhrasingContent<State, Event>[]) => B<State, Event>;
+    b__: (...attrs: AttrArg[]) => B<State, Event>;
+    blockquote_: (...children: readonly FlowContent<State, Event>[]) => Blockquote<State, Event>;
+    blockquote__: (...attrs: AttrArg[]) => Blockquote<State, Event>;
+    button_: (...children: readonly ButtonContent<State, Event>[]) => Button<State, Event>;
+    button__: (...attrs: AttrArg[]) => Button<State, Event>;
+    cite_: (...children: readonly PhrasingContent<State, Event>[]) => Cite<State, Event>;
+    cite__: (...attrs: AttrArg[]) => Cite<State, Event>;
+    code_: (...children: readonly PhrasingContent<State, Event>[]) => Code<State, Event>;
+    code__: (...attrs: AttrArg[]) => Code<State, Event>;
+    dd_: (...children: readonly FlowContent<State, Event>[]) => Dd<State, Event>;
+    dd__: (...attrs: AttrArg[]) => Dd<State, Event>;
+    details_: (...children: readonly FlowContent<State, Event>[]) => Details<State, Event>;
+    details__: (...attrs: AttrArg[]) => Details<State, Event>;
+    div_: (...children: readonly FlowContent<State, Event>[]) => Div<State, Event>;
+    div__: (...attrs: AttrArg[]) => Div<State, Event>;
+    dl_: (...children: readonly (Dd<State, Event> | Dt<State, Event>)[]) => Dl<State, Event>;
+    dl__: (...attrs: AttrArg[]) => Dl<State, Event>;
+    dt_: (...children: readonly PhrasingContent<State, Event>[]) => Dt<State, Event>;
+    dt__: (...attrs: AttrArg[]) => Dt<State, Event>;
+    em_: (...children: readonly PhrasingContent<State, Event>[]) => Em<State, Event>;
+    em__: (...attrs: AttrArg[]) => Em<State, Event>;
+    fieldset_: (...children: readonly FlowContent<State, Event>[]) => Fieldset<State, Event>;
+    fieldset__: (...attrs: AttrArg[]) => Fieldset<State, Event>;
+    figcaption_: (...children: readonly FlowContent<State, Event>[]) => Figcaption<State, Event>;
+    figcaption__: (...attrs: AttrArg[]) => Figcaption<State, Event>;
+    figure_: (...children: readonly FlowContent<State, Event>[]) => Figure<State, Event>;
+    figure__: (...attrs: AttrArg[]) => Figure<State, Event>;
+    footer_: (...children: readonly FlowContent<State, Event>[]) => Footer<State, Event>;
+    footer__: (...attrs: AttrArg[]) => Footer<State, Event>;
+    form_: (...children: readonly FlowContent<State, Event>[]) => Form<State, Event>;
+    form__: (...attrs: AttrArg[]) => Form<State, Event>;
+    h1_: (...children: readonly FlowContent<State, Event>[]) => H1<State, Event>;
+    h1__: (...attrs: AttrArg[]) => H1<State, Event>;
+    h2_: (...children: readonly FlowContent<State, Event>[]) => H2<State, Event>;
+    h2__: (...attrs: AttrArg[]) => H2<State, Event>;
+    h3_: (...children: readonly FlowContent<State, Event>[]) => H3<State, Event>;
+    h3__: (...attrs: AttrArg[]) => H3<State, Event>;
+    h4_: (...children: readonly FlowContent<State, Event>[]) => H4<State, Event>;
+    h4__: (...attrs: AttrArg[]) => H4<State, Event>;
+    h5_: (...children: readonly FlowContent<State, Event>[]) => H5<State, Event>;
+    h5__: (...attrs: AttrArg[]) => H5<State, Event>;
+    h6_: (...children: readonly FlowContent<State, Event>[]) => H6<State, Event>;
+    h6__: (...attrs: AttrArg[]) => H6<State, Event>;
+    header_: (...children: readonly FlowContent<State, Event>[]) => Header<State, Event>;
+    header__: (...attrs: AttrArg[]) => Header<State, Event>;
+    i_: (...children: readonly PhrasingContent<State, Event>[]) => I<State, Event>;
+    i__: (...attrs: AttrArg[]) => I<State, Event>;
+    kbd_: (...children: readonly PhrasingContent<State, Event>[]) => Kbd<State, Event>;
+    kbd__: (...attrs: AttrArg[]) => Kbd<State, Event>;
+    label_: (...children: readonly PhrasingContent<State, Event>[]) => Label<State, Event>;
+    label__: (...attrs: AttrArg[]) => Label<State, Event>;
+    li_: (...children: readonly FlowContent<State, Event>[]) => Li<State, Event>;
+    li__: (...attrs: AttrArg[]) => Li<State, Event>;
+    main_: (...children: readonly FlowContent<State, Event>[]) => Main<State, Event>;
+    main__: (...attrs: AttrArg[]) => Main<State, Event>;
+    mark_: (...children: readonly PhrasingContent<State, Event>[]) => Mark<State, Event>;
+    mark__: (...attrs: AttrArg[]) => Mark<State, Event>;
+    nav_: (...children: readonly FlowContent<State, Event>[]) => Nav<State, Event>;
+    nav__: (...attrs: AttrArg[]) => Nav<State, Event>;
+    ol_: (...children: readonly Li<State, Event>[]) => Ol<State, Event>;
+    ol__: (...attrs: AttrArg[]) => Ol<State, Event>;
+    option_: (...children: readonly string[]) => Option<State, Event>;
+    option__: (...attrs: AttrArg[]) => Option<State, Event>;
+    p_: (...children: readonly FlowContent<State, Event>[]) => P<State, Event>;
+    p__: (...attrs: AttrArg[]) => P<State, Event>;
+    pre_: (...children: readonly PhrasingContent<State, Event>[]) => Pre<State, Event>;
+    pre__: (...attrs: AttrArg[]) => Pre<State, Event>;
+    q_: (...children: readonly PhrasingContent<State, Event>[]) => Q<State, Event>;
+    q__: (...attrs: AttrArg[]) => Q<State, Event>;
+    s_: (...children: readonly PhrasingContent<State, Event>[]) => S<State, Event>;
+    s__: (...attrs: AttrArg[]) => S<State, Event>;
+    section_: (...children: readonly FlowContent<State, Event>[]) => Section<State, Event>;
+    section__: (...attrs: AttrArg[]) => Section<State, Event>;
+    select_: (...children: readonly Option<State, Event>[]) => Select<State, Event>;
+    select__: (...attrs: AttrArg[]) => Select<State, Event>;
+    small_: (...children: readonly PhrasingContent<State, Event>[]) => Small<State, Event>;
+    small__: (...attrs: AttrArg[]) => Small<State, Event>;
+    span_: (...children: readonly PhrasingContent<State, Event>[]) => Span<State, Event>;
+    span__: (...attrs: AttrArg[]) => Span<State, Event>;
+    strong_: (...children: readonly PhrasingContent<State, Event>[]) => Strong<State, Event>;
+    strong__: (...attrs: AttrArg[]) => Strong<State, Event>;
+    sub_: (...children: readonly PhrasingContent<State, Event>[]) => Sub<State, Event>;
+    sub__: (...attrs: AttrArg[]) => Sub<State, Event>;
+    summary_: (...children: readonly PhrasingContent<State, Event>[]) => Summary<State, Event>;
+    summary__: (...attrs: AttrArg[]) => Summary<State, Event>;
+    sup_: (...children: readonly PhrasingContent<State, Event>[]) => Sup<State, Event>;
+    sup__: (...attrs: AttrArg[]) => Sup<State, Event>;
+    svg_: (...children: readonly SvgGraphicElement<State, Event>[]) => Svg<State, Event>;
+    svg__: (...attrs: AttrArg[]) => Svg<State, Event>;
+    table_: (...children: readonly (Tbody<State, Event> | Tfoot<State, Event> | Thead<State, Event> | Tr<State, Event>)[]) => Table<State, Event>;
+    table__: (...attrs: AttrArg[]) => Table<State, Event>;
+    tbody_: (...children: readonly Tr<State, Event>[]) => Tbody<State, Event>;
+    tbody__: (...attrs: AttrArg[]) => Tbody<State, Event>;
+    td_: (...children: readonly FlowContent<State, Event>[]) => Td<State, Event>;
+    td__: (...attrs: AttrArg[]) => Td<State, Event>;
+    textarea_: (...children: readonly PhrasingContent<State, Event>[]) => Textarea<State, Event>;
+    textarea__: (...attrs: AttrArg[]) => Textarea<State, Event>;
+    tfoot_: (...children: readonly Tr<State, Event>[]) => Tfoot<State, Event>;
+    tfoot__: (...attrs: AttrArg[]) => Tfoot<State, Event>;
+    th_: (...children: readonly FlowContent<State, Event>[]) => Th<State, Event>;
+    th__: (...attrs: AttrArg[]) => Th<State, Event>;
+    thead_: (...children: readonly Tr<State, Event>[]) => Thead<State, Event>;
+    thead__: (...attrs: AttrArg[]) => Thead<State, Event>;
+    time_: (...children: readonly PhrasingContent<State, Event>[]) => Time<State, Event>;
+    time__: (...attrs: AttrArg[]) => Time<State, Event>;
+    tr_: (...children: readonly (Td<State, Event> | Th<State, Event>)[]) => Tr<State, Event>;
+    tr__: (...attrs: AttrArg[]) => Tr<State, Event>;
+    u_: (...children: readonly PhrasingContent<State, Event>[]) => U<State, Event>;
+    u__: (...attrs: AttrArg[]) => U<State, Event>;
+    ul_: (...children: readonly Li<State, Event>[]) => Ul<State, Event>;
+    ul__: (...attrs: AttrArg[]) => Ul<State, Event>;
+    view<Params>(nodeId: NodeId | string, nodes: (params: Params) => NodeGroup<State, Event> | Node<State, Event>): (params: Params) => View<State, Params, Event>;
+    componentElem<ComponentState, Params, ComponentEvent>(comp: Component<ComponentState, Params, ComponentEvent>, nodeId: NodeId, params?: Params): ComponentElement<State, Event, ComponentState, Params, ComponentEvent>;
+    br: (...attrs: AttrOrNodeIdArgs) => Br<State, Event>;
+    hr: (...attrs: AttrOrNodeIdArgs) => Hr<State, Event>;
+    img: (...attrs: AttrOrNodeIdArgs) => Img<State, Event>;
+    input: (...attrs: AttrOrNodeIdArgs) => Input<State, Event>;
+    a: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => A<State, Event>;
+    abbr: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Abbr<State, Event>;
+    address: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Address<State, Event>;
+    article: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Article<State, Event>;
+    aside: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Aside<State, Event>;
+    b: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => B<State, Event>;
+    blockquote: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Blockquote<State, Event>;
+    button: (...attrs: AttrOrNodeIdArgs) => (...children: readonly ButtonContent<State, Event>[]) => Button<State, Event>;
+    cite: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Cite<State, Event>;
+    code: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Code<State, Event>;
+    dd: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Dd<State, Event>;
+    details: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Details<State, Event>;
+    div: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Div<State, Event>;
+    dl: (...attrs: AttrOrNodeIdArgs) => (...children: readonly (Dd<State, Event> | Dt<State, Event>)[]) => Dl<State, Event>;
+    dt: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Dt<State, Event>;
+    em: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Em<State, Event>;
+    fieldset: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Fieldset<State, Event>;
+    figcaption: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Figcaption<State, Event>;
+    figure: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Figure<State, Event>;
+    footer: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Footer<State, Event>;
+    form: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Form<State, Event>;
+    h1: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => H1<State, Event>;
+    h2: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => H2<State, Event>;
+    h3: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => H3<State, Event>;
+    h4: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => H4<State, Event>;
+    h5: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => H5<State, Event>;
+    h6: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => H6<State, Event>;
+    header: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Header<State, Event>;
+    i: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => I<State, Event>;
+    kbd: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Kbd<State, Event>;
+    label: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Label<State, Event>;
+    li: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Li<State, Event>;
+    main: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Main<State, Event>;
+    mark: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Mark<State, Event>;
+    nav: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Nav<State, Event>;
+    ol: (...attrs: AttrOrNodeIdArgs) => (...children: readonly Li<State, Event>[]) => Ol<State, Event>;
+    option: (...attrs: AttrOrNodeIdArgs) => (...children: readonly string[]) => Option<State, Event>;
+    p: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => P<State, Event>;
+    pre: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Pre<State, Event>;
+    q: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Q<State, Event>;
+    s: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => S<State, Event>;
+    section: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Section<State, Event>;
+    select: (...attrs: AttrOrNodeIdArgs) => (...children: readonly Option<State, Event>[]) => Select<State, Event>;
+    small: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Small<State, Event>;
+    span: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Span<State, Event>;
+    strong: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Strong<State, Event>;
+    sub: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Sub<State, Event>;
+    summary: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Summary<State, Event>;
+    sup: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Sup<State, Event>;
+    table: (...attrs: AttrOrNodeIdArgs) => (...children: readonly (Tbody<State, Event> | Tfoot<State, Event> | Thead<State, Event> | Tr<State, Event>)[]) => Table<State, Event>;
+    tbody: (...attrs: AttrOrNodeIdArgs) => (...children: readonly Tr<State, Event>[]) => Tbody<State, Event>;
+    td: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Td<State, Event>;
+    textarea: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Textarea<State, Event>;
+    tfoot: (...attrs: AttrOrNodeIdArgs) => (...children: readonly Tr<State, Event>[]) => Tfoot<State, Event>;
+    th: (...attrs: AttrOrNodeIdArgs) => (...children: readonly FlowContent<State, Event>[]) => Th<State, Event>;
+    thead: (...attrs: AttrOrNodeIdArgs) => (...children: readonly Tr<State, Event>[]) => Thead<State, Event>;
+    time: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => Time<State, Event>;
+    tr: (...attrs: AttrOrNodeIdArgs) => (...children: readonly (Td<State, Event> | Th<State, Event>)[]) => Tr<State, Event>;
+    u: (...attrs: AttrOrNodeIdArgs) => (...children: readonly PhrasingContent<State, Event>[]) => U<State, Event>;
+    ul: (...attrs: AttrOrNodeIdArgs) => (...children: readonly Li<State, Event>[]) => Ul<State, Event>;
+    svg: (...attrs: AttrOrNodeIdArgs) => (...children: readonly SvgGraphicElement<State, Event>[]) => Svg<State, Event>;
+    circle: (...attrs: AttrOrNodeIdArgs) => Circle<State, Event>;
+    ellipse: (...attrs: AttrOrNodeIdArgs) => Ellipse<State, Event>;
+    image: (...attrs: AttrOrNodeIdArgs) => Image<State, Event>;
+    line: (...attrs: AttrOrNodeIdArgs) => Line<State, Event>;
+    polyline: (...attrs: AttrOrNodeIdArgs) => Polyline<State, Event>;
+    polygon: (...attrs: AttrOrNodeIdArgs) => Polygon<State, Event>;
+    path: (...attrs: AttrOrNodeIdArgs) => Path<State, Event>;
+    rect: (...attrs: AttrOrNodeIdArgs) => Rect<State, Event>;
+    use: (...attrs: AttrOrNodeIdArgs) => Use<State, Event>;
+    element: (tag: string) => (...attrs: readonly (readonly [string, string] | NodeId)[]) => (...children: readonly FlowContent<State, Event>[]) => CustomElement<State, Event>;
+    nodeGroup: (...nodes: Node<State, Event>[]) => NodeGroup<State, Event>;
+    _: (...nodes: Node<State, Event>[]) => NodeGroup<State, Event>;
+    fixedView: (id: NodeId | string) => (nodes: NodeGroup<State, Event> | Node<State, Event>) => View<State, void, Event>;
+};
+/** Pattern-matches over a `Node` value, calling the appropriate case handler and returning its result. */
+declare function foldNode<State, Event, A>(node: Node<State, Event>, cases: {
+    onText: (text: string) => A;
+    onVoidElement: (element: VoidElement<State, Event, string>) => A;
+    onNonVoidElement: (element: NonVoidElement<State, Event, string, Node<State, Event>>) => A;
+    onComponent: (component: ComponentElement<any, any, any, any, any>) => A;
+    onView: (view: View<State, unknown, Event>) => A;
+}): A;
+
+export { getRandom as $, type Attr as A, clearLocalStorage as B, type Component as C, type Dimensions as D, type Effect as E, type FlatMap as F, clearSessionStorage as G, type HttpRequest as H, type InternalLocation as I, Json as J, confirm as K, type Lens as L, type Method as M, type NodeGroup as N, customEffect as O, type Permission as P, type QueryParam as Q, type Result as R, type ScrollOptions as S, type TaskId as T, type Uuid as U, download as V, fireEvent as W, generateUuid as X, getLocalStorageItem as Y, getLocation as Z, getNotificationPermission as _, type EventActions as a, type Em as a$, getSessionStorageItem as a0, getState as a1, getTime as a2, go as a3, isEffect as a4, log as a5, makeEffects as a6, makeHttpRequest as a7, mapEvent as a8, mapState as a9, writeClipboard as aA, type A as aB, type Abbr as aC, type Address as aD, type Article as aE, type Aside as aF, type AttrArg as aG, type AttrOrNodeIdArgs as aH, type B as aI, type BlockElement as aJ, type Blockquote as aK, type Br as aL, type Button as aM, type ButtonContent as aN, type ChangeData as aO, type Circle as aP, type Cite as aQ, type Code as aR, type ComponentElement as aS, type CustomElement as aT, type Dd as aU, type Details as aV, type Div as aW, type Dl as aX, type Dt as aY, type Element as aZ, type Ellipse as a_, noop as aa, openDatabase as ab, postBroadcastMessage as ac, product as ad, prompt as ae, pure as af, pushState as ag, readClipboard as ah, removeLocalStorageItem as ai, removeSessionStorageItem as aj, replaceState as ak, requestNotificationPermission as al, resultT as am, runDbTransaction as an, scheduleTask as ao, scrollElement as ap, scrollWindow as aq, setAppBadge as ar, setDocumentTitle as as, setLocalStorageItem as at, setSessionStorageItem as au, setTimeout as av, subscribeToBroadcastChannel as aw, taskId as ax, traverse as ay, updateState as az, type HttpResponse as b, type Th as b$, type EventListenerResult as b0, type EventOptions as b1, type Fieldset as b2, type Figcaption as b3, type Figure as b4, type FlowContent as b5, type Footer as b6, type Form as b7, type H1 as b8, type H2 as b9, type Path as bA, type PhrasingContent as bB, type Polygon as bC, type Polyline as bD, type Pre as bE, type Prop as bF, type Q as bG, type Rect as bH, type ReplacedElement as bI, type S as bJ, type ScrollData as bK, type Section as bL, type Select as bM, type Small as bN, type Span as bO, type Strong as bP, type Sub as bQ, type Summary as bR, type Sup as bS, type Svg as bT, type SvgGraphicElement as bU, type Table as bV, type Tbody as bW, type Td as bX, type TextState as bY, type Textarea as bZ, type Tfoot as b_, type H3 as ba, type H4 as bb, type H5 as bc, type H6 as bd, type Header as be, type Hr as bf, type I as bg, type Image as bh, type Img as bi, type InlineElement as bj, type Input as bk, type Kbd as bl, type KeyData as bm, type Label as bn, type Li as bo, type Line as bp, type Main as bq, type Mark as br, type MouseMoveData as bs, type Nav as bt, type NodeId as bu, type NonTextNode as bv, type NonVoidElement as bw, type Ol as bx, type Option as by, type P as bz, type RequestError as c, type Thead as c0, type Time as c1, type TouchData as c2, type Tr as c3, type U as c4, type Ul as c5, type Use as c6, type View as c7, type VoidElement as c8, type WheelData as c9, attr as ca, component as cb, cssVars as cc, foldNode as cd, id as ce, makeDom as cf, nodeId as cg, preventDefault as ch, prop as ci, stopPropagation as cj, stopPropagationAndPreventDefault as ck, typeAttr as cl, type HttpError as d, type Node as e, type ClipboardError as f, type DecodingError as g, type DownloadInput as h, isState as i, type Fragment as j, type Headers as k, type Path$1 as l, manageApplication as m, ResponseBody as n, ResultTransformer as o, permission as p, type Return as q, type ScrollElementError as r, type StorageTarget as s, toComponent as t, uuidFromString as u, type Suspend as v, alert as w, async as x, cancelTask as y, clearAppBadge as z };