@vuetify/v0 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/{index-BxKMMWnQ.d.mts → index-BfpLkDR_.d.mts}

@@ -1,12 +1,12 @@
-import { a as ID, i as Extensible, o as MaybeArray } from "./index-DuddF-NR.mjs";
-import { t as ContextTrinity } from "./index-DTvqw22G.mjs";
-import { b as RegistryTicket, c as TokenTicket, i as TokenContext, m as RegistryContext, o as TokenOptions, r as TokenCollection, x as RegistryTicketInput, y as RegistryOptions } from "./index-DE3bWw11.mjs";
-import { v as FilterMode } from "./adapter-DlX3FA3A.mjs";
-import { t as DateAdapter } from "./adapter-58IvIfAZ.mjs";
-import { n as FeaturesAdapterFlags, r as FeaturesAdapterInterface } from "./index-CT5SCLzW.mjs";
-import { t as LocaleAdapter } from "./adapter-BvWEd9w-.mjs";
-import { t as LoggerAdapter } from "./adapter-Dhq68tz0.mjs";
-import { t as StorageAdapter } from "./index-C6rdXZ7j.mjs";
+import { a as ID, i as Extensible, o as MaybeArray } from "./index-CLR1QMM3.mjs";
+import { t as ContextTrinity } from "./index-H_hl6-4b.mjs";
+import { b as RegistryTicket, c as TokenTicket, g as RegistryEventCallback, i as TokenContext, m as RegistryContext, o as TokenOptions, r as TokenCollection, v as RegistryEventName, x as RegistryTicketInput, y as RegistryOptions } from "./index-Cw04PFVO.mjs";
+import { _ as FilterMode } from "./adapter-Cr7Bl4la.mjs";
+import { t as DateAdapter } from "./adapter-Dzyrlbz7.mjs";
+import { n as FeaturesAdapterFlags, t as FeaturesAdapter } from "./adapter-C6JmOyYo.mjs";
+import { t as LocaleAdapter } from "./adapter-DgBBe_BW.mjs";
+import { t as LoggerAdapter } from "./adapter-o8r-2vUn.mjs";
+import { n as StorageAdapter } from "./memory-B0w39kno.mjs";
 import { App, ComponentPublicInstance, ComputedRef, InjectionKey, MaybeRef, MaybeRefOrGetter, Reactive, Ref, ShallowRef, UnwrapNestedRefs, WatchSource, WritableComputedRef } from "vue";
 
 //#region src/composables/createModel/index.d.ts
@@ -1479,12 +1479,12 @@ interface ComboboxAdapterResult {
   /** Whether no items match the current query */
   isEmpty: Ref<boolean>;
 }
