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

package/dist/{index-B76iGRE3.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().
@@ -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
@@ -4479,6 +4944,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 +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.
@@ -5271,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'>;
@@ -5315,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 */
@@ -5364,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.
@@ -5386,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;
 }
@@ -5405,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 {
@@ -5747,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
@@ -6032,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;
@@ -6082,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;
@@ -6486,4 +7376,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 $, 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 };