@vuetify/v0 1.0.0-alpha.3 → 1.0.0-alpha.5

package/dist/{index-B76iGRE3.d.mts → index-CyUCELZC.d.mts}

@@ -1,12 +1,13 @@
-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 { a as RegistryEventName, c as RegistryTicketInput, o as RegistryOptions, r as RegistryEventCallback, s as RegistryTicket, t as RegistryContext } from "./index-C0ewabdY.mjs";
+import { _ as FilterMode } from "./adapter-BO75n0Cn.mjs";
+import { c as TokenTicket, i as TokenContext, o as TokenOptions, r as TokenCollection } from "./index-C_t6t0Z-.mjs";
+import { t as DateAdapter } from "./adapter-B6IrPwib.mjs";
+import { n as FeaturesAdapterFlags, t as FeaturesAdapter } from "./adapter-CspReV3g.mjs";
+import { t as LocaleAdapter } from "./adapter-DDJHLC8K.mjs";
+import { t as LoggerAdapter } from "./adapter-BEJXp-ie.mjs";
+import { n as StorageAdapter } from "./memory-D-JbdKXg.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 +1480,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 +1493,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 +1512,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;
@@ -1774,7 +1775,7 @@ interface PluginContextConfig<O, E> {
  *   createPluginContext('v0:logger', options => createLogger(options), {
  *     fallback: ns => createFallbackLogger(ns),
  *     setup: (context) => {
- *       if (__DEV__ && IN_BROWSER) (window as any).__v0Logger__ = context
+ *       if (__DEV__ && IN_BROWSER) (window as Window & { __v0Logger__?: typeof context }).__v0Logger__ = context
  *     },
  *   })
  * ```
@@ -2117,6 +2118,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().
@@ -2179,7 +2645,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. */
@@ -2533,7 +2999,119 @@ interface NumberFieldContext {
   /** Snap and optionally clamp the current value. */
   commit: () => void;
 }
-declare function createNumberField(options?: NumberFieldOptions): NumberFieldContext;
+declare function createNumberField(options?: NumberFieldOptions): NumberFieldContext;
+//#endregion
+//#region src/composables/createOtp/index.d.ts
+/**
+ * Pattern presets — string literals compile to internal RegExps; arbitrary
+ * RegExp values are applied per character.
+ *
+ * @example
+ * ```ts
+ * const otp = createOtp({ pattern: 'numeric' })
+ * const hex = createOtp({ pattern: /^[0-9a-fA-F]$/ })
+ * ```
+ */
+type OtpPattern = 'numeric' | 'alphanumeric' | 'alphabetic' | RegExp;
+/**
+ * Options accepted by `createOtp`.
+ *
+ * @example
+ * ```ts
+ * const otp = createOtp({
+ *   length: 6,
+ *   pattern: 'numeric',
+ *   disabled: false,
+ *   onComplete: async value => {
+ *     const ok = await verify(value)
+ *     return ok
+ *   },
+ * })
+ * ```
+ */
+interface OtpOptions extends Omit<InputOptions<string>, 'value' | 'error' | 'errorMessages'> {
+  /** Number of characters. @default 6 */
+  length?: MaybeRefOrGetter<number>;
+  /** Joined value source. @default shallowRef('') */
+  value?: Ref<string>;
+  /**
+   * Per-character pattern. String presets compile to internal RegExps;
+   * custom RegExp must match a single character.
+   * @default 'numeric'
+   */
+  pattern?: MaybeRefOrGetter<OtpPattern>;
+  /**
+   * Fire when the joined value first reaches `length`. Decisional —
+   * return / resolve `false` to reject (clears value, sets error).
+   * A rejected Promise is treated as `false` and logs a warning.
+   */
+  onComplete?: (value: string) => boolean | void | PromiseLike<boolean | void>;
+}
+/**
+ * Reactive context returned by `createOtp`. Consumers index into `value`
+ * for per-character rendering and call the mutation helpers to drive state.
+ *
+ * @example
+ * ```ts
+ * const otp = createOtp({ length: 6 })
+ *
+ * otp.write(0, '4')
+ * otp.distribute('12345', 1) // returns 5
+ * otp.isComplete.value  // true
+ * otp.clear()
+ * ```
+ */
+interface OtpContext {
+  /**
+   * The joined OTP string. Use the mutation helpers (`write`, `distribute`,
+   * `fill`, `clear`) to update. Writing through this ref directly is
+   * intentionally prevented to preserve pattern, length, and lock invariants.
+   */
+  value: Readonly<Ref<string>>;
+  /** Resolved character count from the `length` option. */
+  length: Readonly<Ref<number>>;
+  /**
+   * The underlying `createInput` context — exposes ARIA IDs, validation
+   * state, focus/touched, and the `validate` / `reset` methods.
+   *
+   * Note: `input.value` aliases `OtpContext.value` and is also readonly on
+   * the public surface. Use the mutation helpers (`write`, `distribute`,
+   * `fill`, `clear`) to update.
+   */
+  input: Omit<InputContext<string>, 'value'> & {
+    value: Readonly<Ref<string>>;
+  };
+  /** True when `value` reaches `length` and every character matches `pattern`. */
+  isComplete: Readonly<Ref<boolean>>;
+  /**
+   * True while an async `onComplete` is in flight. Mutation helpers no-op
+   * during this window; consumers can render a spinner against this ref.
+   */
+  isValidating: Readonly<Ref<boolean>>;
+  /**
+   * Write a single character at `index`. Empty string clears trailing
+   * characters from `index` onward. Out-of-range indices and characters
+   * rejected by `pattern` are ignored. No-ops while locked.
+   */
+  write: (index: number, char: string) => void;
+  /**
+   * Splice pattern-accepted characters from `text` into `value` starting
+   * at `index`. Returns the number of characters written. No-ops while
+   * locked or when no characters pass the pattern.
+   */
+  distribute: (text: string, index?: number) => number;
+  /** Clear `value` and rejection state. No-ops while locked. */
+  clear: () => void;
+  /**
+   * Replace `value` with pattern-accepted characters from `text`, truncated
+   * to `length`. Clears rejection state on deliberate empty input or any
+   * accepted characters. No-ops while locked.
+   */
+  fill: (text: string) => void;
+  /** Whether `char` is a single character matching the current `pattern`. */
+  accepts: (char: string) => boolean;
+}
+declare function createOtp(options?: OtpOptions): OtpContext;
 //#endregion
 //#region src/composables/createProgress/index.d.ts
 type ProgressTicketInput = ModelTicketInput<ShallowRef<number>>;
@@ -3989,6 +4567,91 @@ type MaybeElementRef = {
  */
 declare function toElement(target: MaybeElementRef): Element | undefined;
 //#endregion
+//#region src/composables/toHighlight/index.d.ts
+/**
+ * A `[start, end]` index pair where `end` is exclusive (matches
+ * `String.prototype.slice` convention).
+ *
+ * @example
+ * ```ts
+ * import type { MatchRange } from '@vuetify/v0'
+ *
+ * const ranges: MatchRange[] = [[0, 5], [12, 17]]
+ * ```
+ */
+type MatchRange = readonly [number, number];
+/**
+ * A contiguous chunk of source text, flagged as matched or unmatched.
+ *
+ * @example
+ * ```ts
+ * import type { HighlightChunk } from '@vuetify/v0'
+ *
+ * const chunk: HighlightChunk = { text: 'Hello', match: true }
+ * ```
+ */
+interface HighlightChunk {
+  text: string;
+  match: boolean;
+}
+/**
+ * Optional configuration for {@link toHighlight}.
+ *
+ * @example
+ * ```ts
+ * import { toHighlight } from '@vuetify/v0'
+ *
+ * const chunks = toHighlight('Hello World', 'WORLD', {
+ *   ignoreCase: true,
+ *   matchAll: true,
+ * })
+ * ```
+ */
+interface ToHighlightOptions {
+  /**
+   * Pre-computed `[start, end]` index pairs.
+   * When non-empty, takes priority over `query`. `matchAll` is ignored.
+   * Caller-supplied ranges are sorted and merged before chunking, so
+   * unsorted or overlapping input is handled gracefully.
+   */
+  matches?: MaybeRefOrGetter<readonly MatchRange[] | undefined>;
+  /**
+   * Highlight every occurrence (`true`) or only the first per term (`false`, default).
+   * Ignored when `matches` is provided.
+   */
+  matchAll?: MaybeRefOrGetter<boolean>;
+  /** Case-insensitive matching. Default `false`. */
+  ignoreCase?: MaybeRefOrGetter<boolean>;
+}
+/**
+ * Splits text into matched and unmatched chunks.
+ *
+ * Pure transformer — returns a plain array. Wrap the call in `computed()` for
+ * reactive recomputation.
+ *
+ * Priority: `options.matches` (when non-empty) → `query` → no-match fallback.
+ *
+ * @param text The source string to split.
+ * @param query One or more search terms. Empty strings are ignored. Case sensitivity controlled by `options.ignoreCase`.
+ * @param options Optional `matches`, `matchAll`, `ignoreCase`.
+ * @returns A `HighlightChunk[]` array.
+ *
+ * @see https://0.vuetifyjs.com/composables/transformers/to-highlight
+ *
+ * @example
+ * ```ts
+ * import { computed, shallowRef } from 'vue'
+ * import { toHighlight } from '@vuetify/v0'
+ *
+ * const query = shallowRef('World')
+ * const chunks = computed(() => toHighlight('Hello World', query))
+ *
+ * console.log(chunks.value)
+ * // [{ text: 'Hello ', match: false }, { text: 'World', match: true }]
+ * ```
+ */
+declare function toHighlight(text: MaybeRefOrGetter<string>, query?: MaybeRefOrGetter<string | string[] | undefined>, options?: ToHighlightOptions): HighlightChunk[];
+//#endregion
 //#region src/composables/toReactive/index.d.ts
 /**
  * Converts a `MaybeRef` to a `UnwrapNestedRefs`.
@@ -4222,8 +4885,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 +4915,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 +4940,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 +4961,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 +4990,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
@@ -4479,6 +5142,441 @@ interface UseDelayReturn {
  */
 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;
@@ -4605,7 +5703,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.
@@ -5271,6 +6369,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'>;
@@ -5315,22 +6421,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 */
@@ -5364,7 +6459,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.
@@ -5386,15 +6481,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;
 }
@@ -5405,7 +6497,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 {
@@ -5747,12 +6839,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
@@ -6032,7 +7124,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;
@@ -6082,11 +7174,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;
@@ -6486,4 +7574,4 @@ interface ToggleScopeControls {
  */
 declare function useToggleScope(source: WatchSource<boolean>, fn: (() => void) | ((controls: ToggleScopeControls) => void)): ToggleScopeControls;
 //#endregion
-export { RtlAdapter as $, PopoverReturn as $a, FormContextOptions as $i, createFeaturesContext as $n, ModelTicket as $o, createTimeline as $r, useMediaQuery as $t, createStorageContext as A, createPlugin as Aa, NumberFieldContext as Ai, UseIntersectionObserverReturn as An, useBreadcrumbs as Ao, createBreakpoints as Ar, createPermissionsPlugin as At, createStackContext as B, createComboboxContext as Ba, NestedContext as Bi, createHydrationPlugin as Bn, UseImageOptions as Bo, VirtualContext as Br, NotificationsContext as Bt, ThemeAdapter as C, createRulesPlugin as Ca, ProgressContextOptions as Ci, useLocale as Cn, BreadcrumbTicket as Co, UseClickOutsideReturn as Cr, PermissionContext as Ct, StorageOptions as D, Plugin as Da, createProgress as Di, IntersectionObserverEntry as Dn, BreadcrumbsOptions as Do, BreakpointsContextOptions as Dr, PermissionTicket as Dt, StorageContextOptions as E, isStandardSchema as Ea, ProgressTicketInput as Ei, useLazy as En, BreadcrumbsContextOptions as Eo, BreakpointsContext as Er, PermissionPluginOptions as Et, StackOptions as F, provideContext as Fa, createNumeric as Fi, HydrationOptions as Fn, SingleTicketInput as Fo, MaybeElementRef as Fr, NotificationInput as Ft, RtlOptions as G, ComboboxAdapterContext as Ga, NestedSelectionMode as Gi, useHotkey as Gn, SelectionOptions as Go, VirtualState as Gr, createNotificationsPlugin as Gt, useStack as H, ServerAdapter as Ha, NestedOpenMode as Hi, PlatformContext as Hn, useImage as Ho, VirtualDirection as Hr, NotificationsPluginOptions as Ht, StackPluginOptions as I, useContext as Ia, createNested as Ii, HydrationPluginOptions as In, createSingle as Io, toElement as Ir, NotificationSeverity as It, createRtlContext as J, VirtualFocusItem as Ja, InputContext as Ji, FeatureOptions as Jn, createSelection as Jo, useVirtual as Jr, ObservableNodeList as Jt, RtlPluginOptions as K, ComboboxAdapterInterface as Ka, NestedTicket as Ki, FeatureContext as Kn, SelectionTicket as Ko, createVirtual as Kr, useNotifications as Kt, StackTicket as L, ComboboxContext as La, createNestedContext as Li, createFallbackHydration as Ln, createSingleContext as Lo, toArray as Lr, NotificationTicket as Lt, useStorage as M, ContextKey as Ma, createNumberField as Mi, useIntersectionObserver as Mn, SingleContextOptions as Mo, createBreakpointsPlugin as Mr, Vuetify0PermissionAdapter as Mt, StackContext as N, CreateContextOptions as Na, NumericContext as Ni, HydrationContext as Nn, SingleOptions as No, useBreakpoints as Nr, PermissionAdapter as Nt, StoragePluginOptions as O, PluginContextConfig as Oa, createProgressContext as Oi, IntersectionObserverOptions as On, createBreadcrumbs as Oo, BreakpointsOptions as Or, createPermissions as Ot, StackContextOptions as P, createContext as Pa, NumericOptions as Pi, HydrationContextOptions as Pn, SingleTicket as Po, toReactive as Pr, PermissionAdapterInterface as Pt, Vuetify0RtlAdapter as Q, PopoverOptions as Qa, FormContext as Qi, createFeatures as Qn, ModelOptions as Qo, TimelineTicket as Qr, MediaQueryContext as Qt, StackTicketInput as R, ComboboxOptions as Ra, useNested as Ri, createHydration as Rn, useSingle as Ro, ScrollToOptions as Rr, NotificationsAdapterContext as Rt, Vuetify0ThemeOptions as S, createRulesFallback as Sa, ProgressContext as Si, createLocalePlugin as Sn, useGroup as So, UseClickOutsideOptions as Sr, usePresence as St, StorageContext as T, StandardSchemaV1 as Ta, ProgressTicket as Ti, LazyOptions as Tn, BreadcrumbsContext as To, BreakpointName as Tr, PermissionOptions as Tt, RtlContext as U, ClientAdapter as Ua, NestedOptions as Ui, UseHotkeyOptions as Un, SelectionContext as Uo, VirtualItem as Ur, createNotifications as Ut, createStackPlugin as V, useCombobox as Va, NestedContextOptions as Vi, useHydration as Vn, UseImageReturn as Vo, VirtualContextOptions as Vr, NotificationsOptions as Vt, RtlContextOptions as W, ClientAdapterOptions as Wa, NestedRegistration as Wi, UseHotkeyReturn as Wn, SelectionContextOptions as Wo, VirtualOptions as Wr, createNotificationsContext as Wt, createRtlPlugin as X, VirtualFocusReturn as Xa, InputState as Xi, FeatureTicket as Xn, useSelection as Xo, TimelineContextOptions as Xr, UseMutationObserverReturn as Xt, createRtlFallback as Y, VirtualFocusOptions as Ya, InputOptions as Yi, FeaturePluginOptions as Yn, createSelectionContext as Yo, TimelineContext as Yr, UseMutationObserverOptions as Yt, useRtl as Z, useVirtualFocus as Za, createInput as Zi, FeatureTicketInput as Zn, ModelContext as Zo, TimelineOptions as Zr, useMutationObserver as Zt, createThemePlugin as _, RulesContext as _a, QueueTicket as _i, LocaleTicket as _n, GroupOptions as _o, createDatePlugin as _r, ProxyModelTarget as _t, useTimer as a, FormValue as aa, createSlider as ai, LoggerOptions as an, StepTicketInput as ao, useEventListener as ar, ResizeObserverEntry as at, V0UnheadThemeOptions as b, createRules as ba, createQueueContext as bi, createLocaleContext as bn, createGroup as bo, ClickOutsideIgnoreTarget as br, UsePresenceOptions as bt, ThemeContext as c, useForm as ca, RatingItemDescriptor as ci, createLoggerContext as cn, useStep as co, UseDelayReturn as cr, UseResizeObserverReturn as ct, ThemePluginOptions as d, ValidationTicket as da, createRating as di, LogLevel as dn, OverflowOptions as do, DateContext as dr, UseRafReturn as dt, FormOptions as ea, createTimelineContext as ei, usePrefersContrast as en, usePopover as eo, createFeaturesPlugin as er, ModelTicketInput as es, RtlAdapterSetupContext as et, ThemeRecord as f, ValidationTicketInput as fa, createRatingContext as fi, LocaleContext as fn, createOverflow as fo, DateContextOptions as fr, useRaf as ft, createThemeContext as g, RuleInput as ga, QueueOptions as gi, LocaleRecord as gn, GroupContextOptions as go, createDateContext as gr, ProxyModelOptions as gt, createTheme as h, RuleAliases as ha, QueueContextOptions as hi, LocalePluginOptions as hn, GroupContext as ho, createDate as hr, useProxyRegistry as ht, TimerOptions as i, FormValidationRule as ia, SliderTicketInput as ii, LoggerContextOptions as in, StepTicket as io, useDocumentEventListener as ir, useRovingFocus as it, createStoragePlugin as j, createPluginContext as ja, NumberFieldOptions as ji, useElementIntersection as jn, SingleContext as jo, createBreakpointsContext as jr, usePermissions as jt, createStorage as k, PluginOptions as ka, useProgress as ki, UseElementIntersectionReturn as kn, createBreadcrumbsContext as ko, BreakpointsPluginOptions as kr, createPermissionsContext as kt, ThemeContextOptions as l, ValidationContext as la, RatingItemState as li, createLoggerPlugin as ln, OverflowContext as lo, UseDelayStartOptions as lr, useElementSize as lt, ThemeTicketInput as m, RuleAlias as ma, QueueContext as mi, LocaleOptions as mn, useOverflow as mo, DatePluginOptions as mr, ProxyRegistryOptions as mt, useToggleScope as n, FormTicketInput as na, SliderContext as ni, usePrefersReducedMotion as nn, StepContextOptions as no, CleanupFunction as nr, RovingFocusReturn as nt, Colors as o, createForm as oa, RatingContext as oi, LoggerPluginOptions as on, createStep as oo, useWindowEventListener as or, ResizeObserverOptions as ot, ThemeTicket as p, createValidation as pa, useRating as pi, LocaleContextOptions as pn, createOverflowContext as po, DateOptions as pr, ProxyRegistryContext as pt, createRtl as q, ComboboxAdapterResult as qa, NestedTicketInput as qi, FeatureContextOptions as qn, SelectionTicketInput as qo, createVirtualContext as qr, MutationObserverRecord as qt, TimerContext as r, FormValidationResult as ra, SliderOptions as ri, LoggerContext as rn, StepOptions as ro, EventHandler as rr, RovingItem as rt, ThemeColors as s, createFormContext as sa, RatingContextOptions as si, createLogger as sn, createStepContext as so, UseDelayOptions as sr, UseElementSizeReturn as st, ToggleScopeControls as t, FormTicket as ta, useTimeline as ti, usePrefersDark as tn, StepContext as to, useFeatures as tr, createModel as ts, RovingFocusOptions as tt, ThemeOptions as u, ValidationOptions as ua, RatingOptions as ui, useLogger as un, OverflowContextOptions as uo, useDelay as ur, useResizeObserver as ut, useTheme as v, RulesContextOptions as va, QueueTicketInput as vi, LocaleTicketInput as vn, GroupTicket as vo, useDate as vr, useProxyModel as vt, ThemeAdapterInterface as w, useRules as wa, ProgressOptions as wi, LazyContext as wn, BreadcrumbTicketInput as wo, useClickOutside as wr, PermissionContextOptions as wt, V0StyleSheetThemeAdapter as x, createRulesContext as xa, useQueue as xi, createLocaleFallback as xn, createGroupContext as xo, ClickOutsideTarget as xr, UsePresenceReturn as xt, V0UnheadThemeAdapter as y, RulesOptions as ya, createQueue as yi, createLocale as yn, GroupTicketInput as yo, ClickOutsideElement as yr, PresenceState as yt, createStack as z, createCombobox as za, NestedActiveMode as zi, createHydrationContext as zn, ImageStatus as zo, VirtualAnchor as zr, NotificationsAdapterInterface as zt };
+export { RtlAdapterSetupContext as $, ValidationOptions as $a, createProgressContext as $i, useFeatures as $n, OverflowContextOptions as $o, createBreakpointsPlugin as $r, usePrefersDark as $t, createStoragePlugin as A, SortableContext as Aa, createSlider as Ai, useIntersectionObserver as An, useCombobox as Ao, UseDelayStartOptions as Ar, UseImageReturn as As, usePermissions as At, createStackPlugin as B, createInput as Ba, QueueContextOptions as Bi, PlatformContext as Bn, useVirtualFocus as Bo, ClickOutsideElement as Br, ModelContext as Bs, createNotifications as Bt, ThemeAdapter as C, KanbanColumnTicket as Ca, TimelineTicket as Ci, LazyOptions as Cn, createContext as Co, PointerAdapter as Cr, SingleTicket as Cs, PermissionContextOptions as Ct, StoragePluginOptions as D, KanbanOptions as Da, SliderContext as Di, UseElementIntersectionReturn as Dn, ComboboxOptions as Do, DragDropAdapterEmit as Dr, useSingle as Ds, createPermissions as Dt, StorageOptions as E, KanbanEventListener as Ea, useTimeline as Ei, IntersectionObserverOptions as En, ComboboxContext as Eo, DragDropAdapterContext as Er, createSingleContext as Es, PermissionTicket as Et, StackPluginOptions as F, SortableTicketInput as Fa, RatingOptions as Fi, createFallbackHydration as Fn, ComboboxAdapterContext as Fo, DatePluginOptions as Fr, SelectionTicket as Fs, NotificationTicket as Ft, RtlPluginOptions as G, FormTicketInput as Ga, createQueueContext as Gi, FeatureContextOptions as Gn, StepContextOptions as Go, useClickOutside as Gr, MutationObserverRecord as Gt, RtlContext as H, FormContextOptions as Ha, QueueTicket as Hi, UseHotkeyReturn as Hn, PopoverReturn as Ho, ClickOutsideTarget as Hr, ModelTicket as Hs, createNotificationsPlugin as Ht, StackTicket as I, createSortable as Ia, createRating as Ii, createHydration as In, ComboboxAdapterResult as Io, createDate as Ir, SelectionTicketInput as Is, NotificationsAdapterContext as It, createRtlFallback as J, FormValue as Ja, ProgressContextOptions as Ji, FeatureTicket as Jn, StepTicketInput as Jo, BreakpointsContextOptions as Jr, UseMutationObserverReturn as Jt, createRtl as K, FormValidationResult as Ka, useQueue as Ki, FeatureOptions as Kn, StepOptions as Ko, BreakpointName as Kr, ObservableNodeList as Kt, StackTicketInput as L, InputContext as La, createRatingContext as Li, createHydrationContext as Ln, VirtualFocusItem as Lo, createDateContext as Lr, createSelection as Ls, NotificationsContext as Lt, StackContext as M, SortableMovePayload as Ma, RatingContextOptions as Mi, HydrationContextOptions as Mn, ClientComboboxAdapter as Mo, DateContext as Mr, SelectionContext as Ms, PermissionsAdapter as Mt, StackContextOptions as N, SortableOptions as Na, RatingItemDescriptor as Ni, HydrationOptions as Nn, ClientComboboxAdapterOptions as No, DateContextOptions as Nr, SelectionContextOptions as Ns, NotificationInput as Nt, createStorage as O, KanbanTransferPayload as Oa, SliderOptions as Oi, UseIntersectionObserverReturn as On, createCombobox as Oo, UseDelayOptions as Or, ImageStatus as Os, createPermissionsContext as Ot, StackOptions as P, SortableTicket as Pa, RatingItemState as Pi, HydrationPluginOptions as Pn, ComboboxAdapter as Po, DateOptions as Pr, SelectionOptions as Ps, NotificationSeverity as Pt, RtlAdapter as Q, ValidationContext as Qa, createProgress as Qi, createFeaturesPlugin as Qn, OverflowContext as Qo, createBreakpointsContext as Qr, usePrefersContrast as Qt, createStack as R, InputOptions as Ra, useRating as Ri, createHydrationPlugin as Rn, VirtualFocusOptions as Ro, createDatePlugin as Rr, createSelectionContext as Rs, NotificationsOptions as Rt, Vuetify0ThemeOptions as S, NestedTicketInput as Sa, TimelineOptions as Si, LazyContext as Sn, CreateContextOptions as So, KeyboardAdapterOptions as Sr, SingleOptions as Ss, PermissionContext as St, StorageContextOptions as T, KanbanContext as Ta, createTimelineContext as Ti, IntersectionObserverEntry as Tn, useContext as To, DragDropAdapter as Tr, createSingle as Ts, PermissionPluginOptions as Tt, RtlContextOptions as U, FormOptions as Ua, QueueTicketInput as Ui, useHotkey as Un, usePopover as Uo, UseClickOutsideOptions as Ur, ModelTicketInput as Us, useNotifications as Ut, useStack as V, FormContext as Va, QueueOptions as Vi, UseHotkeyOptions as Vn, PopoverOptions as Vo, ClickOutsideIgnoreTarget as Vr, ModelOptions as Vs, createNotificationsContext as Vt, RtlOptions as W, FormTicket as Wa, createQueue as Wi, FeatureContext as Wn, StepContext as Wo, UseClickOutsideReturn as Wr, createModel as Ws, NotificationsAdapter as Wt, useRtl as X, createFormContext as Xa, ProgressTicket as Xi, createFeatures as Xn, createStepContext as Xo, BreakpointsPluginOptions as Xr, MediaQueryContext as Xt, createRtlPlugin as Y, createForm as Ya, ProgressOptions as Yi, FeatureTicketInput as Yn, createStep as Yo, BreakpointsOptions as Yr, useMutationObserver as Yt, V0RtlAdapter as Z, useForm as Za, ProgressTicketInput as Zi, createFeaturesContext as Zn, useStep as Zo, createBreakpoints as Zr, useMediaQuery as Zt, createThemePlugin as _, NestedOpenMode as _a, createVirtual as _i, createLocale as _n, PluginContextConfig as _o, DropZoneTicketInput as _r, createBreadcrumbs as _s, useProxyModel as _t, useTimer as a, NumberFieldContext as aa, toHighlight as ai, createLogger as an, RuleInput as ao, ActiveDrag as ar, GroupContextOptions as as, ResizeObserverOptions as at, V0UnheadThemeOptions as b, NestedSelectionMode as ba, TimelineContext as bi, createLocalePlugin as bn, createPluginContext as bo, useDragDrop as br, SingleContext as bs, UsePresenceReturn as bt, ThemeContext as c, NumericContext as ca, toArray as ci, useLogger as cn, RulesOptions as co, DragDropPlugin as cr, GroupTicketInput as cs, useElementSize as ct, ThemePluginOptions as d, createNested as da, VirtualContext as di, LocaleContextOptions as dn, createRulesFallback as do, DraggableTicket as dr, useGroup as ds, useRaf as dt, useProgress as ea, useBreakpoints as ei, usePrefersReducedMotion as en, ValidationTicket as eo, CleanupFunction as er, OverflowOptions as es, RovingFocusOptions as et, ThemeRecord as f, createNestedContext as fa, VirtualContextOptions as fi, LocaleOptions as fn, createRulesPlugin as fo, DraggableTicketInput as fr, BreadcrumbTicket as fs, ProxyRegistryContext as ft, createThemeContext as g, NestedContextOptions as ga, VirtualState as gi, LocaleTicketInput as gn, Plugin as go, DropZoneTicket as gr, BreadcrumbsOptions as gs, ProxyModelTarget as gt, createTheme as h, NestedContext as ha, VirtualOptions as hi, LocaleTicket as hn, isStandardSchema as ho, DropPosition as hr, BreadcrumbsContextOptions as hs, ProxyModelOptions as ht, TimerOptions as i, createOtp as ia, ToHighlightOptions as ii, LoggerPluginOptions as in, RuleAliases as io, useWindowEventListener as ir, GroupContext as is, ResizeObserverEntry as it, useStorage as j, SortableEventListener as ja, RatingContext as ji, HydrationContext as jn, ServerComboboxAdapter as jo, useDelay as jr, useImage as js, V0PermissionsAdapter as jt, createStorageContext as k, createKanban as ka, SliderTicketInput as ki, useElementIntersection as kn, createComboboxContext as ko, UseDelayReturn as kr, UseImageOptions as ks, createPermissionsPlugin as kt, ThemeContextOptions as l, NumericOptions as la, ScrollToOptions as li, LogLevel as ln, createRules as lo, DragType as lr, createGroup as ls, useResizeObserver as lt, ThemeTicketInput as m, NestedActiveMode as ma, VirtualItem as mi, LocaleRecord as mn, StandardSchemaV1 as mo, DropIndicator as mr, BreadcrumbsContext as ms, useProxyRegistry as mt, useToggleScope as n, OtpOptions as na, HighlightChunk as ni, LoggerContextOptions as nn, createValidation as no, useDocumentEventListener as nr, createOverflowContext as ns, RovingItem as nt, Colors as o, NumberFieldOptions as oa, MaybeElementRef as oi, createLoggerContext as on, RulesContext as oo, DragDropContext as or, GroupOptions as os, UseElementSizeReturn as ot, ThemeTicket as p, useNested as pa, VirtualDirection as pi, LocalePluginOptions as pn, useRules as po, DraggablesContext as pr, BreadcrumbTicketInput as ps, ProxyRegistryOptions as pt, createRtlContext as q, FormValidationRule as qa, ProgressContext as qi, FeaturePluginOptions as qn, StepTicket as qo, BreakpointsContext as qr, UseMutationObserverOptions as qt, TimerContext as r, OtpPattern as ra, MatchRange as ri, LoggerOptions as rn, RuleAlias as ro, useEventListener as rr, useOverflow as rs, useRovingFocus as rt, ThemeColors as s, createNumberField as sa, toElement as si, createLoggerPlugin as sn, RulesContextOptions as so, DragDropOptions as sr, GroupTicket as ss, UseResizeObserverReturn as st, ToggleScopeControls as t, OtpContext as ta, toReactive as ti, LoggerContext as tn, ValidationTicketInput as to, EventHandler as tr, createOverflow as ts, RovingFocusReturn as tt, ThemeOptions as u, createNumeric as ua, VirtualAnchor as ui, LocaleContext as un, createRulesContext as uo, DragVia as ur, createGroupContext as us, UseRafReturn as ut, useTheme as v, NestedOptions as va, createVirtualContext as vi, createLocaleContext as vn, PluginOptions as vo, Orientation as vr, createBreadcrumbsContext as vs, PresenceState as vt, StorageContext as w, KanbanColumnTicketInput as wa, createTimeline as wi, useLazy as wn, provideContext as wo, PointerAdapterOptions as wr, SingleTicketInput as ws, PermissionOptions as wt, V0StyleSheetThemeAdapter as x, NestedTicket as xa, TimelineContextOptions as xi, useLocale as xn, ContextKey as xo, KeyboardAdapter as xr, SingleContextOptions as xs, usePresence as xt, V0UnheadThemeAdapter as y, NestedRegistration as ya, useVirtual as yi, createLocaleFallback as yn, createPlugin as yo, ZonesContext as yr, useBreadcrumbs as ys, UsePresenceOptions as yt, createStackContext as z, InputState as za, QueueContext as zi, useHydration as zn, VirtualFocusReturn as zo, useDate as zr, useSelection as zs, NotificationsPluginOptions as zt };