foldkit-primitives 0.2.1 → 0.4.0

package/dist/interaction/index.d.mts

@@ -0,0 +1,1017 @@
+import { A as ScrollLock, C as targetOf, D as MoveStarted, E as MoveEnded, M as tabbableWithin, O as Moved, S as Targets, T as Move, _ as boxOf, a as TextEdited, b as TargetHovered, c as DRAG_THRESHOLD, d as DragFact, f as DragPlace, g as PointerDrag, h as DraggedOver, i as TextCommitted, j as FocusScope, k as HideOutside, l as DragCancelled, m as DragZone, n as EditableText, o as TextFact, p as DragStarted, r as TextCancelled, s as textOf, t as EditAsked, u as DragDropped, v as zoneOf, w as Fact$1, x as TargetPressed, y as TargetFact } from "../editable-text-CKkS_mWt.mjs";
+import { a as modalityOfKey, i as Modality, r as InputModalityModel, t as InputModality } from "../input-modality-DGOhAknO.mjs";
+import { Schema } from "effect";
+import * as Mount from "foldkit/mount";
+import { Bundle, Declared } from "foldkit-bundle";
+import { Behavior, Behaviors, SlotItem } from "foldkit-mixins";
+import { Attribute, Html, HtmlBuilder, KeyboardModifiers } from "foldkit/html";
+declare namespace dismiss_layer_d_exports {
+  export { BehaviorOptions$14 as BehaviorOptions, Dismiss, LAYER_ATTRIBUTE, Layer$1 as Layer, Message$9 as Message, Model$9 as Model, TRIGGER_ATTRIBUTE, behavior$14 as behavior, bundle$9 as bundle, layersOnPath, toDismiss };
+}
+declare const LAYER_ATTRIBUTE = "data-foldkit-plus-layer";
+declare const TRIGGER_ATTRIBUTE = "data-foldkit-plus-layer-trigger";
+/** An open layer as the document showed it: bottom to top is DOM order. */
+declare const Layer$1: Schema.Struct<{
+  readonly id: Schema.String;
+  /** Dismiss on a press outside it. */
+  readonly outside: Schema.Boolean;
+  /** Dismiss on Escape when topmost. */
+  readonly escape: Schema.Boolean;
+}>;
+type Layer$1 = typeof Layer$1.Type;
+declare const Model$9: Schema.Struct<{
+  /** The open layers at the last event, bottom to top. */
+  readonly layers: Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    /** Dismiss on a press outside it. */
+    readonly outside: Schema.Boolean;
+    /** Dismiss on Escape when topmost. */
+    readonly escape: Schema.Boolean;
+  }>>;
+}>;
+type Model$9 = typeof Model$9.Type;
+declare const Message$9: import("foldkit/message").MessageUnion<{
+  /** A pointer went down; `inside` are the layers whose element or trigger was on the event's path. */
+  readonly PressedAt: {
+    readonly layers: Schema.$Array<Schema.Struct<{
+      readonly id: Schema.String;
+      /** Dismiss on a press outside it. */
+      readonly outside: Schema.Boolean;
+      /** Dismiss on Escape when topmost. */
+      readonly escape: Schema.Boolean;
+    }>>;
+    readonly inside: Schema.$Array<Schema.String>;
+  };
+  readonly PressedEscape: {
+    readonly layers: Schema.$Array<Schema.Struct<{
+      readonly id: Schema.String;
+      /** Dismiss on a press outside it. */
+      readonly outside: Schema.Boolean;
+      /** Dismiss on Escape when topmost. */
+      readonly escape: Schema.Boolean;
+    }>>;
+  };
+}>;
+type Message$9 = typeof Message$9.Type;
+declare const Dismiss: Schema.TaggedStruct<"Dismiss", {
+  readonly ids: Schema.$Array<Schema.String>;
+}>;
+type Dismiss = typeof Dismiss.Type;
+/** Which layers a press inside `inside` dismisses: every layer above the topmost one hit, or all when none was. */
+declare const toDismiss: (layers: ReadonlyArray<Layer$1>, inside: ReadonlyArray<string>) => ReadonlyArray<string>;
+declare const bundle$9: Bundle.Bundle<"DismissLayer", void, {
+  readonly layers: readonly {
+    readonly id: string;
+    readonly outside: boolean;
+    readonly escape: boolean;
+  }[];
+}, {
+  readonly _tag: "PressedAt";
+  readonly layers: readonly {
+    readonly id: string;
+    readonly outside: boolean;
+    readonly escape: boolean;
+  }[];
+  readonly inside: readonly string[];
+} | {
+  readonly _tag: "PressedEscape";
+  readonly layers: readonly {
+    readonly id: string;
+    readonly outside: boolean;
+    readonly escape: boolean;
+  }[];
+}, {
+  readonly _tag: "Dismiss";
+  readonly ids: readonly string[];
+}, never, never, void, {}, {}>;
+/** The layer ids whose element or trigger is on the event's composed path. */
+declare const layersOnPath: (path: ReadonlyArray<EventTarget>) => ReadonlyArray<string>;
+interface BehaviorOptions$14<Input, Slots> {
+  /** The layer's root, rendered only while the layer is open. */
+  readonly layer: keyof Slots & string;
+  /** The element that opens the layer, so a press on it is inside. */
+  readonly trigger?: keyof Slots & string;
+  readonly id: (input: Input) => string;
+  /** Dismiss on a press outside. Default `true`. */
+  readonly outsidePress?: boolean;
+  /** Dismiss on Escape when topmost. Default `true`. */
+  readonly escape?: boolean;
+}
+/**
+ * Marks the layer's container and trigger for the placed stack. The layer
+ * takes part only while its element is rendered, so an `open` flag in the
+ * parent Model is the whole lifecycle. Not for an element with `popover`,
+ * which the browser dismisses itself.
+ */
+declare const behavior$14: <Field extends string>(_declared: Declared<typeof bundle$9, Field>) => <Slots>(slots: Slots) => <Input, ParentMessage>(options: BehaviorOptions$14<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace editable_text_d_exports {
+  export { BehaviorOptions$13 as BehaviorOptions, EditAsked, TextCancelled, TextCommitted, TextEdited, TextFact, behavior$13 as behavior, EditableText as mount, textOf };
+}
+interface BehaviorOptions$13<Slots, ParentMessage> {
+  /** The slot holding the fields. */
+  readonly container: keyof Slots & string;
+  /** The attribute that marks a field, holding its name. */
+  readonly attribute: string;
+  /** Turns each fact into the view's Message. */
+  readonly toMessage: (fact: TextFact) => ParentMessage;
+}
+declare const behavior$13: <Slots>(slots: Slots) => <Input, ParentMessage>(options: BehaviorOptions$13<Slots, ParentMessage>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace focus_scope_d_exports {
+  export { BehaviorOptions$12 as BehaviorOptions, behavior$12 as behavior, FocusScope as mount, tabbableWithin };
+}
+interface BehaviorOptions$12<Slots> {
+  readonly container: keyof Slots & string;
+  /** Keep Tab, Shift+Tab, and a stray focus inside. Default `true`. */
+  readonly contain?: boolean;
+  /** Give focus back to what had it when the container unmounts. Default `true`. */
+  readonly restore?: boolean;
+  /** A selector inside the container to focus first. */
+  readonly initialFocus?: string;
+}
+/**
+ * On insert the container focuses `initialFocus`, else its first tabbable
+ * descendant, else itself; with `contain`, Tab and Shift+Tab wrap inside and
+ * focus that lands outside comes back to the first tabbable; on unmount, with
+ * `restore`, focus returns to the element that had it. A dialog that is not
+ * a native `<dialog>`, a menu, or a command palette takes this.
+ */
+declare const behavior$12: <Slots>(slots: Slots) => <Input, ParentMessage>(options: BehaviorOptions$12<Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace focus_visible_d_exports {
+  export { BehaviorOptions$11 as BehaviorOptions, Modality, InputModalityModel as Model, behavior$11 as behavior, InputModality as bundle, modalityOfKey };
+}
+interface BehaviorOptions$11<Slots> {
+  readonly target: keyof Slots & string;
+}
+declare const behavior$11: <Field extends string>(declared: Declared<typeof InputModality, Field>) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: InputModalityModel; }, ParentMessage>(options: BehaviorOptions$11<Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace roving_tabindex_d_exports {
+  export { Args$8 as Args, BehaviorOptions$10 as BehaviorOptions, Direction, Message$8 as Message, Model$8 as Model, MoveOptions$1 as MoveOptions, Orientation, behavior$10 as behavior, bundle$8 as bundle, idSelector, itemAttributes, move$2 as move, tabStop$1 as tabStop };
+}
+declare const Orientation: Schema.Literals<readonly ["vertical", "horizontal", "both"]>;
+type Orientation = typeof Orientation.Type;
+declare const Model$8: Schema.Struct<{
+  /** The current item's id, or `null` before any item has been focused. */
+  readonly current: Schema.NullOr<Schema.String>;
+}>;
+type Model$8 = typeof Model$8.Type;
+declare const Message$8: import("foldkit/message").MessageUnion<{
+  /** An item became current: the user focused it, or a key moved there. */
+  readonly Focused: {
+    readonly id: Schema.String;
+  };
+}>;
+type Message$8 = typeof Message$8.Type;
+declare const Args$8: Schema.Struct<{
+  readonly orientation: Schema.Literals<readonly ["vertical", "horizontal", "both"]>;
+  /** Wrap from the last enabled item to the first, and back. */
+  readonly loop: Schema.Boolean;
+  /** Keep DOM focus on the container and point at the current item with
+   *  `aria-activedescendant` instead of moving focus. */
+  readonly virtual: Schema.Boolean;
+}>;
+type Args$8 = typeof Args$8.Type;
+declare const bundle$8: Bundle.Bundle<"RovingTabindex", {
+  readonly orientation: "vertical" | "horizontal" | "both";
+  readonly loop: boolean;
+  readonly virtual: boolean;
+}, {
+  readonly current: string | null;
+}, {
+  readonly _tag: "Focused";
+  readonly id: string;
+}, never, never, never, void, {}, {}>;
+type Direction = 'ltr' | 'rtl';
+interface MoveOptions$1 {
+  readonly orientation: Orientation;
+  readonly loop: boolean;
+  readonly direction: Direction;
+  /** How many enabled items PageUp and PageDown move; absent, they are not handled. */
+  readonly page?: number;
+}
+/**
+ * The index the key moves to from `current`, over the enabled indices only, or
+ * `undefined` when the key is not a navigation key here. `current` may be
+ * `-1` (nothing current yet): arrows then land on the first or last enabled
+ * item. Under `rtl`, left and right swap. PageUp and PageDown move by `page`
+ * and clamp at the ends, never wrapping.
+ */
+declare const move$2: (enabled: ReadonlyArray<number>, current: number, key: string, modifiers: KeyboardModifiers, options: MoveOptions$1) => number | undefined;
+/** The item that holds the tab stop: the current one, else the first enabled. */
+declare const tabStop$1: (items: Behaviors.Collection.Items<unknown>, current: string | null) => number;
+interface BehaviorOptions$10<Input, Slots> {
+  /** The slot that receives the arrow keys. */
+  readonly container: keyof Slots & string;
+  /** The slot rendered once per item; must carry the item's id (see `Behaviors.Collection`). */
+  readonly item: keyof Slots & string;
+  readonly items: (input: Input) => Behaviors.Collection.Items<unknown>;
+  /** Default `'ltr'`; return `'rtl'` to swap left and right. */
+  readonly direction?: (input: Input) => Direction;
+}
+/** A selector for an element by id, safe for any id. */
+declare const idSelector: (id: string) => string;
+/**
+ * The attributes one item gets: `tabindex` 0 when it holds the tab stop and
+ * -1 otherwise (none under `virtual`), and `OnFocus` reporting it current.
+ * Shared with `ListNavigation`.
+ */
+declare const itemAttributes: <ParentMessage>(h: HtmlBuilder<ParentMessage>, items: Behaviors.Collection.Items<unknown>, current: string | null, item: SlotItem, virtual: boolean, focused: (id: string) => ParentMessage) => ReadonlyArray<Attribute<ParentMessage>>;
+/**
+ * Wires a placed `RovingTabindex` to the slots: the container's arrow, Home
+ * and End keys focus the next item (synchronously, then dispatch), each item
+ * gets `tabindex` 0 or -1 and reports `Focused` when focused. Under `virtual`
+ * DOM focus never leaves the container: the key only dispatches, the
+ * container carries `aria-activedescendant`, and items keep no `tabindex`.
+ *
+ * Every handled key is default-prevented. Nothing is written on dispose: the
+ * attributes are data, so a view that no longer attaches this leaves no
+ * `tabindex` behind.
+ */
+declare const behavior$10: <Field extends string>(declared: Declared<typeof bundle$8, Field>, args: Args$8) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$8; }, ParentMessage>(options: BehaviorOptions$10<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace grid_navigation_d_exports {
+  export { Args$7 as Args, BehaviorOptions$9 as BehaviorOptions, Message$7 as Message, Model$7 as Model, MoveOptions, behavior$9 as behavior, bundle$7 as bundle, move$1 as move };
+}
+declare const Model$7: Schema.Struct<{
+  /** The current cell's id, or `null` before any cell has been focused. */
+  readonly current: Schema.NullOr<Schema.String>;
+}>;
+type Model$7 = typeof Model$7.Type;
+declare const Message$7: import("foldkit/message").MessageUnion<{
+  /** A cell became current: the user focused it, or a key moved there. */
+  readonly Focused: {
+    readonly id: Schema.String;
+  };
+}>;
+type Message$7 = typeof Message$7.Type;
+declare const Args$7: Schema.Struct<{
+  /** Cells per row; the last row may be short. */
+  readonly columns: Schema.Number;
+  /** Left and right continue into the previous and next row; up and down
+   *  continue into the previous and next column. Off, they stop at the edge. */
+  readonly wrap: Schema.Boolean;
+  /** Keep DOM focus on the container and point at the current cell with
+   *  `aria-activedescendant` instead of moving focus. */
+  readonly virtual: Schema.Boolean;
+}>;
+type Args$7 = typeof Args$7.Type;
+declare const bundle$7: Bundle.Bundle<"GridNavigation", {
+  readonly columns: number;
+  readonly wrap: boolean;
+  readonly virtual: boolean;
+}, {
+  readonly current: string | null;
+}, {
+  readonly _tag: "Focused";
+  readonly id: string;
+}, never, never, never, void, {}, {}>;
+interface MoveOptions {
+  readonly columns: number;
+  readonly wrap: boolean;
+  readonly direction: Direction;
+}
+/**
+ * The index the key moves to from `current` over a grid of `count` cells in
+ * rows of `columns`, skipping cells not in `enabled`, or `undefined` when the
+ * key is not a grid key. Left and right step within the row, and across rows
+ * under `wrap`; up and down step within the column, and across columns under
+ * `wrap`. Home and End are the row's first and last enabled cell; with Ctrl
+ * they are the grid's. At an edge without `wrap` the key is consumed and
+ * `current` is returned. From `-1` (nothing current) a forward key lands on
+ * the first enabled cell and a backward key on the last. Under `rtl`, left
+ * and right swap.
+ */
+declare const move$1: (enabled: ReadonlyArray<number>, count: number, current: number, key: string, modifiers: KeyboardModifiers, options: MoveOptions) => number | undefined;
+interface BehaviorOptions$9<Input, Slots> {
+  /** The slot that receives the arrow keys. */
+  readonly container: keyof Slots & string;
+  /** The slot rendered once per cell; must carry the cell's id (see `Behaviors.Collection`). */
+  readonly item: keyof Slots & string;
+  readonly items: (input: Input) => Behaviors.Collection.Items<unknown>;
+  /** Default `'ltr'`; return `'rtl'` to swap left and right. */
+  readonly direction?: (input: Input) => Direction;
+}
+/**
+ * Wires a placed `GridNavigation` to the slots exactly as `RovingTabindex`
+ * does, with `move` above deciding the cell: the container's arrows, Home and
+ * End focus the next cell (synchronously, then dispatch) or, under `virtual`,
+ * only dispatch and point with `aria-activedescendant`; each cell gets
+ * `tabindex` 0 or -1 and reports `Focused` when focused.
+ */
+declare const behavior$9: <Field extends string>(declared: Declared<typeof bundle$7, Field>, args: Args$7) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$7; }, ParentMessage>(options: BehaviorOptions$9<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace layers_d_exports {
+  export { hideOutside, HideOutside as hideOutsideMount, scrollLock, ScrollLock as scrollLockMount };
+}
+/** Locks the document's scroll while the container is mounted; nested locks release together. */
+declare const scrollLock: <Slots>(slots: Slots) => <Input, ParentMessage>(options: {
+  readonly container: keyof Slots & string;
+}) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+/** Marks everything outside the container inert while it is mounted. */
+declare const hideOutside: <Slots>(slots: Slots) => <Input, ParentMessage>(options: {
+  readonly container: keyof Slots & string;
+}) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace live_announce_d_exports {
+  export { Args$6 as Args, Message$6 as Message, Model$6 as Model, Politeness, REGION_ATTRIBUTE, bundle$6 as bundle, reread, say, view };
+}
+declare const Politeness: Schema.Literals<readonly ["polite", "assertive"]>;
+type Politeness = typeof Politeness.Type;
+declare const Model$6: Schema.Struct<{
+  readonly polite: Schema.String;
+  readonly assertive: Schema.String;
+  /** Waiting for the debounce to read. */
+  readonly pending: Schema.NullOr<Schema.Struct<{
+    readonly message: Schema.String;
+    readonly politeness: Schema.Literals<readonly ["polite", "assertive"]>;
+  }>>;
+  readonly generation: Schema.Number;
+}>;
+type Model$6 = typeof Model$6.Type;
+declare const Message$6: import("foldkit/message").MessageUnion<{
+  readonly Announced: {
+    readonly message: Schema.String;
+    readonly politeness: Schema.Literals<readonly ["polite", "assertive"]>;
+  };
+  readonly Read: {
+    readonly generation: Schema.Number;
+  };
+  readonly Cleared: {
+    readonly generation: Schema.Number;
+  };
+}>;
+type Message$6 = typeof Message$6.Type;
+declare const Args$6: Schema.Struct<{
+  /** A burst of announcements inside this window reads once, the last one. */
+  readonly debounceMs: Schema.Number;
+  /** How long the text stays in the region. */
+  readonly clearAfterMs: Schema.Number;
+}>;
+type Args$6 = typeof Args$6.Type;
+/** The text to put in the region so that `next` is read even when it equals `current`. */
+declare const reread: (current: string, next: string) => string;
+declare const bundle$6: Bundle.Bundle<"LiveAnnounce", {
+  readonly debounceMs: number;
+  readonly clearAfterMs: number;
+}, {
+  readonly polite: string;
+  readonly assertive: string;
+  readonly pending: {
+    readonly message: string;
+    readonly politeness: "polite" | "assertive";
+  } | null;
+  readonly generation: number;
+}, {
+  readonly _tag: "Cleared";
+  readonly generation: number;
+} | {
+  readonly _tag: "Announced";
+  readonly message: string;
+  readonly politeness: "polite" | "assertive";
+} | {
+  readonly _tag: "Read";
+  readonly generation: number;
+}, never, never, never, void, {}, {}>;
+/** The parent Message that announces `text`, to return from `update` or `onOut`. */
+declare const say: <Field extends string>(declared: Declared<typeof bundle$6, Field>) => <ParentMessage>(text: string, politeness?: Politeness) => ParentMessage;
+declare const REGION_ATTRIBUTE = "data-foldkit-plus-live";
+/**
+ * The two live regions. Render once, anywhere in the page, and hide them
+ * visually with a rule on `[data-foldkit-plus-live]`; they must stay in the
+ * accessibility tree, so no `display: none`.
+ */
+declare const view: <ParentMessage>(model: Model$6, h: HtmlBuilder<ParentMessage>) => Html;
+declare namespace list_navigation_d_exports {
+  export { Args$5 as Args, BehaviorOptions$8 as BehaviorOptions, KeyOutcome, Message$5 as Message, Model$5 as Model, behavior$8 as behavior, bundle$5 as bundle, keyOutcome };
+}
+declare const Model$5: Schema.Struct<{
+  readonly current: Schema.NullOr<Schema.String>;
+  readonly query: Schema.String;
+  readonly generation: Schema.Number;
+}>;
+type Model$5 = typeof Model$5.Type;
+declare const Message$5: import("foldkit/message").MessageUnion<{
+  /** An item became current: focused, or reached by a key. */
+  readonly Focused: {
+    readonly id: Schema.String;
+  };
+  /** A printable key extended the query; `match` is the item it now picks, if any. */
+  readonly Typed: {
+    readonly char: Schema.String;
+    readonly match: Schema.NullOr<Schema.String>;
+  };
+  readonly Expired: {
+    readonly generation: Schema.Number;
+  };
+  readonly Cleared: {};
+}>;
+type Message$5 = typeof Message$5.Type;
+declare const Args$5: Schema.Struct<{
+  readonly orientation: Schema.Literals<readonly ["vertical", "horizontal", "both"]>;
+  readonly loop: Schema.Boolean;
+  readonly virtual: Schema.Boolean;
+  /** How long the typeahead query survives after the last key. */
+  readonly timeoutMs: Schema.Number;
+  /** How many enabled items PageUp and PageDown move. */
+  readonly page: Schema.Number;
+}>;
+type Args$5 = typeof Args$5.Type;
+declare const bundle$5: Bundle.Bundle<"ListNavigation", {
+  readonly orientation: "vertical" | "horizontal" | "both";
+  readonly loop: boolean;
+  readonly virtual: boolean;
+  readonly timeoutMs: number;
+  readonly page: number;
+}, {
+  readonly current: string | null;
+  readonly query: string;
+  readonly generation: number;
+}, {
+  readonly _tag: "Cleared";
+} | {
+  readonly _tag: "Typed";
+  readonly char: string;
+  readonly match: string | null;
+} | {
+  readonly _tag: "Expired";
+  readonly generation: number;
+} | {
+  readonly _tag: "Focused";
+  readonly id: string;
+}, never, never, never, void, {}, {}>;
+interface BehaviorOptions$8<Input, Slots> {
+  readonly container: keyof Slots & string;
+  /** The slot rendered once per item; must carry the item's id (see `Behaviors.Collection`). */
+  readonly item: keyof Slots & string;
+  readonly items: (input: Input) => Behaviors.Collection.Items<unknown>;
+  /** The text an item is matched by when typing. */
+  readonly text: (input: Input, index: number) => string;
+  readonly direction?: (input: Input) => Direction;
+}
+/**
+ * The key's outcome, before it is turned into an attribute: navigation to an
+ * id, a typed character with its match, or nothing.
+ */
+type KeyOutcome = {
+  readonly _tag: 'Navigate';
+  readonly id: string;
+} | {
+  readonly _tag: 'Type';
+  readonly char: string;
+  readonly match: string | null;
+};
+declare const keyOutcome: (items: Behaviors.Collection.Items<unknown>, texts: ReadonlyArray<string>, state: {
+  readonly current: string | null;
+  readonly query: string;
+}, key: string, modifiers: KeyboardModifiers, options: MoveOptions$1) => KeyOutcome | undefined;
+/**
+ * Wires a placed `ListNavigation` to the slots. The container gets one key
+ * handler: arrows, Home, End, PageUp and PageDown move by id; a printable key
+ * extends the query and moves to its match. Each item gets `tabindex` and
+ * `OnFocus` as under `RovingTabindex`. Under `virtual` nothing takes DOM focus
+ * and the container carries `aria-activedescendant`.
+ */
+declare const behavior$8: <Field extends string>(declared: Declared<typeof bundle$5, Field>, args: Args$5) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$5; }, ParentMessage>(options: BehaviorOptions$8<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace long_press_d_exports {
+  export { Args$4 as Args, BehaviorOptions$7 as BehaviorOptions, LongPressed, Message$4 as Message, Model$4 as Model, behavior$7 as behavior, bundle$4 as bundle };
+}
+declare const Model$4: Schema.Struct<{
+  /** Down, and the threshold has not passed. */
+  readonly holding: Schema.Boolean;
+  readonly pointerId: Schema.NullOr<Schema.Number>;
+  readonly key: Schema.NullOr<Schema.String>;
+  readonly generation: Schema.Number;
+}>;
+type Model$4 = typeof Model$4.Type;
+declare const Message$4: import("foldkit/message").MessageUnion<{
+  readonly PointerDown: {
+    readonly pointerId: Schema.Number;
+    readonly button: Schema.Number;
+    readonly pointerType: Schema.String;
+  };
+  readonly PointerUp: {
+    readonly pointerId: Schema.Number;
+    readonly pointerType: Schema.String;
+    readonly shiftKey: Schema.Boolean;
+  };
+  readonly PointerCancelled: {
+    readonly pointerId: Schema.Number;
+  };
+  readonly KeyDown: {
+    readonly key: Schema.String;
+    readonly repeat: Schema.Boolean;
+  };
+  readonly KeyUp: {
+    readonly key: Schema.String;
+    readonly shiftKey: Schema.Boolean;
+  };
+  readonly Clicked: {
+    readonly detail: Schema.Number;
+    readonly shiftKey: Schema.Boolean;
+  };
+  readonly Elapsed: {
+    readonly generation: Schema.Number;
+    readonly pointerType: Schema.Literals<readonly ["mouse", "touch", "pen", "keyboard", "virtual"]>;
+  };
+}>;
+type Message$4 = typeof Message$4.Type;
+declare const LongPressed: Schema.TaggedStruct<"LongPressed", {
+  readonly pointerType: Schema.Literals<readonly ["mouse", "touch", "pen", "keyboard", "virtual"]>;
+}>;
+type LongPressed = typeof LongPressed.Type;
+declare const Args$4: Schema.Struct<{
+  readonly thresholdMs: Schema.Number;
+}>;
+type Args$4 = typeof Args$4.Type;
+declare const bundle$4: Bundle.Bundle<"LongPress", {
+  readonly thresholdMs: number;
+}, {
+  readonly holding: boolean;
+  readonly pointerId: number | null;
+  readonly key: string | null;
+  readonly generation: number;
+}, {
+  readonly _tag: "PointerDown";
+  readonly pointerId: number;
+  readonly button: number;
+  readonly pointerType: string;
+} | {
+  readonly _tag: "PointerUp";
+  readonly pointerId: number;
+  readonly pointerType: string;
+  readonly shiftKey: boolean;
+} | {
+  readonly _tag: "PointerCancelled";
+  readonly pointerId: number;
+} | {
+  readonly _tag: "KeyDown";
+  readonly key: string;
+  readonly repeat: boolean;
+} | {
+  readonly _tag: "KeyUp";
+  readonly key: string;
+  readonly shiftKey: boolean;
+} | {
+  readonly _tag: "Clicked";
+  readonly detail: number;
+  readonly shiftKey: boolean;
+} | {
+  readonly _tag: "Elapsed";
+  readonly generation: number;
+  readonly pointerType: "keyboard" | "virtual" | "mouse" | "touch" | "pen";
+}, {
+  readonly _tag: "LongPressed";
+  readonly pointerType: "keyboard" | "virtual" | "mouse" | "touch" | "pen";
+}, never, never, void, {}, {}>;
+interface BehaviorOptions$7<Slots> {
+  readonly target: keyof Slots & string;
+}
+/**
+ * Attaches `Press.events` to the target, mapped into this placement's
+ * Messages, and writes `data-holding` while the element is down. `Press` and
+ * `LongPress` on one slot are refused by the resolver (two Mounts of one
+ * name), so today a slot takes one of them.
+ */
+declare const behavior$7: <Field extends string>(declared: Declared<typeof bundle$4, Field>) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$4; }, ParentMessage>(options: BehaviorOptions$7<Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace move_d_exports {
+  export { BehaviorOptions$6 as BehaviorOptions, Fact$1 as Fact, MoveEnded, MoveStarted, Moved, behavior$6 as behavior, Move as mount };
+}
+interface BehaviorOptions$6<Slots, ParentMessage> {
+  readonly handle: keyof Slots & string;
+  /** Turns each fact into the view's Message. */
+  readonly toMessage: (fact: Fact$1) => ParentMessage;
+}
+declare const behavior$6: <Slots>(slots: Slots) => <Input, ParentMessage>(options: BehaviorOptions$6<Slots, ParentMessage>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace press_d_exports {
+  export { Args$3 as Args, BehaviorOptions$5 as BehaviorOptions, Fact, Message$3 as Message, Model$3 as Model, PointerType, Pressed, behavior$5 as behavior, bundle$3 as bundle, events };
+}
+declare const PointerType: Schema.Literals<readonly ["mouse", "touch", "pen", "keyboard", "virtual"]>;
+type PointerType = typeof PointerType.Type;
+declare const Model$3: Schema.Struct<{
+  /** Down and not yet released or cancelled. For styling. */
+  readonly pressed: Schema.Boolean;
+  /** The pointer that pressed, so another pointer's up cannot release it. */
+  readonly pointerId: Schema.NullOr<Schema.Number>;
+  /** Enter or Space is down. */
+  readonly key: Schema.NullOr<Schema.String>;
+  /** A click arriving before this generation's window ends is the ghost of a pointer press. */
+  readonly suppressing: Schema.NullOr<Schema.Number>;
+  readonly generation: Schema.Number;
+}>;
+type Model$3 = typeof Model$3.Type;
+declare const Message$3: import("foldkit/message").MessageUnion<{
+  readonly PointerDown: {
+    readonly pointerId: Schema.Number;
+    readonly button: Schema.Number;
+    readonly pointerType: Schema.String;
+  };
+  readonly PointerUp: {
+    readonly pointerId: Schema.Number;
+    readonly pointerType: Schema.String;
+    readonly shiftKey: Schema.Boolean;
+  };
+  readonly PointerCancelled: {
+    readonly pointerId: Schema.Number;
+  };
+  readonly KeyDown: {
+    readonly key: Schema.String;
+    readonly repeat: Schema.Boolean;
+  };
+  readonly KeyUp: {
+    readonly key: Schema.String;
+    readonly shiftKey: Schema.Boolean;
+  };
+  /** `detail` is 0 for a click no pointer made: keyboard on a native control, or assistive technology. */
+  readonly Clicked: {
+    readonly detail: Schema.Number;
+    readonly shiftKey: Schema.Boolean;
+  };
+  readonly Unsuppressed: {
+    readonly generation: Schema.Number;
+  };
+}>;
+type Message$3 = typeof Message$3.Type;
+declare const Pressed: Schema.TaggedStruct<"Pressed", {
+  readonly pointerType: Schema.Literals<readonly ["mouse", "touch", "pen", "keyboard", "virtual"]>;
+  /** Shift was held, for a range selection. */
+  readonly shiftKey: Schema.Boolean;
+}>;
+type Pressed = typeof Pressed.Type;
+declare const Args$3: Schema.Struct<{
+  /** How long after a pointer press a `click` is taken for its ghost. */
+  readonly clickSuppressionMs: Schema.Number;
+}>;
+type Args$3 = typeof Args$3.Type;
+declare const bundle$3: Bundle.Bundle<"Press", {
+  readonly clickSuppressionMs: number;
+}, {
+  readonly pressed: boolean;
+  readonly pointerId: number | null;
+  readonly key: string | null;
+  readonly suppressing: number | null;
+  readonly generation: number;
+}, {
+  readonly _tag: "PointerDown";
+  readonly pointerId: number;
+  readonly button: number;
+  readonly pointerType: string;
+} | {
+  readonly _tag: "PointerUp";
+  readonly pointerId: number;
+  readonly pointerType: string;
+  readonly shiftKey: boolean;
+} | {
+  readonly _tag: "PointerCancelled";
+  readonly pointerId: number;
+} | {
+  readonly _tag: "KeyDown";
+  readonly key: string;
+  readonly repeat: boolean;
+} | {
+  readonly _tag: "KeyUp";
+  readonly key: string;
+  readonly shiftKey: boolean;
+} | {
+  readonly _tag: "Clicked";
+  readonly detail: number;
+  readonly shiftKey: boolean;
+} | {
+  readonly _tag: "Unsuppressed";
+  readonly generation: number;
+}, {
+  readonly _tag: "Pressed";
+  readonly pointerType: "keyboard" | "virtual" | "mouse" | "touch" | "pen";
+  readonly shiftKey: boolean;
+}, never, never, void, {}, {}>;
+/** What the element reports; `Unsuppressed` comes from the timer, not the DOM. */
+type Fact = Exclude<Message$3, {
+  readonly _tag: 'Unsuppressed';
+}>;
+/**
+ * The element's press-relevant events as facts. Enter and Space key downs
+ * are default-prevented so a native control does not also click, and Space
+ * does not scroll; the Bundle owns activation. An element marked
+ * `aria-disabled="true"` (which the Behavior writes) reports nothing, read
+ * at event time so a toggle needs no remount. Nothing else is decided here.
+ */
+declare const events: Mount.MountDefinitionNoArgs<"PressEvents", {
+  readonly _tag: "PointerDown";
+  readonly pointerId: number;
+  readonly button: number;
+  readonly pointerType: string;
+} | {
+  readonly _tag: "PointerUp";
+  readonly pointerId: number;
+  readonly pointerType: string;
+  readonly shiftKey: boolean;
+} | {
+  readonly _tag: "PointerCancelled";
+  readonly pointerId: number;
+} | {
+  readonly _tag: "KeyDown";
+  readonly key: string;
+  readonly repeat: boolean;
+} | {
+  readonly _tag: "KeyUp";
+  readonly key: string;
+  readonly shiftKey: boolean;
+} | {
+  readonly _tag: "Clicked";
+  readonly detail: number;
+  readonly shiftKey: boolean;
+}>;
+interface BehaviorOptions$5<Input, Slots> {
+  readonly target: keyof Slots & string;
+  /** Marks the target `aria-disabled`, which also silences its events. */
+  readonly disabled?: (input: Input) => boolean;
+}
+/**
+ * Attaches the events Mount to the target slot, mapped into the placement's
+ * Messages, and writes `data-pressed` while down for styling. The element
+ * decides nothing; a click, a touch, Enter, Space, or an assistive
+ * technology's click all reach `update` and come out as one `Pressed`.
+ */
+declare const behavior$5: <Field extends string>(declared: Declared<typeof bundle$3, Field>) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$3; }, ParentMessage>(options: BehaviorOptions$5<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace selection_d_exports {
+  export { Args$2 as Args, BehaviorOptions$4 as BehaviorOptions, Message$2 as Message, Mode, Model$2 as Model, behavior$4 as behavior, between, bundle$2 as bundle };
+}
+declare const Mode: Schema.Literals<readonly ["single", "multiple", "none"]>;
+type Mode = typeof Mode.Type;
+declare const Model$2: Schema.Struct<{
+  /** In selection order. */
+  readonly selected: Schema.$Array<Schema.String>;
+  /** Where the last plain selection happened; a range extends from it. */
+  readonly anchor: Schema.NullOr<Schema.String>;
+}>;
+type Model$2 = typeof Model$2.Type;
+declare const Message$2: import("foldkit/message").MessageUnion<{
+  /** A plain activation: replaces in single mode, toggles in multiple mode. */
+  readonly Activated: {
+    readonly id: Schema.String;
+  };
+  /** A Shift activation: selects everything between the anchor and `id` in `order`. */
+  readonly Ranged: {
+    readonly id: Schema.String;
+    readonly order: Schema.$Array<Schema.String>;
+  };
+  readonly Replaced: {
+    readonly ids: Schema.$Array<Schema.String>;
+  };
+  readonly Cleared: {};
+}>;
+type Message$2 = typeof Message$2.Type;
+declare const Args$2: Schema.Struct<{
+  readonly mode: Schema.Literals<readonly ["single", "multiple", "none"]>;
+  /** In single mode, whether activating the selected item deselects it. */
+  readonly allowEmpty: Schema.Boolean;
+}>;
+type Args$2 = typeof Args$2.Type;
+/** The ids between `from` and `to` in `order`, inclusive, in `order`'s order. */
+declare const between: (order: ReadonlyArray<string>, from: string | null, to: string) => ReadonlyArray<string>;
+declare const bundle$2: Bundle.Bundle<"Selection", {
+  readonly mode: "single" | "multiple" | "none";
+  readonly allowEmpty: boolean;
+}, {
+  readonly selected: readonly string[];
+  readonly anchor: string | null;
+}, {
+  readonly _tag: "Cleared";
+} | {
+  readonly _tag: "Activated";
+  readonly id: string;
+} | {
+  readonly _tag: "Ranged";
+  readonly id: string;
+  readonly order: readonly string[];
+} | {
+  readonly _tag: "Replaced";
+  readonly ids: readonly string[];
+}, never, never, never, void, {}, {}>;
+interface BehaviorOptions$4<Input, Slots> {
+  /** The slot holding the items, for `aria-multiselectable`. */
+  readonly container?: keyof Slots & string;
+  /** The slot rendered once per item; must carry the item's id. */
+  readonly item: keyof Slots & string;
+  readonly items: (input: Input) => Behaviors.Collection.Items<unknown>;
+  /** Wire a plain click on each item to `Activated`. Default `true`; turn off
+   *  when `Press` or the view owns the click. */
+  readonly click?: boolean;
+}
+/**
+ * Writes `aria-selected` on each item from the placed slice, and
+ * `aria-multiselectable` on the container in multiple mode; wires `OnClick`
+ * to `Activated` unless told not to. A disabled item gets no click.
+ */
+declare const behavior$4: <Field extends string>(declared: Declared<typeof bundle$2, Field>, args: Args$2) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$2; }, ParentMessage>(options: BehaviorOptions$4<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace targets_d_exports {
+  export { BehaviorOptions$3 as BehaviorOptions, TargetFact, TargetHovered, TargetPressed, behavior$3 as behavior, Targets as mount, targetOf };
+}
+interface BehaviorOptions$3<Slots, ParentMessage> {
+  /** The slot holding the marked descendants. */
+  readonly container: keyof Slots & string;
+  /** The attribute that marks a descendant, holding its id. */
+  readonly attribute: string;
+  /** Prevent a press's default, such as a link navigating. Default `false`. */
+  readonly preventDefault?: boolean;
+  /** Turns each fact into the view's Message. */
+  readonly toMessage: (fact: TargetFact) => ParentMessage;
+}
+declare const behavior$3: <Slots>(slots: Slots) => <Input, ParentMessage>(options: BehaviorOptions$3<Slots, ParentMessage>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace pointer_drag_d_exports {
+  export { BehaviorOptions$2 as BehaviorOptions, DRAG_THRESHOLD, DragCancelled, DragDropped, DragFact, DragPlace, DragStarted, DragZone, DraggedOver, behavior$2 as behavior, boxOf, PointerDrag as mount, zoneOf };
+}
+interface BehaviorOptions$2<Slots, ParentMessage> {
+  /** The slot holding the marked descendants. */
+  readonly container: keyof Slots & string;
+  /** The attribute that marks a descendant, holding its id. */
+  readonly attribute: string;
+  /**
+   * Where a drag may land when not among the container's own: elements marked
+   * by `attribute` inside the one `within` selects, such as a page for a palette.
+   */
+  readonly targets?: {
+    readonly attribute: string;
+    readonly within: string;
+  };
+  /** Turns each fact into the view's Message. */
+  readonly toMessage: (fact: DragFact) => ParentMessage;
+}
+declare const behavior$2: <Slots>(slots: Slots) => <Input, ParentMessage>(options: BehaviorOptions$2<Slots, ParentMessage>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace tree_navigation_d_exports {
+  export { Action, Args$1 as Args, BehaviorOptions$1 as BehaviorOptions, Message$1 as Message, Model$1 as Model, Row, Shown, behavior$1 as behavior, bundle$1 as bundle, isOpen, move, shown, tabStop };
+}
+declare const Model$1: Schema.Struct<{
+  /** The current row's id, or `null` before any row has been focused. */
+  readonly current: Schema.NullOr<Schema.String>;
+  /** The rows whose open state differs from `openByDefault`. */
+  readonly toggled: Schema.$Array<Schema.String>;
+}>;
+type Model$1 = typeof Model$1.Type;
+declare const Message$1: import("foldkit/message").MessageUnion<{
+  /** A row became current: the user focused it, or a key moved there. */
+  readonly Focused: {
+    readonly id: Schema.String;
+  };
+  readonly Opened: {
+    readonly id: Schema.String;
+  };
+  readonly Closed: {
+    readonly id: Schema.String;
+  };
+}>;
+type Message$1 = typeof Message$1.Type;
+declare const Args$1: Schema.Struct<{
+  /** Whether a row with children starts open. */
+  readonly openByDefault: Schema.Boolean;
+}>;
+type Args$1 = typeof Args$1.Type;
+/** Whether a row is open, given the default and what was toggled. */
+declare const isOpen: (model: Model$1, args: Args$1, id: string) => boolean;
+declare const bundle$1: Bundle.Bundle<"TreeNavigation", {
+  readonly openByDefault: boolean;
+}, {
+  readonly current: string | null;
+  readonly toggled: readonly string[];
+}, {
+  readonly _tag: "Focused";
+  readonly id: string;
+} | {
+  readonly _tag: "Opened";
+  readonly id: string;
+} | {
+  readonly _tag: "Closed";
+  readonly id: string;
+}, never, never, never, void, {}, {}>;
+/** One row of the tree, in tree order: a parent comes before its children. */
+interface Row {
+  readonly id: string;
+  /** The parent's id, or `null` for a top-level row. */
+  readonly parent: string | null;
+  /** Whether it has children, so it can be opened and closed. */
+  readonly branch: boolean;
+  readonly disabled?: boolean;
+}
+/** A row as it is showing: where it sits, for its ARIA attributes. */
+interface Shown extends Row {
+  /** 1 for a top-level row. */
+  readonly level: number;
+  /** Its place among its siblings, from 1, and how many there are. */
+  readonly position: number;
+  readonly siblings: number;
+}
+/**
+ * The rows that are showing: every row whose ancestors are all open, with its
+ * level and its place among its siblings. A row whose parent is not a row is
+ * treated as top-level.
+ */
+declare const shown: (rows: ReadonlyArray<Row>, model: Model$1, args: Args$1) => ReadonlyArray<Shown>;
+/** What a key does: move to a row, or open or close one. */
+type Action = {
+  readonly _tag: 'Focus';
+  readonly id: string;
+} | {
+  readonly _tag: 'Open';
+  readonly id: string;
+} | {
+  readonly _tag: 'Close';
+  readonly id: string;
+};
+/**
+ * What a key does from the current row, over the rows that are showing, or
+ * `undefined` when it is not a key the tree handles. Disabled rows are stepped
+ * over. With nothing current, Down and Home land on the first row, Up and End
+ * on the last. Right and Left swap under `rtl`.
+ */
+declare const move: (rows: ReadonlyArray<Shown>, current: string | null, key: string, modifiers: KeyboardModifiers, model: Model$1, args: Args$1, direction?: "ltr" | "rtl") => Action | undefined;
+/** The row that holds the tab stop: the current one while it is showing, else the first. */
+declare const tabStop: (rows: ReadonlyArray<Shown>, current: string | null) => string | undefined;
+interface BehaviorOptions$1<Input, Slots> {
+  /** The slot that receives the keys: the element with `role="tree"`. */
+  readonly container: keyof Slots & string;
+  /** The slot rendered once per showing row, with `item.id` or `item.index` into `shown`. */
+  readonly item: keyof Slots & string;
+  /** Every row, open or not, in tree order. */
+  readonly rows: (input: Input) => ReadonlyArray<Row>;
+  /** The DOM id a row's element carries. Default: the row's own id. */
+  readonly domId?: (id: string) => string;
+  readonly direction?: (input: Input) => 'ltr' | 'rtl';
+}
+/**
+ * Wires a placed `TreeNavigation` to the slots. The container's keys move focus
+ * to the row they pick, or open or close the current row with focus left where
+ * it is. Each showing row gets its id, `role="treeitem"`, `aria-level` (and
+ * the same level as `--fk-tree-level`, so one `calc` indents any depth),
+ * `aria-posinset`, `aria-setsize`, `aria-expanded` when it has children,
+ * `aria-disabled` when disabled, a roving `tabindex`, and `OnFocus` reporting
+ * it current. Every handled key is default-prevented.
+ */
+declare const behavior$1: <Field extends string>(declared: Declared<typeof bundle$1, Field>, args: Args$1) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model$1; }, ParentMessage>(options: BehaviorOptions$1<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+declare namespace typeahead_d_exports {
+  export { Args, BehaviorOptions, Message, Model, behavior, bundle, isPrintable, match };
+}
+declare const Model: Schema.Struct<{
+  readonly query: Schema.String;
+  /** Bumped per keystroke, carried by the clear it schedules, so a superseded
+   *  timer's `Expired` changes nothing. */
+  readonly generation: Schema.Number;
+}>;
+type Model = typeof Model.Type;
+declare const Message: import("foldkit/message").MessageUnion<{
+  /** A printable key was pressed with no ctrl, alt or meta. */
+  readonly Typed: {
+    readonly char: Schema.String;
+  };
+  /** The clear timer fired for `generation`. */
+  readonly Expired: {
+    readonly generation: Schema.Number;
+  };
+  /** The query was dropped on purpose (a blur, a selection). */
+  readonly Cleared: {};
+}>;
+type Message = typeof Message.Type;
+declare const Args: Schema.Struct<{
+  /** How long the query survives after the last key. */
+  readonly timeoutMs: Schema.Number;
+}>;
+type Args = typeof Args.Type;
+declare const bundle: Bundle.Bundle<"Typeahead", {
+  readonly timeoutMs: number;
+}, {
+  readonly query: string;
+  readonly generation: number;
+}, {
+  readonly _tag: "Typed";
+  readonly char: string;
+} | {
+  readonly _tag: "Expired";
+  readonly generation: number;
+} | {
+  readonly _tag: "Cleared";
+}, never, never, never, void, {}, {}>;
+/**
+ * The enabled index whose text starts with `query`, searching forward from
+ * `current` and wrapping, or `undefined`. A query of one character, or one
+ * character repeated (`aaa`), starts *after* the current item so repeated
+ * presses cycle through the items that begin with it; a longer query starts
+ * *at* the current item, since the user is refining a match. Case and leading
+ * whitespace are ignored.
+ */
+declare const match: (texts: ReadonlyArray<string>, enabled: ReadonlyArray<number>, query: string, current: number) => number | undefined;
+/** A single character with no ctrl, alt or meta: a typeahead key. */
+declare const isPrintable: (key: string, modifiers: KeyboardModifiers) => boolean;
+interface BehaviorOptions<Input, Slots> {
+  /** The slot that receives the keys. */
+  readonly host: keyof Slots & string;
+  readonly items: (input: Input) => Behaviors.Collection.Items<unknown>;
+  /** The text an item is matched by. */
+  readonly text: (input: Input, index: number) => string;
+  /** The current item's id, so the search starts from it; a placed
+   *  `RovingTabindex` is the usual source. */
+  readonly current: (input: Input) => string | null;
+}
+/**
+ * Wires a placed `Typeahead` to the host slot: a printable key extends the
+ * query, focuses the matching item by its id (which then reports itself
+ * current, through `RovingTabindex`'s `OnFocus`), and dispatches `Typed`.
+ * With no match the key still extends the query, so the next one can match;
+ * a space with an empty query is left to the host (it activates).
+ */
+declare const behavior: <Field extends string>(declared: Declared<typeof bundle, Field>) => <Slots>(slots: Slots) => <Input extends { readonly [K in Field]: Model; }, ParentMessage>(options: BehaviorOptions<Input, Slots>) => Behavior.NamedBehavior<Slots, Input, ParentMessage>;
+//#endregion
+export { dismiss_layer_d_exports as DismissLayer, editable_text_d_exports as EditableText, focus_scope_d_exports as FocusScope, focus_visible_d_exports as FocusVisible, grid_navigation_d_exports as GridNavigation, layers_d_exports as Layers, list_navigation_d_exports as ListNavigation, live_announce_d_exports as LiveAnnounce, long_press_d_exports as LongPress, move_d_exports as Move, pointer_drag_d_exports as PointerDrag, press_d_exports as Press, roving_tabindex_d_exports as RovingTabindex, selection_d_exports as Selection, targets_d_exports as Targets, tree_navigation_d_exports as TreeNavigation, typeahead_d_exports as Typeahead };
+//# sourceMappingURL=index.d.mts.map