-interface ComboboxAdapterInterface {
-  setup: (context: ComboboxAdapterContext) => ComboboxAdapterResult;
+declare abstract class ComboboxAdapter {
+  abstract setup(context: ComboboxAdapterContext): ComboboxAdapterResult;
 }
 //#endregion
 //#region src/composables/createCombobox/adapters/client.d.ts
-interface ClientAdapterOptions {
+interface ClientComboboxAdapterOptions {
   /** Filter matching mode */
   mode?: FilterMode;
   /** Object keys to match against (for object values) */
@@ -1492,14 +1492,14 @@ interface ClientAdapterOptions {
   /** Custom filter function — overrides default matching */
   filter?: (query: string, value: unknown) => boolean;
 }
-declare class ClientAdapter implements ComboboxAdapterInterface {
+declare class ClientComboboxAdapter extends ComboboxAdapter {
   private options;
-  constructor(options?: ClientAdapterOptions);
+  constructor(options?: ClientComboboxAdapterOptions);
   setup(context: ComboboxAdapterContext): ComboboxAdapterResult;
 }
 //#endregion
 //#region src/composables/createCombobox/adapters/server.d.ts
-declare class ServerAdapter implements ComboboxAdapterInterface {
+declare class ServerComboboxAdapter extends ComboboxAdapter {
   setup(context: ComboboxAdapterContext): ComboboxAdapterResult;
 }
 //#endregion
@@ -1511,7 +1511,7 @@ interface ComboboxOptions {
   strict?: MaybeRefOrGetter<boolean>;
   error?: MaybeRefOrGetter<boolean>;
   errorMessages?: MaybeRefOrGetter<MaybeArray<string> | undefined>;
-  adapter?: ComboboxAdapterInterface;
+  adapter?: ComboboxAdapter;
   displayValue?: (value: unknown) => string;
   id?: string;
   name?: string;
@@ -2117,6 +2117,471 @@ interface InputContext<T = string> {
 }
 declare function createInput<T = string>(options: InputOptions<T>): InputContext<T>;
 //#endregion
+//#region src/composables/createSortable/index.d.ts
+/**
+ * Input shape passed to `register` / `onboard`. Inherits all model fields.
+ *
+ * @template V Type of the per-ticket value.
+ *
+ * @example
+ * ```ts
+ * interface TaskTicket extends SortableTicketInput {
+ *   value: { id: number; label: string }
+ * }
+ *
+ * const sortable = createSortable<TaskTicket>()
+ * sortable.register({ value: { id: 1, label: 'A' } })
+ * ```
+ */
+type SortableTicketInput<V = unknown> = ModelTicketInput<V>;
+/**
+ * Output ticket returned by `register` / `onboard` / `get`.
+ * Aliased to `ModelTicket<Z>` — sortable adds no per-ticket fields.
+ *
+ * @template Z The input ticket type (carries the value type V).
+ */
+type SortableTicket<Z extends SortableTicketInput = SortableTicketInput> = ModelTicket<Z>;
+/**
+ * Options accepted by `createSortable`.
+ *
+ * @example
+ * ```ts
+ * const sortable = createSortable({
+ *   disabled: toRef(() => isReadOnlyMode.value),
+ * })
+ * ```
+ */
+interface SortableOptions extends Omit<ModelOptions, 'events'> {
+  /**
+   * Mutation gate. When truthy, `move` / `swap` / `reorder` silently no-op.
+   *
+   * @default false
+   * @remarks Per-ticket `disabled` is honored at the `move` and `swap` call sites
+   * for that ticket. `reorder` **bypasses** per-ticket `disabled` — it's a bulk
+   * operation declaring the canonical order, and applying that order may relocate
+   * disabled tickets. `register` / `onboard` / `unregister` are NEVER gated —
+   * those are composition, not user-driven reorder.
+   *
+   * @example
+   * ```ts
+   * const sortable = createSortable({ disabled: toRef(() => isSaving.value) })
+   * ```
+   */
+  disabled?: MaybeRefOrGetter<boolean>;
+}
+/**
+ * Payload of the `move:ticket` event.
+ *
+ * @example
+ * ```ts
+ * sortable.on('move:ticket', ({ ticket, from, to }) => {
+ *   console.log(ticket.id, from, to)
+ * })
+ * ```
+ */
+interface SortableMovePayload<E extends SortableTicket = SortableTicket> {
+  ticket: E;
+  from: number;
+  to: number;
+}
+/**
+ * Listener-binding signature for a sortable instance — a typed overload for
+ * `move:ticket` plus the registry's generic event channel.
+ *
+ * @template E Output ticket type.
+ */
+type SortableEventListener<E extends SortableTicket = SortableTicket> = {
+  (event: 'move:ticket', cb: (data: SortableMovePayload<E>) => void): void;
+  <K extends Extensible<RegistryEventName>>(event: K, cb: RegistryEventCallback<E, K>): void;
+};
+/**
+ * Public API of a sortable instance.
+ *
+ * @template Z Input ticket type.
+ * @template E Output ticket type.
+ */
+interface SortableContext<Z extends SortableTicketInput = SortableTicketInput, E extends SortableTicket<Z> = SortableTicket<Z>> extends Omit<ModelContext<Z, E>, 'on' | 'off' | 'move'> {
+  /**
+   * Subscribe to the typed `move:ticket` event with a strongly-typed payload.
+   *
+   * @example
+   * ```ts
+   * sortable.on('move:ticket', ({ ticket, from, to }) => {
+   *   console.log(ticket.id, from, to)
+   * })
+   * ```
+   */
+  on: SortableEventListener<E>;
+  /**
+   * Unsubscribe from a `move:ticket` listener. Must be called with the same callback reference used to subscribe.
+   *
+   * @example
+   * ```ts
+   * function onMove ({ ticket, from, to }: SortableMovePayload) {
+   *   console.log(ticket.id, from, to)
+   * }
+   *
+   * sortable.on('move:ticket', onMove)
+   * // later...
+   * sortable.off('move:ticket', onMove)
+   * ```
+   */
+  off: SortableEventListener<E>;
+  /**
+   * Move a ticket to a target index. Other tickets shift to fill.
+   * Emits `move:ticket` once when the index actually changes — a move whose
+   * `toIndex` already equals the ticket's current index is a no-op.
+   * No-ops when the root sortable is disabled or when the ticket is disabled.
+   *
+   * @param id Ticket id to move.
+   * @param toIndex Target index (zero-based).
+   * @returns The moved ticket, or `undefined` when the move was gated or the id is unknown.
+   *
+   * @example
+   * ```ts
+   * sortable.move(ticket.id, 2)
+   * ```
+   */
+  move: (id: ID, toIndex: number) => E | undefined;
+  /**
+   * Swap two tickets' positions. Emits `move:ticket` twice — once per ticket.
+   * No-ops when the root sortable is disabled or when either ticket is disabled.
+   *
+   * @param a Ticket id at one position.
+   * @param b Ticket id at the other position.
+   *
+   * @example
+   * ```ts
+   * sortable.swap(a.id, b.id)
+   * ```
+   */
+  swap: (a: ID, b: ID) => void;
+  /**
+   * Set the canonical order in one shot.
+   *
+   * @param ids Permutation of currently-registered ticket ids.
+   *
+   * @remarks
+   * Validates `ids.length === registry.size` and that every id is unique and known.
+   * Logs a warning via `useLogger()` and silently no-ops if any check fails — drag
+   * handlers that race against concurrent unregisters won't crash.
+   *
+   * Honors root `disabled` (whole call no-ops). Per-ticket `disabled` is **ignored** —
+   * `reorder` is a bulk operation declaring the canonical order, and applying that
+   * order may move disabled tickets. If you want disabled tickets pinned, exclude
+   * them from the ids you pass.
+   *
+   * @example
+   * ```ts
+   * sortable.reorder([c.id, a.id, b.id])
+   * ```
+   */
+  reorder: (ids: ID[]) => void;
+}
+/**
+ * Create an ordered-list state primitive.
+ *
+ * @param options Sortable options.
+ * @returns A {@link SortableContext} that extends {@link ModelContext}.
+ *
+ * @example
+ * ```ts
+ * const sortable = createSortable<Todo>()
+ * sortable.onboard(todos.value.map(value => ({ value })))
+ * ```
+ */
+declare function createSortable<Z extends SortableTicketInput = SortableTicketInput, E extends SortableTicket<Z> = SortableTicket<Z>>(_options?: SortableOptions): SortableContext<Z, E>;
+//#endregion
+//#region src/composables/createKanban/index.d.ts
+/**
+ * Options accepted by `createKanban`.
+ *
+ * @example
+ * ```ts
+ * import { createKanban } from '@vuetify/v0'
+ * import { shallowRef, toRef } from 'vue'
+ *
+ * const isReadOnly = shallowRef(false)
+ * const kanban = createKanban({ disabled: toRef(() => isReadOnly.value) })
+ * ```
+ */
+interface KanbanOptions extends Omit<SortableOptions, 'events'> {
+  /**
+   * Mutation gate. When truthy, `transfer` and column-level mutations no-op.
+   *
+   * @default false
+   */
+  disabled?: MaybeRefOrGetter<boolean>;
+}
+/**
+ * Input shape for a column ticket. Parameterized over the per-column inner
+ * ticket type so `accept` is typed against the caller's domain.
+ *
+ * @template ItemZ The inner ticket input type (extends `SortableTicketInput`).
+ * @template V The column's own value type.
+ *
+ * @example
+ * ```ts
+ * import type { KanbanColumnTicketInput, SortableTicketInput } from '@vuetify/v0'
+ *
+ * interface CardTicket extends SortableTicketInput {
+ *   value: { title: string }
+ * }
+ *
+ * interface BoardColumn extends KanbanColumnTicketInput<CardTicket> {
+ *   value: { title: string; color: string }
+ * }
+ * ```
+ */
+interface KanbanColumnTicketInput<ItemZ extends SortableTicketInput = SortableTicketInput, V = unknown> extends SortableTicketInput<V> {
+  /**
+   * Per-column mutation gate. When truthy, transfers into and out of this
+   * column are blocked, and the column's inner `items` sortable is disabled
+   * (move / swap / reorder no-op). Column-level operations on
+   * `kanban.columns` are unaffected — those are gated by the kanban-level
+   * `disabled`.
+   *
+   * @default false
+   */
+  disabled?: MaybeRefOrGetter<boolean>;
+  /**
+   * Predicate veto for incoming transfers. Synchronous boolean return:
+   * `true` accepts; `false` rejects (silent no-op). Async predicates are
+   * rejected at runtime with a warning.
+   *
+   * @param ticket The item being transferred (from the source column).
+   * @param from The source column id.
+   * @param toIndex The target index inside this destination column.
+   *
+   * @example
+   * ```ts
+   * const review = kanban.columns.register({
+   *   value: { title: 'Review' },
+   *   accept: (ticket, from) => from !== archiveColumn.id,
+   * })
+   * ```
+   */
+  accept?: (ticket: SortableTicket<ItemZ>, from: ID, toIndex: number) => boolean;
+}
+/**
+ * Output ticket returned from `kanban.columns.register`. Extends `SortableTicket`
+ * with the column's own inner sortable on `items`.
+ *
+ * @template ItemZ Inner ticket input type.
+ * @template Z Column input type.
+ *
+ * @example
+ * ```ts
+ * import { createKanban } from '@vuetify/v0'
+ *
+ * const kanban = createKanban()
+ * const todo = kanban.columns.register({ value: { title: 'Todo' } })
+ * todo.items.register({ value: { title: 'Write spec' } })
+ * console.log(todo.id, todo.value.title, todo.items.size)
+ * ```
+ */
+type KanbanColumnTicket<ItemZ extends SortableTicketInput = SortableTicketInput, Z extends KanbanColumnTicketInput<ItemZ> = KanbanColumnTicketInput<ItemZ>> = SortableTicket<Z> & {
+  items: SortableContext<ItemZ>;
+};
+/**
+ * Payload of the `transfer:ticket` event on the kanban bus.
+ *
+ * @example
+ * ```ts
+ * import { createKanban } from '@vuetify/v0'
+ *
+ * const kanban = createKanban()
+ *
+ * kanban.on('transfer:ticket', ({ ticket, from, to, toIndex }) => {
+ *   console.log(ticket.id, from, '→', to, '@', toIndex)
+ * })
+ * ```
+ */
+interface KanbanTransferPayload<ItemZ extends SortableTicketInput = SortableTicketInput> {
+  ticket: SortableTicket<ItemZ>;
+  from: ID;
+  to: ID;
+  fromIndex: number;
+  toIndex: number;
+}
+/**
+ * Listener signature for the kanban-level `transfer:ticket` event. Registry
+ * events (`register:ticket`, `unregister:ticket`, etc.) live on the columns
+ * registry — subscribe via `kanban.columns.on(...)` rather than `kanban.on(...)`.
+ *
+ * @example
+ * ```ts
+ * import { createKanban } from '@vuetify/v0'
+ *
+ * const kanban = createKanban()
+ *
+ * kanban.on('transfer:ticket', ({ ticket, from, to, toIndex }) => {
+ *   console.log(ticket.id, from, '→', to, '@', toIndex)
+ * })
+ * ```
+ */
+type KanbanEventListener<ItemZ extends SortableTicketInput = SortableTicketInput> = (event: 'transfer:ticket', cb: (data: KanbanTransferPayload<ItemZ>) => void) => void;
+/**
+ * Public context returned by `createKanban`.
+ *
+ * @example
+ * ```ts
+ * import { createKanban } from '@vuetify/v0'
+ * import type { KanbanColumnTicketInput, SortableTicketInput } from '@vuetify/v0'
+ *
+ * interface CardTicket extends SortableTicketInput {
+ *   value: { title: string }
+ * }
+ *
+ * interface BoardColumn extends KanbanColumnTicketInput<CardTicket> {
+ *   value: { title: string }
+ * }
+ *
+ * const kanban = createKanban<CardTicket, BoardColumn>()
+ *
+ * const [todo, done] = kanban.columns.onboard([
+ *   { value: { title: 'Todo' } },
+ *   { value: { title: 'Done' } },
+ * ])
+ *
+ * const card = todo.items.register({ value: { title: 'Write spec' } })
+ *
+ * kanban.on('transfer:ticket', ({ ticket, from, to, toIndex }) => {
+ *   console.log(`${ticket.id}: ${from} → ${to} @ ${toIndex}`)
+ * })
+ *
+ * kanban.transfer(card.id, done.id, 0)
+ * ```
+ */
+interface KanbanContext<ItemZ extends SortableTicketInput = SortableTicketInput, ColZ extends KanbanColumnTicketInput<ItemZ> = KanbanColumnTicketInput<ItemZ>> {
+  /**
+   * Column registry. Use this for column register / unregister / move / swap / reorder.
+   *
+   * @remarks
+   * Unregistering a column disposes its `items` sortable — all of the column's
+   * tickets are dropped and any subscribers attached to `column.items` are
+   * cleared. The internal cleanup runs before consumer-registered
+   * `unregister:ticket` handlers, so you cannot rescue items from inside that
+   * callback. To preserve items, move them before calling `unregister`.
+   *
+   * @example
+   * ```ts
+   * import { createKanban } from '@vuetify/v0'
+   *
+   * const kanban = createKanban<CardTicket, BoardColumn>()
+   * const todo = kanban.columns.register({ value: { title: 'Todo' } })
+   * todo.items.register({ value: { title: 'Write spec' } })
+   * kanban.columns.move(todo.id, 1)
+   * ```
+   *
+   * @example
+   * ```ts
+   * // Reflow items into a fallback column before disposing the source column.
+   * for (const item of todo.items.values()) {
+   *   trash.items.register({ id: item.id, value: item.value })
+   * }
+   * todo.unregister()
+   * ```
+   */
+  columns: SortableContext<ColZ, KanbanColumnTicket<ItemZ, ColZ>>;
+  /**
+   * Move an item across columns. Same-column transfer (where `toColumnId`
+   * matches the item's current column) collapses to `column.items.move` and
+   * does not emit `transfer:ticket`.
+   *
+   * Returns the moved ticket, or `undefined` when gated (kanban / source / destination /
+   * item disabled, destination.accept rejected, unknown id, duplicate destination id).
+   *
+   * @example
+   * ```ts
+   * import { createKanban } from '@vuetify/v0'
+   *
+   * const kanban = createKanban()
+   * const [todo, done] = kanban.columns.onboard([{ value: 'Todo' }, { value: 'Done' }])
+   * const card = todo.items.register({ value: 'Write spec' })
+   *
+   * const moved = kanban.transfer(card.id, done.id, 0)
+   * if (moved) console.log('landed at', moved.index)
+   *
+   * // Returns undefined when gated by disabled, accept, or unknown ids:
+   * kanban.transfer(card.id, 'no-such-column', 0) // → undefined
+   * ```
+   */
+  transfer: (id: ID, toColumnId: ID, toIndex: number) => SortableTicket<ItemZ> | undefined;
+  /**
+   * Subscribe to the kanban-level `transfer:ticket` event, fired after each
+   * successful cross-column move. Registry events (`register:ticket`,
+   * `unregister:ticket`, `move:ticket`) live on the columns registry — use
+   * `kanban.columns.on(...)` for those, or `column.items.on(...)` for
+   * per-column intra-column reorder events.
+   *
+   * @example
+   * ```ts
+   * import { createKanban } from '@vuetify/v0'
+   *
+   * const kanban = createKanban()
+   *
+   * kanban.on('transfer:ticket', ({ ticket, from, to, fromIndex, toIndex }) => {
+   *   console.log(ticket.id, from, '→', to, '@', toIndex)
+   * })
+   * ```
+   */
+  on: KanbanEventListener<ItemZ>;
+  /**
+   * Unsubscribe from the `transfer:ticket` event. Must be called with the same
+   * callback reference used to subscribe.
+   *
+   * @example
+   * ```ts
+   * import { createKanban } from '@vuetify/v0'
+   * import type { KanbanTransferPayload } from '@vuetify/v0'
+   *
+   * const kanban = createKanban<CardTicket>()
+   *
+   * function onTransfer (data: KanbanTransferPayload<CardTicket>) {
+   *   console.log(data.ticket.id)
+   * }
+   *
+   * kanban.on('transfer:ticket', onTransfer)
+   * // later
+   * kanban.off('transfer:ticket', onTransfer)
+   * ```
+   */
+  off: KanbanEventListener<ItemZ>;
+}
+/**
+ * Create a headless two-level sortable orchestrator.
+ *
+ * @param options Kanban options (currently only `disabled`).
+ * @returns A {@link KanbanContext}.
+ *
+ * @example
+ * ```ts
+ * import { createKanban } from '@vuetify/v0'
+ * import type { KanbanColumnTicketInput, SortableTicketInput } from '@vuetify/v0'
+ *
+ * interface CardTicket extends SortableTicketInput {
+ *   value: { title: string }
+ * }
+ *
+ * interface BoardColumn extends KanbanColumnTicketInput<CardTicket> {
+ *   value: { title: string }
+ * }
+ *
+ * const kanban = createKanban<CardTicket, BoardColumn>()
+ *
+ * const todo = kanban.columns.register({ value: { title: 'Todo' } })
+ * const review = kanban.columns.register({
+ *   value: { title: 'Review' },
+ *   accept: card => card.value.title.length > 0,
+ * })
+ *
+ * const spec = todo.items.register({ value: { title: 'Write spec' } })
+ * kanban.transfer(spec.id, review.id, 0)
+ * ```
+ */
+declare function createKanban<ItemZ extends SortableTicketInput = SortableTicketInput, ColZ extends KanbanColumnTicketInput<ItemZ> = KanbanColumnTicketInput<ItemZ>>(_options?: KanbanOptions): KanbanContext<ItemZ, ColZ>;
+//#endregion
 //#region src/composables/createNested/types.d.ts
 /**
  * Input type for nested tickets - what users provide to register().
@@ -2130,7 +2595,7 @@ interface NestedTicketInput<V = unknown> extends GroupTicketInput<V> {
   /** Whether this ticket is initially active */
   active?: boolean;
   /** Reference to the DOM element for focus management */
-  el?: MaybeRefOrGetter<HTMLElement | null | undefined>;
+  el?: MaybeRefOrGetter<Element | null | undefined>;
 }
 /**
  * Output type for nested tickets - what users receive from get().
@@ -2140,7 +2605,7 @@ interface NestedTicketInput<V = unknown> extends GroupTicketInput<V> {
  */
 type NestedTicket<Z extends NestedTicketInput = NestedTicketInput> = GroupTicket<Z> & {
   /** ID of the parent ticket, or undefined if this is a root item. Static — set at registration time. */parentId: ID | undefined; /** Reference to the DOM element for focus management */
-  el: MaybeRefOrGetter<HTMLElement | null | undefined> | undefined; /** Whether this ticket is currently open/expanded */
+  el: MaybeRefOrGetter<Element | null | undefined> | undefined; /** Whether this ticket is currently open/expanded */
   isOpen: Readonly<Ref<boolean>>; /** Whether this ticket is currently active/highlighted */
   isActive: Readonly<Ref<boolean>>; /** Whether this ticket is a leaf node (has no children) */
   isLeaf: Readonly<Ref<boolean>>; /** Depth in tree (0 = root) */
@@ -2179,7 +2644,7 @@ type NestedRegistration<Z extends NestedTicketInput = NestedTicketInput> = Parti
  * and hierarchical traversal methods. Perfect for tree structures, nested menus,
  * file explorers, and organizational charts.
  */
-interface NestedContext<Z extends NestedTicketInput = NestedTicketInput, E extends NestedTicket<Z> = NestedTicket<Z>> extends Omit<GroupContext<Z, E>, 'register' | 'onboard' | 'select' | 'unselect' | 'toggle'> {
+interface NestedContext<Z extends NestedTicketInput = NestedTicketInput, E extends NestedTicket<Z> = NestedTicket<Z>> extends Omit<GroupContext<Z, E>, 'register' | 'onboard' | 'offboard' | 'select' | 'unselect' | 'toggle'> {
   /** Map of parent IDs to arrays of child IDs. Use register/unregister to modify. */
   readonly children: ReadonlyMap<ID, readonly ID[]>;
   /** Map of child IDs to their parent ID (or undefined for roots). Use register/unregister to modify. */
@@ -4222,8 +4687,8 @@ interface DateOptions<Z> {
    *
    * @example
    * ```ts
-   * import { Vuetify0DateAdapter } from '@vuetify/v0/date'
-   * createDate({ adapter: new Vuetify0DateAdapter() })
+   * import { V0DateAdapter } from '@vuetify/v0/date'
+   * createDate({ adapter: new V0DateAdapter() })
    * ```
    */
   adapter: DateAdapter<Z>;
@@ -4252,14 +4717,14 @@ interface DatePluginOptions<Z> extends DateContextOptions<Z> {}
  *
  * @example
  * ```ts
- * import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+ * import { V0DateAdapter } from '@vuetify/v0/date'
  *
- * const { adapter } = createDate({ adapter: new Vuetify0DateAdapter() })
+ * const { adapter } = createDate({ adapter: new V0DateAdapter() })
  * const today = adapter.date()
  *
  * // With locale options
  * const { adapter } = createDate({
- *   adapter: new Vuetify0DateAdapter(),
+ *   adapter: new V0DateAdapter(),
  *   locale: 'de-DE',
  * })
  * ```
@@ -4277,10 +4742,10 @@ declare function createDate<Z, E extends DateContext<Z> = DateContext<Z>>(option
  *
  * @example
  * ```ts
- * import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+ * import { V0DateAdapter } from '@vuetify/v0/date'
  *
  * const [useAppDate, provideAppDate] = createDateContext({
- *   adapter: new Vuetify0DateAdapter(),
+ *   adapter: new V0DateAdapter(),
  *   namespace: 'app:date',
  * })
  * ```
@@ -4298,14 +4763,14 @@ declare function createDateContext<Z, E extends DateContext<Z> = DateContext<Z>>
  *
  * @example
  * ```ts
- * import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+ * import { V0DateAdapter } from '@vuetify/v0/date'
  *
  * const app = createApp(App)
- * app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
+ * app.use(createDatePlugin({ adapter: new V0DateAdapter() }))
  *
  * // With locale options
  * app.use(createDatePlugin({
- *   adapter: new Vuetify0DateAdapter(),
+ *   adapter: new V0DateAdapter(),
  *   locale: 'de-DE',
  * }))
  * ```
@@ -4327,10 +4792,10 @@ declare function createDatePlugin<Z, E extends DateContext<Z> = DateContext<Z>>(
  * @example
  * ```ts
  * // main.ts
- * import { Vuetify0DateAdapter } from '@vuetify/v0/date'
+ * import { V0DateAdapter } from '@vuetify/v0/date'
  * import { createDatePlugin } from '@vuetify/v0'
  *
- * app.use(createDatePlugin({ adapter: new Vuetify0DateAdapter() }))
+ * app.use(createDatePlugin({ adapter: new V0DateAdapter() }))
  * ```
  *
  * @example
@@ -4345,18 +4810,587 @@ declare function createDatePlugin<Z, E extends DateContext<Z> = DateContext<Z>>(
  */
 declare function useDate<Z, E extends DateContext<Z> = DateContext<Z>>(namespace?: string): E;
 //#endregion
-//#region src/composables/useEventListener/index.d.ts
-type CleanupFunction = () => void;
-type EventHandler<E = Event> = (event: E) => void;
+//#region src/composables/useDelay/index.d.ts
+interface UseDelayOptions {
+  /**
+   * Delay in milliseconds before the opening transition fires.
+   *
+   * @example
+   * ```ts
+   * useDelay({ openDelay: 300 })
+   * useDelay({ openDelay: () => isFocus.value ? 0 : 500 })
+   * ```
+   */
+  openDelay?: MaybeRefOrGetter<number>;
+  /**
+   * Delay in milliseconds before the closing transition fires.
+   *
+   * @example
+   * ```ts
+   * useDelay({ closeDelay: 200 })
+   * ```
+   */
+  closeDelay?: MaybeRefOrGetter<number>;
+}
 /**
- * Attaches an event listener to the window.
+ * Per-call options for `start()`.
  *
- * @param target The window object.
- * @param event The event to listen for.
- * @param listener The event listener.
- * @param options The event listener options.
- * @template E The event type.
- * @returns A function to remove the event listener.
+ * @example
+ * ```ts
+ * delay.start(false, { minDelay: 500 })
+ * ```
+ */
+interface UseDelayStartOptions {
+  /** Minimum delay floor in ms; max(configuredDelay, minDelay) wins. */
+  minDelay?: number;
+}
+/**
+ * The reactive controls and state surface returned by `useDelay`.
+ *
+ * @example
+ * ```ts
+ * const { start, stop, pause, resume, isActive, isOpening } = useDelay(
+ *   undefined,
+ *   { openDelay: 300, closeDelay: 200 },
+ * )
+ *
+ * start(true)
+ * ```
+ */
+interface UseDelayReturn {
+  /**
+   * Start a delay in the given direction. Restarts if already running. Resolves
+   * with `isOpening` once the delay elapses. If `start()` is called again before
+   * the previous resolves, the previous promise resolves with the new direction.
+   *
+   * @example
+   * ```ts
+   * const delay = useDelay({ openDelay: 300, closeDelay: 200 })
+   * await delay.start(true)                    // resolves true after 300ms
+   * await delay.start(false, { minDelay: 500 }) // resolves false after max(200, 500)
+   * ```
+   */
+  start: (isOpening: boolean, options?: UseDelayStartOptions) => Promise<boolean>;
+  /**
+   * Cancel any pending delay and reset state. Resolves the pending promise with the current direction.
+   *
+   * @example
+   * ```ts
+   * delay.stop()
+   * ```
+   */
+  stop: () => void;
+  /**
+   * Pause the in-flight delay, preserving remaining time. No-op if not running.
+   *
+   * @example
+   * ```ts
+   * delay.pause()
+   * ```
+   */
+  pause: () => void;
+  /**
+   * Resume from where pause left off. No-op if not paused.
+   *
+   * @example
+   * ```ts
+   * delay.resume()
+   * ```
+   */
+  resume: () => void;
+  /**
+   * Whether a delay is currently pending (started, not stopped).
+   */
+  isActive: Readonly<Ref<boolean>>;
+  /**
+   * Whether the pending delay is currently paused.
+   */
+  isPaused: Readonly<Ref<boolean>>;
+  /**
+   * Milliseconds remaining until the pending transition fires.
+   */
+  remaining: Readonly<Ref<number>>;
+  /**
+   * Direction of the pending transition (`true` = opening, `false` = closing).
+   */
+  isOpening: Readonly<Ref<boolean>>;
+}
+/**
+ * Schedule open and close transitions with configurable delays.
+ *
+ * Composes `useTimer` for the lifecycle (`start` / `stop` / `pause` / `resume` plus
+ * reactive `isActive`, `isPaused`, `remaining`) and adds direction tracking
+ * (`isOpening`) and promise-based resolution.
+ *
+ * @param callback Optional callback invoked once a started delay elapses; receives the resolved direction.
+ * @param options Reactive delay settings.
+ * @returns Lifecycle controls and reactive state.
+ *
+ * @see https://0.vuetifyjs.com/composables/system/use-delay
+ *
+ * @example
+ * ```ts
+ * const delay = useDelay(isOpening => isVisible.value = isOpening, {
+ *   openDelay: 300,
+ *   closeDelay: 200,
+ * })
+ *
+ * delay.start(true)
+ * delay.start(false, { minDelay: 500 })
+ * delay.pause()
+ * delay.resume()
+ * delay.stop()
+ * ```
+ */
+declare function useDelay(callback?: (isOpening: boolean) => void, options?: UseDelayOptions): UseDelayReturn;
+//#endregion
+//#region src/composables/useDragDrop/adapters/adapter.d.ts
+interface DragDropAdapterEmit<Z extends DragType = DragType> {
+  start: (source: DraggableTicket<Z>, origin: {
+    x: number;
+    y: number;
+  }, via: DragVia) => void;
+  move: (point: {
+    x: number;
+    y: number;
+  }) => void;
+  drop: () => void;
+  cancel: () => void;
+}
+interface DragDropAdapterContext<Z extends DragType = DragType> extends DragDropContext<Z> {
+  emit: DragDropAdapterEmit<Z>;
+}
+/**
+ * Abstract base class for useDragDrop adapters. Provides a `cleanup` slot, a
+ * `dispose()` lifecycle, and a `locate()` helper that walks the DOM to find the
+ * draggable ticket whose `el` ancestors a given event target.
+ *
+ * @example
+ * ```ts
+ * import { DragDropAdapter, type DragDropAdapterContext } from '@vuetify/v0'
+ *
+ * class MyAdapter extends DragDropAdapter {
+ *   setup (context: DragDropAdapterContext) {
+ *     const stop = useEventListener(document, 'mousedown', event => {
+ *       const ticket = this.locate(event.target, context)
+ *       if (ticket) context.emit.start(ticket, { x: event.clientX, y: event.clientY }, 'pointer')
+ *     })
+ *     this.cleanup = () => stop()
+ *   }
+ * }
+ * ```
+ */
+declare abstract class DragDropAdapter<Z extends DragType = DragType> {
+  protected cleanup: (() => void) | null;
+  dispose(): void;
+  protected locate(target: EventTarget | Element | null, context: DragDropAdapterContext<Z>): DraggableTicket<Z> | null;
+  abstract setup(context: DragDropAdapterContext<Z>): void;
+}
+//#endregion
+//#region src/composables/useDragDrop/adapters/pointer.d.ts
+interface PointerAdapterOptions {
+  /** Drag-activation distance in px (default 0 — start on pointerdown). */
+  threshold?: number;
+}
+/**
+ * Default pointer adapter. Wires `pointerdown` / `pointermove` / `pointerup` /
+ * `pointercancel` on the document and converts them into drag lifecycle calls.
+ *
+ * @example
+ * ```ts
+ * import { PointerAdapter, useDragDrop } from '@vuetify/v0'
+ *
+ * useDragDrop({ adapters: [new PointerAdapter({ threshold: 10 })] })
+ * ```
+ */
+declare class PointerAdapter<Z extends DragType = DragType> extends DragDropAdapter<Z> {
+  private threshold;
+  constructor(options?: PointerAdapterOptions);
+  setup(context: DragDropAdapterContext<Z>): void;
+}
+//#endregion
+//#region src/composables/useDragDrop/adapters/keyboard.d.ts
+interface KeyboardAdapterOptions {
+  /** Activation keys (default [' ', 'Enter']). */
+  activate?: string[];
+  /** Step size in px for arrow-key moves (default 16). */
+  step?: number;
+}
+/**
+ * Default keyboard adapter. Listens for `keydown` on the document; activation
+ * keys start/drop drags, arrow keys nudge the drag point, Escape cancels.
+ *
+ * @example
+ * ```ts
+ * import { KeyboardAdapter, useDragDrop } from '@vuetify/v0'
+ *
+ * useDragDrop({ adapters: [new KeyboardAdapter({ activate: ['x'], step: 32 })] })
+ * ```
+ */
+declare class KeyboardAdapter<Z extends DragType = DragType> extends DragDropAdapter<Z> {
+  private activate;
+  private step;
+  constructor(options?: KeyboardAdapterOptions);
+  setup(context: DragDropAdapterContext<Z>): void;
+}
+//#endregion
+//#region src/composables/useDragDrop/index.d.ts
+/**
+ * Layout axis a drop zone resolves indices along.
+ */
+type Orientation = 'vertical' | 'horizontal';
+/**
+ * Discriminated payload describing what is being dragged. Consumers extend
+ * this with concrete `type` literals plus a matching `value`.
+ *
+ * @example
+ * ```ts
+ * import type { DragType } from '@vuetify/v0'
+ *
+ * type Cards =
+ *   | { type: 'card', value: Card }
+ *   | { type: 'column', value: Column }
+ * // Cards extends DragType — distributive over the union.
+ * ```
+ */
+interface DragType {
+  type: string;
+  value: unknown;
+}
+/**
+ * Resolved drop slot inside an oriented zone. Surfaced via {@link DropPosition}
+ * so consumers can render a between-children indicator against the resolved
+ * child rect.
+ *
+ * @example
+ * ```ts
+ * import { useDragDrop } from '@vuetify/v0'
+ *
+ * const dnd = useDragDrop<{ type: 'card', value: Card }>()
+ * const zone = dnd.zones.register({ el, accept: ['card'], orientation: 'vertical' })
+ *
+ * const indicator = zone.indicator.value
+ * if (indicator) {
+ *   const y = indicator.edge === 'before'
+ *     ? indicator.rect.top
+ *     : indicator.rect.bottom
+ *   const x = indicator.rect.left
+ *   const width = indicator.rect.width
+ *   // Render a 2px bar at (x, y) with `width` to mark drop slot `indicator.index`.
+ * }
+ * ```
+ */
+interface DropIndicator {
+  index: number;
+  edge: 'before' | 'after';
+  rect: DOMRect;
+}
+/**
+ * Position passed to drop hooks. `index` and `indicator` are populated for
+ * oriented zones; unoriented zones receive only the pointer location.
+ *
+ * @example
+ * ```ts
+ * import { useDragDrop } from '@vuetify/v0'
+ *
+ * const dnd = useDragDrop<{ type: 'card', value: Card }>()
+ *
+ * dnd.zones.register({
+ *   el,
+ *   accept: ['card'],
+ *   orientation: 'vertical',
+ *   onDrop: (drag, position) => {
+ *     const target = position.index ?? items.length
+ *     items.splice(target, 0, drag.value)
+ *   },
+ * })
+ * ```
+ */
+interface DropPosition {
+  pointer: {
+    x: number;
+    y: number;
+  };
+  index?: number;
+  indicator?: DropIndicator;
+}
+/**
+ * Source modality for an active drag. Adapters declare their own value via
+ * the `Extensible<...>` escape hatch (e.g., 'touch', 'gamepad').
+ */
+type DragVia = Extensible<'pointer' | 'keyboard'>;
+/**
+ * Active drag state. Distributive over `Z` so that narrowing `drag.type` also
+ * narrows `drag.value` when `Z` is a discriminated union.
+ *
+ * @example
+ * ```ts
+ * import { useDragDrop } from '@vuetify/v0'
+ *
+ * type Cards = { type: 'card', value: Card } | { type: 'column', value: Column }
+ *
+ * const dnd = useDragDrop<Cards>()
+ *
+ * dnd.zones.register({
+ *   el,
+ *   onEnter: drag => {
+ *     if (drag.type === 'card') drag.value.title // narrowed to Card
+ *   },
+ * })
+ * ```
+ */
+type ActiveDrag<Z extends DragType = DragType> = Z extends DragType ? {
+  id: ID;
+  type: Z['type'];
+  value: Z['value'];
+  origin: {
+    x: number;
+    y: number;
+  };
+  current: {
+    x: number;
+    y: number;
+  };
+  delta: {
+    x: number;
+    y: number;
+  };
+  over: ID | null;
+  willAccept: boolean;
+  via: DragVia;
+} : never;
+/**
+ * Input shape for a draggable. Distributive over `Z` so unions narrow.
+ *
+ * @example
+ * ```ts
+ * import { useDragDrop } from '@vuetify/v0'
+ *
+ * const dnd = useDragDrop<{ type: 'card', value: Card }>()
+ *
+ * dnd.draggables.register({
+ *   el: cardRef,
+ *   type: 'card',
+ *   value: card,
+ *   onBeforeStart: drag => !drag.value.locked,
+ * })
+ * ```
+ */
+type DraggableTicketInput<Z extends DragType = DragType> = Z extends DragType ? RegistryTicketInput & {
+  type: Z['type'];
+  value: Z['value'];
+  el: MaybeRefOrGetter<HTMLElement | null>;
+  disabled?: MaybeRefOrGetter<boolean>;
+  onBeforeStart?: (drag: ActiveDrag<Z>) => boolean | void;
+  onMove?: (drag: ActiveDrag<Z>) => void;
+  onCancel?: (drag: ActiveDrag<Z>, reason: 'cancel' | 'reject') => void;
+} : never;
+/**
+ * Output shape for a draggable. Distributive over `Z` so `ticket.type`
+ * narrowing carries `ticket.value` to the matching union member.
+ *
+ * @example
+ * ```ts
+ * import { useDragDrop } from '@vuetify/v0'
+ *
+ * const dnd = useDragDrop<{ type: 'card', value: Card }>()
+ *
+ * const ticket = dnd.draggables.register({ el, type: 'card', value: card })
+ *
+ * ticket.isDragging.value // boolean
+ * ticket.value           // Card
+ * ```
+ */
+type DraggableTicket<Z extends DragType = DragType> = Z extends DragType ? RegistryTicket & {
+  type: Z['type'];
+  value: Z['value'];
+  el: Readonly<Ref<HTMLElement | null>>;
+  isDragging: Readonly<Ref<boolean>>;
+} : never;
+/**
+ * Input shape for a drop zone.
+ *
+ * @example
+ * ```ts
+ * import { useDragDrop } from '@vuetify/v0'
+ *
+ * const dnd = useDragDrop<{ type: 'card', value: Card }>()
+ *
+ * dnd.zones.register({
+ *   el: listRef,
+ *   accept: ['card'],
+ *   orientation: 'vertical',
+ *   onDrop: (drag, position) => items.splice(position.index ?? 0, 0, drag.value),
+ * })
+ * ```
+ */
+interface DropZoneTicketInput<Z extends DragType = DragType> extends RegistryTicketInput {
+  el: MaybeRefOrGetter<HTMLElement | null>;
+  /** Allowed drag types or a synchronous predicate. Async predicates (Promise / thenable returns) are rejected with a warning — `accept` must return synchronously. */
+  accept?: Z['type'][] | ((drag: ActiveDrag<Z>) => boolean);
+  orientation?: Orientation;
+  disabled?: MaybeRefOrGetter<boolean>;
+  onEnter?: (drag: ActiveDrag<Z>) => void;
+  onLeave?: (drag: ActiveDrag<Z>) => void;
+  onBeforeDrop?: (drag: ActiveDrag<Z>, position: DropPosition) => boolean | void;
+  onDrop?: (drag: ActiveDrag<Z>, position: DropPosition) => void;
+}
+/**
+ * Output shape for a drop zone.
+ *
+ * @example
+ * ```ts
+ * import { useDragDrop } from '@vuetify/v0'
+ *
+ * const dnd = useDragDrop<{ type: 'card', value: Card }>()
+ *
+ * const zone = dnd.zones.register({ el, accept: ['card'] })
+ *
+ * zone.isOver.value      // boolean
+ * zone.willAccept.value  // boolean
+ * zone.indicator.value   // DropIndicator | null
+ * ```
+ */
+interface DropZoneTicket extends RegistryTicket {
+  el: Readonly<Ref<HTMLElement | null>>;
+  isOver: Readonly<Ref<boolean>>;
+  willAccept: Readonly<Ref<boolean>>;
+  indicator: Readonly<Ref<DropIndicator | null>>;
+}
+/**
+ * Plugin signature. Receives the public context, optionally returns a
+ * disposer that runs on scope teardown.
+ *
+ * @example
+ * ```ts
+ * import { useDragDrop } from '@vuetify/v0'
+ * import type { DragDropPlugin } from '@vuetify/v0'
+ *
+ * const logDrops: DragDropPlugin = context => {
+ *   const off = context.zones.on('register:ticket', ticket => console.log('zone', ticket.id))
+ *   return () => off()
+ * }
+ *
+ * const dnd = useDragDrop({ plugins: [logDrops] })
+ * ```
+ */
+type DragDropPlugin<Z extends DragType = DragType> = (context: DragDropContext<Z>) => (() => void) | void;
+/**
+ * Options accepted by {@link useDragDrop}.
+ *
+ * @example
+ * ```ts
+ * import { useDragDrop, PointerAdapter } from '@vuetify/v0'
+ *
+ * const dnd = useDragDrop({
+ *   adapters: [new PointerAdapter()],
+ *   onDrop: (drag, position) => console.log('drop', drag, position),
+ * })
+ * ```
+ */
+interface DragDropOptions<Z extends DragType = DragType> {
+  adapters?: DragDropAdapter<Z>[];
+  plugins?: DragDropPlugin<Z>[];
+  onBeforeStart?: (drag: ActiveDrag<Z>) => boolean | void;
+  onMove?: (drag: ActiveDrag<Z>) => void;
+  onBeforeDrop?: (drag: ActiveDrag<Z>, position: DropPosition) => boolean | void;
+  onDrop?: (drag: ActiveDrag<Z>, position: DropPosition) => void;
+  onCancel?: (drag: ActiveDrag<Z>, reason: 'cancel' | 'reject') => void;
+}
+/**
+ * Registry context for draggable tickets, returned as `dnd.draggables`
+ * from {@link useDragDrop}.
+ *
+ * @example
+ * ```ts
+ * import { useDragDrop } from '@vuetify/v0'
+ *
+ * const dnd = useDragDrop<{ type: 'card', value: Card }>()
+ *
+ * const ticket = dnd.draggables.register({ el, type: 'card', value: card })
+ * ```
+ */
+interface DraggablesContext<Z extends DragType = DragType> extends Omit<RegistryContext<DraggableTicketInput<Z>, DraggableTicketInput<Z> & DraggableTicket<Z>>, 'register'> {
+  register: (registration: DraggableTicketInput<Z>) => DraggableTicket<Z>;
+}
+/**
+ * Registry context for drop zones, returned as `dnd.zones`
+ * from {@link useDragDrop}.
+ *
+ * @example
+ * ```ts
+ * import { useDragDrop } from '@vuetify/v0'
+ *
+ * const dnd = useDragDrop<{ type: 'card', value: Card }>()
+ *
+ * const zone = dnd.zones.register({ el, accept: ['card'] })
+ * ```
+ */
+interface ZonesContext<Z extends DragType = DragType> extends Omit<RegistryContext<DropZoneTicketInput<Z>, DropZoneTicketInput<Z> & DropZoneTicket>, 'register'> {
+  register: (registration: DropZoneTicketInput<Z>) => DropZoneTicket;
+}
+/**
+ * Public context returned by {@link useDragDrop}.
+ *
+ * @example
+ * ```ts
+ * import { useDragDrop } from '@vuetify/v0'
+ *
+ * const dnd = useDragDrop<{ type: 'card', value: Card }>()
+ *
+ * dnd.active.value     // ActiveDrag<{ type: 'card', value: Card }> | null
+ * dnd.isDragging.value // boolean
+ * dnd.cancel()         // programmatic cancel
+ * ```
+ */
+interface DragDropContext<Z extends DragType = DragType> {
+  draggables: DraggablesContext<Z>;
+  zones: ZonesContext<Z>;
+  active: Readonly<ShallowRef<ActiveDrag<Z> | null>>;
+  isDragging: Readonly<Ref<boolean>>;
+  cancel: () => void;
+}
+/**
+ * Create a headless drag-and-drop context.
+ *
+ * @param options - Adapters, plugins, and lifecycle hooks. All optional.
+ * @returns A `DragDropContext<Z>` exposing `draggables` / `zones` registries,
+ *   the `active` drag, the `isDragging` boolean, and a programmatic `cancel()`.
+ *
+ * @see https://0.vuetifyjs.com/composables/system/use-drag-drop
+ *
+ * @example
+ * ```ts
+ * import { useDragDrop } from '@vuetify/v0'
+ * import { useTemplateRef } from 'vue'
+ *
+ * const dnd = useDragDrop<{ type: 'card', value: string }>()
+ *
+ * const draggable = useTemplateRef<HTMLElement>('draggable')
+ * const dropzone = useTemplateRef<HTMLElement>('dropzone')
+ *
+ * dnd.draggables.register({ el: draggable, type: 'card', value: 'card-1' })
+ * dnd.zones.register({
+ *   el: dropzone,
+ *   accept: ['card'],
+ *   onDrop: (drag, position) => console.log(drag.value, position.index),
+ * })
+ * ```
+ */
+declare function useDragDrop<Z extends DragType = DragType>(options?: DragDropOptions<Z>): DragDropContext<Z>;
+//#endregion
+//#region src/composables/useEventListener/index.d.ts
+type CleanupFunction = () => void;
+type EventHandler<E = Event> = (event: E) => void;
+/**
+ * Attaches an event listener to the window.
+ *
+ * @param target The window object.
+ * @param event The event to listen for.
+ * @param listener The event listener.
+ * @param options The event listener options.
+ * @template E The event type.
+ * @returns A function to remove the event listener.
  *
  * @see https://0.vuetifyjs.com/composables/system/use-event-listener
  */
@@ -4471,7 +5505,7 @@ interface FeaturePluginOptions extends FeatureContextOptions {
    *
    * @remarks Adapters provide dynamic flag values from external services.
    */
-  adapter?: MaybeArray<FeaturesAdapterInterface>;
+  adapter?: MaybeArray<FeaturesAdapter>;
 }
 /**
  * Creates a new features instance.
@@ -5137,6 +6171,14 @@ interface UseMutationObserverReturn extends ObserverReturn {}
  */
 declare function useMutationObserver(target: MaybeElementRef, callback: (entries: MutationObserverRecord[]) => void, options?: UseMutationObserverOptions): UseMutationObserverReturn;
 //#endregion
+//#region src/composables/useNotifications/adapters/adapter.d.ts
+declare abstract class NotificationsAdapter<Z extends NotificationInput = NotificationInput, E extends NotificationTicket<Z> = NotificationTicket<Z>> {
+  /** Called once when the plugin installs. Wire inbound/outbound sync here. */
+  abstract setup(context: NotificationsAdapterContext<Z, E>): void;
+  /** Called on app unmount. Tear down listeners and connections. */
+  dispose?(): void;
+}
+//#endregion
 //#region src/composables/useNotifications/index.d.ts
 /** Notification urgency level. Maps to ARIA roles: `'error'`/`'warning'` → `role="alert"`, `'info'`/`'success'` → `role="status"`. Extensible — custom values like `'critical'` are allowed with autocomplete for defaults. */
 type NotificationSeverity = Extensible<'info' | 'warning' | 'error' | 'success'>;
@@ -5181,22 +6223,11 @@ interface NotificationsAdapterContext<Z extends NotificationInput = Notification
   send: (input: Z) => E;
   /** Create a notification in registry only (no toast). Use for initial/historical items. */
   register: (input: Z) => E;
-  /** Subscribe to notification lifecycle events (e.g., `'notification:read'`). */
+  /** Subscribe to notification lifecycle events (e.g., `'notification:read'`). The handler receives the affected {@link NotificationTicket}. */
   on: (event: string, handler: (data: unknown) => void) => void;
   /** Unsubscribe from a lifecycle event. */
   off: (event: string, handler: (data: unknown) => void) => void;
 }
-/**
- * Adapter interface for bridging external notification services.
- * Adapters receive an {@link NotificationsAdapterContext} on setup
- * and optionally clean up on dispose.
- */
-interface NotificationsAdapterInterface<Z extends NotificationInput = NotificationInput, E extends NotificationTicket<Z> = NotificationTicket<Z>> {
-  /** Called once when the plugin installs. Wire inbound/outbound sync here. */
-  setup: (context: NotificationsAdapterContext<Z, E>) => void;
-  /** Called on app unmount. Tear down listeners and connections. */
-  dispose?: () => void;
-}
 /** Options for {@link createNotifications}. */
 interface NotificationsOptions extends RegistryOptions {
   /** Default auto-dismiss timeout in ms for the toast queue. @default 3000 */
@@ -5230,7 +6261,7 @@ interface NotificationsContext<Z extends NotificationInput = NotificationInput,
 declare function createNotifications(options?: NotificationsOptions): NotificationsContext;
 interface NotificationsPluginOptions extends NotificationsOptions {
   namespace?: string;
-  adapter?: NotificationsAdapterInterface;
+  adapter?: NotificationsAdapter;
 }
 /**
  * Notification management with registry, event system, and optional adapters.
@@ -5252,15 +6283,12 @@ interface NotificationsPluginOptions extends NotificationsOptions {
 declare const createNotificationsContext: <_E extends NotificationsContext<NotificationInput, NotificationTicket<NotificationInput>> = NotificationsContext<NotificationInput, NotificationTicket<NotificationInput>>>(_options?: NotificationsPluginOptions | undefined) => ContextTrinity<_E>, createNotificationsPlugin: (_options?: NotificationsPluginOptions | undefined) => Plugin, useNotifications: <_E extends NotificationsContext<NotificationInput, NotificationTicket<NotificationInput>> = NotificationsContext<NotificationInput, NotificationTicket<NotificationInput>>>(namespace?: string) => _E;
 //#endregion
 //#region src/composables/usePermissions/adapters/adapter.d.ts
-interface PermissionAdapterInterface {
-  can: <Z extends PermissionTicket = PermissionTicket>(role: ID, action: string, subject: string, context: Record<string, unknown>, permissions: PermissionContext<Z>) => boolean;
-}
-declare abstract class PermissionAdapter implements PermissionAdapterInterface {
+declare abstract class PermissionsAdapter {
   abstract can<Z extends PermissionTicket = PermissionTicket>(role: ID, action: string, subject: string, context: Record<string, unknown>, permissions: PermissionContext<Z>): boolean;
 }
 //#endregion
 //#region src/composables/usePermissions/adapters/v0.d.ts
-declare class Vuetify0PermissionAdapter extends PermissionAdapter {
+declare class V0PermissionsAdapter extends PermissionsAdapter {
   constructor();
   can<Z extends PermissionTicket = PermissionTicket>(role: ID, action: string, subject: string, context: Record<string, unknown>, permissions: PermissionContext<Z>): boolean;
 }
@@ -5271,7 +6299,7 @@ interface PermissionContext<Z extends PermissionTicket = PermissionTicket> exten
   can: (id: ID, action: string, subject: string, context?: Record<string, unknown>) => boolean;
 }
 interface PermissionOptions extends TokenOptions {
-  adapter?: PermissionAdapter;
+  adapter?: PermissionsAdapter;
   permissions?: Record<ID, [string | string[], string | string[], (boolean | ((context: Record<string, unknown>) => boolean))?][]>;
 }
 interface PermissionContextOptions extends PermissionOptions {
@@ -5581,7 +6609,7 @@ declare function useElementSize(target: MaybeElementRef): UseElementSizeReturn;
 //#endregion
 //#region src/composables/useRovingFocus/index.d.ts
 interface RovingItem extends TraversalItem {
-  el?: MaybeRefOrGetter<HTMLElement | null | undefined>;
+  el?: MaybeRefOrGetter<Element | null | undefined>;
 }
 interface RovingFocusOptions {
   target?: MaybeRefOrGetter<HTMLElement | null | undefined>;
@@ -5613,12 +6641,12 @@ interface RtlAdapterSetupContext {
   isRtl: Ref<boolean>;
   toggle: () => void;
 }
-interface RtlAdapter {
-  setup: <T extends RtlAdapterSetupContext>(app: App, context: T, target?: string | HTMLElement | null) => void;
+declare abstract class RtlAdapter {
+  abstract setup<T extends RtlAdapterSetupContext>(app: App, context: T, target?: string | HTMLElement | null): void;
 }
 //#endregion
 //#region src/composables/useRtl/adapters/v0.d.ts
-declare class Vuetify0RtlAdapter implements RtlAdapter {
+declare class V0RtlAdapter extends RtlAdapter {
   setup<T extends RtlAdapterSetupContext>(app: App, context: T, target?: string | HTMLElement | null): void;
 }
 //#endregion
@@ -5898,7 +6926,7 @@ interface StorageContext {
   clear: () => void;
 }
 interface StorageOptions {
-  /** The storage adapter to use. Defaults to localStorage in browser, MemoryAdapter otherwise */
+  /** The storage adapter to use. Defaults to localStorage in browser, MemoryStorageAdapter otherwise */
   adapter?: StorageAdapter;
   /** The prefix to use for all storage keys. Defaults to 'v0:' */
   prefix?: string;
@@ -5948,11 +6976,7 @@ interface ThemeAdapterSetupContext {
   selectedId: Ref<ID | null | undefined>;
   isDark: Readonly<Ref<boolean>>;
 }
-interface ThemeAdapterInterface {
-  setup: <T extends ThemeAdapterSetupContext>(app: App, context: T, target?: string | HTMLElement | null) => void;
-  update: (colors: Record<string, Colors>, isDark?: boolean) => void;
-}
-declare abstract class ThemeAdapter implements ThemeAdapterInterface {
+declare abstract class ThemeAdapter {
   private static UNSAFE_CSS;
   private static SAFE_IDENT;
   stylesheetId: string;
@@ -6222,10 +7246,19 @@ declare const createThemeContext: <_E extends ThemeContext<ThemeTicketInput, The
 //#region src/composables/useTimer/index.d.ts
 interface TimerOptions {
   /**
-   * Duration in milliseconds.
+   * Duration in milliseconds. Accepts a plain number, ref, or getter — the
+   * value is read fresh each time `start()` is invoked, so reactive sources
+   * can change between runs without recreating the timer.
+   *
    * @default 1000
+   *
+   * @example
+   * ```ts
+   * useTimer(handler, { duration: 5000 })
+   * useTimer(handler, { duration: () => isFast.value ? 100 : 1000 })
+   * ```
    */
-  duration?: number;
+  duration?: MaybeRefOrGetter<number>;
   /**
    * Whether the timer repeats after firing.
    * @default false
@@ -6265,6 +7298,12 @@ interface TimerContext {
  * timer.pause()
  * timer.resume()
  * timer.stop()
+ *
+ * // Reactive duration — re-read on each start()
+ * const duration = shallowRef(1000)
+ * const reactive = useTimer(handler, { duration })
+ * duration.value = 2000
+ * reactive.start() // fires after 2000ms
  * ```
  */
 declare function useTimer(handler: () => void, options?: TimerOptions): TimerContext;
@@ -6337,4 +7376,4 @@ interface ToggleScopeControls {
  */
 declare function useToggleScope(source: WatchSource<boolean>, fn: (() => void) | ((controls: ToggleScopeControls) => void)): ToggleScopeControls;
 //#endregion
-export { RtlAdapter as $, StepOptions as $a, FormValidationResult as $i, createFeaturesContext as $n, SliderOptions as $r, useMediaQuery as $t, createStorageContext as A, createContext as Aa, NumericOptions as Ai, UseIntersectionObserverReturn as An, SingleTicket as Ao, toReactive as Ar, createPermissionsPlugin as At, createStackContext as B, ClientAdapterOptions as Ba, NestedRegistration as Bi, createHydrationPlugin as Bn, SelectionContextOptions as Bo, VirtualOptions as Br, NotificationsContext as Bt, ThemeAdapter as C, Plugin as Ca, createProgress as Ci, useLocale as Cn, BreadcrumbsOptions as Co, BreakpointsContextOptions as Cr, PermissionContext as Ct, StorageOptions as D, createPluginContext as Da, NumberFieldOptions as Di, IntersectionObserverEntry as Dn, SingleContext as Do, createBreakpointsContext as Dr, PermissionTicket as Dt, StorageContextOptions as E, createPlugin as Ea, NumberFieldContext as Ei, useLazy as En, useBreadcrumbs as Eo, createBreakpoints as Er, PermissionPluginOptions as Et, StackOptions as F, createCombobox as Fa, NestedActiveMode as Fi, HydrationOptions as Fn, ImageStatus as Fo, VirtualAnchor as Fr, NotificationInput as Ft, RtlOptions as G, VirtualFocusOptions as Ga, InputOptions as Gi, useHotkey as Gn, createSelectionContext as Go, TimelineContext as Gr, createNotificationsPlugin as Gt, useStack as H, ComboboxAdapterInterface as Ha, NestedTicket as Hi, PlatformContext as Hn, SelectionTicket as Ho, createVirtual as Hr, NotificationsPluginOptions as Ht, StackPluginOptions as I, createComboboxContext as Ia, NestedContext as Ii, HydrationPluginOptions as In, UseImageOptions as Io, VirtualContext as Ir, NotificationSeverity as It, createRtlContext as J, PopoverOptions as Ja, FormContext as Ji, FeatureOptions as Jn, ModelOptions as Jo, TimelineTicket as Jr, ObservableNodeList as Jt, RtlPluginOptions as K, VirtualFocusReturn as Ka, InputState as Ki, FeatureContext as Kn, useSelection as Ko, TimelineContextOptions as Kr, useNotifications as Kt, StackTicket as L, useCombobox as La, NestedContextOptions as Li, createFallbackHydration as Ln, UseImageReturn as Lo, VirtualContextOptions as Lr, NotificationTicket as Lt, useStorage as M, useContext as Ma, createNested as Mi, useIntersectionObserver as Mn, createSingle as Mo, toElement as Mr, Vuetify0PermissionAdapter as Mt, StackContext as N, ComboboxContext as Na, createNestedContext as Ni, HydrationContext as Nn, createSingleContext as No, toArray as Nr, PermissionAdapter as Nt, StoragePluginOptions as O, ContextKey as Oa, createNumberField as Oi, IntersectionObserverOptions as On, SingleContextOptions as Oo, createBreakpointsPlugin as Or, createPermissions as Ot, StackContextOptions as P, ComboboxOptions as Pa, useNested as Pi, HydrationContextOptions as Pn, useSingle as Po, ScrollToOptions as Pr, PermissionAdapterInterface as Pt, Vuetify0RtlAdapter as Q, StepContextOptions as Qa, FormTicketInput as Qi, createFeatures as Qn, SliderContext as Qr, MediaQueryContext as Qt, StackTicketInput as R, ServerAdapter as Ra, NestedOpenMode as Ri, createHydration as Rn, useImage as Ro, VirtualDirection as Rr, NotificationsAdapterContext as Rt, Vuetify0ThemeOptions as S, isStandardSchema as Sa, ProgressTicketInput as Si, createLocalePlugin as Sn, BreadcrumbsContextOptions as So, BreakpointsContext as Sr, usePresence as St, StorageContext as T, PluginOptions as Ta, useProgress as Ti, LazyOptions as Tn, createBreadcrumbsContext as To, BreakpointsPluginOptions as Tr, PermissionOptions as Tt, RtlContext as U, ComboboxAdapterResult as Ua, NestedTicketInput as Ui, UseHotkeyOptions as Un, SelectionTicketInput as Uo, createVirtualContext as Ur, createNotifications as Ut, createStackPlugin as V, ComboboxAdapterContext as Va, NestedSelectionMode as Vi, useHydration as Vn, SelectionOptions as Vo, VirtualState as Vr, NotificationsOptions as Vt, RtlContextOptions as W, VirtualFocusItem as Wa, InputContext as Wi, UseHotkeyReturn as Wn, createSelection as Wo, useVirtual as Wr, createNotificationsContext as Wt, createRtlPlugin as X, usePopover as Xa, FormOptions as Xi, FeatureTicket as Xn, ModelTicketInput as Xo, createTimelineContext as Xr, UseMutationObserverReturn as Xt, createRtlFallback as Y, PopoverReturn as Ya, FormContextOptions as Yi, FeaturePluginOptions as Yn, ModelTicket as Yo, createTimeline as Yr, UseMutationObserverOptions as Yt, useRtl as Z, StepContext as Za, FormTicket as Zi, FeatureTicketInput as Zn, createModel as Zo, useTimeline as Zr, useMutationObserver as Zt, createThemePlugin as _, createRulesContext as _a, useQueue as _i, LocaleTicket as _n, createGroupContext as _o, ClickOutsideTarget as _r, ProxyModelTarget as _t, useTimer as a, ValidationContext as aa, RatingItemState as ai, LoggerOptions as an, OverflowContext as ao, useEventListener as ar, ResizeObserverEntry as at, V0UnheadThemeOptions as b, useRules as ba, ProgressOptions as bi, createLocaleContext as bn, BreadcrumbTicketInput as bo, useClickOutside as br, UsePresenceOptions as bt, ThemeContext as c, ValidationTicketInput as ca, createRatingContext as ci, createLoggerContext as cn, createOverflow as co, DateContextOptions as cr, UseResizeObserverReturn as ct, ThemePluginOptions as d, RuleAliases as da, QueueContextOptions as di, LogLevel as dn, GroupContext as do, createDate as dr, UseRafReturn as dt, FormValidationRule as ea, SliderTicketInput as ei, usePrefersContrast as en, StepTicket as eo, createFeaturesPlugin as er, RtlAdapterSetupContext as et, ThemeRecord as f, RuleInput as fa, QueueOptions as fi, LocaleContext as fn, GroupContextOptions as fo, createDateContext as fr, useRaf as ft, createThemeContext as g, createRules as ga, createQueueContext as gi, LocaleRecord as gn, createGroup as go, ClickOutsideIgnoreTarget as gr, ProxyModelOptions as gt, createTheme as h, RulesOptions as ha, createQueue as hi, LocalePluginOptions as hn, GroupTicketInput as ho, ClickOutsideElement as hr, useProxyRegistry as ht, TimerOptions as i, useForm as ia, RatingItemDescriptor as ii, LoggerContextOptions as in, useStep as io, useDocumentEventListener as ir, useRovingFocus as it, createStoragePlugin as j, provideContext as ja, createNumeric as ji, useElementIntersection as jn, SingleTicketInput as jo, MaybeElementRef as jr, usePermissions as jt, createStorage as k, CreateContextOptions as ka, NumericContext as ki, UseElementIntersectionReturn as kn, SingleOptions as ko, useBreakpoints as kr, createPermissionsContext as kt, ThemeContextOptions as l, createValidation as la, useRating as li, createLoggerPlugin as ln, createOverflowContext as lo, DateOptions as lr, useElementSize as lt, ThemeTicketInput as m, RulesContextOptions as ma, QueueTicketInput as mi, LocaleOptions as mn, GroupTicket as mo, useDate as mr, ProxyRegistryOptions as mt, useToggleScope as n, createForm as na, RatingContext as ni, usePrefersReducedMotion as nn, createStep as no, CleanupFunction as nr, RovingFocusReturn as nt, Colors as o, ValidationOptions as oa, RatingOptions as oi, LoggerPluginOptions as on, OverflowContextOptions as oo, useWindowEventListener as or, ResizeObserverOptions as ot, ThemeTicket as p, RulesContext as pa, QueueTicket as pi, LocaleContextOptions as pn, GroupOptions as po, createDatePlugin as pr, ProxyRegistryContext as pt, createRtl as q, useVirtualFocus as qa, createInput as qi, FeatureContextOptions as qn, ModelContext as qo, TimelineOptions as qr, MutationObserverRecord as qt, TimerContext as r, createFormContext as ra, RatingContextOptions as ri, LoggerContext as rn, createStepContext as ro, EventHandler as rr, RovingItem as rt, ThemeColors as s, ValidationTicket as sa, createRating as si, createLogger as sn, OverflowOptions as so, DateContext as sr, UseElementSizeReturn as st, ToggleScopeControls as t, FormValue as ta, createSlider as ti, usePrefersDark as tn, StepTicketInput as to, useFeatures as tr, RovingFocusOptions as tt, ThemeOptions as u, RuleAlias as ua, QueueContext as ui, useLogger as un, useOverflow as uo, DatePluginOptions as ur, useResizeObserver as ut, useTheme as v, createRulesFallback as va, ProgressContext as vi, LocaleTicketInput as vn, useGroup as vo, UseClickOutsideOptions as vr, useProxyModel as vt, ThemeAdapterInterface as w, PluginContextConfig as wa, createProgressContext as wi, LazyContext as wn, createBreadcrumbs as wo, BreakpointsOptions as wr, PermissionContextOptions as wt, V0StyleSheetThemeAdapter as x, StandardSchemaV1 as xa, ProgressTicket as xi, createLocaleFallback as xn, BreadcrumbsContext as xo, BreakpointName as xr, UsePresenceReturn as xt, V0UnheadThemeAdapter as y, createRulesPlugin as ya, ProgressContextOptions as yi, createLocale as yn, BreadcrumbTicket as yo, UseClickOutsideReturn as yr, PresenceState as yt, createStack as z, ClientAdapter as za, NestedOptions as zi, createHydrationContext as zn, SelectionContext as zo, VirtualItem as zr, NotificationsAdapterInterface as zt };
+export { RtlAdapterSetupContext as $, RulesContextOptions as $a, createNumberField as $i, useFeatures as $n, GroupTicket as $o, createBreakpointsPlugin as $r, usePrefersDark as $t, createStoragePlugin as A, InputOptions as Aa, RatingItemState as Ai, useIntersectionObserver as An, VirtualFocusOptions as Ao, UseDelayStartOptions as Ar, createSelectionContext as As, usePermissions as At, createStackPlugin as B, FormValue as Ba, createQueue as Bi, PlatformContext as Bn, StepTicketInput as Bo, ClickOutsideElement as Br, createNotifications as Bt, ThemeAdapter as C, SortableEventListener as Ca, SliderContext as Ci, LazyOptions as Cn, ServerComboboxAdapter as Co, PointerAdapter as Cr, useImage as Cs, PermissionContextOptions as Ct, StoragePluginOptions as D, SortableTicketInput as Da, RatingContext as Di, UseElementIntersectionReturn as Dn, ComboboxAdapterContext as Do, DragDropAdapterEmit as Dr, SelectionTicket as Ds, createPermissions as Dt, StorageOptions as E, SortableTicket as Ea, createSlider as Ei, IntersectionObserverOptions as En, ComboboxAdapter as Eo, DragDropAdapterContext as Er, SelectionOptions as Es, PermissionTicket as Et, StackPluginOptions as F, FormOptions as Fa, QueueContext as Fi, createFallbackHydration as Fn, usePopover as Fo, DatePluginOptions as Fr, ModelTicketInput as Fs, NotificationTicket as Ft, RtlPluginOptions as G, ValidationOptions as Ga, ProgressOptions as Gi, FeatureContextOptions as Gn, OverflowContextOptions as Go, useClickOutside as Gr, MutationObserverRecord as Gt, RtlContext as H, createFormContext as Ha, useQueue as Hi, UseHotkeyReturn as Hn, createStepContext as Ho, ClickOutsideTarget as Hr, createNotificationsPlugin as Ht, StackTicket as I, FormTicket as Ia, QueueContextOptions as Ii, createHydration as In, StepContext as Io, createDate as Ir, createModel as Is, NotificationsAdapterContext as It, createRtlFallback as J, createValidation as Ja, createProgress as Ji, FeatureTicket as Jn, createOverflowContext as Jo, BreakpointsContextOptions as Jr, UseMutationObserverReturn as Jt, createRtl as K, ValidationTicket as Ka, ProgressTicket as Ki, FeatureOptions as Kn, OverflowOptions as Ko, BreakpointName as Kr, ObservableNodeList as Kt, StackTicketInput as L, FormTicketInput as La, QueueOptions as Li, createHydrationContext as Ln, StepContextOptions as Lo, createDateContext as Lr, NotificationsContext as Lt, StackContext as M, createInput as Ma, createRating as Mi, HydrationContextOptions as Mn, useVirtualFocus as Mo, DateContext as Mr, ModelContext as Ms, PermissionsAdapter as Mt, StackContextOptions as N, FormContext as Na, createRatingContext as Ni, HydrationOptions as Nn, PopoverOptions as No, DateContextOptions as Nr, ModelOptions as Ns, NotificationInput as Nt, createStorage as O, createSortable as Oa, RatingContextOptions as Oi, UseIntersectionObserverReturn as On, ComboboxAdapterResult as Oo, UseDelayOptions as Or, SelectionTicketInput as Os, createPermissionsContext as Ot, StackOptions as P, FormContextOptions as Pa, useRating as Pi, HydrationPluginOptions as Pn, PopoverReturn as Po, DateOptions as Pr, ModelTicket as Ps, NotificationSeverity as Pt, RtlAdapter as Q, RulesContext as Qa, NumberFieldOptions as Qi, createFeaturesPlugin as Qn, GroupOptions as Qo, createBreakpointsContext as Qr, usePrefersContrast as Qt, createStack as R, FormValidationResult as Ra, QueueTicket as Ri, createHydrationPlugin as Rn, StepOptions as Ro, createDatePlugin as Rr, NotificationsOptions as Rt, Vuetify0ThemeOptions as S, SortableContext as Sa, useTimeline as Si, LazyContext as Sn, useCombobox as So, KeyboardAdapterOptions as Sr, UseImageReturn as Ss, PermissionContext as St, StorageContextOptions as T, SortableOptions as Ta, SliderTicketInput as Ti, IntersectionObserverEntry as Tn, ClientComboboxAdapterOptions as To, DragDropAdapter as Tr, SelectionContextOptions as Ts, PermissionPluginOptions as Tt, RtlContextOptions as U, useForm as Ua, ProgressContext as Ui, useHotkey as Un, useStep as Uo, UseClickOutsideOptions as Ur, useNotifications as Ut, useStack as V, createForm as Va, createQueueContext as Vi, UseHotkeyOptions as Vn, createStep as Vo, ClickOutsideIgnoreTarget as Vr, createNotificationsContext as Vt, RtlOptions as W, ValidationContext as Wa, ProgressContextOptions as Wi, FeatureContext as Wn, OverflowContext as Wo, UseClickOutsideReturn as Wr, NotificationsAdapter as Wt, useRtl as X, RuleAliases as Xa, useProgress as Xi, createFeatures as Xn, GroupContext as Xo, BreakpointsPluginOptions as Xr, MediaQueryContext as Xt, createRtlPlugin as Y, RuleAlias as Ya, createProgressContext as Yi, FeatureTicketInput as Yn, useOverflow as Yo, BreakpointsOptions as Yr, useMutationObserver as Yt, V0RtlAdapter as Z, RuleInput as Za, NumberFieldContext as Zi, createFeaturesContext as Zn, GroupContextOptions as Zo, createBreakpoints as Zr, useMediaQuery as Zt, createThemePlugin as _, KanbanContext as _a, TimelineContextOptions as _i, createLocale as _n, useContext as _o, DropZoneTicketInput as _r, createSingle as _s, useProxyModel as _t, useTimer as a, useNested as aa, ScrollToOptions as ai, createLogger as an, useRules as ao, ActiveDrag as ar, BreadcrumbTicketInput as as, ResizeObserverOptions as at, V0UnheadThemeOptions as b, KanbanTransferPayload as ba, createTimeline as bi, createLocalePlugin as bn, createCombobox as bo, useDragDrop as br, ImageStatus as bs, UsePresenceReturn as bt, ThemeContext as c, NestedContextOptions as ca, VirtualContextOptions as ci, useLogger as cn, Plugin as co, DragDropPlugin as cr, BreadcrumbsOptions as cs, useElementSize as ct, ThemePluginOptions as d, NestedRegistration as da, VirtualOptions as di, LocaleContextOptions as dn, createPlugin as do, DraggableTicket as dr, useBreadcrumbs as ds, useRaf as dt, NumericContext as ea, useBreakpoints as ei, usePrefersReducedMotion as en, RulesOptions as eo, CleanupFunction as er, GroupTicketInput as es, RovingFocusOptions as et, ThemeRecord as f, NestedSelectionMode as fa, VirtualState as fi, LocaleOptions as fn, createPluginContext as fo, DraggableTicketInput as fr, SingleContext as fs, ProxyRegistryContext as ft, createThemeContext as g, KanbanColumnTicketInput as ga, TimelineContext as gi, LocaleTicketInput as gn, provideContext as go, DropZoneTicket as gr, SingleTicketInput as gs, ProxyModelTarget as gt, createTheme as h, KanbanColumnTicket as ha, useVirtual as hi, LocaleTicket as hn, createContext as ho, DropPosition as hr, SingleTicket as hs, ProxyModelOptions as ht, TimerOptions as i, createNestedContext as ia, toArray as ii, LoggerPluginOptions as in, createRulesPlugin as io, useWindowEventListener as ir, BreadcrumbTicket as is, ResizeObserverEntry as it, useStorage as j, InputState as ja, RatingOptions as ji, HydrationContext as jn, VirtualFocusReturn as jo, useDelay as jr, useSelection as js, V0PermissionsAdapter as jt, createStorageContext as k, InputContext as ka, RatingItemDescriptor as ki, useElementIntersection as kn, VirtualFocusItem as ko, UseDelayReturn as kr, createSelection as ks, createPermissionsPlugin as kt, ThemeContextOptions as l, NestedOpenMode as la, VirtualDirection as li, LogLevel as ln, PluginContextConfig as lo, DragType as lr, createBreadcrumbs as ls, useResizeObserver as lt, ThemeTicketInput as m, NestedTicketInput as ma, createVirtualContext as mi, LocaleRecord as mn, CreateContextOptions as mo, DropIndicator as mr, SingleOptions as ms, useProxyRegistry as mt, useToggleScope as n, createNumeric as na, MaybeElementRef as ni, LoggerContextOptions as nn, createRulesContext as no, useDocumentEventListener as nr, createGroupContext as ns, RovingItem as nt, Colors as o, NestedActiveMode as oa, VirtualAnchor as oi, createLoggerContext as on, StandardSchemaV1 as oo, DragDropContext as or, BreadcrumbsContext as os, UseElementSizeReturn as ot, ThemeTicket as p, NestedTicket as pa, createVirtual as pi, LocalePluginOptions as pn, ContextKey as po, DraggablesContext as pr, SingleContextOptions as ps, ProxyRegistryOptions as pt, createRtlContext as q, ValidationTicketInput as qa, ProgressTicketInput as qi, FeaturePluginOptions as qn, createOverflow as qo, BreakpointsContext as qr, UseMutationObserverOptions as qt, TimerContext as r, createNested as ra, toElement as ri, LoggerOptions as rn, createRulesFallback as ro, useEventListener as rr, useGroup as rs, useRovingFocus as rt, ThemeColors as s, NestedContext as sa, VirtualContext as si, createLoggerPlugin as sn, isStandardSchema as so, DragDropOptions as sr, BreadcrumbsContextOptions as ss, UseResizeObserverReturn as st, ToggleScopeControls as t, NumericOptions as ta, toReactive as ti, LoggerContext as tn, createRules as to, EventHandler as tr, createGroup as ts, RovingFocusReturn as tt, ThemeOptions as u, NestedOptions as ua, VirtualItem as ui, LocaleContext as un, PluginOptions as uo, DragVia as ur, createBreadcrumbsContext as us, UseRafReturn as ut, useTheme as v, KanbanEventListener as va, TimelineOptions as vi, createLocaleContext as vn, ComboboxContext as vo, Orientation as vr, createSingleContext as vs, PresenceState as vt, StorageContext as w, SortableMovePayload as wa, SliderOptions as wi, useLazy as wn, ClientComboboxAdapter as wo, PointerAdapterOptions as wr, SelectionContext as ws, PermissionOptions as wt, V0StyleSheetThemeAdapter as x, createKanban as xa, createTimelineContext as xi, useLocale as xn, createComboboxContext as xo, KeyboardAdapter as xr, UseImageOptions as xs, usePresence as xt, V0UnheadThemeAdapter as y, KanbanOptions as ya, TimelineTicket as yi, createLocaleFallback as yn, ComboboxOptions as yo, ZonesContext as yr, useSingle as ys, UsePresenceOptions as yt, createStackContext as z, FormValidationRule as za, QueueTicketInput as zi, useHydration as zn, StepTicket as zo, useDate as zr, NotificationsPluginOptions as zt };